adhdev 0.5.21 → 0.5.24

package/dist/cli/index.js

@@ -17958,6 +17958,60 @@ var require_dist = __commonJS({
           }, timeoutMs);
         });
       }
+      /**
+       * Evaluate inside the child frame of an attached session.
+       * Extension webviews have a nested iframe structure:
+       *   outer (vscode-webview://) → inner (extension React app)
+       * This method navigates into the inner frame using CDP Page.getFrameTree.
+       * Falls back to evaluateInSession if no child frame is found.
+       */
+      async evaluateInSessionFrame(sessionId, expression, timeoutMs = 15e3) {
+        const ws = this._browserConnected ? this.browserWs : this.ws;
+        if (!ws || ws.readyState !== import_ws2.default.OPEN) {
+          throw new Error("CDP not connected");
+        }
+        const sendViaSession = (method, params = {}) => {
+          return new Promise((resolve7, reject) => {
+            const pendingMap = this._browserConnected ? this.browserPending : this.pending;
+            const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
+            pendingMap.set(id, { resolve: resolve7, reject });
+            ws.send(JSON.stringify({ id, sessionId, method, params }));
+            setTimeout(() => {
+              if (pendingMap.has(id)) {
+                pendingMap.delete(id);
+                reject(new Error(`CDP session timeout: ${method}`));
+              }
+            }, timeoutMs);
+          });
+        };
+        try {
+          const { frameTree } = await sendViaSession("Page.getFrameTree");
+          const childFrame = frameTree?.childFrames?.[0]?.frame;
+          if (!childFrame) {
+            return this.evaluateInSession(sessionId, expression, timeoutMs);
+          }
+          const { executionContextId } = await sendViaSession("Page.createIsolatedWorld", {
+            frameId: childFrame.id,
+            worldName: "adhdev-agent-eval",
+            grantUniveralAccess: true
+          });
+          const result = await sendViaSession("Runtime.evaluate", {
+            expression,
+            returnByValue: true,
+            awaitPromise: true,
+            contextId: executionContextId
+          });
+          if (result?.result?.subtype === "error") {
+            throw new Error(result.result.description);
+          }
+          return result?.result?.value;
+        } catch (e) {
+          if (e.message?.includes("getFrameTree")) {
+            return this.evaluateInSession(sessionId, expression, timeoutMs);
+          }
+          throw e;
+        }
+      }
       async detachAgent(sessionId) {
         try {
           const sendFn = this._browserConnected ? this.sendBrowser.bind(this) : this.sendInternal.bind(this);
@@ -18102,7 +18156,7 @@ var require_dist = __commonJS({
           }
           let result;
           if (sessionId) {
-            result = await this.getCdp().evaluateInSession(sessionId, expression);
+            result = await this.getCdp().evaluateInSessionFrame(sessionId, expression);
           } else {
             result = await this.getCdp().evaluate(expression, 3e4);
           }
@@ -18163,7 +18217,7 @@ var require_dist = __commonJS({
         try {
           let raw;
           if (sessionId) {
-            raw = await this.getCdp().evaluateInSession(sessionId, expression);
+            raw = await this.getCdp().evaluateInSessionFrame(sessionId, expression);
           } else {
             raw = await this.getCdp().evaluate(expression, 15e3);
           }
@@ -18298,7 +18352,7 @@ var require_dist = __commonJS({
         try {
           let raw;
           if (sessionId) {
-            raw = await this.getCdp().evaluateInSession(sessionId, expression);
+            raw = await this.getCdp().evaluateInSessionFrame(sessionId, expression);
           } else {
             raw = await this.getCdp().evaluate(expression, 3e4);
           }
@@ -20520,7 +20574,7 @@ var require_dist = __commonJS({
           if (!targetSessionId) {
             return { success: false, error: `No active session found for ${agentType}` };
           }
-          result = await cdp.evaluateInSession(targetSessionId, scriptCode);
+          result = await cdp.evaluateInSessionFrame(targetSessionId, scriptCode);
         } else if (hasWebviewScript && cdp.evaluateInWebviewFrame) {
           const matchText = provider.webviewMatchText;
           const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
@@ -20754,7 +20808,7 @@ var require_dist = __commonJS({
             sessionId = this.getExtensionSessionId(provider);
           }
           if (!sessionId) return null;
-          const result2 = await cdp.evaluateInSession(sessionId, script, timeout);
+          const result2 = await cdp.evaluateInSessionFrame(sessionId, script, timeout);
           return { result: result2, category: "extension" };
         }
         const result = await cdp.evaluate(script, timeout);
@@ -20780,6 +20834,10 @@ var require_dist = __commonJS({
       /** Extract ideType from _targetInstance or explicit ideType */
       extractIdeType(args) {
         if (args?.ideType) {
+          const mappedKey = this._ctx.instanceIdMap?.get(args.ideType);
+          if (mappedKey) {
+            return mappedKey;
+          }
           if (this._ctx.cdpManagers.has(args.ideType)) {
             return args.ideType;
           }
@@ -25098,7 +25156,7 @@ ${installInfo}`
             results.push(agent.lastState);
           } else {
             try {
-              const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+              const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
               const state = await agent.adapter.readChat(evaluate);
               agent.lastState = state;
               agent.lastError = null;
@@ -25136,7 +25194,7 @@ ${installInfo}`
         const agent = this.managed.get(agentType);
         if (!agent) return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
           await agent.adapter.sendMessage(evaluate, text);
           return true;
         } catch (e) {
@@ -25149,7 +25207,7 @@ ${installInfo}`
         const agent = this.managed.get(agentType);
         if (!agent) return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
           return await agent.adapter.resolveAction(evaluate, action);
         } catch (e) {
           this.logFn(`[AgentStream] resolveAction(${agentType}) error: ${e.message}`);
@@ -25161,7 +25219,7 @@ ${installInfo}`
         const agent = this.managed.get(agentType);
         if (!agent) return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
           await agent.adapter.newSession(evaluate);
           return true;
         } catch (e) {
@@ -25179,7 +25237,7 @@ ${installInfo}`
         }
         if (!agent || typeof agent.adapter.listChats !== "function") return [];
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
           return await agent.adapter.listChats(evaluate);
         } catch (e) {
           this.logFn(`[AgentStream] listChats(${agentType}) error: ${e.message}`);
@@ -25196,7 +25254,7 @@ ${installInfo}`
         }
         if (!agent || typeof agent.adapter.switchSession !== "function") return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
           return await agent.adapter.switchSession(evaluate, sessionId);
         } catch (e) {
           this.logFn(`[AgentStream] switchSession(${agentType}) error: ${e.message}`);
@@ -25207,7 +25265,7 @@ ${installInfo}`
         const agent = this.managed.get(agentType);
         if (!agent || typeof agent.adapter.focusEditor !== "function") return false;
         try {
-          const evaluate = (expr, timeout) => cdp.evaluateInSession(agent.sessionId, expr, timeout);
+          const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
           await agent.adapter.focusEditor(evaluate);
           return true;
         } catch (e) {
@@ -28879,6 +28937,8 @@ var init_server_connection = __esm({
       pongTimeout = null;
       messageHandlers = /* @__PURE__ */ new Map();
       stateChangeCallbacks = [];
+      /** Fallback handler for message types without specific on() registration */
+      unhandledHandler = null;
       userPlan = "free";
       iceServers = null;
       planLimits = null;
@@ -28944,6 +29004,14 @@ var init_server_connection = __esm({
         }
         this.messageHandlers.get(type).push(handler);
       }
+      /**
+       * Register a fallback handler for unregistered message types.
+       * Used for command routing — all server→daemon commands that aren't
+       * explicitly registered (via on()) are forwarded to this handler.
+       */
+      onUnhandled(handler) {
+        this.unhandledHandler = handler;
+      }
       onStateChange(callback) {
         this.stateChangeCallbacks.push(callback);
       }
@@ -29011,6 +29079,8 @@ var init_server_connection = __esm({
           const handlers = this.messageHandlers.get(message.type);
           if (handlers) {
             handlers.forEach((h) => h(message));
+          } else if (this.unhandledHandler && message.type !== "auth_ok") {
+            this.unhandledHandler(message);
           } else if (message.type !== "auth_ok") {
             import_daemon_core.LOG.info("Server", `[ServerConn] Unhandled message type: ${message.type}`);
           }
@@ -29728,16 +29798,16 @@ ${e?.stack || ""}`);
         }
       }
       async handleInputEvent(peerId, msg) {
-        const { id, action, params } = msg;
+        const { id, action, params, instanceId } = msg;
         if (!this.inputHandler) {
           this.sendToPeer(peerId, { id, type: "response", success: false, error: "No input handler" });
           return;
         }
         try {
           const peer = this.peers.get(peerId);
-          const ideType = peer?.screenshotIdeType;
+          const ideType = instanceId || peer?.screenshotIdeType;
           if (!ideType) {
-            log(`[Input] WARNING: No screenshotIdeType for peer ${peerId} \u2014 input may route to wrong IDE`);
+            log(`[Input] WARNING: No instanceId or screenshotIdeType for peer ${peerId}`);
           }
           const result = await this.inputHandler({ action, params, ideType });
           this.sendToPeer(peerId, { id, type: "response", success: true, result });
@@ -30109,7 +30179,7 @@ var init_adhdev_daemon = __esm({
     path2 = __toESM(require("path"));
     crypto2 = __toESM(require("crypto"));
     import_chalk = __toESM(require("chalk"));
-    pkgVersion = "0.5.21";
+    pkgVersion = "0.5.24";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [
@@ -30193,7 +30263,18 @@ var init_adhdev_daemon = __esm({
             if (this.ideType === "unknown") this.ideType = ideType;
           },
           onStreamsUpdated: (ideType, streams) => {
-            this.statusReporter?.updateAgentStreams(ideType, streams);
+            const ideInstance = this.components?.instanceManager?.getInstance(`ide:${ideType}`);
+            if (ideInstance?.onEvent) {
+              for (const stream of streams) {
+                ideInstance.onEvent("stream_update", {
+                  extensionType: stream.agentType,
+                  streams: [stream],
+                  messages: stream.messages || [],
+                  status: stream.status || "idle",
+                  activeModal: stream.activeModal || null
+                });
+              }
+            }
           }
         });
         const versionArchive = new import_daemon_core4.VersionArchive();
@@ -30366,76 +30447,9 @@ var init_adhdev_daemon = __esm({
             if (this.p2p) this.p2p.handleSignaling(sigType, msg.payload);
           });
         }
-        const directCdpCommands = [
-          "read_chat",
-          "send_chat",
-          "list_chats",
-          "new_chat",
-          "switch_chat",
-          "set_mode",
-          "change_model",
-          "set_thought_level",
-          "screenshot",
-          "cdp_eval",
-          "cdp_screenshot",
-          "cdp_command_exec",
-          "cdp_batch",
-          "cdp_remote_action",
-          "cdp_discover_agents",
-          "file_read",
-          "file_write",
-          "file_list",
-          "file_list_browse",
-          "terminal_exec",
-          "refresh_scripts",
-          // CLI/daemon-local commands (launch, restart, detect, stop)
-          "launch_ide",
-          "stop_ide",
-          "restart_ide",
-          "detect_ides",
-          "restart_session",
-          "exec_command",
-          "launch_cli",
-          "stop_cli",
-          // 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",
-          "get_cli_history",
-          "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",
-          // PTY I/O commands (terminal view)
-          "pty_input",
-          "pty_resize",
-          // Extension model/mode control
-          "list_extension_models",
-          "set_extension_model",
-          "list_extension_modes",
-          "set_extension_mode"
-        ];
-        for (const cmdType of directCdpCommands) {
-          this.serverConn.on(cmdType, async (msg) => {
-            await this.handleCommand(msg, cmdType, msg.payload);
-          });
-        }
+        this.serverConn.onUnhandled(async (msg) => {
+          await this.handleCommand(msg, msg.type, msg.payload);
+        });
       }
       async handleCommand(msg, cmd, args) {
         import_daemon_core4.LOG.info("Command", `${cmd}${args?._targetInstance ? ` \u2192 ${args._targetType}:${args._targetInstance.split("_")[0]}` : ""}`);
@@ -30552,10 +30566,20 @@ var init_adhdev_daemon = __esm({
         }
       }
       // ─── CDP helpers ─────────────────────────────
-      /** Return CDP manager for specific IDE (exact match first, then prefix match for multi-window keys) */
+      /** Return CDP manager for specific IDE.
+       *  Lookup order:
+       *  1. instanceIdMap (UUID → managerKey) — for multi-window UUID instance IDs
+       *  2. Exact match on cdpManagers (key = "cursor", "antigravity")
+       *  3. Prefix match (multi-window: "antigravity_WorkspaceName")
+       */
       getCdpFor(ideType) {
         if (!this.components) return null;
         const key = ideType.toLowerCase();
+        const mappedKey = this.components.instanceIdMap.get(ideType) || this.components.instanceIdMap.get(key);
+        if (mappedKey) {
+          const mapped = this.components.cdpManagers.get(mappedKey);
+          if (mapped?.isConnected) return mapped;
+        }
         const exact = this.components.cdpManagers.get(key);
         if (exact) return exact;
         for (const [k, m] of this.components.cdpManagers.entries()) {
@@ -31152,6 +31176,38 @@ function registerSetupCommands(program2, providerLoader) {
       console.log(import_chalk3.default.gray("  Run `adhdev setup` to reconfigure.\n"));
     }
   });
+  program2.command("logout").description("Log out from ADHDev (clear auth credentials, keep config)").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+    const { loadConfig: loadConfig3, saveConfig: saveConfig2 } = await Promise.resolve().then(() => __toESM(require_dist()));
+    if (!options.force) {
+      const inquirer2 = await import("inquirer");
+      const { confirm } = await inquirer2.default.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Log out from ADHDev? This will clear your auth token and disconnect the daemon.",
+          default: false
+        }
+      ]);
+      if (!confirm) return;
+    }
+    try {
+      const { isDaemonRunning: isDaemonRunning2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
+      if (isDaemonRunning2()) {
+        console.log(import_chalk3.default.gray("  Stopping daemon..."));
+        stopDaemon2();
+      }
+    } catch {
+    }
+    const config2 = loadConfig3();
+    config2.apiToken = null;
+    config2.connectionToken = null;
+    config2.userEmail = null;
+    config2.userName = null;
+    saveConfig2(config2);
+    console.log(import_chalk3.default.green("\n\u2713 Logged out successfully."));
+    console.log(import_chalk3.default.gray("  Auth credentials cleared. IDE and workspace settings preserved."));
+    console.log(import_chalk3.default.gray("  Run `adhdev setup` to log in again.\n"));
+  });
 }
 
 // src/cli/daemon-commands.ts