@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/prompt-YKWAI222.js

@@ -0,0 +1,14 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  readSecret
+} from "./chunk-OTUOZ33L.js";
+import "./chunk-CH6RXYAX.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  readSecret
+};

package/dist/bundle/recognize-PAR66KVM.js

@@ -0,0 +1,25 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  SAMPLE_RATE,
+  decodeOgg,
+  detector,
+  loadSherpa,
+  openRecognizer,
+  openSpeechCutter,
+  toModelRate
+} from "./chunk-QQB7WT7R.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  SAMPLE_RATE,
+  decodeOgg,
+  detector,
+  loadSherpa,
+  openRecognizer,
+  openSpeechCutter,
+  toModelRate
+};

package/dist/bundle/remote-CE43TKXC.js

@@ -0,0 +1,28 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  DEFAULT_OPENAI_MODEL,
+  OPENAI_MODELS,
+  OPENAI_URL,
+  isLocal,
+  openRemote,
+  remoteKey,
+  remoteModel
+} from "./chunk-4E7BN3TC.js";
+import "./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 {
+  DEFAULT_OPENAI_MODEL,
+  OPENAI_MODELS,
+  OPENAI_URL,
+  isLocal,
+  openRemote,
+  remoteKey,
+  remoteModel
+};

package/dist/bundle/rerank-M7S7P2TW.js

