@adhdev/daemon-core 0.7.3 → 0.7.5

package/package.json

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

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;