@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/all-profiles-TKMBELRZ.js

@@ -0,0 +1,286 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  answeredWire
+} from "./chunk-JBBZCTTF.js";
+import {
+  CALLER_META_KEY,
+  PROXY_CLIENT_NAME,
+  StdioServerTransport,
+  callerOf,
+  serveStdio
+} from "./chunk-VEIZZRQ5.js";
+import {
+  McpServer
+} from "./chunk-5D4AEUVA.js";
+import "./chunk-7SXGLT6T.js";
+import "./chunk-NPGVOZVK.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./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/mcp/all-profiles.js
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+var PROTOCOL = "2025-06-18";
+var START_MS = 3e4;
+var CHILD_IDLE_MS = 10 * 60 * 1e3;
+var startChild = /* @__PURE__ */ __name((spec, note, onExit) => {
+  const child = spawn(spec.command, spec.args, { env: spec.env, stdio: "pipe" });
+  const pending = /* @__PURE__ */ new Map();
+  let next = 1;
+  let buffer = "";
+  let gone;
+  const fail = /* @__PURE__ */ __name((error) => {
+    gone ??= error;
+    for (const waiter of pending.values())
+      waiter.reject(error);
+    pending.clear();
+  }, "fail");
+  child.on("error", () => fail(new Error("the profile's MCP server could not be started")));
+  child.on("exit", () => {
+    fail(new Error("the profile's MCP server stopped"));
+    onExit();
+  });
+  child.stdin.on("error", () => fail(new Error("the profile's MCP server closed its input")));
+  child.stderr.setEncoding("utf8");
+  let errors = "";
+  child.stderr.on("data", (chunk) => {
+    const lines = (errors + chunk).split("\n");
+    errors = lines.pop() ?? "";
+    for (const line of lines)
+      if (line.trim())
+        note(line);
+  });
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    for (let at = buffer.indexOf("\n"); at !== -1; at = buffer.indexOf("\n")) {
+      const line = buffer.slice(0, at);
+      buffer = buffer.slice(at + 1);
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (message.method !== void 0 && message.id !== void 0) {
+        send({ id: message.id, error: { code: -32601, message: "not offered through the all-profiles server" } });
+        continue;
+      }
+      if (typeof message.id !== "number")
+        continue;
+      const waiter = pending.get(message.id);
+      if (!waiter)
+        continue;
+      pending.delete(message.id);
+      if (message.error)
+        waiter.reject(new Error(message.error.message ?? "the profile's MCP server refused"));
+      else
+        waiter.resolve(message.result ?? {});
+    }
+  });
+  const send = /* @__PURE__ */ __name((message) => child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}
+`), "send");
+  const request = /* @__PURE__ */ __name((method, params) => new Promise((resolve, reject) => {
+    if (gone)
+      return reject(gone);
+    const id = next++;
+    pending.set(id, { resolve, reject });
+    send({ id, method, params });
+  }), "request");
+  const close = /* @__PURE__ */ __name(() => new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null)
+      return resolve();
+    child.once("exit", () => resolve());
+    child.stdin.end();
+  }), "close");
+  const timer = setTimeout(() => fail(new Error("the profile's MCP server did not answer in time")), START_MS);
+  return request("initialize", {
+    protocolVersion: PROTOCOL,
+    capabilities: {},
+    clientInfo: { name: PROXY_CLIENT_NAME, version: "1" }
+  }).then(() => {
+    send({ method: "notifications/initialized" });
+    return { request, close };
+  }).catch(async (error) => {
+    await close();
+    throw error;
+  }).finally(() => clearTimeout(timer));
+}, "startChild");
+var pool = /* @__PURE__ */ __name((options) => {
+  const idleMs = options.idleMs ?? CHILD_IDLE_MS;
+  const note = options.note ?? (() => {
+  });
+  const running = /* @__PURE__ */ new Map();
+  const forget = /* @__PURE__ */ __name((profile, child) => {
+    const one = running.get(profile);
+    if (one?.child !== child)
+      return;
+    clearTimeout(one.timer);
+    running.delete(profile);
+  }, "forget");
+  const use = /* @__PURE__ */ __name(async (profile, work) => {
+    let one = running.get(profile);
+    if (!one) {
+      const child = startChild(options.child(profile), (line) => note(`${profile}: ${line}`), () => forget(profile, child));
+      child.catch(() => forget(profile, child));
+      one = { child };
+      running.set(profile, one);
+    }
+    clearTimeout(one.timer);
+    const entry = one;
+    try {
+      return await work(await entry.child);
+    } finally {
+      if (running.get(profile) === entry) {
+        entry.timer = setTimeout(() => {
+          forget(profile, entry.child);
+          void entry.child.then((child) => child.close()).catch(() => void 0);
+        }, idleMs);
+        entry.timer.unref();
+      }
+    }
+  }, "use");
+  const close = /* @__PURE__ */ __name(async () => {
+    const all = [...running.values()];
+    running.clear();
+    for (const one of all)
+      clearTimeout(one.timer);
+    await Promise.all(all.map((one) => one.child.then((child) => child.close()).catch(() => void 0)));
+  }, "close");
+  return { use, close };
+}, "pool");
+var withProfile = /* @__PURE__ */ __name((tool, profiles, name, signedIn = () => true) => {
+  const schema = tool.inputSchema;
+  const out = profiles.filter((profile) => !signedIn(profile));
+  const states = out.length === 0 ? "" : ` Signed in: ${profiles.filter(signedIn).join(", ") || "none"} \xB7 Not signed in: ${out.join(", ")}.`;
+  return {
+    ...tool,
+    inputSchema: {
+      ...tool.inputSchema,
+      properties: {
+        profile: {
+          type: "string",
+          enum: [...profiles],
+          oneOf: profiles.map((profile) => ({
+            const: profile,
+            title: signedIn(profile) ? profile : `${profile} \u2014 not signed in`
+          })),
+          description: `Which ${name} account, by its profile. If the owner did not name one, ask which \u2014 never guess.${states}`
+        },
+        ...schema.properties
+      },
+      required: ["profile", ...(schema.required ?? []).filter((field) => field !== "profile")]
+    }
+  };
+}, "withProfile");
+var refusal = /* @__PURE__ */ __name((text) => ({
+  isError: true,
+  content: [{ type: "text", text }]
+}), "refusal");
+var allProfilesServer = /* @__PURE__ */ __name((options) => {
+  const children = pool(options);
+  let listed;
+  const tools = /* @__PURE__ */ __name((profiles) => {
+    listed ??= children.use(profiles.find(signedIn) ?? profiles[0], (child) => child.request("tools/list", {})).then((answer) => answer.tools ?? []);
+    listed.catch(() => {
+      listed = void 0;
+    });
+    return listed;
+  }, "tools");
+  const signedIn = /* @__PURE__ */ __name((profile) => options.signedIn?.(profile) ?? true, "signedIn");
+  const build = /* @__PURE__ */ __name(() => {
+    const profiles = [...options.profiles()].sort();
+    const server = new McpServer({ name: options.command, version: options.version }, { capabilities: { tools: {} }, instructions: options.instructions });
+    server.server.setRequestHandler("tools/list", async () => ({
+      tools: profiles.length === 0 ? [] : (await tools(profiles)).map((one) => withProfile(one, profiles, options.name, signedIn))
+    }));
+    const callers = {
+      env: options.env ?? process.env,
+      client: /* @__PURE__ */ __name(() => server.server.getClientVersion(), "client"),
+      connectionId: randomUUID()
+    };
+    server.server.setRequestHandler("tools/call", async (request, ctx) => {
+      const { name, arguments: given = {}, _meta } = request.params;
+      const { profile, ...rest } = given;
+      if (typeof profile !== "string" || !profiles.includes(profile))
+        return refusal(`${name} needs "profile", one of: ${profiles.join(", ")}. If the owner did not say which account, ask.`);
+      if (!signedIn(profile))
+        return refusal(options.signIn?.(profile) ?? `profile ${profile} is not signed in.`);
+      try {
+        return await children.use(profile, (child) => (
+          // Children are shared by every session, so each call names its own caller.
+          child.request("tools/call", {
+            name,
+            arguments: rest,
+            _meta: { ..._meta, [CALLER_META_KEY]: callerOf(ctx, name, callers) }
+          })
+        ));
+      } catch (error) {
+        return refusal(`profile ${profile}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    });
+    return server;
+  }, "build");
+  return { build, close: /* @__PURE__ */ __name(() => children.close(), "close") };
+}, "allProfilesServer");
+var serveAllProfilesOverStdio = /* @__PURE__ */ __name(async (options, io = {}) => {
+  const { build, close } = allProfilesServer(options);
+  const own = io.stdin !== void 0 && io.stdin !== process.stdin;
+  const wire = answeredWire(io.stdin ?? process.stdin, io.stdout ?? process.stdout);
+  const handle = serveStdio(build, {
+    transport: new StdioServerTransport(wire.input, wire.output),
+    onerror: /* @__PURE__ */ __name((error) => options.note?.(`mcp: ${error.message}`), "onerror")
+  });
+  const ended = await new Promise((resolve) => {
+    wire.ended.then(() => resolve("input"));
+    if (own)
+      io.signal?.addEventListener("abort", () => resolve("stopped"), { once: true });
+    else {
+      process.once("SIGINT", () => resolve("stopped"));
+      process.once("SIGTERM", () => resolve("stopped"));
+    }
+  });
+  try {
+    if (ended === "input")
+      await wire.answered();
+    wire.release();
+    await handle.close();
+  } finally {
+    await close();
+  }
+}, "serveAllProfilesOverStdio");
+var serveAllProfilesOverHttp = /* @__PURE__ */ __name(async (options, http) => {
+  const { build, close } = allProfilesServer(options);
+  const { serveOverHttp } = await import("./serve-ENPMIV6J.js");
+  const listening = await serveOverHttp(build, {
+    ...http,
+    appName: options.command,
+    onError: /* @__PURE__ */ __name((error) => options.note?.(`mcp: ${error.message}`), "onError")
+  }).catch(async (error) => {
+    await close();
+    throw error;
+  });
+  return {
+    url: listening.url,
+    close: /* @__PURE__ */ __name(async () => {
+      try {
+        await listening.close();
+      } finally {
+        await close();
+      }
+    }, "close")
+  };
+}, "serveAllProfilesOverHttp");
+export {
+  CHILD_IDLE_MS,
+  allProfilesServer,
+  serveAllProfilesOverHttp,
+  serveAllProfilesOverStdio,
+  withProfile
+};

