@adhdev/daemon-core 0.5.8 → 0.5.16

package/src/commands/router.ts

@@ -16,7 +16,7 @@ import { DaemonCommandHandler } from './handler.js';
 import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
-import { launchWithCdp } from '../launch.js';
+import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
 import { loadConfig, saveConfig, updateConfig } from '../config/config.js';
 import { resolveIdeLaunchWorkspace } from '../config/workspaces.js';
 import { appendWorkspaceActivity } from '../config/workspace-activity.js';
@@ -159,9 +159,9 @@ export class DaemonCommandRouter {
                     this.deps.providerLoader.getMeta(targetType)?.category === 'ide';
 
                 if (isIde) {
-                    // IDE restart: stop → launch
-                    await this.stopIde(targetType);
-                    const launchResult = await this.executeDaemonCommand('launch_ide', { ideType: targetType, enableCdp: true });
+                    // IDE restart: stop (with process kill) → launch
+                    await this.stopIde(targetType, true);
+                    const launchResult = await this.executeDaemonCommand('launch_ide', { ideType: targetType, enableCdp: true, workspace: args?.workspace });
                     return { success: true, restarted: true, ideType: targetType, launch: launchResult };
                 }
 
@@ -173,16 +173,17 @@ export class DaemonCommandRouter {
             case 'stop_ide': {
                 const ideType = args?.ideType;
                 if (!ideType) throw new Error('ideType required');
-                await this.stopIde(ideType);
-                return { success: true, ideType, stopped: true };
+                const killProcess = args?.killProcess !== false; // default true
+                await this.stopIde(ideType, killProcess);
+                return { success: true, ideType, stopped: true, processKilled: killProcess };
             }
 
             // ─── IDE restart ───
             case 'restart_ide': {
                 const ideType = args?.ideType;
                 if (!ideType) throw new Error('ideType required');
-                await this.stopIde(ideType);
-                const launchResult = await this.executeDaemonCommand('launch_ide', { ideType, enableCdp: true });
+                await this.stopIde(ideType, true); // always kill process on restart
+                const launchResult = await this.executeDaemonCommand('launch_ide', { ideType, enableCdp: true, workspace: args?.workspace });
                 return { success: true, ideType, restarted: true, launch: launchResult };
             }
 
@@ -235,10 +236,57 @@ export class DaemonCommandRouter {
                 return { success: result.success, ...result as any };
             }
 
-            // ─── IDE detection ───
+            // ─── Detect IDEs ───
             case 'detect_ides': {
-                this.deps.detectedIdes.value = await detectIDEs();
-                return { success: true, ides: this.deps.detectedIdes.value };
+                const results = await detectIDEs();
+                this.deps.detectedIdes.value = results;
+                return { success: true, detectedInfo: results };
+            }
+
+            // ─── Set User Name ───
+            case 'set_user_name': {
+                const name = args?.userName;
+                if (!name || typeof name !== 'string') throw new Error('userName required');
+                updateConfig({ userName: name });
+                return { success: true, userName: name };
+            }
+
+            // ─── Daemon Self-Upgrade ───
+            case 'daemon_upgrade': {
+                LOG.info('Upgrade', 'Remote upgrade requested from dashboard');
+                try {
+                    const { execSync } = await import('child_process');
+
+                    // Check latest version
+                    const latest = execSync('npm view adhdev version', { encoding: 'utf-8', timeout: 10000 }).trim();
+                    LOG.info('Upgrade', `Latest available: v${latest}`);
+
+                    // Install latest
+                    execSync('npm install -g adhdev@latest', {
+                        encoding: 'utf-8',
+                        timeout: 60000,
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    LOG.info('Upgrade', `✅ Upgraded to v${latest}`);
+
+                    // Schedule restart after response is sent
+                    setTimeout(() => {
+                        LOG.info('Upgrade', 'Restarting daemon with new version...');
+                        const { spawn } = require('child_process');
+                        const child = spawn(process.execPath, [process.argv[1], 'daemon', '-p', '19222'], {
+                            detached: true,
+                            stdio: 'ignore',
+                            env: { ...process.env },
+                        });
+                        child.unref();
+                        process.exit(0);
+                    }, 3000);
+
+                    return { success: true, upgraded: true, version: latest };
+                } catch (e: any) {
+                    LOG.error('Upgrade', `Failed: ${e.message}`);
+                    return { success: false, error: e.message };
+                }
             }
 
             // ─── Machine Settings ───
@@ -247,42 +295,93 @@ export class DaemonCommandRouter {
                 updateConfig({ machineNickname: nickname || null });
                 return { success: true };
             }
+
+            default:
+                break;
         }
 
         return null; // Not handled at this level → delegate to CommandHandler
     }
 
     /**
-     * IDE stop: CDP disconnect + remove from InstanceManager + clean instanceIdMap
+     * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
      */
-    private async stopIde(ideType: string): Promise<void> {
-        // 1. Release CDP manager
-        const cdp = this.deps.cdpManagers.get(ideType);
-        if (cdp) {
-            try { cdp.disconnect(); } catch { /* noop */ }
-            this.deps.cdpManagers.delete(ideType);
-            LOG.info('StopIDE', `CDP disconnected: ${ideType}`);
+    private async stopIde(ideType: string, killProcess: boolean = false): Promise<void> {
+        // 1. Release CDP manager(s) — handle multi-instance (e.g. "cursor" and "cursor_workspace")
+        const cdpKeysToRemove: string[] = [];
+        for (const key of this.deps.cdpManagers.keys()) {
+            if (key === ideType || key.startsWith(`${ideType}_`)) {
+                cdpKeysToRemove.push(key);
+            }
+        }
+        for (const key of cdpKeysToRemove) {
+            const cdp = this.deps.cdpManagers.get(key);
+            if (cdp) {
+                try { cdp.disconnect(); } catch { /* noop */ }
+                this.deps.cdpManagers.delete(key);
+                LOG.info('StopIDE', `CDP disconnected: ${key}`);
+            }
         }
 
-        // 2. Remove IDE instance from InstanceManager
-        const instanceKey = `ide:${ideType}`;
-        const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
-        if (ideInstance) {
-            // Remove IDE and child Extension UUIDs from instanceIdMap
-            if (ideInstance.getInstanceId) {
-                this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
+        // 2. Remove IDE instance(s) from InstanceManager
+        const keysToRemove: string[] = [];
+        for (const key of (this.deps.instanceManager as any).instances?.keys?.() || []) {
+            if (key === `ide:${ideType}` || (typeof key === 'string' && key.startsWith(`ide:${ideType}_`))) {
+                keysToRemove.push(key);
+            }
+        }
+        for (const instanceKey of keysToRemove) {
+            const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
+            if (ideInstance) {
+                // Remove IDE and child Extension UUIDs from instanceIdMap
+                if (ideInstance.getInstanceId) {
+                    this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
+                }
+                if (ideInstance.getExtensionInstances) {
+                    for (const ext of ideInstance.getExtensionInstances()) {
+                        if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
+                    }
+                }
+                this.deps.instanceManager.removeInstance(instanceKey);
+                LOG.info('StopIDE', `Instance removed: ${instanceKey}`);
             }
-            if (ideInstance.getExtensionInstances) {
-                for (const ext of ideInstance.getExtensionInstances()) {
-                    if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
+        }
+        // Fallback: single instance key
+        if (keysToRemove.length === 0) {
+            const instanceKey = `ide:${ideType}`;
+            const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
+            if (ideInstance) {
+                if (ideInstance.getInstanceId) {
+                    this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
+                }
+                if (ideInstance.getExtensionInstances) {
+                    for (const ext of ideInstance.getExtensionInstances()) {
+                        if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
+                    }
+                }
+                this.deps.instanceManager.removeInstance(instanceKey);
+                LOG.info('StopIDE', `Instance removed: ${instanceKey}`);
+            }
+        }
+
+        // 3. Kill OS process if requested
+        if (killProcess) {
+            const running = isIdeRunning(ideType);
+            if (running) {
+                LOG.info('StopIDE', `Killing IDE process: ${ideType}`);
+                const killed = await killIdeProcess(ideType);
+                if (killed) {
+                    LOG.info('StopIDE', `✅ Process killed: ${ideType}`);
+                } else {
+                    LOG.warn('StopIDE', `⚠ Could not kill process: ${ideType} (may need manual intervention)`);
                 }
+            } else {
+                LOG.info('StopIDE', `Process not running: ${ideType}`);
             }
-            this.deps.instanceManager.removeInstance(instanceKey);
-            LOG.info('StopIDE', `Instance removed: ${instanceKey}`);
         }
 
-        // 3. Notify consumer for status update
+        // 4. Notify consumer for status update
         this.deps.onStatusChange?.();
-        LOG.info('StopIDE', `IDE stopped: ${ideType}`);
+        LOG.info('StopIDE', `IDE stopped: ${ideType} (processKill=${killProcess})`);
     }
 }

package/src/daemon/dev-server.ts

@@ -21,6 +21,8 @@ import * as os from 'os';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ChildProcess } from 'child_process';
 import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { DaemonCliManager } from '../commands/cli-manager.js';
 import { generateTemplate as genScaffoldTemplate, generateFiles as genScaffoldFiles } from './scaffold-template.js';
 import { VersionArchive, detectAllVersions } from '../providers/version-archive.js';
 import { LOG } from '../logging/logger.js';
@@ -31,6 +33,8 @@ export class DevServer {
   private server: http.Server | null = null;
   private providerLoader: ProviderLoader;
   private cdpManagers: Map<string, DaemonCdpManager>;
+  private instanceManager: ProviderInstanceManager | null;
+  private cliManager: DaemonCliManager | null;
   private logFn: (msg: string) => void;
   private sseClients: http.ServerResponse[] = [];
   private watchScriptPath: string | null = null;
@@ -42,13 +46,20 @@ export class DevServer {
   private autoImplSSEClients: http.ServerResponse[] = [];
   private autoImplStatus: { running: boolean; type: string | null; progress: any[] } = { running: false, type: null, progress: [] };
 
+  // CLI debug SSE
+  private cliSSEClients: http.ServerResponse[] = [];
+
   constructor(options: {
     providerLoader: ProviderLoader;
     cdpManagers: Map<string, DaemonCdpManager>;
+    instanceManager?: ProviderInstanceManager;
+    cliManager?: DaemonCliManager;
     logFn?: (msg: string) => void;
   }) {
     this.providerLoader = options.providerLoader;
     this.cdpManagers = options.cdpManagers;
+    this.instanceManager = options.instanceManager || null;
+    this.cliManager = options.cliManager || null;
     this.logFn = options.logFn || LOG.forComponent('DevServer').asLogFn();
   }
 
@@ -81,6 +92,15 @@ export class DevServer {
     { method: 'POST', pattern: '/api/watch/stop',          handler: (q, s) => this.handleWatchStop(q, s) },
     { method: 'GET',  pattern: '/api/watch/events',        handler: (q, s) => this.handleSSE(q, s) },
     { method: 'POST', pattern: '/api/scaffold',            handler: (q, s) => this.handleScaffold(q, s) },
+    // CLI Debug routes
+    { method: 'GET',  pattern: '/api/cli/status',           handler: (q, s) => this.handleCliStatus(q, s) },
+    { method: 'POST', pattern: '/api/cli/launch',           handler: (q, s) => this.handleCliLaunch(q, s) },
+    { method: 'POST', pattern: '/api/cli/send',             handler: (q, s) => this.handleCliSend(q, s) },
+    { method: 'POST', pattern: '/api/cli/resolve',           handler: (q, s) => this.handleCliResolve(q, s) },
+    { method: 'POST', pattern: '/api/cli/raw',               handler: (q, s) => this.handleCliRaw(q, s) },
+    { method: 'POST', pattern: '/api/cli/stop',              handler: (q, s) => this.handleCliStop(q, s) },
+    { method: 'GET',  pattern: '/api/cli/events',            handler: (q, s) => this.handleCliSSE(q, s) },
+    { method: 'GET',  pattern: /^\/api\/cli\/debug\/([^/]+)$/, handler: (q, s, p) => this.handleCliDebug(p![0], q, s) },
     // Dynamic routes (provider :type param)
     { method: 'POST', pattern: /^\/api\/providers\/([^/]+)\/script$/,                handler: (q, s, p) => this.handleRunScript(p![0], q, s) },
     { method: 'GET',  pattern: /^\/api\/providers\/([^/]+)\/files$/,                 handler: (q, s, p) => this.handleListFiles(p![0], q, s) },
@@ -2375,4 +2395,269 @@ export class DevServer {
       });
     });
   }
+
+  // ─── CLI Debug Handlers ──────────────────────────────
+
+  /** GET /api/cli/status — list all running CLI/ACP instances with state */
+  private async handleCliStatus(_req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: 'InstanceManager not available (daemon not fully initialized)' });
+      return;
+    }
+    const allStates = this.instanceManager.collectAllStates();
+    const cliStates = allStates.filter(s => s.category === 'cli' || s.category === 'acp');
+    const result = cliStates.map(s => ({
+      instanceId: s.instanceId,
+      type: s.type,
+      name: s.name,
+      category: s.category,
+      status: s.status,
+      mode: s.mode,
+      workspace: s.workspace,
+      messageCount: s.activeChat?.messages?.length || 0,
+      lastMessage: s.activeChat?.messages?.slice(-1)[0] || null,
+      activeModal: s.activeChat?.activeModal || null,
+      pendingEvents: s.pendingEvents || [],
+      currentModel: s.currentModel,
+      settings: s.settings,
+    }));
+    this.json(res, 200, { instances: result, count: result.length });
+  }
+
+  /** POST /api/cli/launch — launch a CLI agent { type, workingDir?, args? } */
+  private async handleCliLaunch(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    if (!this.cliManager) {
+      this.json(res, 503, { error: 'CliManager not available' });
+      return;
+    }
+    const body = await this.readBody(req);
+    const { type, workingDir, args } = body;
+    if (!type) {
+      this.json(res, 400, { error: 'type required (e.g. claude-cli, gemini-cli)' });
+      return;
+    }
+    try {
+      await this.cliManager.startSession(type, workingDir || process.cwd(), args || []);
+      this.json(res, 200, { launched: true, type, workspace: workingDir || process.cwd() });
+    } catch (e: any) {
+      this.json(res, 500, { error: `Launch failed: ${e.message}` });
+    }
+  }
+
+  /** POST /api/cli/send — send message to a running CLI { type, text } */
+  private async handleCliSend(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: 'InstanceManager not available' });
+      return;
+    }
+    const body = await this.readBody(req);
+    const { type, text, instanceId } = body;
+    if (!text) {
+      this.json(res, 400, { error: 'text required' });
+      return;
+    }
+
+    // Find the CLI instance by type or instanceId
+    const allStates = this.instanceManager.collectAllStates();
+    const target = allStates.find(s =>
+      (s.category === 'cli' || s.category === 'acp') &&
+      (instanceId ? s.instanceId === instanceId : s.type === type)
+    );
+    if (!target) {
+      this.json(res, 404, { error: `No running instance found for: ${type || instanceId}` });
+      return;
+    }
+
+    try {
+      this.instanceManager.sendEvent(target.instanceId, 'send_message', { text });
+      this.json(res, 200, { sent: true, type: target.type, instanceId: target.instanceId });
+    } catch (e: any) {
+      this.json(res, 500, { error: `Send failed: ${e.message}` });
+    }
+  }
+
+  /** POST /api/cli/stop — stop a running CLI { type } */
+  private async handleCliStop(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: 'InstanceManager not available' });
+      return;
+    }
+    const body = await this.readBody(req);
+    const { type, instanceId } = body;
+
+    const allStates = this.instanceManager.collectAllStates();
+    const target = allStates.find(s =>
+      (s.category === 'cli' || s.category === 'acp') &&
+      (instanceId ? s.instanceId === instanceId : s.type === type)
+    );
+    if (!target) {
+      this.json(res, 404, { error: `No running instance found for: ${type || instanceId}` });
+      return;
+    }
+
+    try {
+      this.instanceManager.removeInstance(target.instanceId);
+      this.json(res, 200, { stopped: true, type: target.type, instanceId: target.instanceId });
+    } catch (e: any) {
+      this.json(res, 500, { error: `Stop failed: ${e.message}` });
+    }
+  }
+
+  /** GET /api/cli/events — SSE stream of CLI status events */
+  private handleCliSSE(_req: http.IncomingMessage, res: http.ServerResponse): void {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    });
+    res.write('data: {"type":"connected"}\n\n');
+    this.cliSSEClients.push(res);
+
+    // Register event listener if first client + instanceManager available
+    if (this.cliSSEClients.length === 1 && this.instanceManager) {
+      this.instanceManager.onEvent((event) => {
+        this.sendCliSSE(event);
+      });
+    }
+
+    // Send current state snapshot immediately
+    if (this.instanceManager) {
+      const allStates = this.instanceManager.collectAllStates();
+      const cliStates = allStates.filter(s => s.category === 'cli' || s.category === 'acp');
+      for (const s of cliStates) {
+        this.sendCliSSE({ event: 'snapshot', providerType: s.type, status: s.status, instanceId: s.instanceId });
+      }
+    }
+
+    _req.on('close', () => {
+      this.cliSSEClients = this.cliSSEClients.filter(c => c !== res);
+    });
+  }
+
+  private sendCliSSE(data: any): void {
+    const msg = `data: ${JSON.stringify({ ...data, timestamp: Date.now() })}\n\n`;
+    for (const client of this.cliSSEClients) {
+      try { client.write(msg); } catch { /* ignore */ }
+    }
+  }
+
+  /** GET /api/cli/debug/:type — full internal debug state of a CLI adapter */
+  private async handleCliDebug(type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: 'InstanceManager not available' });
+      return;
+    }
+
+    // Find the matching CLI instance
+    const allStates = this.instanceManager.collectAllStates();
+    const target = allStates.find(s =>
+      (s.category === 'cli' || s.category === 'acp') && s.type === type
+    );
+    if (!target) {
+      this.json(res, 404, { error: `No running instance for: ${type}`, available: allStates.filter(s => s.category === 'cli' || s.category === 'acp').map(s => s.type) });
+      return;
+    }
+
+    // Get the ProviderInstance and access adapter debug state
+    const instance = this.instanceManager.getInstance(target.instanceId) as any;
+    if (!instance) {
+      this.json(res, 404, { error: `Instance not found: ${target.instanceId}` });
+      return;
+    }
+
+    try {
+      const adapter = instance.getAdapter?.() || instance.adapter;
+      if (adapter && typeof adapter.getDebugState === 'function') {
+        const debugState = adapter.getDebugState();
+        this.json(res, 200, {
+          instanceId: target.instanceId,
+          providerState: {
+            type: target.type,
+            name: target.name,
+            status: target.status,
+            mode: 'mode' in target ? target.mode : undefined,
+          },
+          debug: debugState,
+        });
+      } else {
+        // Fallback: return what we can from the state
+        this.json(res, 200, {
+          instanceId: target.instanceId,
+          providerState: target,
+          debug: null,
+          message: 'No debug state available (adapter.getDebugState not found)',
+        });
+      }
+    } catch (e: any) {
+      this.json(res, 500, { error: `Debug state failed: ${e.message}` });
+    }
+  }
+
+  /** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
+  private async handleCliResolve(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    const body = await this.readBody(req);
+    const { type, buttonIndex, instanceId } = body;
+    if (buttonIndex === undefined || buttonIndex === null) {
+      this.json(res, 400, { error: 'buttonIndex required (0=Yes, 1=Always, 2=Deny)' });
+      return;
+    }
+
+    if (!this.cliManager) {
+      this.json(res, 503, { error: 'CliManager not available' });
+      return;
+    }
+    // Find adapter from cliManager.adapters map
+    let adapter: any = null;
+    for (const [, a] of this.cliManager.adapters) {
+      if (type && (a as any).cliType === type) { adapter = a; break; }
+    }
+    if (!adapter) {
+      this.json(res, 404, { error: `No running adapter for: ${type || instanceId}` });
+      return;
+    }
+    try {
+      if (typeof adapter.resolveModal === 'function') {
+        adapter.resolveModal(buttonIndex);
+        this.json(res, 200, { resolved: true, type, buttonIndex });
+      } else {
+        this.json(res, 400, { error: 'resolveModal not available on this adapter' });
+      }
+    } catch (e: any) {
+      this.json(res, 500, { error: `Resolve failed: ${e.message}` });
+    }
+  }
+
+  /** POST /api/cli/raw — send raw keystrokes to PTY { type, keys } */
+  private async handleCliRaw(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    const body = await this.readBody(req);
+    const { type, keys, instanceId } = body;
+    if (!keys) {
+      this.json(res, 400, { error: 'keys required (raw string to send to PTY)' });
+      return;
+    }
+
+    if (!this.cliManager) {
+      this.json(res, 503, { error: 'CliManager not available' });
+      return;
+    }
+    let adapter: any = null;
+    for (const [, a] of this.cliManager.adapters) {
+      if (type && (a as any).cliType === type) { adapter = a; break; }
+    }
+    if (!adapter) {
+      this.json(res, 404, { error: `No running adapter for: ${type || instanceId}` });
+      return;
+    }
+    try {
+      if (typeof adapter.writeRaw === 'function') {
+        adapter.writeRaw(keys);
+        this.json(res, 200, { sent: true, type, keysLength: keys.length });
+      } else {
+        this.json(res, 400, { error: 'writeRaw not available on this adapter' });
+      }
+    } catch (e: any) {
+      this.json(res, 500, { error: `Raw send failed: ${e.message}` });
+    }
+  }
 }

