@adhdev/daemon-core 0.5.3

package/providers/_builtin/validate.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * ADHDev Provider Validator
+ * 
+ * Usage:
+ *   node validate.js                     # validate all providers
+ *   node validate.js ide/my-ide/provider.js  # validate a single file
+ */
+const fs = require('fs');
+const path = require('path');
+
+const REQUIRED_FIELDS = ['type', 'name', 'category'];
+const VALID_CATEGORIES = ['ide', 'extension', 'cli', 'acp'];
+const USED_PORTS = new Map();
+const USED_TYPES = new Map();
+
+let errors = 0;
+let warnings = 0;
+let validated = 0;
+
+function validate(filePath) {
+  const rel = path.relative(process.cwd(), filePath);
+  
+  // 1. Syntax check
+  try {
+    delete require.cache[require.resolve(filePath)];
+  } catch {}
+  
+  let mod;
+  try {
+    mod = require(filePath);
+  } catch (e) {
+    console.error(`❌ ${rel}: syntax error — ${e.message}`);
+    errors++;
+    return;
+  }
+
+  // 2. Required fields
+  for (const field of REQUIRED_FIELDS) {
+    if (!mod[field]) {
+      console.error(`❌ ${rel}: missing required field '${field}'`);
+      errors++;
+      return;
+    }
+  }
+
+  // 3. Valid category
+  if (!VALID_CATEGORIES.includes(mod.category)) {
+    console.error(`❌ ${rel}: invalid category '${mod.category}' (must be: ${VALID_CATEGORIES.join(', ')})`);
+    errors++;
+    return;
+  }
+
+  // 4. Unique type
+  if (USED_TYPES.has(mod.type)) {
+    console.error(`❌ ${rel}: duplicate type '${mod.type}' (also in ${USED_TYPES.get(mod.type)})`);
+    errors++;
+    return;
+  }
+  USED_TYPES.set(mod.type, rel);
+
+  // 5. IDE-specific checks
+  if (mod.category === 'ide') {
+    if (!mod.cdpPorts || !Array.isArray(mod.cdpPorts) || mod.cdpPorts.length < 2) {
+      console.warn(`⚠  ${rel}: IDE missing cdpPorts [primary, fallback]`);
+      warnings++;
+    } else {
+      for (const port of mod.cdpPorts) {
+        if (USED_PORTS.has(port)) {
+          console.error(`❌ ${rel}: CDP port ${port} conflicts with ${USED_PORTS.get(port)}`);
+          errors++;
+        }
+        USED_PORTS.set(port, rel);
+      }
+    }
+
+    if (!mod.cli) {
+      console.warn(`⚠  ${rel}: IDE missing 'cli' field`);
+      warnings++;
+    }
+
+    if (!mod.paths) {
+      console.warn(`⚠  ${rel}: IDE missing 'paths' (install detection won't work)`);
+      warnings++;
+    }
+  }
+
+  // 6. ACP-specific checks
+  if (mod.category === 'acp') {
+    if (!mod.spawn || !mod.spawn.command) {
+      console.warn(`⚠  ${rel}: ACP missing spawn.command`);
+      warnings++;
+    }
+  }
+
+  // 7. Scripts check
+  if (mod.category === 'ide' || mod.category === 'extension') {
+    const hasRead = mod.scripts?.readChat || mod.scripts?.webviewReadChat;
+    const hasSend = mod.scripts?.sendMessage || mod.scripts?.webviewSendMessage;
+    if (!hasRead) {
+      console.warn(`⚠  ${rel}: no readChat/webviewReadChat script`);
+      warnings++;
+    }
+    if (!hasSend) {
+      console.warn(`⚠  ${rel}: no sendMessage/webviewSendMessage script`);
+      warnings++;
+    }
+  }
+
+  // 8. Webview IDE consistency
+  if (mod.category === 'ide' && mod.webviewMatchText) {
+    if (!mod.scripts?.webviewReadChat) {
+      console.warn(`⚠  ${rel}: has webviewMatchText but no webviewReadChat script`);
+      warnings++;
+    }
+  }
+
+  validated++;
+  console.log(`✅ ${rel}: ${mod.type} (${mod.category}) — ${mod.name}`);
+}
+
+function scanDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+      scanDir(full);
+    } else if (entry.name === 'provider.js') {
+      validate(full);
+    }
+  }
+}
+
+// ─── Main ───
+const args = process.argv.slice(2);
+
+if (args.length > 0) {
+  // Validate specific file(s)
+  for (const arg of args) {
+    const filePath = path.resolve(arg);
+    if (!fs.existsSync(filePath)) {
+      console.error(`❌ File not found: ${arg}`);
+      errors++;
+      continue;
+    }
+    validate(filePath);
+  }
+} else {
+  // Validate all
+  console.log('🔍 Validating all providers...\n');
+  scanDir(process.cwd());
+}
+
+console.log(`\n━━━ Result: ${validated} passed, ${errors} errors, ${warnings} warnings ━━━`);
+process.exit(errors > 0 ? 1 : 0);

