@adhdev/daemon-core 0.5.3

package/src/agent-stream/provider-adapter.ts

@@ -0,0 +1,138 @@
+/**
+ * ProviderStreamAdapter — generic Extension adapter based on provider.js
+ * 
+ * Consolidates ClineAdapter, RooCodeAdapter, ContinueAdapter.
+ * Auto-configured using provider.js scripts + metadata.
+ */
+
+import type {
+    IAgentStreamAdapter,
+    AgentStreamState,
+    AgentChatListItem,
+    AgentEvaluateFn,
+} from './types.js';
+import type { ProviderModule } from '../providers/contracts.js';
+
+export class ProviderStreamAdapter implements IAgentStreamAdapter {
+    readonly agentType: string;
+    readonly agentName: string;
+    readonly extensionId: string;
+    readonly extensionIdPattern: RegExp;
+    private provider: ProviderModule;
+    private lastSuccessState: AgentStreamState | null = null;
+
+    constructor(provider: ProviderModule) {
+        this.provider = provider;
+        this.agentType = provider.type;
+        this.agentName = provider.displayName || provider.name;
+        this.extensionId = provider.extensionId || provider.type;
+        this.extensionIdPattern = provider.extensionIdPattern
+            || new RegExp(`extensionId=${this.extensionId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'i');
+    }
+
+    private callScript(name: string, ...args: any[]): string | null {
+        const fn = (this.provider.scripts as any)?.[name];
+        if (typeof fn !== 'function') return null;
+        return fn(...args) || null;
+    }
+
+    private hasScript(name: string): boolean {
+        return typeof (this.provider.scripts as any)?.[name] === 'function';
+    }
+
+    async readChat(evaluate: AgentEvaluateFn): Promise<AgentStreamState> {
+        const script = this.callScript('readChat');
+        if (!script) return this.errorState('readChat script not available');
+
+        try {
+            const raw = await evaluate(script) as string;
+            const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            if (data?.error) {
+                const state = this.errorState(data.error);
+                if (this.lastSuccessState?.messages?.length) {
+                    state.messages = this.lastSuccessState.messages;
+                }
+                return state;
+            }
+            const state: AgentStreamState = {
+                agentType: this.agentType,
+                agentName: this.agentName,
+                extensionId: this.extensionId,
+                status: data.status || 'idle',
+                messages: data.messages || [],
+                inputContent: data.inputContent || '',
+                model: data.model,
+                activeModal: data.activeModal,
+            };
+            if (state.messages.length > 0) {
+                this.lastSuccessState = state;
+            }
+            return state;
+        } catch {
+            const state = this.errorState(`Failed to parse ${this.agentName} state`);
+            if (this.lastSuccessState?.messages?.length) {
+                state.messages = this.lastSuccessState.messages;
+            }
+            return state;
+        }
+    }
+
+    async sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void> {
+        const script = this.callScript('sendMessage', text);
+        if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
+        const result = await evaluate(script) as string;
+        if (result && typeof result === 'string' && result.startsWith('error:')) {
+            throw new Error(`[${this.agentName}] sendMessage failed: ${result}`);
+        }
+    }
+
+    async resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean> {
+        const script = this.callScript('resolveAction', { action, button });
+        if (!script) return false; // Not supported if provider has no resolveAction
+        return (await evaluate(script)) === true;
+    }
+
+    async newSession(evaluate: AgentEvaluateFn): Promise<void> {
+        const script = this.callScript('newSession');
+        if (!script) throw new Error(`[${this.agentName}] newSession script not available`);
+        const result = await evaluate(script) as string;
+        if (result && typeof result === 'string' && result.startsWith('error:')) {
+            throw new Error(`[${this.agentName}] newSession failed: ${result}`);
+        }
+        this.lastSuccessState = null;
+    }
+
+    async listChats(evaluate: AgentEvaluateFn): Promise<AgentChatListItem[]> {
+        const script = this.callScript('listSessions');
+        if (!script) return [];
+        try {
+            const raw = await evaluate(script, 10000) as string;
+            const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            if (data?.error) return [];
+            return Array.isArray(data) ? data : [];
+        } catch { return []; }
+    }
+
+    async switchSession(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean> {
+        const script = this.callScript('switchSession', sessionId);
+        if (!script) return false;
+        return (await evaluate(script, 10000)) === true;
+    }
+
+    async focusEditor(evaluate: AgentEvaluateFn): Promise<void> {
+        const script = this.callScript('focusEditor');
+        if (!script) return;
+        await evaluate(script);
+    }
+
+    private errorState(message: string): AgentStreamState {
+        return {
+            agentType: this.agentType,
+            agentName: this.agentName,
+            extensionId: this.extensionId,
+            status: 'error',
+            messages: [],
+            inputContent: '',
+        };
+    }
+}

package/src/agent-stream/types.ts

@@ -0,0 +1,61 @@
+/**
+ * Agent Stream Types — ported for Daemon (identical to original)
+ * 
+ * Agent stream types.
+ * No vscode dependency — can be used as-is.
+ */
+
+/** Agent chat message */
+export interface AgentChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: number;
+}
+
+/** Agent chat history item */
+export interface AgentChatListItem {
+    title: string;
+    id: string;
+    status?: string;
+    time?: string;
+    cost?: string;
+}
+
+/** Agent stream status */
+export interface AgentStreamState {
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    status: 'idle' | 'streaming' | 'waiting_approval' | 'error' | 'disconnected' | 'panel_hidden' | 'not_monitored';
+    messages: AgentChatMessage[];
+    inputContent: string;
+    model?: string;
+    activeModal?: { message: string; buttons: string[] };
+}
+
+/** Agent webview target info */
+export interface AgentWebviewTarget {
+    targetId: string;
+    extensionId: string;
+    agentType: string;
+    url: string;
+}
+
+/** Agent stream adapter interface */
+export interface IAgentStreamAdapter {
+    readonly agentType: string;
+    readonly agentName: string;
+    readonly extensionId: string;
+    readonly extensionIdPattern: RegExp;
+
+    readChat(evaluate: AgentEvaluateFn): Promise<AgentStreamState>;
+    sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void>;
+    resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean>;
+    newSession(evaluate: AgentEvaluateFn): Promise<void>;
+    listChats?(evaluate: AgentEvaluateFn): Promise<AgentChatListItem[]>;
+    switchSession?(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean>;
+    focusEditor?(evaluate: AgentEvaluateFn): Promise<void>;
+    setProvider?(provider: any): void;
+}
+
+export type AgentEvaluateFn = (expression: string, timeoutMs?: number) => Promise<unknown>;

package/src/boot/daemon-lifecycle.ts

@@ -0,0 +1,252 @@
+/**
+ * Daemon Lifecycle — Shared init + shutdown for cloud/standalone
+ *
+ * initDaemonComponents(): Creates all core daemon components in correct order.
+ * shutdownDaemonComponents(): Graceful shutdown of all components.
+ *
+ * Transport-specific setup (ServerConnection, P2P, HTTP/WS) remains in each daemon.
+ */
+
+import { DaemonCdpManager } from '../cdp/manager.js';
+import { DaemonCdpInitializer, type CdpInitializerConfig } from '../cdp/initializer.js';
+import { setupIdeInstance, type CdpSetupContext } from '../cdp/setup.js';
+import { DaemonCommandHandler } from '../commands/handler.js';
+import { DaemonCommandRouter, type CommandRouterDeps } from '../commands/router.js';
+import { DaemonCliManager } from '../commands/cli-manager.js';
+import { DaemonAgentStreamManager } from '../agent-stream/manager.js';
+import { AgentStreamPoller } from '../agent-stream/poller.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { detectIDEs } from '../detection/ide-detector.js';
+import { installGlobalInterceptor, LOG } from '../logging/logger.js';
+import { loadConfig } from '../config/config.js';
+
+// ─── Init Config ───
+
+export interface DaemonInitConfig {
+    /** ProviderLoader log function */
+    providerLogFn?: (msg: string) => void;
+
+    /** CLI Manager deps (transport-specific) */
+    cliManagerDeps: {
+        getServerConn: () => any;
+        getP2p: () => any;
+        onStatusChange: () => void;
+        removeAgentTracking: (key: string) => void;
+    };
+
+    /** CDP config */
+    enabledIdes?: string[];
+
+    /** Router transport-specific callbacks */
+    onStatusChange?: () => void;
+    onPostChatCommand?: () => void;
+    getCdpLogFn?: (ideType: string) => (msg: string) => void;
+
+    /** Additional callback after CDP manager created (transport-specific extras) */
+    onCdpManagerSetup?: (ideType: string, manager: DaemonCdpManager, managerKey: string) => void | Promise<void>;
+
+    /** Poller callback (transport-specific) */
+    onStreamsUpdated?: (ideType: string, streams: any[]) => void;
+
+    /** Instance ticking interval (ms), default 5000 */
+    tickIntervalMs?: number;
+
+    /** CDP scan interval (ms), default 30000 */
+    cdpScanIntervalMs?: number;
+}
+
+// ─── Result ───
+
+export interface DaemonComponents {
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cliManager: DaemonCliManager;
+    commandHandler: DaemonCommandHandler;
+    agentStreamManager: DaemonAgentStreamManager;
+    router: DaemonCommandRouter;
+    poller: AgentStreamPoller;
+    cdpInitializer: DaemonCdpInitializer;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    instanceIdMap: Map<string, string>;
+    detectedIdes: { value: any[] };
+}
+
+// ─── Init ───
+
+/**
+ * Initialize all daemon core components.
+ * Shared by both cloud and standalone daemons.
+ *
+ * Order:
+ *   1. Global log interceptor
+ *   2. ProviderLoader
+ *   3. InstanceManager + CliManager
+ *   4. Detect IDEs
+ *   5. CdpInitializer → connectAll + periodic scan + discovery
+ *   6. CommandHandler + AgentStreamManager
+ *   7. Router + Poller
+ *   8. Start instance ticking
+ */
+export async function initDaemonComponents(config: DaemonInitConfig): Promise<DaemonComponents> {
+    // 1. Global log interceptor
+    installGlobalInterceptor();
+
+    // 2. ProviderLoader
+    const providerLoader = new ProviderLoader({
+        logFn: config.providerLogFn,
+    });
+    providerLoader.loadAll();
+    providerLoader.registerToDetector();
+
+    // 3. Shared state
+    const instanceManager = new ProviderInstanceManager();
+    const cdpManagers = new Map<string, DaemonCdpManager>();
+    const instanceIdMap = new Map<string, string>();
+    const detectedIdesRef = { value: [] as any[] };
+
+    // 4. CLI Manager
+    const cliManager = new DaemonCliManager({
+        ...config.cliManagerDeps,
+        getInstanceManager: () => instanceManager,
+    }, providerLoader);
+
+    // 5. Detect IDEs
+    LOG.info('Init', 'Detecting IDEs...');
+    detectedIdesRef.value = await detectIDEs();
+    const installed = detectedIdesRef.value.filter((i: any) => i.installed);
+    LOG.info('Init', `Found ${installed.length} IDE(s): ${installed.map((i: any) => i.id).join(', ') || 'none'}`);
+
+    // 6. CDP Initializer — connect + register instances
+    const cdpSetupContext: CdpSetupContext = {
+        providerLoader,
+        instanceManager,
+        cdpManagers,
+        instanceIdMap,
+    };
+
+    const cdpInitializer = new DaemonCdpInitializer({
+        providerLoader,
+        cdpManagers,
+        enabledIdes: config.enabledIdes || loadConfig().enabledIdes || undefined,
+        onConnected: async (ideType, manager, managerKey) => {
+            // Register IDE instance (shared logic)
+            await setupIdeInstance(cdpSetupContext, { ideType, manager, managerKey });
+            // Transport-specific extras
+            await config.onCdpManagerSetup?.(ideType, manager, managerKey);
+        },
+    });
+    await cdpInitializer.connectAll(detectedIdesRef.value);
+    cdpInitializer.startPeriodicScan(config.cdpScanIntervalMs ?? 30_000);
+    cdpInitializer.startDiscovery(30_000);
+
+    // 7. CommandHandler
+    const commandHandler = new DaemonCommandHandler({
+        cdpManagers,
+        ideType: 'unknown',
+        adapters: cliManager.adapters,
+        providerLoader,
+        instanceManager,
+        instanceIdMap,
+    });
+
+    // 8. AgentStreamManager
+    const agentStreamManager = new DaemonAgentStreamManager(
+        LOG.forComponent('AgentStream').asLogFn(),
+        providerLoader,
+    );
+    commandHandler.setAgentStreamManager(agentStreamManager);
+
+    // 9. Router + Poller (with internal cross-wiring)
+    // Note: poller is declared first so router's onIdeConnected closure captures it
+    let poller: AgentStreamPoller;
+
+    const router = new DaemonCommandRouter({
+        commandHandler,
+        cliManager,
+        cdpManagers,
+        providerLoader,
+        instanceManager,
+        detectedIdes: detectedIdesRef,
+        instanceIdMap,
+        onCdpManagerCreated: async (ideType: string, manager: DaemonCdpManager) => {
+            // For launch_ide: register instance + extension providers
+            await setupIdeInstance(cdpSetupContext, { ideType, manager });
+            await config.onCdpManagerSetup?.(ideType, manager, ideType);
+        },
+        onIdeConnected: () => poller?.start(),
+        onStatusChange: config.onStatusChange,
+        onPostChatCommand: config.onPostChatCommand,
+        getCdpLogFn: config.getCdpLogFn || ((ideType: string) => LOG.forComponent(`CDP:${ideType}`).asLogFn()),
+    });
+
+    poller = new AgentStreamPoller({
+        agentStreamManager,
+        providerLoader,
+        instanceManager,
+        cdpManagers,
+        onStreamsUpdated: config.onStreamsUpdated,
+    });
+    poller.start();
+
+    // 10. Start instance ticking
+    instanceManager.startTicking(config.tickIntervalMs ?? 5_000);
+
+    return {
+        providerLoader,
+        instanceManager,
+        cliManager,
+        commandHandler,
+        agentStreamManager,
+        router,
+        poller,
+        cdpInitializer,
+        cdpManagers,
+        instanceIdMap,
+        detectedIdes: detectedIdesRef,
+    };
+}
+
+// ─── Shutdown ───
+
+/**
+ * Graceful shutdown of all daemon components.
+ * Shared by both cloud and standalone daemons.
+ *
+ * Order:
+ *   1. Stop timers (poller, cdpInitializer)
+ *   2. Dispose agent stream
+ *   3. Shutdown CLIs
+ *   4. Dispose instances
+ *   5. Disconnect CDPs
+ */
+export async function shutdownDaemonComponents(components: DaemonComponents): Promise<void> {
+    const {
+        poller, cdpInitializer, agentStreamManager,
+        cliManager, instanceManager, cdpManagers,
+    } = components;
+
+    // 1. Stop timers
+    poller.stop();
+    cdpInitializer.stop();
+
+    // 2. Dispose agent stream
+    try {
+        const anyCdp = [...cdpManagers.values()].find(m => m.isConnected);
+        if (agentStreamManager && anyCdp) {
+            await agentStreamManager.dispose(anyCdp);
+        }
+    } catch (e: any) { LOG.warn('Shutdown', `AgentStream dispose: ${e?.message}`); }
+
+    // 3. Shutdown CLIs
+    try { await cliManager.shutdownAll(); } catch { /* noop */ }
+
+    // 4. Dispose instances
+    try { instanceManager.disposeAll(); } catch { /* noop */ }
+
+    // 5. Disconnect CDPs
+    for (const m of cdpManagers.values()) {
+        try { m.disconnect(); } catch { /* noop */ }
+    }
+    cdpManagers.clear();
+}