adhdev 0.5.19 → 0.5.21

package/dist/index.js

@@ -16721,10 +16721,15 @@ var require_dist = __commonJS({
       ProviderLoader: () => ProviderLoader,
       VersionArchive: () => VersionArchive2,
       addCliHistory: () => addCliHistory,
+      buildAllManagedEntries: () => buildAllManagedEntries,
+      buildManagedAcps: () => buildManagedAcps,
+      buildManagedClis: () => buildManagedClis,
+      buildManagedIdes: () => buildManagedIdes,
       connectCdpManager: () => connectCdpManager,
       detectAllVersions: () => detectAllVersions2,
       detectCLIs: () => detectCLIs,
       detectIDEs: () => detectIDEs,
+      findCdpManager: () => findCdpManager,
       getAIExtensions: () => getAIExtensions,
       getAvailableIdeIds: () => getAvailableIdeIds,
       getHostMemorySnapshot: () => getHostMemorySnapshot,
@@ -16733,9 +16738,11 @@ var require_dist = __commonJS({
       getRecentLogs: () => getRecentLogs,
       getWorkspaceActivity: () => getWorkspaceActivity,
       getWorkspaceState: () => getWorkspaceState,
+      hasCdpManager: () => hasCdpManager,
       initDaemonComponents: () => initDaemonComponents2,
       installExtensions: () => installExtensions,
       installGlobalInterceptor: () => installGlobalInterceptor,
+      isCdpConnected: () => isCdpConnected,
       isExtensionInstalled: () => isExtensionInstalled,
       isIdeRunning: () => isIdeRunning,
       isSetupComplete: () => isSetupComplete2,
@@ -19276,6 +19283,117 @@ var require_dist = __commonJS({
         }
       }
     };
+    function findCdpManager(cdpManagers, key) {
+      const exact = cdpManagers.get(key);
+      if (exact) return exact;
+      const prefix = key + "_";
+      for (const [k, m] of cdpManagers.entries()) {
+        if (k.startsWith(prefix) && m.isConnected) return m;
+      }
+      return null;
+    }
+    function hasCdpManager(cdpManagers, key) {
+      if (cdpManagers.has(key)) return true;
+      const prefix = key + "_";
+      for (const k of cdpManagers.keys()) {
+        if (k.startsWith(prefix)) return true;
+      }
+      return false;
+    }
+    function isCdpConnected(cdpManagers, key) {
+      const m = findCdpManager(cdpManagers, key);
+      return m?.isConnected ?? false;
+    }
+    function buildManagedIdes(ideStates, cdpManagers, opts) {
+      const result = [];
+      for (const state of ideStates) {
+        const cdpConnected = state.cdpConnected ?? isCdpConnected(cdpManagers, state.type);
+        result.push({
+          ideType: state.type,
+          ideVersion: "",
+          instanceId: state.instanceId || state.type,
+          workspace: state.workspace || null,
+          terminals: 0,
+          aiAgents: [],
+          activeChat: state.activeChat,
+          chats: [],
+          agentStreams: state.extensions.map((ext) => ({
+            agentType: ext.type,
+            agentName: ext.name,
+            extensionId: ext.type,
+            status: ext.status || "idle",
+            messages: ext.activeChat?.messages || [],
+            inputContent: ext.activeChat?.inputContent || "",
+            activeModal: ext.activeChat?.activeModal || null
+          })),
+          cdpConnected,
+          currentModel: state.currentModel,
+          currentPlan: state.currentPlan,
+          currentAutoApprove: state.currentAutoApprove
+        });
+      }
+      if (opts?.detectedIdes) {
+        const coveredTypes = new Set(ideStates.map((s) => s.type));
+        for (const ide of opts.detectedIdes) {
+          if (!ide.installed || coveredTypes.has(ide.id)) continue;
+          if (!isCdpConnected(cdpManagers, ide.id)) continue;
+          result.push({
+            ideType: ide.id,
+            ideVersion: "",
+            instanceId: ide.id,
+            workspace: null,
+            terminals: 0,
+            aiAgents: [],
+            activeChat: null,
+            chats: [],
+            agentStreams: [],
+            cdpConnected: true,
+            currentModel: void 0,
+            currentPlan: void 0
+          });
+        }
+      }
+      return result;
+    }
+    function buildManagedClis(cliStates) {
+      return cliStates.map((s) => ({
+        id: s.instanceId,
+        instanceId: s.instanceId,
+        cliType: s.type,
+        cliName: s.name,
+        status: s.status,
+        mode: s.mode,
+        workspace: s.workspace || "",
+        activeChat: s.activeChat
+      }));
+    }
+    function buildManagedAcps(acpStates) {
+      return acpStates.map((s) => ({
+        id: s.instanceId,
+        acpType: s.type,
+        acpName: s.name,
+        status: s.status,
+        mode: "chat",
+        workspace: s.workspace || "",
+        activeChat: s.activeChat,
+        currentModel: s.currentModel,
+        currentPlan: s.currentPlan,
+        acpConfigOptions: s.acpConfigOptions,
+        acpModes: s.acpModes,
+        errorMessage: s.errorMessage,
+        errorReason: s.errorReason
+      }));
+    }
+    function buildAllManagedEntries(allStates, cdpManagers, opts) {
+      const ideStates = allStates.filter((s) => s.category === "ide");
+      const cliStates = allStates.filter((s) => s.category === "cli");
+      const acpStates = allStates.filter((s) => s.category === "acp");
+      return {
+        managedIdes: buildManagedIdes(ideStates, cdpManagers, opts),
+        managedClis: buildManagedClis(cliStates),
+        managedAcps: buildManagedAcps(acpStates)
+      };
+    }
     init_config();
     async function handleChatHistory(h, args) {
       const { agentType, offset, limit, instanceId } = args;
@@ -20581,12 +20699,14 @@ var require_dist = __commonJS({
       get currentProviderType() {
         return this._currentProviderType;
       }
-      /** Get CDP manager for a specific ideType.
+      /** Get CDP manager for a specific ideType or managerKey.
+       * Supports exact match, multi-window prefix match, and instanceIdMap UUID lookup.
        * Returns null if no match — never falls back to another IDE. */
       getCdp(ideType) {
         const key = ideType || this._currentIdeType;
         if (!key) return null;
-        const m = this._ctx.cdpManagers.get(key.toLowerCase());
+        const resolved = this._ctx.instanceIdMap?.get(key) || key;
+        const m = findCdpManager(this._ctx.cdpManagers, resolved.toLowerCase());
         if (m?.isConnected) return m;
         return null;
       }
@@ -20657,10 +20777,18 @@ var require_dist = __commonJS({
         const managed = this._agentStream.getManagedAgent(provider.type);
         return managed?.sessionId || null;
       }
-      /** Extract ideType from _targetInstance */
+      /** Extract ideType from _targetInstance or explicit ideType */
       extractIdeType(args) {
-        if (args?.ideType && this._ctx.cdpManagers.has(args.ideType)) {
-          return args.ideType;
+        if (args?.ideType) {
+          if (this._ctx.cdpManagers.has(args.ideType)) {
+            return args.ideType;
+          }
+          const found = findCdpManager(this._ctx.cdpManagers, args.ideType);
+          if (found) {
+            for (const [k, m] of this._ctx.cdpManagers.entries()) {
+              if (m === found) return k;
+            }
+          }
         }
         if (args?._targetInstance) {
           let raw = args._targetInstance;
@@ -20676,9 +20804,10 @@ var require_dist = __commonJS({
           if (this._ctx.cdpManagers.has(raw)) {
             return raw;
           }
-          if (!ideMatch && !cliMatch && !acpMatch) {
-            for (const [key, mgr] of this._ctx.cdpManagers.entries()) {
-              if (mgr.isConnected) return key;
+          const found = findCdpManager(this._ctx.cdpManagers, raw);
+          if (found) {
+            for (const [k, m] of this._ctx.cdpManagers.entries()) {
+              if (m === found) return k;
             }
           }
           const lastUnderscore = raw.lastIndexOf("_");
@@ -22398,9 +22527,11 @@ var require_dist = __commonJS({
             LOG5.info("Upgrade", "Remote upgrade requested from dashboard");
             try {
               const { execSync: execSync7 } = await import("child_process");
-              const latest = execSync7("npm view adhdev version", { encoding: "utf-8", timeout: 1e4 }).trim();
-              LOG5.info("Upgrade", `Latest available: v${latest}`);
-              execSync7("npm install -g adhdev@latest", {
+              const isStandalone = this.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
+              const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
+              const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              LOG5.info("Upgrade", `Latest ${pkgName}: v${latest}`);
+              execSync7(`npm install -g ${pkgName}@latest`, {
                 encoding: "utf-8",
                 timeout: 6e4,
                 stdio: ["pipe", "pipe", "pipe"]
@@ -22408,8 +22539,15 @@ var require_dist = __commonJS({
               LOG5.info("Upgrade", `\u2705 Upgraded to v${latest}`);
               setTimeout(() => {
                 LOG5.info("Upgrade", "Restarting daemon with new version...");
+                try {
+                  const path13 = require("path");
+                  const fs10 = require("fs");
+                  const pidFile = path13.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
+                  if (fs10.existsSync(pidFile)) fs10.unlinkSync(pidFile);
+                } catch {
+                }
                 const { spawn: spawn3 } = require("child_process");
-                const child = spawn3(process.execPath, [process.argv[1], "daemon", "-p", "19222"], {
+                const child = spawn3(process.execPath, process.argv.slice(1), {
                   detached: true,
                   stdio: "ignore",
                   env: { ...process.env }
@@ -22615,54 +22753,10 @@ var require_dist = __commonJS({
             LOG5.info("StatusReport", summary);
           }
         }
-        const managedIdes = ideStates.map((s) => ({
-          ideType: s.type,
-          ideVersion: "",
-          instanceId: s.instanceId,
-          workspace: s.workspace || null,
-          terminals: 0,
-          aiAgents: [],
-          activeChat: s.activeChat,
-          chats: [],
-          agentStreams: s.extensions.map((ext) => ({
-            agentType: ext.type,
-            agentName: ext.name,
-            extensionId: ext.type,
-            status: ext.status || "idle",
-            messages: ext.activeChat?.messages || [],
-            inputContent: ext.activeChat?.inputContent || "",
-            activeModal: ext.activeChat?.activeModal || null
-          })),
-          cdpConnected: s.cdpConnected,
-          currentModel: s.currentModel,
-          currentPlan: s.currentPlan,
-          currentAutoApprove: s.currentAutoApprove
-        }));
-        const managedClis = cliStates.map((s) => ({
-          id: s.instanceId,
-          instanceId: s.instanceId,
-          cliType: s.type,
-          cliName: s.name,
-          status: s.status,
-          mode: s.mode,
-          workspace: s.workspace || "",
-          activeChat: s.activeChat
-        }));
-        const managedAcps = acpStates.map((s) => ({
-          id: s.instanceId,
-          acpType: s.type,
-          acpName: s.name,
-          status: s.status,
-          mode: s.mode,
-          workspace: s.workspace || "",
-          activeChat: s.activeChat,
-          currentModel: s.currentModel,
-          currentPlan: s.currentPlan,
-          acpConfigOptions: s.acpConfigOptions,
-          acpModes: s.acpModes,
-          errorMessage: s.errorMessage,
-          errorReason: s.errorReason
-        }));
+        const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+          allStates,
+          this.deps.cdpManagers
+        );
         const cfg = loadConfig3();
         const wsState = getWorkspaceState(cfg);
         const memSnap = getHostMemorySnapshot();
@@ -22709,37 +22803,34 @@ var require_dist = __commonJS({
           LOG5.debug("P2P", `sent (${JSON.stringify(payload).length} bytes)`);
         }
         if (opts?.p2pOnly) return;
-        const plan = serverConn.getUserPlan();
-        if (plan !== "free") {
-          const wsPayload = {
-            daemonMode: true,
-            machineNickname: payload.machineNickname,
-            defaultWorkspaceId: wsState.defaultWorkspaceId,
-            workspaceCount: (wsState.workspaces || []).length,
-            // managedIdes: server only saves id, type, cdpConnected
-            managedIdes: managedIdes.map((ide) => ({
-              ideType: ide.ideType,
-              instanceId: ide.instanceId,
-              cdpConnected: ide.cdpConnected
-            })),
-            // managedClis: server only saves id, type, name
-            managedClis: managedClis.map((c) => ({
-              id: c.id,
-              cliType: c.cliType,
-              cliName: c.cliName
-            })),
-            // managedAcps: server only saves id, type, name
-            managedAcps: managedAcps?.map((a) => ({
-              id: a.id,
-              acpType: a.acpType,
-              acpName: a.acpName
-            })),
-            p2p: payload.p2p,
-            timestamp: now
-          };
-          serverConn.sendMessage("status_report", wsPayload);
-          LOG5.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
-        }
+        const wsPayload = {
+          daemonMode: true,
+          machineNickname: payload.machineNickname,
+          defaultWorkspaceId: wsState.defaultWorkspaceId,
+          workspaceCount: (wsState.workspaces || []).length,
+          // managedIdes: server only saves id, type, cdpConnected
+          managedIdes: managedIdes.map((ide) => ({
+            ideType: ide.ideType,
+            instanceId: ide.instanceId,
+            cdpConnected: ide.cdpConnected
+          })),
+          // managedClis: server only saves id, type, name
+          managedClis: managedClis.map((c) => ({
+            id: c.id,
+            cliType: c.cliType,
+            cliName: c.cliName
+          })),
+          // managedAcps: server only saves id, type, name
+          managedAcps: managedAcps?.map((a) => ({
+            id: a.id,
+            acpType: a.acpType,
+            acpName: a.acpName
+          })),
+          p2p: payload.p2p,
+          timestamp: now
+        };
+        serverConn.sendMessage("status_report", wsPayload);
+        LOG5.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
       }
       // ─── P2P ─────────────────────────────────────────
       sendP2PPayload(payload) {
@@ -26184,7 +26275,10 @@ async (params) => {
           this.json(res, 400, { error: "expression required" });
           return;
         }
-        const cdp = ideType ? this.cdpManagers.get(ideType) : this.getAnyCdp();
+        const cdp = this.getCdp(ideType);
+        if (!cdp && !ideType) {
+          LOG5.warn("DevServer", "CDP evaluate without ideType \u2014 picked first connected manager");
+        }
         if (!cdp?.isConnected) {
           this.json(res, 503, { error: "No CDP connection available" });
           return;
@@ -26424,7 +26518,7 @@ async (params) => {
             this.sendSSE({ type: "watch_error", error: `Script '${this.watchScriptName}' not found` });
             return;
           }
-          const cdp = this.getAnyCdp();
+          const cdp = this.getCdp();
           if (!cdp) {
             this.sendSSE({ type: "watch_error", error: "No CDP connection" });
             return;
@@ -28177,20 +28271,24 @@ data: ${JSON.stringify(msg.data)}
           }
         }
       }
-      /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise */
+      /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise.
+       *  DevServer is a debugging tool so first-connected fallback is acceptable,
+       *  but callers should pass ideType when possible. */
       getCdp(ideType) {
         if (ideType) {
           const cdp = this.cdpManagers.get(ideType);
           if (cdp?.isConnected) return cdp;
+          for (const [k, m] of this.cdpManagers.entries()) {
+            if (k.startsWith(ideType + "_") && m.isConnected) return m;
+          }
+          LOG5.warn("DevServer", `getCdp: no manager found for ideType '${ideType}', available: [${[...this.cdpManagers.keys()].join(", ")}]`);
+          return null;
         }
         for (const cdp of this.cdpManagers.values()) {
           if (cdp.isConnected) return cdp;
         }
         return null;
       }
-      getAnyCdp() {
-        return this.getCdp();
-      }
       json(res, status, data) {
         res.writeHead(status, { "Content-Type": "application/json" });
         res.end(JSON.stringify(data, null, 2));
@@ -28930,6 +29028,28 @@ var init_server_connection = __esm({
           this.setState("disconnected");
           return;
         }
+        if (code === 4012) {
+          import_daemon_core.LOG.info("Server", `[ServerConn] \u26A0 Force disconnected by user from dashboard.`);
+          import_daemon_core.LOG.info("Server", `[ServerConn] Run 'adhdev daemon' to reconnect.`);
+          this.setState("disconnected");
+          return;
+        }
+        if (code === 4013) {
+          import_daemon_core.LOG.info("Server", `[ServerConn] \u26A0 Connection token was revoked.`);
+          import_daemon_core.LOG.info("Server", `[ServerConn] Run 'adhdev setup' to re-authenticate.`);
+          this.setState("disconnected");
+          try {
+            const path3 = require("path");
+            const fs3 = require("fs");
+            const configPath = path3.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "config.json");
+            if (fs3.existsSync(configPath)) {
+              fs3.unlinkSync(configPath);
+              import_daemon_core.LOG.info("Server", `[ServerConn] Config file removed. Re-run 'adhdev setup'.`);
+            }
+          } catch {
+          }
+          return;
+        }
         if (code !== 1e3 && this.reconnectAttempts < 50) {
           this.setState("disconnected");
           this.scheduleReconnect();
@@ -29415,11 +29535,15 @@ ${e?.stack || ""}`);
           if (parsed.type === "pong") return;
           if (parsed.type === "screenshot_start") {
             const peer = this.peers.get(peerId);
+            if (!parsed.ideType) {
+              log(`screenshot_start: REJECTED \u2014 no ideType from peer ${peerId}`);
+              return;
+            }
             if (peer) {
               peer.screenshotActive = true;
-              peer.screenshotIdeType = parsed.ideType || void 0;
+              peer.screenshotIdeType = parsed.ideType;
               peer.needsFirstFrame = true;
-              log(`screenshot_start: peer=${peerId}, ideType=${parsed.ideType || "any"}, channelOpen=${!!peer.screenshotChannel}, state=${peer.state}`);
+              log(`screenshot_start: peer=${peerId}, ideType=${parsed.ideType}, channelOpen=${!!peer.screenshotChannel}, state=${peer.state}`);
             } else {
               log(`screenshot_start: peer ${peerId} NOT FOUND in peers map!`);
             }
@@ -29612,7 +29736,10 @@ ${e?.stack || ""}`);
         try {
           const peer = this.peers.get(peerId);
           const ideType = peer?.screenshotIdeType;
-          const result = await this.inputHandler({ action, params, _targetInstance: ideType ? `${ideType}_` : void 0 });
+          if (!ideType) {
+            log(`[Input] WARNING: No screenshotIdeType for peer ${peerId} \u2014 input may route to wrong IDE`);
+          }
+          const result = await this.inputHandler({ action, params, ideType });
           this.sendToPeer(peerId, { id, type: "response", success: true, result });
         } catch (e) {
           this.sendToPeer(peerId, { id, type: "response", success: false, error: e?.message });
@@ -29830,7 +29957,11 @@ var init_screenshot_controller = __esm({
         if (!this.deps.isRunning()) return;
         const active = this.deps.isScreenshotActive();
         const ssIdeType = this.deps.getScreenshotIdeType();
-        const cdp = this.deps.getCdp(ssIdeType);
+        if (active && !ssIdeType) {
+          this.timer = setTimeout(() => this.tick(), 500);
+          return;
+        }
+        const cdp = ssIdeType ? this.deps.getCdp(ssIdeType) : null;
         const isRelay = this.deps.isUsingRelay();
         const profile = isRelay ? this.profileRelay : this.profileDirect;
         this.checkBudgetReset();
@@ -29978,7 +30109,7 @@ var init_adhdev_daemon = __esm({
     path2 = __toESM(require("path"));
     crypto2 = __toESM(require("crypto"));
     import_chalk = __toESM(require("chalk"));
-    pkgVersion = "0.5.19";
+    pkgVersion = "0.5.21";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [
@@ -30148,7 +30279,11 @@ var init_adhdev_daemon = __esm({
             getScreenshotIdeType: () => this.p2p?.screenshotIdeType,
             isUsingRelay: () => this.p2p?.isUsingRelay ?? false,
             hasAnyNeedingFirstFrame: () => this.p2p?.hasAnyNeedingFirstFrame() ?? false,
-            getCdp: (ideType) => (ideType ? this.getCdpFor(ideType) : null) || this.getAnyCdp(),
+            getCdp: (ideType) => {
+              if (ideType) return this.getCdpFor(ideType);
+              import_daemon_core4.LOG.warn("P2P", "Screenshot requested without ideType \u2014 cannot determine target IDE. Skipping frame.");
+              return null;
+            },
             sendScreenshotBuffer: (buf) => this.p2p.sendScreenshotBuffer(buf)
           }, planLimits ?? void 0);
           this.screenshotController.start();
@@ -30417,14 +30552,6 @@ var init_adhdev_daemon = __esm({
         }
       }
       // ─── CDP helpers ─────────────────────────────
-      /** Return first connected CDP manager */
-      getAnyCdp() {
-        if (!this.components) return null;
-        for (const m of this.components.cdpManagers.values()) {
-          if (m.isConnected) return m;
-        }
-        return null;
-      }
       /** Return CDP manager for specific IDE (exact match first, then prefix match for multi-window keys) */
       getCdpFor(ideType) {
         if (!this.components) return null;