@adhdev/daemon-core 0.8.34 → 0.8.35

package/src/commands/router.d.ts

@@ -0,0 +1,98 @@
+/**
+ * DaemonCommandRouter — Unified command routing for daemon-level commands
+ *
+ * Unified command routing for daemon-level commands.
+ *
+ * Routing flow:
+ *   1. Daemon-level commands (launch_ide, stop_ide, restart_ide, etc.) → handled here
+ *   2. CLI/ACP commands → delegated to cliManager
+ *   3. Everything else → delegated to commandHandler.handle()
+ */
+import { DaemonCdpManager } from '../cdp/manager.js';
+import { DaemonCommandHandler } from './handler.js';
+import { DaemonCliManager } from './cli-manager.js';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { SessionRegistry } from '../sessions/registry.js';
+export interface SessionHostControlPlane {
+    getDiagnostics(payload?: {
+        includeSessions?: boolean;
+        limit?: number;
+    }): Promise<any>;
+    listSessions(): Promise<any[]>;
+    stopSession(sessionId: string): Promise<any>;
+    resumeSession(sessionId: string): Promise<any>;
+    restartSession(sessionId: string): Promise<any>;
+    sendSignal(sessionId: string, signal: string): Promise<any>;
+    forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    pruneDuplicateSessions(payload?: {
+        providerType?: string;
+        workspace?: string;
+        dryRun?: boolean;
+    }): Promise<any>;
+    acquireWrite(payload: {
+        sessionId: string;
+        clientId: string;
+        ownerType: 'agent' | 'user';
+        force?: boolean;
+    }): Promise<any>;
+    releaseWrite(payload: {
+        sessionId: string;
+        clientId: string;
+    }): Promise<any>;
+}
+export interface CommandRouterDeps {
+    commandHandler: DaemonCommandHandler;
+    cliManager: DaemonCliManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    /** Reference to detected IDEs array (mutable — router updates it) */
+    detectedIdes: {
+        value: any[];
+    };
+    sessionRegistry: SessionRegistry;
+    /** Callback for CDP manager creation after launch_ide */
+    onCdpManagerCreated?: (ideType: string, manager: DaemonCdpManager) => void;
+    /** Callback after IDE connected (e.g., startAgentStreamPolling) */
+    onIdeConnected?: () => void;
+    /** Callback after status change (stop_ide, restart) */
+    onStatusChange?: () => void;
+    /** Callback after chat-related commands */
+    onPostChatCommand?: () => void;
+    /** Get a connected CDP manager (for agent stream reset check) */
+    getCdpLogFn?: (ideType: string) => (msg: string) => void;
+    /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
+    packageName?: string;
+    /** Session host control plane */
+    sessionHostControl?: SessionHostControlPlane | null;
+}
+export interface CommandRouterResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export declare class DaemonCommandRouter {
+    private deps;
+    constructor(deps: CommandRouterDeps);
+    /**
+     * Unified command routing.
+     * Returns result for all commands:
+     *   1. Daemon-level commands (launch_ide, stop_ide, etc.)
+     *   2. CLI commands (launch_cli, stop_cli, agent_command)
+     *   3. DaemonCommandHandler delegation (CDP/agent-stream/file commands)
+     *
+     * @param cmd Command name
+     * @param args Command arguments
+     * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
+     */
+    execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
+    /**
+     * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
+     * Returns null if not handled at this level → caller delegates to CommandHandler.
+     */
+    private executeDaemonCommand;
+    /**
+     * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
+     */
+    private stopIde;
+}

