@adhdev/daemon-core 0.5.3

package/src/commands/cli-manager.ts

@@ -0,0 +1,353 @@
+/**
+ * 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 * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import chalk from 'chalk';
+import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import { detectCLI } from '../detection/cli-detector.js';
+import { loadConfig, saveConfig, addCliHistory } from '../config/config.js';
+import { CliProviderInstance } from '../providers/cli-provider-instance.js';
+import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
+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 { LOG } from '../logging/logger.js';
+
+// ─── external dependency interface ──────────────────────────
+
+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;
+}
+
+type CommandResult = { success: boolean;[key: string]: unknown };
+
+// ─── DaemonCliManager ────────────────────────────
+
+export class DaemonCliManager {
+    readonly adapters = new Map<string, CliAdapter>();
+    private deps: CliManagerDeps;
+    private providerLoader: ProviderLoader;
+
+    constructor(deps: CliManagerDeps, providerLoader: ProviderLoader) {
+        this.deps = deps;
+        this.providerLoader = providerLoader;
+    }
+
+ // ─── Key create ─────────────────────────────────
+
+    getCliKey(cliType: string, dir: string): string {
+        const hash = require('crypto').createHash('md5').update(require('path').resolve(dir)).digest('hex').slice(0, 8);
+        return `${cliType}_${hash}`;
+    }
+
+    private createAdapter(cliType: string, workingDir: string, cliArgs?: string[]): CliAdapter {
+ // cliType normalize (Resolve alias)
+        const normalizedType = this.providerLoader.resolveAlias(cliType);
+
+ // Load CLI config from provider.js
+        const provider = this.providerLoader.getMeta(normalizedType);
+        if (provider && provider.category === 'cli' && provider.patterns && provider.spawn) {
+            console.log(chalk.cyan(`  📦 Using provider: ${provider.name} (${provider.type})`));
+            return new ProviderCliAdapter(provider as any, workingDir, cliArgs);
+        }
+
+        throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
+    }
+
+ // ─── Session start/management ──────────────────────────────
+
+    async startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string): Promise<void> {
+        const trimmed = (workingDir || os.homedir()).trim();
+        const resolvedDir = trimmed.startsWith('~')
+            ? trimmed.replace(/^~/, os.homedir())
+            : path.resolve(trimmed);
+
+ // cliType normalize (Resolve alias)
+        const normalizedType = this.providerLoader.resolveAlias(cliType);
+        const provider = this.providerLoader.getByAlias(cliType);
+
+ // Create UUID-based key (allows separate instances even for same type+dir)
+        const key = crypto.randomUUID();
+
+ // ─── ACP category handle ───
+        if (provider && provider.category === 'acp') {
+            const instanceManager = this.deps.getInstanceManager();
+            if (!instanceManager) throw new Error('InstanceManager not available');
+
+ // Check if command is installed
+            const spawnCmd = provider.spawn?.command;
+            if (spawnCmd) {
+                try {
+                    const { execSync } = require('child_process');
+                    execSync(`which ${spawnCmd}`, { stdio: 'ignore' });
+                } catch {
+                    const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
+                    throw new Error(
+                        `${provider.displayName || provider.name} is not installed.\n` +
+                        `Command '${spawnCmd}' not found in PATH.\n\n` +
+                        `${installInfo}`
+                    );
+                }
+            }
+
+            console.log(chalk.cyan(`  🔌 Starting ACP agent: ${provider.name} (${provider.type}) in ${resolvedDir}`));
+
+            const acpInstance = new AcpProviderInstance(provider, resolvedDir, cliArgs);
+            await instanceManager.addInstance(key, acpInstance, {
+                settings: this.providerLoader.getSettings(normalizedType),
+            });
+
+ // Register ACP entry in adapter map (getStatus queries from acpInstance in real-time)
+            this.adapters.set(key, {
+                cliType: normalizedType,
+                workingDir: resolvedDir,
+                _acpInstance: acpInstance,
+                spawn: async () => {},
+                shutdown: () => { instanceManager.removeInstance(key); },
+                sendMessage: async (text: string) => { acpInstance.onEvent('send_message', { text }); },
+                getStatus: () => {
+                    const state = acpInstance.getState();
+                    return {
+                        status: state.status,
+                        messages: state.activeChat?.messages || [],
+                        activeModal: state.activeChat?.activeModal || null,
+                    };
+                },
+                setOnStatusChange: () => {},
+                setOnPtyData: () => {},
+            } as any);
+
+            console.log(chalk.green(`  ✓ ACP agent started: ${provider.name} in ${resolvedDir}`));
+
+ // If initialModel exists, change model after session start
+            if (initialModel) {
+                try {
+                    await acpInstance.setConfigOption('model', initialModel);
+                    console.log(chalk.green(`  🤖 Initial model set: ${initialModel}`));
+                } catch (e: any) {
+                    LOG.warn('CLI', `[ACP] Initial model set failed: ${e?.message}`);
+                }
+            }
+
+            try { addCliHistory({ cliType: normalizedType, dir: resolvedDir, cliArgs }); } catch (e) { LOG.warn('CLI', `ACP history save failed: ${(e as Error)?.message}`); }
+            this.deps.onStatusChange();
+            return;
+        }
+
+ // ─── CLI category handling (existing) ───
+        const cliInfo = await detectCLI(cliType, this.providerLoader);
+        if (!cliInfo) throw new Error(`${cliType} not found`);
+
+        console.log(chalk.yellow(`  ⚡ Starting CLI ${cliType} in ${resolvedDir}...`));
+        if (provider) {
+            console.log(chalk.cyan(`  📦 Using provider: ${provider.name} (${provider.type})`));
+        }
+
+ // If InstanceManager exists, manage as CliProviderInstance unified
+        const instanceManager = this.deps.getInstanceManager();
+        if (provider && instanceManager) {
+            const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key);
+            await instanceManager.addInstance(key, cliInstance, {
+                serverConn: this.deps.getServerConn(),
+                settings: {},
+                onPtyData: (data: string) => {
+                    this.deps.getP2p()?.broadcastPtyOutput(key, data);
+                },
+            });
+
+ // Keep adapter ref too (backward compat — write, resize etc)
+            this.adapters.set(key, cliInstance.getAdapter() as any);
+            console.log(chalk.green(`  ✓ CLI started: ${cliInfo.displayName} v${cliInfo.version || 'unknown'} in ${resolvedDir}`));
+        } else {
+ // Fallback: InstanceManager without directly adapter manage
+            const adapter = this.createAdapter(cliType, resolvedDir, cliArgs);
+            await adapter.spawn();
+
+            const serverConn = this.deps.getServerConn();
+            if (serverConn && typeof adapter.setServerConn === 'function') {
+                adapter.setServerConn(serverConn);
+            }
+            adapter.setOnStatusChange(() => {
+                this.deps.onStatusChange();
+                const status = adapter.getStatus?.();
+                if (status?.status === 'stopped') {
+                    setTimeout(() => {
+                        if (this.adapters.get(key) === adapter) {
+                            this.adapters.delete(key);
+                            this.deps.removeAgentTracking(key);
+                            console.log(chalk.yellow(`  🧹 Auto-cleaned stopped CLI: ${adapter.cliType}`));
+                            this.deps.onStatusChange();
+                        }
+                    }, 3000);
+                }
+            });
+
+            if (typeof adapter.setOnPtyData === 'function') {
+                adapter.setOnPtyData((data: string) => {
+                    this.deps.getP2p()?.broadcastPtyOutput(key, data);
+                });
+            }
+
+            this.adapters.set(key, adapter);
+            console.log(chalk.green(`  ✓ CLI started: ${cliInfo.displayName} v${cliInfo.version || 'unknown'} in ${resolvedDir}`));
+        }
+
+        try { addCliHistory({ cliType, dir: resolvedDir, cliArgs }); } catch (e) { LOG.warn('CLI', `CLI history save failed: ${(e as Error)?.message}`); }
+
+        this.deps.onStatusChange();
+    }
+
+    async stopSession(key: string): Promise<void> {
+        const adapter = this.adapters.get(key);
+        if (adapter) {
+            adapter.shutdown();
+            this.adapters.delete(key);
+            this.deps.removeAgentTracking(key);
+ // Also remove from InstanceManager
+            this.deps.getInstanceManager()?.removeInstance(key);
+            console.log(chalk.yellow(`  🛑 CLI Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`));
+            this.deps.onStatusChange();
+        }
+    }
+
+    shutdownAll(): void {
+        for (const adapter of this.adapters.values()) adapter.shutdown();
+        this.adapters.clear();
+    }
+
+ // ─── Adapter search ─────────────────────────────
+
+ /**
+ * Search for CLI adapter. Priority order:
+ * 0. instanceKey (UUID direct match) — extracted from _targetInstance / composite ID
+ * 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 {
+ // 0. UUID direct match (most accurate)
+        if (opts?.instanceKey) {
+            let ik = opts.instanceKey;
+ // Strip composite prefix: 'doId:cli:uuid' → 'uuid' or 'doId:uuid' → 'uuid'
+            const colonIdx = ik.lastIndexOf(':');
+            if (colonIdx >= 0) ik = ik.substring(colonIdx + 1);
+            const adapter = this.adapters.get(ik);
+            if (adapter) return { adapter, key: ik };
+        }
+ // 1. agentType + dir match
+        if (opts?.dir) {
+            for (const [k, a] of this.adapters) {
+                if (a.cliType === agentType && a.workingDir === opts.dir) {
+                    return { adapter: a, key: k };
+                }
+            }
+        }
+ // 2. Fuzzy match (returns first of multiple sessions — may be inaccurate)
+        for (const [k, a] of this.adapters) {
+            if (a.cliType === agentType) {
+                return { adapter: a, key: k };
+            }
+        }
+        return null;
+    }
+
+ // ─── CLI command handling ────────────────────────────
+
+    async handleCliCommand(cmd: string, args: any): Promise<CommandResult | null> {
+        switch (cmd) {
+            case 'launch_cli': {
+                const cliType = args?.cliType;
+                const defaultedToHome = !args?.dir;
+                const dir = args?.dir || os.homedir();
+                if (!cliType) throw new Error('cliType required');
+
+                await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel);
+
+ // On startSession success, new UUID key exists in adapters (last added item)
+                let newKey: string | null = null;
+                for (const [k, adapter] of this.adapters) {
+                    if (adapter.cliType === cliType && adapter.workingDir === dir) {
+                        newKey = k; // Last match = just added item
+                    }
+                }
+
+                try {
+                    const config = loadConfig();
+                    console.log(chalk.cyan(`  📂 Saving recent workspace: ${dir}`));
+                    const recent = config.recentCliWorkspaces || [];
+                    if (!recent.includes(dir)) {
+                        const updated = [dir, ...recent].slice(0, 10);
+                        saveConfig({ ...config, recentCliWorkspaces: updated });
+                        console.log(chalk.green(`  ✓ Recent workspace saved: ${dir}`));
+                    }
+                } catch (e) {
+                    console.error(chalk.red(`  ✗ Failed to save recent workspace: ${e}`));
+                }
+
+                return { success: true, cliType, dir, id: newKey, defaultedToHome };
+            }
+            case 'stop_cli': {
+                const cliType = args?.cliType;
+                const dir = args?.dir || '';
+                if (!cliType) throw new Error('cliType required');
+ // UUID (_targetInstance) based search priority
+                const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
+                if (found) {
+                    await this.stopSession(found.key);
+                } else {
+                    console.log(chalk.yellow(`  ⚠ No adapter found for ${cliType}`));
+                }
+                return { success: true, cliType, dir, stopped: true };
+            }
+            case 'restart_session': {
+                const cliType = args?.cliType || args?.agentType || args?.ideType;
+                const dir = args?.dir || process.cwd();
+                if (!cliType) throw new Error('cliType required');
+                const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
+                if (found) await this.stopSession(found.key);
+                await this.startSession(cliType, dir);
+                return { success: true, restarted: true };
+            }
+            case 'agent_command': {
+                const agentType = args?.agentType || args?.cliType;
+                const action = args?.action;
+                if (!agentType || !action) throw new Error('agentType and action required');
+
+                const found = this.findAdapter(agentType, {
+                    dir: args?.dir,
+                    instanceKey: args?._targetInstance,
+                });
+                if (!found) throw new Error(`CLI agent not running: ${agentType}`);
+                const { adapter, key } = found;
+
+                if (action === 'send_chat') {
+                    const message = args.message || args.text;
+                    if (!message) throw new Error('message required for send_chat');
+                    await adapter.sendMessage(message);
+                    return { success: true, status: 'generating' };
+                } else if (action === 'clear_history') {
+                    if (typeof (adapter as any).clearHistory === 'function') (adapter as any).clearHistory();
+                    return { success: true, cleared: true };
+                } else if (action === 'stop') {
+                    await this.stopSession(key);
+                    return { success: true, stopped: true };
+                }
+                throw new Error(`Unknown action: ${action}`);
+            }
+        }
+        return null; // Not a CLI command
+    }
+}

package/src/commands/handler.ts

@@ -0,0 +1,328 @@
+/**
+ * Daemon Commands — unified command handler
+ * 
+ * Routes all functionality from legacy Extension commands.ts to Daemon.
+ * 
+ * Command implementations are split into sub-modules:
+ * - chat-commands.ts    — Chat I/O, session management, mode/model control
+ * - cdp-commands.ts     — CDP eval, screenshot, batch, remote actions, file ops
+ * - stream-commands.ts  — Agent stream, PTY I/O, provider settings, extension scripts
+ */
+
+import { DaemonCdpManager } from '../cdp/manager.js';
+import { CdpDomHandlers } from '../cdp/devtools.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 { loadConfig } from '../config/config.js';
+import { ChatHistoryWriter } from '../config/chat-history.js';
+import { LOG } from '../logging/logger.js';
+
+// Sub-module imports
+import * as Chat from './chat-commands.js';
+import * as Cdp from './cdp-commands.js';
+import * as Stream from './stream-commands.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;
+    /** UUID instanceId → CDP manager key (ideType) mapping */
+    instanceIdMap?: Map<string, string>;
+}
+
+/**
+ * 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 currentIdeType: string | undefined;
+    readonly currentProviderType: string | undefined;
+    readonly agentStream: DaemonAgentStreamManager | null;
+    readonly ctx: CommandContext;
+    readonly historyWriter: ChatHistoryWriter;
+}
+
+export class DaemonCommandHandler implements CommandHelpers {
+    private _ctx: CommandContext;
+    private _agentStream: DaemonAgentStreamManager | null = null;
+    private domHandlers: CdpDomHandlers;
+    private _historyWriter: ChatHistoryWriter;
+
+    /** Current IDE type extracted from command args (per-request) */
+    private _currentIdeType: string | undefined;
+    /** Current provider type — agentType priority, ideType use */
+    private _currentProviderType: string | undefined;
+
+    constructor(ctx: CommandContext) {
+        this._ctx = ctx;
+        this.domHandlers = new CdpDomHandlers((ideType?) => this.getCdp(ideType));
+        this._historyWriter = new ChatHistoryWriter();
+    }
+
+    // ─── CommandHelpers implementation ─────────────────
+
+    get ctx(): CommandContext { return this._ctx; }
+    get agentStream(): DaemonAgentStreamManager | null { return this._agentStream; }
+    get historyWriter(): ChatHistoryWriter { return this._historyWriter; }
+    get currentIdeType(): string | undefined { return this._currentIdeType; }
+    get currentProviderType(): string | undefined { return this._currentProviderType; }
+
+    /** Get CDP manager for a specific ideType.
+     * Returns null if no match — never falls back to another IDE. */
+    getCdp(ideType?: string): DaemonCdpManager | null {
+        const key = ideType || this._currentIdeType;
+        if (!key) return null;
+        const m = this._ctx.cdpManagers.get(key.toLowerCase());
+        if (m?.isConnected) return m;
+        return null;
+    }
+
+    /**
+     * Get provider module — _currentProviderType (agentType priority) use.
+     */
+    getProvider(overrideType?: string): ProviderModule | undefined {
+        const key = overrideType || this._currentProviderType || this._currentIdeType;
+        if (!key || !this._ctx.providerLoader) return undefined;
+        const result = this._ctx.providerLoader.resolve(key);
+        if (result) return result;
+        const baseType = key.split('_')[0];
+        if (baseType !== key) return this._ctx.providerLoader.resolve(baseType);
+        return undefined;
+    }
+
+    /** Get a provider script by name from ProviderLoader. */
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null {
+        const provider = this.getProvider(ideType);
+        if (provider?.scripts) {
+            const fn = (provider.scripts as any)[scriptName];
+            if (typeof fn === 'function') {
+                const firstVal = params ? Object.values(params)[0] : undefined;
+                const script = firstVal ? fn(firstVal) : fn();
+                if (script) return script;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * per-category CDP script execute:
+     * IDE → cdp.evaluate(script) (main window)
+     * Extension → cdp.evaluateInSession(sessionId, script) (webview)
+     */
+    async evaluateProviderScript(
+        scriptName: string,
+        params?: Record<string, string>,
+        timeout = 30000,
+    ): Promise<{ result: any; category: string } | null> {
+        const provider = this.getProvider();
+        const script = this.getProviderScript(scriptName, params);
+        if (!script) return null;
+
+        const cdp = this.getCdp();
+        if (!cdp?.isConnected) return null;
+
+        // Extension: evaluateInSession
+        if (provider?.category === 'extension') {
+            let sessionId = this.getExtensionSessionId(provider);
+            if (!sessionId && this._agentStream) {
+                await this._agentStream.switchActiveAgent(cdp, provider.type);
+                await this._agentStream.syncAgentSessions(cdp);
+                sessionId = this.getExtensionSessionId(provider);
+            }
+            if (!sessionId) return null;
+            const result = await cdp.evaluateInSession(sessionId, script, timeout);
+            return { result, category: 'extension' };
+        }
+
+        // IDE (default): evaluate in main window
+        const result = await cdp.evaluate(script, timeout);
+        return { result, category: provider?.category || 'ide' };
+    }
+
+    /** CLI adapter search */
+    getCliAdapter(type?: string): any | null {
+        const target = type || this._currentIdeType;
+        if (!target || !this._ctx.adapters) return null;
+        for (const [key, adapter] of this._ctx.adapters.entries()) {
+            if ((adapter as any).cliType === target || key.startsWith(target)) {
+                return adapter;
+            }
+        }
+        return null;
+    }
+
+    // ─── Private helpers ──────────────────────────────
+
+    private getExtensionSessionId(provider: ProviderModule): string | null {
+        if (provider.category !== 'extension' || !this._agentStream) return null;
+        const managed = this._agentStream.getManagedAgent(provider.type);
+        return managed?.sessionId || null;
+    }
+
+    /** Extract ideType from _targetInstance */
+    private extractIdeType(args: any): string | undefined {
+        if (args?._targetInstance) {
+            let raw = args._targetInstance as string;
+            const ideMatch = raw.match(/:ide:(.+)$/);
+            const cliMatch = raw.match(/:cli:(.+)$/);
+            const acpMatch = raw.match(/:acp:(.+)$/);
+            if (ideMatch) raw = ideMatch[1];
+            else if (cliMatch) raw = cliMatch[1];
+            else if (acpMatch) raw = acpMatch[1];
+
+            if (this._ctx.instanceIdMap?.has(raw)) {
+                return this._ctx.instanceIdMap.get(raw)!;
+            }
+
+            const lastUnderscore = raw.lastIndexOf('_');
+            if (lastUnderscore > 0) return raw.substring(0, lastUnderscore);
+            return raw;
+        }
+        return undefined;
+    }
+
+    setAgentStreamManager(manager: DaemonAgentStreamManager): void {
+        this._agentStream = manager;
+    }
+
+    // ─── Command Dispatcher ──────────────────────────
+
+    async handle(cmd: string, args: any): Promise<CommandResult> {
+        // Per-request: extract target IDE/provider type from args
+        this._currentIdeType = this.extractIdeType(args);
+        this._currentProviderType = args?.agentType || args?.providerType || this._currentIdeType;
+
+        // Commands without ideType CDP silently fail (prevent P2P retry spam)
+        if (!this._currentIdeType && !this._currentProviderType) {
+            const cdpCommands = ['send_chat', 'read_chat', 'list_chats', 'new_chat', 'switch_chat', 'set_mode', 'change_model', 'set_thought_level', 'resolve_action'];
+            if (cdpCommands.includes(cmd)) {
+                return { success: false, error: 'No ideType specified — cannot route command' };
+            }
+        }
+
+        try {
+            return await this.dispatch(cmd, args);
+        } catch (e: any) {
+            LOG.error('Command', `[${cmd}] Unhandled error: ${e?.message || e}`);
+            return { success: false, error: `Internal error: ${e?.message || 'unknown'}` };
+        }
+    }
+
+    private async dispatch(cmd: string, args: any): Promise<CommandResult> {
+        switch (cmd) {
+            // ─── Chat commands (chat-commands.ts) ───────────────
+            case 'read_chat': return Chat.handleReadChat(this, args);
+            case 'chat_history': return Chat.handleChatHistory(this, args);
+            case 'send_chat': return Chat.handleSendChat(this, args);
+            case 'list_chats': return Chat.handleListChats(this, args);
+            case 'new_chat': return Chat.handleNewChat(this, args);
+            case 'switch_chat': return Chat.handleSwitchChat(this, args);
+            case 'set_mode': return Chat.handleSetMode(this, args);
+            case 'change_model': return Chat.handleChangeModel(this, args);
+            case 'set_thought_level': return Chat.handleSetThoughtLevel(this, args);
+            case 'resolve_action': return Chat.handleResolveAction(this, args);
+
+            // ─── CDP commands (cdp-commands.ts) ───────────────
+            case 'cdp_eval': return Cdp.handleCdpEval(this, args);
+            case 'cdp_screenshot':
+            case 'screenshot': return Cdp.handleScreenshot(this, args);
+            case 'cdp_command_exec': return Cdp.handleCdpCommand(this, args);
+            case 'cdp_batch': return Cdp.handleCdpBatch(this, args);
+            case 'cdp_remote_action': return Cdp.handleCdpRemoteAction(this, args);
+            case 'cdp_discover_agents': return Cdp.handleDiscoverAgents(this, args);
+            case 'cdp_dom_dump': return this.domHandlers.handleDomDump(args);
+            case 'cdp_dom_query': return this.domHandlers.handleDomQuery(args);
+            case 'cdp_dom_debug': return this.domHandlers.handleDomDebug(args);
+
+            // ─── File commands (cdp-commands.ts) ──────────────
+            case 'file_read': return Cdp.handleFileRead(this, args);
+            case 'file_write': return Cdp.handleFileWrite(this, args);
+            case 'file_list': return Cdp.handleFileList(this, args);
+            case 'file_list_browse': return Cdp.handleFileListBrowse(this, args);
+
+            // ─── VSCode API commands (not available) ────
+            case 'vscode_command_exec':
+            case 'execute_vscode_command': {
+                const resolvedCmd = args?.commandId || args?.command;
+                if (resolvedCmd === 'adhdev.captureCdpScreenshot') {
+                    return Cdp.handleScreenshot(this, args);
+                }
+                return { success: false, error: `VSCode command not available: ${resolvedCmd || cmd}` };
+            }
+            case 'get_open_editors':
+            case 'open_tab':
+            case 'close_tab':
+            case 'open_folder':
+            case 'open_folder_picker':
+            case 'open_recent':
+            case 'get_commands':
+                return { success: false, error: `${cmd} requires bridge-extension (removed)` };
+            case 'get_recent_workspaces': return this.handleGetRecentWorkspaces(args);
+
+            // ─── Script manage ───────────────────
+            case 'refresh_scripts': return this.handleRefreshScripts(args);
+
+            // ─── Stream commands (stream-commands.ts) ───────────
+            case 'agent_stream_switch': return Stream.handleAgentStreamSwitch(this, args);
+            case 'agent_stream_read': return Stream.handleAgentStreamRead(this, args);
+            case 'agent_stream_send': return Stream.handleAgentStreamSend(this, args);
+            case 'agent_stream_resolve': return Stream.handleAgentStreamResolve(this, args);
+            case 'agent_stream_new': return Stream.handleAgentStreamNew(this, args);
+            case 'agent_stream_list_chats': return Stream.handleAgentStreamListChats(this, args);
+            case 'agent_stream_switch_session': return Stream.handleAgentStreamSwitchSession(this, args);
+            case 'agent_stream_focus': return Stream.handleAgentStreamFocus(this, args);
+
+            // ─── PTY Raw I/O (stream-commands.ts) ─────────
+            case 'pty_input': return Stream.handlePtyInput(this, args);
+            case 'pty_resize': return Stream.handlePtyResize(this, args);
+
+            // ─── Provider Settings (stream-commands.ts) ──────────
+            case 'get_provider_settings': return Stream.handleGetProviderSettings(this, args);
+            case 'set_provider_setting': return Stream.handleSetProviderSetting(this, args);
+
+            // ─── IDE Extension Settings (stream-commands.ts) ──────────
+            case 'get_ide_extensions': return Stream.handleGetIdeExtensions(this, args);
+            case 'set_ide_extension': return Stream.handleSetIdeExtension(this, args);
+
+            // ─── Extension Model / Mode Control (stream-commands.ts) ──────────
+            case 'list_extension_models': return Stream.handleExtensionScript(this, args, 'listModels');
+            case 'set_extension_model': return Stream.handleExtensionScript(this, args, 'setModel');
+            case 'list_extension_modes': return Stream.handleExtensionScript(this, args, 'listModes');
+            case 'set_extension_mode': return Stream.handleExtensionScript(this, args, 'setMode');
+
+            default:
+                return { success: false, error: `Unknown command: ${cmd}` };
+        }
+    }
+
+    // ─── Misc (kept in handler — too small to extract) ───────
+
+    private async handleGetRecentWorkspaces(args: any): Promise<CommandResult> {
+        const config = loadConfig();
+        const cliRecent = config.recentCliWorkspaces || [];
+        return { success: true, result: cliRecent };
+    }
+
+    private async handleRefreshScripts(_args: any): Promise<CommandResult> {
+        if (this._ctx.providerLoader) {
+            this._ctx.providerLoader.reload();
+            return { success: true };
+        }
+        return { success: false, error: 'ProviderLoader not initialized' };
+    }
+}