@askexenow/exe-os 0.9.345 → 0.9.347

package/dist/bin/exe-mcp.js

@@ -0,0 +1,494 @@
+import "../chunk-MLKGABMK.js";
+
+// src/bin/exe-mcp.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function objectKeys(value) {
+  return isJsonObject(value) ? Object.keys(value) : [];
+}
+function projectEntry(config, projectPath) {
+  const projects = config.projects;
+  if (!isJsonObject(projects)) return void 0;
+  const entry = projects[projectPath];
+  return isJsonObject(entry) ? entry : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function statusFromEnabled(enabled) {
+  return enabled === false ? "INACTIVE" : "ACTIVE";
+}
+function buildClaudeMcpStatus(config, projectPath, configPath = defaultClaudeJsonPath()) {
+  if (!isJsonObject(config)) {
+    throw new Error("Claude JSON root must be an object");
+  }
+  const userNames = objectKeys(config.mcpServers);
+  const project = projectEntry(config, projectPath);
+  const projectNames = project ? objectKeys(project.mcpServers) : [];
+  const disabledNames = project ? stringArray(project.disabledMcpServers) : [];
+  const disabledSet = new Set(disabledNames);
+  const knownNames = /* @__PURE__ */ new Set([...userNames, ...projectNames]);
+  const rows = [
+    ...userNames.map((name) => ({
+      name,
+      runtime: "claude",
+      scope: "user",
+      status: disabledSet.has(name) ? "INACTIVE" : "ACTIVE",
+      configPath
+    })),
+    ...projectNames.map((name) => ({
+      name,
+      runtime: "claude",
+      scope: "project",
+      status: disabledSet.has(name) ? "INACTIVE" : "ACTIVE",
+      configPath
+    })),
+    ...disabledNames.filter((name, index) => !knownNames.has(name) && disabledNames.indexOf(name) === index).map((name) => ({
+      name,
+      runtime: "claude",
+      scope: "external",
+      status: "INACTIVE",
+      configPath
+    }))
+  ];
+  return {
+    projectPath,
+    rows,
+    notes: project ? [] : [`Claude project entry missing for ${projectPath}; run claude in this directory before toggling Claude project MCP servers.`]
+  };
+}
+function buildMcpStatus(config, projectPath) {
+  const report = buildClaudeMcpStatus(config, projectPath);
+  const projectExists = isJsonObject(config) && Boolean(projectEntry(config, projectPath));
+  return {
+    ...report,
+    projectExists,
+    note: report.notes[0]
+  };
+}
+function parseArgs(args) {
+  const parsed = { json: false, rest: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") {
+      parsed.json = true;
+    } else if (arg === "--project") {
+      const value = args[i + 1];
+      if (!value) return { ...parsed, error: "Missing value for --project" };
+      parsed.project = value;
+      i++;
+    } else if (arg === "--runtime") {
+      const value = args[i + 1];
+      if (!value) return { ...parsed, error: "Missing value for --runtime" };
+      if (!isRuntime(value) && value !== "all") {
+        return { ...parsed, error: `Unknown runtime: ${value}` };
+      }
+      parsed.runtime = value;
+      i++;
+    } else if (arg?.startsWith("--")) {
+      return { ...parsed, error: `Unknown option: ${arg}` };
+    } else if (arg) {
+      parsed.rest.push(arg);
+    }
+  }
+  return parsed;
+}
+function isRuntime(value) {
+  return value === "claude" || value === "codex" || value === "opencode";
+}
+function selectedRuntimes(runtime) {
+  return runtime && runtime !== "all" ? [runtime] : ["claude", "codex", "opencode"];
+}
+function resolveProjectPath(project, cwd) {
+  if (!project) return path.resolve(cwd);
+  return path.isAbsolute(project) ? path.resolve(project) : path.resolve(cwd, project);
+}
+function usage() {
+  return `Usage:
+  exe-os mcp [list] [--runtime claude|codex|opencode|all] [--project <path>] [--json]
+  exe-os mcp disable <name> [--runtime claude|codex|opencode|all] [--project <path>]
+  exe-os mcp enable <name> [--runtime claude|codex|opencode|all] [--project <path>]
+`;
+}
+function defaultClaudeJsonPath() {
+  return path.join(os.homedir(), ".claude.json");
+}
+function defaultCodexConfigPath() {
+  return path.join(os.homedir(), ".codex", "config.toml");
+}
+function defaultOpenCodeConfigPath() {
+  return path.join(os.homedir(), ".config", "opencode", "opencode.json");
+}
+function defaultBackupDir() {
+  return path.join(os.homedir(), ".exe-os", "mcp-config-backups");
+}
+function runtimePaths(opts) {
+  return {
+    claude: opts.claudeJsonPath ?? defaultClaudeJsonPath(),
+    codex: opts.codexConfigPath ?? defaultCodexConfigPath(),
+    opencode: opts.opencodeConfigPath ?? defaultOpenCodeConfigPath()
+  };
+}
+function readJsonConfig(filePath, label) {
+  const raw = readFileSync(filePath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${label} at ${filePath}: ${message}`);
+  }
+  if (!isJsonObject(parsed)) {
+    throw new Error(`${label} at ${filePath} must contain an object at the top level.`);
+  }
+  return { raw, config: parsed };
+}
+function readRuntimeConfig(runtime, filePath) {
+  if (!existsSync(filePath)) return void 0;
+  if (runtime === "claude") {
+    const { raw: raw2, config } = readJsonConfig(filePath, "Claude JSON");
+    return { runtime, path: filePath, raw: raw2, config };
+  }
+  if (runtime === "opencode") {
+    const { raw: raw2, config } = readJsonConfig(filePath, "OpenCode JSON");
+    return { runtime, path: filePath, raw: raw2, config };
+  }
+  const raw = readFileSync(filePath, "utf8");
+  return { runtime, path: filePath, raw, sections: parseCodexMcpSections(raw) };
+}
+function readRuntimeConfigs(paths, runtimes) {
+  const configs = [];
+  for (const runtime of runtimes) {
+    const config = readRuntimeConfig(runtime, paths[runtime]);
+    if (config) configs.push(config);
+  }
+  return configs;
+}
+function parseCodexMcpName(rawName) {
+  const trimmed = rawName.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "string") return parsed;
+    } catch {
+      return trimmed.slice(1, -1);
+    }
+  }
+  return trimmed;
+}
+function parseCodexMcpSections(raw) {
+  const headerRegex = /^\[mcp_servers\.([^\]\n]+)\][ \t]*$/gm;
+  const headers = [...raw.matchAll(headerRegex)];
+  return headers.map((match, index) => {
+    const start = match.index ?? 0;
+    const headerEnd = start + match[0].length;
+    const afterHeader = raw.slice(headerEnd);
+    const nextSection = afterHeader.match(/\n\[[^\]\n]+\][ \t]*(?:\n|$)/);
+    const nextMcpHeader = headers[index + 1]?.index;
+    const regexEnd = nextSection?.index == null ? raw.length : headerEnd + nextSection.index;
+    const end = nextMcpHeader == null ? regexEnd : Math.min(regexEnd, nextMcpHeader);
+    const body = raw.slice(headerEnd, end);
+    return {
+      name: parseCodexMcpName(match[1] ?? ""),
+      start,
+      end,
+      headerEnd,
+      body
+    };
+  });
+}
+function codexEnabled(section) {
+  const enabledMatch = section.body.match(/^\s*enabled\s*=\s*(true|false)\s*(?:#.*)?$/m);
+  return enabledMatch?.[1] !== "false";
+}
+function buildCodexMcpStatus(config) {
+  return config.sections.map((section) => ({
+    name: section.name,
+    runtime: "codex",
+    scope: "config",
+    status: codexEnabled(section) ? "ACTIVE" : "INACTIVE",
+    configPath: config.path
+  }));
+}
+function buildOpenCodeMcpStatus(config) {
+  const mcp = config.config.mcp;
+  if (mcp !== void 0 && !isJsonObject(mcp)) {
+    throw new Error(`OpenCode mcp key at ${config.path} must be an object.`);
+  }
+  return Object.entries(mcp ?? {}).map(([name, entry]) => ({
+    name,
+    runtime: "opencode",
+    scope: "config",
+    status: isJsonObject(entry) ? statusFromEnabled(entry.enabled) : "ACTIVE",
+    configPath: config.path
+  }));
+}
+function buildStatusReport(configs, projectPath) {
+  const rows = [];
+  const notes = [];
+  for (const config of configs) {
+    if (config.runtime === "claude") {
+      const report = buildClaudeMcpStatus(config.config, projectPath, config.path);
+      rows.push(...report.rows);
+      notes.push(...report.notes);
+    } else if (config.runtime === "codex") {
+      rows.push(...buildCodexMcpStatus(config));
+    } else {
+      rows.push(...buildOpenCodeMcpStatus(config));
+    }
+  }
+  return { projectPath, rows, notes };
+}
+function sameStringSet(left, right) {
+  if (left.length !== right.length) return false;
+  const rightSet = new Set(right);
+  return left.every((key) => rightSet.has(key));
+}
+function serializeJsonWithSanityCheck(originalTopLevelKeys, next, label) {
+  const serialized = JSON.stringify(next, null, 2) + "\n";
+  const roundTrip = JSON.parse(serialized);
+  if (!isJsonObject(roundTrip)) {
+    throw new Error(`Refusing to write ${label}: serialized value did not round-trip to an object.`);
+  }
+  if (!sameStringSet(originalTopLevelKeys, Object.keys(roundTrip))) {
+    throw new Error(`Refusing to write ${label}: top-level keys changed unexpectedly.`);
+  }
+  return serialized;
+}
+function backupConfig(configPath, backupDir) {
+  mkdirSync(backupDir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+  const base = path.basename(configPath).replace(/[^A-Za-z0-9_.-]/g, "_");
+  const backupPath = path.join(backupDir, `${base}.${stamp}.bak`);
+  copyFileSync(configPath, backupPath);
+  const prefix = `${base}.`;
+  const backups = readdirSync(backupDir).filter((name) => name.startsWith(prefix) && name.endsWith(".bak")).map((name) => {
+    const filePath = path.join(backupDir, name);
+    return { filePath, mtimeMs: statSync(filePath).mtimeMs };
+  }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const backup of backups.slice(10)) {
+    rmSync(backup.filePath, { force: true });
+  }
+}
+function writeAtomically(filePath, content) {
+  const tmpPath = `${filePath}.exe-mcp-tmp-${process.pid}`;
+  try {
+    writeFileSync(tmpPath, content, { mode: 384 });
+    renameSync(tmpPath, filePath);
+  } catch (err) {
+    rmSync(tmpPath, { force: true });
+    throw err;
+  }
+}
+function renderTable(report) {
+  const rows = report.rows;
+  if (rows.length === 0) {
+    const lines2 = ["No configured MCP servers found."];
+    if (report.notes.length > 0) lines2.push("", ...report.notes);
+    return `${lines2.join("\n")}
+`;
+  }
+  const widths = {
+    runtime: Math.max("runtime".length, ...rows.map((row) => row.runtime.length)),
+    name: Math.max("name".length, ...rows.map((row) => row.name.length)),
+    scope: Math.max("scope".length, ...rows.map((row) => row.scope.length)),
+    status: Math.max("status".length, ...rows.map((row) => row.status.length))
+  };
+  const lines = [
+    `${"runtime".padEnd(widths.runtime)}  ${"name".padEnd(widths.name)}  ${"scope".padEnd(widths.scope)}  ${"status".padEnd(widths.status)}`,
+    `${"-".repeat(widths.runtime)}  ${"-".repeat(widths.name)}  ${"-".repeat(widths.scope)}  ${"-".repeat(widths.status)}`,
+    ...rows.map((row) => `${row.runtime.padEnd(widths.runtime)}  ${row.name.padEnd(widths.name)}  ${row.scope.padEnd(widths.scope)}  ${row.status.padEnd(widths.status)}`)
+  ];
+  if (report.notes.length > 0) lines.push("", ...report.notes);
+  return `${lines.join("\n")}
+`;
+}
+function disabledArrayForMutation(project) {
+  const disabled = project.disabledMcpServers;
+  if (disabled === void 0) {
+    const next = [];
+    project.disabledMcpServers = next;
+    return next;
+  }
+  if (!Array.isArray(disabled)) {
+    throw new Error("Project disabledMcpServers exists but is not an array; refusing to overwrite it.");
+  }
+  return disabled;
+}
+function knownClaudeServerNames(config, project) {
+  return [.../* @__PURE__ */ new Set([...objectKeys(config.mcpServers), ...objectKeys(project.mcpServers)])];
+}
+function setClaudeServerEnabled(config, projectPath, name, enabled) {
+  const project = projectEntry(config.config, projectPath);
+  if (!project) return false;
+  if (!knownClaudeServerNames(config.config, project).includes(name)) return false;
+  const currentDisabled = project.disabledMcpServers;
+  if (currentDisabled !== void 0 && !Array.isArray(currentDisabled)) {
+    throw new Error("Project disabledMcpServers exists but is not an array; refusing to overwrite it.");
+  }
+  if (enabled) {
+    if (currentDisabled === void 0) return true;
+    project.disabledMcpServers = currentDisabled.filter((item) => item !== name);
+    return true;
+  }
+  const disabled = disabledArrayForMutation(project);
+  const disabledStrings = stringArray(disabled);
+  if (!disabledStrings.includes(name)) disabled.push(name);
+  return true;
+}
+function setCodexServerEnabled(raw, section, enabled) {
+  const desiredLine = `enabled = ${enabled ? "true" : "false"}`;
+  const sectionText = raw.slice(section.start, section.end);
+  const enabledRegex = /^(\s*)enabled\s*=\s*(?:true|false)(\s*(?:#.*)?)$/m;
+  let nextSection;
+  if (enabledRegex.test(sectionText)) {
+    nextSection = sectionText.replace(enabledRegex, `$1${desiredLine}$2`);
+  } else {
+    nextSection = `${sectionText.slice(0, section.headerEnd - section.start)}
+${desiredLine}${sectionText.slice(section.headerEnd - section.start)}`;
+  }
+  return raw.slice(0, section.start) + nextSection + raw.slice(section.end);
+}
+function setOpenCodeServerEnabled(config, name, enabled) {
+  const mcp = config.config.mcp;
+  if (mcp !== void 0 && !isJsonObject(mcp)) {
+    throw new Error(`OpenCode mcp key at ${config.path} must be an object.`);
+  }
+  const servers = mcp ?? {};
+  const entry = servers[name];
+  if (entry === void 0) return false;
+  if (!isJsonObject(entry)) {
+    throw new Error(`OpenCode MCP server "${name}" at ${config.path} must be an object before it can be toggled.`);
+  }
+  entry.enabled = enabled;
+  return true;
+}
+function knownServerSummary(configs, projectPath) {
+  const names = /* @__PURE__ */ new Set();
+  for (const config of configs) {
+    if (config.runtime === "claude") {
+      const project = projectEntry(config.config, projectPath);
+      if (project) knownClaudeServerNames(config.config, project).forEach((name) => names.add(name));
+    } else if (config.runtime === "codex") {
+      config.sections.forEach((section) => names.add(section.name));
+    } else {
+      const mcp = config.config.mcp;
+      if (isJsonObject(mcp)) Object.keys(mcp).forEach((name) => names.add(name));
+    }
+  }
+  return names.size > 0 ? [...names].sort().join(", ") : "(none)";
+}
+function writeMutatedConfig(config, backupDir, content) {
+  let serialized;
+  if (config.runtime === "claude") {
+    serialized = serializeJsonWithSanityCheck(Object.keys(JSON.parse(config.raw)), config.config, "Claude JSON");
+  } else if (config.runtime === "opencode") {
+    serialized = serializeJsonWithSanityCheck(Object.keys(JSON.parse(config.raw)), config.config, "OpenCode JSON");
+  } else if (content !== void 0) {
+    serialized = content;
+  } else {
+    throw new Error("Internal error: Codex TOML mutation did not produce content.");
+  }
+  backupConfig(config.path, backupDir);
+  writeAtomically(config.path, serialized);
+}
+async function runList(parsed, paths, projectPath, stdout, stderr) {
+  if (parsed.rest.length > 0) {
+    stderr.write(usage());
+    return 1;
+  }
+  try {
+    const configs = readRuntimeConfigs(paths, selectedRuntimes(parsed.runtime));
+    const report = buildStatusReport(configs, projectPath);
+    stdout.write(parsed.json ? `${JSON.stringify(report, null, 2)}
+` : renderTable(report));
+    return 0;
+  } catch (err) {
+    stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function runToggle(subcommand, parsed, paths, projectPath, backupDir, stdout, stderr) {
+  if (parsed.rest.length !== 1) {
+    stderr.write(usage());
+    return 1;
+  }
+  const name = parsed.rest[0];
+  const enabled = subcommand === "enable";
+  try {
+    const runtimes = selectedRuntimes(parsed.runtime);
+    const configs = readRuntimeConfigs(paths, runtimes);
+    if (configs.length === 0) {
+      stderr.write(`No MCP config files found for ${runtimes.join(", ")}. Run the relevant exe-os installer first.
+`);
+      return 1;
+    }
+    const mutations = [];
+    for (const config of configs) {
+      if (config.runtime === "claude") {
+        if (setClaudeServerEnabled(config, projectPath, name, enabled)) mutations.push({ config });
+      } else if (config.runtime === "codex") {
+        const section = config.sections.find((candidate) => candidate.name === name);
+        if (section) mutations.push({ config, content: setCodexServerEnabled(config.raw, section, enabled) });
+      } else if (setOpenCodeServerEnabled(config, name, enabled)) {
+        mutations.push({ config });
+      }
+    }
+    if (mutations.length === 0) {
+      stderr.write(`Unknown server "${name}". Known servers: ${knownServerSummary(configs, projectPath)}
+`);
+      return 1;
+    }
+    for (const mutation of mutations) {
+      writeMutatedConfig(mutation.config, backupDir, mutation.content);
+    }
+    const changedRuntimes = mutations.map((mutation) => mutation.config.runtime).join(", ");
+    stdout.write(`${name} ${enabled ? "enabled" : "disabled"} for ${changedRuntimes}.
+`);
+    return 0;
+  } catch (err) {
+    stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function main(args, opts = {}) {
+  const stdout = opts.stdout ?? process.stdout;
+  const stderr = opts.stderr ?? process.stderr;
+  const cwd = opts.cwd ?? process.cwd();
+  const paths = runtimePaths(opts);
+  const backupDir = opts.backupDir ?? defaultBackupDir();
+  const explicitSubcommand = args[0] === "list" || args[0] === "disable" || args[0] === "enable";
+  const subcommand = explicitSubcommand ? args[0] : "list";
+  if (!explicitSubcommand && args[0] && !args[0].startsWith("--")) {
+    stderr.write(`Unknown mcp command: ${args[0]}
+${usage()}`);
+    return 1;
+  }
+  if (!["list", "disable", "enable"].includes(subcommand)) {
+    stderr.write(`Unknown mcp command: ${subcommand}
+${usage()}`);
+    return 1;
+  }
+  const parsed = parseArgs(args.slice(explicitSubcommand ? 1 : 0));
+  if (parsed.error) {
+    stderr.write(`${parsed.error}
+${usage()}`);
+    return 1;
+  }
+  const projectPath = resolveProjectPath(parsed.project, cwd);
+  if (subcommand === "list") {
+    return runList(parsed, paths, projectPath, stdout, stderr);
+  }
+  return runToggle(subcommand, parsed, paths, projectPath, backupDir, stdout, stderr);
+}
+export {
+  buildClaudeMcpStatus,
+  buildMcpStatus,
+  main
+};

package/dist/bin/exe-memory-reads.js

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 import {
   initStore
-} from "../chunk-XWD6F6EZ.js";
-import "../chunk-IUMAJIHE.js";
+} from "../chunk-TQSAPNFW.js";
+import "../chunk-FFUEDKYK.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-OTVEIJUQ.js";
-import "../chunk-TNZSK6L7.js";
+import "../chunk-VBHLE3TR.js";
 import "../chunk-5MOYSU5A.js";
 import "../chunk-4QCFFW2H.js";
 import "../chunk-76CJBM36.js";
 import "../chunk-MP2AFCGL.js";
 import {
   getClient
-} from "../chunk-3BO6S3L2.js";
+} from "../chunk-ZY2ABBVR.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-7IE3NPBV.js";
+import "../chunk-FM4ZI5ZP.js";
 import "../chunk-OMXJMOBD.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-BBMTVAE3.js";

package/dist/bin/exe-new-employee.js

@@ -7,26 +7,26 @@ import {
   buildCustomEmployeePrompt,
   getTemplate,
   personalizePrompt
-} from "../chunk-YESAKOJE.js";
-import "../chunk-GY6VSMMB.js";
+} from "../chunk-DZJL775P.js";
+import "../chunk-T7ZLJZAO.js";
 import "../chunk-CQN4IKRB.js";
 import {
   PlanLimitError,
   assertEmployeeLimit
-} from "../chunk-LEESW32W.js";
+} from "../chunk-Y7637VDZ.js";
 import {
   hireEmployee,
   registerBinSymlinks,
   validateEmployeeName
-} from "../chunk-3BO6S3L2.js";
+} from "../chunk-ZY2ABBVR.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-7IE3NPBV.js";
+import "../chunk-FM4ZI5ZP.js";
 import "../chunk-OMXJMOBD.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-BBMTVAE3.js";
 import "../chunk-FXU7JOXK.js";
-import "../chunk-RSMOYIVR.js";
-import "../chunk-DQOBH5VO.js";
+import "../chunk-ZK53K7OR.js";
+import "../chunk-SJLZ53ZR.js";
 import "../chunk-BCZF3AGJ.js";
 import "../chunk-HSGBZSCA.js";
 import {
@@ -147,7 +147,7 @@ ${rolePrompt}${emotionalSection}`;
     console.error(`Warning: some launchers failed: ${bins.errors.join("; ")}`);
   }
   try {
-    const { resolvePackageRoot } = await import("../installer-6O3XLAQ5.js");
+    const { resolvePackageRoot } = await import("../installer-SQF5I6YS.js");
     const { homedir } = await import("os");
     const pkgRoot = resolvePackageRoot();
     const wrapResult = generateSessionWrappers(pkgRoot);

package/dist/bin/exe-os-mcp-proxy.js

@@ -3,11 +3,11 @@ import {
   buildMcpHttpHeaders,
   mcpHttpPort,
   mcpHttpUrl
-} from "../chunk-U6NQ6OEU.js";
+} from "../chunk-MESFJRIT.js";
 import "../chunk-B6TI3TZT.js";
-import "../chunk-3BO6S3L2.js";
+import "../chunk-ZY2ABBVR.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-7IE3NPBV.js";
+import "../chunk-FM4ZI5ZP.js";
 import "../chunk-OMXJMOBD.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-BBMTVAE3.js";
@@ -43,17 +43,53 @@ function parseRetryAfter(value) {
   if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
   return null;
 }
-function errorCode(err) {
-  const nodeErr = err;
-  return nodeErr.code ?? nodeErr.cause?.code;
+function errorChain(err) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [err];
+  while (stack.length > 0 && out.length < 16) {
+    const current = stack.shift();
+    if (current === void 0 || current === null || seen.has(current)) continue;
+    seen.add(current);
+    out.push(current);
+    if (typeof current !== "object") continue;
+    const withCause = current;
+    if (withCause.cause !== void 0) stack.push(withCause.cause);
+    if (Array.isArray(withCause.errors)) stack.push(...withCause.errors);
+  }
+  return out;
+}
+function errorCodes(err) {
+  return errorChain(err).flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const code = item.code;
+    return typeof code === "string" ? [code] : [];
+  });
+}
+function errorMessages(err) {
+  return errorChain(err).flatMap((item) => {
+    if (item instanceof Error) return [item.message];
+    if (typeof item === "string") return [item];
+    if (!item || typeof item !== "object") return [];
+    const message = item.message;
+    return typeof message === "string" ? [message] : [];
+  });
+}
+function isAbortOrTimeout(err) {
+  return errorChain(err).some((item) => {
+    if (!item || typeof item !== "object") return false;
+    const withFields = item;
+    return withFields.code === "ABORT_ERR" || withFields.name === "AbortError" || withFields.name === "TimeoutError";
+  });
 }
 function isConnectionRefused(err) {
-  return errorCode(err) === "ECONNREFUSED";
+  return errorCodes(err).includes("ECONNREFUSED");
 }
 function isConnectionLost(err) {
-  const code = errorCode(err);
-  const message = err instanceof Error ? err.message : String(err);
-  return code === "ECONNRESET" || code === "EPIPE" || /socket hang up/i.test(message);
+  if (isAbortOrTimeout(err)) return false;
+  const codes = errorCodes(err);
+  if (codes.some((code) => code === "ECONNRESET" || code === "EPIPE" || code === "UND_ERR_SOCKET")) return true;
+  return errorMessages(err).some((message) => /socket hang up/i.test(message) || /other side closed/i.test(message) || /\bterminated\b/i.test(message));
 }
 function isIdempotentMethod(message) {
   const method = message.method ?? "";