@wirecat/mail-cli 0.0.0-stage → 0.1.1

package/dist/bundle/embed-LWNHIRBQ.js

@@ -0,0 +1,37 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  WARM_IDLE_MS,
+  defaultThreads,
+  isTextModelInstalled,
+  loadModel,
+  meanOf,
+  openEmbedder,
+  placedText,
+  runEmbedders,
+  textModelsDirectory,
+  truncated,
+  unit,
+  warmEmbedders
+} from "./chunk-Z34ICZA3.js";
+import "./chunk-5NYMNSSO.js";
+import "./chunk-FZ5FXIG6.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  WARM_IDLE_MS,
+  defaultThreads,
+  isTextModelInstalled,
+  loadModel,
+  meanOf,
+  openEmbedder,
+  placedText,
+  runEmbedders,
+  textModelsDirectory,
+  truncated,
+  unit,
+  warmEmbedders
+};

package/dist/bundle/embedder-2LYD3U37.js

@@ -0,0 +1,110 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  openSession,
+  truncated,
+  unit
+} from "./chunk-Z34ICZA3.js";
+import "./chunk-5NYMNSSO.js";
+import "./chunk-FZ5FXIG6.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/images/picture/embedder.js
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/images/picture/preprocess.js
+var SIZE = 224;
+var MEAN = [0.48145466, 0.4578275, 0.40821073];
+var STD = [0.26862954, 0.26130258, 0.27577711];
+var importCanvas = /* @__PURE__ */ __name(async () => {
+  try {
+    return await importFrom(new URL("images/picture/preprocess.js", import.meta.resolve("@wirecat/cli-core")).href, "@napi-rs/canvas");
+  } catch {
+    throw new CliError("validation_error", "searching pictures needs the optional package @napi-rs/canvas to read an image \u2014 install it next to this tool");
+  }
+}, "importCanvas");
+var preprocess = /* @__PURE__ */ __name(async (bytes, load = importCanvas) => {
+  const { createCanvas, loadImage } = await load();
+  let image;
+  try {
+    image = await loadImage(bytes);
+  } catch {
+    throw new CliError("invalid_response", "the file is not an image this tool can read");
+  }
+  const scale = SIZE / Math.min(image.width, image.height);
+  const width = Math.max(SIZE, Math.round(image.width * scale));
+  const height = Math.max(SIZE, Math.round(image.height * scale));
+  const surface = createCanvas(SIZE, SIZE);
+  const context = surface.getContext("2d");
+  context.fillStyle = "#ffffff";
+  context.fillRect(0, 0, SIZE, SIZE);
+  context.imageSmoothingQuality = "high";
+  context.drawImage(image, 0, 0, image.width, image.height, Math.round((SIZE - width) / 2), Math.round((SIZE - height) / 2), width, height);
+  const { data } = context.getImageData(0, 0, SIZE, SIZE);
+  const plane = SIZE * SIZE;
+  const pixels = new Float32Array(3 * plane);
+  for (let at = 0; at < plane; at++) {
+    for (let channel = 0; channel < 3; channel++) {
+      pixels[channel * plane + at] = (data[at * 4 + channel] / 255 - MEAN[channel]) / STD[channel];
+    }
+  }
+  return pixels;
+}, "preprocess");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/images/picture/embedder.js
+var openPictureEmbedder = /* @__PURE__ */ __name(async (model, directory, { threads = 4, canvas } = {}) => {
+  const { Tokenizer } = await importFrom(new URL("images/picture/embedder.js", import.meta.resolve("@wirecat/cli-core")).href, "@huggingface/tokenizers");
+  const path = /* @__PURE__ */ __name((name) => join(directory, model.id, name), "path");
+  const tokenizer = new Tokenizer(JSON.parse(readFileSync(path("tokenizer.json"), "utf8")), JSON.parse(readFileSync(path("tokenizer_config.json"), "utf8")));
+  const sessions = [];
+  const lazy = /* @__PURE__ */ __name((name) => {
+    let opened;
+    return () => {
+      opened ??= openSession(readFileSync(path(name)), threads).then((created) => {
+        sessions.push(created.session);
+        return created;
+      });
+      return opened;
+    };
+  }, "lazy");
+  const vision = lazy(model.vision);
+  const text = lazy(model.text);
+  return {
+    model,
+    embedImage: /* @__PURE__ */ __name(async (bytes) => {
+      const pixels = await preprocess(bytes, canvas);
+      const { ort, session } = await vision();
+      const output = await session.run({ pixel_values: new ort.Tensor("float32", pixels, [1, 3, SIZE, SIZE]) });
+      return unit(Float32Array.from(output.image_embeds?.data));
+    }, "embedImage"),
+    embedQuery: /* @__PURE__ */ __name(async (query) => {
+      const ids = truncated(tokenizer.encode(query.toLowerCase()).ids, model.maxTokens);
+      const shape = [1, ids.length];
+      const { ort, session } = await text();
+      const feeds = {
+        input_ids: new ort.Tensor("int64", BigInt64Array.from(ids, BigInt), shape)
+      };
+      if (session.inputNames.includes("attention_mask"))
+        feeds.attention_mask = new ort.Tensor("int64", new BigInt64Array(ids.length).fill(1n), shape);
+      const output = await session.run(feeds);
+      return unit(Float32Array.from(output.text_embeds?.data));
+    }, "embedQuery"),
+    close: /* @__PURE__ */ __name(async () => {
+      await Promise.all(sessions.map((session) => session.release()));
+    }, "close")
+  };
+}, "openPictureEmbedder");
+export {
+  openPictureEmbedder
+};