@@ -0,0 +1,51 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  defaultThreads,
+  loadModel,
+  truncated
+} 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 {
+  __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/embeddings/rerank.js
+var openReranker = /* @__PURE__ */ __name(async (model, directory, { threads = defaultThreads() } = {}) => {
+  const { ort, tokenizer, session } = await loadModel(model, directory, threads);
+  const typeIds = session.inputNames.includes("token_type_ids");
+  const output = session.outputNames[0];
+  const one = /* @__PURE__ */ __name(async (question, passage) => {
+    const encoded = tokenizer.encode(question, { text_pair: passage, return_token_type_ids: true });
+    const ids = truncated(encoded.ids, model.maxTokens);
+    const shape = [1, ids.length];
+    const feeds = {
+      input_ids: new ort.Tensor("int64", BigInt64Array.from(ids, BigInt), shape),
+      attention_mask: new ort.Tensor("int64", new BigInt64Array(ids.length).fill(1n), shape)
+    };
+    if (typeIds)
+      feeds.token_type_ids = new ort.Tensor("int64", BigInt64Array.from(truncated(encoded.token_type_ids, model.maxTokens), BigInt), shape);
+    const logit = (await session.run(feeds))[output]?.data[0];
+    if (typeof logit !== "number" || !Number.isFinite(logit))
+      throw new Error(`${model.id} gave no score`);
+    return logit;
+  }, "one");
+  return {
+    model,
+    score: /* @__PURE__ */ __name(async (question, passages) => {
+      const scores = [];
+      for (const passage of passages)
+        scores.push(await one(question, passage));
+      return scores;
+    }, "score"),
+    close: /* @__PURE__ */ __name(() => session.release(), "close")
+  };
+}, "openReranker");
+export {
+  openReranker
+};

package/dist/bundle/serve-ENPMIV6J.js

@@ -0,0 +1,197 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  listen
+} from "./chunk-FDCGTODC.js";
+import {
+  ownerLogin
+} from "./chunk-BTQX2ZSZ.js";
+import {
+  WebStandardStreamableHTTPServerTransport,
+  createMcpHandler,
+  getOAuthProtectedResourceMetadataUrl,
+  hostHeaderValidationResponse,
+  isLegacyRequest,
+  oauthMetadataResponse,
+  requireBearerAuth
+} from "./chunk-5D4AEUVA.js";
+import {
+  activityRecorder,
+  calledTools,
+  httpActivityFile,
+  httpLock
+} from "./chunk-GN62YOT5.js";
+import "./chunk-TE5U5OAM.js";
+import "./chunk-KM7Q67Z3.js";
+import "./chunk-J3QXTBD2.js";
+import "./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/http/serve.js
+import { randomUUID } from "node:crypto";
+var MCP_PATH = "/mcp";
+var AS_METADATA = "/.well-known/oauth-authorization-server";
+var LOCAL = ["localhost", "127.0.0.1"];
+var MAX_SESSIONS = 20;
+var MAX_LOGIN_BODY = 64 * 1024;
+var SESSION_IDLE_MS = 60 * 60 * 1e3;
+var sessionMissing = /* @__PURE__ */ __name(() => new Response(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "Session not found" }, id: null }), {
+  status: 404,
+  headers: { "content-type": "application/json" }
+}), "sessionMissing");
+var legacySessions = /* @__PURE__ */ __name((build, now) => {
+  const sessions = /* @__PURE__ */ new Map();
+  const drop = /* @__PURE__ */ __name(async (id) => {
+    const one = sessions.get(id);
+    sessions.delete(id);
+    await one?.close();
+  }, "drop");
+  const handle = /* @__PURE__ */ __name(async (request, auth) => {
+    for (const [id2, one] of sessions)
+      if (now() - one.seen > SESSION_IDLE_MS)
+        await drop(id2);
+    const id = request.headers.get("mcp-session-id");
+    if (id) {
+      const known = sessions.get(id);
+      if (!known || known.clientId !== auth.clientId)
+        return sessionMissing();
+      known.seen = now();
+      return known.transport.handleRequest(request, { authInfo: auth });
+    }
+    const server = build();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: /* @__PURE__ */ __name(() => randomUUID(), "sessionIdGenerator"),
+      onsessionclosed: /* @__PURE__ */ __name((closed) => void sessions.delete(closed), "onsessionclosed")
+    });
+    await server.connect(transport);
+    const response = await transport.handleRequest(request, { authInfo: auth });
+    if (!transport.sessionId) {
+      await server.close();
+      return response;
+    }
+    sessions.set(transport.sessionId, { transport, close: /* @__PURE__ */ __name(() => server.close(), "close"), clientId: auth.clientId, seen: now() });
+    while (sessions.size > MAX_SESSIONS)
+      await drop(sessions.keys().next().value);
+    return response;
+  }, "handle");
+  return {
+    handle,
+    close: /* @__PURE__ */ __name(async () => {
+      for (const id of [...sessions.keys()])
+        await drop(id);
+    }, "close")
+  };
+}, "legacySessions");
+var metadataRequest = /* @__PURE__ */ __name((request, path, base) => {
+  const url = new URL(request.url);
+  const inserted = base && path === `${AS_METADATA}${base}`;
+  if (!inserted && url.pathname === path)
+    return request;
+  url.pathname = inserted ? AS_METADATA : path;
+  return new Request(url, { method: request.method, headers: request.headers });
+}, "metadataRequest");
+var toolsIn = /* @__PURE__ */ __name(async (request) => {
+  if (request.method !== "POST")
+    return [];
+  try {
+    return calledTools(await request.clone().json());
+  } catch {
+    return [];
+  }
+}, "toolsIn");
+var serveOverHttp = /* @__PURE__ */ __name(async (build, options) => {
+  const { publicUrl, port, tokenFile, appName, onCode, onError, now, lockFile, version } = options;
+  const lock = lockFile ? httpLock(lockFile, {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    port,
+    publicUrl: publicUrl.href,
+    ...version ? { version } : {}
+  }) : void 0;
+  if (lock?.held)
+    throw new CliError("validation_error", `${appName} already serves MCP over HTTP for this profile on port ${lock.held.port} (PID ${lock.held.pid}, since ${lock.held.startedAt})`);
+  const base = publicUrl.pathname === "/" ? "" : publicUrl.pathname.replace(/\/+$/, "");
+  const issuer = new URL(`${publicUrl.origin}${base}`);
+  const resource = new URL(`${base}${MCP_PATH}`, publicUrl.origin);
+  const mcpPath = resource.pathname;
+  const publicPath = /* @__PURE__ */ __name((path) => base && path !== base && !path.startsWith(`${base}/`) && !path.startsWith("/.well-known/") ? `${base}${path}` : path, "publicPath");
+  const login = ownerLogin({
+    issuer,
+    resource,
+    file: tokenFile,
+    appName,
+    onCode: /* @__PURE__ */ __name((code, expires) => {
+      lock?.update({ loginCode: code, loginCodeExpiresAt: expires.toISOString() });
+      onCode(code, expires);
+    }, "onCode"),
+    ...now ? { now } : {}
+  });
+  const insecure = issuer.protocol === "http:" && LOCAL.includes(issuer.hostname);
+  const mcp = createMcpHandler(build, { legacy: "reject", ...onError ? { onerror: onError } : {} });
+  const legacy = legacySessions(build, now ?? Date.now);
+  const bearer = requireBearerAuth({
+    verifier: login.verifier,
+    resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource)
+  });
+  const activity = activityRecorder(httpActivityFile(tokenFile), now);
+  const allowedHosts = [.../* @__PURE__ */ new Set([publicUrl.hostname, ...LOCAL])];
+  const allowedOrigins = [publicUrl.origin];
+  const listening = await listen(async (request) => {
+    const refused = hostHeaderValidationResponse(request, allowedHosts);
+    if (refused)
+      return refused;
+    const path = publicPath(new URL(request.url).pathname);
+    const discovery = oauthMetadataResponse(metadataRequest(request, path, base), {
+      oauthMetadata: login.metadata,
+      resourceServerUrl: resource,
+      resourceName: appName,
+      ...insecure ? { dangerouslyAllowInsecureIssuerUrl: true } : {}
+    });
+    if (discovery)
+      return discovery;
+    if (Number(request.headers.get("content-length") ?? 0) > MAX_LOGIN_BODY && path !== mcpPath)
+      return new Response("Request too large", { status: 413 });
+    const origin = request.headers.get("origin");
+    if (origin && !allowedOrigins.includes(origin))
+      return new Response("Origin not allowed", { status: 403 });
+    const answered = await login.handle(request, path);
+    if (answered)
+      return answered;
+    if (path !== mcpPath)
+      return new Response("Not found", { status: 404 });
+    const auth = await bearer(request);
+    if (auth instanceof Response)
+      return auth;
+    activity.record(auth.clientId, await toolsIn(request));
+    return await isLegacyRequest(request) ? legacy.handle(request, auth) : mcp.fetch(request, { authInfo: auth });
+  }, { host: "127.0.0.1", port }).catch((error) => {
+    login.close();
+    lock?.release();
+    throw error;
+  });
+  lock?.update({ listeningAt: (/* @__PURE__ */ new Date()).toISOString() });
+  return {
+    url: listening.url,
+    close: /* @__PURE__ */ __name(async () => {
+      login.close();
+      activity.flush();
+      try {
+        await listening.close();
+        await legacy.close();
+        await mcp.close();
+      } finally {
+        lock?.release();
+      }
+    }, "close")
+  };
+}, "serveOverHttp");
+export {
+  MCP_PATH,
+  serveOverHttp
+};