package/dist/bundle/anthropic-7LMUAEIZ.js

@@ -0,0 +1,72 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  Anthropic
+} from "./chunk-XQUUANA2.js";
+import {
+  checkedOptions
+} from "./chunk-YO4CUH5E.js";
+import {
+  messagesFor,
+  systemFor
+} from "./chunk-J6MSJLIW.js";
+import "./chunk-J3QXTBD2.js";
+import {
+  array,
+  optional,
+  strictObject,
+  string
+} from "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./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/models/anthropic.js
+var options = strictObject({
+  stop_sequences: optional(array(string()))
+});
+var anthropic = {
+  images: true,
+  baseUrl: "https://api.anthropic.com",
+  validate: /* @__PURE__ */ __name((given) => checkedOptions("anthropic", options, given), "validate"),
+  complete: /* @__PURE__ */ __name(async (target, request, checked, apiKey, fetcher) => {
+    const client = new Anthropic({
+      apiKey: apiKey ?? "",
+      authToken: null,
+      fetch: /* @__PURE__ */ __name((input, init) => fetcher(input, { ...init, redirect: "error" }), "fetch"),
+      baseURL: target.baseUrl,
+      maxRetries: 0,
+      logLevel: "off",
+      timeout: 12e4
+    });
+    const response = await client.messages.stream({
+      ...checked,
+      model: target.model,
+      system: systemFor(request),
+      messages: [
+        ...messagesFor(request),
+        ...request.images === void 0 ? [] : [
+          {
+            role: "user",
+            content: request.images.map((image) => ({
+              type: "image",
+              source: { type: "base64", media_type: image.mimeType, data: image.data }
+            }))
+          }
+        ]
+      ],
+      max_tokens: request.maxTokens
+    }).finalMessage();
+    if (response.stop_reason !== "end_turn")
+      throw new Error("incomplete response");
+    return {
+      text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+      tokens: response.usage.input_tokens + response.usage.output_tokens + (response.usage.cache_creation_input_tokens ?? 0) + (response.usage.cache_read_input_tokens ?? 0)
+    };
+  }, "complete")
+};
+export {
+  anthropic
+};

