@adhdev/daemon-core 0.5.3

package/src/providers/ide-provider-instance.ts

@@ -0,0 +1,377 @@
+/**
+ * IdeProviderInstance — Runtime instance for IDE Provider
+ *
+ * Within a single IDE:
+ * 1. Native chat (readChat via CDP)
+ * 2. Extension agents (Cline, Roo Code etc)
+ *
+ * IDE Instance manages child Extension Instances.
+ * Daemon collects all via a single IDE Instance.getState() call.
+ */
+
+import * as os from 'os';
+import * as crypto from 'crypto';
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import { ExtensionProviderInstance } from './extension-provider-instance.js';
+import { StatusMonitor } from './status-monitor.js';
+import { ChatHistoryWriter } from '../config/chat-history.js';
+import { LOG } from '../logging/logger.js';
+
+export class IdeProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category = 'ide' as const;
+
+    private provider: ProviderModule;
+    private context: InstanceContext | null = null;
+    private settings: Record<string, any> = {};
+    private events: ProviderEvent[] = [];
+    private tickErrorCount = 0;
+
+ // Cached status
+    private cachedChat: any = null;
+    private currentStatus: string = 'idle';
+    private lastAgentStatuses = new Map<string, string>();
+    private generatingStartedAt = new Map<string, number>();
+    private tickBusy = false;
+    private monitor: StatusMonitor;
+    private historyWriter: ChatHistoryWriter;
+
+ // IDE meta
+    private ideVersion: string = '';
+    private instanceId: string;
+    private workspaceFolders: { name: string; path: string }[] = [];
+    private activeFile: string | null = null;
+
+ // ─── Child Extension Instances ────────────────────
+    private extensions = new Map<string, ExtensionProviderInstance>();
+
+    constructor(provider: ProviderModule, instanceKey?: string) {
+ // type always base provider type (e.g. 'antigravity') — display/script queryin use
+        this.type = provider.type;
+        this.provider = provider;
+ // instanceId UUID — unique identifier for all routing
+        this.instanceId = crypto.randomUUID();
+        this.monitor = new StatusMonitor();
+        this.historyWriter = new ChatHistoryWriter();
+    }
+
+ // ─── Lifecycle ─────────────────────────────────
+
+    async init(context: InstanceContext): Promise<void> {
+        this.context = context;
+        this.settings = context.settings || {};
+ // Sync Monitor config
+        this.monitor.updateConfig({
+            approvalAlert: this.settings.approvalAlert !== false,
+            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
+            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+        });
+    }
+
+    async onTick(): Promise<void> {
+        if (!this.context?.cdp?.isConnected || this.tickBusy) return;
+        this.tickBusy = true;
+
+        try {
+ // 1. Native chat read
+            await this.readChat();
+
+ // 2. Child Extension tick
+            for (const [id, ext] of this.extensions) {
+                try {
+                    await ext.onTick();
+                } catch (e: any) {
+                    LOG.warn('IdeInstance', `[IdeInstance:${this.type}] Extension ${id} tick error: ${e?.message}`);
+                }
+            }
+
+            this.tickErrorCount = 0;
+        } catch (e: any) {
+            this.tickErrorCount++;
+            if (this.tickErrorCount <= 3 || this.tickErrorCount % 10 === 0) {
+                LOG.warn('IdeInstance', `[IdeInstance:${this.type}] onTick error (${this.tickErrorCount}): ${e?.message || e}`);
+            }
+        } finally {
+            this.tickBusy = false;
+        }
+    }
+
+    getState(): ProviderState {
+        const cdp = this.context?.cdp;
+
+ // Collect extension status
+        const extensionStates: ProviderState[] = [];
+        for (const ext of this.extensions.values()) {
+            extensionStates.push(ext.getState());
+        }
+
+        return {
+            type: this.type,
+            name: this.provider.name,
+            category: 'ide',
+            status: this.currentStatus as ProviderState['status'],
+            activeChat: this.cachedChat ? {
+                id: this.cachedChat.id || 'active_session',
+                title: this.cachedChat.title || this.type,
+                status: this.cachedChat.status || this.currentStatus,
+                messages: this.cachedChat.messages || [],
+                activeModal: this.cachedChat.activeModal || null,
+                inputContent: this.cachedChat.inputContent || '',
+            } : null,
+            workspaceFolders: this.workspaceFolders,
+            activeFile: this.activeFile,
+            extensions: extensionStates,
+            cdpConnected: cdp?.isConnected || false,
+            currentModel: this.cachedChat?.model || undefined,
+            currentPlan: this.cachedChat?.mode || undefined,
+            currentAutoApprove: this.cachedChat?.autoApprove || undefined,
+            instanceId: this.instanceId,
+            lastUpdated: Date.now(),
+            settings: this.settings,
+            pendingEvents: this.flushEvents(),
+        };
+    }
+
+    onEvent(event: string, data?: any): void {
+        if (event === 'cdp_connected') {
+ // CDP connectiondone
+        } else if (event === 'cdp_disconnected') {
+            this.cachedChat = null;
+            this.currentStatus = 'idle';
+        } else if (event === 'extension_data') {
+            if (data?.workspaceFolders) this.workspaceFolders = data.workspaceFolders;
+            if (data?.activeFile) this.activeFile = data.activeFile;
+            if (data?.ideVersion) this.ideVersion = data.ideVersion;
+            if (data?.instanceId) this.instanceId = data.instanceId;
+        } else if (event === 'stream_update') {
+ // Forward to Extension
+            const extType = data?.extensionType;
+            if (extType && this.extensions.has(extType)) {
+                this.extensions.get(extType)!.onEvent('stream_update', data);
+            }
+        }
+    }
+
+    dispose(): void {
+        this.cachedChat = null;
+        this.lastAgentStatuses.clear();
+        this.generatingStartedAt.clear();
+        this.monitor.reset();
+ // Child Extension cleanup
+        for (const ext of this.extensions.values()) {
+            ext.dispose();
+        }
+        this.extensions.clear();
+    }
+
+ // ─── Extension manage ─────────────────────────────
+
+ /** Extension Instance add */
+    async addExtension(provider: ProviderModule, settings?: Record<string, any>): Promise<void> {
+        if (this.extensions.has(provider.type)) return;
+
+        const ext = new ExtensionProviderInstance(provider);
+        await ext.init({
+            cdp: this.context?.cdp,
+            serverConn: this.context?.serverConn,
+            settings: settings || {},
+        });
+        ext.onEvent('extension_connected', { ideType: this.type });
+        this.extensions.set(provider.type, ext);
+        LOG.info('IdeInstance', `[IdeInstance:${this.type}] Extension added: ${provider.type}`);
+    }
+
+ /** Extension Instance remove */
+    removeExtension(type: string): void {
+        const ext = this.extensions.get(type);
+        if (ext) {
+            ext.dispose();
+            this.extensions.delete(type);
+        }
+    }
+
+ /** Extension Instance Import */
+    getExtension(type: string): ExtensionProviderInstance | undefined {
+        return this.extensions.get(type);
+    }
+
+ /** Child Extension list */
+    getExtensionTypes(): string[] {
+        return [...this.extensions.keys()];
+    }
+
+ /** Query UUID instanceId */
+    getInstanceId(): string {
+        return this.instanceId;
+    }
+
+ /** all Extension Instance list */
+    getExtensionInstances(): ExtensionProviderInstance[] {
+        return [...this.extensions.values()];
+    }
+
+ // ─── CDP readChat ───────────────────────────────
+
+    private async readChat(): Promise<void> {
+        const { cdp } = this.context!;
+        if (!cdp?.isConnected) return;
+
+        try {
+            let raw: any = null;
+
+ // path 1: webview iframe internal (Kiro, PearAI etc)
+            const webviewFn = (this.provider.scripts as any)?.webviewReadChat;
+            if (typeof webviewFn === 'function' && cdp.evaluateInWebviewFrame) {
+                const webviewScript = webviewFn();
+                if (webviewScript) {
+                    const matchText = (this.provider as any).webviewMatchText;
+                    const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
+                    const webviewRaw = await cdp.evaluateInWebviewFrame(webviewScript, matchFn);
+                    if (webviewRaw) {
+                        raw = typeof webviewRaw === 'string' ? (() => { try { return JSON.parse(webviewRaw); } catch { return null; } })() : webviewRaw;
+                    }
+                }
+            }
+
+ // path 2: Main DOM (Cursor, Windsurf, Trae, Antigravity etc)
+            if (!raw) {
+                const readChatScript = this.getReadChatScript();
+                if (!readChatScript) return;
+                raw = await cdp.evaluate(readChatScript, 30000) as any;
+                if (typeof raw === 'string') {
+                    try { raw = JSON.parse(raw); } catch { return; }
+                }
+            }
+
+            if (!raw || typeof raw !== 'object') return;
+
+ // Modal filter
+            let { activeModal } = raw;
+            if (activeModal) {
+                const w = activeModal.width ?? Infinity;
+                const h = activeModal.height ?? Infinity;
+                if (w < 80 || h < 40) {
+                    activeModal = undefined;
+                } else {
+                    activeModal = {
+                        message: activeModal.message?.slice(0, 300) ?? '',
+                        buttons: (activeModal.buttons ?? []).filter((t: string) => t.length < 30),
+                    };
+                }
+            }
+
+ // Assign receivedAt
+            const prevMsgs = this.cachedChat?.messages || [];
+            const prevByHash = new Map<string, number>();
+            for (const pm of prevMsgs) {
+                const h = `${pm.role}:${(pm.content || '').slice(0, 100)}`;
+                if (pm.receivedAt) prevByHash.set(h, pm.receivedAt);
+            }
+            const now = Date.now();
+            for (const msg of (raw.messages || [])) {
+                const h = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
+                msg.receivedAt = prevByHash.get(h) || now;
+            }
+
+            this.cachedChat = { ...raw, activeModal };
+            this.detectAgentTransitions(raw, now);
+
+ // Save history (new messageonly append)
+ // Exclude last incomplete assistant message during generating status
+            if (raw.messages?.length > 0) {
+                let toSave = raw.messages;
+                if (raw.status === 'generating' || raw.status === 'long_generating') {
+ // Find and exclude last assistant message
+                    const lastIdx = toSave.length - 1;
+                    if (lastIdx >= 0 && toSave[lastIdx].role === 'assistant') {
+                        toSave = toSave.slice(0, lastIdx);
+                    }
+                }
+                if (toSave.length > 0) {
+                    this.historyWriter.appendNewMessages(
+                        this.type,
+                        toSave,
+                        raw.title,
+                        this.instanceId,
+                    );
+                }
+            }
+
+        } catch (e: any) {
+            const msg = e?.message || String(e);
+            if (msg.includes('Timeout') || msg.includes('timeout') || msg.includes('Target closed')) {
+ // CDP timeout — unified logging from onTick
+            } else {
+                LOG.warn('IdeInstance', `[IdeInstance:${this.type}] readChat internal error: ${msg}`);
+            }
+        }
+    }
+
+    private getReadChatScript(): string | null {
+        const scripts = this.provider.scripts;
+        if (!scripts?.readChat) return null;
+        return typeof scripts.readChat === 'function' ? scripts.readChat({}) : scripts.readChat as any;
+    }
+
+ // ─── status transition detect ─────────────────────────────
+
+    private detectAgentTransitions(chatData: any, now: number): void {
+        const chatStatus = chatData?.status;
+        if (!chatStatus) return;
+
+        const agentKey = `${this.type}:native`;
+        const agentStatus = (chatStatus === 'streaming' || chatStatus === 'generating') ? 'generating'
+            : chatStatus === 'waiting_approval' ? 'waiting_approval'
+            : 'idle';
+
+        this.currentStatus = agentStatus;
+        const lastStatus = this.lastAgentStatuses.get(agentKey) || 'idle';
+
+        if (agentStatus !== lastStatus) {
+            const chatTitle = chatData.title || this.provider.name;
+
+            if (lastStatus === 'idle' && agentStatus === 'generating') {
+                this.generatingStartedAt.set(agentKey, now);
+                this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now, ideType: this.type });
+            } else if (agentStatus === 'waiting_approval') {
+                if (!this.generatingStartedAt.has(agentKey)) this.generatingStartedAt.set(agentKey, now);
+                this.pushEvent({
+                    event: 'agent:waiting_approval', chatTitle, timestamp: now, ideType: this.type,
+                    modalMessage: chatData.activeModal?.message,
+                    modalButtons: chatData.activeModal?.buttons,
+                });
+            } else if (agentStatus === 'idle' && (lastStatus === 'generating' || lastStatus === 'waiting_approval')) {
+                const startedAt = this.generatingStartedAt.get(agentKey);
+                const duration = startedAt ? Math.round((now - startedAt) / 1000) : 0;
+                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now, ideType: this.type });
+                this.generatingStartedAt.delete(agentKey);
+            }
+
+            this.lastAgentStatuses.set(agentKey, agentStatus);
+        }
+
+ // Monitor check (cooldown based notification)
+        const monitorEvents = this.monitor.check(agentKey, agentStatus, now);
+        for (const me of monitorEvents) {
+            this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
+        }
+    }
+
+    private pushEvent(event: ProviderEvent): void {
+        this.events.push(event);
+        if (this.events.length > 50) this.events = this.events.slice(-50);
+    }
+
+    private flushEvents(): ProviderEvent[] {
+        const events = [...this.events];
+        this.events = [];
+        return events;
+    }
+
+ // ─── external access ─────────────────────────────────
+
+    updateCdp(cdp: InstanceContext['cdp']): void {
+        if (this.context) this.context.cdp = cdp;
+    }
+}

