@adhdev/daemon-core 0.7.38 → 0.7.40

package/dist/cli-adapter-types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * CliAdapter — common interface for CLI agents
+ *
+ * Contract implemented by all CLI adapters (ProviderCliAdapter etc).
+ */
+export interface CliAdapter {
+    cliType: string;
+    cliName: string;
+    workingDir: string;
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): any;
+    getPartialResponse(): string;
+    saveAndStop?(): Promise<void>;
+    shutdown(): void;
+    detach?(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(callback: () => void): void;
+    setServerConn?(serverConn: any): void;
+    setOnPtyData?(callback: (data: string) => void): void;
+    writeRaw?(data: string): void;
+    resize?(cols: number, rows: number): void;
+}

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -0,0 +1,229 @@
+/**
+ * ProviderCliAdapter — Script-based CLI Adapter
+ *
+ * All CLI providers use versioned scripts (like IDE providers).
+ * Scripts are Node.js functions that receive PTY buffer data and return structured results.
+ *
+ * Required scripts in scripts/{version}/scripts.js:
+ *   - detectStatus(input)  → AgentStatus string ('idle' | 'generating' | 'waiting_approval')
+ *   - parseOutput(input)   → ReadChatResult { messages, status, activeModal, ... }
+ *   - parseApproval(input) → ModalInfo | null
+ *
+ * provider.json contract:
+ *   type, name, category: 'cli', binary, spawn, approvalKeys
+ *   compatibility: [{ ideVersion, scriptDir }]  ← versioned scripts
+ */
+import type { CliAdapter } from '../cli-adapter-types.js';
+import type { ProviderResumeCapability } from '../providers/contracts.js';
+import { type PtyRuntimeMetadata, type PtyTransportFactory } from './pty-transport.js';
+export interface CliChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: number;
+}
+export interface CliSessionStatus {
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+    messages: CliChatMessage[];
+    workingDir: string;
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+    terminalHistory?: string;
+}
+/**
+ * CLI Script Functions.
+ * Unlike IDE scripts (which return JS code strings for CDP evaluate),
+ * CLI scripts are Node.js functions that receive PTY buffer data and return structured results.
+ */
+export interface CliScripts {
+    /** Full PTY buffer → ReadChatResult (messages, status, activeModal) */
+    parseOutput?: (input: CliScriptInput) => any;
+    /** Lightweight status detection (high-frequency polling) → AgentStatus string */
+    detectStatus?: (input: {
+        tail: string;
+        screenText?: string;
+        rawBuffer?: string;
+    }) => string | null;
+    /** Parse approval modal from PTY output → ModalInfo | null */
+    parseApproval?: (input: {
+        buffer: string;
+        screenText?: string;
+        rawBuffer?: string;
+        tail: string;
+    }) => {
+        message: string;
+        buttons: string[];
+    } | null;
+    /** Produce a cli-specific prompt from a dashboard action payload */
+    resolveAction?: (data: any) => string;
+    /** Custom scripts */
+    [name: string]: ((input: any) => any) | undefined;
+}
+export interface CliScriptInput {
+    buffer: string;
+    rawBuffer: string;
+    recentBuffer: string;
+    screenText: string;
+    terminalHistory?: string;
+    messages: CliChatMessage[];
+    partialResponse: string;
+}
+export interface CliProviderModule {
+    type: string;
+    name: string;
+    category: 'cli';
+    binary: string;
+    sendDelayMs?: number;
+    sendKey?: string;
+    submitStrategy?: 'wait_for_echo' | 'immediate';
+    spawn: {
+        command: string;
+        args: string[];
+        shell: boolean;
+        env: Record<string, string>;
+    };
+    timeouts?: {
+        /** PTY output batch transmit interval (default 50ms) */
+        ptyFlush?: number;
+        /** Wait for startup dialog auto-proceed (default 300ms) */
+        dialogAccept?: number;
+        /** Approval detect cooldown (default 2000ms) */
+        approvalCooldown?: number;
+        /** Check for completion on no-response during generating (default 6000ms) */
+        generatingIdle?: number;
+        /** Check for completion on no-response (default 5000ms) */
+        idleFinish?: number;
+        /** Max response wait (default 300000ms = 5min) */
+        maxResponse?: number;
+        /** shutdown after kill wait (default 1000ms) */
+        shutdownGrace?: number;
+        /** Output settle debounce before evaluating status (default 300ms) */
+        outputSettle?: number;
+    };
+    resume?: ProviderResumeCapability;
+}
+/**
+ * Normalize raw provider JSON for auto-implement approval patterns.
+ * Used by dev-server only — ProviderCliAdapter itself uses scripts.
+ */
+export declare function normalizeCliProviderForRuntime(raw: any): {
+    patterns: {
+        approval: RegExp[];
+    };
+};
+export declare class ProviderCliAdapter implements CliAdapter {
+    private extraArgs;
+    readonly cliType: string;
+    readonly cliName: string;
+    workingDir: string;
+    private provider;
+    private ptyProcess;
+    private transportFactory;
+    private messages;
+    private committedMessages;
+    private structuredMessages;
+    private currentStatus;
+    private onStatusChange;
+    private responseBuffer;
+    private recentOutputBuffer;
+    private isWaitingForResponse;
+    private activeModal;
+    private responseTimeout;
+    private idleTimeout;
+    private ready;
+    private startupBuffer;
+    private startupParseGate;
+    private spawnAt;
+    private onPtyDataCallback;
+    private pendingOutputParseBuffer;
+    private pendingOutputParseTimer;
+    private ptyOutputBuffer;
+    private ptyOutputFlushTimer;
+    private serverConn;
+    private logBuffer;
+    private lastApprovalResolvedAt;
+    private approvalTransitionBuffer;
+    private approvalExitTimeout;
+    private pendingScriptStatus;
+    private pendingScriptStatusSince;
+    private pendingScriptStatusTimer;
+    private settleTimer;
+    private settledBuffer;
+    private submitPendingUntil;
+    private responseSettleIgnoreUntil;
+    private responseEpoch;
+    private submitRetryTimer;
+    private submitRetryUsed;
+    private submitRetryPromptSnippet;
+    private resizeSuppressUntil;
+    private statusHistory;
+    private cliScripts;
+    /** Full accumulated ANSI-stripped PTY output */
+    private accumulatedBuffer;
+    /** Full accumulated raw PTY output (with ANSI) */
+    private accumulatedRawBuffer;
+    /** Current visible terminal screen snapshot */
+    private terminalScreen;
+    /** Rolling append-only terminal transcript built from screen snapshots */
+    private terminalHistory;
+    /** Max accumulated buffer size (last 50KB) */
+    private static readonly MAX_ACCUMULATED_BUFFER;
+    private currentTurnScope;
+    private syncMessageViews;
+    private sliceFromOffset;
+    private buildParseInput;
+    private setStatus;
+    private readonly timeouts;
+    private readonly approvalKeys;
+    private readonly sendDelayMs;
+    private readonly sendKey;
+    private readonly submitStrategy;
+    private static readonly SCRIPT_STATUS_DEBOUNCE_MS;
+    constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], transportFactory?: PtyTransportFactory);
+    /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
+    setCliScripts(scripts: CliScripts): void;
+    setServerConn(serverConn: any): void;
+    setOnStatusChange(callback: () => void): void;
+    setOnPtyData(callback: (data: string) => void): void;
+    private flushPendingOutputParse;
+    spawn(): Promise<void>;
+    private handleOutput;
+    private scheduleSettle;
+    private armApprovalExitTimeout;
+    private looksLikeVisibleIdlePrompt;
+    private evaluateSettled;
+    private finishResponse;
+    private commitCurrentTranscript;
+    private runDetectStatus;
+    private runParseApproval;
+    getStatus(): CliSessionStatus;
+    /**
+     * Script-based full parse — returns ReadChatResult.
+     * Called by command handler / dashboard for rich content rendering.
+     */
+    getScriptParsedStatus(): any;
+    private parseCurrentTranscript;
+    /** Whether this adapter has CLI scripts loaded */
+    hasCliScripts(): boolean;
+    /**
+     * Resolves an action (like 'fix' lint error) from the dashboard.
+     * Uses resolveAction script if available, otherwise falls back to standard text.
+     */
+    resolveAction(data: any): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getPartialResponse(): string;
+    getRuntimeMetadata(): PtyRuntimeMetadata | null;
+    cancel(): void;
+    saveAndStop(): Promise<void>;
+    private waitForStopped;
+    shutdown(): void;
+    detach(): void;
+    clearHistory(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    writeRaw(data: string): void;
+    resolveModal(buttonIndex: number): void;
+    resize(cols: number, rows: number): void;
+    getDebugState(): Record<string, any>;
+}

