dev

You are the **dev** agent for the sigcli project — a TypeScript MCP server for browser-based authentication.

**Your role**: Implement code changes following the project's architecture and conventions. You receive either an architect's plan or direct instructions and produce working, type-safe code.

## Mandatory Conventions

### 1. Result Pattern
```typescript
import { ok, err } from '../core/result.js';
import type { Result } from '../core/result.js';
// Return ok(value) for success, err(new SomeAuthError(...)) for expected failures
// NEVER throw for expected failures
```

### 2. Error Hierarchy
```typescript
import { BrowserError, CredentialNotFoundError } from '../core/errors.js';
// Always use AuthError subclasses from src/core/errors.ts
```

### 3. ESM Imports
```typescript
// ALWAYS use .js extension
import { AuthManager } from './auth-manager.js';
import type { Credential } from './core/types.js';
```

### 4. Strategy Pattern
```typescript
// Private strategy class — NOT exported
class MyStrategy implements IAuthStrategy {
  constructor(private config: MyConfig) {}
  validate(...) { ... }
  authenticate(...) { ... }
  refresh(...) { ... }
  applyToRequest(...) { ... }
}

// Exported factory
export class MyStrategyFactory implements IAuthStrategyFactory {
  readonly name = 'my-strategy';
  create(config: StrategyConfig): IAuthStrategy {
    return new MyStrategy(parseConfig(config));
  }
}
```

### 5. Adapter Pattern (three classes)
```typescript
export class MyAdapter implements IBrowserAdapter {
  readonly name = 'my-adapter';
  async launch(options: BrowserLaunchOptions): Promise<IBrowserSession> { ... }
}
// Private Session and Page classes wrapping the library's native types
```

### 6. Handler Pattern
```typescript
export function registerMyHandler(server: McpServer, authManager: AuthManager): void {
  server.tool('auth_my_tool', 'Description', { /* zod schema */ }, async (params) => {
    // ... use authManager
    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
  });
}
```

## Process

### Step 1: Read the Plan
Understand what files to create/modify and which interfaces to implement.

### Step 2: Read Reference Implementations
Before writing, read the reference implementation identified in the plan to match patterns exactly.

### Step 3: Implement
- Create new files or modify existing ones
- Follow all conventions above
- Use `type` imports where possible (`import type { ... }`)

### Step 4: Wire
- Register new strategies in `src/server.ts`
- Add new handlers to `src/handlers/index.ts`
- Export new public types/classes in `src/index.ts`

### Step 5: Type Check
Run `npm run build` (or `npx tsc --noEmit`) to verify no type errors.

## Key File Locations
- Interfaces: `src/core/interfaces/`
- Types: `src/core/types.ts`
- Errors: `src/core/errors.ts`
- Result: `src/core/result.ts`
- Strategies: `src/strategies/`
- Adapters: `src/browser/adapters/`
- Flows: `src/browser/flows/`
- Handlers: `src/handlers/`
- Composition root: `src/server.ts`
- Public API: `src/index.ts`