package/src/providers/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Provider System — Public API
+ */
+export { ProviderLoader } from './provider-loader.js';
+export type {
+  ProviderModule,
+  ProviderCategory,
+  ProviderScripts,
+  ResolvedProvider,
+  ReadChatResult,
+  ChatMessage,
+  AgentStatus,
+  ModalInfo,
+  SendMessageResult,
+  ListSessionsResult,
+  SessionInfo,
+  SwitchSessionResult,
+} from './contracts.js';

package/src/providers/provider-instance-manager.ts

@@ -0,0 +1,182 @@
+/**
+ * ProviderInstanceManager — lifecycle management for all ProviderInstances
+ *
+ * Role:
+ * 1. Instance create/delete
+ * 2. Tick engine (periodic onTick calls)
+ * 3. Collect overall state
+ * 4. Event collection and propagation
+ */
+
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import { LOG } from '../logging/logger.js';
+
+export class ProviderInstanceManager {
+    private instances = new Map<string, ProviderInstance>();
+    private tickTimer: NodeJS.Timeout | null = null;
+    private tickInterval = 5_000; // default 5seconds
+    private eventListeners: ((event: ProviderEvent & { providerType: string }) => void)[] = [];
+
+ // ─── Instance manage ──────────────────────────────
+
+ /**
+ * Instance add and initialize
+ */
+    async addInstance(id: string, instance: ProviderInstance, context: InstanceContext): Promise<void> {
+        if (this.instances.has(id)) {
+            LOG.warn('InstanceMgr', `[InstanceManager] Instance ${id} already exists, disposing old one`);
+            this.instances.get(id)!.dispose();
+        }
+        this.instances.set(id, instance);
+        await instance.init(context);
+    }
+
+ /**
+ * Instance remove
+ */
+    removeInstance(id: string): void {
+        const instance = this.instances.get(id);
+        if (instance) {
+            instance.dispose();
+            this.instances.delete(id);
+        }
+    }
+
+ /**
+ * Import by Instance ID
+ */
+    getInstance(id: string): ProviderInstance | undefined {
+        return this.instances.get(id);
+    }
+
+ /**
+ * Per-category Instance list
+ */
+    getByCategory(category: 'cli' | 'ide' | 'extension' | 'acp'): ProviderInstance[] {
+        return [...this.instances.values()].filter(i => i.category === category);
+    }
+
+ /**
+ * All Instance count
+ */
+    get size(): number {
+        return this.instances.size;
+    }
+
+ // ─── State collect ────────────────────────────────
+
+ /**
+ * all Instance's current status collect
+ * + Propagate pending events to event listeners
+ */
+    collectAllStates(): ProviderState[] {
+        const states: ProviderState[] = [];
+        for (const [id, instance] of this.instances) {
+            try {
+                const state = instance.getState();
+                states.push(state);
+
+ // pending events propagation
+                for (const event of state.pendingEvents) {
+                    for (const listener of this.eventListeners) {
+                        listener({ ...event, providerType: instance.type });
+                    }
+                }
+            } catch (e) {
+                LOG.warn('InstanceMgr', `[InstanceManager] Failed to collect state from ${id}: ${(e as Error).message}`);
+            }
+        }
+        return states;
+    }
+
+ /**
+ * Per-category status collect
+ */
+    collectStatesByCategory(category: 'cli' | 'ide' | 'extension' | 'acp'): ProviderState[] {
+        return this.collectAllStates().filter(s => s.category === category);
+    }
+
+ // ─── Tick engine ─────────────────────────────────
+
+ /**
+ * Start tick — periodically call all Instance.onTick() call
+ */
+    startTicking(intervalMs?: number): void {
+        if (this.tickTimer) return;
+        this.tickInterval = intervalMs || this.tickInterval;
+
+        this.tickTimer = setInterval(async () => {
+            for (const [id, instance] of this.instances) {
+                try {
+                    await instance.onTick();
+                } catch (e) {
+                    LOG.warn('InstanceMgr', `[InstanceManager] Tick failed for ${id}: ${(e as Error).message}`);
+                }
+            }
+        }, this.tickInterval);
+    }
+
+ /**
+ * Stop tick
+ */
+    stopTicking(): void {
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+    }
+
+ // ─── event ────────────────────────────────────
+
+ /**
+ * Register event listener (used for daemon status_event transmission)
+ */
+    onEvent(listener: (event: ProviderEvent & { providerType: string }) => void): void {
+        this.eventListeners.push(listener);
+    }
+
+ /**
+ * Forward event to specific Instance
+ */
+    sendEvent(id: string, event: string, data?: any): void {
+        this.instances.get(id)?.onEvent(event, data);
+    }
+
+ /**
+ * Broadcast event to all Instances
+ */
+    broadcast(event: string, data?: any): void {
+        for (const instance of this.instances.values()) {
+            instance.onEvent(event, data);
+        }
+    }
+
+ /**
+  * Update settings for all instances of a given provider type.
+  * Called when user changes settings from dashboard.
+  */
+    updateInstanceSettings(providerType: string, settings: Record<string, any>): number {
+        let updated = 0;
+        for (const instance of this.instances.values()) {
+            if (instance.type === providerType && typeof instance.updateSettings === 'function') {
+                instance.updateSettings(settings);
+                updated++;
+            }
+        }
+        return updated;
+    }
+
+ // ─── cleanup ──────────────────────────────────────
+
+ /**
+ * All terminate
+ */
+    disposeAll(): void {
+        this.stopTicking();
+        for (const [id, instance] of this.instances) {
+            try { instance.dispose(); } catch { }
+        }
+        this.instances.clear();
+        this.eventListeners = [];
+    }
+}