package/dist/bundle/failure-OAIC5VAP.js

@@ -0,0 +1,24 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  catchCrashes,
+  errorObjectOf,
+  errorRecordOf,
+  exitCodeOfAnswer,
+  exitCodeOfError,
+  mcpErrorResult,
+  renderError,
+  retryOf
+} from "./chunk-LQ37ALDJ.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  catchCrashes,
+  errorObjectOf,
+  errorRecordOf,
+  exitCodeOfAnswer,
+  exitCodeOfError,
+  mcpErrorResult,
+  renderError,
+  retryOf
+};

package/dist/bundle/first-run-N3HJKGU7.js

@@ -0,0 +1,27 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  askSetupQuestions,
+  asksAtStart,
+  setupAtStart,
+  systemLanguage
+} from "./chunk-IK5TH3O7.js";
+import "./chunk-ZD3WUGR2.js";
+import "./chunk-P7P5MNAU.js";
+import "./chunk-WLFLBWNH.js";
+import "./chunk-MNOIRJEO.js";
+import "./chunk-KHTO2Q6E.js";
+import "./chunk-QX7RCLRS.js";
+import "./chunk-D72URWJE.js";
+import "./chunk-FZ5FXIG6.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  askSetupQuestions,
+  asksAtStart,
+  setupAtStart,
+  systemLanguage
+};

package/dist/bundle/first-screen-4U2DMV3G.js

@@ -0,0 +1,32 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  WIRECAT_TOOLS,
+  firstScreen,
+  installHelp
+} from "./chunk-TWTATDM7.js";
+import "./chunk-MS53RALV.js";
+import "./chunk-TVREDYX4.js";
+import "./chunk-HTQTIKWP.js";
+import "./chunk-GQQJOH7A.js";
+import "./chunk-QLEUNU6G.js";
+import "./chunk-7SXGLT6T.js";
+import "./chunk-WLFLBWNH.js";
+import "./chunk-KM7Q67Z3.js";
+import "./chunk-6MAZWSC3.js";
+import "./chunk-3KEVLSNN.js";
+import "./chunk-UH4DDRHA.js";
+import "./chunk-NPGVOZVK.js";
+import "./chunk-KHTO2Q6E.js";
+import "./chunk-5NYMNSSO.js";
+import "./chunk-FZ5FXIG6.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  WIRECAT_TOOLS,
+  firstScreen,
+  installHelp
+};

package/dist/bundle/instructions-GJHHFV64.js

@@ -0,0 +1,11 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  appInstructions,
+  instructions
+} from "./chunk-TQFCPUIM.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  appInstructions,
+  instructions
+};