package/src/daemon-core.ts

@@ -5,7 +5,8 @@
  * Actual implementation extracted from launcher and placed in this package.
  */
 
-import type { DaemonStatus, CommandResult, DaemonEvent, IdeEntry, CliEntry, AcpEntry } from './types.js';
+import type { StatusResponse, CommandResult, DaemonEvent } from './types.js';
+import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry } from './shared-types.js';
 
 export interface DaemonCoreOptions {
  /** Data directory for config, logs */
@@ -28,10 +29,10 @@ export interface IDaemonCore {
   stop(): Promise<void>;
 
  /** Get current daemon status snapshot */
-  getStatus(): DaemonStatus;
+  getStatus(): StatusResponse;
 
  /** Subscribe to status changes. Returns unsubscribe function. */
-  onStatusChange(callback: (status: DaemonStatus) => void): () => void;
+  onStatusChange(callback: (status: StatusResponse) => void): () => void;
 
  /** Subscribe to all daemon events. Returns unsubscribe function. */
   onEvent(callback: (event: DaemonEvent) => void): () => void;
@@ -40,11 +41,11 @@ export interface IDaemonCore {
   executeCommand(type: string, payload: any, target?: string): Promise<CommandResult>;
 
  /** Get currently detected/managed IDEs */
-  getManagedIdes(): IdeEntry[];
+  getManagedIdes(): ManagedIdeEntry[];
 
  /** Get currently detected/managed CLIs */
-  getManagedClis(): CliEntry[];
+  getManagedClis(): ManagedCliEntry[];
 
  /** Get currently detected/managed ACP agents */
-  getManagedAcps(): AcpEntry[];
+  getManagedAcps(): ManagedAcpEntry[];
 }

package/src/detection/ide-detector.ts

@@ -89,13 +89,13 @@ function getIdeVersion(cliCommand: string): string | null {
 }
 
 function checkPathExists(paths: string[]): string | null {
+    const home = homedir();
     for (const p of paths) {
         if (p.includes('*')) {
-            const home = homedir();
-            const starIdx = p.indexOf('*');
-            const suffix = p.substring(starIdx + 1);
-            const homeNormalized = home.replace(/\//g, '\\\\');
-            const resolved = homeNormalized + suffix;
+            // Wildcard expansion: replace `*` with the current user's home folder name
+            // e.g. "C:\Users\*\AppData\..." → "C:\Users\vilmi\AppData\..."
+            const username = home.split(/[\\/]/).pop() || '';
+            const resolved = p.replace('*', username);
             if (existsSync(resolved)) return resolved;
         } else {
             if (existsSync(p)) return p;

package/src/index.ts

@@ -7,10 +7,6 @@
 
 // ── Types ──
 export type {
-  DaemonStatus,
-  IdeEntry,
-  CliEntry,
-  AcpEntry,
   ChatMessage,
   ExtensionInfo,
   CommandResult as CoreCommandResult,
@@ -20,10 +16,32 @@ export type {
   SystemInfo,
   DetectedIde,
   ProviderInfo,
-  AgentStreamEntry,
   AgentEntry,
 } from './types.js';
 
+// ── Shared Types (cross-package) ──
+export type {
+  ManagedIdeEntry,
+  ManagedCliEntry,
+  ManagedAcpEntry,
+  ManagedAgentStream,
+  AvailableProviderInfo,
+  AcpConfigOption,
+  AcpMode,
+  StatusReportPayload,
+  MachineInfo,
+  DetectedIdeInfo,
+  WorkspaceEntry,
+  WorkspaceActivity,
+  ProviderStatus,
+  ProviderErrorReason,
+  ActiveChatData,
+  IdeProviderState,
+  CliProviderState,
+  AcpProviderState,
+  ExtensionProviderState,
+} from './shared-types.js';
+
 // ── Core Interface ──
 export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
@@ -31,7 +49,6 @@ export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 export { loadConfig, saveConfig, resetConfig, isSetupComplete, addCliHistory, markSetupComplete, updateConfig } from './config/config.js';
 export { getWorkspaceState } from './config/workspaces.js';
 export { getWorkspaceActivity } from './config/workspace-activity.js';
-export type { WorkspaceEntry } from './config/workspaces.js';
 
 // ── Detection ──
 export { detectIDEs } from './detection/ide-detector.js';
@@ -68,7 +85,7 @@ export { logCommand, getRecentCommands } from './logging/command-log.js';
 export { DaemonCliManager } from './commands/cli-manager.js';
 
 // ── Launch ──
-export { launchWithCdp, getAvailableIdeIds } from './launch.js';
+export { launchWithCdp, getAvailableIdeIds, killIdeProcess, isIdeRunning } from './launch.js';
 
 // ── IPC ──
 export { DEFAULT_DAEMON_PORT, DAEMON_WS_PATH } from './ipc-protocol.js';