@wirecat/cli-template 0.9.0 → 0.11.0

package/dist/bundle/chunk-7IXL4UFK.js

@@ -0,0 +1,158 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  botInstructions
+} from "./chunk-CXQXVKUY.js";
+import {
+  answered,
+  normal,
+  registerCommands,
+  runCommandForAgent,
+  toolsFromCommands
+} from "./chunk-YJNUDHJD.js";
+import {
+  agentJson,
+  skillResource
+} from "./chunk-4LURWBVV.js";
+import {
+  callerOf,
+  serveStdio
+} from "./chunk-IBBN7Z3A.js";
+import {
+  wholeList
+} from "./chunk-FZZIU4B7.js";
+import {
+  McpServer
+} from "./chunk-5D4AEUVA.js";
+import {
+  MESSENGER_CHANGE_REFUSAL,
+  changesMessenger,
+  flatten,
+  itemOf,
+  readOnlyLockOf,
+  readOnlyRefusal
+} from "./chunk-QJ6XW4DM.js";
+import {
+  mcpErrorResult,
+  object
+} from "./chunk-EFHLQXG6.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/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
+};