@michael-joseph-miller/ant-bot 0.3.1 → 0.4.0

package/dist/server.js

@@ -18,7 +18,7 @@ import {
   SettingsSchema,
   UpdateBotRequest,
   UpdateConnectorRequest
-} from "./chunk-I3GHIX3G.js";
+} from "./chunk-BKF7CUVN.js";
 import {
   findWebDist,
   nodeLocateDeps,
@@ -38,7 +38,7 @@ import {
 
 // daemon/src/api/server.ts
 import path11 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { createRequire } from "node:module";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
@@ -47,6 +47,7 @@ import websocket from "@fastify/websocket";
 import fastifyStatic from "@fastify/static";
 
 // daemon/src/app.ts
+import fs8 from "node:fs";
 import path8 from "node:path";
 
 // daemon/src/db/db.ts
@@ -184,6 +185,19 @@ CREATE TABLE bot_connectors (
   enabled INTEGER NOT NULL DEFAULT 1,
   PRIMARY KEY (bot_id, connector_id)
 );
+`
+  },
+  {
+    version: 3,
+    name: "connector-kind-and-health",
+    // Built-in connectors (served by the daemon) alongside custom ones, and the last verdict a
+    // check or a turn reached — so the screen shows a connector's real state instead of a toast
+    // that has already vanished.
+    up: `
+ALTER TABLE connectors ADD COLUMN kind TEXT NOT NULL DEFAULT 'custom';
+ALTER TABLE connectors ADD COLUMN last_status TEXT;
+ALTER TABLE connectors ADD COLUMN last_error TEXT;
+ALTER TABLE connectors ADD COLUMN checked_at INTEGER;
 `
   }
 ];
@@ -257,10 +271,10 @@ function migrate(db, opts = {}) {
     });
     try {
       run();
-    } catch (err) {
+    } catch (err2) {
       throw new MigrationError(
         "MIGRATION_FAILED",
-        `migration ${m.version} (${m.name}) failed: ${err.message}` + (backupPath ? `. The pre-migration database was saved to ${backupPath}` : "")
+        `migration ${m.version} (${m.name}) failed: ${err2.message}` + (backupPath ? `. The pre-migration database was saved to ${backupPath}` : "")
       );
     }
     applied.push({ version: m.version, name: m.name });
@@ -365,8 +379,12 @@ var toConnector = (r) => ({
   id: r.id,
   name: r.name,
   description: r.description,
+  kind: r.kind === "builtin" ? "builtin" : "custom",
   config: ConnectorConfigSchema.parse(JSON.parse(r.config_json)),
   enabled: b(r.enabled),
+  lastStatus: r.last_status ?? null,
+  lastError: r.last_error ?? null,
+  checkedAt: r.checked_at ?? null,
   createdAt: r.created_at
 });
 var toRoutine = (r) => ({
@@ -756,10 +774,17 @@ var Store = class {
   createConnector(c) {
     const id = newId();
     this.db.prepare(
-      `INSERT INTO connectors (id,name,description,config_json,enabled,created_at) VALUES (?,?,?,?,?,?)`
-    ).run(id, c.name, c.description ?? "", JSON.stringify(c.config), i(c.enabled, true), now());
+      `INSERT INTO connectors (id,name,description,config_json,enabled,kind,created_at) VALUES (?,?,?,?,?,?,?)`
+    ).run(id, c.name, c.description ?? "", JSON.stringify(c.config), i(c.enabled, true), c.kind ?? "custom", now());
     return this.getConnector(id);
   }
+  /** Record the latest verdict. Written by both `check` and the turn's own mount report. */
+  setConnectorStatus(id, status, error = null) {
+    this.db.prepare(`UPDATE connectors SET last_status=?, last_error=?, checked_at=? WHERE id=?`).run(status, error, now(), id);
+  }
+  setConnectorStatusByName(name, status, error = null) {
+    this.db.prepare(`UPDATE connectors SET last_status=?, last_error=?, checked_at=? WHERE name=?`).run(status, error, now(), name);
+  }
   getConnector(id) {
     const r = this.db.prepare(`SELECT * FROM connectors WHERE id=?`).get(id);
     return r ? toConnector(r) : null;
@@ -1042,7 +1067,12 @@ var BUILTIN_RULES = [
   { kind: "allow", toolPattern: "Glob", inputPattern: "", scopeNote: "Listing files is safe", builtin: true, enabled: true },
   { kind: "allow", toolPattern: "Grep", inputPattern: "", scopeNote: "Searching files is safe", builtin: true, enabled: true },
   { kind: "allow", toolPattern: "TodoWrite", inputPattern: "", scopeNote: "Planning scratchpad", builtin: true, enabled: true },
-  { kind: "allow", toolPattern: "Bash", inputPattern: "^\\s*(git\\s+(status|diff|log|show|branch)|ls|pwd|cat|head|tail|wc|echo|date|which|grep|find|rg)\\b", scopeNote: "Read-only shell inspection", builtin: true, enabled: true }
+  { kind: "allow", toolPattern: "Bash", inputPattern: "^\\s*(git\\s+(status|diff|log|show|branch)|ls|pwd|cat|head|tail|wc|echo|date|which|grep|find|rg)\\b", scopeNote: "Read-only shell inspection", builtin: true, enabled: true },
+  // The one place a seeded `mcp__*` rule is right: these tool names are ant-bot's own (the gmail
+  // connector is served by the daemon), fixed, and fully qualified — so they cannot match a
+  // third-party server's tool by alias, and they are the two Gmail actions that leave the machine.
+  { kind: "require", toolPattern: "mcp__gmail__send_message", inputPattern: "", scopeNote: "Sending email", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "mcp__gmail__create_draft", inputPattern: "", scopeNote: "Creating an email draft", builtin: true, enabled: true }
 ];
 function seedBuiltinRules(store) {
   const key = (r) => `${r.kind}\0${r.toolPattern}\0${r.inputPattern}`;
@@ -1183,8 +1213,8 @@ var PermissionGateway = class {
         if (verdict.verdict === "deny_suggested")
           return this.askHuman({ ...args, reason: `Auto review flagged this: ${verdict.reason}` });
         return this.askHuman({ ...args, reason: verdict.reason });
-      } catch (err) {
-        log3.warn("auto review failed; falling back to human approval", err);
+      } catch (err2) {
+        log3.warn("auto review failed; falling back to human approval", err2);
       }
     }
     return this.askHuman({
@@ -1293,6 +1323,18 @@ import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
 // daemon/src/agent/session.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// daemon/src/agent/runtime.ts
+var ClaudeRuntime = class {
+  name = "claude";
+  mountConnectors(connectors) {
+    const out = {};
+    for (const [name, c] of Object.entries(connectors)) out[name] = { ...c, alwaysLoad: true };
+    return out;
+  }
+};
+
+// daemon/src/agent/session.ts
 var log4 = logger("agent");
 function resolveModel(tier) {
   return tier;
@@ -1305,6 +1347,7 @@ function buildEnv(settings, base = process.env) {
   }
   return env;
 }
+var runtime = new ClaudeRuntime();
 async function* runTurn(req) {
   const abort = req.abortController ?? new AbortController();
   const options = {
@@ -1316,7 +1359,14 @@ async function* runTurn(req) {
     includePartialMessages: true,
     permissionMode: "default",
     canUseTool: req.canUseTool,
-    mcpServers: req.mcpServers,
+    mcpServers: {
+      ...req.mcpServers ?? {},
+      ...runtime.mountConnectors(req.connectors ?? {})
+    },
+    // ant-bot is the MCP host. The SDK mounts exactly what is passed here and nothing else — not
+    // ~/.claude.json, not plugins, not claude.ai connectors. A bot's tools cannot change because
+    // of something configured outside ant-bot, and swapping the runtime later swaps only this.
+    strictMcpConfig: true,
     env: buildEnv(req.settings),
     // Do not inherit the user's own Claude Code project settings into bot turns.
     settingSources: [],
@@ -1324,23 +1374,40 @@ async function* runTurn(req) {
   };
   if (req.resumeSessionId) options.resume = req.resumeSessionId;
   if (req.skillPluginPath) {
-    options.plugins = [{ type: "local", path: req.skillPluginPath }];
+    options.plugins = [{ type: "local", path: req.skillPluginPath, skipMcpDiscovery: true }];
     options.skills = req.enabledSkills ?? [];
   }
+  const pending = [];
+  options.onElicitation = async (request) => {
+    if (request.mode === "url" && request.url) {
+      pending.push({ kind: "signin", signin: { serverName: request.serverName, url: request.url } });
+      return { action: "accept" };
+    }
+    log4.warn(`declined a ${request.mode ?? "form"} elicitation from "${request.serverName}": ${request.message}`);
+    return { action: "decline" };
+  };
   let q;
   try {
     q = query({ prompt: req.prompt, options });
-  } catch (err) {
-    yield { kind: "error", message: err instanceof Error ? err.message : String(err) };
+  } catch (err2) {
+    yield { kind: "error", message: err2 instanceof Error ? err2.message : String(err2) };
     return;
   }
   const seenToolIds = /* @__PURE__ */ new Set();
   try {
     for await (const msg of q) {
+      while (pending.length) yield pending.shift();
       const m = msg;
       switch (m.type) {
         case "system":
           if (m.subtype === "init" && m.session_id) yield { kind: "session", sessionId: m.session_id };
+          if (m.subtype === "elicitation_complete" && typeof m.mcp_server_name === "string") {
+            try {
+              await q.reconnectMcpServer(m.mcp_server_name);
+            } catch (err2) {
+              log4.warn(`reconnect of "${m.mcp_server_name}" after sign-in failed: ${err2.message}`);
+            }
+          }
           if (m.subtype === "init" && Array.isArray(m.mcp_servers)) {
             yield { kind: "mcp_status", mcpStatus: m.mcp_servers };
           }
@@ -1395,13 +1462,13 @@ async function* runTurn(req) {
           break;
       }
     }
-  } catch (err) {
+  } catch (err2) {
     if (abort.signal.aborted) {
       yield { kind: "error", message: "Interrupted." };
       return;
     }
-    log4.error("turn failed", err);
-    yield { kind: "error", message: err instanceof Error ? err.message : String(err) };
+    log4.error("turn failed", err2);
+    yield { kind: "error", message: err2 instanceof Error ? err2.message : String(err2) };
   }
 }
 
@@ -1484,8 +1551,8 @@ var NullAutoReviewer = class {
 function makeAutoReviewer(getSettings, cwd) {
   try {
     return new HaikuAutoReviewer(getSettings, cwd);
-  } catch (err) {
-    log5.warn("falling back to null reviewer", err);
+  } catch (err2) {
+    log5.warn("falling back to null reviewer", err2);
     return new NullAutoReviewer();
   }
 }
@@ -1748,8 +1815,8 @@ ${lines.join("\n")}` }] };
                   text: `Installed: ${names}.${note} A skill must still be assigned to you in Bot settings before you can invoke it \u2014 ask the human to enable it, then retry.`
                 }]
               };
