@adhdev/daemon-core 0.6.77 → 0.7.0

package/src/commands/chat-commands.ts

@@ -7,15 +7,49 @@ import type { CommandResult, CommandHelpers } from './handler.js';
 import { readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 
+const RECENT_SEND_WINDOW_MS = 1200;
+const recentSendByTarget = new Map<string, number>();
+
+function getCurrentProviderType(h: CommandHelpers, fallback = ''): string {
+    return h.currentSession?.providerType || h.currentProviderType || fallback;
+}
+
+function getCurrentManagerKey(h: CommandHelpers): string {
+    return h.currentSession?.cdpManagerKey || h.currentManagerKey || '';
+}
+
 function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: string) {
-    return h.getCliAdapter(args?._targetInstance || h.currentIdeType || providerType);
+    return h.getCliAdapter(args?.targetSessionId || providerType || h.currentSession?.providerType || h.currentManagerKey);
+}
+
+function buildRecentSendKey(h: CommandHelpers, args: any, provider: any, text: string): string {
+    const target =
+        args?.targetSessionId
+        || args?.agentType
+        || h.currentSession?.providerType
+        || h.currentProviderType
+        || h.currentManagerKey
+        || 'unknown';
+    return `${provider?.category || 'unknown'}:${target}:${text.trim()}`;
+}
+
+function isRecentDuplicateSend(key: string): boolean {
+    const now = Date.now();
+    for (const [candidate, ts] of recentSendByTarget.entries()) {
+        if (now - ts > RECENT_SEND_WINDOW_MS) recentSendByTarget.delete(candidate);
+    }
+    const previous = recentSendByTarget.get(key);
+    if (previous && (now - previous) <= RECENT_SEND_WINDOW_MS) return true;
+    recentSendByTarget.set(key, now);
+    return false;
 }
 
 export async function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const { agentType, offset, limit, instanceId } = args;
+    const { agentType, offset, limit } = args;
+    const instanceId = args?.targetSessionId;
     try {
         const provider = h.getProvider(agentType);
-        const agentStr = provider?.type || agentType || h.currentIdeType || '';
+        const agentStr = provider?.type || agentType || getCurrentProviderType(h);
         const result = readChatHistory(agentStr, offset || 0, limit || 30, instanceId);
         return { success: true, ...result, agent: agentStr };
     } catch (e: any) {
@@ -60,7 +94,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         provider.type || 'unknown_extension',
                         parsed.messages || [],
                         parsed.title,
-                        args?.instanceId
+                        args?.targetSessionId
                     );
                     return { success: true, ...parsed };
                 }
@@ -71,15 +105,18 @@ 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);
-                const stream = streams.find((s: any) => s.agentType === provider.type);
+            const parentSessionId = h.currentSession?.parentSessionId;
+            if (cdp && parentSessionId) {
+                const stream = await h.agentStream.collectActiveSession(cdp, parentSessionId);
+                if (stream?.agentType !== provider.type) {
+                    return { success: true, messages: [], status: 'idle' };
+                }
                 if (stream) {
                     h.historyWriter.appendNewMessages(
                         stream.agentType,
                         stream.messages || [],
                         undefined,
-                        args?.instanceId
+                        args?.targetSessionId
                     );
                     return { success: true, messages: stream.messages || [], status: stream.status, agentType: stream.agentType };
                 }
@@ -107,11 +144,11 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 if (parsed && typeof parsed === 'object') {
                     _log(`Webview OK: ${parsed.messages?.length || 0} msgs`);
                     h.historyWriter.appendNewMessages(
-                        provider?.type || h.currentIdeType || 'unknown_webview',
-                        parsed.messages || [],
-                        parsed.title,
-                        args?.instanceId
-                    );
+                    provider?.type || getCurrentProviderType(h, 'unknown_webview'),
+                    parsed.messages || [],
+                    parsed.title,
+                    args?.targetSessionId
+                );
                     return { success: true, ...parsed };
                 }
             }