package/src/agent-stream/index.ts

@@ -0,0 +1,6 @@
+export { DaemonAgentStreamManager } from './manager.js';
+export type { ManagedAgent } from './manager.js';
+export { ProviderStreamAdapter } from './provider-adapter.js';
+export * from './types.js';
+export { AgentStreamPoller } from './poller.js';
+export type { AgentStreamPollerDeps } from './poller.js';

package/src/agent-stream/manager.ts

@@ -0,0 +1,286 @@
+/**
+ * DaemonAgentStreamManager — manage agent streams (ported for Daemon)
+ * 
+ * Agent stream manager for extension data collection.
+ * All vscode dependencies removed — pure Node.js environment.
+ * 
+ * Panel focus is delegated to Extension via IPC.
+ * CDP session management uses DaemonCdpManager directly.
+ */
+
+import { DaemonCdpManager, AgentWebviewTarget } from '../cdp/manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { ProviderStreamAdapter } from './provider-adapter.js';
+import { LOG } from '../logging/logger.js';
+import type {
+    IAgentStreamAdapter,
+    AgentStreamState,
+    AgentChatListItem,
+    AgentEvaluateFn,
+} from './types.js';
+
+export interface ManagedAgent {
+    adapter: IAgentStreamAdapter;
+    sessionId: string;
+    target: AgentWebviewTarget;
+    lastState: AgentStreamState | null;
+    lastError: string | null;
+    lastHiddenCheckTime: number;
+}
+
+export class DaemonAgentStreamManager {
+    private allAdapters: IAgentStreamAdapter[] = [];
+    private managed = new Map<string, ManagedAgent>();
+    private enabled = true;
+    private logFn: (msg: string) => void;
+    private lastDiscoveryTime = 0;
+    private discoveryIntervalMs = 10_000;
+
+
+    private _activeAgentType: string | null = null;
+
+    constructor(logFn?: (msg: string) => void, providerLoader?: ProviderLoader) {
+        this.logFn = logFn || LOG.forComponent('AgentStream').asLogFn();
+
+ // Create adapter for all extension providers
+ // Per-IDE filtering is handled by each CDP manager via setExtensionProviders
+        if (providerLoader) {
+            const allExtProviders = providerLoader.getByCategory('extension');
+            for (const p of allExtProviders) {
+                const adapter = new ProviderStreamAdapter(p);
+                this.allAdapters.push(adapter);
+                this.logFn(`[AgentStream] Adapter created: ${p.type} (${p.name})`);
+            }
+        }
+    }
+
+    setEnabled(enabled: boolean) { this.enabled = enabled; }
+    get isEnabled() { return this.enabled; }
+    get activeAgentType(): string | null { return this._activeAgentType; }
+
+ /** Panel focus based on provider.js focusPanel or extensionId (currently no-op) */
+    async ensureAgentPanelOpen(agentType: string, targetIdeType?: string): Promise<void> {
+ // Extension was removed, so localServer-based panel focus no longer works
+ // Can be replaced with CDP-based focus (future implementation)
+    }
+
+    async switchActiveAgent(cdp: DaemonCdpManager, agentType: string | null): Promise<void> {
+        if (this._activeAgentType === agentType) return;
+
+        if (this._activeAgentType) {
+            const prev = this.managed.get(this._activeAgentType);
+            if (prev) {
+                try { await cdp.detachAgent(prev.sessionId); } catch { }
+                this.managed.delete(this._activeAgentType);
+                this.logFn(`[AgentStream] Deactivated: ${prev.adapter.agentName}`);
+            }
+        }
+
+        this._activeAgentType = agentType;
+        this.lastDiscoveryTime = 0;
+        this.logFn(`[AgentStream] Active agent: ${agentType || 'none'}`);
+    }
+
+ /** Agent webview discovery + session connection */
+    async syncAgentSessions(cdp: DaemonCdpManager): Promise<void> {
+        if (!this.enabled || !this._activeAgentType) return;
+
+        const now = Date.now();
+        if (this.managed.has(this._activeAgentType) && (now - this.lastDiscoveryTime) < this.discoveryIntervalMs) {
+            return;
+        }
+        this.lastDiscoveryTime = now;
+
+        try {
+            const targets = await cdp.discoverAgentWebviews();
+            const activeTarget = targets.find(t => t.agentType === this._activeAgentType);
+
+            if (activeTarget && !this.managed.has(this._activeAgentType)) {
+                const adapter = this.allAdapters.find(a => a.agentType === this._activeAgentType);
+                if (adapter) {
+                    const sessionId = await cdp.attachToAgent(activeTarget);
+                    if (sessionId) {
+                        this.managed.set(this._activeAgentType, {
+                            adapter,
+                            sessionId,
+                            target: activeTarget,
+                            lastState: null,
+                            lastError: null,
+                            lastHiddenCheckTime: 0,
+                        });
+                        this.logFn(`[AgentStream] Connected: ${adapter.agentName}`);
+                    }
+                }
+            }
+
+ // Cleanup inactive agents
+            for (const [type, agent] of this.managed) {
+                if (type !== this._activeAgentType) {
+                    await cdp.detachAgent(agent.sessionId);
+                    this.managed.delete(type);
+                }
+            }
+
+            this.discoveryIntervalMs = this.managed.has(this._activeAgentType) ? 30_000 : 10_000;
+        } catch (e) {
+            this.logFn(`[AgentStream] sync error: ${(e as Error).message}`);
+        }
+    }
+
+ /** Collect active agent status */
+    async collectAgentStreams(cdp: DaemonCdpManager): Promise<AgentStreamState[]> {
+        if (!this.enabled) return [];
+
+        const results: AgentStreamState[] = [];
+
+        if (this._activeAgentType && this.managed.has(this._activeAgentType)) {
+            const agent = this.managed.get(this._activeAgentType)!;
+            const type = this._activeAgentType;
+
+            const isHidden = agent.lastState?.status === 'panel_hidden';
+            const hiddenCacheFresh = isHidden && (Date.now() - agent.lastHiddenCheckTime < 30000);
+
+            if (hiddenCacheFresh) {
+                results.push(agent.lastState!);
+            } else {
+                try {
+                    const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                        cdp.evaluateInSession(agent.sessionId, expr, timeout);
+                    const state = await agent.adapter.readChat(evaluate);
+                    agent.lastState = state;
+                    agent.lastError = null;
+                    if (state.status === 'panel_hidden') {
+                        agent.lastHiddenCheckTime = Date.now();
+                    }
+                    results.push(state);
+                } catch (e) {
+                    const errorMsg = (e as Error)?.message || String(e);
+                    this.logFn(`[AgentStream] readChat(${type}) error: ${errorMsg.slice(0, 200)}`);
+                    agent.lastError = errorMsg;
+                    results.push({
+                        agentType: type,
+                        agentName: agent.adapter.agentName,
+                        extensionId: agent.adapter.extensionId,
+                        status: 'disconnected',
+                        messages: agent.lastState?.messages || [],
+                        inputContent: '',
+                    });
+                    if (errorMsg.includes('timeout') || errorMsg.includes('not connected') || errorMsg.includes('Session')) {
+                        try { await cdp.detachAgent(agent.sessionId); } catch { }
+                        this.managed.delete(type);
+                        this.lastDiscoveryTime = 0;
+                    }
+                }
+            }
+        }
+
+        return results;
+    }
+
+    async sendToAgent(cdp: DaemonCdpManager, agentType: string, text: string, targetIdeType?: string): Promise<boolean> {
+        await this.ensureAgentPanelOpen(agentType, targetIdeType);
+        const agent = this.managed.get(agentType);
+        if (!agent) return false;
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+            await agent.adapter.sendMessage(evaluate, text);
+            return true;
+        } catch (e) {
+            this.logFn(`[AgentStream] sendToAgent(${agentType}) error: ${(e as Error).message}`);
+            return false;
+        }
+    }
+
+    async resolveAgentAction(cdp: DaemonCdpManager, agentType: string, action: 'approve' | 'reject', targetIdeType?: string): Promise<boolean> {
+        await this.ensureAgentPanelOpen(agentType, targetIdeType);
+        const agent = this.managed.get(agentType);
+        if (!agent) return false;
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+            return await agent.adapter.resolveAction(evaluate, action);
+        } catch (e) {
+            this.logFn(`[AgentStream] resolveAction(${agentType}) error: ${(e as Error).message}`);
+            return false;
+        }
+    }
+
+    async newAgentSession(cdp: DaemonCdpManager, agentType: string, targetIdeType?: string): Promise<boolean> {
+        await this.ensureAgentPanelOpen(agentType, targetIdeType);
+        const agent = this.managed.get(agentType);
+        if (!agent) return false;
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+            await agent.adapter.newSession(evaluate);
+            return true;
+        } catch (e) {
+            this.logFn(`[AgentStream] newSession(${agentType}) error: ${(e as Error).message}`);
+            return false;
+        }
+    }
+
+    async listAgentChats(cdp: DaemonCdpManager, agentType: string): Promise<AgentChatListItem[]> {
+        let agent = this.managed.get(agentType);
+ // on-demand: try activate+sync if not in managed list
+        if (!agent) {
+            this.logFn(`[AgentStream] listChats: ${agentType} not managed, trying on-demand activation`);
+            await this.switchActiveAgent(cdp, agentType);
+            await this.syncAgentSessions(cdp);
+            agent = this.managed.get(agentType);
+        }
+        if (!agent || typeof agent.adapter.listChats !== 'function') return [];
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSession(agent!.sessionId, expr, timeout);
+            return await agent.adapter.listChats(evaluate);
+        } catch (e) {
+            this.logFn(`[AgentStream] listChats(${agentType}) error: ${(e as Error).message}`);
+            return [];
+        }
+    }
+
+    async switchAgentSession(cdp: DaemonCdpManager, agentType: string, sessionId: string): Promise<boolean> {
+        let agent = this.managed.get(agentType);
+        if (!agent) {
+            this.logFn(`[AgentStream] switchSession: ${agentType} not managed, trying on-demand activation`);
+            await this.switchActiveAgent(cdp, agentType);
+            await this.syncAgentSessions(cdp);
+            agent = this.managed.get(agentType);
+        }
+        if (!agent || typeof agent.adapter.switchSession !== 'function') return false;
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSession(agent!.sessionId, expr, timeout);
+            return await agent.adapter.switchSession(evaluate, sessionId);
+        } catch (e) {
+            this.logFn(`[AgentStream] switchSession(${agentType}) error: ${(e as Error).message}`);
+            return false;
+        }
+    }
+
+    async focusAgentEditor(cdp: DaemonCdpManager, agentType: string): Promise<boolean> {
+        const agent = this.managed.get(agentType);
+        if (!agent || typeof agent.adapter.focusEditor !== 'function') return false;
+        try {
+            const evaluate: AgentEvaluateFn = (expr, timeout) =>
+                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+            await agent.adapter.focusEditor(evaluate);
+            return true;
+        } catch (e) {
+            this.logFn(`[AgentStream] focusEditor(${agentType}) error: ${(e as Error).message}`);
+            return false;
+        }
+    }
+
+    getConnectedAgents(): string[] { return Array.from(this.managed.keys()); }
+    getManagedAgent(agentType: string): ManagedAgent | undefined { return this.managed.get(agentType); }
+
+    async dispose(cdp: DaemonCdpManager): Promise<void> {
+        for (const [, agent] of this.managed) {
+            try { await cdp.detachAgent(agent.sessionId); } catch { }
+        }
+        this.managed.clear();
+    }
+}

