@michael-joseph-miller/ant-bot 0.1.4 → 0.2.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { createRequire as __antbotCreateRequire } from 'node:module';
 const require = __antbotCreateRequire(import.meta.url);
 import {
   SettingsSchema
-} from "./chunk-4XML2GPY.js";
+} from "./chunk-RMDMUCVS.js";
 
 // cli/src/index.ts
 import fs10 from "node:fs";
@@ -19,6 +19,7 @@ var KNOWN_COMMANDS = [
   "doctor",
   "open",
   "skill",
+  "connector",
   "backup",
   "restore",
   "update"
@@ -39,6 +40,7 @@ var COMMAND_FLAGS = {
   doctor: {},
   open: {},
   skill: {},
+  connector: {},
   backup: {
     out: { type: "string" }
   },
@@ -50,6 +52,7 @@ var COMMAND_FLAGS = {
     yes: { type: "boolean", default: false }
   }
 };
+var PASSTHROUGH_COMMANDS = /* @__PURE__ */ new Set(["connector"]);
 function isKnownCommand(value) {
   return KNOWN_COMMANDS.includes(value);
 }
@@ -87,6 +90,10 @@ Run "antbot --help" for usage.`);
       help = true;
       continue;
     }
+    if (PASSTHROUGH_COMMANDS.has(command)) {
+      positionals.push(tok);
+      continue;
+    }
     if (tok.startsWith("--")) {
       let name = tok.slice(2);
       let inlineValue;
@@ -142,6 +149,7 @@ Daemon:
 
 Data:
   skill <subcommand>   Manage the skills your bots can use
+  connector <subcmd>   Manage the MCP servers your bots can use
   backup [--out PATH]  Archive the database, config, skills, and bot memory
   restore <path>       Restore from a backup archive
 
@@ -256,6 +264,27 @@ live database handle and may be mid-turn.
 
 In a git checkout there is nothing for a package manager to update \u2014 use
 \`git pull && pnpm install\` instead.`,
+  connector: `antbot connector \u2014 manage the MCP servers your bots can use
+
+Usage: antbot connector <subcommand>
+
+  list                 Show every connector, with a warning for any missing secret
+  add <name> \u2026         Add one: --stdio "<cmd>" or --url <url>
+  enable|disable <n>   Turn one on or off for every bot at once
+  remove <name>        Delete it, and every bot's assignment to it
+  test <name>          Connect and list the tools it offers
+
+A connector is an MCP server registered once for the account and then assigned to
+individual bots in Bot settings \u2014 a bot with no assignment cannot see its tools at
+all. Its tools reach bots as \`mcp__<name>__<tool>\` and pass the permission gateway
+like any other tool, so the first call asks you for approval.
+
+Credentials stay in the keychain: write {{secret:NAME}} in any --env or --header
+value and the daemon substitutes it when the connector is mounted.
+
+  antbot connector add fs --stdio "npx -y @modelcontextprotocol/server-filesystem /tmp"
+  antbot connector add gh --url https://api.example.com/mcp \\
+    --header "Authorization=Bearer {{secret:GH_TOKEN}}"`,
   restore: `antbot restore \u2014 restore from a backup archive
 
 Usage: antbot restore <path> [--yes]
@@ -536,6 +565,16 @@ async function postJson(port, path12, body) {
     })
   );
 }
+async function patchJson(port, path12, body) {
+  return unwrap(
+    await fetch(`${BASE(port)}${path12}`, {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    })
+  );
+}
 async function deleteJson(port, path12) {
   return unwrap(
     await fetch(`${BASE(port)}${path12}`, { method: "DELETE", signal: AbortSignal.timeout(1e4) })
@@ -1160,6 +1199,190 @@ async function lintSkills(args) {
   return 0;
 }
 
+// cli/src/connector.ts
+function collectPairs(argv, flag) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== flag) continue;
+    const raw = argv[i + 1] ?? "";
+    const eq = raw.indexOf("=");
+    if (eq > 0) out[raw.slice(0, eq)] = raw.slice(eq + 1);
+    i++;
+  }
+  return out;
+}
+function flagValue(argv, flag) {
+  const i = argv.indexOf(flag);
+  return i >= 0 ? argv[i + 1] : void 0;
+}
+function splitCommand(input) {
+  const parts = input.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  const clean = parts.map(
+    (p) => p.startsWith('"') && p.endsWith('"') || p.startsWith("'") && p.endsWith("'") ? p.slice(1, -1) : p
+  );
+  return { command: clean[0] ?? "", args: clean.slice(1) };
+}
+function buildConfigFromFlags(argv) {
+  const stdio = flagValue(argv, "--stdio");
+  const url = flagValue(argv, "--url");
+  if (stdio && url) return { error: "Use either --stdio or --url, not both." };
+  if (stdio) {
+    const { command, args } = splitCommand(stdio);
+    if (!command) return { error: '--stdio needs a command, e.g. --stdio "npx -y @scope/server"' };
+    return { config: { transport: "stdio", command, args, env: collectPairs(argv, "--env") } };
+  }
+  if (url) {
+    const transport = flagValue(argv, "--transport") ?? "http";
+    if (transport !== "http" && transport !== "sse") return { error: "--transport must be http or sse" };
+    const tools = flagValue(argv, "--tools");
+    return {
+      config: {
+        transport,
+        url,
+        headers: collectPairs(argv, "--header"),
+        ...tools ? { tools: tools.split(",").map((t) => t.trim()).filter(Boolean) } : {}
+      }
+    };
+  }
+  return { error: 'Give either --stdio "<command>" or --url <url>.' };
+}
+var transportOf = (c) => String(c.config.transport ?? "?");
+async function findByName(port, name) {
+  return (await getJson(port, "/api/connectors")).find((c) => c.name === name);
+}
+async function runConnectorCommand(argv, port) {
+  const sub = argv[0];
+  const hint = () => {
+    console.error(dim("Subcommands: list, add, enable, disable, remove, test."));
+    console.error(dim("Run `antbot connector --help` for the full usage."));
+  };
+  if (!sub) {
+    console.error(red("antbot connector needs a subcommand."));
+    hint();
+    return 2;
+  }
+  let rows;
+  const load = async () => {
+    try {
+      rows = await getJson(port, "/api/connectors");
+      return true;
+    } catch (err) {
+      console.error(red(`Could not reach the daemon on port ${port}: ${err.message}`));
+      console.error(dim("Start it with `antbot start`."));
+      return false;
+    }
+  };
+  switch (sub) {
+    case "list": {
+      if (!await load()) return 1;
+      if (!rows.length) {
+        console.log(dim("No connectors yet. Add one with `antbot connector add`."));
+        return 0;
+      }
+      for (const c of rows) {
+        const state = c.enabled ? "" : dim(" (disabled)");
+        console.log(`${bold(c.name)}  ${dim(transportOf(c))}${state}`);
+        if (c.description) console.log(`  ${c.description}`);
+        if (c.missingSecrets.length) {
+          console.log(yellow(`  missing secret(s): ${c.missingSecrets.join(", ")} \u2014 this connector will not mount`));
+        }
+      }
+      return 0;
+    }
+    case "add": {
+      const name = argv[1];
+      if (!name || name.startsWith("--")) {
+        console.error(red('Usage: antbot connector add <name> (--stdio "<cmd>" | --url <url>)'));
+        return 2;
+      }
+      const built = buildConfigFromFlags(argv);
+      if ("error" in built) {
+        console.error(red(built.error));
+        return 2;
+      }
+      try {
+        const created = await postJson(port, "/api/connectors", {
+          name,
+          description: flagValue(argv, "--desc") ?? "",
+          config: built.config
+        });
+        console.log(green(`Added connector "${created.name}".`));
+        console.log(dim("Assign it to a bot in Bot settings, then `antbot connector test` to check it."));
+        return 0;
+      } catch (err) {
+        console.error(red(err.message));
+        return 1;
+      }
+    }
+    case "enable":
+    case "disable": {
+      const name = argv[1];
+      if (!name) {
+        console.error(red(`Usage: antbot connector ${sub} <name>`));
+        return 2;
+      }
+      if (!await load()) return 1;
+      const match = rows.find((c) => c.name === name);
+      if (!match) {
+        console.error(red(`No connector named "${name}".`));
+        return 1;
+      }
+      await patchJson(port, `/api/connectors/${match.id}`, { enabled: sub === "enable" });
+      console.log(green(`Connector "${name}" ${sub}d.`));
+      return 0;
+    }
+    case "remove": {
+      const name = argv[1];
+      if (!name) {
+        console.error(red("Usage: antbot connector remove <name>"));
+        return 2;
+      }
+      if (!await load()) return 1;
+      const match = rows.find((c) => c.name === name);
+      if (!match) {
+        console.error(red(`No connector named "${name}".`));
+        return 1;
+      }
+      await deleteJson(port, `/api/connectors/${match.id}`);
+      console.log(green(`Removed connector "${name}". Bot assignments for it are gone too.`));
+      return 0;
+    }
+    case "test": {
+      const name = argv[1];
+      if (!name) {
+        console.error(red("Usage: antbot connector test <name>"));
+        return 2;
+      }
+      let match;
+      try {
+        match = await findByName(port, name);
+      } catch (err) {
+        console.error(red(`Could not reach the daemon on port ${port}: ${err.message}`));
+        return 1;
+      }
+      if (!match) {
+        console.error(red(`No connector named "${name}".`));
+        return 1;
+      }
+      const result = await postJson(port, `/api/connectors/${match.id}/test`, {});
+      if (!result.ok) {
+        console.error(red(`${name}: ${result.error ?? "could not connect"}`));
+        return 1;
+      }
+      console.log(green(`${name}: connected, ${result.tools.length} tool(s)`));
+      for (const t of result.tools) {
+        console.log(`  ${bold(`mcp__${name}__${t.name}`)}`);
+        if (t.description) console.log(`    ${dim(t.description)}`);
+      }
+      return 0;
+    }
+    default:
+      console.error(red(`Unknown subcommand "${sub}".`));
+      hint();
+      return 2;
+  }
+}
+
 // cli/src/updateCommand.ts
 import fs9 from "node:fs";
 import path10 from "node:path";
@@ -1538,6 +1761,11 @@ async function main() {
       process.exit(await runSkillCommand(parsed.positionals, cfg.port));
       return;
     }
+    case "connector": {
+      const cfg = loadConfig();
+      process.exit(await runConnectorCommand(parsed.positionals, cfg.port));
+      return;
+    }
     case "backup":
       process.exit(await runBackupCommand(typeof parsed.flags.out === "string" ? parsed.flags.out : void 0));
       return;