package/dist/bundle/app-server-JGMIJDD4.js

@@ -0,0 +1,229 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  PER_RUN,
+  envelope
+} from "./chunk-GWDCKUBI.js";
+import {
+  answered,
+  failed,
+  registerCommands,
+  runCommandForAgent,
+  toolsFromCommands
+} from "./chunk-3KOA73LS.js";
+import {
+  mcpUrlOf
+} from "./chunk-CEW6KIFA.js";
+import {
+  agentJson,
+  skillResource
+} from "./chunk-K4FVKPDQ.js";
+import "./chunk-JVMVLITS.js";
+import {
+  appInstructions
+} from "./chunk-TQFCPUIM.js";
+import {
+  answeredWire
+} from "./chunk-JBBZCTTF.js";
+import {
+  StdioServerTransport,
+  serveStdio
+} from "./chunk-VEIZZRQ5.js";
+import {
+  McpServer
+} from "./chunk-5D4AEUVA.js";
+import "./chunk-3E3WA2L6.js";
+import "./chunk-T6464KYA.js";
+import "./chunk-75CWWETH.js";
+import "./chunk-WXAXYJJ7.js";
+import "./chunk-J6MSJLIW.js";
+import "./chunk-CH6RXYAX.js";
+import "./chunk-MS53RALV.js";
+import "./chunk-TVREDYX4.js";
+import {
+  DEFAULT_OUTPUT_BYTES,
+  changesAuthorityAt,
+  describeProgram,
+  environmentOf,
+  fetchesOnlyAt,
+  judgedTargets,
+  readOnlyLockOf,
+  rootOf2 as rootOf
+} from "./chunk-GQQJOH7A.js";
+import "./chunk-QLEUNU6G.js";
+import "./chunk-7SXGLT6T.js";
+import "./chunk-ZD3WUGR2.js";
+import "./chunk-P7P5MNAU.js";
+import "./chunk-WLFLBWNH.js";
+import {
+  mcpHttpMarker
+} from "./chunk-GN62YOT5.js";
+import "./chunk-TE5U5OAM.js";
+import "./chunk-KM7Q67Z3.js";
+import "./chunk-4E7BN3TC.js";
+import "./chunk-YPQQ5J4X.js";
+import "./chunk-6MAZWSC3.js";
+import "./chunk-NK7EB63L.js";
+import "./chunk-4FEMINO2.js";
+import "./chunk-3KEVLSNN.js";
+import "./chunk-UH4DDRHA.js";
+import "./chunk-NPGVOZVK.js";
+import "./chunk-MNOIRJEO.js";
+import "./chunk-KHTO2Q6E.js";
+import "./chunk-F6D6PJ34.js";
+import "./chunk-EOEDICIE.js";
+import "./chunk-QX7RCLRS.js";
+import "./chunk-D72URWJE.js";
+import "./chunk-Z34ICZA3.js";
+import "./chunk-5NYMNSSO.js";
+import "./chunk-FZ5FXIG6.js";
+import "./chunk-J3QXTBD2.js";
+import {
+  mcpErrorResult
+} from "./chunk-LQ37ALDJ.js";
+import "./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/mcp/app-server.js
+var EXCLUDED = [["mcp"]];
+var createAppServer = /* @__PURE__ */ __name((command, context, options) => {
+  const { app } = options;
+  const root = rootOf(command);
+  const environment = environmentOf(command);
+  if (!environment.runCommand)
+    throw new Error("the MCP server runs inside run(), which hands it the program");
+  const program = { run: environment.runCommand, commands: describeProgram(root) };
+  const flags = command.optsWithGlobals();
+  const overrides = flags.permission ?? [];
+  const { settings } = context;
+  const levels = /* @__PURE__ */ __name(() => options.resolveSettings(flags, { env: context.env }).permissions, "levels");
+  const readOnly = /* @__PURE__ */ __name(() => readOnlyLockOf(app, context.env) !== void 0, "readOnly");
+  const authority = changesAuthorityAt(root);
+  const targets = judgedTargets(root);
+  const passed = Object.fromEntries(Object.entries(environment).filter(([key]) => !PER_RUN.has(key)));
+  const tools = toolsFromCommands(program.commands, {
+    includeUnavailable: true,
+    exclude: EXCLUDED,
+    levels: settings.permissions,
+    currentLevels: levels,
+    readOnly: readOnly(),
+    authority,
+    fetchOnly: fetchesOnlyAt(root),
+    permissions: options.permissions
+  });
+  const availability = /* @__PURE__ */ __name((one) => () => {
+    const permitted = one.availability?.() ?? { available: true };
+    if (!permitted.available)
+      return permitted;
+    return options.availability?.(one.path, settings.profile) ?? permitted;
+  }, "availability");
+  const commands = Object.fromEntries(tools.map((one) => [
+    one.command,
+    {
+      title: one.title,
+      description: one.description,
+      writes: one.writes,
+      availability: availability(one),
+      input: one.input,
+      run: /* @__PURE__ */ __name(async (input, ctx) => {
+        const own = options.availability?.(one.path, settings.profile);
+        if (own && !own.available)
+          return failed(new CliError("permission_error", `${one.command}: ${own.reason ?? "unavailable for this profile"}`, {
+            ...own.permission ? { permission: own.permission } : {}
+          }), app.errors);
+        const traceparent = ctx?.mcpReq?._meta?.traceparent;
+        const env = typeof traceparent === "string" ? { ...context.env, TRACEPARENT: traceparent } : context.env;
+        const answer = await runCommandForAgent(program, one.path, input, {
+          profile: settings.profile,
+          readOnly: readOnly(),
+          env,
+          levels,
+          overrides,
+          authority,
+          permissions: options.permissions,
+          environment: passed
+        });
+        if ("error" in answer)
+          return mcpErrorResult(JSON.parse(agentJson(answer.error)));
+        try {
+          return answered(envelope(one.command, answer.result), DEFAULT_OUTPUT_BYTES, targets);
+        } catch (error) {
+          return failed(error, app.errors);
+        }
+      }, "run")
+    }
+  ]));
+  const skill = options.skill ? skillResource(app, options.skill) : void 0;
+  const build = /* @__PURE__ */ __name(() => {
+    const server = new McpServer({ name: app.command, version: app.version }, {
+      instructions: appInstructions({
+        command: app.command,
+        name: options.name,
+        profile: settings.profile,
+        untrusted: options.untrusted,
+        ...skill ? { skill: skill.instruction } : {}
+      })
+    });
+    registerCommands(server, app.command, commands, app.errors, void 0, app.messenger);
+    if (skill) {
+      const { uri, name, title, description, mimeType, read } = skill;
+      server.registerResource(name, uri, { title, description, mimeType }, read);
+    }
+    return server;
+  }, "build");
+  return { build, offered: Object.keys(commands) };
+}, "createAppServer");
+var serveAppOverStdio = /* @__PURE__ */ __name(async (command, context, options) => {
+  const { build } = createAppServer(command, context, options);
+  const { stdin, stdout, signal } = environmentOf(command);
+  const own = stdin && stdout && stdin !== process.stdin;
+  const wire = answeredWire(own ? stdin : process.stdin, own ? stdout : process.stdout);
+  const handle = serveStdio(build, {
+    transport: new StdioServerTransport(wire.input, wire.output),
+    onerror: /* @__PURE__ */ __name((error) => context.renderer.note(`mcp: ${error.message}`), "onerror")
+  });
+  const ended = await new Promise((resolve) => {
+    wire.ended.then(() => resolve("input"));
+    if (own)
+      signal?.addEventListener("abort", () => resolve("stopped"), { once: true });
+    else {
+      process.once("SIGINT", () => resolve("stopped"));
+      process.once("SIGTERM", () => resolve("stopped"));
+    }
+  });
+  if (ended === "input")
+    await wire.answered();
+  wire.release();
+  await handle.close();
+}, "serveAppOverStdio");
+var serveAppOverHttp = /* @__PURE__ */ __name(async (command, context, options, http) => {
+  const { app } = options;
+  const { build } = createAppServer(command, context, options);
+  const { serveOverHttp } = await import("./serve-ENPMIV6J.js");
+  const listening = await serveOverHttp(build, {
+    ...http,
+    appName: app.command,
+    onCode: /* @__PURE__ */ __name((code, expires) => context.renderer.note(context.env[mcpHttpMarker(app.envPrefix)] === void 0 ? `login code for a new browser app: ${code} (until ${expires.toTimeString().slice(0, 5)}; a new one after each login)` : `a new login code for a browser app: \`${app.command} ${context.settings.profile} mcp server status\``), "onCode"),
+    onError: /* @__PURE__ */ __name((error) => context.renderer.note(`mcp: ${error.message}`), "onError")
+  }).catch((error) => {
+    if (error.code === "EADDRINUSE")
+      throw new CliError("configuration_error", `port ${http.port} is in use \u2014 pass another with --port`);
+    throw error;
+  });
+  context.renderer.note(`serving on ${listening.url.href} \u2014 point your tunnel at it; connectors use ${mcpUrlOf(http.publicUrl).href}`);
+  await new Promise((resolve) => {
+    process.once("SIGINT", resolve);
+    process.once("SIGTERM", resolve);
+  });
+  await listening.close();
+}, "serveAppOverHttp");
+export {
+  createAppServer,
+  serveAppOverHttp,
+  serveAppOverStdio
+};