package/src/commands/stream-commands.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stream Commands — Agent Stream, PTY I/O, Provider Settings,
+ *                   IDE Extension Settings, Extension Script Execution
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handlePtyInput(h: CommandHelpers, args: any): CommandResult;
+export declare function handlePtyResize(h: CommandHelpers, args: any): CommandResult;
+export declare function handleGetProviderSettings(h: CommandHelpers, args: any): CommandResult;
+export declare function handleSetProviderSetting(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleExtensionScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult>;
+export declare function handleProviderScript(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandResult;
+export declare function handleSetIdeExtension(h: CommandHelpers, args: any): CommandResult;

package/src/commands/upgrade-helper.d.ts

@@ -0,0 +1,10 @@
+export interface DaemonUpgradeHelperPayload {
+    packageName: string;
+    targetVersion: string;
+    parentPid: number;
+    restartArgv: string[];
+    cwd?: string;
+    sessionHostAppName?: string;
+}
+export declare function spawnDetachedDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): void;
+export declare function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean>;

package/src/commands/workspace-commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * workspace_* commands — list/add/remove/default (config.json)
+ */
+export type WorkspaceCommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+export declare function handleWorkspaceList(): WorkspaceCommandResult;
+export declare function handleWorkspaceAdd(args: any): WorkspaceCommandResult;
+export declare function handleWorkspaceRemove(args: any): WorkspaceCommandResult;
+export declare function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult;

package/src/config/chat-history.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Chat History Persistence — Persist completed chat messages to local disk
+ *
+ * Design:
+ * - ~/.adhdev/history/{agentType}/YYYY-MM-DD.jsonl
+ * - JSONL format (one line = one message, append-friendly)
+ * - Track only new messages (hash comparison with previous)
+ * - Auto-rotation (delete files older than 30 days)
+ * - Async/non-blocking (no impact on chat collection)
+ */
+interface HistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    kind?: string;
+    senderName?: string;
+    agent: string;
+    instanceId?: string;
+    historySessionId?: string;
+    sessionTitle?: string;
+}
+export interface SavedHistorySessionSummary {
+    historySessionId: string;
+    sessionTitle?: string;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    preview?: string;
+}
+export declare class ChatHistoryWriter {
+    /** Last seen message count per agent (deduplication) */
+    private lastSeenCounts;
+    /** Last seen message hash per agent (deduplication) */
+    private lastSeenHashes;
+    /** Last appended normalized message signature per agent/session */
+    private lastSeenSignatures;
+    /** Last appended normalized non-system turn signature per agent/session */
+    private lastSeenTurnSignatures;
+    private rotated;
+    /**
+    * Append new messages to history
+    *
+    * @param agentType agent type (e.g. 'antigravity', 'cursor')
+    * @param messages Message array received from readChat
+    * @param sessionTitle Current session title
+    * @param instanceId IDE instance UUID (distinguishes windows of the same agent)
+    */
+    appendNewMessages(agentType: string, messages: Array<{
+        role: string;
+        content: string;
+        receivedAt?: number;
+        kind?: string;
+        senderName?: string;
+        historyDedupKey?: string;
+    }>, sessionTitle?: string, instanceId?: string, historySessionId?: string): void;
+    seedSessionHistory(agentType: string, messages?: Array<{
+        role: string;
+        content: string;
+        receivedAt?: number;
+        kind?: string;
+        historyDedupKey?: string;
+    }>, historySessionId?: string, instanceId?: string): void;
+    appendSystemMarker(agentType: string, content: string, options?: {
+        sessionTitle?: string;
+        instanceId?: string;
+        historySessionId?: string;
+        dedupKey?: string;
+        receivedAt?: number;
+        senderName?: string;
+    }): void;
+    promoteHistorySession(agentType: string, previousHistorySessionId: string, nextHistorySessionId: string): void;
+    compactHistorySession(agentType: string, historySessionId: string): void;
+    /** Called when agent session is explicitly changed */
+    onSessionChange(agentType: string): void;
+    /** Delete history files older than 30 days */
+    private rotateOldFiles;
+    /** Allow only filename-safe characters */
+    private sanitize;
+}
+/**
+ * Read history (static — called from P2P commands)
+ *
+ * Read JSONL files in reverse order, returning most recent messages first.
+ * When instanceId is specified, reads only that instance file.
+ * Offset/limit-based paging.
+ */
+export declare function readChatHistory(agentType: string, offset?: number, limit?: number, historySessionId?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+};
+export declare function listSavedHistorySessions(agentType: string, options?: {
+    offset?: number;
+    limit?: number;
+}): {
+    sessions: SavedHistorySessionSummary[];
+    hasMore: boolean;
+};
+export {};

package/src/config/config.d.ts