@@ -131,10 +168,10 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             if (parsed && typeof parsed === 'object' && parsed.messages?.length > 0) {
                 _log(`OK: ${parsed.messages?.length} msgs`);
                 h.historyWriter.appendNewMessages(
-                    provider?.type || h.currentIdeType || 'unknown_ide',
+                    provider?.type || getCurrentProviderType(h, 'unknown_ide'),
                     parsed.messages || [],
                     parsed.title,
-                    args?.instanceId
+                    args?.targetSessionId
                 );
                 return { success: true, ...parsed };
             }
@@ -151,17 +188,23 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
     if (!text) return { success: false, error: 'text required' };
     const _log = (msg: string) => LOG.debug('Command', `[send_chat] ${msg}`);
     const provider = h.getProvider(args?.agentType);
+    const dedupeKey = buildRecentSendKey(h, args, provider, text);
 
     const _logSendSuccess = (method: string, targetAgent?: string) => {
         h.historyWriter.appendNewMessages(
-            targetAgent || provider?.type || h.currentIdeType || 'unknown_agent',
+            targetAgent || provider?.type || getCurrentProviderType(h, 'unknown_agent'),
             [{ role: 'user', content: text, receivedAt: Date.now() }],
             undefined, // title
-            args?.instanceId
+            args?.targetSessionId
         );
         return { success: true, sent: true, method, targetAgent };
     };
 
