@adhdev/daemon-core 0.6.77 → 0.6.79

package/src/commands/chat-commands.ts

@@ -71,8 +71,8 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
         // Alternative: AgentStreamManager (script fail when)
         if (h.agentStream) {
             const cdp = h.getCdp();
-            if (cdp) {
-                const streams = await h.agentStream.collectAgentStreams(cdp);
+            if (cdp && h.currentIdeType) {
+                const streams = await h.agentStream.collectAgentStreams(cdp, h.currentIdeType);
                 const stream = streams.find((s: any) => s.agentType === provider.type);
                 if (stream) {
                     h.historyWriter.appendNewMessages(
@@ -197,8 +197,8 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
             _log(`Extension script error: ${e.message}`);
         }
         // Method 2: AgentStreamManager
-        if (h.agentStream && h.getCdp()) {
-            const ok = await h.agentStream.sendToAgent(h.getCdp()!, provider.type, text, h.currentIdeType);
+        if (h.agentStream && h.getCdp() && h.currentIdeType) {
+            const ok = await h.agentStream.sendToAgent(h.getCdp()!, h.currentIdeType, provider.type, text, h.currentIdeType);
             if (ok) {
                 _log(`AgentStreamManager sent OK`);
                 return _logSendSuccess('agent-stream');
@@ -318,9 +318,9 @@ export async function handleListChats(h: CommandHelpers, args: any): Promise<Com
     const provider = h.getProvider(args?.agentType);
 
     // Extension: via AgentStreamManager
-    if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
+    if (provider?.category === 'extension' && h.agentStream && h.getCdp() && h.currentIdeType) {
         try {
-            const chats = await h.agentStream.listAgentChats(h.getCdp()!, provider.type);
+            const chats = await h.agentStream.listAgentChats(h.getCdp()!, h.currentIdeType, provider.type);
             LOG.info('Command', `[list_chats] Extension: ${chats.length} chats`);
             return { success: true, chats };
         } catch (e: any) {
@@ -377,8 +377,8 @@ export async function handleNewChat(h: CommandHelpers, args: any): Promise<Comma
         return { success: false, error: 'new_chat not supported by this CLI provider' };
     }
 
-    if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
-        const ok = await h.agentStream.newAgentSession(h.getCdp()!, provider.type, h.currentIdeType);
+    if (provider?.category === 'extension' && h.agentStream && h.getCdp() && h.currentIdeType) {
+        const ok = await h.agentStream.newAgentSession(h.getCdp()!, h.currentIdeType, provider.type, h.currentIdeType);
         return { success: ok };
     }
 
@@ -412,8 +412,8 @@ export async function handleSwitchChat(h: CommandHelpers, args: any): Promise<Co
     if (!sessionId) return { success: false, error: 'sessionId required' };
     LOG.info('Command', `[switch_chat] sessionId=${sessionId}, ideType=${ideType}`);
 
-    if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
-        const ok = await h.agentStream.switchAgentSession(h.getCdp()!, provider.type, sessionId);
+    if (provider?.category === 'extension' && h.agentStream && h.getCdp() && h.currentIdeType) {
+        const ok = await h.agentStream.switchAgentSession(h.getCdp()!, h.currentIdeType, provider.type, sessionId);
         return { success: ok, result: ok ? 'switched' : 'failed' };
     }
 
@@ -681,9 +681,9 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
     }
 
     // 1. Extension: via AgentStreamManager
-    if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
+    if (provider?.category === 'extension' && h.agentStream && h.getCdp() && h.currentIdeType) {
         const ok = await h.agentStream.resolveAgentAction(
-            h.getCdp()!, provider.type, action, h.currentIdeType
+            h.getCdp()!, h.currentIdeType, provider.type, action, h.currentIdeType
         );
         return { success: ok };
     }

package/src/commands/handler.ts

@@ -97,7 +97,7 @@ export class DaemonCommandHandler implements CommandHelpers {
         // 1. Try instanceIdMap (UUID → managerKey)
         const resolved = this._ctx.instanceIdMap?.get(key) || key;
         // 2. Use findCdpManager (exact + prefix match)
-        const m = findCdpManager(this._ctx.cdpManagers, resolved.toLowerCase());
+        const m = findCdpManager(this._ctx.cdpManagers, resolved);
         if (m?.isConnected) return m;
         return null;
     }
@@ -148,11 +148,11 @@ export class DaemonCommandHandler implements CommandHelpers {
 
         // Extension: evaluateInSession
         if (provider?.category === 'extension') {
-            let sessionId = this.getExtensionSessionId(provider);
-            if (!sessionId && this._agentStream) {
-                await this._agentStream.switchActiveAgent(cdp, provider.type);
-                await this._agentStream.syncAgentSessions(cdp);
-                sessionId = this.getExtensionSessionId(provider);
+            let sessionId = this.getExtensionSessionId(provider, this._currentIdeType);
+            if (!sessionId && this._agentStream && this._currentIdeType) {
+                await this._agentStream.switchActiveAgent(cdp, this._currentIdeType, provider.type);
+                await this._agentStream.syncAgentSessions(cdp, this._currentIdeType);
+                sessionId = this.getExtensionSessionId(provider, this._currentIdeType);
             }
             if (!sessionId) return null;
             const result = await cdp.evaluateInSessionFrame(sessionId, script, timeout);
@@ -194,18 +194,48 @@ export class DaemonCommandHandler implements CommandHelpers {
 
     // ─── Private helpers ──────────────────────────────
 
-    private getExtensionSessionId(provider: ProviderModule): string | null {
-        if (provider.category !== 'extension' || !this._agentStream) return null;
-        const managed = this._agentStream.getManagedAgent(provider.type);
+    private getExtensionSessionId(provider: ProviderModule, scopeKey?: string): string | null {
+        if (provider.category !== 'extension' || !this._agentStream || !scopeKey) return null;
+        const managed = this._agentStream.getManagedAgent(provider.type, scopeKey);
         return managed?.sessionId || null;
     }
 
+    private resolveManagerKeyFromInstanceId(instanceId: string): string | undefined {
+        const mapped = this._ctx.instanceIdMap?.get(instanceId);
+        if (mapped) return mapped;
+
+        const entries = (this._ctx.instanceManager as any)?.instances?.entries?.();
+        if (!entries) return undefined;
+
+        for (const [instanceKey, instance] of entries as Iterable<[string, any]>) {
+            if (typeof instanceKey !== 'string' || !instanceKey.startsWith('ide:')) continue;
+
+            if (typeof instance?.getInstanceId === 'function' && instance.getInstanceId() === instanceId) {
+                const managerKey = instanceKey.slice(4);
+                this._ctx.instanceIdMap?.set(instanceId, managerKey);
+                return managerKey;
+            }
+
+            if (typeof instance?.getExtensionInstances === 'function') {
+                for (const ext of instance.getExtensionInstances() || []) {
+                    if (typeof ext?.getInstanceId === 'function' && ext.getInstanceId() === instanceId) {
+                        const managerKey = instanceKey.slice(4);
+                        this._ctx.instanceIdMap?.set(instanceId, managerKey);
+                        return managerKey;
+                    }
+                }
+            }
+        }
+
+        return undefined;
+    }
+
     /** Extract ideType from _targetInstance or explicit ideType */
     private extractIdeType(args: any): string | undefined {
         // Also accept explicit ideType from args (P2P input, agentType for extensions)
         if (args?.ideType) {
             // UUID → managerKey via instanceIdMap (P2P sends UUID instance IDs)
-            const mappedKey = this._ctx.instanceIdMap?.get(args.ideType);
+            const mappedKey = this.resolveManagerKeyFromInstanceId(args.ideType);
             if (mappedKey) {
                 return mappedKey;
             }
@@ -232,8 +262,9 @@ export class DaemonCommandHandler implements CommandHelpers {
             else if (cliMatch) raw = cliMatch[1];
             else if (acpMatch) raw = acpMatch[1];
 
-            if (this._ctx.instanceIdMap?.has(raw)) {
-                return this._ctx.instanceIdMap.get(raw)!;
+            const mappedKey = this.resolveManagerKeyFromInstanceId(raw);
+            if (mappedKey) {
+                return mappedKey;
             }
 
             // Direct CDP manager key match (e.g. "cursor", "cursor_remote_vs")

package/src/commands/stream-commands.ts

@@ -11,15 +11,15 @@ 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' };
+    if (!h.agentStream || !h.getCdp() || !h.currentIdeType) return { success: false, error: 'AgentStream or CDP not available' };
     const agentType = args?.agentType || args?.agent || null;
-    await h.agentStream.switchActiveAgent(h.getCdp()!, agentType);
+    await h.agentStream.switchActiveAgent(h.getCdp()!, h.currentIdeType, 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()!);
+    if (!h.agentStream || !h.getCdp() || !h.currentIdeType) return { success: false, error: 'AgentStream or CDP not available' };
+    const streams = await h.agentStream.collectAgentStreams(h.getCdp()!, h.currentIdeType);
     return { success: true, streams };
 }
 
@@ -46,52 +46,58 @@ export async function handleAgentStreamSend(h: CommandHelpers, args: any): Promi
 
     // 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;
+    const resolvedAgent = agentType || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
     if (!resolvedAgent) return { success: false, error: 'agentType required' };
-    const ok = await h.agentStream.sendToAgent(h.getCdp()!, resolvedAgent, text, h.currentIdeType);
+    if (!h.currentIdeType) return { success: false, error: 'ideType required' };
+    const ok = await h.agentStream.sendToAgent(h.getCdp()!, h.currentIdeType, 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 agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
     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);
+    if (!h.currentIdeType) return { success: false, error: 'ideType required' };
+    const ok = await h.agentStream.resolveAgentAction(h.getCdp()!, h.currentIdeType, 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;
+    const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
     if (!agentType) return { success: false, error: 'agentType required' };
-    const ok = await h.agentStream.newAgentSession(h.getCdp()!, agentType, h.currentIdeType);
+    if (!h.currentIdeType) return { success: false, error: 'ideType required' };
+    const ok = await h.agentStream.newAgentSession(h.getCdp()!, h.currentIdeType, 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;
+    const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
     if (!agentType) return { success: false, error: 'agentType required' };
-    const chats = await h.agentStream.listAgentChats(h.getCdp()!, agentType);
+    if (!h.currentIdeType) return { success: false, error: 'ideType required' };
+    const chats = await h.agentStream.listAgentChats(h.getCdp()!, h.currentIdeType, 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 agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
     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);
+    if (!h.currentIdeType) return { success: false, error: 'ideType required' };
+    const ok = await h.agentStream.switchAgentSession(h.getCdp()!, h.currentIdeType, 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;
+    const agentType = args?.agentType || args?.agent || (h.currentIdeType ? h.agentStream.getActiveAgentType(h.currentIdeType) : null);
     if (!agentType) return { success: false, error: 'agentType required' };
     await h.agentStream.ensureAgentPanelOpen(agentType, h.currentIdeType);
-    const ok = await h.agentStream.focusAgentEditor(h.getCdp()!, agentType);
+    if (!h.currentIdeType) return { success: false, error: 'ideType required' };
+    const ok = await h.agentStream.focusAgentEditor(h.getCdp()!, h.currentIdeType, agentType);
     return { success: ok };
 }
 

package/src/index.ts

@@ -76,6 +76,8 @@ export type { CommandRouterDeps, CommandRouterResult } from './commands/router.j
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildManagedIdes, buildManagedClis, buildManagedAcps, buildAllManagedEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
 export { buildStatusSnapshot } from './status/snapshot.js';
+export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';
+export type { ManagedStatus } from './status/normalize.js';
 export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';
 
 // ── Logger ──

package/src/status/builders.ts

@@ -16,6 +16,7 @@ import type {
     AcpProviderState,
     ProviderState,
 } from '../providers/provider-instance.js';
+import { normalizeActiveChatData, normalizeManagedStatus } from './normalize.js';
 
 // ─── CDP Manager lookup helpers ──────────────────────
 
@@ -100,13 +101,13 @@ export function buildManagedIdes(
             workspace: state.workspace || null,
             terminals: 0,
             aiAgents: [],
-            activeChat: state.activeChat,
+            activeChat: normalizeActiveChatData(state.activeChat),
             chats: [],
             agentStreams: state.extensions.map((ext) => ({
                 agentType: ext.type,
                 agentName: ext.name,
                 extensionId: ext.type,
-                status: ext.status || 'idle',
+                status: normalizeManagedStatus(ext.status, { activeModal: ext.activeChat?.activeModal || null }),
                 messages: ext.activeChat?.messages || [],
                 inputContent: ext.activeChat?.inputContent || '',
                 activeModal: ext.activeChat?.activeModal || null,
@@ -155,10 +156,10 @@ export function buildManagedClis(
         instanceId: s.instanceId,
         cliType: s.type,
         cliName: s.name,
-        status: s.status,
+        status: normalizeManagedStatus(s.status, { activeModal: s.activeChat?.activeModal || null }),
         mode: 'terminal' as const,
         workspace: s.workspace || '',
-        activeChat: s.activeChat,
+        activeChat: normalizeActiveChatData(s.activeChat),
     }));
 }
 
@@ -172,10 +173,10 @@ export function buildManagedAcps(
         id: s.instanceId,
         acpType: s.type,
         acpName: s.name,
-        status: s.status,
+        status: normalizeManagedStatus(s.status, { activeModal: s.activeChat?.activeModal || null }),
         mode: 'chat' as const,
         workspace: s.workspace || '',
-        activeChat: s.activeChat,
+        activeChat: normalizeActiveChatData(s.activeChat),
         currentModel: s.currentModel,
         currentPlan: s.currentPlan,
         acpConfigOptions: s.acpConfigOptions,

package/src/status/normalize.ts

@@ -0,0 +1,64 @@
+import type { ActiveChatData } from '../providers/provider-instance.js';
+
+export type ManagedStatus =
+    | 'idle'
+    | 'generating'
+    | 'waiting_approval'
+    | 'error'
+    | 'stopped'
+    | 'starting'
+    | 'panel_hidden'
+    | 'not_monitored'
+    | 'disconnected';
+
+const WORKING_STATUSES = new Set([
+    'generating',
+    'streaming',
+    'loading',
+    'loading_reference',
+    'thinking',
+    'active',
+]);
+
+function hasApprovalButtons(activeModal?: { buttons?: unknown[] | null } | null): boolean {
+    return (activeModal?.buttons?.length ?? 0) > 0;
+}
+
+export function normalizeManagedStatus(
+    status?: string | null,
+    opts?: { activeModal?: { buttons?: unknown[] | null } | null },
+): ManagedStatus {
+    if (hasApprovalButtons(opts?.activeModal)) return 'waiting_approval';
+
+    const normalized = String(status || 'idle').trim().toLowerCase();
+    if (normalized === 'waiting_approval') return 'waiting_approval';
+    if (WORKING_STATUSES.has(normalized)) return 'generating';
+    if (normalized === 'error') return 'error';
+    if (normalized === 'stopped') return 'stopped';
+    if (normalized === 'starting') return 'starting';
+    if (normalized === 'panel_hidden') return 'panel_hidden';
+    if (normalized === 'not_monitored') return 'not_monitored';
+    if (normalized === 'disconnected') return 'disconnected';
+    return 'idle';
+}
+
+export function isManagedStatusWorking(status?: string | null): boolean {
+    return normalizeManagedStatus(status) === 'generating';
+}
+
+export function isManagedStatusWaiting(
+    status?: string | null,
+    opts?: { activeModal?: { buttons?: unknown[] | null } | null },
+): boolean {
+    return normalizeManagedStatus(status, opts) === 'waiting_approval';
+}
+
+export function normalizeActiveChatData<T extends ActiveChatData | null | undefined>(
+    activeChat: T,
+): T {
+    if (!activeChat) return activeChat;
+    return {
+        ...activeChat,
+        status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
+    } as T;
+}