package/dist/bundle/server-JRTHUCVY.js

@@ -0,0 +1,63 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  PER_RUN,
+  createServer,
+  envelope,
+  serveOverHttpUntilStopped,
+  serveOverStdio
+} from "./chunk-GWDCKUBI.js";
+import "./chunk-3KOA73LS.js";
+import "./chunk-CEW6KIFA.js";
+import "./chunk-K4FVKPDQ.js";
+import "./chunk-JVMVLITS.js";
+import "./chunk-TQFCPUIM.js";
+import "./chunk-JBBZCTTF.js";
+import "./chunk-VEIZZRQ5.js";
+import "./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 "./chunk-GQQJOH7A.js";
+import "./chunk-QLEUNU6G.js";
+import "./chunk-7SXGLT6T.js";
+import "./chunk-ZD3WUGR2.js";
+import "./chunk-P7P5MNAU.js";
+import "./chunk-WLFLBWNH.js";
+import "./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 "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  PER_RUN,
+  createServer,
+  envelope,
+  serveOverHttpUntilStopped,
+  serveOverStdio
+};

package/dist/bundle/server-MBEZLVKZ.js

@@ -0,0 +1,189 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  botInstructions
+} from "./chunk-2LLNPNMB.js";
+import {
+  answered,
+  normal,
+  registerCommands,
+  runCommandForAgent,
+  toolsFromCommands
+} from "./chunk-3KOA73LS.js";
+import {
+  agentJson,
+  skillResource
+} from "./chunk-K4FVKPDQ.js";
+import "./chunk-JVMVLITS.js";
+import {
+  callerOf,
+  serveStdio
+} from "./chunk-VEIZZRQ5.js";
+import {
+  McpServer
+} from "./chunk-5D4AEUVA.js";
+import {
+  wholeList
+} from "./chunk-T6464KYA.js";
+import "./chunk-75CWWETH.js";
+import "./chunk-WXAXYJJ7.js";
+import "./chunk-J6MSJLIW.js";
+import "./chunk-CH6RXYAX.js";
+import "./chunk-TVREDYX4.js";
+import {
+  MESSENGER_CHANGE_REFUSAL,
+  changesMessenger,
+  flatten,
+  itemOf,
+  readOnlyLockOf,
+  readOnlyRefusal
+} 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 "./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,
+  object
+} 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/mcp/bot/server.js
+import { randomUUID } from "node:crypto";
+var body = /* @__PURE__ */ __name((command, value) => Array.isArray(value) ? wholeList(`bot ${command}`, value) : value !== null && typeof value === "object" && ("item" in value || "items" in value) ? value : itemOf(value !== null && typeof value === "object" ? value : { value }), "body");
+var createBotServer = /* @__PURE__ */ __name((options) => {
+  const { bot, program, settings, env } = options;
+  const command = bot.app.command;
+  const levels = options.levels ?? (() => settings.permissions);
+  const authority = /* @__PURE__ */ __name((path) => options.authority?.(path) === true || path[0] === "config" && (path[1] === "set" || path[1] === "unset"), "authority");
+  const catalogue = {
+    includeUnavailable: true,
+    levels: settings.permissions,
+    currentLevels: levels,
+    readOnly: readOnlyLockOf(bot.app, env) !== void 0,
+    ...options.keyOf ? { keyOf: options.keyOf } : {},
+    authority,
+    ...options.fetchOnly ? { fetchOnly: options.fetchOnly } : {},
+    offline: true,
+    // Another bot's copy is this bot's to read only where `read_other_bots` says so.
+    ...settings.readOtherBots ? {} : { omit: ["all_bots", "bots"] }
+  };
+  const tools = [
+    ...toolsFromCommands(program.commands, { ...catalogue, root: ["bot"] }),
+    ...toolsFromCommands(program.commands.filter((one) => one.path[0] === "config"), {
+      ...catalogue,
+      omit: ["bot", "personal", "defaults"]
+    })
+  ];
+  const writes = tools.filter((tool) => tool.writes && tool.availability?.().available !== false).map((tool) => tool.command);
+  const skill = options.skill ? skillResource(bot.app, options.skill) : void 0;
+  let queue = Promise.resolve();
+  const invoke = /* @__PURE__ */ __name((path, input, caller) => {
+    const next = queue.then(() => runCommandForAgent(program, path, path[0] === "config" ? { ...input, bot: true } : input, {
+      profile: settings.profile,
+      readOnly: readOnlyLockOf(bot.app, env) !== void 0,
+      env,
+      levels,
+      ...options.keyOf ? { keyOf: options.keyOf } : {},
+      authority,
+      ...caller ? { caller } : {}
+    }));
+    queue = next.catch(() => void 0);
+    return next;
+  }, "invoke");
+  const build = /* @__PURE__ */ __name(() => {
+    const callers = { env, client: /* @__PURE__ */ __name(() => server.server.getClientVersion(), "client"), connectionId: randomUUID() };
+    const server = new McpServer({ name: `${command}-bot-${settings.profile}`, version: bot.app.version }, {
+      instructions: botInstructions({
+        command,
+        name: bot.name ?? command,
+        profile: settings.profile,
+        writes,
+        ...skill ? { skill: skill.instruction } : {}
+      })
+    });
+    if (skill) {
+      const { uri, name, title, description, mimeType, read } = skill;
+      server.registerResource(name, uri, { title, description, mimeType }, read);
+    }
+    const commands = Object.fromEntries(tools.map((tool) => [
+      tool.command,
+      {
+        title: tool.title,
+        description: tool.description,
+        writes: tool.writes,
+        availability: tool.availability,
+        input: tool.input,
+        run: /* @__PURE__ */ __name(async (args, ctx) => {
+          const caller = callerOf(ctx, `${command}_${tool.command.replaceAll(" ", "_")}`, callers);
+          const answer = await invoke(tool.path, args, caller);
+          return "error" in answer ? mcpErrorResult(JSON.parse(agentJson(answer.error))) : answered(body(tool.command, answer.result));
+        }, "run")
+      }
+    ]));
+    commands.status = {
+      title: "This server's bot and profile",
+      description: "Which profile this server speaks for, where its bot token comes from, which bot it is, and which writing commands are on. Sends nothing.",
+      writes: false,
+      input: object({}),
+      run: /* @__PURE__ */ __name(async () => {
+        const auth = await invoke(["bot", "auth", "show"], {});
+        const shown = "error" in auth ? auth.error : auth.result?.item ?? auth.result;
+        return answered(itemOf({
+          profile: settings.profile,
+          kind: "bot",
+          auth: shown,
+          writes: tools.filter((tool) => tool.writes && tool.availability?.().available !== false).map((tool) => tool.command),
+          permissions: levels()
+        }));
+      }, "run")
+    };
+    registerCommands(server, `${command}_bot`, commands, void 0, (asked) => {
+      const lock = readOnlyLockOf(bot.app, env);
+      const one = flatten(program.commands).find((info) => info.path[0] === "bot" && normal(info.path.slice(1).join(" ")) === asked);
+      if (lock && one && changesMessenger(one))
+        throw readOnlyRefusal(lock, MESSENGER_CHANGE_REFUSAL);
+    }, bot.app.messenger);
+    return server;
+  }, "build");
+  return { build, tools, offered: tools.map((tool) => tool.command) };
+}, "createBotServer");
+var serveBotOverStdio = /* @__PURE__ */ __name(async (options, note) => {
+  const { build } = createBotServer(options);
+  const handle = serveStdio(build, { onerror: /* @__PURE__ */ __name((error) => note(`mcp: ${error.message}`), "onerror") });
+  await new Promise((resolve) => {
+    process.stdin.once("end", resolve);
+    process.stdin.once("close", resolve);
+    process.once("SIGINT", resolve);
+    process.once("SIGTERM", resolve);
+  });
+  await handle.close();
+}, "serveBotOverStdio");
+export {
+  createBotServer,
+  serveBotOverStdio
+};

package/dist/bundle/sqlite-runtime-HVGDHBJJ.js

@@ -0,0 +1,18 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  ensureSqlite,
+  nodeRuntime,
+  relay
+} from "./chunk-TWPDVUBR.js";
+import "./chunk-F6D6PJ34.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  ensureSqlite,
+  nodeRuntime,
+  relay
+};

package/dist/bundle/state-QZSOSKBD.js

@@ -0,0 +1,35 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  ACCESS_SECONDS,
+  REFRESH_SECONDS,
+  httpLaunchFile,
+  httpLock,
+  httpLockFile,
+  httpLogFile,
+  mcpHttpMarker,
+  readHttpLaunch,
+  readHttpLock,
+  readStored,
+  signedInClients
+} from "./chunk-GN62YOT5.js";
+import "./chunk-TE5U5OAM.js";
+import "./chunk-KM7Q67Z3.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  ACCESS_SECONDS,
+  REFRESH_SECONDS,
+  httpLaunchFile,
+  httpLock,
+  httpLockFile,
+  httpLogFile,
+  mcpHttpMarker,
+  readHttpLaunch,
+  readHttpLock,
+  readStored,
+  signedInClients
+};