adhdev 0.1.50 → 0.1.53

package/dist/index.js

@@ -1991,6 +1991,193 @@ var init_daemon_cdp = __esm({
         this.log(`[CDP] typeAndSend: sent "${text.substring(0, 50)}..."`);
         return true;
       }
+      /**
+       * 좌표 기반 typeAndSend — webview iframe 안의 입력 필드에 사용
+       * selector 대신 직접 좌표를 받아 클릭+입력+Enter
+       */
+      async typeAndSendAt(x, y, text) {
+        if (!this.isConnected) return false;
+        await this.sendInternal("Input.dispatchMouseEvent", {
+          type: "mousePressed",
+          x: Math.round(x),
+          y: Math.round(y),
+          button: "left",
+          clickCount: 1
+        });
+        await this.sendInternal("Input.dispatchMouseEvent", {
+          type: "mouseReleased",
+          x: Math.round(x),
+          y: Math.round(y),
+          button: "left",
+          clickCount: 1
+        });
+        await new Promise((r) => setTimeout(r, 300));
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "rawKeyDown",
+          key: "a",
+          code: "KeyA",
+          windowsVirtualKeyCode: 65,
+          modifiers: 8
+          // Meta
+        });
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "keyUp",
+          key: "a",
+          code: "KeyA",
+          windowsVirtualKeyCode: 65,
+          modifiers: 8
+        });
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "rawKeyDown",
+          key: "Backspace",
+          code: "Backspace",
+          windowsVirtualKeyCode: 8
+        });
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "keyUp",
+          key: "Backspace",
+          code: "Backspace",
+          windowsVirtualKeyCode: 8
+        });
+        await new Promise((r) => setTimeout(r, 150));
+        await this.sendInternal("Input.insertText", { text });
+        await new Promise((r) => setTimeout(r, 200));
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "rawKeyDown",
+          key: "Enter",
+          code: "Enter",
+          windowsVirtualKeyCode: 13,
+          nativeVirtualKeyCode: 13
+        });
+        await this.sendInternal("Input.dispatchKeyEvent", {
+          type: "keyUp",
+          key: "Enter",
+          code: "Enter",
+          windowsVirtualKeyCode: 13,
+          nativeVirtualKeyCode: 13
+        });
+        this.log(`[CDP] typeAndSendAt(${Math.round(x)},${Math.round(y)}): sent "${text.substring(0, 50)}..."`);
+        return true;
+      }
+      /**
+       * Webview iframe 내부에서 JS evaluate
+       * Kiro, PearAI 등 채팅 UI가 webview iframe 안에 있는 IDE에서 사용.
+       * 
+       * 1. browser WS로 Target.getTargets → vscode-webview iframe 찾기
+       * 2. Target.attachToTarget → session 획득
+       * 3. Page.getFrameTree → nested iframe 찾기
+       * 4. Page.createIsolatedWorld → contextId 획득
+       * 5. Runtime.evaluate → 결과 반환
+       * 
+       * @param expression 실행할 JS 표현식
+       * @param matchFn webview iframe URL 매칭 함수 (optional, 모든 webview 시도)
+       * @returns evaluate 결과 또는 null
+       */
+      async evaluateInWebviewFrame(expression, matchFn) {
+        if (!this._browserConnected) {
+          await this.connectBrowserWs().catch(() => {
+          });
+        }
+        if (!this.browserWs || !this._browserConnected) {
+          this.log("[CDP] evaluateInWebviewFrame: no browser WS");
+          return null;
+        }
+        const browserWs = this.browserWs;
+        let msgId = this.browserMsgId;
+        const sendWs = (method, params = {}, sessionId) => {
+          return new Promise((resolve6, reject) => {
+            const mid = msgId++;
+            this.browserMsgId = msgId;
+            const handler = (raw) => {
+              try {
+                const msg = JSON.parse(raw.toString());
+                if (msg.id === mid) {
+                  browserWs.removeListener("message", handler);
+                  if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+                  else resolve6(msg.result);
+                }
+              } catch {
+              }
+            };
+            browserWs.on("message", handler);
+            const payload = { id: mid, method, params };
+            if (sessionId) payload.sessionId = sessionId;
+            browserWs.send(JSON.stringify(payload));
+            setTimeout(() => {
+              browserWs.removeListener("message", handler);
+              reject(new Error(`timeout: ${method}`));
+            }, 1e4);
+          });
+        };
+        try {
+          const { targetInfos } = await sendWs("Target.getTargets");
+          const webviewIframes = (targetInfos || []).filter(
+            (t) => t.type === "iframe" && (t.url || "").includes("vscode-webview")
+          );
+          if (webviewIframes.length === 0) {
+            this.log("[CDP] evaluateInWebviewFrame: no webview iframes found");
+            return null;
+          }
+          for (const iframe of webviewIframes) {
+            let sessionId = null;
+            try {
+              const attached = await sendWs("Target.attachToTarget", {
+                targetId: iframe.targetId,
+                flatten: true
+              });
+              sessionId = attached.sessionId;
+              const { frameTree } = await sendWs("Page.getFrameTree", {}, sessionId);
+              const childFrame = frameTree?.childFrames?.[0]?.frame;
+              if (!childFrame) {
+                await sendWs("Target.detachFromTarget", { sessionId }).catch(() => {
+                });
+                continue;
+              }
+              const { executionContextId } = await sendWs("Page.createIsolatedWorld", {
+                frameId: childFrame.id,
+                worldName: "adhdev-eval",
+                grantUniveralAccess: true
+              }, sessionId);
+              if (matchFn) {
+                const checkResult = await sendWs("Runtime.evaluate", {
+                  expression: `document.documentElement?.outerHTML?.substring(0, 500000) || ''`,
+                  returnByValue: true,
+                  contextId: executionContextId
+                }, sessionId);
+                const bodyText = checkResult?.result?.value || "";
+                if (!matchFn(bodyText)) {
+                  await sendWs("Target.detachFromTarget", { sessionId }).catch(() => {
+                  });
+                  continue;
+                }
+              }
+              const result = await sendWs("Runtime.evaluate", {
+                expression,
+                returnByValue: true,
+                contextId: executionContextId
+              }, sessionId);
+              await sendWs("Target.detachFromTarget", { sessionId }).catch(() => {
+              });
+              const value = result?.result?.value;
+              if (value != null) {
+                this.log(`[CDP] evaluateInWebviewFrame: success in ${iframe.targetId.substring(0, 12)}`);
+                return typeof value === "string" ? value : JSON.stringify(value);
+              }
+            } catch (e) {
+              if (sessionId) {
+                await sendWs("Target.detachFromTarget", { sessionId }).catch(() => {
+                });
+              }
+              this.log(`[CDP] evaluateInWebviewFrame: error in ${iframe.targetId.substring(0, 12)}: ${e.message}`);
+            }
+          }
+          this.log("[CDP] evaluateInWebviewFrame: no matching webview found");
+          return null;
+        } catch (e) {
+          this.log(`[CDP] evaluateInWebviewFrame error: ${e.message}`);
+          return null;
+        }
+      }
       // ─── Agent Webview Multi-Session ─────────────────────────
       async discoverAgentWebviews() {
         if (!this.isConnected) return [];
@@ -3306,7 +3493,15 @@ var init_dev_server = __esm({
             this.json(res, 500, { error: "Script function returned null" });
             return;
           }
-          const raw = await cdp2.evaluate(scriptCode, 3e4);
+          const isWebviewScript = scriptName.toLowerCase().includes("webview");
+          let raw;
+          if (isWebviewScript) {
+            const matchText = provider2.webviewMatchText;
+            const matchFn = matchText ? (body2) => body2.includes(matchText) : void 0;
+            raw = await cdp2.evaluateInWebviewFrame(scriptCode, matchFn);
+          } else {
+            raw = await cdp2.evaluate(scriptCode, 3e4);
+          }
           let result = raw;
           if (typeof raw === "string") {
             try {
@@ -4286,8 +4481,11 @@ var init_daemon_commands = __esm({
           let raw = args._targetInstance;
           const ideMatch = raw.match(/:ide:(.+)$/);
           const cliMatch = raw.match(/:cli:(.+)$/);
+          const acpMatch = raw.match(/:acp:(.+)$/);
           if (ideMatch) raw = ideMatch[1];
           else if (cliMatch) raw = cliMatch[1];
+          else if (acpMatch) raw = acpMatch[1];
+          if (raw.startsWith("acp_")) raw = raw.substring(4);
           const lastUnderscore = raw.lastIndexOf("_");
           if (lastUnderscore > 0) return raw.substring(0, lastUnderscore);
         }
@@ -4510,16 +4708,16 @@ var init_daemon_commands = __esm({
       async handleReadChat(args) {
         const provider2 = this.getProvider();
         const _log = (msg) => console.log(`[read_chat] ${msg}`);
-        if (provider2?.category === "cli") {
+        if (provider2?.category === "cli" || provider2?.category === "acp") {
           const adapter = this.getCliAdapter(provider2.type);
           if (adapter) {
-            _log(`CLI adapter: ${adapter.cliType}`);
+            _log(`${provider2.category} adapter: ${adapter.cliType}`);
             const status = adapter.getStatus?.();
             if (status) {
               return { success: true, messages: status.messages || [], status: status.status, activeModal: status.activeModal };
             }
           }
-          return { success: false, error: "CLI adapter not found" };
+          return { success: false, error: `${provider2.category} adapter not found` };
         }
         if (provider2?.category === "extension") {
           try {
@@ -4554,15 +4752,44 @@ var init_daemon_commands = __esm({
         }
         const cdp2 = this.getCdp();
         if (!cdp2?.isConnected) return { success: false, error: "CDP not connected" };
+        const webviewScript = this.getProviderScript("webviewReadChat") || this.getProviderScript("webview_read_chat");
+        if (webviewScript) {
+          try {
+            const matchText = provider2?.webviewMatchText;
+            const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+            const raw = await cdp2.evaluateInWebviewFrame(webviewScript, matchFn);
+            if (raw) {
+              let parsed = raw;
+              if (typeof parsed === "string") {
+                try {
+                  parsed = JSON.parse(parsed);
+                } catch {
+                }
+              }
+              if (parsed && typeof parsed === "object") {
+                _log(`Webview OK: ${parsed.messages?.length || 0} msgs`);
+                return { success: true, ...parsed };
+              }
+            }
+          } catch (e) {
+            _log(`Webview readChat error: ${e.message}`);
+          }
+          return { success: true, messages: [], status: "idle" };
+        }
         const script = this.getProviderScript("readChat") || this.getProviderScript("read_chat");
         if (script) {
           try {
             const result = await cdp2.evaluate(script, 5e4);
-            if (result && typeof result === "object" && result.messages?.length > 0) {
-              _log(`OK: ${result.messages?.length} msgs`);
-              return { success: true, ...result };
+            let parsed = result;
+            if (typeof parsed === "string") {
+              try {
+                parsed = JSON.parse(parsed);
+              } catch {
+              }
             }
-            if (result && typeof result === "object") {
+            if (parsed && typeof parsed === "object" && parsed.messages?.length > 0) {
+              _log(`OK: ${parsed.messages?.length} msgs`);
+              return { success: true, ...parsed };
             }
           } catch (e) {
             console.log(`[read_chat] Script error: ${e.message}`);
@@ -4575,15 +4802,15 @@ var init_daemon_commands = __esm({
         if (!text) return { success: false, error: "text required" };
         const _log = (msg) => console.log(`[send_chat] ${msg}`);
         const provider2 = this.getProvider();
-        if (provider2?.category === "cli") {
+        if (provider2?.category === "cli" || provider2?.category === "acp") {
           const adapter = this.getCliAdapter(provider2.type);
           if (adapter) {
-            _log(`CLI adapter: ${adapter.cliType}`);
+            _log(`${provider2.category} adapter: ${adapter.cliType}`);
             try {
               await adapter.sendMessage(text);
-              return { success: true, sent: true, method: "cli-adapter", targetAgent: adapter.cliType };
+              return { success: true, sent: true, method: `${provider2.category}-adapter`, targetAgent: adapter.cliType };
             } catch (e) {
-              return { success: false, error: `CLI send failed: ${e.message}` };
+              return { success: false, error: `${provider2.category} send failed: ${e.message}` };
             }
           }
         }
@@ -4652,10 +4879,26 @@ var init_daemon_commands = __esm({
               return { success: true, sent: true, method: "script" };
             }
             if (parsed?.needsTypeAndSend && parsed?.selector) {
-              const sent = await targetCdp.typeAndSend(parsed.selector, text);
-              if (sent) {
-                _log(`typeAndSend(script.selector=${parsed.selector}) success`);
-                return { success: true, sent: true, method: "typeAndSend-script" };
+              try {
+                const sent = await targetCdp.typeAndSend(parsed.selector, text);
+                if (sent) {
+                  _log(`typeAndSend(script.selector=${parsed.selector}) success`);
+                  return { success: true, sent: true, method: "typeAndSend-script" };
+                }
+              } catch (e) {
+                _log(`typeAndSend(script.selector) failed: ${e.message}`);
+              }
+            }
+            if (parsed?.needsTypeAndSend && parsed?.clickCoords) {
+              try {
+                const { x, y } = parsed.clickCoords;
+                const sent = await targetCdp.typeAndSendAt(x, y, text);
+                if (sent) {
+                  _log(`typeAndSendAt(${x},${y}) success`);
+                  return { success: true, sent: true, method: "typeAndSendAt-script" };
+                }
+              } catch (e) {
+                _log(`typeAndSendAt failed: ${e.message}`);
               }
             }
           } catch (e) {
@@ -4676,6 +4919,27 @@ var init_daemon_commands = __esm({
             console.log(`[list_chats] Extension error: ${e.message}`);
           }
         }
+        try {
+          const webviewScript = this.getProviderScript("webviewListSessions") || this.getProviderScript("webview_list_sessions");
+          if (webviewScript) {
+            const matchText = provider2?.webviewMatchText;
+            const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+            const raw = await this.getCdp()?.evaluateInWebviewFrame?.(webviewScript, matchFn);
+            let parsed = raw;
+            if (typeof parsed === "string") {
+              try {
+                parsed = JSON.parse(parsed);
+              } catch {
+              }
+            }
+            if (parsed?.sessions) {
+              console.log(`[list_chats] Webview OK: ${parsed.sessions.length} chats`);
+              return { success: true, chats: parsed.sessions };
+            }
+          }
+        } catch (e) {
+          console.log(`[list_chats] Webview error: ${e.message}`);
+        }
         try {
           const evalResult = await this.evaluateProviderScript("listSessions");
           if (evalResult) {
@@ -4702,6 +4966,17 @@ var init_daemon_commands = __esm({
           const ok = await this.agentStream.newAgentSession(this.getCdp(), provider2.type, this._currentIdeType);
           return { success: ok };
         }
+        try {
+          const webviewScript = this.getProviderScript("webviewNewSession") || this.getProviderScript("webview_new_session");
+          if (webviewScript) {
+            const matchText = provider2?.webviewMatchText;
+            const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+            const raw = await this.getCdp()?.evaluateInWebviewFrame?.(webviewScript, matchFn);
+            if (raw) return { success: true, result: raw };
+          }
+        } catch (e) {
+          return { success: false, error: `webviewNewSession failed: ${e.message}` };
+        }
         try {
           const evalResult = await this.evaluateProviderScript("newSession");
           if (evalResult) return { success: true };
@@ -4722,6 +4997,17 @@ var init_daemon_commands = __esm({
         }
         const cdp2 = this.getCdp(ideType);
         if (!cdp2?.isConnected) return { success: false, error: "CDP not connected" };
+        try {
+          const webviewScript = this.getProviderScript("webviewSwitchSession", { SESSION_ID: JSON.stringify(sessionId) });
+          if (webviewScript) {
+            const matchText = provider2?.webviewMatchText;
+            const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+            const raw = await cdp2.evaluateInWebviewFrame?.(webviewScript, matchFn);
+            if (raw) return { success: true, result: raw };
+          }
+        } catch (e) {
+          return { success: false, error: `webviewSwitchSession failed: ${e.message}` };
+        }
         const script = this.getProviderScript("switchSession", { SESSION_ID: JSON.stringify(sessionId) }) || this.getProviderScript("switch_session", { SESSION_ID: JSON.stringify(sessionId) });
         if (!script) return { success: false, error: "switch_session script not available" };
         try {
@@ -4822,6 +5108,36 @@ var init_daemon_commands = __esm({
           );
           return { success: ok };
         }
+        if (provider2?.scripts?.webviewResolveAction || provider2?.scripts?.webview_resolve_action) {
+          const script = this.getProviderScript("webviewResolveAction", { action, button, buttonText: button }) || this.getProviderScript("webview_resolve_action", { action, button, buttonText: button });
+          if (script) {
+            const cdp2 = this.getCdp();
+            if (cdp2?.isConnected) {
+              try {
+                const matchText = provider2?.webviewMatchText;
+                const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+                const raw = await cdp2.evaluateInWebviewFrame?.(script, matchFn);
+                let result = raw;
+                if (typeof raw === "string") {
+                  try {
+                    result = JSON.parse(raw);
+                  } catch {
+                  }
+                }
+                console.log(`[resolveAction] webview script result:`, JSON.stringify(result));
+                if (result?.resolved) {
+                  return { success: true, clicked: result.clicked };
+                }
+                if (result?.found && result.x != null && result.y != null) {
+                  console.log(`[resolveAction] Webview coordinate click not fully supported via CDP. Click directly in script.`);
+                }
+                if (result?.found || result?.resolved) return { success: true };
+              } catch (e) {
+                return { success: false, error: `webviewResolveAction failed: ${e.message}` };
+              }
+            }
+          }
+        }
         if (provider2?.scripts?.resolveAction) {
           const script = provider2.scripts.resolveAction({ action, button, buttonText: button });
           if (script) {
@@ -5274,11 +5590,14 @@ var init_daemon_commands = __esm({
         if (!loader) return { success: false, error: "ProviderLoader not initialized" };
         const provider2 = loader.get(agentType);
         if (!provider2) return { success: false, error: `Provider not found: ${agentType}` };
-        if (!provider2.scripts?.[scriptName]) {
-          return { success: false, error: `Script '${scriptName}' not available for ${agentType}` };
-        }
-        const script = provider2.scripts[scriptName](args);
-        if (!script) return { success: false, error: `Script '${scriptName}' returned null` };
+        const isWebviewScript = provider2.category === "ide" && ["webviewListModels", "webviewSetModel", "webviewListModes", "webviewSetMode"].includes(`webview${scriptName.charAt(0).toUpperCase() + scriptName.slice(1)}`);
+        const actualScriptName = isWebviewScript ? `webview${scriptName.charAt(0).toUpperCase() + scriptName.slice(1)}` : scriptName;
+        if (!provider2.scripts?.[actualScriptName]) {
+          return { success: false, error: `Script '${actualScriptName}' not available for ${agentType}` };
+        }
+        const scriptFn = provider2.scripts[actualScriptName];
+        const scriptCode = scriptFn(args);
+        if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
         const cdpKey = provider2.category === "ide" ? this._currentIdeType || agentType : this._currentIdeType || ideType;
         console.log(`[ExtScript] provider=${provider2.type} category=${provider2.category} cdpKey=${cdpKey}`);
         const cdp2 = this.getCdp(cdpKey);
@@ -5297,9 +5616,13 @@ var init_daemon_commands = __esm({
             if (!targetSessionId) {
               return { success: false, error: `No active session found for ${agentType}` };
             }
-            result = await cdp2.evaluateInSession(targetSessionId, script);
+            result = await cdp2.evaluateInSession(targetSessionId, scriptCode);
+          } else if (isWebviewScript && cdp2.evaluateInWebviewFrame) {
+            const matchText = provider2.webviewMatchText;
+            const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+            result = await cdp2.evaluateInWebviewFrame(scriptCode, matchFn);
           } else {
-            result = await cdp2.evaluate(script, 3e4);
+            result = await cdp2.evaluate(scriptCode, 3e4);
           }
           if (typeof result === "string") {
             try {
@@ -6074,9 +6397,10 @@ var init_daemon_status = __esm({
           const exts = (s.extensions || []).length;
           return `${s.type}(${s.status},${msgs}msg,${exts}ext${s.currentModel ? ",model=" + s.currentModel : ""})`;
         }).join(", ");
-        const cliSummary = [...cliStates, ...acpStates].map((s) => `${s.type}(${s.status})`).join(", ");
+        const cliSummary = cliStates.map((s) => `${s.type}(${s.status})`).join(", ");
+        const acpSummary = acpStates.map((s) => `${s.type}(${s.status})`).join(", ");
         const logLevel = opts?.p2pOnly ? "debug" : "info";
-        LOG[logLevel]("StatusReport", `\u2192${target} IDE: ${ideStates.length} [${ideSummary}] CLI: ${cliStates.length + acpStates.length} [${cliSummary}]`);
+        LOG[logLevel]("StatusReport", `\u2192${target} IDE: ${ideStates.length} [${ideSummary}] CLI: ${cliStates.length} [${cliSummary}] ACP: ${acpStates.length} [${acpSummary}]`);
         const managedIdes = ideStates.map((s) => ({
           ideType: s.type,
           ideVersion: "",
@@ -6151,19 +6475,16 @@ var init_daemon_status = __esm({
           workingDir: s.workingDir || "",
           activeChat: s.activeChat
         }));
-        for (const s of acpStates) {
-          managedClis.push({
-            id: s.instanceId,
-            cliType: s.type,
-            cliName: s.name,
-            status: s.status,
-            mode: "chat",
-            workingDir: s.workingDir || "",
-            activeChat: s.activeChat,
-            currentModel: s.currentModel,
-            isAcp: true
-          });
-        }
+        const managedAcps = acpStates.map((s) => ({
+          id: s.instanceId,
+          acpType: s.type,
+          acpName: s.name,
+          status: s.status,
+          mode: "chat",
+          workingDir: s.workingDir || "",
+          activeChat: s.activeChat,
+          currentModel: s.currentModel
+        }));
         const extSummary = localServer?.getLatestExtensionData() || {
           activeFile: null,
           workspaceFolders: [],
@@ -6187,6 +6508,7 @@ var init_daemon_status = __esm({
           },
           managedIdes,
           managedClis,
+          managedAcps,
           detectedIdes: this.deps.detectedIdes.map((ide) => ({ ...ide, type: ide.id })),
           p2p: {
             available: p2p?.isAvailable || false,
@@ -6917,18 +7239,545 @@ var init_cli_provider_instance = __esm({
   }
 });
 
+// src/providers/acp-provider-instance.ts
+var path9, crypto, import_child_process6, import_readline, AcpProviderInstance;
+var init_acp_provider_instance = __esm({
+  "src/providers/acp-provider-instance.ts"() {
+    "use strict";
+    path9 = __toESM(require("path"));
+    crypto = __toESM(require("crypto"));
+    import_child_process6 = require("child_process");
+    import_readline = require("readline");
+    init_status_monitor();
+    AcpProviderInstance = class {
+      constructor(provider2, workingDir, cliArgs = []) {
+        this.cliArgs = cliArgs;
+        this.type = provider2.type;
+        this.provider = provider2;
+        this.workingDir = workingDir;
+        this.instanceId = `acp_${provider2.type}_${crypto.createHash("md5").update(require("os").hostname() + provider2.type + workingDir).digest("hex").slice(0, 8)}`;
+        this.monitor = new StatusMonitor();
+      }
+      type;
+      category = "acp";
+      provider;
+      context = null;
+      settings = {};
+      events = [];
+      monitor;
+      // Process
+      process = null;
+      readline = null;
+      requestId = 1;
+      pendingRequests = /* @__PURE__ */ new Map();
+      // State
+      sessionId = null;
+      messages = [];
+      currentStatus = "starting";
+      lastStatus = "starting";
+      generatingStartedAt = 0;
+      agentCapabilities = {};
+      currentModel;
+      currentMode;
+      activeToolCalls = [];
+      stopReason = null;
+      partialContent = "";
+      // Config
+      workingDir;
+      instanceId;
+      // ─── Lifecycle ─────────────────────────────────
+      async init(context) {
+        this.context = context;
+        this.settings = context.settings || {};
+        this.monitor.updateConfig({
+          approvalAlert: this.settings.approvalAlert !== false,
+          longGeneratingAlert: this.settings.longGeneratingAlert !== false,
+          longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+        });
+        await this.spawnAgent();
+      }
+      async onTick() {
+        if (this.process && this.process.exitCode !== null) {
+          this.currentStatus = "stopped";
+          this.detectStatusTransition();
+        }
+      }
+      getState() {
+        const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
+        const recentMessages = this.messages.slice(-50).map((m) => ({
+          role: m.role,
+          content: m.content.length > 2e3 ? m.content.slice(0, 2e3) + "\n... (truncated)" : m.content,
+          timestamp: m.timestamp
+        }));
+        if (this.currentStatus === "generating" && this.partialContent) {
+          const cleaned = this.partialContent.trim();
+          if (cleaned) {
+            recentMessages.push({
+              role: "assistant",
+              content: (cleaned.length > 2e3 ? cleaned.slice(0, 2e3) + "..." : cleaned) + "...",
+              timestamp: Date.now()
+            });
+          }
+        }
+        return {
+          type: this.type,
+          name: this.provider.name,
+          category: "acp",
+          status: this.currentStatus,
+          mode: "chat",
+          activeChat: {
+            id: this.sessionId || `${this.type}_${this.workingDir}`,
+            title: `${this.provider.name} \xB7 ${dirName}`,
+            status: this.currentStatus,
+            messages: recentMessages,
+            activeModal: this.currentStatus === "waiting_approval" ? {
+              message: this.activeToolCalls.find((t) => t.status === "running")?.name || "Permission requested",
+              buttons: ["Approve", "Reject"]
+            } : null,
+            inputContent: ""
+          },
+          workingDir: this.workingDir,
+          currentModel: this.currentModel,
+          currentPlan: this.currentMode,
+          instanceId: this.instanceId,
+          lastUpdated: Date.now(),
+          settings: this.settings,
+          pendingEvents: this.flushEvents()
+        };
+      }
+      onEvent(event, data) {
+        if (event === "send_message" && data?.text) {
+          this.sendPrompt(data.text).catch(
+            (e) => console.warn(`[ACP:${this.type}] sendPrompt error:`, e?.message)
+          );
+        } else if (event === "resolve_action") {
+          const action = data?.action || "approve";
+          this.resolvePermission(action === "approve" || action === "accept").catch((e) => console.warn(`[ACP:${this.type}] resolvePermission error:`, e?.message));
+        } else if (event === "cancel") {
+          this.cancelSession().catch(
+            (e) => console.warn(`[ACP:${this.type}] cancel error:`, e?.message)
+          );
+        }
+      }
+      dispose() {
+        if (this.process) {
+          try {
+            this.process.kill("SIGTERM");
+          } catch {
+          }
+          this.process = null;
+        }
+        if (this.readline) {
+          this.readline.close();
+          this.readline = null;
+        }
+        for (const [, req] of this.pendingRequests) {
+          clearTimeout(req.timer);
+          req.reject(new Error("Instance disposed"));
+        }
+        this.pendingRequests.clear();
+        this.monitor.reset();
+      }
+      // ─── ACP Process Management ──────────────────────
+      async spawnAgent() {
+        const spawnConfig = this.provider.spawn;
+        if (!spawnConfig) {
+          throw new Error(`[ACP:${this.type}] No spawn config defined`);
+        }
+        const command = spawnConfig.command;
+        const args = [...spawnConfig.args || [], ...this.cliArgs];
+        const env = { ...process.env, ...spawnConfig.env || {} };
+        console.log(`[ACP:${this.type}] Spawning: ${command} ${args.join(" ")} in ${this.workingDir}`);
+        this.process = (0, import_child_process6.spawn)(command, args, {
+          cwd: this.workingDir,
+          env,
+          stdio: ["pipe", "pipe", "pipe"],
+          shell: spawnConfig.shell || false
+        });
+        this.readline = (0, import_readline.createInterface)({ input: this.process.stdout });
+        this.readline.on("line", (line) => {
+          const trimmed = line.trim();
+          if (!trimmed) return;
+          try {
+            const msg = JSON.parse(trimmed);
+            this.handleMessage(msg);
+          } catch (e) {
+          }
+        });
+        this.process.stderr?.on("data", (data) => {
+          const text = data.toString().trim();
+          if (text) {
+            console.log(`[ACP:${this.type}:stderr] ${text.slice(0, 200)}`);
+          }
+        });
+        this.process.on("exit", (code, signal) => {
+          console.log(`[ACP:${this.type}] Process exited: code=${code} signal=${signal}`);
+          this.currentStatus = "stopped";
+          this.detectStatusTransition();
+        });
+        this.process.on("error", (err) => {
+          console.error(`[ACP:${this.type}] Process error:`, err.message);
+          this.currentStatus = "error";
+          this.detectStatusTransition();
+        });
+        await this.initialize();
+      }
+      // ─── ACP Protocol ────────────────────────────────
+      async initialize() {
+        try {
+          const result = await this.sendRequest("initialize", {
+            protocolVersion: "0.1.0",
+            clientInfo: {
+              name: "adhdev",
+              version: "0.1.0"
+            },
+            clientCapabilities: {
+              roots: true
+            },
+            workspaceFolders: [{
+              name: path9.basename(this.workingDir),
+              uri: `file://${this.workingDir}`
+            }]
+          });
+          this.agentCapabilities = result?.capabilities || {};
+          console.log(`[ACP:${this.type}] Initialized. Agent capabilities:`, JSON.stringify(this.agentCapabilities));
+          this.sendNotification("initialized");
+          await this.createSession();
+        } catch (e) {
+          console.error(`[ACP:${this.type}] Initialize failed:`, e?.message);
+          this.currentStatus = "error";
+        }
+      }
+      async createSession() {
+        try {
+          const result = await this.sendRequest("session/new", {
+            cwd: this.workingDir,
+            mcpServers: []
+          });
+          this.sessionId = result?.sessionId || null;
+          this.currentStatus = "idle";
+          this.messages = [];
+          if (result?.models?.currentModelId) {
+            this.currentModel = result.models.currentModelId;
+          }
+          console.log(`[ACP:${this.type}] Session created: ${this.sessionId}${this.currentModel ? ` (model: ${this.currentModel})` : ""}`);
+        } catch (e) {
+          console.warn(`[ACP:${this.type}] session/new failed:`, e?.message);
+          this.currentStatus = "idle";
+        }
+      }
+      async sendPrompt(text) {
+        this.messages.push({
+          role: "user",
+          content: text,
+          timestamp: Date.now()
+        });
+        this.currentStatus = "generating";
+        this.partialContent = "";
+        this.detectStatusTransition();
+        try {
+          const result = await this.sendRequest("session/prompt", {
+            sessionId: this.sessionId,
+            prompt: [{ type: "text", text }]
+          }, 3e5);
+          if (result?.stopReason) {
+            this.stopReason = result.stopReason;
+          }
+          if (this.partialContent.trim()) {
+            this.messages.push({
+              role: "assistant",
+              content: this.partialContent.trim(),
+              timestamp: Date.now()
+            });
+            this.partialContent = "";
+          }
+          this.currentStatus = "idle";
+          this.detectStatusTransition();
+        } catch (e) {
+          console.warn(`[ACP:${this.type}] prompt error:`, e?.message);
+          if (this.partialContent.trim()) {
+            this.messages.push({
+              role: "assistant",
+              content: this.partialContent.trim(),
+              timestamp: Date.now()
+            });
+            this.partialContent = "";
+          }
+          this.currentStatus = "idle";
+          this.detectStatusTransition();
+        }
+      }
+      async cancelSession() {
+        this.sendNotification("session/cancel", {
+          sessionId: this.sessionId
+        });
+        this.currentStatus = "idle";
+        this.detectStatusTransition();
+      }
+      permissionResolvers = [];
+      async resolvePermission(approved) {
+        const resolver = this.permissionResolvers.shift();
+        if (resolver) {
+          resolver(approved);
+        }
+        if (this.currentStatus === "waiting_approval") {
+          this.currentStatus = "generating";
+          this.detectStatusTransition();
+        }
+      }
+      // ─── JSON-RPC Transport ──────────────────────────
+      sendRequest(method, params, timeoutMs = 3e4) {
+        return new Promise((resolve6, reject) => {
+          if (!this.process?.stdin?.writable) {
+            reject(new Error("Process stdin not writable"));
+            return;
+          }
+          const id = this.requestId++;
+          const msg = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params
+          };
+          const timer = setTimeout(() => {
+            this.pendingRequests.delete(id);
+            reject(new Error(`Request ${method} timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          this.pendingRequests.set(id, { resolve: resolve6, reject, timer });
+          const line = JSON.stringify(msg) + "\n";
+          this.process.stdin.write(line);
+        });
+      }
+      sendNotification(method, params) {
+        if (!this.process?.stdin?.writable) return;
+        const msg = {
+          jsonrpc: "2.0",
+          method,
+          ...params && { params }
+        };
+        const line = JSON.stringify(msg) + "\n";
+        this.process.stdin.write(line);
+      }
+      handleMessage(msg) {
+        if ("id" in msg && msg.id !== void 0 && !("method" in msg && msg.method)) {
+          const pending = this.pendingRequests.get(msg.id);
+          if (pending) {
+            clearTimeout(pending.timer);
+            this.pendingRequests.delete(msg.id);
+            const resp = msg;
+            if (resp.error) {
+              pending.reject(new Error(`${resp.error.message} (${resp.error.code})`));
+            } else {
+              pending.resolve(resp.result);
+            }
+          }
+          return;
+        }
+        if ("method" in msg) {
+          this.handleNotification(msg);
+          if ("id" in msg && msg.id !== void 0) {
+            this.handleAgentRequest(msg);
+          }
+        }
+      }
+      handleNotification(msg) {
+        switch (msg.method) {
+          case "session/update": {
+            const params = msg.params;
+            this.handleSessionUpdate(params);
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      handleAgentRequest(msg) {
+        switch (msg.method) {
+          case "fs/readTextFile":
+          case "fs/writeTextFile": {
+            this.sendResponse(msg.id, null, {
+              code: -32601,
+              message: "File system access not supported by ADHDev client"
+            });
+            break;
+          }
+          case "requestPermission": {
+            this.currentStatus = "waiting_approval";
+            this.detectStatusTransition();
+            const promise = new Promise((resolve6) => {
+              this.permissionResolvers.push(resolve6);
+              setTimeout(() => {
+                const idx = this.permissionResolvers.indexOf(resolve6);
+                if (idx >= 0) {
+                  this.permissionResolvers.splice(idx, 1);
+                  resolve6(false);
+                }
+              }, 3e5);
+            });
+            promise.then((approved) => {
+              this.sendResponse(msg.id, {
+                outcome: approved ? "approved" : "denied"
+              });
+            });
+            break;
+          }
+          case "terminal/create":
+          case "terminal/output":
+          case "terminal/release":
+          case "terminal/kill":
+          case "terminal/waitForExit": {
+            this.sendResponse(msg.id, null, {
+              code: -32601,
+              message: "Terminal not supported by ADHDev client"
+            });
+            break;
+          }
+          default: {
+            this.sendResponse(msg.id, null, {
+              code: -32601,
+              message: `Method ${msg.method} not supported`
+            });
+          }
+        }
+      }
+      sendResponse(id, result, error) {
+        if (!this.process?.stdin?.writable) return;
+        const msg = {
+          jsonrpc: "2.0",
+          id,
+          ...error ? { error } : { result }
+        };
+        const line = JSON.stringify(msg) + "\n";
+        this.process.stdin.write(line);
+      }
+      // ─── ACP session/update 처리 ─────────────────────
+      handleSessionUpdate(params) {
+        if (!params) return;
+        if (params.messageDelta) {
+          const delta = params.messageDelta;
+          if (delta.content) {
+            for (const part of Array.isArray(delta.content) ? delta.content : [delta.content]) {
+              if (part.type === "text" && part.text) {
+                this.partialContent += part.text;
+              }
+            }
+          }
+          this.currentStatus = "generating";
+        }
+        if (params.message) {
+          const m = params.message;
+          let content = "";
+          if (typeof m.content === "string") {
+            content = m.content;
+          } else if (Array.isArray(m.content)) {
+            content = m.content.filter((p) => p.type === "text").map((p) => p.text || "").join("\n");
+          }
+          if (content.trim()) {
+            this.messages.push({
+              role: m.role || "assistant",
+              content: content.trim(),
+              timestamp: Date.now()
+            });
+            this.partialContent = "";
+          }
+        }
+        if (params.toolCallUpdate) {
+          const tc = params.toolCallUpdate;
+          const existing = this.activeToolCalls.find((t) => t.id === tc.id);
+          if (existing) {
+            if (tc.status) existing.status = tc.status;
+            if (tc.output) existing.output = tc.output;
+          } else {
+            this.activeToolCalls.push({
+              id: tc.id || `tc_${Date.now()}`,
+              name: tc.name || "unknown",
+              status: tc.status || "running",
+              input: typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
+            });
+          }
+        }
+        if (params.stopReason) {
+          this.stopReason = params.stopReason;
+          if (params.stopReason !== "cancelled") {
+            this.currentStatus = "idle";
+          }
+          this.activeToolCalls = [];
+          this.detectStatusTransition();
+        }
+        if (params.model) {
+          this.currentModel = params.model;
+        }
+      }
+      // ─── 상태 전이 감지 ────────────────────────────
+      detectStatusTransition() {
+        const now = Date.now();
+        const newStatus = this.currentStatus;
+        const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
+        const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
+        if (newStatus !== this.lastStatus) {
+          if (this.lastStatus === "idle" && newStatus === "generating") {
+            this.generatingStartedAt = now;
+            this.pushEvent({ event: "agent:generating_started", chatTitle, timestamp: now });
+          } else if (newStatus === "waiting_approval") {
+            if (!this.generatingStartedAt) this.generatingStartedAt = now;
+            this.pushEvent({
+              event: "agent:waiting_approval",
+              chatTitle,
+              timestamp: now,
+              modalMessage: this.activeToolCalls.find((t) => t.status === "running")?.name
+            });
+          } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
+            const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
+            this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now });
+            this.generatingStartedAt = 0;
+          } else if (newStatus === "stopped") {
+            this.pushEvent({ event: "agent:stopped", chatTitle, timestamp: now });
+          }
+          this.lastStatus = newStatus;
+        }
+        const agentKey = `${this.type}:acp`;
+        const monitorEvents = this.monitor.check(agentKey, newStatus, now);
+        for (const me of monitorEvents) {
+          this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
+        }
+      }
+      pushEvent(event) {
+        this.events.push(event);
+        if (this.events.length > 50) this.events = this.events.slice(-50);
+      }
+      flushEvents() {
+        const events = [...this.events];
+        this.events = [];
+        return events;
+      }
+      // ─── 외부 접근 ─────────────────────────────────
+      get cliType() {
+        return this.type;
+      }
+      get cliName() {
+        return this.provider.name;
+      }
+      /** ACP Agent capabilities (initialize 후 사용 가능) */
+      getCapabilities() {
+        return this.agentCapabilities;
+      }
+    };
+  }
+});
+
 // src/daemon-cli.ts
-var os10, path9, import_chalk, DaemonCliManager;
+var os10, path10, import_chalk, DaemonCliManager;
 var init_daemon_cli = __esm({
   "src/daemon-cli.ts"() {
     "use strict";
     os10 = __toESM(require("os"));
-    path9 = __toESM(require("path"));
+    path10 = __toESM(require("path"));
     import_chalk = __toESM(require("chalk"));
     init_provider_cli_adapter();
     init_cli_detector();
     init_config();
     init_cli_provider_instance();
+    init_acp_provider_instance();
     DaemonCliManager = class {
       adapters = /* @__PURE__ */ new Map();
       deps;
@@ -6963,20 +7812,61 @@ var init_daemon_cli = __esm({
       // ─── 세션 시작/중지 ──────────────────────────────
       async startSession(cliType, workingDir, cliArgs) {
         const trimmed = (workingDir || os10.homedir()).trim();
-        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path9.resolve(trimmed);
-        const cliInfo = await detectCLI(cliType);
-        if (!cliInfo) throw new Error(`${cliType} not found`);
-        const key = this.getCliKey(cliType, resolvedDir);
-        if (this.adapters.has(key)) {
-          console.log(import_chalk.default.yellow(`  \u26A1 CLI ${cliType} already running in ${resolvedDir}`));
-          return;
-        }
+        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path10.resolve(trimmed);
         const typeMap = {
           "claude-code": "claude-cli",
           "codex": "codex-cli"
         };
         const normalizedType = typeMap[cliType] || cliType;
         const provider2 = this.providerLoader.get(normalizedType);
+        const key = this.getCliKey(normalizedType, resolvedDir);
+        if (this.adapters.has(key)) {
+          console.log(import_chalk.default.yellow(`  \u26A1 ${cliType} already running in ${resolvedDir}`));
+          return;
+        }
+        if (provider2 && provider2.category === "acp") {
+          const instanceManager2 = this.deps.getInstanceManager();
+          if (!instanceManager2) throw new Error("InstanceManager not available");
+          console.log(import_chalk.default.cyan(`  \u{1F50C} Starting ACP agent: ${provider2.name} (${provider2.type}) in ${resolvedDir}`));
+          const acpInstance = new AcpProviderInstance(provider2, resolvedDir, cliArgs);
+          await instanceManager2.addInstance(key, acpInstance, {
+            settings: this.providerLoader.getSettings(normalizedType)
+          });
+          this.adapters.set(key, {
+            cliType: normalizedType,
+            workingDir: resolvedDir,
+            spawn: async () => {
+            },
+            shutdown: () => {
+              instanceManager2.removeInstance(key);
+            },
+            sendMessage: async (text) => {
+              acpInstance.onEvent("send_message", { text });
+            },
+            getStatus: () => {
+              const state = acpInstance.getState();
+              return {
+                status: state.status,
+                messages: state.activeChat?.messages || [],
+                activeModal: state.activeChat?.activeModal || null
+              };
+            },
+            setOnStatusChange: () => {
+            },
+            setOnPtyData: () => {
+            }
+          });
+          console.log(import_chalk.default.green(`  \u2713 ACP agent started: ${provider2.name} in ${resolvedDir}`));
+          try {
+            addCliHistory({ cliType: normalizedType, dir: resolvedDir, cliArgs });
+          } catch (e) {
+            console.warn("[ACP] History save failed:", e?.message);
+          }
+          this.deps.onStatusChange();
+          return;
+        }
+        const cliInfo = await detectCLI(cliType);
+        if (!cliInfo) throw new Error(`${cliType} not found`);
         console.log(import_chalk.default.yellow(`  \u26A1 Starting CLI ${cliType} in ${resolvedDir}...`));
         if (provider2) {
           console.log(import_chalk.default.cyan(`  \u{1F4E6} Using provider: ${provider2.name} (${provider2.type})`));
@@ -7408,12 +8298,12 @@ var init_extension_provider_instance = __esm({
 });
 
 // src/providers/ide-provider-instance.ts
-var os11, crypto, IdeProviderInstance;
+var os11, crypto2, IdeProviderInstance;
 var init_ide_provider_instance = __esm({
   "src/providers/ide-provider-instance.ts"() {
     "use strict";
     os11 = __toESM(require("os"));
-    crypto = __toESM(require("crypto"));
+    crypto2 = __toESM(require("crypto"));
     init_extension_provider_instance();
     init_status_monitor();
     IdeProviderInstance = class {
@@ -7441,7 +8331,7 @@ var init_ide_provider_instance = __esm({
       constructor(provider2, instanceKey) {
         this.type = provider2.type;
         this.provider = provider2;
-        this.instanceId = instanceKey ? `${instanceKey}_${crypto.createHash("md5").update(os11.hostname() + instanceKey).digest("hex").slice(0, 8)}` : `${provider2.type}_${crypto.createHash("md5").update(os11.hostname() + provider2.type).digest("hex").slice(0, 8)}`;
+        this.instanceId = instanceKey ? `${instanceKey}_${crypto2.createHash("md5").update(os11.hostname() + instanceKey).digest("hex").slice(0, 8)}` : `${provider2.type}_${crypto2.createHash("md5").update(os11.hostname() + provider2.type).digest("hex").slice(0, 8)}`;
         this.monitor = new StatusMonitor();
       }
       // ─── Lifecycle ─────────────────────────────────
@@ -7569,15 +8459,36 @@ var init_ide_provider_instance = __esm({
       async readChat() {
         const { cdp: cdp2 } = this.context;
         if (!cdp2?.isConnected) return;
-        const readChatScript = this.getReadChatScript();
-        if (!readChatScript) return;
         try {
-          let raw = await cdp2.evaluate(readChatScript, 3e4);
-          if (typeof raw === "string") {
-            try {
-              raw = JSON.parse(raw);
-            } catch {
-              return;
+          let raw = null;
+          const webviewFn = this.provider.scripts?.webviewReadChat;
+          if (typeof webviewFn === "function" && cdp2.evaluateInWebviewFrame) {
+            const webviewScript = webviewFn();
+            if (webviewScript) {
+              const matchText = this.provider.webviewMatchText;
+              const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
+              const webviewRaw = await cdp2.evaluateInWebviewFrame(webviewScript, matchFn);
+              if (webviewRaw) {
+                raw = typeof webviewRaw === "string" ? (() => {
+                  try {
+                    return JSON.parse(webviewRaw);
+                  } catch {
+                    return null;
+                  }
+                })() : webviewRaw;
+              }
+            }
+          }
+          if (!raw) {
+            const readChatScript = this.getReadChatScript();
+            if (!readChatScript) return;
+            raw = await cdp2.evaluate(readChatScript, 3e4);
+            if (typeof raw === "string") {
+              try {
+                raw = JSON.parse(raw);
+              } catch {
+                return;
+              }
             }
           }
           if (!raw || typeof raw !== "object") return;
@@ -7680,9 +8591,9 @@ __export(adhdev_daemon_exports, {
   stopDaemon: () => stopDaemon
 });
 function getDaemonPidFile() {
-  const dir = path10.join(os12.homedir(), ".adhdev");
+  const dir = path11.join(os12.homedir(), ".adhdev");
   if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  return path10.join(dir, "daemon.pid");
+  return path11.join(dir, "daemon.pid");
 }
 function writeDaemonPid(pid) {
   fs6.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
@@ -7718,7 +8629,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os12, fs6, path10, crypto2, import_chalk2, DANGEROUS_PATTERNS, AdhdevDaemon;
+var os12, fs6, path11, crypto3, import_chalk2, DANGEROUS_PATTERNS, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -7741,8 +8652,8 @@ var init_adhdev_daemon = __esm({
     init_daemon_logger();
     os12 = __toESM(require("os"));
     fs6 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
-    crypto2 = __toESM(require("crypto"));
+    path11 = __toESM(require("path"));
+    crypto3 = __toESM(require("crypto"));
     import_chalk2 = __toESM(require("chalk"));
     DANGEROUS_PATTERNS = [
       /\brm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i,
@@ -7877,7 +8788,7 @@ var init_adhdev_daemon = __esm({
         this.commandHandler.setAgentStreamManager(this.agentStreamManager);
         this.startAgentStreamPolling();
         const machineId = os12.hostname().replace(/[^a-zA-Z0-9]/g, "_");
-        const machineHash = crypto2.createHash("md5").update(os12.hostname() + os12.homedir()).digest("hex").slice(0, 8);
+        const machineHash = crypto3.createHash("md5").update(os12.hostname() + os12.homedir()).digest("hex").slice(0, 8);
         const instanceId = `daemon_${machineId}_${machineHash}`;
         this.bridge = new CliBridgeConnection({
           serverUrl: options.serverUrl || config.serverUrl,
@@ -9065,16 +9976,16 @@ async function injectTokenToIDE(ide, connectionToken) {
   try {
     const os13 = await import("os");
     const fs7 = await import("fs");
-    const path11 = await import("path");
+    const path12 = await import("path");
     const platform7 = os13.platform();
     const home = os13.homedir();
     const getSettingsPath = (appName2) => {
       if (platform7 === "darwin") {
-        return path11.join(home, "Library", "Application Support", appName2, "User", "settings.json");
+        return path12.join(home, "Library", "Application Support", appName2, "User", "settings.json");
       } else if (platform7 === "win32") {
-        return path11.join(process.env.APPDATA || path11.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
+        return path12.join(process.env.APPDATA || path12.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
       } else {
-        return path11.join(home, ".config", appName2, "User", "settings.json");
+        return path12.join(home, ".config", appName2, "User", "settings.json");
       }
     };
     const loader = new ProviderLoader({ logFn: () => {
@@ -9092,7 +10003,7 @@ async function injectTokenToIDE(ide, connectionToken) {
         settings = {};
       }
     } else {
-      fs7.mkdirSync(path11.dirname(settingsPath), { recursive: true });
+      fs7.mkdirSync(path12.dirname(settingsPath), { recursive: true });
     }
     settings["adhdev.connectionToken"] = connectionToken;
     settings["adhdev.autoConnect"] = true;
@@ -9128,8 +10039,8 @@ async function startDaemonFlow() {
     const daemon = new AdhdevDaemon2();
     const { execSync: execSync6 } = await import("child_process");
     const os13 = await import("os");
-    const path11 = await import("path");
-    const logPath = path11.join(os13.homedir(), ".adhdev", "daemon.log");
+    const path12 = await import("path");
+    const logPath = path12.join(os13.homedir(), ".adhdev", "daemon.log");
     try {
       execSync6(`nohup adhdev daemon > "${logPath}" 2>&1 &`, {
         timeout: 3e3,