ZacharyZhang-NY
e74dafcd36
Three independently ugly bugs that all fed the same log flood:
* Electron's `WebFrameMain.send` writes every "Render frame was disposed"
to stderr via `console.error`. When the worker fans a second
agent-event past a reloading renderer, we produced thousands of
identical lines and stalled the main loop on stderr I/O. Added a
`mainFrame.detached` guard so the send is short-circuited before
Electron's own catch block fires, and installed a targeted filter in
`suppress-warnings.ts` (now actually imported from the entry point)
so the specific `console.error("Error sending from webFrameMain:"…)`
noise never reaches the terminal. Any other payload still surfaces.
* `dispatchAgentMessage` accepted the human-reader sentinel as a wake
target when an agent replied to `__board__` — `wakeAgentIfPossible`
then called `db.getAgent("__board__")`, threw, and the dispatcher
kept repeating on every send. Strip `HUMAN_SENDER_ID` at
`resolveMessageWakeTargets`, and keep a defense-in-depth guard in the
heartbeat so a stray caller (future automation fan-out) cannot
reintroduce the crash.
* Pi's skills loader rejects any SKILL.md whose frontmatter `name`
diverges from its parent directory. The four bundled `my-writing-style`
copies declared `name: writing-style-skill`, so every install emitted
a warning and dropped the skill. They also lived as orphan gitlinks
(mode 160000 without .gitmodules), and the global `*.md` gitignore
hid every other SKILL.md from version control. Fixed the frontmatter
to match the dir, converted the dangling submodules to plain trees,
and allowlisted `builtin-skills/**/*.md` so a fresh clone carries the
catalogue instead of silently losing it.
99 lines
2.7 KiB
Markdown
99 lines
2.7 KiB
Markdown
---
|
|
title: Define Input and Output Ports for Use Cases
|
|
impact: HIGH
|
|
impactDescription: decouples use cases from delivery mechanism
|
|
tags: usecase, ports, input, output, boundaries
|
|
---
|
|
|
|
## Define Input and Output Ports for Use Cases
|
|
|
|
Use cases should define their own input (request) and output (response) data structures. These ports isolate the use case from the delivery mechanism (HTTP, CLI, queue).
|
|
|
|
**Incorrect (use case coupled to HTTP):**
|
|
|
|
```csharp
|
|
public class RegisterUserUseCase
|
|
{
|
|
public IActionResult Execute(HttpRequest request) // Coupled to ASP.NET
|
|
{
|
|
var email = request.Form["email"];
|
|
var password = request.Form["password"];
|
|
|
|
if (string.IsNullOrEmpty(email))
|
|
return new BadRequestResult(); // HTTP-specific response
|
|
|
|
var user = new User(email, password);
|
|
_repository.Save(user);
|
|
|
|
return new OkObjectResult(new { id = user.Id }); // JSON response
|
|
}
|
|
}
|
|
```
|
|
|
|
**Correct (use case with defined ports):**
|
|
|
|
```csharp
|
|
// application/ports/input/RegisterUserCommand.cs
|
|
public record RegisterUserCommand(
|
|
string Email,
|
|
string Password,
|
|
string Name
|
|
);
|
|
|
|
// application/ports/output/RegisterUserResult.cs
|
|
public record RegisterUserResult(
|
|
string UserId,
|
|
string Email,
|
|
DateTime CreatedAt
|
|
);
|
|
|
|
// application/usecases/RegisterUserUseCase.cs
|
|
public class RegisterUserUseCase
|
|
{
|
|
private readonly IUserRepository _repository;
|
|
private readonly IPasswordHasher _hasher;
|
|
|
|
public RegisterUserResult Execute(RegisterUserCommand command)
|
|
{
|
|
if (string.IsNullOrEmpty(command.Email))
|
|
throw new ValidationException("Email required");
|
|
|
|
var hashedPassword = _hasher.Hash(command.Password);
|
|
var user = new User(command.Email, hashedPassword, command.Name);
|
|
_repository.Save(user);
|
|
|
|
return new RegisterUserResult(
|
|
user.Id.Value,
|
|
user.Email.Value,
|
|
user.CreatedAt
|
|
);
|
|
}
|
|
}
|
|
|
|
// interface_adapters/controllers/UserController.cs
|
|
[ApiController]
|
|
public class UserController : ControllerBase
|
|
{
|
|
[HttpPost]
|
|
public IActionResult Register([FromBody] RegisterRequest request)
|
|
{
|
|
var command = new RegisterUserCommand(
|
|
request.Email,
|
|
request.Password,
|
|
request.Name
|
|
);
|
|
|
|
var result = _useCase.Execute(command);
|
|
|
|
return Ok(new { userId = result.UserId });
|
|
}
|
|
}
|
|
```
|
|
|
|
**Benefits:**
|
|
- Same use case callable from HTTP, CLI, message queue, tests
|
|
- Request/response format changes don't affect use case
|
|
- Use case testable without HTTP infrastructure
|
|
|
|
Reference: [Clean Architecture - Input/Output Ports](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
|