-            } catch (err) {
-              const e = err;
+            } catch (err2) {
+              const e = err2;
               if (e.name === "MultipleSkillsError" && Array.isArray(e.names)) {
                 const listed = e.names.slice(0, 40).join(", ");
                 const more = e.names.length > 40 ? `, and ${e.names.length - 40} more` : "";
@@ -1782,8 +1849,8 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
                 return { content: [{ type: "text", text: `No skill with slug "${args.slug}". Installed: ${known || "none"}.` }] };
               }
               return { content: [{ type: "text", text: `Removed "${args.slug}"${res.name ? ` (${res.name})` : ""}.` }] };
-            } catch (err) {
-              return { content: [{ type: "text", text: `Remove failed: ${err.message}` }] };
+            } catch (err2) {
+              return { content: [{ type: "text", text: `Remove failed: ${err2.message}` }] };
             }
           }
         ),
@@ -1834,13 +1901,12 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
       isGroup
     });
     let text = "";
-    let ok = true;
+    let ok2 = true;
     let errorMessage = "";
     const toolCards = /* @__PURE__ */ new Map();
     const mcpServers = { antbot: this.buildToolServer(bot, job.threadId, job.hops) };
     const browser = this.deps.browserTools?.(bot.id);
     if (browser) mcpServers.browser = browser;