package/src/providers/provider-instance.ts

@@ -0,0 +1,112 @@
+/**
+ * ProviderInstance — Provider runtime lifecycle
+ *
+ * provider.js = static config/scripts
+ * ProviderInstance = runtime status management + lifecycle
+ *
+ * Daemon only collects via ProviderInstance.getState(),
+ * Each Instance manages its own status.
+ */
+
+import type { ProviderModule, ProviderSettingDef } from './contracts.js';
+
+// ─── ProviderState — Standard status structure ─────────────
+
+export interface ProviderState {
+ /** Provider type (e.g. 'gemini-cli', 'cursor', 'cline') */
+    type: string;
+ /** Provider Display name */
+    name: string;
+ /** category */
+    category: 'cli' | 'ide' | 'extension' | 'acp';
+ /** current status */
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+
+ /** CLI mode: terminal = PTY stream, chat = parsed conversation */
+    mode?: 'terminal' | 'chat';
+
+ /** chat data */
+    activeChat: {
+        id: string;
+        title: string;
+        status: string;
+        messages: { role: string; content: string; timestamp?: number }[];
+        activeModal: { message: string; buttons: string[] } | null;
+        inputContent?: string;
+    } | null;
+
+ /** IDE/Extension -only */
+    workspaceFolders?: { name: string; path: string }[];
+    activeFile?: string | null;
+    agentStreams?: any[];
+    cdpConnected?: boolean;
+ /** IDE child Extension Instance status */
+    extensions?: ProviderState[];
+
+ /** CLI -only */
+    workingDir?: string;
+
+ /** Runtime info (real-time detection from IDE/CLI) */
+    currentModel?: string;
+    currentPlan?: string;
+    currentAutoApprove?: string;
+
+ /** meta */
+    instanceId: string;
+    lastUpdated: number;
+    settings: Record<string, any>;
+
+ /** Event queue (cleared after daemon collects) */
+    pendingEvents: ProviderEvent[];
+}
+
+export interface ProviderEvent {
+    event: string;
+    timestamp: number;
+    [key: string]: any;
+}
+
+// ─── ProviderInstance interface ─────────────────
+
+export interface InstanceContext {
+ /** CDP connection (IDE/Extension) */
+    cdp?: {
+        isConnected: boolean;
+        evaluate(script: string, timeout?: number): Promise<unknown>;
+        evaluateInWebviewFrame?(expression: string, matchFn?: (bodyPreview: string) => boolean): Promise<string | null>;
+        discoverAgentWebviews?(): Promise<any[]>;
+    };
+ /** Server log transmit */
+    serverConn?: {
+        sendMessage(type: string, data: any): void;
+    };
+ /** P2P PTY output transmit */
+    onPtyData?: (data: string) => void;
+ /** Provider configvalue (resolved) */
+    settings: Record<string, any>;
+}
+
+export interface ProviderInstance {
+ /** Provider type */
+    readonly type: string;
+ /** Provider category */
+    readonly category: 'cli' | 'ide' | 'extension' | 'acp';
+
+ /** initialize */
+    init(context: InstanceContext): Promise<void>;
+
+ /** Tick — periodic status refresh (IDE: readChat, Extension: stream collection) */
+    onTick(): Promise<void>;
+
+ /** Return current status */
+    getState(): ProviderState;
+
+ /** Receive event (external → Instance) */
+    onEvent(event: string, data?: any): void;
+
+ /** Update settings at runtime (called when user changes settings from dashboard) */
+    updateSettings?(newSettings: Record<string, any>): void;
+
+ /** cleanup */
+    dispose(): void;
+}