@adhdev/daemon-core 0.5.7 → 0.5.16

package/dist/index.js

@@ -396,7 +396,9 @@ __export(index_exports, {
   installExtensions: () => installExtensions,
   installGlobalInterceptor: () => installGlobalInterceptor,
   isExtensionInstalled: () => isExtensionInstalled,
+  isIdeRunning: () => isIdeRunning,
   isSetupComplete: () => isSetupComplete,
+  killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
   launchWithCdp: () => launchWithCdp,
   loadConfig: () => loadConfig,
@@ -499,13 +501,11 @@ function getIdeVersion(cliCommand) {
   }
 }
 function checkPathExists(paths) {
+  const home = (0, import_os2.homedir)();
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = (0, import_os2.homedir)();
-      const starIdx = p.indexOf("*");
-      const suffix = p.substring(starIdx + 1);
-      const homeNormalized = home.replace(/\//g, "\\\\");
-      const resolved = homeNormalized + suffix;
+      const username = home.split(/[\\/]/).pop() || "";
+      const resolved = p.replace("*", username);
       if ((0, import_fs2.existsSync)(resolved)) return resolved;
     } else {
       if ((0, import_fs2.existsSync)(p)) return p;
@@ -2340,8 +2340,7 @@ var IdeProviderInstance = class {
   // IDE meta
   ideVersion = "";
   instanceId;
-  workspaceFolders = [];
-  activeFile = null;
+  workspace = "";
   // ─── Child Extension Instances ────────────────────
   extensions = /* @__PURE__ */ new Map();
   constructor(provider, instanceKey) {
@@ -2402,8 +2401,7 @@ var IdeProviderInstance = class {
         activeModal: this.cachedChat.activeModal || null,
         inputContent: this.cachedChat.inputContent || ""
       } : null,
-      workspaceFolders: this.workspaceFolders,
-      activeFile: this.activeFile,
+      workspace: this.workspace || null,
       extensions: extensionStates,
       cdpConnected: cdp?.isConnected || false,
       currentModel: this.cachedChat?.model || void 0,
@@ -2420,11 +2418,6 @@ var IdeProviderInstance = class {
     } else if (event === "cdp_disconnected") {
       this.cachedChat = null;
       this.currentStatus = "idle";
-    } else if (event === "extension_data") {
-      if (data?.workspaceFolders) this.workspaceFolders = data.workspaceFolders;
-      if (data?.activeFile) this.activeFile = data.activeFile;
-      if (data?.ideVersion) this.ideVersion = data.ideVersion;
-      if (data?.instanceId) this.instanceId = data.instanceId;
     } else if (event === "stream_update") {
       const extType = data?.extensionType;
       if (extType && this.extensions.has(extType)) {
@@ -2480,6 +2473,10 @@ var IdeProviderInstance = class {
   getExtensionInstances() {
     return [...this.extensions.values()];
   }
+  /** Set workspace from daemon launch context */
+  setWorkspace(workspace) {
+    this.workspace = workspace;
+  }
   // ─── CDP readChat ───────────────────────────────
   async readChat() {
     const { cdp } = this.context;
@@ -6033,8 +6030,8 @@ var DaemonCommandRouter = class {
         if (!targetType) throw new Error("cliType or ideType required");
         const isIde = this.deps.cdpManagers.has(targetType) || this.deps.providerLoader.getMeta(targetType)?.category === "ide";
         if (isIde) {
-          await this.stopIde(targetType);
-          const launchResult = await this.executeDaemonCommand("launch_ide", { ideType: targetType, enableCdp: true });
+          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 };
         }
         return this.deps.cliManager.handleCliCommand(cmd, args);
@@ -6043,15 +6040,16 @@ var DaemonCommandRouter = class {
       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;
+        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);
+        const launchResult = await this.executeDaemonCommand("launch_ide", { ideType, enableCdp: true, workspace: args?.workspace });
         return { success: true, ideType, restarted: true, launch: launchResult };
       }
       // ─── IDE launch + CDP connect ───
@@ -6097,10 +6095,48 @@ var DaemonCommandRouter = class {
         }
         return { success: result.success, ...result };
       }
-      // ─── 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: execSync7 } = await import("child_process");
+          const latest = execSync7("npm view adhdev version", { encoding: "utf-8", timeout: 1e4 }).trim();
+          LOG.info("Upgrade", `Latest available: v${latest}`);
+          execSync7("npm install -g adhdev@latest", {
+            encoding: "utf-8",
+            timeout: 6e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          LOG.info("Upgrade", `\u2705 Upgraded to v${latest}`);
+          setTimeout(() => {
+            LOG.info("Upgrade", "Restarting daemon with new version...");
+            const { spawn: spawn3 } = require("child_process");
+            const child = spawn3(process.execPath, [process.argv[1], "daemon", "-p", "19222"], {
+              detached: true,
+              stdio: "ignore",
+              env: { ...process.env }
+            });
+            child.unref();
+            process.exit(0);
+          }, 3e3);
+          return { success: true, upgraded: true, version: latest };
+        } catch (e) {
+          LOG.error("Upgrade", `Failed: ${e.message}`);
+          return { success: false, error: e.message };
+        }
       }
       // ─── Machine Settings ───
       case "set_machine_nickname": {
@@ -6108,38 +6144,85 @@ var DaemonCommandRouter = class {
         updateConfig({ machineNickname: nickname || null });
         return { success: true };
       }
+      default:
+        break;
     }
     return null;
   }
   /**
-   * IDE stop: CDP disconnect + remove from InstanceManager + clean instanceIdMap
+   * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
    */
-  async stopIde(ideType) {
-    const cdp = this.deps.cdpManagers.get(ideType);
-    if (cdp) {
-      try {
-        cdp.disconnect();
-      } catch {
+  async stopIde(ideType, killProcess = false) {
+    const cdpKeysToRemove = [];
+    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 {
+        }
+        this.deps.cdpManagers.delete(key);
+        LOG.info("StopIDE", `CDP disconnected: ${key}`);
+      }
+    }
+    const keysToRemove = [];
+    for (const key of this.deps.instanceManager.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);
+      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}`);
       }
-      this.deps.cdpManagers.delete(ideType);
-      LOG.info("StopIDE", `CDP disconnected: ${ideType}`);
     }
-    const instanceKey = `ide:${ideType}`;
-    const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
-    if (ideInstance) {
-      if (ideInstance.getInstanceId) {
-        this.deps.instanceIdMap.delete(ideInstance.getInstanceId());
+    if (keysToRemove.length === 0) {
+      const instanceKey = `ide:${ideType}`;
+      const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
+      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}`);
       }
-      if (ideInstance.getExtensionInstances) {
-        for (const ext of ideInstance.getExtensionInstances()) {
-          if (ext.getInstanceId) this.deps.instanceIdMap.delete(ext.getInstanceId());
+    }
+    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", `\u2705 Process killed: ${ideType}`);
+        } else {
+          LOG.warn("StopIDE", `\u26A0 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}`);
     }
     this.deps.onStatusChange?.();
-    LOG.info("StopIDE", `IDE stopped: ${ideType}`);
+    LOG.info("StopIDE", `IDE stopped: ${ideType} (processKill=${killProcess})`);
   }
 };
 
@@ -6233,7 +6316,7 @@ var DaemonStatusReporter = class {
     const acpStates = allStates.filter((s) => s.category === "acp");
     const ideSummary = ideStates.map((s) => {
       const msgs = s.activeChat?.messages?.length || 0;
-      const exts = (s.extensions || []).length;
+      const exts = s.extensions.length;
       return `${s.type}(${s.status},${msgs}msg,${exts}ext${s.currentModel ? ",model=" + s.currentModel : ""})`;
     }).join(", ");
     const cliSummary = cliStates.map((s) => `${s.type}(${s.status})`).join(", ");
@@ -6253,13 +6336,12 @@ var DaemonStatusReporter = class {
       ideType: s.type,
       ideVersion: "",
       instanceId: s.instanceId,
-      workspaceFolders: s.workspaceFolders || [],
-      activeFile: s.activeFile || null,
+      workspace: s.workspace || null,
       terminals: 0,
       aiAgents: [],
       activeChat: s.activeChat,
       chats: [],
-      agentStreams: (s.extensions || []).map((ext) => ({
+      agentStreams: s.extensions.map((ext) => ({
         agentType: ext.type,
         agentName: ext.name,
         extensionId: ext.type,
@@ -6268,7 +6350,7 @@ var DaemonStatusReporter = class {
         inputContent: ext.activeChat?.inputContent || "",
         activeModal: ext.activeChat?.activeModal || null
       })),
-      cdpConnected: s.cdpConnected || false,
+      cdpConnected: s.cdpConnected,
       currentModel: s.currentModel,
       currentPlan: s.currentPlan,
       currentAutoApprove: s.currentAutoApprove
@@ -6279,8 +6361,8 @@ var DaemonStatusReporter = class {
       cliType: s.type,
       cliName: s.name,
       status: s.status,
-      mode: s.mode || "terminal",
-      workingDir: s.workingDir || "",
+      mode: s.mode,
+      workspace: s.workspace || "",
       activeChat: s.activeChat
     }));
     const managedAcps = acpStates.map((s) => ({
@@ -6288,19 +6370,22 @@ var DaemonStatusReporter = class {
       acpType: s.type,
       acpName: s.name,
       status: s.status,
-      mode: "chat",
-      workingDir: s.workingDir || "",
+      mode: s.mode,
+      workspace: s.workspace || "",
       activeChat: s.activeChat,
       currentModel: s.currentModel,
       currentPlan: s.currentPlan,
       acpConfigOptions: s.acpConfigOptions,
-      acpModes: s.acpModes
+      acpModes: s.acpModes,
+      errorMessage: s.errorMessage,
+      errorReason: s.errorReason
     }));
     const cfg = loadConfig();
     const wsState = getWorkspaceState(cfg);
     const memSnap = getHostMemorySnapshot();
     const payload = {
       daemonMode: true,
+      version: this.deps.daemonVersion || "unknown",
       machineNickname: cfg.machineNickname || null,
       workspaces: wsState.workspaces,
       defaultWorkspaceId: wsState.defaultWorkspaceId,
@@ -6326,7 +6411,6 @@ var DaemonStatusReporter = class {
         peers: p2p?.connectedPeerCount || 0,
         screenshotActive: p2p?.screenshotActive || false
       },
-      cdpConnected: [...cdpManagers.values()].some((c) => c.isConnected),
       connectedExtensions: [],
       detectedIdes: this.deps.detectedIdes || [],
       availableProviders: this.deps.providerLoader.getAll().map((p) => ({
@@ -6368,7 +6452,6 @@ var DaemonStatusReporter = class {
           acpName: a.acpName
         })),
         p2p: payload.p2p,
-        cdpConnected: payload.cdpConnected,
         timestamp: now
       };
       serverConn.sendMessage("status_report", wsPayload);
@@ -6507,12 +6590,14 @@ var FALLBACK_PROMPT = [
   /Type your message/i,
   /^>\s*$/m,
   // '>' alone on its own line
-  /[›➤]\s*$/,
-  /for shortcuts/i,
-  /\?\s*for help/i,
+  /[›❯]\s*[\r\n]/,
+  // prompt char followed by line ending (ANSI-stripped may not have $ at end)
+  /[›❯]\s*$/m,
+  // prompt char at end of line (multiline)
+  /for\s*shortcuts/i,
+  // Claude Code prompt (ANSI strip may remove spaces → 'forshortcuts')
+  /\?\s*for\s*help/i,
   /Press enter/i
-  // NOTE: removed /^[\s\u2500-\u257f]*>\s*$/m — the box-drawing char range is too wide and
-  // can match dialog-clearing ANSI output, causing false prompt detection in approval state.
 ];
 var FALLBACK_GENERATING = [
   /[\u2800-\u28ff]/,
@@ -6524,13 +6609,18 @@ var FALLBACK_GENERATING = [
   // Specific Claude Code status
 ];
 var FALLBACK_APPROVAL = [
-  /Allow\s+once/i,
-  /Always\s+allow/i,
+  /Allow\s*once/i,
+  // ANSI strip may remove spaces
+  /Always\s*allow/i,
   /\(y\/n\)/i,
   /\[Y\/n\]/i,
-  /Run\s+this\s+command/i
-  // NOTE: removed /Do you want to (?:run|execute|allow)/i — too broad, matches AI explanation
-  // text like "Do you want to allow this feature?" causing false approval notifications.
+  /Run\s*this\s*command/i,
+  /Allow\s*tool/i,
+  // Claude Code v2 approval
+  /Yes,?\s*don'?t\s*ask/i,
+  // "Yes, don't ask again" (Claude Code)
+  /Deny/i
+  // Deny button presence = approval dialog
 ];
 function defaultCleanOutput(raw, _lastUserInput) {
   return stripAnsi(raw).trim();
@@ -6565,6 +6655,8 @@ var ProviderCliAdapter = class {
       maxResponse: t.maxResponse ?? 3e5,
       shutdownGrace: t.shutdownGrace ?? 1e3
     };
+    const rawKeys = provider.approvalKeys;
+    this.approvalKeys = rawKeys && typeof rawKeys === "object" ? rawKeys : {};
   }
   cliType;
   cliName;
@@ -6596,8 +6688,20 @@ var ProviderCliAdapter = class {
   approvalExitTimeout = null;
   // Resize redraw suppression
   resizeSuppressUntil = 0;
+  // Debug: status transition history
+  statusHistory = [];
+  setStatus(status, trigger) {
+    const prev = this.currentStatus;
+    if (prev === status) return;
+    this.currentStatus = status;
+    this.statusHistory.push({ status, at: Date.now(), trigger });
+    if (this.statusHistory.length > 50) this.statusHistory.shift();
+    LOG.info("CLI", `[${this.cliType}] status: ${prev} \u2192 ${status}${trigger ? ` (${trigger})` : ""}`);
+  }
   // Resolved timeouts (provider defaults + overrides)
   timeouts;
+  // Provider approval key mapping (e.g. { 0: '1', 1: '2', 2: '3' }) — loaded from provider.json
+  approvalKeys;
   // ─── Lifecycle ─────────────────────────────────
   setServerConn(serverConn) {
     this.serverConn = serverConn;
@@ -6677,11 +6781,11 @@ var ProviderCliAdapter = class {
     this.ptyProcess.onExit(({ exitCode }) => {
       LOG.info("CLI", `[${this.cliType}] Exit code ${exitCode}`);
       this.ptyProcess = null;
-      this.currentStatus = "stopped";
+      this.setStatus("stopped", "pty_exit");
       this.ready = false;
       this.onStatusChange?.();
     });
-    this.currentStatus = "starting";
+    this.setStatus("starting", "spawn");
     this.onStatusChange?.();
   }
   // ─── Output state machine ────────────────────────────
@@ -6699,9 +6803,13 @@ var ProviderCliAdapter = class {
     this.recentOutputBuffer = (this.recentOutputBuffer + cleanData).slice(-1e3);
     if (!this.ready) {
       this.startupBuffer += cleanData;
+      LOG.info("CLI", `[${this.cliType}] startup chunk (${cleanData.length} chars): ${cleanData.slice(0, 200).replace(/\n/g, "\\n")}`);
       const dialogPatterns = [
         /Do you want to connect/i,
-        /Do you trust the files/i
+        /Do you trust the files/i,
+        /Quick safety check/i,
+        /Is this a project/i,
+        /Enter to confirm/i
       ];
       if (dialogPatterns.some((p) => p.test(this.startupBuffer))) {
         setTimeout(() => this.ptyProcess?.write("\r"), this.timeouts.dialogAccept);
@@ -6710,7 +6818,7 @@ var ProviderCliAdapter = class {
       }
       if (patterns.prompt.some((p) => p.test(this.startupBuffer))) {
         this.ready = true;
-        this.currentStatus = "idle";
+        this.setStatus("idle", "prompt_matched");
         LOG.info("CLI", `[${this.cliType}] \u2713 Ready`);
         this.onStatusChange?.();
       }
@@ -6721,12 +6829,12 @@ var ProviderCliAdapter = class {
       if (this.lastApprovalResolvedAt && Date.now() - this.lastApprovalResolvedAt < this.timeouts.approvalCooldown) return;
       const ctxLines = this.recentOutputBuffer.split("\n").map((l) => l.trim()).filter((l) => l && !/^[─═╭╮╰╯│]+$/.test(l));
       this.isWaitingForResponse = true;
-      this.currentStatus = "waiting_approval";
+      this.setStatus("waiting_approval", "approval_pattern");
       this.recentOutputBuffer = "";
       this.approvalTransitionBuffer = "";
       this.activeModal = {
         message: ctxLines.slice(-5).join(" ").slice(0, 200) || "Approval required",
-        buttons: ["Allow once", "Always allow", "Deny"]
+        buttons: this.cliType === "claude-cli" ? ["Yes (y)", "Always allow (a)", "Deny (Esc)"] : ["Allow once", "Always allow", "Deny"]
       };
       if (this.idleTimeout) clearTimeout(this.idleTimeout);
       if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
@@ -6738,7 +6846,7 @@ var ProviderCliAdapter = class {
           this.recentOutputBuffer = "";
           this.approvalTransitionBuffer = "";
           this.approvalExitTimeout = null;
-          this.currentStatus = this.isWaitingForResponse ? "generating" : "idle";
+          this.setStatus(this.isWaitingForResponse ? "generating" : "idle", "approval_cleared");
           this.onStatusChange?.();
         }
       }, 6e4);
@@ -6754,7 +6862,7 @@ var ProviderCliAdapter = class {
           clearTimeout(this.approvalExitTimeout);
           this.approvalExitTimeout = null;
         }
-        this.currentStatus = "generating";
+        this.setStatus("generating", "approval_gen_resume");
         this.activeModal = null;
         this.recentOutputBuffer = "";
         this.approvalTransitionBuffer = "";
@@ -6777,7 +6885,7 @@ var ProviderCliAdapter = class {
       if (patterns.generating.some((p) => p.test(cleanData))) {
         this.isWaitingForResponse = true;
         this.responseBuffer = "";
-        this.currentStatus = "generating";
+        this.setStatus("generating", "autonomous_gen");
         this.onStatusChange?.();
       }
     }
@@ -6786,7 +6894,7 @@ var ProviderCliAdapter = class {
       if (this.idleTimeout) clearTimeout(this.idleTimeout);
       const stillGenerating = patterns.generating.some((p) => p.test(cleanData));
       if (stillGenerating) {
-        this.currentStatus = "generating";
+        this.setStatus("generating", "still_generating");
         this.idleTimeout = setTimeout(() => {
           if (this.isWaitingForResponse) this.finishResponse();
         }, this.timeouts.generatingIdle);
@@ -6833,7 +6941,7 @@ var ProviderCliAdapter = class {
     this.responseBuffer = "";
     this.isWaitingForResponse = false;
     this.activeModal = null;
-    this.currentStatus = "idle";
+    this.setStatus("idle", "response_finished");
     this.onStatusChange?.();
   }
   // ─── Public API (CliAdapter interface) ──────────
@@ -6852,7 +6960,7 @@ var ProviderCliAdapter = class {
     this.messages.push({ role: "user", content: text, timestamp: Date.now() });
     this.isWaitingForResponse = true;
     this.responseBuffer = "";
-    this.currentStatus = "generating";
+    this.setStatus("generating", "sendMessage");
     this.onStatusChange?.();
     this.ptyProcess.write(text + "\r");
     this.responseTimeout = setTimeout(() => {
@@ -6880,7 +6988,7 @@ var ProviderCliAdapter = class {
         } catch {
         }
         this.ptyProcess = null;
-        this.currentStatus = "stopped";
+        this.setStatus("stopped", "stop_cmd");
         this.ready = false;
         this.onStatusChange?.();
       }, this.timeouts.shutdownGrace);
@@ -6906,9 +7014,13 @@ var ProviderCliAdapter = class {
   */
   resolveModal(buttonIndex) {
     if (!this.ptyProcess || this.currentStatus !== "waiting_approval") return;
-    const DOWN = "\x1B[B";
-    const keys = DOWN.repeat(Math.max(0, buttonIndex)) + "\r";
-    this.ptyProcess.write(keys);
+    if (buttonIndex in this.approvalKeys) {
+      this.ptyProcess.write(this.approvalKeys[buttonIndex]);
+    } else {
+      const DOWN = "\x1B[B";
+      const keys = DOWN.repeat(Math.max(0, buttonIndex)) + "\r";
+      this.ptyProcess.write(keys);
+    }
   }
   resize(cols, rows) {
     if (this.ptyProcess) {
@@ -6919,6 +7031,44 @@ var ProviderCliAdapter = class {
       }
     }
   }
+  /**
+  * Full debug state — exposes all internal buffers, status, and patterns for debugging.
+  * Used by DevServer /api/cli/debug endpoint.
+  */
+  getDebugState() {
+    return {
+      type: this.cliType,
+      name: this.cliName,
+      status: this.currentStatus,
+      ready: this.ready,
+      workingDir: this.workingDir,
+      messages: this.messages.slice(-20),
+      messageCount: this.messages.length,
+      // Buffers
+      startupBuffer: this.startupBuffer.slice(-500),
+      recentOutputBuffer: this.recentOutputBuffer.slice(-500),
+      responseBuffer: this.responseBuffer.slice(-500),
+      approvalTransitionBuffer: this.approvalTransitionBuffer.slice(-500),
+      // State
+      isWaitingForResponse: this.isWaitingForResponse,
+      activeModal: this.activeModal,
+      lastApprovalResolvedAt: this.lastApprovalResolvedAt,
+      resizeSuppressUntil: this.resizeSuppressUntil,
+      // Provider patterns (serialized)
+      patterns: {
+        prompt: this.provider.patterns.prompt.map((p) => p.toString()),
+        generating: this.provider.patterns.generating.map((p) => p.toString()),
+        approval: this.provider.patterns.approval.map((p) => p.toString()),
+        ready: this.provider.patterns.ready.map((p) => p.toString())
+      },
+      // Status history
+      statusHistory: this.statusHistory.slice(-30),
+      // Timeouts config
+      timeouts: this.timeouts,
+      // PTY alive
+      ptyAlive: !!this.ptyProcess
+    };
+  }
 };
 
 // src/commands/cli-manager.ts
@@ -6947,6 +7097,8 @@ var CliProviderInstance = class {
   generatingStartedAt = 0;
   settings = {};
   monitor;
+  generatingDebounceTimer = null;
+  generatingDebouncePending = null;
   historyWriter;
   instanceId;
   // ─── Lifecycle ─────────────────────────────────
@@ -7013,7 +7165,7 @@ var CliProviderInstance = class {
         activeModal: adapterStatus.activeModal,
         inputContent: ""
       },
-      workingDir: this.workingDir,
+      workspace: this.workingDir,
       instanceId: this.instanceId,
       lastUpdated: Date.now(),
       settings: this.settings,
@@ -7042,8 +7194,24 @@ var CliProviderInstance = class {
       LOG.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
       if (this.lastStatus === "idle" && newStatus === "generating") {
         this.generatingStartedAt = now;
-        this.pushEvent({ event: "agent:generating_started", chatTitle, timestamp: now });
+        if (this.generatingDebounceTimer) clearTimeout(this.generatingDebounceTimer);
+        this.generatingDebouncePending = { chatTitle, timestamp: now };
+        this.generatingDebounceTimer = setTimeout(() => {
+          if (this.generatingDebouncePending) {
+            this.pushEvent({ event: "agent:generating_started", ...this.generatingDebouncePending });
+            this.generatingDebouncePending = null;
+          }
+          this.generatingDebounceTimer = null;
+        }, 1e3);
       } else if (newStatus === "waiting_approval") {
+        if (this.generatingDebouncePending) {
+          if (this.generatingDebounceTimer) {
+            clearTimeout(this.generatingDebounceTimer);
+            this.generatingDebounceTimer = null;
+          }
+          this.pushEvent({ event: "agent:generating_started", ...this.generatingDebouncePending });
+          this.generatingDebouncePending = null;
+        }
         if (!this.generatingStartedAt) this.generatingStartedAt = now;
         const modal = adapterStatus.activeModal;
         LOG.info("CLI", `[${this.type}] approval modal: "${modal?.message?.slice(0, 80) ?? "none"}"`);
@@ -7056,10 +7224,24 @@ var CliProviderInstance = class {
         });
       } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
         const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
-        LOG.info("CLI", `[${this.type}] completed in ${duration}s`);
-        this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now });
+        if (this.generatingDebouncePending) {
+          LOG.info("CLI", `[${this.type}] suppressed short generating (${now - this.generatingStartedAt}ms)`);
+          if (this.generatingDebounceTimer) {
+            clearTimeout(this.generatingDebounceTimer);
+            this.generatingDebounceTimer = null;
+          }
+          this.generatingDebouncePending = null;
+        } else {
+          LOG.info("CLI", `[${this.type}] completed in ${duration}s`);
+          this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now });
+        }
         this.generatingStartedAt = 0;
       } else if (newStatus === "stopped") {
+        if (this.generatingDebounceTimer) {
+          clearTimeout(this.generatingDebounceTimer);
+          this.generatingDebounceTimer = null;
+        }
+        this.generatingDebouncePending = null;
         this.pushEvent({ event: "agent:stopped", chatTitle, timestamp: now });
       }
       this.lastStatus = newStatus;
@@ -7210,7 +7392,7 @@ var AcpProviderInstance = class {
         } : null,
         inputContent: ""
       },
-      workingDir: this.workingDir,
+      workspace: this.workingDir,
       currentModel: this.currentModel,
       currentPlan: this.currentMode,
       instanceId: this.instanceId,
@@ -7221,8 +7403,8 @@ var AcpProviderInstance = class {
       acpConfigOptions: this.configOptions,
       acpModes: this.availableModes,
       // Error details for dashboard display
-      errorMessage: this.errorMessage,
-      errorReason: this.errorReason
+      errorMessage: this.errorMessage || void 0,
+      errorReason: this.errorReason || void 0
     };
   }
   onEvent(event, data) {
@@ -7705,29 +7887,27 @@ var AcpProviderInstance = class {
   handleSessionUpdate(params) {
     if (!params) return;
     const update = params.update;
-    this.log.debug(`[${this.type}] sessionUpdate: ${update.sessionUpdate} | keys=${Object.keys(update).join(",")}`);
+    this.log.debug(`[${this.type}] sessionUpdate: ${update.sessionUpdate}`);
     switch (update.sessionUpdate) {
       case "agent_message_chunk": {
         const content = update.content;
-        if (content?.type === "text" && content.text) {
+        if (content.type === "text") {
           this.partialContent += content.text;
-        } else if (content?.type === "image") {
+        } else if (content.type === "image") {
           this.partialBlocks.push({
             type: "image",
-            data: content.data || "",
-            mimeType: content.mimeType || "image/png",
-            uri: content.uri
+            data: content.data,
+            mimeType: content.mimeType
           });
-        } else if (content?.type === "resource_link") {
+        } else if (content.type === "resource_link") {
           this.partialBlocks.push({
             type: "resource_link",
-            uri: content.uri || "",
+            uri: content.uri,
             name: content.name || "resource",
-            title: content.title,
-            mimeType: content.mimeType,
-            size: content.size
+            title: content.title ?? void 0,
+            mimeType: content.mimeType ?? void 0
           });
-        } else if (content?.type === "resource") {
+        } else if (content.type === "resource") {
           this.partialBlocks.push({
             type: "resource",
             resource: content.resource
@@ -7899,7 +8079,7 @@ var AcpProviderInstance = class {
         return { ...b, text: b.text.slice(0, -3) };
       }
       return b;
-    }).filter((b) => b.type !== "text" || b.text.trim());
+    }).filter((b) => b.type !== "text" || b.type === "text" && b.text.trim());
     if (finalBlocks.length > 0) {
       this.messages.push({
         role: "assistant",
@@ -9460,6 +9640,8 @@ var DevServer = class _DevServer {
   server = null;
   providerLoader;
   cdpManagers;
+  instanceManager;
+  cliManager;
   logFn;
   sseClients = [];
   watchScriptPath = null;
@@ -9469,9 +9651,13 @@ var DevServer = class _DevServer {
   autoImplProcess = null;
   autoImplSSEClients = [];
   autoImplStatus = { running: false, type: null, progress: [] };
+  // CLI debug SSE
+  cliSSEClients = [];
   constructor(options) {
     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();
   }
   log(msg) {
@@ -9498,6 +9684,15 @@ var DevServer = 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) },
@@ -11764,6 +11959,251 @@ data: ${JSON.stringify(msg.data)}
       });
     });
   }
+  // ─── CLI Debug Handlers ──────────────────────────────
+  /** GET /api/cli/status — list all running CLI/ACP instances with state */
+  async handleCliStatus(_req, res) {
+    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? } */
+  async handleCliLaunch(req, res) {
+    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) {
+      this.json(res, 500, { error: `Launch failed: ${e.message}` });
+    }
+  }
+  /** POST /api/cli/send — send message to a running CLI { type, text } */
+  async handleCliSend(req, res) {
+    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;
+    }
+    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) {
+      this.json(res, 500, { error: `Send failed: ${e.message}` });
+    }
+  }
+  /** POST /api/cli/stop — stop a running CLI { type } */
+  async handleCliStop(req, res) {
+    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) {
+      this.json(res, 500, { error: `Stop failed: ${e.message}` });
+    }
+  }
+  /** GET /api/cli/events — SSE stream of CLI status events */
+  handleCliSSE(_req, res) {
+    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);
+    if (this.cliSSEClients.length === 1 && this.instanceManager) {
+      this.instanceManager.onEvent((event) => {
+        this.sendCliSSE(event);
+      });
+    }
+    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);
+    });
+  }
+  sendCliSSE(data) {
+    const msg = `data: ${JSON.stringify({ ...data, timestamp: Date.now() })}
+
+`;
+    for (const client of this.cliSSEClients) {
+      try {
+        client.write(msg);
+      } catch {
+      }
+    }
+  }
+  /** GET /api/cli/debug/:type — full internal debug state of a CLI adapter */
+  async handleCliDebug(type, _req, res) {
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: "InstanceManager not available" });
+      return;
+    }
+    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;
+    }
+    const instance = this.instanceManager.getInstance(target.instanceId);
+    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 : void 0
+          },
+          debug: debugState
+        });
+      } else {
+        this.json(res, 200, {
+          instanceId: target.instanceId,
+          providerState: target,
+          debug: null,
+          message: "No debug state available (adapter.getDebugState not found)"
+        });
+      }
+    } catch (e) {
+      this.json(res, 500, { error: `Debug state failed: ${e.message}` });
+    }
+  }
+  /** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
+  async handleCliResolve(req, res) {
+    const body = await this.readBody(req);
+    const { type, buttonIndex, instanceId } = body;
+    if (buttonIndex === void 0 || 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;
+    }
+    let adapter = null;
+    for (const [, a] of this.cliManager.adapters) {
+      if (type && a.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) {
+      this.json(res, 500, { error: `Resolve failed: ${e.message}` });
+    }
+  }
+  /** POST /api/cli/raw — send raw keystrokes to PTY { type, keys } */
+  async handleCliRaw(req, res) {
+    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 = null;
+    for (const [, a] of this.cliManager.adapters) {
+      if (type && a.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) {
+      this.json(res, 500, { error: `Raw send failed: ${e.message}` });
+    }
+  }
 };
 
 // src/installer.ts
@@ -12113,7 +12553,9 @@ async function shutdownDaemonComponents(components) {
   installExtensions,
   installGlobalInterceptor,
   isExtensionInstalled,
+  isIdeRunning,
   isSetupComplete,
+  killIdeProcess,
   launchIDE,
   launchWithCdp,
   loadConfig,