package/src/agent-stream/poller.ts

@@ -0,0 +1,154 @@
+/**
+ * AgentStreamPoller — Periodic agent stream polling + extension dynamic management
+ *
+ * Extracted from cloud daemon's startAgentStreamPolling() logic.
+ * Used by both daemon-cloud and daemon-standalone.
+ *
+ * Responsibilities:
+ *   1. Refresh extension providers in CDP managers (config changes take effect immediately)
+ *   2. Dynamically add/remove IDE instance extensions based on enabled state
+ *   3. Sync agent sessions + collect agent streams
+ *   4. Auto-discover agents in connected IDEs
+ */
+
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { DaemonAgentStreamManager } from './manager.js';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { registerExtensionProviders } from '../cdp/setup.js';
+import { LOG } from '../logging/logger.js';
+import type { AgentStreamState } from './types.js';
+
+// ─── Types ───
+
+export interface AgentStreamPollerDeps {
+    agentStreamManager: DaemonAgentStreamManager;
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    /** Callback when agent streams are updated */
+    onStreamsUpdated?: (ideType: string, streams: AgentStreamState[]) => void;
+}
+
+export class AgentStreamPoller {
+    private deps: AgentStreamPollerDeps;
+    private _activeIdeType: string | null = null;
+    private timer: NodeJS.Timeout | null = null;
+
+    constructor(deps: AgentStreamPollerDeps) {
+        this.deps = deps;
+    }
+
+    /** Currently active IDE type for agent streaming */
+    get activeIde(): string | null {
+        return this._activeIdeType;
+    }
+
+    /** Reset active IDE tracking (e.g., when IDE is stopped) */
+    resetActiveIde(ideType: string): void {
+        if (this._activeIdeType === ideType) {
+            this._activeIdeType = null;
+        }
+    }
+
+    /** Start polling (idempotent — ignored if already started) */
+    start(intervalMs = 5000): void {
+        if (this.timer) return; // Already running
+
+        this.timer = setInterval(async () => {
+            await this.tick();
+        }, intervalMs);
+    }
+
+    /** Stop polling */
+    stop(): void {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+
+    /** Single poll tick — can also be called manually */
+    private async tick(): Promise<void> {
+        const {
+            agentStreamManager,
+            providerLoader,
+            instanceManager,
+            cdpManagers,
+        } = this.deps;
+
+        if (!agentStreamManager || cdpManagers.size === 0) return;
+
+        // ─── Phase 1: Refresh extension providers + IDE instance extensions ───
+        for (const [ideType, cdp] of cdpManagers) {
+            // 1a. Refresh CDP manager's extension providers from config
+            registerExtensionProviders(providerLoader, cdp, ideType);
+
+            // 1b. Dynamically add/remove IDE instance extensions
+            const ideInstance = instanceManager.getInstance(`ide:${ideType}`) as any;
+            if (ideInstance?.getExtensionTypes && ideInstance?.addExtension && ideInstance?.removeExtension) {
+                const currentExtTypes = new Set(ideInstance.getExtensionTypes() as string[]);
+                const enabledExtTypes = new Set(
+                    providerLoader.getEnabledByCategory('extension', ideType).map((p: any) => p.type)
+                );
+
+                // Remove disabled extensions
+                for (const extType of currentExtTypes) {
+                    if (!enabledExtTypes.has(extType)) {
+                        ideInstance.removeExtension(extType);
+                        LOG.info('AgentStream', `Extension removed: ${extType} (disabled for ${ideType})`);
+                    }
+                }
+
+                // Add newly enabled extensions
+                for (const extType of enabledExtTypes) {
+                    if (!currentExtTypes.has(extType)) {
+                        const extProvider = providerLoader.getMeta(extType);
+                        if (extProvider) {
+                            const extSettings = providerLoader.getSettings(extType);
+                            ideInstance.addExtension(extProvider, extSettings);
+                            LOG.info('AgentStream', `Extension added: ${extType} (enabled for ${ideType})`);
+                        }
+                    }
+                }
+            }
+        }
+
+        // ─── Phase 2: Agent session sync + collect ───
+
+        // If agent already connected to a specific IDE, only operate on that CDP
+        if (this._activeIdeType) {
+            const cdp = cdpManagers.get(this._activeIdeType);
+            if (cdp?.isConnected) {
+                try {
+                    await agentStreamManager.syncAgentSessions(cdp);
+                    const streams = await agentStreamManager.collectAgentStreams(cdp);
+                    this.deps.onStreamsUpdated?.(this._activeIdeType, streams);
+                } catch { }
+                return;
+            }
+            // CDP lost — reset
+            this._activeIdeType = null;
+        }
+
+        // ─── Phase 3: Auto-discover agents ───
+        if (!agentStreamManager.activeAgentType) {
+            for (const [ideType, cdp] of cdpManagers) {
+                if (!cdp.isConnected) continue;
+                try {
+                    const discovered = await cdp.discoverAgentWebviews();
+                    if (discovered.length > 0) {
+                        this._activeIdeType = ideType;
+                        await agentStreamManager.switchActiveAgent(cdp, discovered[0].agentType);
+                        LOG.info('AgentStream', `Auto-activated: ${discovered[0].agentType} (${ideType})`);
+                        // sync+collect immediately
+                        await agentStreamManager.syncAgentSessions(cdp);
+                        const streams = await agentStreamManager.collectAgentStreams(cdp);
+                        this.deps.onStreamsUpdated?.(ideType, streams);
+                        return;
+                    }
+                } catch { }
+            }
+        }
+    }
+}