adhdev 0.1.21 → 0.1.22

package/dist/index.js

@@ -821,6 +821,8 @@ var init_cli_bridge = __esm({
           const handlers = this.messageHandlers.get(message.type);
           if (handlers) {
             handlers.forEach((h) => h(message));
+          } else if (message.type !== "auth_ok" && message.type !== "auth_error") {
+            console.log(`[CliBridge] Unhandled message type: ${message.type}`);
           }
         } catch (error) {
           console.error("[CliBridge] Failed to parse message:", error);
@@ -1931,8 +1933,10 @@ var init_daemon_cdp = __esm({
       MAX_FAILURES = 5;
       agentSessions = /* @__PURE__ */ new Map();
       logFn;
-      constructor(port = 9333, logFn) {
+      disableFallback;
+      constructor(port = 9333, logFn, disableFallback = false) {
         this.port = port;
+        this.disableFallback = disableFallback;
         this.logFn = logFn || ((msg) => {
           console.log(msg);
           try {
@@ -2011,6 +2015,7 @@ var init_daemon_cdp = __esm({
       async findTarget() {
         let target = await this.findTargetOnPort(this.port);
         if (target) return target;
+        if (this.disableFallback) return null;
         const fallbackPorts = [9222, 9333, 9335, 9337, 9339].filter((p) => p !== this.port);
         for (const port of fallbackPorts) {
           target = await this.findTargetOnPort(port);
@@ -2070,7 +2075,10 @@ var init_daemon_cdp = __esm({
         this.reconnectTimer = setTimeout(async () => {
           this.reconnectTimer = null;
           if (!this._connected) {
-            await this.connect();
+            const ok = await this.connect();
+            if (!ok && !this._connected) {
+              this.scheduleReconnect();
+            }
           }
         }, 5e3);
       }
@@ -2256,7 +2264,9 @@ var init_daemon_cdp = __esm({
         try {
           const result = await this.sendInternal("Page.captureScreenshot", {
             format: "jpeg",
-            quality: 60
+            quality: 25,
+            clip: void 0
+            // full viewport
           }, 1e4);
           if (result?.data) {
             return Buffer.from(result.data, "base64");
@@ -2577,12 +2587,22 @@ var init_daemon_p2p = __esm({
       fileRequestHandler = null;
       inputHandler = null;
       commandHandler = null;
+      _ssDebugDone = false;
       get screenshotActive() {
         for (const peer of this.peers.values()) {
           if (peer.screenshotActive && peer.state === "connected") return true;
         }
         return false;
       }
+      /** Get the ideType for the currently active screenshot request */
+      get screenshotIdeType() {
+        for (const peer of this.peers.values()) {
+          if (peer.screenshotActive && peer.state === "connected" && peer.screenshotIdeType) {
+            return peer.screenshotIdeType;
+          }
+        }
+        return void 0;
+      }
       constructor(bridge) {
         this.bridge = bridge;
         this.tryLoadNodeDatachannel();
@@ -2781,11 +2801,17 @@ var init_daemon_p2p = __esm({
             }
           });
           const screenshotCh = pc.createDataChannel("screenshots");
-          entry.screenshotChannel = screenshotCh;
           screenshotCh.onOpen(() => {
             log(`Screenshots channel OPEN for peer ${pid}`);
-            entry.state = "connected";
-            this.notifyStateChange();
+            const peer = this.peers.get(pid);
+            if (peer) {
+              peer.screenshotChannel = screenshotCh;
+              peer.state = "connected";
+              this.notifyStateChange();
+              if (peer.screenshotActive) {
+                log(`Screenshots auto-starting for peer ${pid} (was waiting for channel open)`);
+              }
+            }
           });
           screenshotCh.onClosed(() => {
             log(`Screenshots channel CLOSED for peer ${pid}`);
@@ -2819,14 +2845,24 @@ var init_daemon_p2p = __esm({
         const text = typeof msg === "string" ? msg : msg.toString("utf-8");
         try {
           const parsed = JSON.parse(text);
+          log(`Files message from peer ${peerId}: type=${parsed.type}`);
           if (parsed.type === "screenshot_start") {
             const peer = this.peers.get(peerId);
-            if (peer) peer.screenshotActive = true;
+            if (peer) {
+              peer.screenshotActive = true;
+              peer.screenshotIdeType = parsed.ideType || void 0;
+              log(`screenshot_start: peer=${peerId}, ideType=${parsed.ideType || "any"}, channelOpen=${!!peer.screenshotChannel}, state=${peer.state}`);
+            } else {
+              log(`screenshot_start: peer ${peerId} NOT FOUND in peers map!`);
+            }
             return;
           }
           if (parsed.type === "screenshot_stop") {
             const peer = this.peers.get(peerId);
-            if (peer) peer.screenshotActive = false;
+            if (peer) {
+              peer.screenshotActive = false;
+              log(`screenshot_stop: peer=${peerId}`);
+            }
             return;
           }
           if (parsed.type === "input") {
@@ -2863,14 +2899,28 @@ var init_daemon_p2p = __esm({
       sendScreenshot(base64Data) {
         let sentAny = false;
         const buffer = Buffer.from(base64Data, "base64");
-        for (const peer of this.peers.values()) {
+        let debugOnce = !this._ssDebugDone;
+        const CHUNK_SIZE = 6e4;
+        for (const [pid, peer] of this.peers.entries()) {
+          if (debugOnce) {
+            log(`sendScreenshot peer=${pid}: state=${peer.state}, hasSsCh=${!!peer.screenshotChannel}, ssActive=${peer.screenshotActive}, chOpen=${peer.screenshotChannel?.isOpen?.() ?? "N/A"}, bufSize=${buffer.length}`);
+          }
           if (peer.state !== "connected" || !peer.screenshotChannel || !peer.screenshotActive) continue;
           try {
-            peer.screenshotChannel.sendMessageBinary(buffer);
+            if (!peer.screenshotChannel.isOpen()) continue;
+            const header = Buffer.alloc(4);
+            header.writeUInt32BE(buffer.length, 0);
+            peer.screenshotChannel.sendMessageBinary(header);
+            for (let offset = 0; offset < buffer.length; offset += CHUNK_SIZE) {
+              const chunk = buffer.subarray(offset, Math.min(offset + CHUNK_SIZE, buffer.length));
+              peer.screenshotChannel.sendMessageBinary(chunk);
+            }
             sentAny = true;
-          } catch {
+          } catch (e) {
+            if (debugOnce) log(`sendScreenshot ERROR for peer ${pid}: ${e?.message}`);
           }
         }
+        if (debugOnce) this._ssDebugDone = true;
         return sentAny;
       }
       // ─── 핸들러 등록 ────────────────────────────
@@ -2904,7 +2954,9 @@ var init_daemon_p2p = __esm({
           return;
         }
         try {
-          const result = await this.inputHandler({ action, params });
+          const peer = this.peers.get(peerId);
+          const ideType = peer?.screenshotIdeType;
+          const result = await this.inputHandler({ action, params, _targetInstance: ideType ? `${ideType}_` : void 0 });
           this.sendToPeer(peerId, { id, type: "response", success: true, result });
         } catch (e) {
           this.sendToPeer(peerId, { id, type: "response", success: false, error: e?.message });
@@ -3156,13 +3208,46 @@ var init_daemon_commands = __esm({
     DaemonCommandHandler = class {
       ctx;
       agentStream = null;
+      /** Get CDP manager for a specific ideType, or first connected one */
+      getCdp(ideType) {
+        const key = ideType || this._currentIdeType;
+        if (key) {
+          const m = this.ctx.cdpManagers.get(key.toLowerCase());
+          if (m?.isConnected) return m;
+        }
+        for (const m of this.ctx.cdpManagers.values()) {
+          if (m.isConnected) return m;
+        }
+        return null;
+      }
+      /** Current IDE type extracted from command args (per-request) */
+      _currentIdeType;
+      /** Extract ideType from _targetInstance (e.g. 'vscode_abc123' → 'vscode') */
+      extractIdeType(args) {
+        if (args?._targetInstance) {
+          const parts = args._targetInstance.split("_");
+          if (parts.length >= 2) return parts[0];
+        }
+        return void 0;
+      }
       constructor(ctx) {
         this.ctx = ctx;
       }
+      /** Get ScriptLoader for specific ideType, fallback to first available */
+      getScriptLoader(ideType) {
+        const key = ideType || this._currentIdeType;
+        if (key) {
+          const l = this.ctx.scriptLoaders.get(key.toLowerCase());
+          if (l) return l;
+        }
+        for (const l of this.ctx.scriptLoaders.values()) return l;
+        return void 0;
+      }
       setAgentStreamManager(manager) {
         this.agentStream = manager;
       }
       async handle(cmd, args) {
+        this._currentIdeType = this.extractIdeType(args);
         switch (cmd) {
           // ─── CDP 직접 처리 ───────────────────
           case "read_chat":
@@ -3205,8 +3290,13 @@ var init_daemon_commands = __esm({
             return this.handleFileListBrowse(args);
           // ─── vscode API → Extension 위임 ────
           case "vscode_command_exec":
-          case "execute_vscode_command":
-            return this.delegateToExtension(args?.command || cmd, args?.args);
+          case "execute_vscode_command": {
+            const resolvedCmd = args?.commandId || args?.command;
+            if (resolvedCmd === "adhdev.captureCdpScreenshot") {
+              return this.handleScreenshot(args);
+            }
+            return this.delegateToExtension(resolvedCmd || cmd, args?.args);
+          }
           case "get_open_editors":
             return this.delegateToExtension("adhdev.getOpenEditors", [args]);
           case "open_tab":
@@ -3249,59 +3339,97 @@ var init_daemon_commands = __esm({
       }
       // ─── CDP 기반 채팅 명령 ──────────────────────
       async handleReadChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const script = this.ctx.scriptLoader?.get("read_chat");
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const script = this.getScriptLoader()?.get("read_chat");
         if (!script) return { success: false, error: "read_chat script not loaded" };
         try {
-          const result = await this.ctx.cdp.evaluate(script, 5e4);
+          const result = await this.getCdp().evaluate(script, 5e4);
           return { success: true, ...result };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleSendChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
         const text = args?.text || args?.message;
         if (!text) return { success: false, error: "text required" };
-        const script = this.ctx.scriptLoader?.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
-        if (!script) return { success: false, error: "send_message script not loaded" };
-        try {
-          await this.ctx.cdp.evaluate(script, 3e4);
-          return { success: true, sent: true };
-        } catch (e) {
-          return { success: false, error: e.message };
+        const targetCdp = this.getCdp();
+        const targetLoader = this.getScriptLoader();
+        if (targetCdp?.isConnected && targetLoader) {
+          const script = targetLoader.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
+          if (script) {
+            console.log(`[send_chat] Targeting IDE: ${this._currentIdeType || "fallback-first"}`);
+            try {
+              await targetCdp.evaluate(script, 3e4);
+              return { success: true, sent: true };
+            } catch (e) {
+              console.log(`[send_chat] Failed on ${this._currentIdeType}: ${e.message}`);
+            }
+          }
         }
+        console.log(`[send_chat] No specific target, trying all CDPs...`);
+        for (const [ideType, cdp] of this.ctx.cdpManagers) {
+          if (!cdp.isConnected) continue;
+          const loader = this.ctx.scriptLoaders.get(ideType);
+          if (!loader) continue;
+          const script = loader.getWithParams("send_message", { MESSAGE: JSON.stringify(text) });
+          if (!script) continue;
+          console.log(`[send_chat] Trying IDE: ${ideType}`);
+          try {
+            await cdp.evaluate(script, 3e4);
+            return { success: true, sent: true, targetIde: ideType };
+          } catch (e) {
+            console.log(`[send_chat] Failed on ${ideType}: ${e.message}`);
+          }
+        }
+        return { success: false, error: "No CDP could send the message" };
       }
       async handleListChats(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const script = this.ctx.scriptLoader?.get("list_chats");
-        if (!script) return { success: false, error: "list_chats script not loaded" };
+        const cdp = this.getCdp();
+        if (!cdp?.isConnected) {
+          console.log(`[list_chats] CDP not connected, ideType=${this._currentIdeType}`);
+          return { success: false, error: "CDP not connected" };
+        }
+        const script = this.getScriptLoader()?.get("list_chats");
+        if (!script) {
+          console.log(`[list_chats] script not loaded`);
+          return { success: false, error: "list_chats script not loaded" };
+        }
         try {
-          const result = await this.ctx.cdp.evaluate(script, 3e4);
-          return { success: true, chats: result };
+          console.log(`[list_chats] Evaluating on ideType=${this._currentIdeType}`);
+          const result = await cdp.evaluate(script, 3e4);
+          let parsed = result;
+          if (typeof result === "string") {
+            try {
+              parsed = JSON.parse(result);
+            } catch {
+            }
+          }
+          console.log(`[list_chats] Result type=${typeof parsed}, isArray=${Array.isArray(parsed)}, len=${Array.isArray(parsed) ? parsed.length : "N/A"}`);
+          return { success: true, chats: parsed };
         } catch (e) {
+          console.log(`[list_chats] Error: ${e.message}`);
           return { success: false, error: e.message };
         }
       }
       async handleNewChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const script = this.ctx.scriptLoader?.get("new_session");
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const script = this.getScriptLoader()?.get("new_session");
         if (!script) return { success: false, error: "new_session script not loaded" };
         try {
-          await this.ctx.cdp.evaluate(script, 15e3);
+          await this.getCdp().evaluate(script, 15e3);
           return { success: true };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleSwitchChat(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const sessionId = args?.sessionId || args?.id || args?.chatId;
         if (!sessionId) return { success: false, error: "sessionId required" };
-        const script = this.ctx.scriptLoader?.getWithParams("switch_session", { SESSION_ID: sessionId });
+        const script = this.getScriptLoader()?.getWithParams("switch_session", { SESSION_ID: sessionId });
         if (!script) return { success: false, error: "switch_session script not loaded" };
         try {
-          await this.ctx.cdp.evaluate(script, 15e3);
+          await this.getCdp().evaluate(script, 15e3);
           return { success: true };
         } catch (e) {
           return { success: false, error: e.message };
@@ -3315,12 +3443,12 @@ var init_daemon_commands = __esm({
         return this.delegateToExtension("workbench.action.openSettings", [`cursor.model`]);
       }
       async handleResolveModal(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const button = args?.button || args?.buttonText || "Accept";
-        const script = this.ctx.scriptLoader?.getWithParams("resolve_modal", { BUTTON_TEXT: button });
+        const script = this.getScriptLoader()?.getWithParams("resolve_modal", { BUTTON_TEXT: button });
         if (!script) {
           try {
-            await this.ctx.cdp.evaluate(`
+            await this.getCdp().evaluate(`
                     (() => {
                         const btns = [...document.querySelectorAll('button')];
                         const btn = btns.find(b => b.textContent?.trim() === ${JSON.stringify(button)});
@@ -3334,7 +3462,7 @@ var init_daemon_commands = __esm({
           }
         }
         try {
-          await this.ctx.cdp.evaluate(script, 1e4);
+          await this.getCdp().evaluate(script, 1e4);
           return { success: true };
         } catch (e) {
           return { success: false, error: e.message };
@@ -3342,22 +3470,23 @@ var init_daemon_commands = __esm({
       }
       // ─── CDP 직접 명령 ──────────────────────────
       async handleCdpEval(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const expression = args?.expression || args?.script;
         if (!expression) return { success: false, error: "expression required" };
         try {
-          const result = await this.ctx.cdp.evaluate(expression, 5e4);
+          const result = await this.getCdp().evaluate(expression, 5e4);
           return { success: true, result };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleScreenshot(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         try {
-          const buf = await this.ctx.cdp.captureScreenshot();
+          const buf = await this.getCdp().captureScreenshot();
           if (buf) {
-            return { success: true, screenshot: buf.toString("base64"), format: "jpeg" };
+            const b64 = buf.toString("base64");
+            return { success: true, result: b64, base64: b64, screenshot: b64, format: "jpeg" };
           }
           return { success: false, error: "Screenshot failed" };
         } catch (e) {
@@ -3365,26 +3494,26 @@ var init_daemon_commands = __esm({
         }
       }
       async handleCdpCommand(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const method = args?.method;
         const params = args?.params || {};
         if (!method) return { success: false, error: "method required" };
         try {
-          const result = await this.ctx.cdp.sendCdpCommand(method, params);
+          const result = await this.getCdp().sendCdpCommand(method, params);
           return { success: true, result };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
       async handleCdpBatch(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const commands = args?.commands;
         const stopOnError = args?.stopOnError !== false;
         if (!commands?.length) return { success: false, error: "commands array required" };
         const results = [];
         for (const cmd of commands) {
           try {
-            const result = await this.ctx.cdp.sendCdpCommand(cmd.method, cmd.params || {});
+            const result = await this.getCdp().sendCdpCommand(cmd.method, cmd.params || {});
             results.push({ method: cmd.method, success: true, result });
           } catch (e) {
             results.push({ method: cmd.method, success: false, error: e.message });
@@ -3394,49 +3523,60 @@ var init_daemon_commands = __esm({
         return { success: true, results };
       }
       async handleCdpRemoteAction(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
         const action = args?.action;
         const params = args?.params || args;
         try {
           switch (action) {
             case "input_key": {
               const { key, modifiers } = params;
-              await this.ctx.cdp.send("Input.dispatchKeyEvent", {
+              await this.getCdp().send("Input.dispatchKeyEvent", {
                 type: "keyDown",
                 key,
                 ...modifiers?.ctrl ? { modifiers: 2 } : {},
                 ...modifiers?.shift ? { modifiers: 8 } : {}
               });
-              await this.ctx.cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key });
+              await this.getCdp().send("Input.dispatchKeyEvent", { type: "keyUp", key });
               return { success: true };
             }
             case "input_click": {
-              const { x, y, button: btn } = params;
-              await this.ctx.cdp.send("Input.dispatchMouseEvent", {
+              let { x, y, nx, ny, button: btn } = params;
+              if ((x === void 0 || y === void 0) && nx !== void 0 && ny !== void 0) {
+                const viewport = await this.getCdp().evaluate(
+                  "JSON.stringify({ w: window.innerWidth, h: window.innerHeight })"
+                );
+                const { w, h } = JSON.parse(viewport);
+                x = Math.round(nx * w);
+                y = Math.round(ny * h);
+              }
+              if (x === void 0 || y === void 0) {
+                return { success: false, error: "No coordinates provided (x,y or nx,ny required)" };
+              }
+              await this.getCdp().send("Input.dispatchMouseEvent", {
                 type: "mousePressed",
                 x,
                 y,
                 button: btn || "left",
                 clickCount: 1
               });
-              await this.ctx.cdp.send("Input.dispatchMouseEvent", {
+              await this.getCdp().send("Input.dispatchMouseEvent", {
                 type: "mouseReleased",
                 x,
                 y,
                 button: btn || "left",
                 clickCount: 1
               });
-              return { success: true };
+              return { success: true, x, y };
             }
             case "input_type": {
               const { text } = params;
               for (const char of text || "") {
-                await this.ctx.cdp.send("Input.dispatchKeyEvent", {
+                await this.getCdp().send("Input.dispatchKeyEvent", {
                   type: "keyDown",
                   text: char,
                   key: char
                 });
-                await this.ctx.cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key: char });
+                await this.getCdp().send("Input.dispatchKeyEvent", { type: "keyUp", key: char });
               }
               return { success: true };
             }
@@ -3445,9 +3585,28 @@ var init_daemon_commands = __esm({
             case "page_eval":
               return this.handleCdpEval(params);
             case "dom_query": {
-              const html = await this.ctx.cdp.querySelector(params?.selector);
+              const html = await this.getCdp().querySelector(params?.selector);
               return { success: true, html };
             }
+            case "input_wheel": {
+              let { x, y, nx, ny, deltaX, deltaY } = params;
+              if ((x === void 0 || y === void 0) && nx !== void 0 && ny !== void 0) {
+                const viewport = await this.getCdp().evaluate(
+                  "JSON.stringify({ w: window.innerWidth, h: window.innerHeight })"
+                );
+                const { w, h } = JSON.parse(viewport);
+                x = Math.round(nx * w);
+                y = Math.round(ny * h);
+              }
+              await this.getCdp().send("Input.dispatchMouseEvent", {
+                type: "mouseWheel",
+                x: x || 0,
+                y: y || 0,
+                deltaX: deltaX || 0,
+                deltaY: deltaY || 0
+              });
+              return { success: true };
+            }
             default:
               return { success: false, error: `Unknown remote action: ${action}` };
           }
@@ -3456,8 +3615,8 @@ var init_daemon_commands = __esm({
         }
       }
       async handleDiscoverAgents(args) {
-        if (!this.ctx.cdp?.isConnected) return { success: false, error: "CDP not connected" };
-        const agents = await this.ctx.cdp.discoverAgentWebviews();
+        if (!this.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
+        const agents = await this.getCdp().discoverAgentWebviews();
         return { success: true, agents };
       }
       // ─── 파일 직접 처리 ─────────────────────────
@@ -3514,7 +3673,7 @@ var init_daemon_commands = __esm({
         if (!this.ctx.localServer || this.ctx.localServer.extensionCount === 0) {
           return { success: false, error: "No extension connected" };
         }
-        return this.ctx.localServer.executeVscodeCommand(command, args);
+        return this.ctx.localServer.executeVscodeCommand(command, args, this._currentIdeType);
       }
       // ─── 기타 ───────────────────────────────────
       async handleGetRecentWorkspaces(args) {
@@ -3533,66 +3692,67 @@ var init_daemon_commands = __esm({
         }
       }
       async handleRefreshScripts(args) {
-        if (!this.ctx.scriptLoader) return { success: false, error: "ScriptLoader not initialized" };
-        await this.ctx.scriptLoader.refresh();
+        const loader = this.getScriptLoader();
+        if (!loader) return { success: false, error: "ScriptLoader not initialized" };
+        await loader.refresh();
         return { success: true };
       }
       // ─── Agent Stream 명령 ───────────────────────
       async handleAgentStreamSwitch(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || null;
-        await this.agentStream.switchActiveAgent(this.ctx.cdp, agentType);
+        await this.agentStream.switchActiveAgent(this.getCdp(), agentType);
         return { success: true, activeAgent: agentType };
       }
       async handleAgentStreamRead(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
-        const streams = await this.agentStream.collectAgentStreams(this.ctx.cdp);
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
+        const streams = await this.agentStream.collectAgentStreams(this.getCdp());
         return { success: true, streams };
       }
       async handleAgentStreamSend(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         const text = args?.text || args?.message;
         if (!agentType || !text) return { success: false, error: "agentType and text required" };
-        const ok = await this.agentStream.sendToAgent(this.ctx.cdp, agentType, text);
+        const ok = await this.agentStream.sendToAgent(this.getCdp(), agentType, text);
         return { success: ok };
       }
       async handleAgentStreamResolve(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         const action = args?.action || "approve";
         if (!agentType) return { success: false, error: "agentType required" };
-        const ok = await this.agentStream.resolveAgentAction(this.ctx.cdp, agentType, action);
+        const ok = await this.agentStream.resolveAgentAction(this.getCdp(), agentType, action);
         return { success: ok };
       }
       async handleAgentStreamNew(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         if (!agentType) return { success: false, error: "agentType required" };
-        const ok = await this.agentStream.newAgentSession(this.ctx.cdp, agentType);
+        const ok = await this.agentStream.newAgentSession(this.getCdp(), agentType);
         return { success: ok };
       }
       async handleAgentStreamListChats(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         if (!agentType) return { success: false, error: "agentType required" };
-        const chats = await this.agentStream.listAgentChats(this.ctx.cdp, agentType);
+        const chats = await this.agentStream.listAgentChats(this.getCdp(), agentType);
         return { success: true, chats };
       }
       async handleAgentStreamSwitchSession(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         const sessionId = args?.sessionId || args?.id;
         if (!agentType || !sessionId) return { success: false, error: "agentType and sessionId required" };
-        const ok = await this.agentStream.switchAgentSession(this.ctx.cdp, agentType, sessionId);
+        const ok = await this.agentStream.switchAgentSession(this.getCdp(), agentType, sessionId);
         return { success: ok };
       }
       async handleAgentStreamFocus(args) {
-        if (!this.agentStream || !this.ctx.cdp) return { success: false, error: "AgentStream or CDP not available" };
+        if (!this.agentStream || !this.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
         const agentType = args?.agentType || args?.agent || this.agentStream.activeAgentType;
         if (!agentType) return { success: false, error: "agentType required" };
         await this.agentStream.ensureAgentPanelOpen(agentType);
-        const ok = await this.agentStream.focusAgentEditor(this.ctx.cdp, agentType);
+        const ok = await this.agentStream.focusAgentEditor(this.getCdp(), agentType);
         return { success: ok };
       }
     };
@@ -4193,10 +4353,10 @@ var init_adhdev_daemon = __esm({
       localServer = null;
       bridge = null;
       adapter = null;
-      cdpManager = null;
+      cdpManagers = /* @__PURE__ */ new Map();
       cdpDiscoveryTimer = null;
       p2p = null;
-      scriptLoader = null;
+      scriptLoaders = /* @__PURE__ */ new Map();
       commandHandler = null;
       screenshotTimer = null;
       agentStreamManager = null;
@@ -4208,7 +4368,9 @@ var init_adhdev_daemon = __esm({
       detectedIdes = [];
       localPort;
       ideType = "unknown";
-      _cachedAgentStreams = [];
+      _cachedAgentStreamsMap = /* @__PURE__ */ new Map();
+      _cachedActiveChatMap = /* @__PURE__ */ new Map();
+      _cdpChatBusy = false;
       constructor() {
         this.localPort = DEFAULT_DAEMON_PORT;
       }
@@ -4271,18 +4433,27 @@ var init_adhdev_daemon = __esm({
         }
         this.detectedIdes = await detectIDEs();
         await this.initCdp();
-        this.ideType = this.detectedIdes.find((ide) => ide.running)?.type || "cursor";
-        this.scriptLoader = new DaemonScriptLoader(
-          options.serverUrl || config.serverUrl,
-          this.ideType
-        );
-        this.scriptLoader.setToken(config.connectionToken);
-        await this.scriptLoader.start().catch((e) => {
-          console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed: ${e.message}`));
-        });
+        const serverUrl = options.serverUrl || config.serverUrl;
+        for (const ideType of this.cdpManagers.keys()) {
+          const loader = new DaemonScriptLoader(serverUrl, ideType);
+          loader.setToken(config.connectionToken);
+          await loader.start().catch((e) => {
+            console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed for ${ideType}: ${e.message}`));
+          });
+          this.scriptLoaders.set(ideType, loader);
+        }
+        if (this.scriptLoaders.size === 0) {
+          const fallbackType = this.detectedIdes.find((ide) => ide.installed)?.id || "cursor";
+          const loader = new DaemonScriptLoader(serverUrl, fallbackType);
+          loader.setToken(config.connectionToken);
+          await loader.start().catch((e) => {
+            console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed: ${e.message}`));
+          });
+          this.scriptLoaders.set(fallbackType, loader);
+        }
         this.commandHandler = new DaemonCommandHandler({
-          cdp: this.cdpManager,
-          scriptLoader: this.scriptLoader,
+          cdpManagers: this.cdpManagers,
+          scriptLoaders: this.scriptLoaders,
           localServer: this.localServer,
           ideType: this.ideType
         });
@@ -4293,16 +4464,7 @@ var init_adhdev_daemon = __esm({
         );
         this.agentStreamManager.setLocalServer(this.localServer);
         this.commandHandler.setAgentStreamManager(this.agentStreamManager);
-        if (this.cdpManager) {
-          this.agentStreamTimer = setInterval(async () => {
-            if (!this.cdpManager?.isConnected || !this.agentStreamManager) return;
-            try {
-              await this.agentStreamManager.syncAgentSessions(this.cdpManager);
-              this._cachedAgentStreams = await this.agentStreamManager.collectAgentStreams(this.cdpManager);
-            } catch {
-            }
-          }, 5e3);
-        }
+        this.startAgentStreamPolling();
         if (options.cliType) {
           const cliInfo = await detectCLI(options.cliType);
           if (cliInfo) {
@@ -4353,12 +4515,26 @@ var init_adhdev_daemon = __esm({
               return { id: req.id, success: result.success, entries: result.files, error: result.error };
             }
           });
+          let ssDebugCount = 0;
           this.screenshotTimer = setInterval(async () => {
-            if (!this.p2p?.screenshotActive || !this.cdpManager?.isConnected) return;
+            const active = this.p2p?.screenshotActive;
+            const ssIdeType = this.p2p?.screenshotIdeType;
+            const cdp = ssIdeType ? this.getCdpFor(ssIdeType) : this.getAnyCdp();
+            if (!active || !cdp) return;
+            ssDebugCount++;
+            if (ssDebugCount <= 3 || ssDebugCount % 25 === 0) {
+              console.log(`[SS] Capturing screenshot... (tick ${ssDebugCount}, active=${active}, cdp=true)`);
+            }
             try {
-              const buf = await this.cdpManager.captureScreenshot();
-              if (buf) this.p2p.sendScreenshot(buf.toString("base64"));
-            } catch {
+              const buf = await cdp.captureScreenshot();
+              if (buf) {
+                const sent = this.p2p.sendScreenshot(buf.toString("base64"));
+                if (ssDebugCount <= 3) console.log(`[SS] Screenshot sent: ${buf.length} bytes, delivered=${sent}`);
+              } else {
+                if (ssDebugCount <= 5) console.log(`[SS] captureScreenshot returned null`);
+              }
+            } catch (e) {
+              if (ssDebugCount <= 5) console.log(`[SS] Screenshot error: ${e?.message}`);
             }
           }, 200);
         } else {
@@ -4391,9 +4567,10 @@ var init_adhdev_daemon = __esm({
         console.log(import_chalk2.default.bold("  \u{1F309} ADHDev Daemon"));
         console.log(`  ${import_chalk2.default.bold("Local:")}   ws://127.0.0.1:${this.localPort}/ipc`);
         console.log(`  ${import_chalk2.default.bold("Server:")}  ${serverUrl}`);
-        console.log(`  ${import_chalk2.default.bold("CDP:")}     ${this.cdpManager?.isConnected ? `\u2705 port ${this.cdpManager.getPort()}` : "\u274C not connected"}`);
+        const cdpStatus = this.cdpManagers.size > 0 ? `\u2705 ${[...this.cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(", ")}` : "\u274C not connected";
+        console.log(`  ${import_chalk2.default.bold("CDP:")}     ${cdpStatus}`);
         console.log(`  ${import_chalk2.default.bold("P2P:")}     ${this.p2p?.isAvailable ? "\u2705 available" : "\u274C unavailable"}`);
-        console.log(`  ${import_chalk2.default.bold("Scripts:")} ${this.scriptLoader ? `\u2705 ${this.ideType}` : "\u274C not loaded"}`);
+        console.log(`  ${import_chalk2.default.bold("Scripts:")} ${this.scriptLoaders.size > 0 ? `\u2705 ${[...this.scriptLoaders.keys()].join(", ")}` : "\u274C not loaded"}`);
         if (options.cliType) {
           console.log(`  ${import_chalk2.default.bold("CLI:")}     ${options.cliType}`);
           console.log(`  ${import_chalk2.default.bold("Dir:")}     ${options.workingDir || process.cwd()}`);
@@ -4405,19 +4582,6 @@ var init_adhdev_daemon = __esm({
       // ─── 서버 명령 핸들러 ───────────────────────────
       registerServerHandlers() {
         if (!this.bridge) return;
-        this.bridge.on("send_chat", (msg) => {
-          const text = msg.payload.message;
-          if (!text || !this.adapter) {
-            this.sendResult(msg, false, { error: "No message or CLI adapter" });
-            return;
-          }
-          console.log(import_chalk2.default.cyan(`  \u2190 Chat: "${text.slice(0, 60)}${text.length > 60 ? "..." : ""}"`));
-          this.adapter.sendMessage(text).then(() => {
-            this.sendResult(msg, true, { sent: true });
-          }).catch((e) => {
-            this.sendResult(msg, false, { error: e?.message || "Failed" });
-          });
-        });
         this.bridge.on("command", async (msg) => {
           const cmd = msg.payload.command;
           const args = msg.payload.args;
@@ -4455,7 +4619,38 @@ var init_adhdev_daemon = __esm({
           "file_list",
           "file_list_browse",
           "terminal_exec",
-          "refresh_scripts"
+          "refresh_scripts",
+          // CLI/daemon-local commands (launch, restart, detect)
+          "launch_ide",
+          "detect_ides",
+          "restart_session",
+          "switch_cli",
+          "change_dir",
+          "exec_command",
+          // Extension-delegated commands (must be registered to receive WS messages)
+          "vscode_command_exec",
+          "execute_vscode_command",
+          "get_open_editors",
+          "open_tab",
+          "close_tab",
+          "open_folder",
+          "open_folder_picker",
+          "open_recent",
+          "get_commands",
+          "get_recent_workspaces",
+          "open_panel",
+          "open_file",
+          "create_terminal",
+          "close_terminal",
+          // Agent stream commands
+          "agent_stream_switch",
+          "agent_stream_read",
+          "agent_stream_send",
+          "agent_stream_resolve",
+          "agent_stream_new",
+          "agent_stream_list_chats",
+          "agent_stream_switch_session",
+          "agent_stream_focus"
         ];
         for (const cmdType of directCdpCommands) {
           this.bridge.on(cmdType, async (msg) => {
@@ -4506,7 +4701,33 @@ var init_adhdev_daemon = __esm({
               return;
             }
             case "launch_ide": {
-              const result = await launchWithCdp(args);
+              const launchArgs = { ...args, ideId: args.ideId || args.ideType };
+              const ideKey = launchArgs.ideId;
+              console.log(`[launch_ide] target=${ideKey || "auto"}`);
+              const result = await launchWithCdp(launchArgs);
+              if (result.success && result.port && result.ideId && !this.cdpManagers.has(result.ideId)) {
+                console.log(import_chalk2.default.cyan(`[launch_ide] Connecting CDP for ${result.ideId} on port ${result.port}...`));
+                const manager = new DaemonCdpManager(result.port, (msg2) => {
+                  console.log(import_chalk2.default.gray(msg2));
+                }, true);
+                const connected = await manager.connect();
+                if (connected) {
+                  this.cdpManagers.set(result.ideId, manager);
+                  console.log(import_chalk2.default.green(`  \u{1F50D} CDP connected: ${result.ideId} (port ${result.port})`));
+                  console.log(import_chalk2.default.green(`  \u{1F4E1} CDP: ${this.cdpManagers.size} IDE(s) connected`));
+                  if (!this.scriptLoaders.has(result.ideId)) {
+                    const config = loadConfig();
+                    const serverUrl = config.serverUrl || "https://api.adhf.dev";
+                    const loader = new DaemonScriptLoader(serverUrl, result.ideId);
+                    loader.setToken(config.connectionToken || "");
+                    await loader.start().catch((e) => {
+                      console.log(import_chalk2.default.yellow(`  \u26A0 ScriptLoader start failed for ${result.ideId}: ${e?.message}`));
+                    });
+                    this.scriptLoaders.set(result.ideId, loader);
+                  }
+                }
+              }
+              this.startAgentStreamPolling();
               this.sendResult(msg, result.success, result);
               return;
             }
@@ -4570,14 +4791,43 @@ var init_adhdev_daemon = __esm({
           const isProcessing = this.adapter?.isProcessing();
           const interval = isProcessing ? 2e3 : 15e3;
           this.statusTimer = setTimeout(() => {
-            this.sendUnifiedStatusReport();
+            this.sendUnifiedStatusReport().catch(() => {
+            });
             scheduleNext();
           }, interval);
         };
         scheduleNext();
       }
-      sendUnifiedStatusReport() {
+      async sendUnifiedStatusReport() {
         if (!this.bridge?.isConnected()) return;
+        if (this.cdpManagers.size > 0 && this.scriptLoaders.size > 0 && !this._cdpChatBusy) {
+          this._cdpChatBusy = true;
+          for (const [ideType, cdp] of this.cdpManagers) {
+            if (!cdp.isConnected) continue;
+            const loader = this.scriptLoaders.get(ideType);
+            if (!loader) continue;
+            const readChatScript = loader.get("read_chat");
+            if (!readChatScript) continue;
+            try {
+              const raw = await cdp.evaluate(readChatScript, 3e4);
+              if (raw && typeof raw === "object") {
+                let { activeModal } = raw;
+                if (activeModal) {
+                  const w = activeModal.width ?? Infinity;
+                  const h = activeModal.height ?? Infinity;
+                  if (w < 80 || h < 40) activeModal = void 0;
+                  else activeModal = {
+                    message: activeModal.message?.slice(0, 300) ?? "",
+                    buttons: (activeModal.buttons ?? []).filter((t) => t.length < 30)
+                  };
+                }
+                this._cachedActiveChatMap.set(ideType, { ...raw, activeModal });
+              }
+            } catch {
+            }
+          }
+          this._cdpChatBusy = false;
+        }
         const now = Date.now();
         const perExtData = this.localServer?.getPerExtensionData() || [];
         const extSummary = this.localServer?.getLatestExtensionData() || {
@@ -4587,12 +4837,13 @@ var init_adhdev_daemon = __esm({
           aiAgents: [],
           connectedIdes: []
         };
-        const cdpAgentStreams = this._cachedAgentStreams || [];
         const managedIdes = perExtData.map((ext) => {
-          const isMainCdpIde = ext.ideType.toLowerCase() === this.ideType.toLowerCase();
+          const ideKey = ext.ideType.toLowerCase();
+          const isMainCdpIde = this.cdpManagers.has(ideKey);
+          const cdpStreamsForIde = this._cachedAgentStreamsMap.get(ideKey) || [];
           const ideAgentStreams = [
             ...ext.agentStreams,
-            ...isMainCdpIde ? cdpAgentStreams : []
+            ...isMainCdpIde ? cdpStreamsForIde : []
           ];
           return {
             ideType: ext.ideType,
@@ -4602,10 +4853,10 @@ var init_adhdev_daemon = __esm({
             activeFile: ext.activeFile,
             terminals: ext.terminals,
             aiAgents: ext.aiAgents,
-            activeChat: ext.activeChat,
+            activeChat: isMainCdpIde && this._cachedActiveChatMap.has(ideKey) ? this._cachedActiveChatMap.get(ideKey) : ext.activeChat,
             chats: ext.chats,
             agentStreams: ideAgentStreams,
-            cdpConnected: isMainCdpIde ? this.cdpManager?.isConnected || false : false
+            cdpConnected: isMainCdpIde ? this.cdpManagers.get(ext.ideType.toLowerCase())?.isConnected || false : false
           };
         });
         const managedClis = [];
@@ -4673,8 +4924,12 @@ var init_adhdev_daemon = __esm({
           // 관리 중인 IDE/CLI (계층 데이터)
           managedIdes,
           managedClis,
-          // IDE 감지 결과 (설치된 IDE 목록)
-          detectedIdes: this.detectedIdes,
+          // IDE 감지 결과 (설치된 IDE 목록) — 프론트엔드 호환 매핑 (id→type)
+          detectedIdes: this.detectedIdes.map((ide) => ({
+            ...ide,
+            type: ide.id
+            // 프론트엔드 MachineDetail.tsx는 'type' 필드 사용
+          })),
           // P2P 상태
           p2p: {
             available: this.p2p?.isAvailable || false,
@@ -4682,8 +4937,8 @@ var init_adhdev_daemon = __esm({
             peers: this.p2p?.connectedPeerCount || 0,
             screenshotActive: this.p2p?.screenshotActive || false
           },
-          cdpConnected: this.cdpManager?.isConnected || false,
-          scriptLoaderReady: !!this.scriptLoader,
+          cdpConnected: this.getAnyCdp() !== null,
+          scriptLoaderReady: this.scriptLoaders.size > 0,
           timestamp: now,
           // ─── Legacy compat (서버 기존 로직용, 점진적 제거 예정) ───
           activeFile: extSummary.activeFile,
@@ -4703,7 +4958,7 @@ var init_adhdev_daemon = __esm({
               messages: c.activeChat?.messages || [],
               inputContent: ""
             })),
-            ...cdpAgentStreams
+            ...[...this._cachedAgentStreamsMap.values()].flat()
           ],
           connectedExtensions: extSummary.connectedIdes,
           system: {
@@ -4740,13 +4995,16 @@ var init_adhdev_daemon = __esm({
         if (this.cdpDiscoveryTimer) clearInterval(this.cdpDiscoveryTimer);
         if (this.screenshotTimer) clearInterval(this.screenshotTimer);
         if (this.agentStreamTimer) clearInterval(this.agentStreamTimer);
-        if (this.agentStreamManager && this.cdpManager) {
-          await this.agentStreamManager.dispose(this.cdpManager).catch(() => {
+        const anyCdpStop = this.getAnyCdp();
+        if (this.agentStreamManager && anyCdpStop) {
+          await this.agentStreamManager.dispose(anyCdpStop).catch(() => {
           });
         }
         this.p2p?.disconnect();
-        this.scriptLoader?.stop();
-        this.cdpManager?.disconnect();
+        for (const loader of this.scriptLoaders.values()) loader.stop();
+        this.scriptLoaders.clear();
+        for (const m of this.cdpManagers.values()) m.disconnect();
+        this.cdpManagers.clear();
         this.localServer?.stop();
         this.bridge?.disconnect();
         removeDaemonPid();
@@ -4754,6 +5012,33 @@ var init_adhdev_daemon = __esm({
         process.exit(0);
       }
       // ─── CDP 관리 ───────────────────────────────────
+      /** 첫 번째 연결된 CDP 매니저 반환 */
+      getAnyCdp() {
+        for (const m of this.cdpManagers.values()) {
+          if (m.isConnected) return m;
+        }
+        return null;
+      }
+      /** 특정 IDE의 CDP 매니저 반환 */
+      getCdpFor(ideType) {
+        return this.cdpManagers.get(ideType.toLowerCase()) || null;
+      }
+      /** Agent stream polling 시작 (idempotent — 이미 시작됐으면 무시) */
+      startAgentStreamPolling() {
+        if (this.agentStreamTimer) return;
+        this.agentStreamTimer = setInterval(async () => {
+          if (!this.agentStreamManager || this.cdpManagers.size === 0) return;
+          for (const [ideType, cdp] of this.cdpManagers) {
+            if (!cdp.isConnected) continue;
+            try {
+              await this.agentStreamManager.syncAgentSessions(cdp);
+              const streams = await this.agentStreamManager.collectAgentStreams(cdp);
+              this._cachedAgentStreamsMap.set(ideType, streams);
+            } catch {
+            }
+          }
+        }, 5e3);
+      }
       async initCdp() {
         const cdpPortMap = {
           cursor: 9333,
@@ -4763,7 +5048,7 @@ var init_adhdev_daemon = __esm({
         };
         const portsToTry = [];
         for (const ide of this.detectedIdes) {
-          const ideKey = ide.type || ide.name?.toLowerCase();
+          const ideKey = ide.id || ide.name?.toLowerCase();
           const port = cdpPortMap[ideKey];
           if (port) portsToTry.push({ port, ide: ideKey });
         }
@@ -4775,22 +5060,31 @@ var init_adhdev_daemon = __esm({
         for (const { port, ide } of portsToTry) {
           const manager = new DaemonCdpManager(port, (msg) => {
             console.log(import_chalk2.default.gray(msg));
-          });
+          }, true);
           const connected = await manager.connect();
           if (connected) {
-            this.cdpManager = manager;
-            this.ideType = ide;
-            console.log(import_chalk2.default.green(`  \u{1F50D} CDP connected: ${ide} (port ${port})`));
-            this.cdpDiscoveryTimer = setInterval(async () => {
-              if (this.cdpManager?.isConnected) {
-                await this.cdpManager.discoverAgentWebviews();
-              }
-            }, 3e4);
-            return;
+            const actualPort = manager.getPort();
+            const actualIde = Object.entries(cdpPortMap).find(([, p]) => p === actualPort)?.[0] || ide;
+            this.cdpManagers.set(actualIde, manager);
+            console.log(import_chalk2.default.green(`  \u{1F50D} CDP connected: ${actualIde} (port ${actualPort})`));
+            if (this.ideType === "unknown") {
+              this.ideType = actualIde;
+            }
           }
         }
-        console.log(import_chalk2.default.yellow(`  \u26A0 CDP not available \u2014 tried ports: ${portsToTry.map((p) => `${p.ide}:${p.port}`).join(", ")}`));
-        console.log(import_chalk2.default.yellow(`    IDE may need relaunch with --remote-debugging-port`));
+        if (this.cdpManagers.size > 0) {
+          console.log(import_chalk2.default.green(`  \u{1F4E1} CDP: ${this.cdpManagers.size} IDE(s) connected`));
+          this.cdpDiscoveryTimer = setInterval(async () => {
+            for (const m of this.cdpManagers.values()) {
+              if (m.isConnected) {
+                await m.discoverAgentWebviews();
+              }
+            }
+          }, 3e4);
+        } else {
+          console.log(import_chalk2.default.yellow(`  \u26A0 CDP not available \u2014 tried ports: ${portsToTry.map((p) => `${p.ide}:${p.port}`).join(", ")}`));
+          console.log(import_chalk2.default.yellow(`    IDE may need relaunch with --remote-debugging-port`));
+        }
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "adhdev",
-    "version": "0.1.21",
+    "version": "0.1.22",
     "description": "ADHDev CLI — Detect, install and configure your IDE + AI agent extensions",
     "main": "dist/index.js",
     "bin": {