@adhdev/daemon-core 0.6.77 → 0.7.0

package/src/agent-stream/poller.ts

@@ -15,6 +15,7 @@ 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 type { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import type { AgentStreamState } from './types.js';
 
@@ -25,13 +26,13 @@ export interface AgentStreamPollerDeps {
     providerLoader: ProviderLoader;
     instanceManager: ProviderInstanceManager;
     cdpManagers: Map<string, DaemonCdpManager>;
+    sessionRegistry: SessionRegistry;
     /** 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) {
@@ -40,14 +41,12 @@ export class AgentStreamPoller {
 
     /** Currently active IDE type for agent streaming */
     get activeIde(): string | null {
-        return this._activeIdeType;
+        return null;
     }
 
     /** Reset active IDE tracking (e.g., when IDE is stopped) */
-    resetActiveIde(ideType: string): void {
-        if (this._activeIdeType === ideType) {
-            this._activeIdeType = null;
-        }
+    resetActiveIde(parentSessionId: string): void {
+        this.deps.agentStreamManager.resetParentSession(parentSessionId);
     }
 
     /** Start polling (idempotent — ignored if already started) */
@@ -74,6 +73,7 @@ export class AgentStreamPoller {
             providerLoader,
             instanceManager,
             cdpManagers,
+            sessionRegistry,
         } = this.deps;
 
         if (!agentStreamManager || cdpManagers.size === 0) return;
@@ -85,6 +85,7 @@ export class AgentStreamPoller {
 
             // 1b. Dynamically add/remove IDE instance extensions
             const ideInstance = instanceManager.getInstance(`ide:${ideType}`) as any;
+            const parentSessionId = ideInstance?.getInstanceId?.();
             if (ideInstance?.getExtensionTypes && ideInstance?.addExtension && ideInstance?.removeExtension) {
                 const currentExtTypes = new Set(ideInstance.getExtensionTypes() as string[]);
                 const enabledExtTypes = new Set(
@@ -94,6 +95,10 @@ export class AgentStreamPoller {
                 // Remove disabled extensions
                 for (const extType of currentExtTypes) {
                     if (!enabledExtTypes.has(extType)) {
+                        const extInstance = ideInstance.getExtension?.(extType);
+                        if (extInstance?.getInstanceId) {
+                            sessionRegistry.unregister(extInstance.getInstanceId());
+                        }
                         ideInstance.removeExtension(extType);
                         LOG.info('AgentStream', `Extension removed: ${extType} (disabled for ${ideType})`);
                     }
@@ -106,6 +111,18 @@ export class AgentStreamPoller {
                         if (extProvider) {
                             const extSettings = providerLoader.getSettings(extType);
                             ideInstance.addExtension(extProvider, extSettings);
+                            const extInstance = ideInstance.getExtension?.(extType);
+                            if (parentSessionId && extInstance?.getInstanceId) {
+                                sessionRegistry.register({
+                                    sessionId: extInstance.getInstanceId(),
+                                    parentSessionId,
+                                    providerType: extType,
+                                    providerCategory: 'extension',
+                                    transport: 'cdp-webview',
+                                    cdpManagerKey: ideType,
+                                    instanceKey: `ide:${ideType}`,
+                                });
+                            }
                             LOG.info('AgentStream', `Extension added: ${extType} (enabled for ${ideType})`);
                         }
                     }
@@ -113,56 +130,51 @@ export class AgentStreamPoller {
             }
 
             // 1c. If the active agent stream belongs to a now-disabled extension, detach it
-            if (this._activeIdeType === ideType && agentStreamManager.activeAgentType) {
-                const activeType = agentStreamManager.activeAgentType;
-                const enabledExtTypes = new Set(
-                    providerLoader.getEnabledExtensionProviders(ideType).map((p: any) => p.type)
-                );
-                if (!enabledExtTypes.has(activeType)) {
-                    LOG.info('AgentStream', `Active agent ${activeType} was disabled for ${ideType} — detaching`);
-                    await agentStreamManager.switchActiveAgent(cdp, null);
-                    this._activeIdeType = null;
+            const activeSessionId = parentSessionId ? agentStreamManager.getActiveSessionId(parentSessionId) : null;
+            if (activeSessionId) {
+                const activeTarget = sessionRegistry.get(activeSessionId);
+                const enabledExtTypes = new Set(providerLoader.getEnabledExtensionProviders(ideType).map((p: any) => p.type));
+                if (!activeTarget || !enabledExtTypes.has(activeTarget.providerType)) {
+                    LOG.info('AgentStream', `Active agent ${activeTarget?.providerType || activeSessionId} was disabled for ${ideType} — detaching`);
+                    await agentStreamManager.setActiveSession(cdp, parentSessionId!, null);
                     // Report empty streams so dashboard removes the tab
                     this.deps.onStreamsUpdated?.(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;
+            if (!cdp.isConnected) {
+                if (parentSessionId && activeSessionId) {
+                    agentStreamManager.resetParentSession(parentSessionId);
+                    this.deps.onStreamsUpdated?.(ideType, []);
+                }
+                continue;
             }
-            // CDP lost — reset
-            this._activeIdeType = null;
-        }
 
-        // ─── Phase 3: Auto-discover agents ───
-        if (!agentStreamManager.activeAgentType) {
-            for (const [ideType, cdp] of cdpManagers) {
-                if (!cdp.isConnected) continue;
+            // ─── Phase 2: Agent session sync + collect ───
+            let resolvedActiveSessionId = activeSessionId;
+
+            // ─── Phase 3: Auto-discover agents ───
+            if (!resolvedActiveSessionId && parentSessionId) {
                 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;
+                    for (const target of discovered) {
+                        const sessionId = agentStreamManager.resolveSessionForAgent(parentSessionId, target.agentType);
+                        if (sessionId) {
+                            resolvedActiveSessionId = sessionId;
+                            await agentStreamManager.setActiveSession(cdp, parentSessionId, sessionId);
+                            LOG.info('AgentStream', `Auto-activated: ${target.agentType} (${ideType})`);
+                            break;
+                        }
                     }
                 } catch { }
             }
+
+            if (!resolvedActiveSessionId || !parentSessionId) continue;
+
+            try {
+                await agentStreamManager.syncActiveSession(cdp, parentSessionId);
+                const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+                this.deps.onStreamsUpdated?.(ideType, stream ? [stream] : []);
+            } catch { }
         }
     }
 }

package/src/boot/daemon-lifecycle.ts

@@ -20,6 +20,7 @@ import { VersionArchive, detectAllVersions } from '../providers/version-archive.
 import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { DevServer } from '../daemon/dev-server.js';
 import { detectIDEs } from '../detection/ide-detector.js';
+import { SessionRegistry } from '../sessions/registry.js';
 import { installGlobalInterceptor, LOG } from '../logging/logger.js';
 import { loadConfig } from '../config/config.js';
 
@@ -70,7 +71,7 @@ export interface DaemonComponents {
     poller: AgentStreamPoller;
     cdpInitializer: DaemonCdpInitializer;
     cdpManagers: Map<string, DaemonCdpManager>;
-    instanceIdMap: Map<string, string>;
+    sessionRegistry: SessionRegistry;
     detectedIdes: { value: any[] };
 }
 
@@ -141,13 +142,16 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // 3. Shared state
     const instanceManager = new ProviderInstanceManager();
     const cdpManagers = new Map<string, DaemonCdpManager>();
-    const instanceIdMap = new Map<string, string>();
+    const sessionRegistry = new SessionRegistry();
     const detectedIdesRef = { value: [] as any[] };
+    let agentStreamManager: DaemonAgentStreamManager | null = null;
+    let poller: AgentStreamPoller | null = null;
 
     // 4. CLI Manager
     const cliManager = new DaemonCliManager({
         ...config.cliManagerDeps,
         getInstanceManager: () => instanceManager,
+        getSessionRegistry: () => sessionRegistry,
     }, providerLoader);
 
     // 5. Detect IDEs
@@ -161,7 +165,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         providerLoader,
         instanceManager,
         cdpManagers,
-        instanceIdMap,
+        sessionRegistry,
     };
 
     const cdpInitializer = new DaemonCdpInitializer({
@@ -174,6 +178,21 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
             // Transport-specific extras
             await config.onCdpManagerSetup?.(ideType, manager, managerKey);
         },
+        onDisconnected: async (_ideType, _manager, managerKey) => {
+            sessionRegistry.unregisterByManagerKey(managerKey);
+            const instanceKey = `ide:${managerKey}`;
+            const ideInstance = instanceManager.getInstance(instanceKey) as any;
+
+            if (ideInstance) {
+                instanceManager.removeInstance(instanceKey);
+                LOG.info('CDP', `Instance removed after disconnect: ${instanceKey}`);
+            }
+
+            if (ideInstance?.getInstanceId) {
+                agentStreamManager?.resetParentSession(ideInstance.getInstanceId());
+            }
+            config.onStatusChange?.();
+        },
     });
     await cdpInitializer.connectAll(detectedIdesRef.value);
     cdpInitializer.startPeriodicScan(config.cdpScanIntervalMs ?? 30_000);
@@ -186,20 +205,19 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         adapters: cliManager.adapters,
         providerLoader,
         instanceManager,
-        instanceIdMap,
+        sessionRegistry,
     });
 
     // 8. AgentStreamManager
-    const agentStreamManager = new DaemonAgentStreamManager(
+    agentStreamManager = new DaemonAgentStreamManager(
         LOG.forComponent('AgentStream').asLogFn(),
         providerLoader,
+        sessionRegistry,
     );
     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,
@@ -207,7 +225,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         providerLoader,
         instanceManager,
         detectedIdes: detectedIdesRef,
-        instanceIdMap,
+        sessionRegistry,
         onCdpManagerCreated: async (ideType: string, manager: DaemonCdpManager) => {
             // For launch_ide: register instance + extension providers
             await setupIdeInstance(cdpSetupContext, { ideType, manager });
@@ -224,6 +242,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         providerLoader,
         instanceManager,
         cdpManagers,
+        sessionRegistry,
         onStreamsUpdated: config.onStreamsUpdated,
     });
     poller.start();
@@ -241,7 +260,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         poller,
         cdpInitializer,
         cdpManagers,
-        instanceIdMap,
+        sessionRegistry,
         detectedIdes: detectedIdesRef,
     };
 }
@@ -288,9 +307,8 @@ export async function shutdownDaemonComponents(components: DaemonComponents): Pr
 
     // 2. Dispose agent stream
     try {
-        const anyCdp = [...cdpManagers.values()].find(m => m.isConnected);
-        if (agentStreamManager && anyCdp) {
-            await agentStreamManager.dispose(anyCdp);
+        if (agentStreamManager) {
+            await agentStreamManager.dispose(cdpManagers);
         }
     } catch (e: any) { LOG.warn('Shutdown', `AgentStream dispose: ${e?.message}`); }
 

package/src/cdp/initializer.ts

@@ -24,6 +24,13 @@ export interface CdpInitializerConfig {
     enabledIdes?: string[];
     /** Callback when a new CDP manager is connected */
     onConnected?: (ideType: string, manager: DaemonCdpManager, managerKey: string) => void | Promise<void>;
+    /** Callback when a stale/disconnected CDP manager is removed */
+    onDisconnected?: (
+        ideType: string,
+        manager: DaemonCdpManager,
+        managerKey: string,
+        reason: 'ide_closed' | 'target_closed' | 'target_rekeyed',
+    ) => void | Promise<void>;
 }
 
 export class DaemonCdpInitializer {
@@ -88,6 +95,7 @@ export class DaemonCdpInitializer {
 
         // 1. Try multi-window: list all workbench pages on this port
         const targets = await DaemonCdpManager.listAllTargets(port);
+        await this.pruneStaleManagers(port, ide, targets);
 
         if (targets.length === 0) {
             // Prevent duplicate fallback connection
@@ -153,6 +161,45 @@ export class DaemonCdpInitializer {
         }
     }
 
+    private async pruneStaleManagers(
+        port: number,
+        ide: string,
+        targets: Array<{ id: string }>,
+    ): Promise<void> {
+        const trackedTargetIds = new Set(targets.map((target) => target.id));
+        const removals: Array<{
+            key: string;
+            manager: DaemonCdpManager;
+            reason: 'ide_closed' | 'target_closed' | 'target_rekeyed';
+        }> = [];
+
+        for (const [key, manager] of this.config.cdpManagers.entries()) {
+            if (!(key === ide || key.startsWith(`${ide}_`))) continue;
+            if (manager.getPort() !== port) continue;
+
+            if (targets.length === 0) {
+                removals.push({ key, manager, reason: 'ide_closed' });
+                continue;
+            }
+
+            if (manager.targetId && !trackedTargetIds.has(manager.targetId)) {
+                removals.push({ key, manager, reason: 'target_closed' });
+                continue;
+            }
+
+            if (key === ide && !manager.targetId && targets.length > 1) {
+                removals.push({ key, manager, reason: 'target_rekeyed' });
+            }
+        }
+
+        for (const { key, manager, reason } of removals) {
+            try { manager.disconnect(); } catch { /* noop */ }
+            this.config.cdpManagers.delete(key);
+            LOG.info('CDP', `Removed stale manager: ${key} (${reason})`);
+            await this.config.onDisconnected?.(ide, manager, key, reason);
+        }
+    }
+
     // ─── Periodic scanning ───
 
     /**

package/src/cdp/manager.ts

@@ -660,9 +660,12 @@ export class DaemonCdpManager {
         try {
  // 1. Find webview iframe targets
             const { targetInfos } = await sendWs('Target.getTargets');
-            const webviewIframes = (targetInfos || []).filter(
-                (t: any) => t.type === 'iframe' && (t.url || '').includes('vscode-webview')
-            );
+            const pageWebviewUrls = await this.getCurrentPageWebviewUrls();
+            const webviewIframes = (targetInfos || []).filter((t: any) => {
+                if (t.type !== 'iframe' || !(t.url || '').includes('vscode-webview')) return false;
+                if (pageWebviewUrls.size === 0) return true;
+                return pageWebviewUrls.has(t.url || '');
+            });
 
             if (webviewIframes.length === 0) {
                 this.log('[CDP] evaluateInWebviewFrame: no webview iframes found');
@@ -766,6 +769,8 @@ export class DaemonCdpManager {
                 allTargets = result?.targetInfos || [];
             }
 
+            const pageWebviewUrls = await this.getCurrentPageWebviewUrls();
+
             const iframes = allTargets.filter((t: any) => t.type === 'iframe');
             const typeMap = new Map<string, number>();
             for (const t of allTargets) {
@@ -794,6 +799,7 @@ export class DaemonCdpManager {
                 const url = target.url || '';
                 const hasWebview = url.includes('vscode-webview');
                 if (!hasWebview) continue;
+                if (pageWebviewUrls.size > 0 && !pageWebviewUrls.has(url)) continue;
 
                 for (const known of this.extensionProviders) {
                     if (known.extensionIdPattern.test(url)) {
@@ -822,7 +828,10 @@ export class DaemonCdpManager {
     async attachToAgent(target: AgentWebviewTarget): Promise<string | null> {
         if (!this.isConnected) return null;
         for (const [sid, t] of this.agentSessions) {
-            if (t.agentType === target.agentType) return sid;
+            if (t.targetId === target.targetId) return sid;
+            if (t.agentType === target.agentType && t.targetId !== target.targetId) {
+                await this.detachAgent(sid).catch(() => { });
+            }
         }
         try {
  // Attach via Browser WS (iframes can only be attached from browser-level)
@@ -963,6 +972,38 @@ export class DaemonCdpManager {
         return this.agentSessions;
     }
 
+    private async getCurrentPageWebviewUrls(): Promise<Set<string>> {
+        if (!this.isConnected) return new Set();
+
+        try {
+            const urls = new Set<string>();
+            const { frameTree } = await this.sendInternal('Page.getFrameTree', {}, 5000);
+            const visit = (node: any) => {
+                const url = node?.frame?.url;
+                if (typeof url === 'string' && url.includes('vscode-webview')) {
+                    urls.add(url);
+                }
+                for (const child of node?.childFrames || []) visit(child);
+            };
+            if (frameTree) visit(frameTree);
+            if (urls.size > 0) return urls;
+        } catch { /* fall through to DOM scan */ }
+
+        try {
+            const raw = await this.evaluate(
+                `JSON.stringify(Array.from(document.querySelectorAll('iframe,webview'))
+                    .map((el) => el.src || el.getAttribute('src') || '')
+                    .filter((src) => typeof src === 'string' && src.includes('vscode-webview')))`,
+                5000,
+            );
+            const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            if (!Array.isArray(parsed)) return new Set();
+            return new Set(parsed.filter((src: unknown): src is string => typeof src === 'string' && src.length > 0));
+        } catch {
+            return new Set();
+        }
+    }
+
  // ─── Screenshot ──────────────────────────────────────────
 
     async captureScreenshot(opts?: { quality?: number }): Promise<Buffer | null> {

package/src/cdp/setup.ts

@@ -9,14 +9,13 @@ import { DaemonCdpManager } from './manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { IdeProviderInstance } from '../providers/ide-provider-instance.js';
-import type { ProviderModule } from '../providers/contracts.js';
+import { SessionRegistry } from '../sessions/registry.js';
 
 export interface CdpSetupContext {
   providerLoader: ProviderLoader;
   instanceManager: ProviderInstanceManager;
   cdpManagers: Map<string, DaemonCdpManager>;
-  /** UUID instanceId → CDP manager key mapping */
-  instanceIdMap: Map<string, string>;
+  sessionRegistry: SessionRegistry;
   /** Server connection (optional) */
   serverConn?: any;
 }
@@ -58,7 +57,7 @@ export function registerExtensionProviders(
  * 2. Create IdeProviderInstance
  * 3. Register in InstanceManager
  * 4. Register enabled extensions
- * 5. Update instanceIdMap (IDE + extension UUIDs)
+ * 5. Register runtime sessions (workspace + extension children)
  *
  * @returns The created IdeProviderInstance, or null if provider not found
  */
@@ -66,7 +65,7 @@ export async function setupIdeInstance(
   ctx: CdpSetupContext,
   opts: SetupIdeInstanceOptions,
 ): Promise<IdeProviderInstance | null> {
-  const { providerLoader, instanceManager, instanceIdMap } = ctx;
+  const { providerLoader, instanceManager, sessionRegistry } = ctx;
   const { ideType, manager, settings } = opts;
   const managerKey = opts.managerKey || ideType;
 
@@ -91,18 +90,34 @@ export async function setupIdeInstance(
     settings: resolvedSettings,
   });
 
-  // 5. Map IDE instance UUID → manager key
-  instanceIdMap.set(ideInstance.getInstanceId(), managerKey);
+  // 5. Register workspace session
+  sessionRegistry.register({
+    sessionId: ideInstance.getInstanceId(),
+    parentSessionId: null,
+    providerType: ideType,
+    providerCategory: 'ide',
+    transport: 'cdp-page',
+    cdpManagerKey: managerKey,
+    instanceKey: `ide:${managerKey}`,
+  });
 
   // 6. Register enabled extensions
   const extensionProviders = providerLoader.getEnabledByCategory('extension', ideType);
   for (const extProvider of extensionProviders) {
     const extSettings = providerLoader.getSettings(extProvider.type);
     await ideInstance.addExtension(extProvider, extSettings);
-    // Map extension UUIDs too (CDP uses parent IDE)
-    for (const ext of ideInstance.getExtensionInstances()) {
-      instanceIdMap.set(ext.getInstanceId(), managerKey);
-    }
+  }
+
+  for (const ext of ideInstance.getExtensionInstances()) {
+    sessionRegistry.register({
+      sessionId: ext.getInstanceId(),
+      parentSessionId: ideInstance.getInstanceId(),
+      providerType: ext.type,
+      providerCategory: 'extension',
+      transport: 'cdp-webview',
+      cdpManagerKey: managerKey,
+      instanceKey: `ide:${managerKey}`,
+    });
   }
 
   return ideInstance;