@adhdev/daemon-core 0.5.3

package/src/commands/router.ts

@@ -0,0 +1,258 @@
+/**
+ * DaemonCommandRouter — Unified command routing for daemon-level commands
+ *
+ * Extracted from cloud daemon's executeDaemonCommand() logic.
+ * Used by both daemon-cloud and daemon-standalone.
+ *
+ * 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 { registerExtensionProviders } from '../cdp/setup.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 { launchWithCdp } from '../launch.js';
+import { detectIDEs } from '../detection/ide-detector.js';
+import { LOG } from '../logging/logger.js';
+import { logCommand } from '../logging/command-log.js';
+import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
+import * as fs from 'fs';
+
+// ─── Types ───
+
+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[] };
+    /** UUID instanceId → CDP manager key mapping */
+    instanceIdMap: Map<string, string>;
+    /** Callback for CDP manager creation after launch_ide (cloud: setupCdpManager, standalone: no-op) */
+    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 (cloud: throttled report) */
+    onPostChatCommand?: () => void;
+    /** Get a connected CDP manager (for agent stream reset check) */
+    getCdpLogFn?: (ideType: string) => (msg: string) => void;
+}
+
+export interface CommandRouterResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+
+// Commands that trigger post-chat status updates
+const CHAT_COMMANDS = [
+    'send_chat', 'new_chat', 'switch_chat', 'set_mode',
+    'change_model', 'agent_stream_send',
+];
+
+export class DaemonCommandRouter {
+    private deps: CommandRouterDeps;
+
+    constructor(deps: CommandRouterDeps) {
+        this.deps = deps;
+    }
+
+    /**
+     * 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.)
+     */
+    async execute(cmd: string, args: any, source: string = 'unknown'): Promise<CommandRouterResult> {
+        const cmdStart = Date.now();
+
+        try {
+            // 1. Try daemon-level command
+            const daemonResult = await this.executeDaemonCommand(cmd, args);
+            if (daemonResult) {
+                logCommand({ ts: new Date().toISOString(), cmd, source: source as any, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
+                return daemonResult;
+            }
+
+            // 2. Delegate to DaemonCommandHandler
+            const handlerResult = await this.deps.commandHandler.handle(cmd, args);
+            logCommand({ ts: new Date().toISOString(), cmd, source: source as any, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
+
+            // 3. Post-chat command callback
+            if (CHAT_COMMANDS.includes(cmd) && this.deps.onPostChatCommand) {
+                this.deps.onPostChatCommand();
+            }
+
+            return handlerResult;
+        } catch (e: any) {
+            logCommand({ ts: new Date().toISOString(), cmd, source: source as any, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
+            throw e;
+        }
+    }
+
+    // ─── Daemon-level command core ───────────────────
+
+    /**
+     * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
+     * Returns null if not handled at this level → caller delegates to CommandHandler.
+     */
+    private async executeDaemonCommand(cmd: string, args: any): Promise<CommandRouterResult | null> {
+        switch (cmd) {
+            // ─── CLI / ACP commands ───
+            case 'launch_cli':
+            case 'stop_cli':
+            case 'agent_command': {
+                return this.deps.cliManager.handleCliCommand(cmd, args);
+            }
+
+            // ─── Logs ───
+            case 'get_logs': {
+                const count = parseInt(args?.count) || parseInt(args?.lines) || 100;
+                const minLevel = args?.minLevel || 'info';
+                const sinceTs = args?.since || 0;
+
+                try {
+                    // Priority 1: ring buffer (fast and structured)
+                    let logs = getRecentLogs(count, minLevel);
+                    if (sinceTs > 0) {
+                        logs = logs.filter((l: any) => l.ts > sinceTs);
+                    }
+                    if (logs.length > 0) {
+                        return { success: true, logs, totalBuffered: logs.length };
+                    }
+                    // Priority 2: file fallback
+                    if (fs.existsSync(LOG_PATH)) {
+                        const content = fs.readFileSync(LOG_PATH, 'utf-8');
+                        const allLines = content.split('\n');
+                        const recent = allLines.slice(-count).join('\n');
+                        return { success: true, logs: recent, totalLines: allLines.length };
+                    }
+                    return { success: true, logs: [], totalBuffered: 0 };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            // ─── restart_session: IDE / CLI / ACP unified ───
+            case 'restart_session': {
+                const targetType = args?.cliType || args?.agentType || args?.ideType;
+                if (!targetType) throw new Error('cliType or ideType required');
+
+                // Check if IDE (in cdpManagers or provider category is ide)
+                const isIde = this.deps.cdpManagers.has(targetType) ||
+                    this.deps.providerLoader.getMeta(targetType)?.category === 'ide';
+
+                if (isIde) {
+                    // IDE restart: stop → launch
+                    await this.stopIde(targetType);
+                    const launchResult = await this.executeDaemonCommand('launch_ide', { ideType: targetType, enableCdp: true });
+                    return { success: true, restarted: true, ideType: targetType, launch: launchResult };
+                }
+
+                // CLI/ACP restart: delegate to CliManager
+                return this.deps.cliManager.handleCliCommand(cmd, args);
+            }
+
+            // ─── IDE stop ───
+            case 'stop_ide': {
+                const ideType = args?.ideType;
+                if (!ideType) throw new Error('ideType required');
+                await this.stopIde(ideType);
+                return { success: true, ideType, stopped: true };
+            }
+
+            // ─── IDE restart ───
+            case 'restart_ide': {
+                const ideType = args?.ideType;
+                if (!ideType) throw new Error('ideType required');
+                await this.stopIde(ideType);
+                const launchResult = await this.executeDaemonCommand('launch_ide', { ideType, enableCdp: true });
+                return { success: true, ideType, restarted: true, launch: launchResult };
+            }
+
+            // ─── IDE launch + CDP connect ───
+            case 'launch_ide': {
+                const launchArgs = { ...args, ideId: args?.ideId || args?.ideType };
+                const ideKey = launchArgs.ideId;
+                LOG.info('LaunchIDE', `target=${ideKey || 'auto'}`);
+                const result = await launchWithCdp(launchArgs);
+
+                if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
+                    const logFn = this.deps.getCdpLogFn
+                        ? this.deps.getCdpLogFn(result.ideId)
+                        : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
+                    const provider = this.deps.providerLoader.getMeta(result.ideId);
+                    const manager = new DaemonCdpManager(result.port, logFn, undefined, (provider as any)?.targetFilter);
+                    const connected = await manager.connect();
+                    if (connected) {
+                        // Register active extension providers for this IDE in CDP manager
+                        registerExtensionProviders(this.deps.providerLoader, manager, result.ideId);
+                        this.deps.cdpManagers.set(result.ideId, manager);
+                        LOG.info('CDP', `Connected: ${result.ideId} (port ${result.port})`);
+                        LOG.info('CDP', `${this.deps.cdpManagers.size} IDE(s) connected`);
+
+                        // Notify consumer (cloud: setupCdpManager, standalone: setupIdeInstance)
+                        this.deps.onCdpManagerCreated?.(result.ideId, manager);
+                    }
+                }
+                this.deps.onIdeConnected?.();
+                return { success: result.success, ...result as any };
+            }
+
+            // ─── IDE detection ───
+            case 'detect_ides': {
+                this.deps.detectedIdes.value = await detectIDEs();
+                return { success: true, ides: this.deps.detectedIdes.value };
+            }
+        }
+
+        return null; // Not handled at this level → delegate to CommandHandler
+    }
+
+    /**
+     * IDE stop: CDP disconnect + remove from InstanceManager + clean instanceIdMap
+     */
+    private async stopIde(ideType: string): Promise<void> {
+        // 1. Release CDP manager
+        const cdp = this.deps.cdpManagers.get(ideType);
+        if (cdp) {
+            try { cdp.disconnect(); } catch { /* noop */ }
+            this.deps.cdpManagers.delete(ideType);
+            LOG.info('StopIDE', `CDP disconnected: ${ideType}`);
+        }
+
+        // 2. Remove IDE instance from InstanceManager
+        const instanceKey = `ide:${ideType}`;
+        const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
+        if (ideInstance) {
+            // Remove IDE and child Extension UUIDs from instanceIdMap
+            if (ideInstance.getInstanceId) {
+                this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
+            }
+            if (ideInstance.getExtensionInstances) {
+                for (const ext of ideInstance.getExtensionInstances()) {
+                    if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
+                }
+            }
+            this.deps.instanceManager.removeInstance(instanceKey);
+            LOG.info('StopIDE', `Instance removed: ${instanceKey}`);
+        }
+
+        // 3. Notify consumer for status update
+        this.deps.onStatusChange?.();
+        LOG.info('StopIDE', `IDE stopped: ${ideType}`);
+    }
+}

package/src/commands/stream-commands.ts

@@ -0,0 +1,325 @@
+/**
+ * Stream Commands — Agent Stream, PTY I/O, Provider Settings,
+ *                   IDE Extension Settings, Extension Script Execution
+ */
+
+import type { CommandResult, CommandHelpers } from './handler.js';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import { loadConfig } from '../config/config.js';
+import { LOG } from '../logging/logger.js';
+
+// ─── Agent Stream commands ───────────────────────
+
+export async function handleAgentStreamSwitch(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const agentType = args?.agentType || args?.agent || null;
+    await h.agentStream.switchActiveAgent(h.getCdp()!, agentType);
+    return { success: true, activeAgent: agentType };
+}
+
+export async function handleAgentStreamRead(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const streams = await h.agentStream.collectAgentStreams(h.getCdp()!);
+    return { success: true, streams };
+}
+
+export async function handleAgentStreamSend(h: CommandHelpers, args: any): Promise<CommandResult> {
+    const agentType = args?.agentType || args?.agent;
+    const text = args?.text || args?.message;
+    if (!text) return { success: false, error: 'text required' };
+
+    // CLI adapter routing
+    if (agentType && h.ctx.adapters) {
+        for (const [key, adapter] of h.ctx.adapters.entries()) {
+            if (adapter.cliType === agentType || key.includes(agentType)) {
+                LOG.info('Command', `[agent_stream_send] Routing to CLI adapter: ${adapter.cliType}`);
+                try {
+                    await adapter.sendMessage(text);
+                    return { success: true, sent: true, targetAgent: adapter.cliType };
+                } catch (e: any) {
+                    LOG.info('Command', `[agent_stream_send] CLI adapter failed: ${e.message}`);
+                    return { success: false, error: `CLI send failed: ${e.message}` };
+                }
+            }
+        }
+    }
+
+    // CDP-based IDE agent routing
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const resolvedAgent = agentType || h.agentStream.activeAgentType;
+    if (!resolvedAgent) return { success: false, error: 'agentType required' };
+    const ok = await h.agentStream.sendToAgent(h.getCdp()!, resolvedAgent, text, h.currentIdeType);
+    return { success: ok };
+}
+
+export async function handleAgentStreamResolve(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+    const action = args?.action as 'approve' | 'reject' || 'approve';
+    if (!agentType) return { success: false, error: 'agentType required' };
+    const ok = await h.agentStream.resolveAgentAction(h.getCdp()!, agentType, action, h.currentIdeType);
+    return { success: ok };
+}
+
+export async function handleAgentStreamNew(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+    if (!agentType) return { success: false, error: 'agentType required' };
+    const ok = await h.agentStream.newAgentSession(h.getCdp()!, agentType, h.currentIdeType);
+    return { success: ok };
+}
+
+export async function handleAgentStreamListChats(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+    if (!agentType) return { success: false, error: 'agentType required' };
+    const chats = await h.agentStream.listAgentChats(h.getCdp()!, agentType);
+    return { success: true, chats };
+}
+
+export async function handleAgentStreamSwitchSession(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+    const sessionId = args?.sessionId || args?.id;
+    if (!agentType || !sessionId) return { success: false, error: 'agentType and sessionId required' };
+    const ok = await h.agentStream.switchAgentSession(h.getCdp()!, agentType, sessionId);
+    return { success: ok };
+}
+
+export async function handleAgentStreamFocus(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
+    const agentType = args?.agentType || args?.agent || h.agentStream.activeAgentType;
+    if (!agentType) return { success: false, error: 'agentType required' };
+    await h.agentStream.ensureAgentPanelOpen(agentType, h.currentIdeType);
+    const ok = await h.agentStream.focusAgentEditor(h.getCdp()!, agentType);
+    return { success: ok };
+}
+
+// ─── PTY Raw I/O ──────────────────────────────────
+
+export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
+    const { cliType, data } = args || {};
+    if (!data) return { success: false, error: 'data required' };
+
+    if (h.ctx.adapters) {
+        const targetCli = cliType || '';
+        if (!targetCli && h.ctx.adapters.size > 0) {
+            const first = h.ctx.adapters.values().next().value;
+            if (first && typeof first.writeRaw === 'function') {
+                first.writeRaw(data);
+                return { success: true };
+            }
+        }
+        const directAdapter = h.ctx.adapters.get(targetCli);
+        if (directAdapter && typeof directAdapter.writeRaw === 'function') {
+            directAdapter.writeRaw(data);
+            return { success: true };
+        }
+        for (const [, adapter] of h.ctx.adapters) {
+            if (adapter.cliType === targetCli && typeof adapter.writeRaw === 'function') {
+                adapter.writeRaw(data);
+                return { success: true };
+            }
+        }
+        for (const [key, adapter] of h.ctx.adapters) {
+            if ((key.startsWith(targetCli) || targetCli.startsWith(adapter.cliType)) && typeof adapter.writeRaw === 'function') {
+                adapter.writeRaw(data);
+                return { success: true };
+            }
+        }
+    }
+    return { success: false, error: `CLI adapter not found: ${cliType}` };
+}
+
+export function handlePtyResize(h: CommandHelpers, args: any): CommandResult {
+    const { cliType, cols, rows, force } = args || {};
+    if (!cols || !rows) return { success: false, error: 'cols and rows required' };
+
+    if (h.ctx.adapters) {
+        const targetCli = cliType || '';
+        if (!targetCli && h.ctx.adapters.size > 0) {
+            const first = h.ctx.adapters.values().next().value;
+            if (first && typeof first.resize === 'function') {
+                if (force) { first.resize(cols - 1, rows); setTimeout(() => first.resize(cols, rows), 50); }
+                else { first.resize(cols, rows); }
+                return { success: true };
+            }
+        }
+        const directAdapter = h.ctx.adapters.get(targetCli);
+        if (directAdapter && typeof directAdapter.resize === 'function') {
+            if (force) {
+                directAdapter.resize(cols - 1, rows);
+                setTimeout(() => directAdapter.resize(cols, rows), 50);
+            } else {
+                directAdapter.resize(cols, rows);
+            }
+            return { success: true };
+        }
+        for (const [key, adapter] of h.ctx.adapters) {
+            if ((adapter.cliType === targetCli || key.startsWith(targetCli) || targetCli.startsWith(adapter.cliType)) && typeof adapter.resize === 'function') {
+                if (force) {
+                    adapter.resize(cols - 1, rows);
+                    setTimeout(() => adapter.resize(cols, rows), 50);
+                } else {
+                    adapter.resize(cols, rows);
+                }
+                return { success: true };
+            }
+        }
+    }
+    return { success: false, error: `CLI adapter not found: ${cliType}` };
+}
+
+// ─── Provider Settings ────────────────────────
+
+export function handleGetProviderSettings(h: CommandHelpers, args: any): CommandResult {
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    const { providerType } = args || {};
+    if (providerType) {
+        const schema = loader?.getPublicSettings(providerType) || [];
+        const values = loader?.getSettings(providerType) || {};
+        return { success: true, providerType, schema, values };
+    }
+    const allSettings = loader?.getAllPublicSettings() || {};
+    const allValues: Record<string, any> = {};
+    for (const type of Object.keys(allSettings)) {
+        allValues[type] = loader?.getSettings(type) || {};
+    }
+    return { success: true, settings: allSettings, values: allValues };
+}
+
+export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandResult {
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    const { providerType, key, value } = args || {};
+    if (!providerType || !key || value === undefined) {
+        return { success: false, error: 'providerType, key, and value are required' };
+    }
+    const result = loader?.setSetting(providerType, key, value);
+    if (result) {
+        if (h.ctx.instanceManager) {
+            const allSettings = loader?.getSettings(providerType) || {};
+            const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
+            LOG.info('Command', `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} → ${updated} instance(s) updated`);
+        }
+        return { success: true, providerType, key, value };
+    }
+    return { success: false, error: `Failed to set ${providerType}.${key} — invalid key, value, or not a public setting` };
+}
+
+// ─── Extension Script Execution (Model/Mode) ─────
+
+export async function handleExtensionScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult> {
+    const { agentType, ideType } = args || {};
+    LOG.info('Command', `[ExtScript] ${scriptName} agentType=${agentType} ideType=${ideType} _currentIdeType=${h.currentIdeType}`);
+    if (!agentType) return { success: false, error: 'agentType is required' };
+
+    const loader = h.ctx.providerLoader;
+    if (!loader) return { success: false, error: 'ProviderLoader not initialized' };
+    const provider = loader.resolve(agentType);
+    if (!provider) return { success: false, error: `Provider not found: ${agentType}` };
+
+    const webviewScriptName = `webview${scriptName.charAt(0).toUpperCase() + scriptName.slice(1)}`;
+    const hasWebviewScript = provider.category === 'ide' &&
+        !!provider.scripts?.[webviewScriptName];
+
+    const actualScriptName = hasWebviewScript ? webviewScriptName : scriptName;
+
+    if (!provider.scripts?.[actualScriptName as keyof typeof provider.scripts]) {
+        return { success: false, error: `Script '${actualScriptName}' not available for ${agentType}` };
+    }
+
+    const scriptFn = provider.scripts[actualScriptName as keyof typeof provider.scripts] as Function;
+    const scriptCode = scriptFn(args);
+    if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
+
+    const cdpKey = provider.category === 'ide' ? (h.currentIdeType || agentType) : (h.currentIdeType || ideType);
+    LOG.info('Command', `[ExtScript] provider=${provider.type} category=${provider.category} cdpKey=${cdpKey}`);
+    const cdp = h.getCdp(cdpKey);
+    if (!cdp?.isConnected) return { success: false, error: `No CDP connection for ${cdpKey || 'any'}` };
+
+    try {
+        let result: unknown;
+
+        if (provider.category === 'extension') {
+            const sessions = cdp.getAgentSessions();
+            let targetSessionId: string | null = null;
+            for (const [sessionId, target] of sessions) {
+                if (target.agentType === agentType) {
+                    targetSessionId = sessionId;
+                    break;
+                }
+            }
+            if (!targetSessionId) {
+                return { success: false, error: `No active session found for ${agentType}` };
+            }
+            result = await cdp.evaluateInSession(targetSessionId, scriptCode);
+        } else if (hasWebviewScript && cdp.evaluateInWebviewFrame) {
+            const matchText = provider.webviewMatchText;
+            const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
+            result = await cdp.evaluateInWebviewFrame(scriptCode, matchFn);
+        } else {
+            result = await cdp.evaluate(scriptCode, 30000);
+        }
+
+        if (typeof result === 'string') {
+            try {
+                const parsed = JSON.parse(result);
+                return { success: true, ...parsed };
+            } catch {
+                return { success: true, result };
+            }
+        }
+        return { success: true, result };
+    } catch (e: any) {
+        return { success: false, error: `Script execution failed: ${e.message}` };
+    }
+}
+
+// ─── IDE Extension Settings (per-IDE on/off) ─────
+
+export function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandResult {
+    const { ideType } = args || {};
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    if (!loader) return { success: false, error: 'ProviderLoader not initialized' };
+
+    const allExtProviders = loader.getByCategory?.('extension') || [];
+    const config = loadConfig();
+
+    if (ideType) {
+        const extensions = allExtProviders.map(p => ({
+            type: p.type,
+            name: p.name,
+            extensionId: p.extensionId,
+            enabled: config.ideSettings?.[ideType]?.extensions?.[p.type]?.enabled === true,
+        }));
+        return { success: true, ideType, extensions };
+    }
+
+    const connectedIdes = [...(h.ctx.cdpManagers?.keys?.() || [])];
+    const result: Record<string, any[]> = {};
+    for (const ide of connectedIdes) {
+        result[ide] = allExtProviders.map(p => ({
+            type: p.type,
+            name: p.name,
+            extensionId: p.extensionId,
+            enabled: config.ideSettings?.[ide]?.extensions?.[p.type]?.enabled === true,
+        }));
+    }
+    return { success: true, ides: result };
+}
+
+export function handleSetIdeExtension(h: CommandHelpers, args: any): CommandResult {
+    const { ideType, extensionType, enabled } = args || {};
+    if (!ideType || !extensionType || enabled === undefined) {
+        return { success: false, error: 'ideType, extensionType, and enabled are required' };
+    }
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    if (!loader?.setIdeExtensionEnabled) {
+        return { success: false, error: 'ProviderLoader not initialized' };
+    }
+    const ok = loader.setIdeExtensionEnabled(ideType, extensionType, !!enabled);
+    if (ok) {
+        return { success: true, ideType, extensionType, enabled: !!enabled };
+    }
+    return { success: false, error: 'Failed to save setting' };
+}