@ansible-flow/node 0.0.0-stage → 0.85.0

package/dist/chunks/chunk-2MZQHIXP.js

@@ -0,0 +1,614 @@
+// src/node/ai/writers.ts
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import {
+  applyEdits,
+  findNodeAtLocation,
+  modify,
+  parse as parseJsonc,
+  parseTree
+} from "jsonc-parser";
+import { TOOL_SPECS } from "@ansible-flow/core/ai/specs";
+var AGENTS = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+  "zcode",
+  "copilot",
+  "cursor",
+  // AFD-173: the agents built into VS Code forks, by the files they read (AFD-172 probes).
+  "kiro",
+  "antigravity",
+  "devin"
+];
+var SERVER_NAME = "ansible-flow";
+var SKILL_NAME = "ansible-flow";
+var MANIFEST = ".afd-skill.json";
+var BEGIN = `# >>> ${SERVER_NAME} (managed by Ansible Flow Designer; Remove AI Assistant Setup deletes it)`;
+var END = `# <<< ${SERVER_NAME}`;
+var hash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+async function readText(path) {
+  try {
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function exists(path) {
+  try {
+    await fs.stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function backup(path) {
+  const copy = `${path}.afd-backup`;
+  if (await exists(path) && !await exists(copy)) await fs.copyFile(path, copy);
+}
+var SKILL_HOME = {
+  claude: { repo: ".claude", user: ".claude" },
+  codex: { repo: ".agents", user: ".agents" },
+  gemini: { repo: ".agents", user: ".gemini" },
+  opencode: { repo: ".agents", user: ".agents" },
+  zcode: { repo: ".agents", user: ".agents" },
+  copilot: { repo: ".github", user: ".copilot" },
+  cursor: { repo: ".claude", user: ".claude" },
+  kiro: { repo: ".kiro", user: ".kiro" },
+  // Antigravity's customization roots: .agents in a repository, ~/.gemini/config for the user.
+  antigravity: { repo: ".agents", user: ".gemini/config" },
+  // Devin reads ~/.codeium/windsurf/skills and ~/.agents/skills, not ~/.devin/skills.
+  devin: { repo: ".agents", user: ".codeium/windsurf" }
+};
+function skillDirs(agent, scope, env) {
+  const base = scope === "repo" ? env.repo : env.home;
+  if (!base) return [];
+  return [join(base, SKILL_HOME[agent][scope], "skills", SKILL_NAME)];
+}
+async function readManifest(dir) {
+  const raw = await readText(join(dir, MANIFEST));
+  if (raw === void 0) return void 0;
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!data || typeof data !== "object") return void 0;
+  const { version, files } = data;
+  if (!files || typeof files !== "object" || Array.isArray(files)) return void 0;
+  const kept = {};
+  for (const [name, h] of Object.entries(files))
+    if (typeof h === "string" && SKILL_FILE.test(name) && name !== MANIFEST) kept[name] = h;
+  return { version: typeof version === "string" ? version : "", files: kept };
+}
+var SKILL_FILE = /^(?!.*(?:^|\/)\.\.?(?:\/|$))[\w.-]+(?:\/[\w.-]+)*$/;
+var insideDir = (root, path) => {
+  const rel = relative(root, path);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+};
+async function nearestReal(path) {
+  for (let p = path; ; p = dirname(p)) {
+    try {
+      return await fs.realpath(p);
+    } catch {
+      if (dirname(p) === p) return p;
+    }
+  }
+}
+async function skillPath(dir, name) {
+  if (!SKILL_FILE.test(name)) return void 0;
+  const path = join(dir, ...name.split("/"));
+  const [root, parent] = await Promise.all([nearestReal(dir), nearestReal(dirname(path))]);
+  return insideDir(root, parent) ? path : void 0;
+}
+async function skillState(dir) {
+  if (!await exists(dir)) return void 0;
+  const link = await fs.lstat(dir).then(
+    (s) => s.isSymbolicLink(),
+    () => false
+  );
+  const manifest = link ? void 0 : await readManifest(dir);
+  if (!manifest) return { dir, foreign: true, edited: [] };
+  const edited = [];
+  for (const [name, h] of Object.entries(manifest.files)) {
+    const path = await skillPath(dir, name);
+    const text = path && await readText(path);
+    if (text !== void 0 && hash(text) !== h) edited.push(name);
+  }
+  return { dir, foreign: false, version: manifest.version, edited };
+}
+function newerVersion(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d > 0;
+  }
+  return false;
+}
+async function planSkill(dir, skill) {
+  const state = await skillState(dir);
+  if (!state) return "create";
+  if (state.foreign) return "skip";
+  if (state.version && newerVersion(state.version, skill.version)) return "unchanged";
+  for (const [name, text] of Object.entries(skill.files)) {
+    const path = await skillPath(dir, name);
+    if (!path || await readText(path) !== text) return "update";
+  }
+  return state.version === skill.version ? "unchanged" : "update";
+}
+async function writeSkill(dir, skill) {
+  const before = await skillState(dir);
+  if (before?.foreign) throw new Error(`${dir} exists and is not ours`);
+  const old = before ? await readManifest(dir) : void 0;
+  for (const name of Object.keys(old?.files ?? {})) {
+    if (name in skill.files) continue;
+    const path = await skillPath(dir, name);
+    if (path) await fs.rm(path, { force: true });
+  }
+  for (const [name, text] of Object.entries(skill.files)) {
+    const path = await skillPath(dir, name);
+    if (!path) throw new Error(`${name} would be written outside ${dir}`);
+    await fs.mkdir(dirname(path), { recursive: true });
+    await fs.writeFile(path, text, "utf8");
+  }
+  const manifest = {
+    version: skill.version,
+    files: Object.fromEntries(Object.entries(skill.files).map(([n, t]) => [n, hash(t)]))
+  };
+  await fs.writeFile(join(dir, MANIFEST), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+async function removeSkill(dir) {
+  const state = await skillState(dir);
+  if (!state || state.foreign) return false;
+  const manifest = await readManifest(dir);
+  const names = Object.keys(manifest?.files ?? {});
+  for (const name of names) {
+    const path = await skillPath(dir, name);
+    if (path) await fs.rm(path, { force: true });
+  }
+  await fs.rm(join(dir, MANIFEST), { force: true });
+  const prune = async (d) => {
+    if (!insideDir(dir, d)) return;
+    try {
+      if ((await fs.readdir(d)).length === 0) {
+        await fs.rmdir(d);
+        if (d !== dir) await prune(dirname(d));
+      }
+    } catch {
+    }
+  };
+  for (const name of names) await prune(dirname(join(dir, ...name.split("/"))));
+  await prune(dir);
+  return true;
+}
+var codexConfig = (env) => join(env.home, ".codex", "config.toml");
+var tomlString = (s) => JSON.stringify(s);
+function codexBlock(launch) {
+  const lines = [
+    BEGIN,
+    `[mcp_servers.${SERVER_NAME}]`,
+    `command = ${tomlString(launch.command)}`,
+    `args = [${launch.args.map(tomlString).join(", ")}]`
+  ];
+  if (launch.env && Object.keys(launch.env).length)
+    lines.push(
+      `env = { ${Object.entries(launch.env).map(([k, v]) => `${k} = ${tomlString(v)}`).join(", ")} }`
+    );
+  lines.push(END);
+  return lines.join("\n");
+}
+function splitBlock(text) {
+  const start = text.indexOf(BEGIN);
+  const end = start < 0 ? -1 : text.indexOf(END, start);
+  if (start < 0 || end < 0) return { before: text, after: "" };
+  return {
+    before: text.slice(0, start),
+    block: text.slice(start, end + END.length),
+    after: text.slice(end + END.length)
+  };
+}
+var handWritten = (text) => new RegExp(`^\\s*\\[mcp_servers\\.(${SERVER_NAME}|"${SERVER_NAME}")\\]`, "m").test(
+  splitBlock(text).before + splitBlock(text).after
+);
+async function planCodex(env, launch) {
+  const target = codexConfig(env);
+  const text = await readText(target) ?? "";
+  const item = { agent: "codex", what: "mcp", target };
+  if (handWritten(text))
+    return {
+      ...item,
+      action: "skip",
+      note: `[mcp_servers.${SERVER_NAME}] is written by hand there; left as it is`
+    };
+  const { block } = splitBlock(text);
+  if (block === void 0) return { ...item, action: "create" };
+  return { ...item, action: block === codexBlock(launch) ? "unchanged" : "update" };
+}
+async function writeCodex(env, launch) {
+  const target = codexConfig(env);
+  const text = await readText(target) ?? "";
+  if (handWritten(text)) return;
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const block = codexBlock(launch).replaceAll("\n", eol);
+  const parts = splitBlock(text);
+  const next = parts.block === void 0 ? `${text}${text && !text.endsWith("\n") ? eol : ""}${text ? eol : ""}${block}${eol}` : `${parts.before}${block}${parts.after}`;
+  if (next === text) return;
+  await fs.mkdir(dirname(target), { recursive: true });
+  await backup(target);
+  await fs.writeFile(target, next, "utf8");
+}
+async function removeCodex(env) {
+  const target = codexConfig(env);
+  const text = await readText(target);
+  if (text === void 0) return false;
+  const parts = splitBlock(text);
+  if (parts.block === void 0) return false;
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const after = parts.after.startsWith(eol) ? parts.after.slice(eol.length) : parts.after;
+  await fs.writeFile(
+    target,
+    `${parts.before.replace(/(\r?\n)+$/, eol)}${after}`.replace(/^\r?\n$/, ""),
+    "utf8"
+  );
+  return true;
+}
+var stdio = (l) => ({
+  command: l.command,
+  args: l.args,
+  ...l.env ? { env: l.env } : {}
+});
+async function opencodeConfig(env) {
+  const dir = join(env.home, ".config", "opencode");
+  const jsonc = join(dir, "opencode.jsonc");
+  return await exists(jsonc) ? jsonc : join(dir, "opencode.json");
+}
+var STDIO_KEYS = ["command", "args", "env"];
+var READ_ONLY_TOOLS = TOOL_SPECS.filter((s) => s.readOnly).map((s) => s.name);
+var CURSOR_WORKSPACE = "${workspaceFolder}";
+var JSON_MCP = {
+  gemini: {
+    file: async (env) => join(env.home, ".gemini", "settings.json"),
+    path: ["mcpServers", SERVER_NAME],
+    entry: (l) => ({
+      ...stdio(l),
+      description: "Ansible Flow Designer: read and edit *.flow.yaml flows by key"
+    }),
+    managed: [...STDIO_KEYS, "description"]
+  },
+  opencode: {
+    file: opencodeConfig,
+    path: ["mcp", SERVER_NAME],
+    entry: (l) => ({
+      type: "local",
+      command: [l.command, ...l.args],
+      ...l.env ? { environment: l.env } : {},
+      enabled: true
+    }),
+    managed: ["type", "command", "environment"]
+  },
+  // ZCode reads ~/.agents/mcp.json (besides ~/.zcode/config.json): a file other agents share.
+  zcode: {
+    file: async (env) => join(env.home, ".agents", "mcp.json"),
+    path: ["mcpServers", SERVER_NAME],
+    entry: stdio,
+    managed: STDIO_KEYS
+  },
+  copilot: {
+    file: async (env) => join(env.home, ".copilot", "mcp-config.json"),
+    path: ["mcpServers", SERVER_NAME],
+    entry: (l) => ({ type: "local", ...stdio(l), tools: ["*"] }),
+    managed: ["type", ...STDIO_KEYS]
+  },
+  cursor: {
+    file: async (env) => join(env.home, ".cursor", "mcp.json"),
+    path: ["mcpServers", SERVER_NAME],
+    // AFD-173: Cursor starts global servers in the home folder and sends no roots; the workspace
+    // comes as a variable (the server leaves it out when Cursor does not resolve it).
+    entry: (l) => ({
+      ...stdio(l),
+      env: { ...l.env ?? {}, AFD_MCP_ROOTS: CURSOR_WORKSPACE }
+    }),
+    managed: STDIO_KEYS
+  },
+  kiro: {
+    file: async (env) => join(env.home, ".kiro", "settings", "mcp.json"),
+    path: ["mcpServers", SERVER_NAME],
+    // AFD-174: Kiro asks before every call; the tools that only read are approved when the entry
+    // is first written. Not managed: what the user approves or takes back later stays.
+    entry: (l) => ({ ...stdio(l), autoApprove: READ_ONLY_TOOLS }),
+    managed: STDIO_KEYS
+  },
+  // Antigravity IDE's global customization root; its own plugin folders do not load MCP servers.
+  antigravity: {
+    file: async (env) => join(env.home, ".gemini", "config", "mcp_config.json"),
+    path: ["mcpServers", SERVER_NAME],
+    entry: stdio,
+    managed: STDIO_KEYS
+  },
+  devin: {
+    file: async (env) => devinMcpFile(env),
+    path: ["mcpServers", SERVER_NAME],
+    entry: stdio,
+    managed: STDIO_KEYS
+  }
+};
+function devinMcpFile(env) {
+  const platform = env.platform ?? process.platform;
+  return platform === "win32" ? join(env.home, "AppData", "Roaming", "devin", "mcp_config.json") : join(env.xdgConfig || join(env.home, ".config"), "devin", "mcp_config.json");
+}
+async function mcpTarget(agent, env, launch) {
+  if (agent === "claude") return launch ? claudeCommandLine(launch) : "claude mcp";
+  if (agent === "codex") return codexConfig(env);
+  return JSON_MCP[agent].file(env);
+}
+function formatting(text) {
+  const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
+  return {
+    insertSpaces: !indent.includes("	"),
+    tabSize: indent.includes("	") ? 1 : indent.length,
+    eol: text.includes("\r\n") ? "\r\n" : "\n"
+  };
+}
+function current(text, path) {
+  const tree = parseTree(text);
+  const node = tree && findNodeAtLocation(tree, path);
+  return node ? parseJsonc(text.slice(node.offset, node.offset + node.length)) : void 0;
+}
+function broken(text) {
+  const errors = [];
+  parseJsonc(text, errors, { allowTrailingComma: true });
+  return errors.length > 0;
+}
+async function planJson(agent, env, launch) {
+  const spec = JSON_MCP[agent];
+  const target = await spec.file(env);
+  const text = await readText(target) ?? "";
+  const item = { agent, what: "mcp", target };
+  if (text.trim() && broken(text))
+    return { ...item, action: "skip", note: "it does not parse as JSON; left as it is" };
+  const now = text.trim() ? current(text, spec.path) : void 0;
+  if (now === void 0) return { ...item, action: "create" };
+  const want = spec.entry(launch);
+  const have = now && typeof now === "object" ? now : {};
+  const same = spec.managed.every((k) => JSON.stringify(have[k]) === JSON.stringify(want[k]));
+  return { ...item, action: same ? "unchanged" : "update" };
+}
+async function writeJson(agent, env, launch) {
+  const spec = JSON_MCP[agent];
+  const target = await spec.file(env);
+  const text = await readText(target) ?? "";
+  if (text.trim() && broken(text)) return;
+  const base = text.trim() ? text : "{}\n";
+  const want = spec.entry(launch);
+  const now = current(base, spec.path);
+  let next = base;
+  if (now === void 0 || !now || typeof now !== "object" || Array.isArray(now))
+    next = applyEdits(next, modify(next, spec.path, want, { formattingOptions: formatting(next) }));
+  else
+    for (const key of spec.managed)
+      next = applyEdits(
+        next,
+        modify(next, [...spec.path, key], want[key], { formattingOptions: formatting(next) })
+      );
+  if (next === text) return;
+  await fs.mkdir(dirname(target), { recursive: true });
+  await backup(target);
+  await fs.writeFile(target, next, "utf8");
+}
+async function removeJson(agent, env) {
+  const spec = JSON_MCP[agent];
+  const target = await spec.file(env);
+  const text = await readText(target);
+  if (!text || broken(text) || current(text, spec.path) === void 0) return false;
+  await fs.writeFile(
+    target,
+    applyEdits(text, modify(text, spec.path, void 0, { formattingOptions: formatting(text) })),
+    "utf8"
+  );
+  return true;
+}
+function claudeAddArgs(launch) {
+  const env = Object.entries(launch.env ?? {}).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
+  return ["mcp", "add", "-s", "user", SERVER_NAME, ...env, "--", launch.command, ...launch.args];
+}
+function claudeCommandLine(launch) {
+  const q = (a) => /[\s"]/.test(a) ? `"${a.replaceAll('"', '\\"')}"` : a;
+  return ["claude", ...claudeAddArgs(launch)].map(q).join(" ");
+}
+async function planClaude(env, launch) {
+  const item = {
+    agent: "claude",
+    what: "mcp",
+    target: claudeCommandLine(launch)
+  };
+  if (!env.claude)
+    return {
+      ...item,
+      action: "skip",
+      note: "claude is not on PATH: run this command once it is installed"
+    };
+  const got = await env.claude(["mcp", "get", SERVER_NAME]);
+  if (got.code !== 0) return { ...item, action: "create" };
+  const same = got.out.includes(launch.command) && launch.args.every((a) => got.out.includes(a));
+  return { ...item, action: same ? "unchanged" : "update" };
+}
+async function writeClaude(env, launch) {
+  if (!env.claude) return;
+  if ((await env.claude(["mcp", "get", SERVER_NAME])).code === 0)
+    await env.claude(["mcp", "remove", SERVER_NAME, "-s", "user"]);
+  const r = await env.claude(claudeAddArgs(launch));
+  if (r.code !== 0) throw new Error(`claude mcp add failed: ${r.out.trim()}`);
+}
+async function removeClaude(env) {
+  if (!env.claude || (await env.claude(["mcp", "get", SERVER_NAME])).code !== 0) return false;
+  return (await env.claude(["mcp", "remove", SERVER_NAME, "-s", "user"])).code === 0;
+}
+function claudeRunner(path) {
+  const shim = /\.(cmd|bat)$/i.test(path);
+  return (args) => new Promise((done) => {
+    const quoted = shim ? args.map((a) => `"${a.replaceAll('"', '""')}"`) : args;
+    execFile(
+      shim ? `"${path}"` : path,
+      quoted,
+      { timeout: 3e4, windowsHide: true, shell: shim },
+      (err, stdout, stderr) => done({
+        code: err ? err.code ?? 1 : 0,
+        out: `${stdout}${stderr}`
+      })
+    );
+  });
+}
+function planMcp(agent, env, launch) {
+  return agent === "claude" ? planClaude(env, launch) : agent === "codex" ? planCodex(env, launch) : planJson(agent, env, launch);
+}
+async function planSetup(agents, scope, env, launch, skill) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const agent of agents) {
+    for (const dir of skillDirs(agent, scope, env)) {
+      if (seen.has(dir)) continue;
+      seen.add(dir);
+      const action = await planSkill(dir, skill);
+      const state = action === "update" ? await skillState(dir) : void 0;
+      items.push({
+        agent,
+        what: "skill",
+        target: dir,
+        action,
+        ...action === "skip" ? { note: "a folder of that name exists and is not ours; left as it is" } : {},
+        ...state?.edited.length ? { note: `you changed ${state.edited.join(", ")}; it will be replaced` } : {}
+      });
+    }
+    items.push(await planMcp(agent, env, launch));
+  }
+  return items;
+}
+async function applySetup(items, env, launch, skill) {
+  for (const item of items) {
+    if (item.action !== "create" && item.action !== "update") continue;
+    if (item.what === "skill") await writeSkill(item.target, skill);
+    else if (item.agent === "claude") await writeClaude(env, launch);
+    else if (item.agent === "codex") await writeCodex(env, launch);
+    else await writeJson(item.agent, env, launch);
+  }
+}
+async function removeSetup(agents, env) {
+  const removed = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const agent of agents) {
+    for (const scope of ["repo", "user"])
+      for (const dir of skillDirs(agent, scope, env)) {
+        if (seen.has(dir)) continue;
+        seen.add(dir);
+        if (await removeSkill(dir))
+          removed.push({ agent, what: "skill", target: dir, action: "remove" });
+      }
+    const gone = agent === "claude" ? await removeClaude(env) : agent === "codex" ? await removeCodex(env) : await removeJson(agent, env);
+    if (gone)
+      removed.push({ agent, what: "mcp", target: await mcpTarget(agent, env), action: "remove" });
+  }
+  return removed;
+}
+var claudeConfig = (env) => join(env.home, ".claude.json");
+var isServer = (a) => typeof a === "string" && /(^|[\\/])mcp\.js$/i.test(a);
+function entryServer(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return {};
+  const e = entry;
+  const words = Array.isArray(e.command) ? e.command : [e.command, ...Array.isArray(e.args) ? e.args : []];
+  const [command] = words;
+  const server = words.slice(1).find(isServer);
+  return {
+    ...typeof command === "string" ? { command } : {},
+    ...server ? { server } : {}
+  };
+}
+var parseOr = (text) => {
+  try {
+    return text === void 0 ? void 0 : JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+};
+async function registration(agent, env) {
+  const file = agent === "claude" ? claudeConfig(env) : await mcpTarget(agent, env);
+  const text = await readText(file);
+  if (!text?.includes(SERVER_NAME)) return void 0;
+  if (agent === "codex") {
+    if (handWritten(text)) return { agent, file, hand: true };
+    const { block } = splitBlock(text);
+    if (block === void 0) return void 0;
+    const command = parseOr(/^command = (".*")\s*$/m.exec(block)?.[1]);
+    const args = parseOr(/^args = (\[.*\])\s*$/m.exec(block)?.[1]);
+    return { agent, file, ...entryServer({ command, args }) };
+  }
+  let entry;
+  if (agent === "claude") {
+    const data = parseOr(text);
+    entry = data?.mcpServers?.[SERVER_NAME];
+  } else {
+    if (broken(text)) return void 0;
+    entry = current(text, JSON_MCP[agent].path);
+  }
+  return entry === void 0 ? void 0 : { agent, file, ...entryServer(entry) };
+}
+function storageId(server) {
+  return /[\\/]globalStorage[\\/]([^\\/]+)[\\/]mcp[\\/]mcp\.js$/i.exec(server)?.[1]?.toLowerCase();
+}
+async function staleRegistrations(agents, env, server) {
+  const ours = storageId(server);
+  const found = [];
+  for (const agent of agents) {
+    const r = await registration(agent, env);
+    if (!r?.server || r.hand) continue;
+    const id = storageId(r.server);
+    if (!id) continue;
+    if (!await exists(r.server)) found.push({ ...r, server: r.server, why: "missing" });
+    else if (ours && id !== ours) found.push({ ...r, server: r.server, why: "elsewhere" });
+  }
+  return found;
+}
+
+export {
+  AGENTS,
+  SERVER_NAME,
+  SKILL_NAME,
+  skillDirs,
+  skillState,
+  newerVersion,
+  planSkill,
+  writeSkill,
+  removeSkill,
+  codexConfig,
+  codexBlock,
+  planCodex,
+  writeCodex,
+  removeCodex,
+  CURSOR_WORKSPACE,
+  devinMcpFile,
+  mcpTarget,
+  planJson,
+  writeJson,
+  removeJson,
+  claudeAddArgs,
+  claudeCommandLine,
+  planClaude,
+  writeClaude,
+  removeClaude,
+  claudeRunner,
+  planMcp,
+  planSetup,
+  applySetup,
+  removeSetup,
+  claudeConfig,
+  entryServer,
+  registration,
+  storageId,
+  staleRegistrations
+};
+//# sourceMappingURL=chunk-2MZQHIXP.js.map