@cydm/pie 2.2.0 → 2.4.0

package/dist/builtin/extensions/mcp-adapter/index.js

@@ -544,6 +544,7 @@ function normalizeEntry(name, raw, sourcePath, sourceScope, homeDir) {
   const hasStdio = typeof raw.command === "string" && raw.command.length > 0;
   const hasHttp = typeof raw.url === "string" && raw.url.length > 0;
   if (!hasStdio && !hasHttp) return null;
+  const directTools = normalizeDirectTools(raw.directTools);
   return {
     name,
     command: hasStdio ? expandHome(raw.command, homeDir) : void 0,
@@ -554,8 +555,8 @@ function normalizeEntry(name, raw, sourcePath, sourceScope, homeDir) {
     headers: asStringRecord(raw.headers),
     inheritEnv: raw.inheritEnv !== false,
     connectTimeoutMs: typeof raw.connectTimeoutMs === "number" && Number.isFinite(raw.connectTimeoutMs) && raw.connectTimeoutMs > 0 ? raw.connectTimeoutMs : void 0,
-    directTools: normalizeDirectTools(raw.directTools).mode,
-    directToolsWhitelist: normalizeDirectTools(raw.directTools).whitelist,
+    directTools: directTools.mode,
+    directToolsWhitelist: directTools.whitelist,
     disabled: raw.disabled === true,
     sourcePath,
     sourceScope
@@ -615,8 +616,8 @@ function resolveMcpAdapterConfig(cwd, configDir, homeDir = os.homedir()) {
         continue;
       }
       const existing = merged.get(name);
-      if (existing && raw.disabled === true) {
-        merged.set(name, { ...existing, disabled: true });
+      if (existing && (raw.disabled === true || raw.disabled === false)) {
+        merged.set(name, { ...existing, disabled: raw.disabled });
       }
     }
   }
@@ -24438,6 +24439,7 @@ import * as path2 from "node:path";
 var CONNECT_TIMEOUT_MS = 3e4;
 var PACKAGE_MANAGER_CONNECT_TIMEOUT_MS = 12e4;
 var PACKAGE_MANAGER_COMMANDS = /* @__PURE__ */ new Set(["npx", "npm", "bunx", "uvx", "uv", "pnpm", "pnpmx"]);
+var METADATA_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var CALL_TIMEOUT_MS = 12e4;
 var STDERR_TAIL_LIMIT = 4e3;
 function connectTimeoutFor(definition) {
@@ -24445,6 +24447,17 @@ function connectTimeoutFor(definition) {
   const base = path2.basename(definition.command ?? "");
   return PACKAGE_MANAGER_COMMANDS.has(base) ? PACKAGE_MANAGER_CONNECT_TIMEOUT_MS : CONNECT_TIMEOUT_MS;
 }
+function unpinnedWarnings(definitions) {
+  const commandPattern = new RegExp(`(^|\\s)(?:${[...PACKAGE_MANAGER_COMMANDS].join("|")})\\s`);
+  const warnings = [];
+  for (const definition of definitions) {
+    const spec = [definition.command ?? "", ...definition.args].join(" ");
+    if (commandPattern.test(spec) && /@latest\b/.test(spec)) {
+      warnings.push(`${definition.name}: unpinned "@latest" fetch \u2014 pin an exact version (e.g. pkg@1.2.3).`);
+    }
+  }
+  return warnings;
+}
 function appendTail(tail, chunk) {
   return (tail + String(chunk)).slice(-STDERR_TAIL_LIMIT);
 }
@@ -24487,15 +24500,8 @@ function withTimeout(promise, timeoutMs, label, signal) {
   });
 }
 var McpServerManager = class {
-  runtimes = /* @__PURE__ */ new Map();
-  definitions;
-  cachePath;
-  log;
-  /** Set by dispose(); after it, no new connects and no late attach. */
-  disposed = false;
-  /** Prefixed names claimed by more than one server in the last loadCatalog(); callTool fail-closes on them. */
-  conflictedNames = /* @__PURE__ */ new Set();
-  constructor(definitions, cachePath, log) {
+  constructor(definitions, cacheDir, log, now = Date.now) {
+    this.now = now;
     this.definitions = new Map(definitions.map((definition) => [sanitizeName(definition.name), definition]));
     if (this.definitions.size !== definitions.length) {
       const counts = /* @__PURE__ */ new Map();
@@ -24510,12 +24516,43 @@ var McpServerManager = class {
         );
       }
     }
-    this.cachePath = cachePath;
+    this.cacheDir = cacheDir;
     this.log = log;
   }
+  now;
+  runtimes = /* @__PURE__ */ new Map();
+  definitions;
+  // Cache directory holding one <server>.json shard per connected server. A
+  // legacy pre-sharding single file (<configDir>/mcp-metadata.json) is
+  // deliberately ignored — the cache is disposable and shards rebuild on the
+  // next connect.
+  cacheDir;
+  log;
+  /** Set by dispose(); after it, no new connects and no late attach. */
+  disposed = false;
+  /** Prefixed names claimed by more than one server in the last loadCatalog(); callTool fail-closes on them. */
+  conflictedNames = /* @__PURE__ */ new Set();
   getDefinition(server) {
     return this.definitions.get(sanitizeName(server));
   }
+  /**
+   * Resolve a `<server>_<tool>` prefixed name against CONFIGURED server names.
+   * Splitting at the first underscore breaks servers whose own name contains
+   * underscores (`my_server_echo` would resolve to server "my"), so match the
+   * longest configured server name that prefixes the tool name instead. When
+   * several configured names prefix (e.g. servers `my` and `my_server` both
+   * exist), the longest match wins: that is how toPrefixedName() would have
+   * constructed the deepest claim, and it is deterministic.
+   */
+  resolvePrefixedName(prefixedName) {
+    let best = null;
+    for (const key of this.definitions.keys()) {
+      if (!prefixedName.startsWith(`${key}_`)) continue;
+      if (best !== null && key.length <= best.server.length) continue;
+      best = { server: key, tool: prefixedName.slice(key.length + 1) };
+    }
+    return best;
+  }
   listDefinitions() {
     return [...this.definitions.values()];
   }
@@ -24614,13 +24651,11 @@ var McpServerManager = class {
       }
       seen.add(tool.prefixedName);
     }
-    for (const [otherKey, otherRuntime] of this.runtimes) {
+    for (const otherRuntime of this.runtimes.values()) {
       if (otherRuntime === runtime || !otherRuntime.tools) continue;
       for (const otherTool of otherRuntime.tools) {
         if (seen.has(otherTool.prefixedName)) {
-          throw new Error(
-            `tool name collision between "${runtime.definition.name}" and "${otherKey}": ${otherTool.prefixedName}`
-          );
+          this.log(`mcp: tool name "${otherTool.prefixedName}" is claimed by more than one server \u2014 disabled until the servers are renamed (fail-closed)`);
         }
       }
     }
@@ -24629,23 +24664,45 @@ var McpServerManager = class {
   }
   persistMetadata() {
     try {
-      const snapshot = { ...this.readCacheFile() };
+      fs2.mkdirSync(this.cacheDir, { recursive: true });
       for (const [key, runtime] of this.runtimes) {
-        if (runtime.tools) snapshot[key] = runtime.tools;
-      }
-      fs2.mkdirSync(path2.dirname(this.cachePath), { recursive: true });
-      const tempPath = `${this.cachePath}.${process.pid}.tmp`;
-      fs2.writeFileSync(tempPath, JSON.stringify({ updatedAt: Date.now(), tools: snapshot }, null, 2), "utf8");
-      try {
-        fs2.renameSync(tempPath, this.cachePath);
-      } catch (error2) {
-        fs2.unlinkSync(tempPath);
-        throw error2;
+        if (!runtime.tools) continue;
+        const shardPath = path2.join(this.cacheDir, `${key}.json`);
+        const tempPath = `${shardPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+        fs2.writeFileSync(tempPath, JSON.stringify({ updatedAt: this.now(), tools: runtime.tools }, null, 2), "utf8");
+        try {
+          fs2.renameSync(tempPath, shardPath);
+        } catch (error2) {
+          fs2.unlinkSync(tempPath);
+          throw error2;
+        }
       }
+      this.deleteExpiredShards();
     } catch (error2) {
       this.log(`mcp: metadata cache write failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
+  /** Delete shard files older than METADATA_TTL_MS (stale entries of offline servers age out). */
+  deleteExpiredShards() {
+    let names;
+    try {
+      names = fs2.readdirSync(this.cacheDir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      const filePath = path2.join(this.cacheDir, name);
+      try {
+        const mtimeMs = fs2.statSync(filePath).mtimeMs;
+        const parsed = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+        if (typeof parsed.updatedAt !== "number" || this.now() - parsed.updatedAt > METADATA_TTL_MS) {
+          if (fs2.statSync(filePath).mtimeMs === mtimeMs) fs2.unlinkSync(filePath);
+        }
+      } catch {
+      }
+    }
+  }
   /** Cached descriptors for one server (from the metadata cache file). */
   cachedToolsFor(server) {
     return this.loadCatalog().filter((tool) => tool.server === sanitizeName(server));
@@ -24681,27 +24738,60 @@ var McpServerManager = class {
     this.conflictedNames = conflicts;
     return [...catalog.values()].sort((a, b) => a.prefixedName.localeCompare(b.prefixedName));
   }
-  cacheMtime;
+  cacheSignature;
   cacheSnapshot = {};
-  /** Read the metadata cache file, re-reading only when the mtime changed. */
+  cacheUpdatedAt = {};
+  pruneExpiredSnapshot() {
+    for (const [key, updatedAt] of Object.entries(this.cacheUpdatedAt)) {
+      if (this.now() - updatedAt > METADATA_TTL_MS) {
+        delete this.cacheSnapshot[key];
+        delete this.cacheUpdatedAt[key];
+      }
+    }
+    return this.cacheSnapshot;
+  }
+  /**
+   * Read the sharded metadata cache (<cacheDir>/<server>.json), merging every
+   * shard's tools by server key (the file name is the sanitized server key).
+   * Re-reads only when the signature changed; the signature must cover each
+   * shard's name + mtime — the directory's own mtime is NOT enough, because a
+   * rename replacing an existing shard leaves it unchanged.
+   */
   readCacheFile() {
-    let mtime;
+    let names;
     try {
-      mtime = fs2.statSync(this.cachePath).mtimeMs;
+      names = fs2.readdirSync(this.cacheDir).sort();
     } catch {
-      this.cacheMtime = void 0;
+      this.cacheSignature = void 0;
       this.cacheSnapshot = {};
+      this.cacheUpdatedAt = {};
       return this.cacheSnapshot;
     }
-    if (mtime === this.cacheMtime) return this.cacheSnapshot;
-    try {
-      const parsed = JSON.parse(fs2.readFileSync(this.cachePath, "utf8"));
-      this.cacheSnapshot = parsed.tools ?? {};
-      this.cacheMtime = mtime;
-    } catch {
-      this.cacheSnapshot = {};
-      this.cacheMtime = mtime;
+    let signature = "";
+    for (const name of names) {
+      try {
+        signature += `${name}:${fs2.statSync(path2.join(this.cacheDir, name)).mtimeMs};`;
+      } catch {
+      }
     }
+    if (signature === this.cacheSignature) return this.pruneExpiredSnapshot();
+    const snapshot = {};
+    const updatedAt = {};
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const parsed = JSON.parse(fs2.readFileSync(path2.join(this.cacheDir, name), "utf8"));
+        if (typeof parsed.updatedAt !== "number" || this.now() - parsed.updatedAt > METADATA_TTL_MS) continue;
+        if (!Array.isArray(parsed.tools)) continue;
+        const key = name.slice(0, -".json".length);
+        snapshot[key] = parsed.tools;
+        updatedAt[key] = parsed.updatedAt;
+      } catch {
+      }
+    }
+    this.cacheSnapshot = snapshot;
+    this.cacheUpdatedAt = updatedAt;
+    this.cacheSignature = signature;
     return this.cacheSnapshot;
   }
   async callTool(prefixedName, args, signal) {
@@ -24716,13 +24806,10 @@ var McpServerManager = class {
     let server = descriptor?.server;
     let toolName = descriptor?.tool;
     if (!server) {
-      const separator = prefixedName.indexOf("_");
-      if (separator > 0) {
-        const candidate = prefixedName.slice(0, separator);
-        if (this.definitions.has(candidate)) {
-          server = candidate;
-          toolName = prefixedName.slice(separator + 1);
-        }
+      const resolved = this.resolvePrefixedName(prefixedName);
+      if (resolved) {
+        server = resolved.server;
+        toolName = resolved.tool;
       }
     }
     if (!server || !toolName) {
@@ -24756,9 +24843,15 @@ ${tail}` : "")
         error: `MCP connection to "${server}" closed before the call could start.`
       };
     }
+    if (signal?.aborted) {
+      return {
+        delivery: "not_sent",
+        error: `MCP call "${prefixedName}" was cancelled before the request was sent; nothing was executed.`
+      };
+    }
     try {
       const result = await withTimeout(
-        client.callTool({ name: toolName, arguments: args }),
+        client.callTool({ name: toolName, arguments: args }, void 0, signal !== void 0 ? { signal } : void 0),
         CALL_TIMEOUT_MS,
         `call "${prefixedName}"`,
         signal
@@ -24771,6 +24864,12 @@ ${tail}` : "")
       };
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
+      if (error2 instanceof ProtocolError && (error2.code === ProtocolErrorCode.InvalidRequest || error2.code === ProtocolErrorCode.InvalidParams) && /output schema|structured content/i.test(message)) {
+        return {
+          delivery: "invalid_result",
+          error: `MCP server "${server}" returned a result that fails its own outputSchema: ${message}. The call DID reach the server and the tool likely executed \u2014 do NOT retry automatically; verify state with a read-only tool first.`
+        };
+      }
       if (runtime.client === void 0 || /closed|aborted|timed out|socket|ECONNRESET/i.test(message)) {
         return {
           delivery: "may_have_run",
@@ -24918,7 +25017,7 @@ function structuredContentIsMirroredInText(textBlocks, structured) {
 }
 function mapMcpOutcome(outcome, maxBytes) {
   if (outcome.delivery !== "ok") {
-    const prefix = outcome.delivery === "may_have_run" ? "[outcome unknown]" : "[not executed]";
+    const prefix = outcome.delivery === "may_have_run" || outcome.delivery === "invalid_result" ? "[outcome unknown]" : "[not executed]";
     return {
       content: [{ type: "text", text: `${prefix} ${outcome.error ?? "MCP call failed"}` }],
       details: { mode: "mcp", delivery: outcome.delivery, ...outcome.protocolCode !== void 0 ? { protocolCode: outcome.protocolCode } : {} },
@@ -24960,7 +25059,7 @@ function createMcpProxyTool(getManager, ensureTrusted, options = {}) {
   return {
     name: "mcp",
     label: "MCP",
-    description: 'Call tools on configured MCP servers without loading their definitions. Discover: mcp({ search: "screenshot" }) lists matching <server>_<tool> names with compact parameter hints (cached metadata; servers do not start for search). Inspect: mcp({ tool: "<name>", describe: true }) returns the full input schema. Call: mcp({ tool: "<name>", args: { ... } }) \u2014 the server starts lazily on first use. args may be a JSON object or JSON string. If a result is marked [outcome unknown], the tool may have executed: do not retry automatically \u2014 verify state with a read-only call first.',
+    description: 'Call tools on configured MCP servers without loading their definitions. Discover: mcp({ search: "screenshot" }) lists matching <server>_<tool> names with compact parameter hints (cached metadata; servers do not start for search). Inspect: mcp({ tool: "<name>", describe: true }) returns the full input schema. Call: mcp({ tool: "<name>", args: { ... } }) \u2014 the server starts lazily on first use. args may be a JSON object or JSON string. Tool lists are a snapshot taken when a server connects: tools added or removed by a running server only appear after /reload refreshes the session. If a result is marked [outcome unknown], the tool may have executed: do not retry automatically \u2014 verify state with a read-only call first.',
     parameters: Type.Object({
       search: Type.Optional(Type.String({ description: "Query text to discover MCP tools by name/description" })),
       tool: Type.Optional(Type.String({ description: "Prefixed tool name <server>_<tool> to describe or call" })),
@@ -25005,8 +25104,8 @@ ${truncate(JSON.stringify(schema ?? {}, null, 2), maxBytes)}` : `unknown MCP too
           isError: descriptor === void 0
         };
       }
-      const separator = params.tool.indexOf("_");
-      const server = descriptor?.server ?? (separator > 0 ? params.tool.slice(0, separator) : "");
+      const resolved = getManager().resolvePrefixedName(params.tool);
+      const server = descriptor?.server ?? resolved?.server ?? "";
       if (server) {
         const trust = await ensureTrusted(server);
         if (!trust.trusted) {
@@ -25160,10 +25259,10 @@ function formatServerForTrustPrompt(definition) {
 function mcpAdapter(ctx) {
   const configDir = resolveConfigDir();
   const trustStore = new McpTrustStore(path4.join(configDir, "mcp-trust.json"));
-  const metadataCachePath = path4.join(configDir, "mcp-metadata.json");
+  const metadataCacheDir = path4.join(configDir, "mcp-metadata");
   let manager = new McpServerManager(
     resolveMcpAdapterConfig(ctx.cwd, configDir).servers,
-    metadataCachePath,
+    metadataCacheDir,
     ctx.log
   );
   async function reloadManager() {
@@ -25171,28 +25270,42 @@ function mcpAdapter(ctx) {
     try {
       manager = new McpServerManager(
         resolveMcpAdapterConfig(ctx.cwd, configDir).servers,
-        metadataCachePath,
+        metadataCacheDir,
         ctx.log
       );
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       ctx.log(`mcp: config reload failed: ${message}`);
       if (ctx.hasUI) ctx.ui.notify(`MCP adapter config error: ${message}`, "error");
-      manager = new McpServerManager([], metadataCachePath, ctx.log);
+      manager = new McpServerManager([], metadataCacheDir, ctx.log);
     }
   }
-  function writeProjectOverride(serverName, disabled) {
+  ctx.registerCleanup?.(() => manager.dispose().catch(() => void 0));
+  function readProjectOverride() {
     const filePath = path4.join(ctx.cwd, ".pie", "mcp-adapter.json");
     let parsed = {};
     try {
       parsed = JSON.parse(fs4.readFileSync(filePath, "utf8"));
     } catch {
     }
+    return parsed;
+  }
+  function writeProjectOverride(serverName, disabled) {
+    const filePath = path4.join(ctx.cwd, ".pie", "mcp-adapter.json");
+    const parsed = readProjectOverride();
     const servers = parsed.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers) ? { ...parsed.mcpServers } : {};
+    const existing = servers[serverName];
+    const existingObj = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
     if (disabled === null) {
-      delete servers[serverName];
+      delete existingObj.disabled;
+      if (Object.keys(existingObj).length === 0) {
+        delete servers[serverName];
+      } else {
+        servers[serverName] = existingObj;
+      }
     } else {
-      servers[serverName] = { disabled };
+      existingObj.disabled = disabled;
+      servers[serverName] = existingObj;
     }
     parsed.mcpServers = servers;
     fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
@@ -25229,16 +25342,6 @@ function mcpAdapter(ctx) {
   if (eagerRegistered.length > 0) {
     ctx.log(`mcp: registered ${eagerRegistered.length} direct tool(s) from metadata cache: ${eagerRegistered.join(", ")}`);
   }
-  function unpinnedWarnings() {
-    const warnings = [];
-    for (const definition of manager.listDefinitions()) {
-      const spec = [definition.command ?? "", ...definition.args].join(" ");
-      if (/(^|\s)(npx|bunx|uvx)\s/.test(spec) && /@latest\b/.test(spec)) {
-        warnings.push(`${definition.name}: unpinned "@latest" fetch \u2014 pin an exact version (e.g. pkg@1.2.3).`);
-      }
-    }
-    return warnings;
-  }
   ctx.registerCommand({
     name: "mcp",
     description: "MCP adapter: status (default), enable/disable <server>",
@@ -25254,10 +25357,21 @@ function mcpAdapter(ctx) {
           commandCtx.ui.notify(`Unknown MCP server "${target}". Run /mcp for the configured list.`, "warning");
           return;
         }
-        const filePath = writeProjectOverride(definition.name, sub === "disable" ? true : null);
+        const overrides = readProjectOverride().mcpServers;
+        const forceEnabled = overrides?.[definition.name]?.disabled === false;
+        const filePath = writeProjectOverride(
+          definition.name,
+          // enable must lift a source-level disabled:true with an explicit
+          // {disabled:false} force-override: deleting the override alone
+          // would leave the source-level disable in force. Preserve an
+          // existing force-enable on repeated enable commands too.
+          sub === "disable" ? true : definition.disabled || forceEnabled ? false : null
+        );
         await reloadManager();
+        const effectiveDisabled = manager.getDefinition(definition.name)?.disabled ?? false;
+        const stateLabel = effectiveDisabled ? "disabled" : sub === "disable" ? "still enabled" : "enabled";
         commandCtx.ui.notify(
-          `MCP server "${definition.name}" ${sub}d (wrote ${filePath}). ` + (eagerRegistered.length > 0 ? "Restart or /reload to resync direct tools." : "Effective immediately."),
+          `MCP server "${definition.name}" ${stateLabel} (wrote ${filePath}). ` + (eagerRegistered.length > 0 ? "Restart or /reload to resync direct tools." : "Effective immediately."),
           "info"
         );
         return;
@@ -25279,7 +25393,7 @@ function mcpAdapter(ctx) {
           lines.push(`- ${sanitizeName(definition.name)} [${manager.statusOf(definition.name)}, ${scopeLabel}] ${spec}`);
         }
       }
-      const warnings = unpinnedWarnings();
+      const warnings = unpinnedWarnings(manager.listDefinitions());
       if (warnings.length > 0) lines.push("", "Warnings:", ...warnings.map((warning) => `- ${warning}`));
       const config2 = resolveMcpAdapterConfig(commandCtx.cwd, configDir);
       if (config2.problems.length > 0) lines.push("", "Config problems:", ...config2.problems.map((problem) => `- ${problem}`));

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,9 +7,9 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-HH2Q2SNX.js";
-import "../../../chunks/chunk-QJH6YN2W.js";
-import "../../../chunks/chunk-IM43UYVV.js";
+} from "../../../chunks/chunk-FKUEIYFQ.js";
+import "../../../chunks/chunk-ZKHMNEXL.js";
+import "../../../chunks/chunk-YRXXRLMQ.js";
 import {
   Type
 } from "../../../chunks/chunk-XXGYUYXI.js";

package/dist/builtin/extensions/subagent/index.js

@@ -1,14 +1,14 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-G3SE3I2L.js";
-import "../../../chunks/chunk-5353DEEC.js";
+} from "../../../chunks/chunk-XVUV3IM2.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-HH2Q2SNX.js";
-import "../../../chunks/chunk-QJH6YN2W.js";
-import "../../../chunks/chunk-IM43UYVV.js";
+} from "../../../chunks/chunk-FKUEIYFQ.js";
+import "../../../chunks/chunk-ZKHMNEXL.js";
+import "../../../chunks/chunk-YRXXRLMQ.js";
+import "../../../chunks/chunk-5353DEEC.js";
 import "../../../chunks/chunk-XXGYUYXI.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";
 

package/dist/builtin/extensions/todo/index.js

@@ -8,9 +8,9 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-HH2Q2SNX.js";
-import "../../../chunks/chunk-QJH6YN2W.js";
-import "../../../chunks/chunk-IM43UYVV.js";
+} from "../../../chunks/chunk-FKUEIYFQ.js";
+import "../../../chunks/chunk-ZKHMNEXL.js";
+import "../../../chunks/chunk-YRXXRLMQ.js";
 import "../../../chunks/chunk-XXGYUYXI.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";
 

package/dist/builtin/skills/chrome-devtools-axi/chrome-devtools-axi-runtime.js

@@ -21,6 +21,6 @@ function tryFastPath(argv, options) {
 
 // vendor/chrome-devtools-axi/bin/chrome-devtools-axi.ts
 if (!tryFastPath(process.argv.slice(2), { version: VERSION })) {
-  const { main } = await import("./cli-F2VCSVL4.js");
+  const { main } = await import("./cli-P4VG6ZZG.js");
   await main(process.argv.slice(2));
 }

package/dist/builtin/skills/chrome-devtools-axi/{cli-F2VCSVL4.js → cli-P4VG6ZZG.js}

@@ -1612,7 +1612,7 @@ function installSessionStartHooks(options = {}) {
 
 // vendor/chrome-devtools-axi/src/client.ts
 import { execFileSync, spawn as spawn2 } from "node:child_process";
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "node:fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3, unlinkSync } from "node:fs";
 import { request } from "node:http";
 import { dirname as dirname3 } from "node:path";
 
@@ -1945,6 +1945,39 @@ function isBridgeProcess(pid) {
     return false;
   }
 }
+async function probeBridgeIdentity(port, sessionName) {
+  try {
+    const resp = await httpGet(port, "/health", HEALTH_TIMEOUT_MS);
+    const data = JSON.parse(resp);
+    if (data.status !== "ok") return "unknown";
+    if (typeof data.session === "string" && data.session !== sessionName) {
+      return "other";
+    }
+    return "own";
+  } catch {
+    return "unknown";
+  }
+}
+async function judgeRecordedBridge(pidInfo, sessionName) {
+  const identity = await probeBridgeIdentity(pidInfo.port, sessionName);
+  if (identity === "own") {
+    return {
+      terminate: true,
+      killProcessGroup: isBridgeProcess(pidInfo.pid)
+    };
+  }
+  if (identity === "other") {
+    return { terminate: false, killProcessGroup: false };
+  }
+  const bridge = isBridgeProcess(pidInfo.pid);
+  return { terminate: bridge, killProcessGroup: bridge };
+}
+function removePidFile(pidFile) {
+  try {
+    unlinkSync(pidFile);
+  } catch {
+  }
+}
 async function terminateBridgeProcess(pid, opts = {}) {
   if (!isProcessAlive(pid)) return;
   const killProcessGroup = opts.killProcessGroup === true;
@@ -2065,9 +2098,14 @@ async function ensureBridge(spawnBridge = spawnBridgeProcess, notice) {
     })) {
       return pidInfo.port;
     }
-    await terminateBridgeProcess(pidInfo.pid, {
-      killProcessGroup: isBridgeProcess(pidInfo.pid)
-    });
+    const verdict = await judgeRecordedBridge(pidInfo, sessionName);
+    if (verdict.terminate) {
+      await terminateBridgeProcess(pidInfo.pid, {
+        killProcessGroup: verdict.killProcessGroup
+      });
+    } else {
+      removePidFile(pidFile);
+    }
   }
   clearSelectedPageId();
   const child = spawnBridge(port, sessionName);
@@ -2338,8 +2376,10 @@ async function stopBridge() {
   const pidInfo = readPidFile();
   if (!pidInfo) return false;
   if (!isProcessAlive(pidInfo.pid)) return false;
+  const verdict = await judgeRecordedBridge(pidInfo, resolveSessionName());
+  if (!verdict.terminate) return false;
   await terminateBridgeProcess(pidInfo.pid, {
-    killProcessGroup: isBridgeProcess(pidInfo.pid)
+    killProcessGroup: verdict.killProcessGroup
   });
   clearSelectedPageId();
   return true;
@@ -2350,7 +2390,7 @@ import {
   existsSync as existsSync4,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync4,
-  unlinkSync,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { dirname as dirname4, join as join3 } from "node:path";
@@ -2379,7 +2419,7 @@ function bumpGeneration() {
 }
 
 // vendor/chrome-devtools-axi/src/run.ts
-import { mkdtempSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, rmdirSync } from "node:fs";
+import { mkdtempSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, rmdirSync } from "node:fs";
 import { join as join4 } from "node:path";
 import { tmpdir } from "node:os";
 import { pathToFileURL } from "node:url";
@@ -2786,7 +2826,7 @@ async function runScript(content, callTool2) {
       globalThis.page = prevPage;
     }
     try {
-      unlinkSync2(tmpFile);
+      unlinkSync3(tmpFile);
       rmdirSync(tmpDir);
     } catch {
     }