@adhdev/daemon-core 0.7.4 → 0.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/forward.ts

@@ -24,6 +24,12 @@ export function forwardAgentStreamsToIdeInstance(
             activeModal: stream.activeModal || null,
             model: stream.model || undefined,
             mode: stream.mode || undefined,
+            sessionId: stream.sessionId || stream.instanceId || undefined,
+            title: stream.title || stream.agentName || undefined,
+            agentType: stream.agentType || undefined,
+            agentName: stream.agentName || undefined,
+            extensionId: stream.extensionId || undefined,
+            inputContent: stream.inputContent || '',
         });
     }
 }

package/src/boot/daemon-lifecycle.ts

@@ -185,7 +185,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
 
             if (ideInstance) {
                 instanceManager.removeInstance(instanceKey);
-                LOG.info('CDP', `Instance removed after disconnect: ${instanceKey}`);
+                LOG.info('IDE', `Instance removed after detach: ${instanceKey}`);
             }
 
             if (ideInstance?.getInstanceId) {

package/src/cdp/initializer.ts

@@ -78,9 +78,9 @@ export class DaemonCdpInitializer {
 
         // Summary
         if (cdpManagers.size > 0) {
-            LOG.info('CDP', `${cdpManagers.size} IDE(s) connected: ${[...cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(', ')}`);
+            LOG.info('IDE', `${cdpManagers.size} IDE window(s) attached: ${[...cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(', ')}`);
         } else {
-            LOG.warn('CDP', `No IDEs connected — tried: ${filtered.map(p => `${p.ide}:${p.port}`).join(', ')}`);
+            LOG.warn('IDE', `No IDE windows attached — tried: ${filtered.map(p => `${p.ide}:${p.port}`).join(', ')}`);
         }
     }
 
@@ -113,7 +113,7 @@ export class DaemonCdpInitializer {
             if (connected) {
                 registerExtensionProviders(providerLoader, manager, ide);
                 cdpManagers.set(ide, manager);
-                LOG.info('CDP', `Connected: ${ide} (port ${port})`);
+                LOG.info('IDE', `Attached: ${ide} (port ${port})`);
                 await this.config.onConnected?.(ide, manager, ide);
             }
             return;
@@ -155,7 +155,7 @@ export class DaemonCdpInitializer {
             if (connected) {
                 registerExtensionProviders(providerLoader, manager, ide);
                 cdpManagers.set(managerKey, manager);
-                LOG.info('CDP', `Connected: ${managerKey} (port ${port}${targets.length > 1 ? `, page "${target.title}"` : ''})`);
+                LOG.info('IDE', `Attached window: ${managerKey} (port ${port}${targets.length > 1 ? `, page "${target.title}"` : ''})`);
                 await this.config.onConnected?.(ide, manager, managerKey);
             }
         }
@@ -195,7 +195,7 @@ export class DaemonCdpInitializer {
         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})`);
+            LOG.info('IDE', `Detached window: ${key} (${reason})`);
             await this.config.onDisconnected?.(ide, manager, key, reason);
         }
     }

package/src/cdp/scanner.ts

@@ -134,7 +134,7 @@ export class DaemonCdpScanner {
 
     registerExtensionProviders(this.ctx.providerLoader, manager, ide);
     this.ctx.cdpManagers.set(ide, manager);
-    LOG.info('CDP', `Connected: ${ide} (port ${port})`);
+    LOG.info('IDE', `Attached: ${ide} (port ${port})`);
 
     // Setup IDE instance
     await setupIdeInstance(this.ctx, { ideType: ide, manager });
@@ -172,7 +172,7 @@ export class DaemonCdpScanner {
       if (!manager) continue;
 
       this.ctx.cdpManagers.set(managerKey, manager);
-      LOG.info('CDP', `Connected: ${managerKey} (port ${port}, page "${target.title}")`);
+      LOG.info('IDE', `Attached window: ${managerKey} (port ${port}, page "${target.title}")`);
 
       await setupIdeInstance(this.ctx, {
         ideType: ide,

package/src/commands/handler.ts

@@ -65,6 +65,96 @@ export interface CommandHelpers {
     readonly historyWriter: ChatHistoryWriter;
 }
 
+const COMMAND_DEBUG_LEVELS = new Set([
+    'pty_input',
+    'pty_resize',
+    'cdp_eval',
+    'cdp_batch',
+    'cdp_dom_query',
+    'cdp_dom_dump',
+    'cdp_dom_debug',
+]);
+
+function logAtLevel(level: 'debug' | 'info' | 'warn' | 'error', category: string, message: string): void {
+    switch (level) {
+        case 'debug':
+            LOG.debug(category, message);
+            return;
+        case 'warn':
+            LOG.warn(category, message);
+            return;
+        case 'error':
+            LOG.error(category, message);
+            return;
+        default:
+            LOG.info(category, message);
+    }
+}
+
+function getCommandLogLevel(cmd: string): 'debug' | 'info' {
+    return COMMAND_DEBUG_LEVELS.has(cmd) ? 'debug' : 'info';
+}
+
+function summarizeLogValue(value: unknown): string {
+    if (value === null) return 'null';
+    if (value === undefined) return 'undefined';
+    if (typeof value === 'string') {
+        const normalized = value.replace(/\s+/g, ' ').trim();
+        if (!normalized) return '""';
+        if (normalized.length <= 80) return JSON.stringify(normalized);
+        return `${JSON.stringify(normalized.slice(0, 80))}…(${normalized.length} chars)`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+    if (Array.isArray(value)) return `[${value.length} items]`;
+    if (typeof value === 'object') return '{...}';
+    return String(value);
+}
+
+function summarizeCommandArgs(args: any): string {
+    if (!args || typeof args !== 'object') return '-';
+
+    const preferredKeys = [
+        'targetSessionId',
+        'providerType',
+        'agentType',
+        'ideType',
+        'model',
+        'mode',
+        'action',
+        'button',
+        'key',
+        'force',
+        'offset',
+        'limit',
+        'cols',
+        'rows',
+        'path',
+        'command',
+        'commandId',
+        'workspace',
+        'dir',
+        'url',
+        'text',
+        'message',
+        'data',
+        'value',
+    ];
+
+    const entries: string[] = [];
+    for (const key of preferredKeys) {
+        if (!(key in args) || args[key] === undefined) continue;
+        const value =
+            key === 'text' || key === 'message'
+                ? `${String(args[key] || '').length} chars`
+                : key === 'data'
+                    ? `${String(args[key] || '').length} chars`
+                    : summarizeLogValue(args[key]);
+        entries.push(`${key}=${value}`);
+    }
+
+    return entries.length ? entries.join(' ') : '{...}';
+}
+
 export class DaemonCommandHandler implements CommandHelpers {
     private _ctx: CommandContext;
     private _agentStream: DaemonAgentStreamManager | null = null;
@@ -235,6 +325,30 @@ export class DaemonCommandHandler implements CommandHelpers {
         return undefined;
     }
 
+    private logCommandStart(cmd: string, args: any): void {
+        const routeBits = [
+            this._currentRoute.session?.sessionId ? `session=${this._currentRoute.session.sessionId}` : '',
+            this._currentRoute.managerKey ? `manager=${this._currentRoute.managerKey}` : '',
+            this._currentRoute.providerType ? `provider=${this._currentRoute.providerType}` : '',
+        ].filter(Boolean).join(' ');
+        const summary = summarizeCommandArgs(args);
+        logAtLevel(
+            getCommandLogLevel(cmd),
+            'Command',
+            `[${cmd}] start${routeBits ? ` ${routeBits}` : ''} args=${summary}`,
+        );
+    }
+
+    private logCommandEnd(cmd: string, result: CommandResult, startedAt: number): void {
+        const durationMs = Date.now() - startedAt;
+        const parts = [`[${cmd}] end`, `success=${result.success}`, `duration=${durationMs}ms`];
+        if (typeof result.error === 'string' && result.error) {
+            parts.push(`error=${JSON.stringify(result.error)}`);
+        }
+        const level = result.success ? getCommandLogLevel(cmd) : 'warn';
+        logAtLevel(level, 'Command', parts.join(' '));
+    }
+
     setAgentStreamManager(manager: DaemonAgentStreamManager): void {
         this._agentStream = manager;
     }
@@ -244,20 +358,29 @@ export class DaemonCommandHandler implements CommandHelpers {
     async handle(cmd: string, args: any): Promise<CommandResult> {
         // Per-request: extract target session / CDP scope / provider type from args
         this._currentRoute = this.resolveRoute(args);
+        const startedAt = Date.now();
+        this.logCommandStart(cmd, args);
 
         // Commands without ideType CDP silently fail (prevent P2P retry spam)
+        let result: CommandResult;
         if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {
             const cdpCommands = ['send_chat', 'read_chat', 'list_chats', 'new_chat', 'switch_chat', 'set_mode', 'change_model', 'set_thought_level', 'resolve_action'];
             if (cdpCommands.includes(cmd)) {
-                return { success: false, error: 'No targetSessionId specified — cannot route command' };
+                result = { success: false, error: 'No targetSessionId specified — cannot route command' };
+                this.logCommandEnd(cmd, result, startedAt);
+                return result;
             }
         }
 
         try {
-            return await this.dispatch(cmd, args);
+            result = await this.dispatch(cmd, args);
+            this.logCommandEnd(cmd, result, startedAt);
+            return result;
         } catch (e: any) {
             LOG.error('Command', `[${cmd}] Unhandled error: ${e?.message || e}`);
-            return { success: false, error: `Internal error: ${e?.message || 'unknown'}` };
+            result = { success: false, error: `Internal error: ${e?.message || 'unknown'}` };
+            this.logCommandEnd(cmd, result, startedAt);
+            return result;
         }
     }
 

package/src/commands/stream-commands.ts

@@ -85,7 +85,6 @@ export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandR
 
 export async function handleExtensionScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult> {
     const { agentType, ideType } = args || {};
-    LOG.info('Command', `[ExtScript] ${scriptName} agentType=${agentType} ideType=${ideType} session=${h.currentSession?.sessionId || ''}`);
     if (!agentType) return { success: false, error: 'agentType is required' };
 
     const loader = h.ctx.providerLoader;

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

@@ -32,6 +32,10 @@ export class ExtensionProviderInstance implements ProviderInstance {
  // meta
     private instanceId: string;
     private ideType: string = '';
+    private chatId: string | null = null;
+    private chatTitle: string | null = null;
+    private agentName: string = '';
+    private extensionId: string = '';
 
     constructor(provider: ProviderModule) {
         this.type = provider.type;
@@ -69,8 +73,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
             category: 'extension',
             status: this.currentStatus as ProviderState['status'],
             activeChat: this.messages.length > 0 ? {
-                id: `${this.type}_session`,
-                title: this.provider.name,
+                id: this.chatId || this.instanceId,
+                title: this.chatTitle || this.agentName || this.provider.name,
                 status: this.currentStatus,
                 messages: this.messages,
                 activeModal: this.activeModal,
@@ -94,6 +98,10 @@ export class ExtensionProviderInstance implements ProviderInstance {
             if (data?.activeModal !== undefined) this.activeModal = data.activeModal;
             if (data?.model) this.currentModel = data.model;
             if (data?.mode) this.currentMode = data.mode;
+            if (typeof data?.sessionId === 'string' && data.sessionId.trim()) this.chatId = data.sessionId;
+            if (typeof data?.title === 'string' && data.title.trim()) this.chatTitle = data.title;
+            if (typeof data?.agentName === 'string' && data.agentName.trim()) this.agentName = data.agentName;
+            if (typeof data?.extensionId === 'string' && data.extensionId.trim()) this.extensionId = data.extensionId;
             if (data?.status) {
                 const newStatus = data.status;
                 this.detectTransition(newStatus, data);
@@ -117,12 +125,6 @@ export class ExtensionProviderInstance implements ProviderInstance {
     }
 
  // ─── status transition detect ──────────────────────────────
-    // NOTE: Extension transitions are TRACKED but NOT emitted as events.
-    // The parent IdeProviderInstance already emits identical events
-    // (generating_started, generating_completed, waiting_approval)
-    // via its own detectAgentTransitions(). Emitting here would cause
-    // duplicate toasts with slightly different content.
-
     private detectTransition(newStatus: string, data: any): void {
         const now = Date.now();
         const agentStatus = (newStatus === 'streaming' || newStatus === 'generating') ? 'generating'
@@ -136,13 +138,44 @@ export class ExtensionProviderInstance implements ProviderInstance {
             : undefined;
 
         if (agentStatus !== this.lastAgentStatus) {
-            // Track generating start time (for monitor elapsed calculation)
             if (this.lastAgentStatus === 'idle' && agentStatus === 'generating') {
                 this.generatingStartedAt = now;
+                this.pushEvent({
+                    event: 'agent:generating_started',
+                    chatTitle: this.resolveChatTitle(data),
+                    timestamp: now,
+                    ideType: this.ideType || this.type,
+                    agentType: this.type,
+                    agentName: this.agentName || this.provider.name,
+                    extensionId: this.extensionId || this.type,
+                });
+            } else if (agentStatus === 'waiting_approval') {
+                if (!this.generatingStartedAt) this.generatingStartedAt = now;
+                this.pushEvent({
+                    event: 'agent:waiting_approval',
+                    chatTitle: this.resolveChatTitle(data),
+                    timestamp: now,
+                    ideType: this.ideType || this.type,
+                    agentType: this.type,
+                    agentName: this.agentName || this.provider.name,
+                    extensionId: this.extensionId || this.type,
+                    modalMessage: data?.activeModal?.message,
+                    modalButtons: data?.activeModal?.buttons,
+                });
             } else if (agentStatus === 'idle' && (this.lastAgentStatus === 'generating' || this.lastAgentStatus === 'waiting_approval')) {
+                const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
+                this.pushEvent({
+                    event: 'agent:generating_completed',
+                    chatTitle: this.resolveChatTitle(data),
+                    duration,
+                    timestamp: now,
+                    ideType: this.ideType || this.type,
+                    agentType: this.type,
+                    agentName: this.agentName || this.provider.name,
+                    extensionId: this.extensionId || this.type,
+                });
                 this.generatingStartedAt = 0;
             }
-            // Do NOT pushEvent for transitions — parent IDE instance handles these
             this.lastAgentStatus = agentStatus;
         }
 
@@ -164,4 +197,11 @@ export class ExtensionProviderInstance implements ProviderInstance {
         this.events = [];
         return events;
     }
+
+    private resolveChatTitle(data: any): string {
+        const title = typeof data?.title === 'string' && data.title.trim()
+            ? data.title.trim()
+            : this.chatTitle;
+        return title || this.agentName || this.provider.name;
+    }
 }

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

@@ -75,16 +75,13 @@ export class ProviderInstanceManager {
             try {
                 const state = instance.getState();
                 states.push(state);
-
- // pending events propagation
-                for (const event of state.pendingEvents) {
-                    for (const listener of this.eventListeners) {
-                        listener({
-                            ...event,
-                            providerType: instance.type,
-                            instanceId: state.instanceId,
-                            targetSessionId: state.instanceId,
-                            providerCategory: state.category,
+                this.emitPendingEvents(instance.type, state);
+                if (state.category === 'ide') {
+                    for (const childState of state.extensions) {
+                        this.emitPendingEvents(childState.type, childState, {
+                            targetSessionId: childState.instanceId,
+                            workspaceName: state.workspace || undefined,
+                            parentSessionId: state.instanceId,
                         });
                     }
                 }
@@ -141,6 +138,26 @@ export class ProviderInstanceManager {
         this.eventListeners.push(listener);
     }
 
+    private emitPendingEvents(
+        providerType: string,
+        state: ProviderState,
+        extra: Record<string, unknown> = {},
+    ): void {
+        for (const event of state.pendingEvents) {
+            for (const listener of this.eventListeners) {
+                listener({
+                    ...event,
+                    providerType,
+                    instanceId: state.instanceId,
+                    targetSessionId: state.instanceId,
+                    providerCategory: state.category,
+                    workspaceName: state.workspace || undefined,
+                    ...extra,
+                });
+            }
+        }
+    }
+
  /**
  * Forward event to specific Instance
  */