@@ -29,6 +29,15 @@ export interface ADHDevConfig {
      */
     machineId?: string;
     machineSecret?: string | null;
+    /**
+     * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
+     * `POST /cli/complete`. This remains useful for account-side machine actions
+     * that target the registered machine row directly (for example cloud rename).
+     *
+     * Machine auth itself uses `machineSecret` (adm_) and no longer falls back
+     * to `registeredMachineId`.
+     */
+    registeredMachineId?: string;
     providerSettings: Record<string, Record<string, any>>;
     ideSettings: Record<string, {
         extensions?: Record<string, {
@@ -37,6 +46,11 @@ export interface ADHDevConfig {
     }>;
     disableUpstream?: boolean;
     providerDir?: string;
+    /**
+     * Browser terminal sizing behavior for dashboard CLI panes.
+     * Default `measured` keeps terminal size daemon-authoritative.
+     * `fit` opt-in restores xterm fit-based sizing for advanced users.
+     */
     terminalSizingMode?: 'measured' | 'fit';
 }
 export declare function generateMachineId(): string;

package/src/config/recent-activity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Unified recent activity — launcher-facing "pick up where you launched".
+ *
+ * Unlike live session state, this is launch oriented:
+ * - one normalized row shape for IDE / CLI / ACP
+ * - deduped by provider session when available, else by kind + providerType + workspace
+ * - used only for quick-launch shortcuts
+ */
+import type { DaemonState } from './state-store.js';
+export interface RecentActivityEntry {
+    id: string;
+    kind: 'ide' | 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    providerSessionId?: string;
+    workspace?: string | null;
+    currentModel?: string;
+    title?: string;
+    lastUsedAt: number;
+}
+export declare function buildRecentActivityKey(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace'>): string;
+export declare function buildRecentActivityKeyForEntry(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace' | 'providerSessionId'>): string;
+export declare function appendRecentActivity(state: DaemonState, entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & {
+    lastUsedAt?: number;
+}): DaemonState;
+export declare function getRecentActivity(state: DaemonState, limit?: number): RecentActivityEntry[];
+export declare function getSessionSeenAt(state: DaemonState, sessionId: string): number;
+export declare function getSessionSeenMarker(state: DaemonState, sessionId: string): string;
+export declare function markSessionSeen(state: DaemonState, sessionId: string, seenAt?: number, completionMarker?: string | null): DaemonState;

package/src/config/saved-sessions.d.ts

@@ -0,0 +1,22 @@
+import type { DaemonState } from './state-store.js';
+export interface SavedProviderSessionEntry {
+    id: string;
+    kind: 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    providerSessionId: string;
+    workspace?: string | null;
+    currentModel?: string;
+    title?: string;
+    createdAt: number;
+    lastUsedAt: number;
+}
+export declare function buildSavedProviderSessionKey(providerSessionId: string): string;
+export declare function upsertSavedProviderSession(state: DaemonState, entry: Omit<SavedProviderSessionEntry, 'id' | 'createdAt' | 'lastUsedAt'> & {
+    createdAt?: number;
+    lastUsedAt?: number;
+}): DaemonState;
+export declare function getSavedProviderSessions(state: DaemonState, filters?: {
+    providerType?: string;
+    kind?: SavedProviderSessionEntry['kind'];
+}): SavedProviderSessionEntry[];

package/src/config/state-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ADHDev State Store — Runtime state persistence
+ *
+ * Separates volatile runtime state (sessions, activity, read markers)
+ * from static configuration (config.json).
+ *
+ * State is stored in ~/.adhdev/state.json
+ */
+import type { RecentActivityEntry } from './recent-activity.js';
+import type { SavedProviderSessionEntry } from './saved-sessions.js';
+export interface DaemonState {
+    /** Unified recent activity across IDE / CLI / ACP launch flows */
+    recentActivity: RecentActivityEntry[];
+    /** Persistent resume-capable provider sessions keyed by providerSessionId */
+    savedProviderSessions: SavedProviderSessionEntry[];
+    /** Last seen timestamps for live sessions, keyed by sessionId */
+    sessionReads: Record<string, number>;
+    /** Last seen completion marker for live sessions, keyed by sessionId */
+    sessionReadMarkers: Record<string, string>;
+}
+/**
+ * Load runtime state from disk
+ */
+export declare function loadState(): DaemonState;
+/**
+ * Save runtime state to disk
+ */
+export declare function saveState(state: DaemonState): void;
+/**
+ * Reset runtime state
+ */
+export declare function resetState(): void;

package/src/config/workspaces.d.ts

@@ -17,7 +17,6 @@ export declare function validateWorkspacePath(absPath: string): {
 };
 /** Default workspace label from path */
 export declare function defaultWorkspaceLabel(absPath: string): string;
-
 export declare function getDefaultWorkspacePath(config: ADHDevConfig): string | null;
 export declare function getWorkspaceState(config: ADHDevConfig): {
     workspaces: WorkspaceEntry[];

package/src/daemon/dev-auto-implement.d.ts

@@ -0,0 +1,43 @@
+/**
+ * DevServer — Auto-Implement Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ * Contains prompt builders (IDE + CLI), agent spawn logic,
+ * SSE streaming, and provider directory resolution for auto-implement.
+ */
+import type * as http from 'http';
+import type { DevServerContext, ProviderCategory } from './dev-server-types.js';
+type CliExerciseVerification = {
+    request?: Record<string, any>;
+    mustContainAny?: string[];
+    mustNotContainAny?: string[];
+    mustMatchAny?: string[];
+    mustNotMatchAny?: string[];
+    lastAssistantMustContainAny?: string[];
+    lastAssistantMustNotContainAny?: string[];
+    lastAssistantMustMatchAny?: string[];
+    lastAssistantMustNotMatchAny?: string[];
+    inspectFields?: string[];
+    description?: string;
+    focusAreas?: string[];
+    fixtureName?: string;
+    fixtureNames?: string[];
+};
+export declare function getDefaultAutoImplReference(ctx: DevServerContext, category: string, type: string): string;
+export declare function resolveAutoImplReference(ctx: DevServerContext, category: string, requestedReference: string | undefined, targetType: string): string | null;
+export declare function getLatestScriptVersionDir(scriptsDir: string): string | null;
+export declare function resolveAutoImplWritableProviderDir(ctx: DevServerContext, category: ProviderCategory, type: string, requestedDir?: string): {
+    dir: string | null;
+    reason?: string;
+};
+export declare function loadAutoImplReferenceScripts(ctx: DevServerContext, referenceType: string | null): Record<string, string>;
+export declare function handleAutoImplement(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function buildAutoImplPrompt(ctx: DevServerContext, type: string, provider: any, providerDir: string, functions: string[], domContext: any, referenceScripts: Record<string, string>, userComment?: string, referenceType?: string | null, verification?: CliExerciseVerification): string;
+export declare function buildCliAutoImplPrompt(ctx: DevServerContext, type: string, provider: any, providerDir: string, functions: string[], referenceScripts: Record<string, string>, userComment?: string, referenceType?: string | null, verification?: CliExerciseVerification): string;
+export declare function handleAutoImplSSE(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): void;
+export declare function handleAutoImplCancel(ctx: DevServerContext, _type: string, _req: http.IncomingMessage, res: http.ServerResponse): void;
+export declare function sendAutoImplSSE(ctx: DevServerContext, msg: {
+    event: string;
+    data: any;
+}): void;
+export {};

package/src/daemon/dev-cdp-handlers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DevServer — CDP & DOM Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ */
+import type * as http from 'http';
+import type { DevServerContext } from './dev-server-types.js';
+export declare function handleCdpEvaluate(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpClick(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpDomQuery(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScreenshot(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScriptsRun(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleTypeAndSend(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleTypeAndSendAt(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScriptHints(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpTargets(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomInspect(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomChildren(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomAnalyze(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleFindCommon(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleFindByText(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomContext(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

package/src/daemon/dev-cli-debug.d.ts

@@ -0,0 +1,106 @@
+/**
+ * DevServer — CLI Debug Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ * All functions take a DevServerContext as their first argument.
+ */
+import type * as http from 'http';
+import type { DevServerContext } from './dev-server-types.js';
+type CliExerciseRequest = {
+    type?: string;
+    text?: string;
+    instanceId?: string;
+    workingDir?: string;
+    args?: string[];
+    autoLaunch?: boolean;
+    freshSession?: boolean;
+    autoResolveApprovals?: boolean;
+    approvalButtonIndex?: number;
+    timeoutMs?: number;
+    readyTimeoutMs?: number;
+    idleSettledMs?: number;
+    traceLimit?: number;
+    stopWhenDone?: boolean;
+};
+export type CliFixtureAssertions = {
+    mustContainAny?: string[];
+    mustNotContainAny?: string[];
+    mustMatchAny?: string[];
+    mustNotMatchAny?: string[];
+    lastAssistantMustContainAny?: string[];
+    lastAssistantMustNotContainAny?: string[];
+    lastAssistantMustMatchAny?: string[];
+    lastAssistantMustNotMatchAny?: string[];
+    statusesSeen?: string[];
+    requireNotTimedOut?: boolean;
+};
+type CliExerciseFixture = {
+    version: 1;
+    kind: 'cli-exercise-fixture';
+    name: string;
+    type: string;
+    createdAt: string;
+    providerDir: string | null;
+    providerResolution: Record<string, any> | null;
+    request: CliExerciseRequest;
+    result: Record<string, any>;
+    assertions: CliFixtureAssertions;
+    notes?: string;
+};
+export declare function validateCliFixtureResult(result: any, assertions: CliFixtureAssertions): string[];
+export declare function runCliExerciseInternal(ctx: DevServerContext, body: CliExerciseRequest): Promise<Record<string, any>>;
+export declare function runCliAutoImplVerification(ctx: DevServerContext, type: string, verification?: {
+    request?: Record<string, any>;
+    mustContainAny?: string[];
+    mustNotContainAny?: string[];
+    mustMatchAny?: string[];
+    mustNotMatchAny?: string[];
+    lastAssistantMustContainAny?: string[];
+    lastAssistantMustNotContainAny?: string[];
+    lastAssistantMustMatchAny?: string[];
+    lastAssistantMustNotMatchAny?: string[];
+    fixtureName?: string;
+    fixtureNames?: string[];
+}): Promise<{
+    mode: 'fixture_replay' | 'fixture_replay_suite' | 'exercise';
+    pass: boolean;
+    failures: string[];
+    result: Record<string, any>;
+    assertions: CliFixtureAssertions;
+    fixture?: CliExerciseFixture;
+    results?: Array<{
+        fixtureName: string;
+        pass: boolean;
+        failures: string[];
+        result: Record<string, any>;
+        assertions: CliFixtureAssertions;
+        fixture: CliExerciseFixture;
+    }>;
+}>;
+/** GET /api/cli/status — list all running CLI/ACP instances with state */
+export declare function handleCliStatus(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/launch — launch a CLI agent { type, workingDir?, args? } */
+export declare function handleCliLaunch(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/send — send message to a running CLI { type, text } */
+export declare function handleCliSend(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/stop — stop a running CLI { type } */
+export declare function handleCliStop(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/events — SSE stream of CLI status events */
+export declare function handleCliSSE(ctx: DevServerContext, cliSSEClients: http.ServerResponse[], _req: http.IncomingMessage, res: http.ServerResponse): void;
+/** GET /api/cli/debug/:type — full internal debug state of a CLI adapter */
+export declare function handleCliDebug(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/trace/:type — recent CLI trace timeline plus current debug snapshot */
+export declare function handleCliTrace(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/exercise — autonomously run a CLI repro and wait for final settled trace */
+export declare function handleCliExercise(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/fixture/capture — run exact exercise once and persist it as a reusable fixture */
+export declare function handleCliFixtureCapture(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/fixtures/:type — list saved exercise fixtures for a provider */
+export declare function handleCliFixtureList(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/fixture/replay — rerun a saved exact exercise and validate against saved assertions */
+export declare function handleCliFixtureReplay(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
+export declare function handleCliResolve(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/raw — send raw keystrokes to PTY { type, keys } */
+export declare function handleCliRaw(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export {};

package/src/daemon/dev-server-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared types & context interface for DevServer handler modules.
+ *
+ * Each handler module (cdp, cli-debug, auto-implement) imports DevServerContext
+ * to access shared state and utilities without circular references.
+ */
+import type * as http from 'http';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { DaemonCliManager } from '../commands/cli-manager.js';
+import type { ProviderCategory } from '../providers/contracts.js';
+/**
+ * Context passed from the main DevServer to handler modules.
+ * Provides access to shared dependencies and utility methods.
+ */
+export interface DevServerContext {
+    readonly providerLoader: ProviderLoader;
+    readonly cdpManagers: Map<string, DaemonCdpManager>;
+    readonly instanceManager: ProviderInstanceManager | null;
+    readonly cliManager: DaemonCliManager | null;
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    json(res: http.ServerResponse, status: number, data: any): void;
+    readBody(req: http.IncomingMessage): Promise<any>;
+    log(msg: string): void;
+    autoImplSSEClients: http.ServerResponse[];
+    sendAutoImplSSE(msg: {
+        event: string;
+        data: any;
+    }): void;
+    autoImplStatus: {
+        running: boolean;
+        type: string | null;
+        progress: any[];
+    };
+    autoImplProcess: import('child_process').ChildProcess | null;
+    sendCliSSE(data: any): void;
+    handleRunScript(type: string, req: http.IncomingMessage, res: http.ServerResponse, parsedBody?: any): Promise<void>;
+    findProviderDir(type: string): string | null;
+    getLatestScriptVersionDir(scriptsDir: string): string | null;
+}
+/** Re-export for convenience */
+export type { ProviderCategory };