+    if (isRecentDuplicateSend(dedupeKey)) {
+        _log(`Suppressed duplicate send for ${dedupeKey}`);
+        return { success: true, sent: false, deduplicated: true };
+    }
+
     // CLI / ACP category: transmit via adapter
     if (provider?.category === 'cli' || provider?.category === 'acp') {
         const adapter = getTargetedCliAdapter(h, args, provider.type);
@@ -197,8 +240,9 @@ 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);
+        const extensionSessionId = h.currentSession?.sessionId;
+        if (h.agentStream && h.getCdp() && extensionSessionId) {
+            const ok = await h.agentStream.sendToSession(h.getCdp()!, extensionSessionId, text);
             if (ok) {
                 _log(`AgentStreamManager sent OK`);
                 return _logSendSuccess('agent-stream');
@@ -207,50 +251,15 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         return { success: false, error: `Extension '${provider.type}' send failed` };
     }
 
-    // IDE category (default): Provider → typeAndSend → script
+    // IDE category (default): provider sendMessage script is authoritative when present.
     const targetCdp = h.getCdp();
     if (!targetCdp?.isConnected) {
-        _log(`No CDP for ${h.currentIdeType}`);
-        return { success: false, error: `CDP for ${h.currentIdeType || 'unknown'} not connected` };
+        const managerKey = getCurrentManagerKey(h);
+        _log(`No CDP for ${managerKey}`);
+        return { success: false, error: `CDP for ${managerKey || 'unknown'} not connected` };
     }
 
-    _log(`Targeting IDE: ${h.currentIdeType}`);
-
-    // Method 0: webview-based IDE (try webviewSendMessage first)
-    if (provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
-        try {
-            const webviewScript = (provider.scripts as any).webviewSendMessage(text);
-            if (webviewScript && targetCdp.evaluateInWebviewFrame) {
-                const matchText = provider.webviewMatchText;
-                const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
-                const wvResult = await targetCdp.evaluateInWebviewFrame(webviewScript, matchFn);
-                let wvParsed: any = wvResult;
-                if (typeof wvResult === 'string') { try { wvParsed = JSON.parse(wvResult); } catch { } }
-                if (wvParsed?.sent) {
-                    _log(`webviewSendMessage (priority) OK`);
-                    return _logSendSuccess('webview-script-priority');
-                }
-                _log(`webviewSendMessage (priority) did not confirm sent, falling through`);
-            }
-        } catch (e: any) {
-            _log(`webviewSendMessage (priority) failed: ${e.message}, falling through`);
-        }
-    }
-
-    // Method 1: use provider.inputMethod if available (main frame input)
-    if (provider?.inputMethod === 'cdp-type-and-send' && provider.inputSelector) {
-        try {
-            const sent = await targetCdp.typeAndSend(provider.inputSelector, text);
-            if (sent) {
-                _log(`typeAndSend(provider.inputSelector=${provider.inputSelector}) success`);
-                return _logSendSuccess('typeAndSend-provider');
-            }
-        } catch (e: any) {
-            _log(`typeAndSend(provider) failed: ${e.message}`);
-        }
-    }
-
-    // Method 2: provider sendMessage script
+    _log(`Targeting IDE: ${getCurrentManagerKey(h)}`);
     const sendScript = h.getProviderScript('sendMessage', { MESSAGE: text });
     if (sendScript) {
         try {
@@ -261,7 +270,6 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
                 _log(`sendMessage script OK`);
                 return _logSendSuccess('script');
             }
-            // needsTypeAndSend response: typeAndSend using script-specified selector
             if (parsed?.needsTypeAndSend && parsed?.selector) {
                 try {
                     const sent = await targetCdp.typeAndSend(parsed.selector, text);
@@ -273,8 +281,30 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
                     _log(`typeAndSend(script.selector) failed: ${e.message}`);
                 }
             }
-            // webviewSendMessage: attempt direct transmission from inside webview iframe
-            if (parsed?.needsTypeAndSend && provider?.scripts?.webviewSendMessage) {
+            if (parsed?.needsTypeAndSend && parsed?.clickCoords) {
+                try {
+                    const { x, y } = parsed.clickCoords;
+                    const sent = await targetCdp.typeAndSendAt(x, y, text);
+                    if (sent) {
+                        _log(`typeAndSendAt(${x},${y}) success`);
+                        return _logSendSuccess('typeAndSendAt-script');
+                    }
+                } catch (e: any) {
+                    _log(`typeAndSendAt failed: ${e.message}`);
+                }
+            }
+            if (parsed?.needsTypeAndSend && provider?.inputMethod === 'cdp-type-and-send' && provider.inputSelector) {
+                try {
+                    const sent = await targetCdp.typeAndSend(provider.inputSelector, text);
+                    if (sent) {
+                        _log(`typeAndSend(provider.inputSelector=${provider.inputSelector}) success`);
+                        return _logSendSuccess('typeAndSend-provider');
+                    }
+                } catch (e: any) {
+                    _log(`typeAndSend(provider) failed: ${e.message}`);
+                }
+            }
+            if (parsed?.needsTypeAndSend && provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
                 try {
                     const webviewScript = (provider.scripts as any).webviewSendMessage(text);
                     if (webviewScript && targetCdp.evaluateInWebviewFrame) {
@@ -292,21 +322,41 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
                     _log(`webviewSendMessage failed: ${e.message}`);
                 }
             }
-            // Coordinate-based fallback: input field inside webview iframe
-            if (parsed?.needsTypeAndSend && parsed?.clickCoords) {
-                try {
-                    const { x, y } = parsed.clickCoords;
-                    const sent = await targetCdp.typeAndSendAt(x, y, text);
-                    if (sent) {
-                        _log(`typeAndSendAt(${x},${y}) success`);
-                        return _logSendSuccess('typeAndSendAt-script');
-                    }
-                } catch (e: any) {
-                    _log(`typeAndSendAt failed: ${e.message}`);
+            return { success: false, error: parsed?.error || 'Provider sendMessage did not confirm send' };
+        } catch (e: any) {
+            _log(`sendMessage script failed: ${e.message}`);
+            return { success: false, error: `Provider sendMessage failed: ${e.message}` };
+        }
+    }
+
+    if (provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
+        try {
+            const webviewScript = (provider.scripts as any).webviewSendMessage(text);
+            if (webviewScript && targetCdp.evaluateInWebviewFrame) {
+                const matchText = provider.webviewMatchText;
+                const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
+                const wvResult = await targetCdp.evaluateInWebviewFrame(webviewScript, matchFn);
+                let wvParsed: any = wvResult;
+                if (typeof wvResult === 'string') { try { wvParsed = JSON.parse(wvResult); } catch { } }
+                if (wvParsed?.sent) {
+                    _log(`webviewSendMessage OK`);
+                    return _logSendSuccess('webview-script');
                 }
             }
         } catch (e: any) {
-            _log(`sendMessage script failed: ${e.message}`);
+            _log(`webviewSendMessage failed: ${e.message}`);
+        }
+    }
+
+    if (provider?.inputMethod === 'cdp-type-and-send' && provider.inputSelector) {
+        try {
+            const sent = await targetCdp.typeAndSend(provider.inputSelector, text);
+            if (sent) {
+                _log(`typeAndSend(provider.inputSelector=${provider.inputSelector}) success`);
+                return _logSendSuccess('typeAndSend-provider');
+            }
+        } catch (e: any) {
+            _log(`typeAndSend(provider) failed: ${e.message}`);
         }
     }
 
@@ -318,9 +368,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.currentSession?.sessionId) {
         try {
-            const chats = await h.agentStream.listAgentChats(h.getCdp()!, provider.type);
+            const chats = await h.agentStream.listSessionChats(h.getCdp()!, h.currentSession.sessionId);
             LOG.info('Command', `[list_chats] Extension: ${chats.length} chats`);
             return { success: true, chats };
         } catch (e: any) {
@@ -377,8 +427,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.currentSession?.sessionId) {
+        const ok = await h.agentStream.newSession(h.getCdp()!, h.currentSession.sessionId);
         return { success: ok };
     }
 
@@ -407,17 +457,17 @@ export async function handleNewChat(h: CommandHelpers, args: any): Promise<Comma
 
 export async function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult> {
     const provider = h.getProvider(args?.agentType);
-    const ideType = h.currentIdeType;
+    const managerKey = getCurrentManagerKey(h);
     const sessionId = args?.sessionId || args?.id || args?.chatId;
     if (!sessionId) return { success: false, error: 'sessionId required' };
-    LOG.info('Command', `[switch_chat] sessionId=${sessionId}, ideType=${ideType}`);
+    LOG.info('Command', `[switch_chat] sessionId=${sessionId}, manager=${managerKey}`);
 
-    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.currentSession?.sessionId) {
+        const ok = await h.agentStream.switchConversation(h.getCdp()!, h.currentSession.sessionId, sessionId);
         return { success: ok, result: ok ? 'switched' : 'failed' };
     }
 
-    const cdp = h.getCdp(ideType);
+    const cdp = h.getCdp(managerKey);
     if (!cdp?.isConnected) return { success: false, error: 'CDP not connected' };
 
     // webview IDE
@@ -549,7 +599,7 @@ export async function handleChangeModel(h: CommandHelpers, args: any): Promise<C
     const provider = h.getProvider(args?.agentType);
     const model = args?.model;
 
-    LOG.info('Command', `[change_model] model=${model} provider=${provider?.type} category=${provider?.category} ideType=${h.currentIdeType} providerType=${h.currentProviderType}`);
+    LOG.info('Command', `[change_model] model=${model} provider=${provider?.type} category=${provider?.category} manager=${getCurrentManagerKey(h)} providerType=${getCurrentProviderType(h)}`);
 
     // ACP provider
     if (provider?.category === 'acp') {
@@ -681,10 +731,8 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
     }
 
     // 1. Extension: via AgentStreamManager
-    if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
-        const ok = await h.agentStream.resolveAgentAction(
-            h.getCdp()!, provider.type, action, h.currentIdeType
-        );
+    if (provider?.category === 'extension' && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
+        const ok = await h.agentStream.resolveSessionAction(h.getCdp()!, h.currentSession.sessionId, action);
         return { success: ok };
     }
 

package/src/commands/cli-manager.ts

@@ -19,6 +19,7 @@ import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
+import type { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 
 // ─── external dependency interface ──────────────────────────
@@ -33,6 +34,7 @@ export interface CliManagerDeps {
     removeAgentTracking(key: string): void;
  /** InstanceManager — register in CLI unified status */
     getInstanceManager(): ProviderInstanceManager | null;
+    getSessionRegistry?(): SessionRegistry | null;
 }
 
 type CommandResult = { success: boolean;[key: string]: unknown };
@@ -105,6 +107,7 @@ export class DaemonCliManager {
 
  // Create UUID-based key (allows separate instances even for same type+dir)
         const key = crypto.randomUUID();
+        const sessionRegistry = this.deps.getSessionRegistry?.() || null;
 
  // ─── ACP category handle ───
         if (provider && provider.category === 'acp') {
@@ -133,6 +136,16 @@ export class DaemonCliManager {
             await instanceManager.addInstance(key, acpInstance, {
                 settings: this.providerLoader.getSettings(normalizedType),
             });
+            const sessionId = acpInstance.getInstanceId();
+            sessionRegistry?.register({
+                sessionId,
+                parentSessionId: null,
+                providerType: normalizedType,
+                providerCategory: 'acp',
+                transport: 'acp',
+                adapterKey: key,
+                instanceKey: key,
+            });
 
  // Register ACP entry in adapter map (getStatus queries from acpInstance in real-time)
             this.adapters.set(key, {
@@ -190,9 +203,18 @@ export class DaemonCliManager {
                     serverConn: this.deps.getServerConn(),
                     settings: {},
                     onPtyData: (data: string) => {
-                        this.deps.getP2p()?.broadcastPtyOutput(key, data);
+                        this.deps.getP2p()?.broadcastPtyOutput(cliInstance.instanceId, data);
                     },
                 });
+                sessionRegistry?.register({
+                    sessionId: cliInstance.instanceId,
+                    parentSessionId: null,
+                    providerType: normalizedType,
+                    providerCategory: 'cli',
+                    transport: 'pty',
+                    adapterKey: key,
+                    instanceKey: key,
+                });
             } catch (spawnErr: any) {
                 // Spawn failed — cleanup and propagate error
                 LOG.error('CLI', `[${cliType}] Spawn failed: ${spawnErr?.message}`);
@@ -216,6 +238,7 @@ export class DaemonCliManager {
                             if (this.adapters.has(key)) {
                                 this.adapters.delete(key);
                                 this.deps.removeAgentTracking(key);
+                                sessionRegistry?.unregisterByInstanceKey(key);
                                 instanceManager.removeInstance(key);
                                 LOG.info('CLI', `🧹 Auto-cleaned ${status.status} CLI: ${cliType}`);
                                 this.deps.onStatusChange();
@@ -279,6 +302,7 @@ export class DaemonCliManager {
             // Always cleanup regardless of shutdown success
             this.adapters.delete(key);
             this.deps.removeAgentTracking(key);
+            this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
             this.deps.getInstanceManager()?.removeInstance(key);
             LOG.info('CLI', `🛑 Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
             this.deps.onStatusChange();
@@ -286,6 +310,7 @@ export class DaemonCliManager {
             // Adapter not found — try InstanceManager direct removal
             const im = this.deps.getInstanceManager();
             if (im) {
+                this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
                 im.removeInstance(key);
                 this.deps.removeAgentTracking(key);
                 LOG.warn('CLI', `🧹 Force-removed orphan entry: ${key}`);
@@ -303,7 +328,7 @@ export class DaemonCliManager {
 
  /**
  * Search for CLI adapter. Priority order:
- * 0. instanceKey (UUID direct match) — extracted from _targetInstance / composite ID
+ * 0. sessionId (UUID direct match)
  * 1. agentType + dir (iteration match)
  * 2. agentType fuzzy match (⚠ returns first match when multiple sessions exist)
  */
@@ -382,8 +407,8 @@ export class DaemonCliManager {
                 const cliType = args?.cliType;
                 const dir = args?.dir || '';
                 if (!cliType) throw new Error('cliType required');
- // UUID (_targetInstance) based search priority
-                const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
+ // UUID session target based search priority
+                const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
                 if (found) {
                     await this.stopSession(found.key);
                 } else {
@@ -415,7 +440,7 @@ export class DaemonCliManager {
                 }
                 const dir = rdir.path;
                 if (!cliType) throw new Error('cliType required');
-                const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
+                const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
                 if (found) await this.stopSession(found.key);
                 await this.startSession(cliType, dir);
                 this.persistRecentDir(cliType, dir);
@@ -428,7 +453,7 @@ export class DaemonCliManager {
 
                 const found = this.findAdapter(agentType, {
                     dir: args?.dir,
-                    instanceKey: args?._targetInstance,
+                    instanceKey: args?.targetSessionId,
                 });
                 if (!found) throw new Error(`CLI agent not running: ${agentType}`);
                 const { adapter, key } = found;