package/dist/cli-adapters/pty-transport.d.ts

@@ -0,0 +1,43 @@
+export interface PtySpawnOptions {
+    cwd: string;
+    env: Record<string, string>;
+    cols: number;
+    rows: number;
+}
+export interface PtyRuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+export interface PtyRuntimeClientInfo {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+export interface PtyRuntimeMetadata {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    writeOwner?: PtyRuntimeWriteOwner | null;
+    attachedClients?: PtyRuntimeClientInfo[];
+}
+export interface PtyRuntimeTransport {
+    readonly pid: number;
+    readonly ready: Promise<void>;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    clearBuffer?(): void;
+    detach?(): void;
+    getMetadata?(): PtyRuntimeMetadata | null;
+    onData(callback: (data: string) => void): void;
+    onExit(callback: (info: {
+        exitCode: number;
+    }) => void): void;
+}
+export interface PtyTransportFactory {
+    spawn(command: string, args: string[], options: PtySpawnOptions): PtyRuntimeTransport;
+}
+export declare class NodePtyTransportFactory implements PtyTransportFactory {
+    spawn(command: string, args: string[], options: PtySpawnOptions): PtyRuntimeTransport;
+}

package/dist/cli-adapters/session-host-transport.d.ts

@@ -0,0 +1,19 @@
+import { type SessionHostEndpoint, type SessionHostCategory } from '@adhdev/session-host-core';
+import type { PtyRuntimeTransport, PtySpawnOptions, PtyTransportFactory } from './pty-transport.js';
+interface SessionHostPtyTransportFactoryOptions {
+    endpoint?: SessionHostEndpoint;
+    appName?: string;
+    clientId: string;
+    runtimeId: string;
+    providerType: string;
+    category?: SessionHostCategory;
+    workspace: string;
+    meta?: Record<string, unknown>;
+    attachExisting?: boolean;
+}
+export declare class SessionHostPtyTransportFactory implements PtyTransportFactory {
+    private readonly options;
+    constructor(options: SessionHostPtyTransportFactoryOptions);
+    spawn(command: string, args: string[], spawnOptions: PtySpawnOptions): PtyRuntimeTransport;
+}
+export {};

package/dist/cli-adapters/terminal-backends/ghostty-vt-backend.d.ts

@@ -0,0 +1,12 @@
+import type { TerminalViewportBackend, TerminalViewportBackendOptions, TerminalViewportBackendPreference } from './types.js';
+export declare function resolveTerminalBackendPreference(): TerminalViewportBackendPreference;
+export declare function isGhosttyVtBackendAvailable(): boolean;
+export declare class GhosttyVtTerminalBackend implements TerminalViewportBackend {
+    readonly kind: "ghostty-vt";
+    private terminal;
+    constructor(options: TerminalViewportBackendOptions);
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    dispose(): void;
+}

package/dist/cli-adapters/terminal-backends/types.d.ts

@@ -0,0 +1,14 @@
+export type TerminalViewportBackendKind = 'xterm' | 'ghostty-vt';
+export type TerminalViewportBackendPreference = TerminalViewportBackendKind | 'auto';
+export type TerminalViewportBackendOptions = {
+    rows: number;
+    cols: number;
+    scrollback: number;
+};
+export interface TerminalViewportBackend {
+    readonly kind: TerminalViewportBackendKind;
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    dispose(): void;
+}

package/dist/cli-adapters/terminal-backends/xterm-backend.d.ts

@@ -0,0 +1,13 @@
+import type { TerminalViewportBackend, TerminalViewportBackendOptions } from './types.js';
+export declare class XtermTerminalBackend implements TerminalViewportBackend {
+    readonly kind: "xterm";
+    private rows;
+    private cols;
+    private terminal;
+    constructor(options: TerminalViewportBackendOptions);
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    dispose(): void;
+    private createTerminal;
+}

package/dist/cli-adapters/terminal-screen.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PTY screen snapshot abstraction.
+ *
+ * We currently keep xterm as the default parser/model because it is already
+ * proven in production, but the surface is now backend-agnostic so we can
+ * swap in libghostty-vt once a native Node binding is available.
+ */
+import type { TerminalViewportBackendKind, TerminalViewportBackendPreference } from './terminal-backends/types.js';
+export declare function getTerminalBackendRuntimeStatus(): {
+    backend: TerminalViewportBackendKind;
+    preference: TerminalViewportBackendPreference;
+    ghosttyAvailable: boolean;
+};
+export declare class TerminalScreen {
+    readonly backendKind: TerminalViewportBackendKind;
+    private rows;
+    private cols;
+    private readonly preference;
+    private terminal;
+    constructor(rows?: number, cols?: number);
+    reset(rows?: number, cols?: number): void;
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    dispose(): void;
+    private createBackend;
+}

package/dist/commands/cdp-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CDP Commands — cdpEval, screenshot, cdpCommand, cdpBatch, cdpRemoteAction,
+ *                discoverAgents, file operations
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleCdpEval(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleScreenshot(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpCommand(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpBatch(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpRemoteAction(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleDiscoverAgents(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileRead(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileWrite(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileList(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileListBrowse(h: CommandHelpers, args: any): Promise<CommandResult>;

package/dist/commands/chat-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chat Commands — readChat, sendChat, listChats, newChat, switchChat,
+ *                 setMode, changeModel, setThoughtLevel, resolveAction, chatHistory
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleListChats(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleNewChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetMode(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleChangeModel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetThoughtLevel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleResolveAction(h: CommandHelpers, args: any): Promise<CommandResult>;

package/dist/commands/cli-manager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * DaemonCliManager — CLI session creation, management, and command handling
+ *
+ * Separated from adhdev-daemon.ts.
+ * CLI cases of createAdapter, startCliSession, stopCliSession, executeDaemonCommand extracted to independent module extract.
+ */
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+import type { SessionRegistry } from '../sessions/registry.js';
+export interface CliManagerDeps {
+    /** Server connection — injected into adapter */
+    getServerConn(): any | null;
+    /** P2P — PTY output transmit */
+    getP2p(): {
+        broadcastPtyOutput(key: string, data: string): void;
+    } | null;
+    /** StatusReporter callback */
+    onStatusChange(): void;
+    removeAgentTracking(key: string): void;
+    /** InstanceManager — register in CLI unified status */
+    getInstanceManager(): ProviderInstanceManager | null;
+    getSessionRegistry?(): SessionRegistry | null;
+    createPtyTransportFactory?: (params: CliTransportFactoryParams) => PtyTransportFactory | null;
+    listHostedCliRuntimes?: () => Promise<HostedCliRuntimeDescriptor[]>;
+}
+type CommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+export interface CliTransportFactoryParams {
+    runtimeId: string;
+    providerType: string;
+    workspace: string;
+    cliArgs?: string[];
+    attachExisting?: boolean;
+}
+export interface HostedCliRuntimeDescriptor {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
+    recoveryState?: string | null;
+    cliType: string;
+    workspace: string;
+    cliArgs?: string[];
+}
+export declare class DaemonCliManager {
+    readonly adapters: Map<string, CliAdapter>;
+    private deps;
+    private providerLoader;
+    constructor(deps: CliManagerDeps, providerLoader: ProviderLoader);
+    getCliKey(cliType: string, dir: string): string;
+    private persistRecentActivity;
+    private getTransportFactory;
+    private createAdapter;
+    private startCliExitMonitor;
+    private registerCliInstance;
+    startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string): Promise<void>;
+    stopSession(key: string): Promise<void>;
+    stopSessionWithMode(key: string, mode: 'hard' | 'save'): Promise<void>;
+    shutdownAll(): void;
+    detachAll(): void;
+    restoreHostedSessions(records?: HostedCliRuntimeDescriptor[]): Promise<number>;
+    /**
+    * Search for CLI adapter. Priority order:
+    * 0. sessionId (UUID direct match)
+    * 1. agentType + dir (iteration match)
+    * 2. agentType fuzzy match (⚠ returns first match when multiple sessions exist)
+    */
+    findAdapter(agentType: string, opts?: {
+        dir?: string;
+        instanceKey?: string;
+    }): {
+        adapter: CliAdapter;
+        key: string;
+    } | null;
+    handleCliCommand(cmd: string, args: any): Promise<CommandResult | null>;
+}
+export {};

package/dist/commands/handler.d.ts

@@ -0,0 +1,101 @@
+/**
+ * DaemonCommandHandler — unified command routing for CDP & CLI
+ *
+ * Routes incoming commands (from server WS, P2P, or local WS) to
+ * the correct CDP manager or CLI adapter.
+ *
+ * Key concepts:
+ *   - extractIdeType(): determines target IDE from targetSessionId or ideType
+ *   - getCdp(): returns the DaemonCdpManager for current command
+ *   - getProvider(): returns the ProviderModule for current command
+ *   - handle(): main entry point, sets context then dispatches
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { ProviderModule } from '../providers/contracts.js';
+import type { DaemonAgentStreamManager } from '../agent-stream/index.js';
+import { ChatHistoryWriter } from '../config/chat-history.js';
+import type { SessionRegistry, SessionRuntimeTarget } from '../sessions/registry.js';
+export interface CommandResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export interface CommandContext {
+    cdpManagers: Map<string, DaemonCdpManager>;
+    ideType: string;
+    adapters: Map<string, any>;
+    providerLoader?: ProviderLoader;
+    /** ProviderInstanceManager — for runtime settings propagation */
+    instanceManager?: ProviderInstanceManager;
+    sessionRegistry?: SessionRegistry;
+}
+/**
+ * Shared helpers interface — passed to sub-module command functions
+ * for accessing CDP, providers, agent streams, and other handler-owned state.
+ */
+export interface CommandHelpers {
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    getProvider(overrideType?: string): ProviderModule | undefined;
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
+    evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{
+        result: any;
+        category: string;
+    } | null>;
+    getCliAdapter(type?: string): any | null;
+    readonly currentManagerKey: string | undefined;
+    readonly currentIdeType: string | undefined;
+    readonly currentProviderType: string | undefined;
+    readonly currentSession: SessionRuntimeTarget | undefined;
+    readonly agentStream: DaemonAgentStreamManager | null;
+    readonly ctx: CommandContext;
+    readonly historyWriter: ChatHistoryWriter;
+}
+export declare class DaemonCommandHandler implements CommandHelpers {
+    private _ctx;
+    private _agentStream;
+    private domHandlers;
+    private _historyWriter;
+    /** Current request route context */
+    private _currentRoute;
+    constructor(ctx: CommandContext);
+    get ctx(): CommandContext;
+    get agentStream(): DaemonAgentStreamManager | null;
+    get historyWriter(): ChatHistoryWriter;
+    get currentManagerKey(): string | undefined;
+    get currentIdeType(): string | undefined;
+    get currentProviderType(): string | undefined;
+    get currentSession(): SessionRuntimeTarget | undefined;
+    /** Get CDP manager for a specific session or manager key. */
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    /**
+     * Get provider module — _currentProviderType (agentType priority) use.
+     */
+    getProvider(overrideType?: string): ProviderModule | undefined;
+    /** Get a provider script by name from ProviderLoader. */
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
+    /**
+     * per-category CDP script execute:
+     * IDE → cdp.evaluate(script) (main window)
+     * Extension → cdp.evaluateInSession(sessionId, script) (webview)
+     */
+    evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{
+        result: any;
+        category: string;
+    } | null>;
+    /** CLI adapter search */
+    getCliAdapter(type?: string): any | null;
+    private inferProviderType;
+    private resolveRoute;
+    /** Extract CDP scope key from target session or explicit ideType */
+    private extractIdeType;
+    private logCommandStart;
+    private logCommandEnd;
+    setAgentStreamManager(manager: DaemonAgentStreamManager): void;
+    handle(cmd: string, args: any): Promise<CommandResult>;
+    private dispatch;
+    private handleRefreshScripts;
+    private proxyDevServerPost;
+    private proxyDevServerGet;
+    private proxyDevServerScaffold;
+}

package/dist/commands/router.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 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;
+}
+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;
+}