package/dist/bundle/mail.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  IDENTITY
+} from "./chunk-52F5DWS5.js";
+import {
+  installerOf
+} from "./chunk-QX7RCLRS.js";
+import {
+  DESCRIBE_FLAG,
+  DISPATCH_FLAG,
+  PROGRAM_PREFIX,
+  SHIM_FORMAT,
+  describeAnswer,
+  exists,
+  fileState,
+  shimFiles,
+  writeShim
+} from "./chunk-TI6VBZKJ.js";
+import "./chunk-J3QXTBD2.js";
+import {
+  catchCrashes
+} from "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/bin/mail.js
+import { enableCompileCache } from "node:module";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/start.js
+import { fileURLToPath } from "node:url";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/launcher.js
+import { readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+var posix = /* @__PURE__ */ __name((path) => path.replaceAll("\\", "/"), "posix");
+var pnpmHome = /* @__PURE__ */ __name((path, env) => {
+  const home = env.PNPM_HOME;
+  return home && path.startsWith(`${posix(home).replace(/\/+$/, "")}/`) ? home : void 0;
+}, "pnpmHome");
+var layoutFolders = /* @__PURE__ */ __name((script, env) => {
+  const path = posix(script);
+  const home = pnpmHome(path, env);
+  if (home)
+    return [join(home, "bin"), home];
+  switch (installerOf(script)) {
+    case "bun":
+      return [`${path.slice(0, path.indexOf("/install/global/node_modules/"))}/bin`];
+    case "npm": {
+      const root = path.slice(0, path.indexOf("/node_modules/"));
+      return [basename(root) === "lib" ? join(dirname(root), "bin") : root];
+    }
+    default:
+      return [];
+  }
+}, "layoutFolders");
+var binFolder = /* @__PURE__ */ __name(({ name, argv1, script, env, platform }) => {
+  if (!["npm", "pnpm", "bun"].includes(installerOf(script)) && !pnpmHome(posix(script), env))
+    return void 0;
+  const extensions = platform === "win32" ? [".cmd", ".exe"] : [""];
+  const candidates = [argv1 ? dirname(argv1) : void 0, ...layoutFolders(script, env)];
+  for (const dir of new Set(candidates)) {
+    if (dir === void 0 || basename(dir) === ".bin")
+      continue;
+    for (const extension of extensions) {
+      const program = `${PROGRAM_PREFIX}${name}${extension}`;
+      if (exists(join(dir, program)))
+        return { dir, program };
+    }
+  }
+  return void 0;
+}, "binFolder");
+var installed = /* @__PURE__ */ __name((dir, program) => {
+  if (!exists(join(dir, program)))
+    return false;
+  if (!program.toLowerCase().endsWith(".exe"))
+    return true;
+  let script;
+  try {
+    script = readFileSync(join(dir, `${program.slice(0, -4)}.bunx`)).toString("utf16le").split('"')[0] ?? "";
+  } catch {
+    return true;
+  }
+  if (script === "" || exists(resolve(dir, script)))
+    return true;
+  const at = posix(script).lastIndexOf("/install/global/node_modules/");
+  return at < 0 || exists(join(dirname(dir), posix(script).slice(at + 1)));
+}, "installed");
+var NAME = "wcat";
+var ensureLauncher = /* @__PURE__ */ __name(({ dir, program, platform }) => {
+  try {
+    const mine = shimFiles("launcher", { dir, name: NAME, target: program, platform });
+    const states = mine.map((file) => fileState(file.path));
+    if (states.some((one) => one.state === "foreign"))
+      return "foreign";
+    const ours = states.flatMap((one) => one.state === "ours" ? [one] : []);
+    if (ours.some(({ mark }) => mark.format > SHIM_FORMAT))
+      return "newer";
+    if (ours.some(({ mark }) => mark.kind !== "launcher"))
+      return "foreign";
+    const current = ours.find(({ mark }) => installed(dir, mark.target))?.mark.target;
+    const wanted = shimFiles("launcher", { dir, name: NAME, target: current ?? program, platform });
+    const stale = wanted.filter((file, at) => {
+      const state = states[at];
+      return state?.state !== "ours" || state.text !== file.text;
+    });
+    if (stale.length === 0)
+      return "kept";
+    for (const file of stale)
+      writeShim(file);
+    return "written";
+  } catch {
+    return "failed";
+  }
+}, "ensureLauncher");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/start.js
+var wcatStart = /* @__PURE__ */ __name(async (tool, io = {}) => {
+  const argv = io.argv ?? process.argv;
+  const env = io.env ?? process.env;
+  const platform = io.platform ?? process.platform;
+  const stdout = io.stdout ?? process.stdout;
+  const [first, ...rest] = argv.slice(2);
+  if (first === DESCRIBE_FLAG) {
+    stdout.write(`${JSON.stringify(describeAnswer(tool))}
+`);
+    return { code: 0 };
+  }
+  if (first === DISPATCH_FLAG) {
+    const { runWcat } = await import("./dispatch-EUKKT3PD.js");
+    const code = await runWcat(rest, { env, platform, stdout, stderr: io.stderr ?? process.stderr, self: tool });
+    return { code };
+  }
+  const folder = binFolder({
+    name: tool.command,
+    argv1: argv[1],
+    script: io.script ?? fileURLToPath(new URL("wcat/start.js", import.meta.resolve("@wirecat/cli-base")).href),
+    env,
+    platform
+  });
+  return folder ? { launcher: ensureLauncher({ ...folder, platform }) } : {};
+}, "wcatStart");
+
+// dist/bin/mail.js
+enableCompileCache();
+var wcat = await wcatStart({
+  command: IDENTITY.command,
+  version: IDENTITY.version,
+  description: IDENTITY.description,
+  docs: "https://github.com/WireCatLabs/mail-cli#readme"
+});
+if (wcat.code !== void 0) {
+  process.exitCode = wcat.code;
+} else {
+  const stopCatching = catchCrashes({ cli: IDENTITY.command, interactive: process.stdout.isTTY === true });
+  const { run } = await import("./program-JTJB26P3.js");
+  try {
+    process.exitCode = await run(process.argv.slice(2));
+  } finally {
+    stopCatching();
+  }
+}

package/dist/bundle/mcp-L7SRVDRN.js

@@ -0,0 +1,167 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  executableEnvironment,
+  executableOnPath
+} from "./chunk-P7P5MNAU.js";
+import {
+  require_cross_spawn
+} from "./chunk-D72URWJE.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/mcp/index.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+var realRun = /* @__PURE__ */ __name((file, args) => {
+  const result = import_cross_spawn.default.sync(executableOnPath(file, process.env), args, {
+    encoding: "utf8",
+    timeout: 1e4,
+    maxBuffer: 256e3,
+    env: executableEnvironment(process.env)
+  });
+  return { status: result.status, error: result.error, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}, "realRun");
+var executable = /* @__PURE__ */ __name((client) => client === "codex" ? "codex" : "claude", "executable");
+var presentIn = /* @__PURE__ */ __name((client, name, run) => {
+  const state = lookUp(client, name, run);
+  if (state === "unavailable")
+    throw new Error(`${executable(client)} is not installed or could not be started`);
+  return state === "registered";
+}, "presentIn");
+var setupArguments = /* @__PURE__ */ __name((client, name, entry) => {
+  const variables = Object.entries(entry.env ?? {}).flatMap(([key, value]) => ["--env", `${key}=${value}`]);
+  if (client === "codex")
+    return ["mcp", "add", name, ...variables, "--", entry.command, ...entry.args];
+  return ["mcp", "add", "--scope", "user", name, ...variables, "--", entry.command, ...entry.args];
+}, "setupArguments");
+var checkName = /* @__PURE__ */ __name((name) => {
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name))
+    throw new Error("the MCP name must be letters, digits, _ or -");
+}, "checkName");
+var lookUp = /* @__PURE__ */ __name((client, name, run) => {
+  const file = executable(client);
+  const existing = run(file, ["mcp", "get", name, ...client === "codex" ? ["--json"] : []]);
+  if (existing.error)
+    return "unavailable";
+  if (existing.status === 0)
+    return "registered";
+  if (!/No MCP server named/i.test(existing.stdout + existing.stderr)) {
+    throw new Error(`${file} could not check its MCP configuration`);
+  }
+  return "missing";
+}, "lookUp");
+var stdioEntryStatus = /* @__PURE__ */ __name((client, name, { run = realRun } = {}) => {
+  checkName(name);
+  return { client, name, state: lookUp(client, name, run) };
+}, "stdioEntryStatus");
+var removeArguments = /* @__PURE__ */ __name((client, name) => (
+  // Claude Code without a scope removes from whichever scope holds the name, which may be a project's own entry.
+  client === "codex" ? ["mcp", "remove", name] : ["mcp", "remove", "--scope", "user", name]
+), "removeArguments");
+var removeStdioEntry = /* @__PURE__ */ __name((client, name, { run = realRun } = {}) => {
+  checkName(name);
+  if (!presentIn(client, name, run))
+    return { client, name, removed: false };
+  const file = executable(client);
+  const removed = run(file, removeArguments(client, name));
+  if (removed.status !== 0 || removed.error)
+    throw new Error(`${file} could not remove ${name}`);
+  return { client, name, removed: true };
+}, "removeStdioEntry");
+var installStdioEntry = /* @__PURE__ */ __name((client, name, entry, { run = realRun } = {}) => {
+  checkName(name);
+  if (!entry.command || entry.args.some((arg) => arg.includes("\0")))
+    throw new Error("invalid MCP command");
+  const file = executable(client);
+  if (presentIn(client, name, run))
+    throw new Error(`${name} is already configured in ${file}; remove it there first`);
+  const args = setupArguments(client, name, entry);
+  const added = run(file, args);
+  if (added.status !== 0 || added.error)
+    throw new Error(`${file} could not add ${name}`);
+  return { client, name, command: [entry.command, ...entry.args] };
+}, "installStdioEntry");
+var probeStdio = /* @__PURE__ */ __name(async (entry, { timeoutMs = 1e4, start = /* @__PURE__ */ __name((file, args, env) => (0, import_cross_spawn.default)(executableOnPath(file, env), args, {
+  env: executableEnvironment(env),
+  stdio: "pipe"
+}), "start") } = {}) => {
+  const child = start(entry.command, entry.args, { ...process.env, ...entry.env });
+  let buffer = "";
+  let timer;
+  const pending = /* @__PURE__ */ new Map();
+  const request = /* @__PURE__ */ __name((id, method, params) => new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+  }), "request");
+  const fail = /* @__PURE__ */ __name((error) => {
+    for (const waiter of pending.values())
+      waiter.reject(error);
+    pending.clear();
+  }, "fail");
+  child.on("error", () => fail(new Error("the MCP server could not be started")));
+  child.on("exit", () => fail(new Error("the MCP server exited before answering")));
+  child.stdin.on("error", () => fail(new Error("the MCP server closed its input")));
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    if (buffer.length > 1e6)
+      return fail(new Error("the MCP server sent too much output"));
+    for (let newline = buffer.indexOf("\n"); newline !== -1; newline = buffer.indexOf("\n")) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      try {
+        const value = JSON.parse(line);
+        if (typeof value.id !== "number")
+          continue;
+        const waiter = pending.get(value.id);
+        if (!waiter)
+          continue;
+        pending.delete(value.id);
+        if (value.error)
+          waiter.reject(new Error("the MCP server rejected the handshake"));
+        else
+          waiter.resolve(value.result ?? {});
+      } catch {
+        fail(new Error("the MCP server sent invalid JSON"));
+      }
+    }
+  });
+  try {
+    timer = setTimeout(() => fail(new Error("the MCP server did not answer in time")), timeoutMs);
+    await request(1, "initialize", {
+      protocolVersion: "2025-11-25",
+      capabilities: {},
+      clientInfo: { name: "cli-base-mcp-doctor", version: "1" }
+    });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+    const result = await request(2, "tools/list", {});
+    const tools = result.tools;
+    if (!Array.isArray(tools))
+      throw new Error("the MCP server returned no tool list");
+    const named = tools.filter((item) => item !== null && typeof item === "object" && "name" in item && typeof item.name === "string");
+    if (named.length !== tools.length)
+      throw new Error("the MCP server returned an invalid tool list");
+    return {
+      tools: named.map((item) => item.name),
+      potentialWrites: named.filter((item) => item.annotations?.readOnlyHint !== true).map((item) => item.name)
+    };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    pending.clear();
+    child.stdin.end();
+    child.kill();
+  }
+}, "probeStdio");
+export {
+  installStdioEntry,
+  probeStdio,
+  removeArguments,
+  removeStdioEntry,
+  setupArguments,
+  stdioEntryStatus
+};