-    if (connectors) Object.assign(mcpServers, connectors.servers);
     try {
       for await (const ev of runTurn({
         prompt: job.prompt,
@@ -1851,6 +1917,9 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
         settings,
         abortController: abort,
         mcpServers,
+        // Names are validated against RESERVED_CONNECTOR_NAMES, so these cannot clobber the two
+        // in-process servers above. Mounted by the runtime adapter, not here.
+        connectors: connectors?.servers ?? {},
         skillPluginPath: this.deps.skillPluginPath?.(),
         // Skill names come from SKILL.md frontmatter, which is what the SDK matches on.
         enabledSkills: botSkills.map((s) => s.name),
@@ -1888,17 +1957,17 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
         if (ev.kind === "text" && ev.text) text += ev.text;
         if (ev.kind === "done") {
           if (ev.text && !text.trim()) text = ev.text;
-          ok = !ev.isError;
+          ok2 = !ev.isError;
         }
         if (ev.kind === "error") {
-          ok = false;
+          ok2 = false;
           errorMessage = ev.message ?? "Unknown error";
         }
       }
-    } catch (err) {
-      ok = false;
-      errorMessage = err instanceof Error ? err.message : String(err);
-      log6.error("turn crashed", err);
+    } catch (err2) {
+      ok2 = false;
+      errorMessage = err2 instanceof Error ? err2.message : String(err2);
+      log6.error("turn crashed", err2);
     } finally {
       this.running.delete(job.botId);
     }
@@ -1912,7 +1981,7 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
     const interrupted = abort.signal.aborted;
     this.setState(job.botId, interrupted ? "interrupted" : "idle", "unread");
     if (interrupted) this.setState(job.botId, "idle", "unread");
-    job.onDone?.(final || errorMessage, ok && !interrupted);
+    job.onDone?.(final || errorMessage, ok2 && !interrupted);
     void this.drain();
   }
   async applyEvent(ev, ctx) {
@@ -1926,6 +1995,10 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
       // simply behaves as though the connector were never assigned. Surfacing the SDK's own
       // verdict is the difference between "my bot ignores my connector" and a stated reason.
       case "mcp_status": {
+        for (const m of ev.mcpStatus ?? []) {
+          if (m.name === "antbot" || m.name === "browser") continue;
+          store.setConnectorStatusByName(m.name, m.status, m.error ?? null);
+        }
         const bad = (ev.mcpStatus ?? []).filter((m) => m.status !== "connected");
         if (!bad.length) break;
         for (const m of bad) {
@@ -1941,6 +2014,16 @@ Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\
         });
         break;
       }
+      // Mid-turn sign-in: the link goes into the thread as a card, where the human is looking,
+      // and it persists — a toast would be gone before they came back from the browser.
+      case "signin": {
+        if (!ev.signin) break;
+        const card = { type: "signin", serverName: ev.signin.serverName, url: ev.signin.url };
+        const idx = store.appendCard(msgId, card);
+        bus.publish({ type: "message.card", threadId: job.threadId, botId: bot.id, messageId: msgId, card, cardIndex: idx });
+        store.setConnectorStatusByName(ev.signin.serverName, "needs-sign-in", null);
+        break;
+      }
       case "text":
         if (ev.text) {
           const cur = store.getMessage(msgId);
@@ -2009,7 +2092,7 @@ function describeMcpStatus(status) {
     case "needs-auth":
       return "needs authentication \u2014 the server rejected the credentials it was given (or was given none)";
     case "failed":
-      return "failed to start \u2014 check the command or URL with `antbot connector test`";
+      return "failed to start \u2014 run `antbot mcp check <name>` to see why";
     case "pending":
       return "did not finish connecting in time";
     case "disabled":
@@ -2222,8 +2305,8 @@ async function discoverAuth(mcpUrl, headers = {}) {
       signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
     });
     challenge = res.headers.get("www-authenticate");
-  } catch (err) {
-    throw new OAuthError(`Could not reach ${mcpUrl}: ${err.message}`);
+  } catch (err2) {
+    throw new OAuthError(`Could not reach ${mcpUrl}: ${err2.message}`);
   }
   const found = await firstResourceMetadata(mcpUrl, challenge);
   if (!found) {
@@ -2310,13 +2393,16 @@ var clientSecretName = (connectorName) => `antbot:oauth-client:${connectorName}`
 var redirectUri = (port) => `http://127.0.0.1:${port}/api/connectors/oauth/callback`;
 var LOGIN_TTL_MS = 10 * 60 * 1e3;
 var ConnectorAuthService = class {
-  constructor(secrets, port) {
+  constructor(secrets, portOf) {
     this.secrets = secrets;
-    this.port = port;
+    this.portOf = portOf;
   }
   secrets;
-  port;
+  portOf;
   pending = /* @__PURE__ */ new Map();
+  get port() {
+    return this.portOf();
+  }
   /** Has this connector been signed in? Names only — never reads a value to answer. */
   isAuthorized(connectorName) {
     return this.secrets.list().includes(tokenSecretName(connectorName));
@@ -2342,8 +2428,8 @@ var ConnectorAuthService = class {
   async forgetClient(connectorName) {
     await this.secrets.remove(clientSecretName(connectorName));
   }
-  async readClient(connectorName) {
-    const key = clientSecretName(connectorName);
+  async readClient(clientKey) {
+    const key = clientSecretName(clientKey);
     const found = (await this.secrets.resolve([key])).get(key);
     if (!found) return null;
     try {
@@ -2364,49 +2450,76 @@ var ConnectorAuthService = class {
       throw new OAuthError("Sign-in applies to http and sse connectors; a stdio server takes its credentials in env.");
     }
     const discovery = await discoverAuth(connector.config.url);
+    const authorizeUrl = await this.beginLoginWith(
+      {
+        connectorId: connector.id,
+        connectorName: connector.name,
+        clientKey: connector.name,
+        authorizationEndpoint: discovery.authServer.authorizationEndpoint,
+        tokenEndpoint: discovery.authServer.tokenEndpoint,
+        registrationEndpoint: discovery.authServer.registrationEndpoint,
+        resource: discovery.resource.resource,
+        scopes: opts.scopes?.length ? opts.scopes : discovery.resource.scopesSupported,
+        // Without these Google issues no refresh token, and the connector dies in an hour. Harmless
+        // for providers that ignore them.
+        extras: { access_type: "offline", prompt: "consent" }
+      },
+      opts
+    );
+    return { authorizeUrl, discovery };
+  }
+  /**
+   * Begin a sign-in against a known authorization server. Used directly by built-in connectors,
+   * whose provider endpoints are fixed and whose client credentials are shared under one
+   * `clientKey` — one Google client serves Gmail, Calendar and Drive.
+   */
+  async beginLoginWith(target, opts = {}) {
     const redirect = redirectUri(this.port);
-    const remembered = await this.readClient(connector.name);
+    const remembered = await this.readClient(target.clientKey);
     let clientId = opts.clientId ?? remembered?.clientId;
     let clientSecret = opts.clientSecret ?? (opts.clientId ? void 0 : remembered?.clientSecret);
-    if (!clientId && discovery.authServer.registrationEndpoint) {
-      const registered = await registerClient(discovery.authServer.registrationEndpoint, redirect);
+    if (!clientId && target.registrationEndpoint) {
+      const registered = await registerClient(target.registrationEndpoint, redirect);
       clientId = registered?.clientId;
       clientSecret = registered?.clientSecret;
     }
     if (!clientId) {
+      const who = target.providerName ?? new URL(target.authorizationEndpoint).host;
       throw new OAuthError(
-        `${new URL(discovery.authServer.authorizationEndpoint).host} does not support automatic app registration, so it needs a client ID you create yourself. Register one with that provider, add "${redirect}" as an authorised redirect URI, and pass the client ID with --client-id.`
+        `${who} does not support automatic app registration, so it needs a client ID you create yourself. Register one with that provider, add "${redirect}" as an authorised redirect URI, and pass the client ID with --client-id.`
       );
     }
     if (opts.clientId || opts.clientSecret || !remembered) {
-      await this.secrets.set(clientSecretName(connector.name), JSON.stringify({ clientId, clientSecret }));
+      await this.secrets.set(clientSecretName(target.clientKey), JSON.stringify({ clientId, clientSecret }));
     }
     const pkce = createPkce();
     const state = crypto2.randomBytes(16).toString("base64url");
     this.pending.set(state, {
-      connectorId: connector.id,
-      connectorName: connector.name,
+      connectorId: target.connectorId,
+      connectorName: target.connectorName,
       verifier: pkce.verifier,
       clientId,
       clientSecret,
-      tokenEndpoint: discovery.authServer.tokenEndpoint,
-      resource: discovery.resource.resource,
+      tokenEndpoint: target.tokenEndpoint,
+      resource: target.resource,
       redirectUri: redirect,
       startedAt: Date.now()
     });
     this.sweep();
-    const authorizeUrl = buildAuthorizeUrl({
-      authorizationEndpoint: discovery.authServer.authorizationEndpoint,
+    return buildAuthorizeUrl({
+      authorizationEndpoint: target.authorizationEndpoint,
       clientId,
       redirectUri: redirect,
-      scopes: opts.scopes?.length ? opts.scopes : discovery.resource.scopesSupported,
+      scopes: target.scopes,
       state,
       challenge: pkce.challenge,
-      resource: discovery.resource.resource,
-      // Without these Google issues no refresh token, and the connector dies in an hour.
-      extra: { access_type: "offline", prompt: "consent" }
+      resource: target.resource,
+      extra: target.extras
     });
-    return { authorizeUrl, discovery };
+  }
+  /** Whether client credentials are on file for a key (a connector name or a provider key). */
+  hasClient(clientKey) {
+    return this.secrets.list().includes(clientSecretName(clientKey));
   }
   /** Finish a sign-in from the redirect. Returns the connector that was authorised. */
   async completeLogin(state, code) {
@@ -2424,14 +2537,14 @@ var ConnectorAuthService = class {
         redirectUri: p.redirectUri,
         resource: p.resource
       });
-    } catch (err) {
-      const message = err.message;
+    } catch (err2) {
+      const message = err2.message;
       if (/client_secret/i.test(message)) {
         throw new OAuthError(
           `This provider requires a client secret as well as a client ID. Add the secret from the same OAuth client (in Google's console: the client's "Client secret") and sign in again.`
         );
       }
-      throw err;
+      throw err2;
     }
     await this.write(p.connectorName, tokens);
     log7.info(`connector "${p.connectorName}" signed in`);
@@ -2449,8 +2562,8 @@ var ConnectorAuthService = class {
       try {
         tokens = await refreshTokens(tokens);
         await this.write(connectorName, tokens);
-      } catch (err) {
-        log7.warn(`could not refresh tokens for "${connectorName}": ${err.message}`);
+      } catch (err2) {
+        log7.warn(`could not refresh tokens for "${connectorName}": ${err2.message}`);
         return null;
       }
     }
@@ -2462,6 +2575,532 @@ var ConnectorAuthService = class {
   }
 };
 
+// daemon/src/connectors/builtin/service.ts
+import crypto3 from "node:crypto";
+
+// daemon/src/connectors/builtin/gmail.ts
+import { z as z2 } from "zod";
+
+// daemon/src/connectors/builtin/mcpServer.ts
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var RPC = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602
+};
+var err = (id, code, message) => ({ jsonrpc: "2.0", id, error: { code, message } });
+var ok = (id, result) => ({ jsonrpc: "2.0", id, result });
+var toolError = (text) => ({ content: [{ type: "text", text }], isError: true });
+var toolText = (text) => ({ content: [{ type: "text", text }] });
+async function handleMcpRequest(body, server, ctx) {
+  const req = body;
+  if (!req || typeof req !== "object" || req.jsonrpc !== "2.0" || typeof req.method !== "string") {
+    return err(null, RPC.INVALID_REQUEST, "Expected a JSON-RPC 2.0 request");
+  }
+  const id = req.id ?? null;
+  if (req.id === void 0) return null;
+  switch (req.method) {
+    case "initialize": {
+      const asked = String(req.params?.protocolVersion ?? MCP_PROTOCOL_VERSION);
+      return ok(id, {
+        // Echo the client's version when it is one we can serve; the surface is small enough that
+        // every revision since 2024-11-05 is compatible for these three methods.
+        protocolVersion: asked,
+        capabilities: { tools: {} },
+        serverInfo: { name: server.name, version: server.version }
+      });
+    }
+    case "ping":
+      return ok(id, {});
+    case "tools/list":
+      return ok(id, {
+        tools: server.tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
+      });
+    case "tools/call": {
+      const name = String(req.params?.name ?? "");
+      const tool2 = server.tools.find((t) => t.name === name);
+      if (!tool2) return err(id, RPC.INVALID_PARAMS, `Unknown tool: ${name}`);
+      const parsed = tool2.parse.safeParse(req.params?.arguments ?? {});
+      if (!parsed.success) {
+        return err(id, RPC.INVALID_PARAMS, `Invalid arguments for ${name}: ${parsed.error.issues[0]?.message ?? "invalid"}`);
+      }
+      let context;
+      try {
+        context = await ctx();
+      } catch (e) {
+        return ok(id, toolError(e.message));
+      }
+      try {
+        return ok(id, await tool2.handler(parsed.data, context));
+      } catch (e) {
+        return ok(id, toolError(`${name} failed: ${e.message}`));
+      }
+    }
+    default:
+      return err(id, RPC.METHOD_NOT_FOUND, `Method not supported: ${req.method}`);
+  }
+}
+
+// daemon/src/connectors/builtin/gmail.ts
+var API = "https://gmail.googleapis.com/gmail/v1/users/me";
+async function gmail(fetchFn, ctx, path12, init = {}) {
+  const res = await fetchFn(`${API}${path12}`, {
+    ...init,
+    headers: { Authorization: `Bearer ${ctx.accessToken}`, "content-type": "application/json", ...init.headers ?? {} }
+  });
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (!res.ok) {
+    const msg = body?.error?.message ?? `HTTP ${res.status}`;
+    const hint = res.status === 401 || res.status === 403 ? " \u2014 sign in to the gmail connector again" : "";
+    return { ok: false, error: `Gmail: ${msg}${hint}` };
+  }
+  return { ok: true, body };
+}
+function summarizeMessage(m) {
+  const headers = {};
+  for (const h of m?.payload?.headers ?? []) {
+    const k = String(h.name).toLowerCase();
+    if (["from", "to", "cc", "subject", "date"].includes(k)) headers[k] = String(h.value);
+  }
+  return {
+    id: m?.id,
+    threadId: m?.threadId,
+    labelIds: m?.labelIds ?? [],
+    snippet: m?.snippet ?? "",
+    ...headers,
+    body: extractText(m?.payload) ?? ""
+  };
+}
+function extractText(payload) {
+  if (!payload) return null;
+  const decode = (data) => Buffer.from(data.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+  if (payload.mimeType === "text/plain" && payload.body?.data) return decode(payload.body.data);
+  if (Array.isArray(payload.parts)) {
+    for (const p of payload.parts) {
+      const t = extractText(p);
+      if (t) return t;
+    }
+  }
+  if (payload.mimeType === "text/html" && payload.body?.data) {
+    return decode(payload.body.data).replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  }
+  return null;
+}
+function buildRawMessage(m) {
+  const lines = [
+    `To: ${m.to}`,
+    ...m.cc ? [`Cc: ${m.cc}`] : [],
+    `Subject: ${m.subject}`,
+    ...m.inReplyTo ? [`In-Reply-To: ${m.inReplyTo}`, `References: ${m.inReplyTo}`] : [],
+    "Content-Type: text/plain; charset=utf-8",
+    "MIME-Version: 1.0",
+    "",
+    m.body
+  ];
+  return Buffer.from(lines.join("\r\n"), "utf8").toString("base64url");
+}
+var json = (v) => toolText(JSON.stringify(v, null, 2));
+function gmailTools(fetchFn = fetch) {
+  return [
+    {
+      name: "search_threads",
+      description: 'Search the mailbox with Gmail query syntax (e.g. "is:unread", "from:alice newer_than:7d"). Returns thread ids with a snippet of the latest message.',
+      inputSchema: {
+        type: "object",
+        properties: { query: { type: "string" }, maxResults: { type: "integer", minimum: 1, maximum: 50 } },
+        required: ["query"]
+      },
+      parse: z2.object({ query: z2.string().min(1), maxResults: z2.number().int().min(1).max(50).default(10) }),
+      handler: async (a, ctx) => {
+        const r = await gmail(fetchFn, ctx, `/threads?q=${encodeURIComponent(a.query)}&maxResults=${a.maxResults}`);
+        if (!r.ok) return toolError(r.error);
+        return json({ threads: (r.body.threads ?? []).map((t) => ({ id: t.id, snippet: t.snippet })), estimate: r.body.resultSizeEstimate });
+      }
+    },
+    {
+      name: "get_thread",
+      description: "Read every message in a thread: from, to, subject, date and a plain-text body.",
+      inputSchema: { type: "object", properties: { threadId: { type: "string" } }, required: ["threadId"] },
+      parse: z2.object({ threadId: z2.string().min(1) }),
+      handler: async (a, ctx) => {
+        const r = await gmail(fetchFn, ctx, `/threads/${encodeURIComponent(a.threadId)}?format=full`);
+        if (!r.ok) return toolError(r.error);
+        return json({ id: r.body.id, messages: (r.body.messages ?? []).map(summarizeMessage) });
+      }
+    },
+    {
+      name: "get_message",
+      description: "Read one message by id.",
+      inputSchema: { type: "object", properties: { messageId: { type: "string" } }, required: ["messageId"] },
+      parse: z2.object({ messageId: z2.string().min(1) }),
+      handler: async (a, ctx) => {
+        const r = await gmail(fetchFn, ctx, `/messages/${encodeURIComponent(a.messageId)}?format=full`);
+        if (!r.ok) return toolError(r.error);
+        return json(summarizeMessage(r.body));
+      }
+    },
+    {
+      name: "list_labels",
+      description: "List the mailbox labels (INBOX, SENT, user labels\u2026) with their ids.",
+      inputSchema: { type: "object", properties: {} },
+      parse: z2.object({}),
+      handler: async (_a, ctx) => {
+        const r = await gmail(fetchFn, ctx, "/labels");
+        if (!r.ok) return toolError(r.error);
+        return json({ labels: (r.body.labels ?? []).map((l) => ({ id: l.id, name: l.name, type: l.type })) });
+      }
+    },
+    {
+      name: "create_draft",
+      description: "Create a draft email. Nothing is sent. Set inReplyTo to a message id to draft a reply in that thread.",
+      inputSchema: {
+        type: "object",
+        properties: { to: { type: "string" }, subject: { type: "string" }, body: { type: "string" }, cc: { type: "string" }, inReplyTo: { type: "string" } },
+        required: ["to", "subject", "body"]
+      },
+      parse: z2.object({ to: z2.string().min(1), subject: z2.string(), body: z2.string(), cc: z2.string().optional(), inReplyTo: z2.string().optional() }),
+      handler: async (a, ctx) => {
+        const r = await gmail(fetchFn, ctx, "/drafts", { method: "POST", body: JSON.stringify({ message: { raw: buildRawMessage(a) } }) });
+        if (!r.ok) return toolError(r.error);
+        return json({ draftId: r.body.id, messageId: r.body.message?.id });
+      }
+    },
+    {
+      name: "send_message",
+      description: "Send an email immediately. This is consequential and asks the human for approval.",
+      inputSchema: {
+        type: "object",
+        properties: { to: { type: "string" }, subject: { type: "string" }, body: { type: "string" }, cc: { type: "string" }, inReplyTo: { type: "string" } },
+        required: ["to", "subject", "body"]
+      },
+      parse: z2.object({ to: z2.string().min(1), subject: z2.string(), body: z2.string(), cc: z2.string().optional(), inReplyTo: z2.string().optional() }),
+      handler: async (a, ctx) => {
+        const r = await gmail(fetchFn, ctx, "/messages/send", { method: "POST", body: JSON.stringify({ raw: buildRawMessage(a) }) });
+        if (!r.ok) return toolError(r.error);
+        return json({ sent: true, messageId: r.body.id, threadId: r.body.threadId });
+      }
+    }
+  ];
+}
+
+// daemon/src/connectors/builtin/catalog.ts
+var GOOGLE = {
+  key: "google",
+  displayName: "Google",
+  authorizationEndpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenEndpoint: "https://oauth2.googleapis.com/token",
+  authorizeExtras: { access_type: "offline", prompt: "consent" },
+  dynamicRegistration: false,
+  setupSteps: [
+    "Open console.cloud.google.com \u2192 APIs & Services \u2192 Credentials \u2192 Create credentials \u2192 OAuth client ID.",
+    'Application type: Web application. Under "Authorised redirect URIs" add exactly: {redirectUri}',
+    "Enable the Gmail API for the project (APIs & Services \u2192 Library).",
+    "Copy the Client ID and Client secret it shows you. One client works for every Google connector."
+  ]
+};
+var BUILTIN_CATALOG = {
+  gmail: {
+    name: "gmail",
+    displayName: "Gmail",
+    description: "Read, search and draft email in the signed-in Gmail account.",
+    provider: GOOGLE,
+    // modify covers read + draft + send; asking for less means a second consent screen later.
+    scopes: ["https://www.googleapis.com/auth/gmail.modify"],
+    tools: gmailTools
+  }
+};
+
+// daemon/src/connectors/builtin/service.ts
+var BuiltinService = class {
+  constructor(auth, portOf, version) {
+    this.auth = auth;
+    this.portOf = portOf;
+    this.version = version;
+  }
+  auth;
+  portOf;
+  version;
+  /** Rotates every boot. Checked on every `/mcp/<name>` request. */
+  bearer = crypto3.randomBytes(24).toString("base64url");
+  get port() {
+    return this.portOf();
+  }
+  get(name) {
+    return BUILTIN_CATALOG[name];
+  }
+  /** The config a built-in connector's row stores: the daemon's own endpoint, nothing secret. */
+  rowConfig(name) {
+    return { transport: "http", url: `http://127.0.0.1:${this.port}/mcp/${name}`, headers: {} };
+  }
+  /** What actually gets mounted: the row's config plus this boot's bearer. */
+  mountConfig(connector) {
+    return {
+      type: "http",
+      url: `http://127.0.0.1:${this.port}/mcp/${connector.name}`,
+      headers: { Authorization: `Bearer ${this.bearer}` }
+    };
+  }
+  authorized(name) {
+    return this.auth?.isAuthorized(name) ?? false;
+  }
+  /** Constant-time compare so the bearer cannot be guessed a byte at a time. */
+  checkBearer(header) {
+    const given = (header ?? "").replace(/^Bearer\s+/i, "");
+    const a = Buffer.from(given);
+    const b2 = Buffer.from(this.bearer);
+    return a.length === b2.length && crypto3.timingSafeEqual(a, b2);
+  }
+  /** Serve one MCP request for a built-in connector. */
+  async handle(name, body) {
+    const def = this.get(name);
+    if (!def) return { jsonrpc: "2.0", id: null, error: { code: -32601, message: `No built-in connector named ${name}` } };
+    return handleMcpRequest(body, { name: def.name, version: this.version, tools: def.tools() }, async () => {
+      const hdr = await this.auth?.authHeader(name);
+      if (!hdr) {
+        throw new Error(
+          `${def.displayName} is not signed in. Sign in on the Connectors screen or with \`antbot mcp login ${name}\`.`
+        );
+      }
+      return { accessToken: hdr.Authorization.replace(/^Bearer\s+/, "") };
+    });
+  }
+  /** Start the provider sign-in for a built-in connector. Returns the URL to open. */
+  async beginLogin(connector, opts = {}) {
+    const def = this.get(connector.name);
+    if (!def) throw new Error(`No built-in connector named ${connector.name}`);
+    if (!this.auth) throw new Error("Secrets backend unavailable, so a sign-in cannot be stored.");
+    const p = def.provider;
+    return this.auth.beginLoginWith(
+      {
+        connectorId: connector.id,
+        connectorName: connector.name,
+        clientKey: p.key,
+        authorizationEndpoint: p.authorizationEndpoint,
+        tokenEndpoint: p.tokenEndpoint,
+        scopes: def.scopes,
+        extras: p.authorizeExtras,
+        providerName: p.displayName
+      },
+      opts
+    );
+  }
+};
+
+// daemon/src/bots/mcpProbe.ts
+import { spawn } from "node:child_process";
+var log8 = logger("mcp-probe");
+var PROTOCOL_VERSION = "2025-06-18";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_DESCRIPTION = 200;
+function parseToolsResult(result) {
+  const tools = result?.tools;
+  if (!Array.isArray(tools)) return [];
+  return tools.filter((t) => typeof t === "object" && t !== null).map((t) => ({
+    name: String(t.name ?? ""),
+    description: String(t.description ?? "").slice(0, MAX_DESCRIPTION)
+  })).filter((t) => t.name.length > 0);
+}
+var rpc = (id, method, params) => `${JSON.stringify({ jsonrpc: "2.0", id, method, ...params ? { params } : {} })}
+`;
+var notify = (method) => `${JSON.stringify({ jsonrpc: "2.0", method })}
+`;
+var failed = (error) => ({ ok: false, tools: [], error });
+async function probeStdio(cfg, timeoutMs) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cfg.command, cfg.args ?? [], {
+        // The server's own env plus the connector's — a connector that needs PATH still gets it.
+        env: { ...process.env, ...cfg.env ?? {} },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (err2) {
+      return resolve(failed(err2.message));
+    }
+    let settled = false;
+    let stderr = "";
+    let buffer = "";
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      resolve(r);
+    };
+    const timer = setTimeout(
+      () => finish(failed(`timed out after ${timeoutMs}ms${stderr ? `: ${stderr.trim().slice(0, 200)}` : ""}`)),
+      timeoutMs
+    );
+    child.on("error", (err2) => finish(failed(err2.message)));
+    child.on(
+      "exit",
+      (code) => finish(failed(`server exited with code ${code}${stderr ? `: ${stderr.trim().slice(0, 200)}` : ""}`))
+    );
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.stdout?.on("data", (d) => {
+      buffer += d.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 1) {
+          try {
+            child.stdin?.write(notify("notifications/initialized"));
+            child.stdin?.write(rpc(2, "tools/list"));
+          } catch (err2) {
+            finish(failed(err2.message));
+          }
+        } else if (msg.id === 2) {
+          if (msg.error) return finish(failed(JSON.stringify(msg.error).slice(0, 200)));
+          finish({ ok: true, tools: parseToolsResult(msg.result) });
+        }
+      }
+    });
+    try {
+      child.stdin?.write(
+        rpc(1, "initialize", {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: "ant-bot", version: "1.0.0" }
+        })
+      );
+    } catch (err2) {
+      finish(failed(err2.message));
+    }
+  });
+}
+async function probeHttp(cfg, timeoutMs) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  const base = {
+    "content-type": "application/json",
+    accept: "application/json, text/event-stream",
+    ...cfg.headers ?? {}
+  };
+  const readBody = async (res) => {
+    const text = await res.text();
+    const line = text.split("\n").find((l) => l.startsWith("data:"));
+    try {
+      return JSON.parse(line ? line.slice(5).trim() : text);
+    } catch {
+      return null;
+    }
+  };
+  try {
+    const initRes = await fetch(cfg.url, {
+      method: "POST",
+      signal: ac.signal,
+      headers: base,
+      body: rpc(1, "initialize", {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "ant-bot", version: "1.0.0" }
+      })
+    });
+    if (!initRes.ok) return failed(`initialize returned HTTP ${initRes.status}`);
+    const session = initRes.headers.get("mcp-session-id");
+    const withSession = session ? { ...base, "mcp-session-id": session } : base;
+    await readBody(initRes);
+    await fetch(cfg.url, { method: "POST", signal: ac.signal, headers: withSession, body: notify("notifications/initialized") }).catch(() => void 0);
+    const listRes = await fetch(cfg.url, {
+      method: "POST",
+      signal: ac.signal,
+      headers: withSession,
+      body: rpc(2, "tools/list")
+    });
+    if (!listRes.ok) return failed(`tools/list returned HTTP ${listRes.status}`);
+    const body = await readBody(listRes);
+    if (body?.error) return failed(JSON.stringify(body.error).slice(0, 200));
+    return { ok: true, tools: parseToolsResult(body?.result) };
+  } catch (err2) {
+    const e = err2;
+    return failed(e.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e.message);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function probeConnector(config, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const type = config.type;
+  try {
+    if (type === "stdio") {
+      return await probeStdio(config, timeoutMs);
+    }
+    if (type === "http") {
+      return await probeHttp(config, timeoutMs);
+    }
+    if (type === "sse") return failed("testing is not supported for sse connectors \u2014 assign it to a bot and run a turn");
+    return failed(`unknown transport: ${String(type)}`);
+  } catch (err2) {
+    log8.warn("probe threw", err2);
+    return failed(err2.message);
+  }
+}
+
+// daemon/src/connectors/check.ts
+function decideCheck(signals) {
+  if (signals.builtinProvider) {
+    return signals.builtinSignedIn ? { status: "ready", tools: signals.probe?.tools ?? [], provider: signals.builtinProvider.name } : {
+      status: "needs-sign-in",
+      selfRegistration: signals.builtinProvider.dynamicRegistration,
+      provider: signals.builtinProvider.name,
+      tools: signals.probe?.tools ?? []
+    };
+  }
+  if (signals.missingSecrets.length) {
+    return { status: "needs-credential", tools: [], detail: `missing secret(s): ${signals.missingSecrets.join(", ")}` };
+  }
+  if (signals.challenge === "auth") {
+    const as = signals.discovery?.authServer;
+    return {
+      status: "needs-sign-in",
+      selfRegistration: Boolean(as?.registrationEndpoint),
+      provider: as ? new URL(as.authorizationEndpoint).host : void 0,
+      tools: signals.probe?.tools ?? []
+    };
+  }
+  if (signals.challenge === "unreachable" || signals.probe && !signals.probe.ok) {
+    return { status: "unreachable", tools: [], detail: signals.probe?.error };
+  }
+  return { status: "ready", tools: signals.probe?.tools ?? [] };
+}
+async function gatherCustomSignals(connector, mounted, missingSecrets) {
+  if (missingSecrets.length || !mounted) return { probe: null, challenge: "none", missingSecrets };
+  const probe = await probeConnector(mounted, { timeoutMs: 8e3 });
+  if (mounted.type === "stdio") return { probe, challenge: probe.ok ? "none" : "unreachable", missingSecrets };
+  if (!probe.ok) return { probe, challenge: "unreachable", missingSecrets };
+  try {
+    const discovery = await discoverAuth(mounted.url, mounted.headers);
+    return { probe, challenge: "auth", discovery, missingSecrets };
+  } catch (err2) {
+    const msg = err2.message;
+    if (err2 instanceof OAuthError && /did not advertise an authorization server/.test(msg)) {
+      return { probe, challenge: "auth", discovery: null, missingSecrets };
+    }
+    return { probe, challenge: "none", missingSecrets };
+  }
+}
+
+// daemon/src/app.ts
+import { fileURLToPath } from "node:url";
+
 // daemon/src/config/config.ts
 import fs6 from "node:fs";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
@@ -2538,11 +3177,11 @@ function writeConfig(cfg) {
 // daemon/src/permissions/secrets.ts
 import fs7 from "node:fs";
 import path7 from "node:path";
-import crypto3 from "node:crypto";
+import crypto4 from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var exec = promisify(execFile);
-var log8 = logger("secrets");
+var log9 = logger("secrets");
 var SERVICE = "ant-bot";
 var SecretToolBackend = class {
   name = "libsecret (secret-tool)";
@@ -2551,7 +3190,7 @@ var SecretToolBackend = class {
       const p = execFile(
         "secret-tool",
         ["store", "--label", `${SERVICE}: ${key}`, "service", SERVICE, "account", key],
-        (err) => err ? reject(err) : resolve()
+        (err2) => err2 ? reject(err2) : resolve()
       );
       p.stdin?.end(value);
     });
@@ -2609,7 +3248,7 @@ var EncryptedFileBackend = class {
   key() {
     if (!fs7.existsSync(this.keyFile)) {
       fs7.mkdirSync(path7.dirname(this.keyFile), { recursive: true });
-      fs7.writeFileSync(this.keyFile, crypto3.randomBytes(32), { mode: 384 });
+      fs7.writeFileSync(this.keyFile, crypto4.randomBytes(32), { mode: 384 });
     }
     return fs7.readFileSync(this.keyFile);
   }
@@ -2620,7 +3259,7 @@ var EncryptedFileBackend = class {
       const key = this.key();
       const out = {};
       for (const [k, v] of Object.entries(raw)) {
-        const d = crypto3.createDecipheriv("aes-256-gcm", key, Buffer.from(v.iv, "base64"));
+        const d = crypto4.createDecipheriv("aes-256-gcm", key, Buffer.from(v.iv, "base64"));
         d.setAuthTag(Buffer.from(v.tag, "base64"));
         out[k] = Buffer.concat([d.update(Buffer.from(v.data, "base64")), d.final()]).toString("utf8");
       }
@@ -2633,8 +3272,8 @@ var EncryptedFileBackend = class {
     const key = this.key();
     const out = {};
     for (const [k, v] of Object.entries(values)) {
-      const iv = crypto3.randomBytes(12);
-      const c = crypto3.createCipheriv("aes-256-gcm", key, iv);
+      const iv = crypto4.randomBytes(12);
+      const c = crypto4.createCipheriv("aes-256-gcm", key, iv);
       const data = Buffer.concat([c.update(v, "utf8"), c.final()]);
       out[k] = { iv: iv.toString("base64"), tag: c.getAuthTag().toString("base64"), data: data.toString("base64") };
     }
@@ -2663,13 +3302,13 @@ async function pickBackend(fallbackFile) {
     try {
       await exec(bin, args);
       return true;
-    } catch (err) {
-      return err.code !== "ENOENT";
+    } catch (err2) {
+      return err2.code !== "ENOENT";
     }
   };
   if (process.platform === "darwin" && await has("security", ["-h"])) return new MacKeychainBackend();
   if (process.platform === "linux" && await has("secret-tool", ["--version"])) return new SecretToolBackend();
-  log8.warn("no system keychain available; using the encrypted-file fallback");
+  log9.warn("no system keychain available; using the encrypted-file fallback");
   return new EncryptedFileBackend(fallbackFile);
 }
 var SecretsService = class {
@@ -2741,12 +3380,12 @@ var SecretsService = class {
 };
 
 // daemon/src/app.ts
-var log9 = logger("app");
+var log10 = logger("app");
 async function optionalImport(name, load) {
   try {
     return await load();
-  } catch (err) {
-    log9.warn(`${name} module could not be loaded`, err.message);
+  } catch (err2) {
+    log10.warn(`${name} module could not be loaded`, err2.message);
     return null;
   }
 }
@@ -2775,7 +3414,9 @@ async function createApp(opts = {}) {
     manager: void 0,
     lastUserActivity: { at: Date.now() },
     shutdown: async () => {
-    }
+    },
+    mountConnector: async () => null,
+    checkConnector: async () => ({ status: "unreachable", tools: [] })
   };
   app.manager = new BotManager({
     store,
@@ -2820,41 +3461,84 @@ async function createApp(opts = {}) {
      */
     connectorServers: async (botId) => {
       const assigned = store.listBotConnectors(botId);
-      if (!assigned.length) return { servers: {}, mounted: [] };
-      const available = new Set(app.secrets?.list() ?? []);
-      const { mount, skipped } = planConnectorMount(assigned, available);
-      for (const s of skipped) {
-        log9.warn(`connector "${s.connector.name}" not mounted \u2014 missing secret(s): ${s.missing.join(", ")}`);
-      }
       const servers = {};
       const mounted = [];
-      for (const connector of mount) {
-        const refs = extractSecretRefs(connector.config);
-        try {
-          const secrets = refs.length ? await app.secrets.resolve(refs) : /* @__PURE__ */ new Map();
-          const built = buildMcpServerConfig(connector, secrets);
-          const auth = await app.connectorAuth?.authHeader(connector.name);
-          if (auth && built.headers && !("Authorization" in built.headers)) {
-            built.headers = { ...built.headers, ...auth };
-          }
-          servers[connector.name] = built;
-          mounted.push({ name: connector.name, description: connector.description });
-        } catch (err) {
-          log9.warn(`connector "${connector.name}" not mounted`, err.message);
-        }
+      for (const connector of assigned) {
+        const built = await app.mountConnector(connector);
+        if (!built) continue;
+        servers[connector.name] = built;
+        mounted.push({ name: connector.name, description: connector.description });
       }
       return { servers, mounted };
     }
   });
+  app.mountConnector = async (connector) => {
+    if (connector.kind === "builtin") {
+      if (!app.builtin?.get(connector.name)) return null;
+      return app.builtin.mountConfig(connector);
+    }
+    const available = new Set(app.secrets?.list() ?? []);
+    const { skipped } = planConnectorMount([connector], available);
+    if (skipped.length) {
+      const missing = skipped[0].missing;
+      log10.warn(`connector "${connector.name}" not mounted \u2014 missing secret(s): ${missing.join(", ")}`);
+      store.setConnectorStatus(connector.id, "needs-credential", `missing secret(s): ${missing.join(", ")}`);
+      return null;
+    }
+    try {
+      const refs = extractSecretRefs(connector.config);
+      const secrets = refs.length ? await app.secrets.resolve(refs) : /* @__PURE__ */ new Map();
+      const built = buildMcpServerConfig(connector, secrets);
+      const auth = await app.connectorAuth?.authHeader(connector.name);
+      if (auth && built.type !== "stdio" && !("Authorization" in built.headers)) {
+        built.headers = { ...built.headers, ...auth };
+      }
+      return built;
+    } catch (err2) {
+      log10.warn(`connector "${connector.name}" not mounted`, err2.message);
+      store.setConnectorStatus(connector.id, "needs-credential", err2.message);
+      return null;
+    }
+  };
+  app.checkConnector = async (connector) => {
+    let verdict;
+    if (connector.kind === "builtin") {
+      const def = app.builtin?.get(connector.name);
+      const tools = def ? def.tools().map((t) => ({ name: t.name, description: t.description })) : [];
+      verdict = decideCheck({
+        probe: def ? { ok: true, tools } : null,
+        challenge: "none",
+        missingSecrets: [],
+        builtinSignedIn: app.builtin?.authorized(connector.name) ?? false,
+        builtinProvider: def ? { name: def.provider.displayName, dynamicRegistration: def.provider.dynamicRegistration } : void 0
+      });
+    } else {
+      const available = new Set(app.secrets?.list() ?? []);
+      const missing = computeMissingSecrets(connector, available);
+      const mounted = missing.length ? null : await app.mountConnector(connector);
+      verdict = decideCheck(await gatherCustomSignals(connector, mounted, missing));
+    }
+    store.setConnectorStatus(connector.id, verdict.status, verdict.detail ?? null);
+    return verdict;
+  };
   try {
     app.secrets = new SecretsService(
       await pickBackend(cfg.paths.secrets),
       `${cfg.paths.secrets}.index`
     );
-    log9.info(`secrets backend: ${app.secrets.backendName}`);
-    app.connectorAuth = new ConnectorAuthService(app.secrets, cfg.port);
-  } catch (err) {
-    log9.warn("secrets backend unavailable", err.message);
+    log10.info(`secrets backend: ${app.secrets.backendName}`);
+    app.connectorAuth = new ConnectorAuthService(app.secrets, () => app.cfg.port);
+  } catch (err2) {
+    log10.warn("secrets backend unavailable", err2.message);
+  }
+  app.builtin = new BuiltinService(
+    app.connectorAuth,
+    () => app.cfg.port,
+    readPackageVersion(path8.dirname(fileURLToPath(import.meta.url)), (p) => fs8.existsSync(p), (p) => fs8.readFileSync(p, "utf8"))
+  );
+  try {
+  } catch (err2) {
+    log10.warn("secrets backend unavailable", err2.message);
   }
   await wireSkills(app);
   await wireBrowser(app);
@@ -2880,12 +3564,12 @@ async function wireSkills(app) {
     const mod = await optionalImport("skills", () => import("./skills-JUHWFBD6.js"));
     const pluginMod = await optionalImport("skill plugin", () => import("./plugin-WYUCG6F7.js"));
     const Ctor = mod?.SkillStore ?? mod?.default;
-    if (!Ctor) return void log9.warn("skills subsystem unavailable: no SkillStore export");
+    if (!Ctor) return void log10.warn("skills subsystem unavailable: no SkillStore export");
     const pluginRoot = app.cfg.paths.skills;
     if (pluginMod?.ensureSkillPlugin) {
       pluginMod.ensureSkillPlugin(pluginRoot);
       const moved = pluginMod.migrateLegacyLayout?.(pluginRoot) ?? [];
-      if (moved.length) log9.info(`migrated ${moved.length} skill(s) into the plugin layout: ${moved.join(", ")}`);
+      if (moved.length) log10.info(`migrated ${moved.length} skill(s) into the plugin layout: ${moved.join(", ")}`);
       app.skillPluginPath = pluginRoot;
     }
     const filesDir = pluginMod?.skillFilesDir?.(pluginRoot) ?? pluginRoot;
@@ -2898,30 +3582,30 @@ async function wireSkills(app) {
         const installed = took("install");
         const updated = took("update");
         const kept = [...took("skip-modified"), ...took("skip-foreign")];
-        if (installed.length) log9.info(`installed ${installed.length} bundled skill(s): ${installed.join(", ")}`);
-        if (updated.length) log9.info(`updated ${updated.length} bundled skill(s): ${updated.join(", ")}`);
-        if (kept.length) log9.info(`left ${kept.length} locally-modified skill(s) alone: ${kept.join(", ")}`);
+        if (installed.length) log10.info(`installed ${installed.length} bundled skill(s): ${installed.join(", ")}`);
+        if (updated.length) log10.info(`updated ${updated.length} bundled skill(s): ${updated.join(", ")}`);
+        if (kept.length) log10.info(`left ${kept.length} locally-modified skill(s) alone: ${kept.join(", ")}`);
         const written = [...installed, ...updated, ...took("adopt")];
         const renamed = app.skills?.refreshFromDisk?.(written) ?? [];
-        if (renamed.length) log9.info(`refreshed metadata for ${renamed.length} skill(s): ${renamed.join(", ")}`);
+        if (renamed.length) log10.info(`refreshed metadata for ${renamed.length} skill(s): ${renamed.join(", ")}`);
       } catch (e) {
-        log9.warn("bundled skills not synced", e.message);
+        log10.warn("bundled skills not synced", e.message);
       }
     }
     app.skills.syncFromDisk?.();
     const fixed = app.skills.reconcile?.();
-    if (fixed?.repaired.length) log9.info(`repaired ${fixed.repaired.length} skill path(s): ${fixed.repaired.join(", ")}`);
-    if (fixed?.removed.length) log9.info(`dropped ${fixed.removed.length} skill row(s) with no files on disk`);
-    log9.info(`skills ready (${app.store.listSkills().length} registered)`);
-  } catch (err) {
-    log9.warn("skills subsystem unavailable", err.message);
+    if (fixed?.repaired.length) log10.info(`repaired ${fixed.repaired.length} skill path(s): ${fixed.repaired.join(", ")}`);
+    if (fixed?.removed.length) log10.info(`dropped ${fixed.removed.length} skill row(s) with no files on disk`);
+    log10.info(`skills ready (${app.store.listSkills().length} registered)`);
+  } catch (err2) {
+    log10.warn("skills subsystem unavailable", err2.message);
   }
 }
 async function wireBrowser(app) {
   try {
     const mod = await optionalImport("browser", () => import("./browser-NOWM4S6C.js"));
     const Ctor = mod?.BrowserService ?? mod?.default;
-    if (!Ctor) return void log9.warn("browser subsystem unavailable: no BrowserService export");
+    if (!Ctor) return void log10.warn("browser subsystem unavailable: no BrowserService export");
     const svc = new Ctor({ profileDir: app.cfg.paths.browserProfile, bus: app.bus, headless: true });
     let toolsMod = null;
     toolsMod = await optionalImport("browser tools", () => import("./tools-YNE7ZRPR.js"));
@@ -2936,16 +3620,16 @@ async function wireBrowser(app) {
       return s;
     };
     app.browser = svc;
-    log9.info("browser computer service ready");
-  } catch (err) {
-    log9.warn("browser subsystem unavailable", err.message);
+    log10.info("browser computer service ready");
+  } catch (err2) {
+    log10.warn("browser subsystem unavailable", err2.message);
   }
 }
 async function wireScheduler(app) {
   try {
     const mod = await optionalImport("scheduler", () => import("./scheduler-VZVHQWGD.js"));
     const Ctor = mod?.Scheduler ?? mod?.default;
-    if (!Ctor) return void log9.warn("scheduler subsystem unavailable: no Scheduler export");
+    if (!Ctor) return void log10.warn("scheduler subsystem unavailable: no Scheduler export");
     app.scheduler = new Ctor({
       store: app.store,
       bus: app.bus,
@@ -2953,9 +3637,9 @@ async function wireScheduler(app) {
       getSettings: app.getSettings
     });
     app.scheduler.start?.();
-    log9.info(`scheduler started (${app.store.listRoutines().filter((r) => r.enabled).length} active routines)`);
-  } catch (err) {
-    log9.warn("scheduler subsystem unavailable", err.message);
+    log10.info(`scheduler started (${app.store.listRoutines().filter((r) => r.enabled).length} active routines)`);
+  } catch (err2) {
+    log10.warn("scheduler subsystem unavailable", err2.message);
   }
 }
 function drainMailbox(app) {
@@ -2987,7 +3671,7 @@ function workspaceRelative(root, p) {
 
 // daemon/src/bots/groups.ts
 import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
-var log10 = logger("groups");
+var log11 = logger("groups");
 async function routeGroupMessage(args) {
   const { text, members, mentionBotIds, mentionEveryone, settings, cwd } = args;
   if (mentionEveryone) return members;
@@ -3025,8 +3709,8 @@ Which single teammate should own this? Reply with only the slug.`,
     const slug = out.trim().toLowerCase().replace(/[^a-z0-9-]/g, "");
     const found = members.find((m) => m.slug === slug);
     if (found) return [found];
-  } catch (err) {
-    log10.warn("group router failed; defaulting to first member", err);
+  } catch (err2) {
+    log11.warn("group router failed; defaulting to first member", err2);
   }
   return members.slice(0, 1);
 }
@@ -3037,13 +3721,13 @@ function parseMentions(text, members) {
 }
 
 // daemon/src/api/routes-core.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path9 from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var SERVER_VERSION = readPackageVersion(
-  path9.dirname(fileURLToPath(import.meta.url)),
-  (p) => fs8.existsSync(p),
-  (p) => fs8.readFileSync(p, "utf8")
+  path9.dirname(fileURLToPath2(import.meta.url)),
+  (p) => fs9.existsSync(p),
+  (p) => fs9.readFileSync(p, "utf8")
 );
 function registerCoreRoutes(f, app) {
   const { store, bus, manager } = app;
@@ -3066,9 +3750,9 @@ function registerCoreRoutes(f, app) {
     if (!parsed.success) return reply.code(400).send({ error: parsed.error.issues[0]?.message ?? "Invalid body" });
     try {
       return store.createBot(parsed.data);
-    } catch (err) {
-      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
-      throw err;
+    } catch (err2) {
+      if (err2 instanceof LimitError) return reply.code(409).send({ error: err2.message, code: err2.code });
+      throw err2;
     }
   });
   f.get("/api/bots/:id", async (req, reply) => {
@@ -3104,9 +3788,9 @@ function registerCoreRoutes(f, app) {
     try {
       const copy = store.duplicateBot(req.params.id);
       return copy ?? reply.code(404).send({ error: "No such bot" });
-    } catch (err) {
-      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
-      throw err;
+    } catch (err2) {
+      if (err2 instanceof LimitError) return reply.code(409).send({ error: err2.message, code: err2.code });
+      throw err2;
     }
   });
   f.post("/api/bots/:id/stop", async (req) => ({
@@ -3159,9 +3843,9 @@ function registerCoreRoutes(f, app) {
         return reply.code(400).send({ error: "One or more bots do not exist" });
       const title = parsed.data.title || members.map((m) => m.name).join(", ");
       return store.createThread({ ...parsed.data, title });
-    } catch (err) {
-      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
-      throw err;
+    } catch (err2) {
+      if (err2 instanceof LimitError) return reply.code(409).send({ error: err2.message, code: err2.code });
+      throw err2;
     }
   });
   f.get("/api/threads/:id", async (req, reply) => {
@@ -3202,9 +3886,9 @@ function registerCoreRoutes(f, app) {
     if (parsed.data.attachmentIds?.length) {
       try {
         store.attachToMessage(parsed.data.attachmentIds, msg.id);
-      } catch (err) {
-        if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
-        throw err;
+      } catch (err2) {
+        if (err2 instanceof LimitError) return reply.code(409).send({ error: err2.message, code: err2.code });
+        throw err2;
       }
     }
     bus.publish({ type: "message.created", threadId: thread.id, botId: null, message: store.getMessage(msg.id) });
@@ -3236,178 +3920,8 @@ ${attachments.map((a) => `- ${a.name} \u2192 ${a.path}`).join("\n")}` : "";
 }
 
 // daemon/src/api/routes-ops.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import path10 from "node:path";
-
-// daemon/src/bots/mcpProbe.ts
-import { spawn } from "node:child_process";
-var log11 = logger("mcp-probe");
-var PROTOCOL_VERSION = "2025-06-18";
-var DEFAULT_TIMEOUT_MS = 1e4;
-var MAX_DESCRIPTION = 200;
-function parseToolsResult(result) {
-  const tools = result?.tools;
-  if (!Array.isArray(tools)) return [];
-  return tools.filter((t) => typeof t === "object" && t !== null).map((t) => ({
-    name: String(t.name ?? ""),
-    description: String(t.description ?? "").slice(0, MAX_DESCRIPTION)
-  })).filter((t) => t.name.length > 0);
-}
-var rpc = (id, method, params) => `${JSON.stringify({ jsonrpc: "2.0", id, method, ...params ? { params } : {} })}
-`;
-var notify = (method) => `${JSON.stringify({ jsonrpc: "2.0", method })}
-`;
-var failed = (error) => ({ ok: false, tools: [], error });
-async function probeStdio(cfg, timeoutMs) {
-  return new Promise((resolve) => {
-    let child;
-    try {
-      child = spawn(cfg.command, cfg.args ?? [], {
-        // The server's own env plus the connector's — a connector that needs PATH still gets it.
-        env: { ...process.env, ...cfg.env ?? {} },
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } catch (err) {
-      return resolve(failed(err.message));
-    }
-    let settled = false;
-    let stderr = "";
-    let buffer = "";
-    const finish = (r) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-      resolve(r);
-    };
-    const timer = setTimeout(
-      () => finish(failed(`timed out after ${timeoutMs}ms${stderr ? `: ${stderr.trim().slice(0, 200)}` : ""}`)),
-      timeoutMs
-    );
-    child.on("error", (err) => finish(failed(err.message)));
-    child.on(
-      "exit",
-      (code) => finish(failed(`server exited with code ${code}${stderr ? `: ${stderr.trim().slice(0, 200)}` : ""}`))
-    );
-    child.stderr?.on("data", (d) => {
-      stderr += d.toString();
-    });
-    child.stdout?.on("data", (d) => {
-      buffer += d.toString();
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        let msg;
-        try {
-          msg = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (msg.id === 1) {
-          try {
-            child.stdin?.write(notify("notifications/initialized"));
-            child.stdin?.write(rpc(2, "tools/list"));
-          } catch (err) {
-            finish(failed(err.message));
-          }
-        } else if (msg.id === 2) {
-          if (msg.error) return finish(failed(JSON.stringify(msg.error).slice(0, 200)));
-          finish({ ok: true, tools: parseToolsResult(msg.result) });
-        }
-      }
-    });
-    try {
-      child.stdin?.write(
-        rpc(1, "initialize", {
-          protocolVersion: PROTOCOL_VERSION,
-          capabilities: {},
-          clientInfo: { name: "ant-bot", version: "1.0.0" }
-        })
-      );
-    } catch (err) {
-      finish(failed(err.message));
-    }
-  });
-}
-async function probeHttp(cfg, timeoutMs) {
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), timeoutMs);
-  const base = {
-    "content-type": "application/json",
-    accept: "application/json, text/event-stream",
-    ...cfg.headers ?? {}
-  };
-  const readBody = async (res) => {
-    const text = await res.text();
-    const line = text.split("\n").find((l) => l.startsWith("data:"));
-    try {
-      return JSON.parse(line ? line.slice(5).trim() : text);
-    } catch {
-      return null;
-    }
-  };
-  try {
-    const initRes = await fetch(cfg.url, {
-      method: "POST",
-      signal: ac.signal,
-      headers: base,
-      body: rpc(1, "initialize", {
-        protocolVersion: PROTOCOL_VERSION,
-        capabilities: {},
-        clientInfo: { name: "ant-bot", version: "1.0.0" }
-      })
-    });
-    if (!initRes.ok) return failed(`initialize returned HTTP ${initRes.status}`);
-    const session = initRes.headers.get("mcp-session-id");
-    const withSession = session ? { ...base, "mcp-session-id": session } : base;
-    await readBody(initRes);
-    await fetch(cfg.url, { method: "POST", signal: ac.signal, headers: withSession, body: notify("notifications/initialized") }).catch(() => void 0);
-    const listRes = await fetch(cfg.url, {
-      method: "POST",
-      signal: ac.signal,
-      headers: withSession,
-      body: rpc(2, "tools/list")
-    });
-    if (!listRes.ok) return failed(`tools/list returned HTTP ${listRes.status}`);
-    const body = await readBody(listRes);
-    if (body?.error) return failed(JSON.stringify(body.error).slice(0, 200));
-    return { ok: true, tools: parseToolsResult(body?.result) };
-  } catch (err) {
-    const e = err;
-    return failed(e.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e.message);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function probeConnector(config, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const type = config.type;
-  try {
-    if (type === "stdio") {
-      return await probeStdio(config, timeoutMs);
-    }
-    if (type === "http") {
-      const result = await probeHttp(config, timeoutMs);
-      const headers = config.headers ?? {};
-      const authed = Object.keys(headers).some((h) => /^(authorization|x-api-key|api-key)$/i.test(h));
-      if (result.ok && !authed) {
-        result.authHint = "This server was reached without any credential. If it needs one, the tools will list here but a bot will still see none \u2014 add an Authorization header, e.g. {{secret:NAME}}.";
-      }
-      return result;
-    }
-    if (type === "sse") return failed("testing is not supported for sse connectors \u2014 assign it to a bot and run a turn");
-    return failed(`unknown transport: ${String(type)}`);
-  } catch (err) {
-    log11.warn("probe threw", err);
-    return failed(err.message);
-  }
-}
-
-// daemon/src/api/routes-ops.ts
 function registerOpsRoutes(f, app) {
   const { store, gateway, bus } = app;
   f.get("/api/approvals", async () => store.listPendingApprovals());
@@ -3441,35 +3955,74 @@ function registerOpsRoutes(f, app) {
     store.deleteRule(rule.id);
     return { ok: true };
   });
-  f.get("/api/connectors", async () => {
-    const available = new Set(app.secrets?.list() ?? []);
-    return store.listConnectors().map((c) => ({
-      ...c,
-      missingSecrets: computeMissingSecrets(c, available),
-      // Names only — knowing a connector is signed in never requires reading its token.
-      signedIn: app.connectorAuth?.isAuthorized(c.name) ?? false
-    }));
+  const describe = (c) => ({
+    ...c,
+    missingSecrets: computeMissingSecrets(c, new Set(app.secrets?.list() ?? [])),
+    // Names only — knowing a connector is signed in never requires reading its token.
+    signedIn: app.connectorAuth?.isAuthorized(c.name) ?? false
   });
+  f.get("/api/connectors", async () => store.listConnectors().map(describe));
+  f.get(
+    "/api/connectors/catalog",
+    async () => Object.values(BUILTIN_CATALOG).map((b2) => ({
+      name: b2.name,
+      displayName: b2.displayName,
+      description: b2.description,
+      provider: b2.provider.displayName,
+      needsClientCredentials: !b2.provider.dynamicRegistration,
+      setupSteps: b2.provider.setupSteps.map((step) => step.replace("{redirectUri}", redirectUri(app.cfg.port)))
+    }))
+  );
   f.post("/api/connectors", async (req, reply) => {
     const parsed = CreateConnectorRequest.safeParse(req.body);
     if (!parsed.success) return reply.code(400).send({ error: parsed.error.issues[0]?.message ?? "Invalid body" });
-    if (store.getConnectorByName(parsed.data.name)) {
-      return reply.code(409).send({ error: `A connector named "${parsed.data.name}" already exists` });
+    const body = parsed.data;
+    if (store.getConnectorByName(body.name)) {
+      return reply.code(409).send({ error: `A connector named "${body.name}" already exists` });
     }
-    return store.createConnector(parsed.data);
+    let created;
+    if (body.builtin) {
+      const def = app.builtin?.get(body.builtin);
+      if (!def) return reply.code(400).send({ error: `No built-in connector named "${body.builtin}"` });
+      if (body.name !== def.name) return reply.code(400).send({ error: `The built-in ${def.name} connector must be named "${def.name}"` });
+      created = store.createConnector({
+        name: def.name,
+        description: body.description || def.description,
+        config: app.builtin.rowConfig(def.name),
+        kind: "builtin",
+        enabled: body.enabled
+      });
+    } else {
+      created = store.createConnector({ name: body.name, description: body.description, config: body.config, enabled: body.enabled });
+    }
+    for (const botId of body.botIds ?? []) {
+      if (!store.getBot(botId)) continue;
+      const current = store.listBotConnectors(botId).map((c) => c.id);
+      store.setBotConnectors(botId, [.../* @__PURE__ */ new Set([...current, created.id])]);
+    }
+    const check = await app.checkConnector(created);
+    return { ...describe(store.getConnector(created.id)), check };
   });
   f.patch("/api/connectors/:id", async (req, reply) => {
     const parsed = UpdateConnectorRequest.safeParse(req.body);
     if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
-    const updated = store.updateConnector(req.params.id, parsed.data);
-    if (!updated) return reply.code(404).send({ error: "No such connector" });
-    return updated;
+    const existing = store.getConnector(req.params.id);
+    if (!existing) return reply.code(404).send({ error: "No such connector" });
+    if (existing.kind === "builtin" && parsed.data.config) return reply.code(400).send({ error: "A built-in connector has no editable config" });
+    return describe(store.updateConnector(req.params.id, parsed.data));
   });
   f.delete("/api/connectors/:id", async (req, reply) => {
-    if (!store.getConnector(req.params.id)) return reply.code(404).send({ error: "No such connector" });
+    const c = store.getConnector(req.params.id);
+    if (!c) return reply.code(404).send({ error: "No such connector" });
+    await app.connectorAuth?.signOut(c.name);
     store.deleteConnector(req.params.id);
     return { ok: true };
   });
+  f.post("/api/connectors/:id/check", async (req, reply) => {
+    const connector = store.getConnector(req.params.id);
+    if (!connector) return reply.code(404).send({ error: "No such connector" });
+    return app.checkConnector(connector);
+  });
   f.post(
     "/api/connectors/:id/login",
     async (req, reply) => {
@@ -3477,10 +4030,10 @@ function registerOpsRoutes(f, app) {
       if (!connector) return reply.code(404).send({ error: "No such connector" });
       if (!app.connectorAuth) return reply.code(503).send({ error: "Secrets backend unavailable, so sign-in cannot be stored" });
       try {
-        const { authorizeUrl } = await app.connectorAuth.beginLogin(connector, req.body ?? {});
+        const authorizeUrl = connector.kind === "builtin" ? await app.builtin.beginLogin(connector, req.body ?? {}) : (await app.connectorAuth.beginLogin(connector, req.body ?? {})).authorizeUrl;
         return { authorizeUrl };
-      } catch (err) {
-        return reply.code(400).send({ error: err.message });
+      } catch (err2) {
+        return reply.code(400).send({ error: err2.message });
       }
     }
   );
@@ -3488,56 +4041,39 @@ function registerOpsRoutes(f, app) {
     const connector = store.getConnector(req.params.id);
     if (!connector) return reply.code(404).send({ error: "No such connector" });
     await app.connectorAuth?.signOut(connector.name);
+    store.setConnectorStatus(connector.id, "needs-sign-in", null);
     return { ok: true };
   });
   f.get(
     "/api/connectors/oauth/callback",
     async (req, reply) => {
-      const page = (title, detail, ok) => `<!doctype html><meta charset=utf-8><title>${title}</title>
+      const page = (title, detail, ok2) => `<!doctype html><meta charset=utf-8><title>${title}</title>
          <body style="font-family:system-ui;background:#0b0d10;color:#e6e8eb;padding:3rem;max-width:40rem">
-         <h1 style="color:${ok ? "#4ade80" : "#f87171"}">${title}</h1><p>${detail}</p>
+         <h1 style="color:${ok2 ? "#4ade80" : "#f87171"}">${title}</h1><p>${detail}</p>
          <p style="color:#9aa4b2">You can close this tab and return to ant-bot.</p>`;
       const { code, state, error, error_description: desc } = req.query;
-      if (error) {
-        return reply.type("text/html").send(page("Sign-in failed", `${error}: ${desc ?? ""}`, false));
-      }
-      if (!code || !state) {
-        return reply.type("text/html").send(page("Sign-in failed", "The provider did not return a code.", false));
-      }
-      if (!app.connectorAuth) {
-        return reply.type("text/html").send(page("Sign-in failed", "The secrets backend is unavailable.", false));
-      }
+      if (error) return reply.type("text/html").send(page("Sign-in failed", `${error}: ${desc ?? ""}`, false));
+      if (!code || !state) return reply.type("text/html").send(page("Sign-in failed", "The provider did not return a code.", false));
+      if (!app.connectorAuth) return reply.type("text/html").send(page("Sign-in failed", "The secrets backend is unavailable.", false));
       try {
-        const { connectorName } = await app.connectorAuth.completeLogin(state, code);
-        bus.publish({
-          type: "notify",
-          botId: null,
-          threadId: null,
-          title: "Connector signed in",
-          body: `${connectorName} is now authorised.`,
-          level: "info"
-        });
+        const { connectorId, connectorName } = await app.connectorAuth.completeLogin(state, code);
+        const row = store.getConnector(connectorId);
+        if (row) await app.checkConnector(row);
+        bus.publish({ type: "notify", botId: null, threadId: null, title: "Connector signed in", body: `${connectorName} is now authorised.`, level: "info" });
         return reply.type("text/html").send(page("Signed in", `<b>${connectorName}</b> is now authorised.`, true));
-      } catch (err) {
-        return reply.type("text/html").send(page("Sign-in failed", err.message, false));
+      } catch (err2) {
+        return reply.type("text/html").send(page("Sign-in failed", err2.message, false));
       }
     }
   );
-  f.post("/api/connectors/:id/test", async (req, reply) => {
-    const connector = store.getConnector(req.params.id);
-    if (!connector) return reply.code(404).send({ error: "No such connector" });
-    const refs = extractSecretRefs(connector.config);
-    const missing = computeMissingSecrets(connector, new Set(app.secrets?.list() ?? []));
-    if (missing.length) {
-      return { ok: false, tools: [], error: `missing secret(s): ${missing.join(", ")}` };
-    }
-    try {
-      const secrets = refs.length && app.secrets ? await app.secrets.resolve(refs) : /* @__PURE__ */ new Map();
-      return await probeConnector(buildMcpServerConfig(connector, secrets));
-    } catch (err) {
-      return { ok: false, tools: [], error: err.message };
-    }
+  f.post("/mcp/:name", async (req, reply) => {
+    if (!app.builtin) return reply.code(503).send({ error: "Built-in connectors unavailable" });
+    if (!app.builtin.checkBearer(req.headers.authorization)) return reply.code(401).send({ error: "Unauthorized" });
+    const res = await app.builtin.handle(req.params.name, req.body);
+    if (res === null) return reply.code(202).send();
+    return res;
   });
+  f.delete("/mcp/:name", async () => ({ ok: true }));
   f.get("/api/skills", async () => store.listSkills());
   f.post("/api/skills", async (req, reply) => {
     const parsed = CreateSkillRequest.safeParse(req.body);
@@ -3559,8 +4095,8 @@ function registerOpsRoutes(f, app) {
           replaced: i2.replaced
         }))
       };
-    } catch (err) {
-      return reply.code(400).send({ error: err.message });
+    } catch (err2) {
+      return reply.code(400).send({ error: err2.message });
     }
   });
   f.get("/api/skills/:id", async (req, reply) => {
@@ -3604,9 +4140,9 @@ function registerOpsRoutes(f, app) {
       const routine = store.createRoutine({ ...parsed.data, timezone: parsed.data.timezone ?? app.getSettings().timezone });
       app.scheduler?.reload?.(routine.id);
       return routine;
-    } catch (err) {
-      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
-      throw err;
+    } catch (err2) {
+      if (err2 instanceof LimitError) return reply.code(409).send({ error: err2.message, code: err2.code });
+      throw err2;
     }
   });
   f.patch("/api/routines/:id", async (req, reply) => {
@@ -3637,8 +4173,8 @@ function registerOpsRoutes(f, app) {
     const buf = await part.toBuffer();
     const safe = String(part.filename ?? "file").replace(/[^a-zA-Z0-9._-]/g, "_");
     const dest = path10.join(app.cfg.paths.attachments, `${Date.now()}-${safe}`);
-    fs9.mkdirSync(path10.dirname(dest), { recursive: true });
-    fs9.writeFileSync(dest, buf);
+    fs10.mkdirSync(path10.dirname(dest), { recursive: true });
+    fs10.writeFileSync(dest, buf);
     try {
       return store.createAttachment({
         messageId: null,
@@ -3647,16 +4183,16 @@ function registerOpsRoutes(f, app) {
         mime: part.mimetype ?? "application/octet-stream",
         bytes: buf.byteLength
       });
-    } catch (err) {
-      fs9.unlinkSync(dest);
-      if (err instanceof LimitError) return reply.code(413).send({ error: err.message, code: err.code });
-      throw err;
+    } catch (err2) {
+      fs10.unlinkSync(dest);
+      if (err2 instanceof LimitError) return reply.code(413).send({ error: err2.message, code: err2.code });
+      throw err2;
     }
   });
   f.get("/api/attachments/:id", async (req, reply) => {
     const a = store.getAttachment(req.params.id);
-    if (!a || !fs9.existsSync(a.path)) return reply.code(404).send({ error: "No such attachment" });
-    return reply.type(a.mime).send(fs9.createReadStream(a.path));
+    if (!a || !fs10.existsSync(a.path)) return reply.code(404).send({ error: "No such attachment" });
+    return reply.type(a.mime).send(fs10.createReadStream(a.path));
   });
   f.get("/api/usage", async () => {
     const rows = store.listUsage(0);
@@ -3723,12 +4259,12 @@ function registerOpsRoutes(f, app) {
     const root = app.cfg.paths.workspace;
     const target = workspaceRelative(root, req.query.path ?? ".");
     if (!target) return reply.code(400).send({ error: "Path is outside the workspace" });
-    if (!fs9.existsSync(target)) return [];
-    return fs9.readdirSync(target, { withFileTypes: true }).map((d) => {
+    if (!fs10.existsSync(target)) return [];
+    return fs10.readdirSync(target, { withFileTypes: true }).map((d) => {
       const full = path10.join(target, d.name);
       let bytes = 0;
       try {
-        bytes = d.isFile() ? fs9.statSync(full).size : 0;
+        bytes = d.isFile() ? fs10.statSync(full).size : 0;
       } catch {
       }
       return { name: d.name, path: path10.relative(root, full), dir: d.isDirectory(), bytes };
@@ -3737,7 +4273,7 @@ function registerOpsRoutes(f, app) {
   f.get("/api/workspace/file", async (req, reply) => {
     const root = app.cfg.paths.workspace;
     const target = workspaceRelative(root, req.query.path ?? "");
-    if (!target || !fs9.existsSync(target) || !fs9.statSync(target).isFile())
+    if (!target || !fs10.existsSync(target) || !fs10.statSync(target).isFile())
       return reply.code(404).send({ error: "No such file" });
     const ext = path10.extname(target).toLowerCase();
     const mime = {
@@ -3753,14 +4289,14 @@ function registerOpsRoutes(f, app) {
       ".pdf": "application/pdf",
       ".html": "text/html"
     };
-    return reply.type(mime[ext] ?? "application/octet-stream").send(fs9.createReadStream(target));
+    return reply.type(mime[ext] ?? "application/octet-stream").send(fs10.createReadStream(target));
   });
   f.get("/api/computer/status", async () => {
     if (!app.browser?.status) return { available: false, reason: "Browser service not built", mode: "host", headless: true, pages: [] };
     try {
       return await app.browser.status();
-    } catch (err) {
-      return { available: false, reason: err.message, mode: "host", headless: true, pages: [] };
+    } catch (err2) {
+      return { available: false, reason: err2.message, mode: "host", headless: true, pages: [] };
     }
   });
   f.post("/api/computer/takeover", async (req, reply) => {
@@ -3779,7 +4315,7 @@ var log12 = logger("server");
 var require_ = createRequire(import.meta.url);
 function resolveWebDist() {
   return findWebDist(
-    nodeLocateDeps(path11.dirname(fileURLToPath2(import.meta.url)), (spec) => {
+    nodeLocateDeps(path11.dirname(fileURLToPath3(import.meta.url)), (spec) => {
       try {
         return require_.resolve(spec);
       } catch {
@@ -3845,9 +4381,9 @@ async function startServer(opts = {}) {
           } catch {
           }
         });
-      } catch (err) {
+      } catch (err2) {
         try {
-          socket.send(JSON.stringify({ type: "error", message: err.message }));
+          socket.send(JSON.stringify({ type: "error", message: err2.message }));
         } catch {
         }
         socket.close();
@@ -3861,10 +4397,10 @@ async function startServer(opts = {}) {
         } catch {
           return;
         }
-        const fail = (err) => {
+        const fail = (err2) => {
           try {
             if (socket.readyState === 1)
-              socket.send(JSON.stringify({ type: "input-error", message: err.message }));
+              socket.send(JSON.stringify({ type: "input-error", message: err2.message }));
           } catch {
           }
         };
@@ -3908,14 +4444,15 @@ async function startServer(opts = {}) {
       });
     }
   }
-  fastify.setErrorHandler((err, _req, reply) => {
-    log12.error("request failed", err);
-    const e = err;
+  fastify.setErrorHandler((err2, _req, reply) => {
+    log12.error("request failed", err2);
+    const e = err2;
     const code = e.statusCode && e.statusCode >= 400 ? e.statusCode : 500;
     reply.code(code).send({ error: e.message ?? "Internal error" });
   });
   const port = opts.port ?? app.cfg.port;
   const host = opts.host ?? app.cfg.host;
+  app.cfg.port = port;
   await fastify.listen({ port, host });
   const url = `http://${host}:${port}`;
   const delivered = drainMailbox(app);