@michael-joseph-miller/ant-bot 0.2.2 → 0.3.0

package/dist/server.js

@@ -18,7 +18,7 @@ import {
   SettingsSchema,
   UpdateBotRequest,
   UpdateConnectorRequest
-} from "./chunk-F3D2K4WZ.js";
+} from "./chunk-I3GHIX3G.js";
 import {
   findWebDist,
   nodeLocateDeps,
@@ -2097,6 +2097,341 @@ function buildMcpServerConfig(connector, secrets) {
   };
 }
 
+// daemon/src/connectors/auth.ts
+import crypto2 from "node:crypto";
+
+// daemon/src/connectors/oauth.ts
+import crypto from "node:crypto";
+function parseResourceMetadataUrl(wwwAuthenticate) {
+  if (!wwwAuthenticate) return null;
+  const m = /resource_metadata\s*=\s*"([^"]+)"/i.exec(wwwAuthenticate);
+  return m ? m[1] : null;
+}
+function parseProtectedResourceMetadata(body) {
+  const b2 = body;
+  const servers = b2?.authorization_servers;
+  if (!Array.isArray(servers) || servers.length === 0) return null;
+  return {
+    authorizationServers: servers.map(String),
+    scopesSupported: Array.isArray(b2?.scopes_supported) ? b2.scopes_supported.map(String) : [],
+    resource: typeof b2?.resource === "string" ? b2.resource : void 0
+  };
+}
+function parseAuthServerMetadata(body) {
+  const b2 = body;
+  const auth = b2?.authorization_endpoint;
+  const token = b2?.token_endpoint;
+  if (typeof auth !== "string" || typeof token !== "string") return null;
+  return {
+    authorizationEndpoint: auth,
+    tokenEndpoint: token,
+    registrationEndpoint: typeof b2?.registration_endpoint === "string" ? b2.registration_endpoint : void 0,
+    scopesSupported: Array.isArray(b2?.scopes_supported) ? b2.scopes_supported.map(String) : []
+  };
+}
+function authServerMetadataUrls(issuer) {
+  const u = new URL(issuer);
+  const path12 = u.pathname.replace(/\/$/, "");
+  const base = `${u.protocol}//${u.host}`;
+  return [
+    `${base}/.well-known/oauth-authorization-server${path12}`,
+    `${base}/.well-known/openid-configuration${path12}`,
+    `${base}${path12}/.well-known/oauth-authorization-server`,
+    `${base}${path12}/.well-known/openid-configuration`
+  ];
+}
+function createPkce() {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function buildAuthorizeUrl(i2) {
+  const u = new URL(i2.authorizationEndpoint);
+  const p = u.searchParams;
+  p.set("response_type", "code");
+  p.set("client_id", i2.clientId);
+  p.set("redirect_uri", i2.redirectUri);
+  p.set("state", i2.state);
+  p.set("code_challenge", i2.challenge);
+  p.set("code_challenge_method", "S256");
+  if (i2.scopes.length) p.set("scope", i2.scopes.join(" "));
+  if (i2.resource) p.set("resource", i2.resource);
+  for (const [k, v] of Object.entries(i2.extra ?? {})) p.set(k, v);
+  return u.toString();
+}
+function parseTokenResponse(body, ctx, now2) {
+  const b2 = body;
+  if (typeof b2?.access_token !== "string") return null;
+  const expiresIn = typeof b2.expires_in === "number" ? b2.expires_in : void 0;
+  return {
+    accessToken: b2.access_token,
+    // A refresh response often omits refresh_token, meaning "keep using the one you have".
+    refreshToken: typeof b2.refresh_token === "string" ? b2.refresh_token : ctx.previousRefresh,
+    expiresAt: expiresIn ? now2 + expiresIn * 1e3 : void 0,
+    scope: typeof b2.scope === "string" ? b2.scope : void 0,
+    tokenEndpoint: ctx.tokenEndpoint,
+    clientId: ctx.clientId,
+    clientSecret: ctx.clientSecret,
+    resource: ctx.resource
+  };
+}
+function needsRefresh(tokens, now2, skewMs = 6e4) {
+  if (!tokens.expiresAt) return false;
+  return now2 + skewMs >= tokens.expiresAt;
+}
+var JSON_HEADERS = { accept: "application/json" };
+var FETCH_TIMEOUT_MS = 15e3;
+async function getJson(url) {
+  try {
+    const res = await fetch(url, { headers: JSON_HEADERS, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+    return res.ok ? await res.json() : null;
+  } catch {
+    return null;
+  }
+}
+var OAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OAuthError";
+  }
+};
+function resourceMetadataCandidates(mcpUrl, wwwAuthenticate) {
+  const u = new URL(mcpUrl);
+  const path12 = u.pathname.replace(/\/$/, "");
+  const out = [];
+  const hint = parseResourceMetadataUrl(wwwAuthenticate);
+  if (hint) out.push(hint);
+  out.push(`${u.origin}/.well-known/oauth-protected-resource${path12}`);
+  out.push(`${u.origin}/.well-known/oauth-protected-resource`);
+  return [...new Set(out)];
+}
+async function firstResourceMetadata(mcpUrl, wwwAuthenticate) {
+  for (const url of resourceMetadataCandidates(mcpUrl, wwwAuthenticate)) {
+    const meta = parseProtectedResourceMetadata(await getJson(url));
+    if (meta) return meta;
+  }
+  return null;
+}
+async function discoverAuth(mcpUrl, headers = {}) {
+  let challenge;
+  try {
+    const res = await fetch(mcpUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json, text/event-stream", ...headers },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "__antbot_auth_probe__", arguments: {} } }),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    challenge = res.headers.get("www-authenticate");
+  } catch (err) {
+    throw new OAuthError(`Could not reach ${mcpUrl}: ${err.message}`);
+  }
+  const found = await firstResourceMetadata(mcpUrl, challenge);
+  if (!found) {
+    throw new OAuthError(
+      "This server did not advertise an authorization server, so ant-bot cannot sign in to it. If it takes a static token, add one as an Authorization header instead."
+    );
+  }
+  const resourceMeta = found;
+  for (const issuer of resourceMeta.authorizationServers) {
+    for (const url of authServerMetadataUrls(issuer)) {
+      const meta = parseAuthServerMetadata(await getJson(url));
+      if (meta) return { resource: resourceMeta, authServer: meta };
+    }
+  }
+  throw new OAuthError(`Could not read authorization server metadata for ${resourceMeta.authorizationServers.join(", ")}`);
+}
+async function registerClient(registrationEndpoint, redirectUri2) {
+  try {
+    const res = await fetch(registrationEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...JSON_HEADERS },
+      body: JSON.stringify({
+        client_name: "ant-bot",
+        redirect_uris: [redirectUri2],
+        grant_types: ["authorization_code", "refresh_token"],
+        response_types: ["code"],
+        token_endpoint_auth_method: "none"
+      }),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!res.ok) return null;
+    const b2 = await res.json();
+    return typeof b2.client_id === "string" ? { clientId: b2.client_id, clientSecret: typeof b2.client_secret === "string" ? b2.client_secret : void 0 } : null;
+  } catch {
+    return null;
+  }
+}
+async function postForm(endpoint, form) {
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded", ...JSON_HEADERS },
+    body: new URLSearchParams(form).toString(),
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    const e = body;
+    throw new OAuthError(String(e?.error_description ?? e?.error ?? `token endpoint returned HTTP ${res.status}`));
+  }
+  return body;
+}
+async function exchangeCode(input) {
+  const body = await postForm(input.tokenEndpoint, {
+    grant_type: "authorization_code",
+    code: input.code,
+    code_verifier: input.verifier,
+    client_id: input.clientId,
+    redirect_uri: input.redirectUri,
+    ...input.clientSecret ? { client_secret: input.clientSecret } : {},
+    ...input.resource ? { resource: input.resource } : {}
+  });
+  const tokens = parseTokenResponse(body, input, input.now ?? Date.now());
+  if (!tokens) throw new OAuthError("The authorization server did not return an access token.");
+  return tokens;
+}
+async function refreshTokens(tokens, now2 = Date.now()) {
+  if (!tokens.refreshToken) throw new OAuthError("No refresh token \u2014 sign in again.");
+  const body = await postForm(tokens.tokenEndpoint, {
+    grant_type: "refresh_token",
+    refresh_token: tokens.refreshToken,
+    client_id: tokens.clientId,
+    ...tokens.clientSecret ? { client_secret: tokens.clientSecret } : {},
+    ...tokens.resource ? { resource: tokens.resource } : {}
+  });
+  const next = parseTokenResponse(body, { ...tokens, previousRefresh: tokens.refreshToken }, now2);
+  if (!next) throw new OAuthError("The authorization server did not return a refreshed access token.");
+  return next;
+}
+
+// daemon/src/connectors/auth.ts
+var log7 = logger("connector-auth");
+var tokenSecretName = (connectorName) => `antbot:oauth:${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) {
+    this.secrets = secrets;
+    this.port = port;
+  }
+  secrets;
+  port;
+  pending = /* @__PURE__ */ new Map();
+  /** Has this connector been signed in? Names only — never reads a value to answer. */
+  isAuthorized(connectorName) {
+    return this.secrets.list().includes(tokenSecretName(connectorName));
+  }
+  async read(connectorName) {
+    const key = tokenSecretName(connectorName);
+    const found = (await this.secrets.resolve([key])).get(key);
+    if (!found) return null;
+    try {
+      return JSON.parse(found);
+    } catch {
+      log7.warn(`stored tokens for "${connectorName}" are unreadable`);
+      return null;
+    }
+  }
+  async write(connectorName, tokens) {
+    await this.secrets.set(tokenSecretName(connectorName), JSON.stringify(tokens));
+  }
+  async signOut(connectorName) {
+    await this.secrets.remove(tokenSecretName(connectorName));
+  }
+  /**
+   * Begin a sign-in. Returns the URL the human must open.
+   *
+   * `clientId` is required only when the authorization server does not support dynamic client
+   * registration — Google being the notable case, where the human supplies one from their own
+   * cloud console. Everything else registers ant-bot automatically.
+   */
+  async beginLogin(connector, opts = {}) {
+    if (connector.config.transport === "stdio") {
+      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 redirect = redirectUri(this.port);
+    let clientId = opts.clientId;
+    let clientSecret = opts.clientSecret;
+    if (!clientId && discovery.authServer.registrationEndpoint) {
+      const registered = await registerClient(discovery.authServer.registrationEndpoint, redirect);
+      clientId = registered?.clientId;
+      clientSecret = registered?.clientSecret;
+    }
+    if (!clientId) {
+      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.`
+      );
+    }
+    const pkce = createPkce();
+    const state = crypto2.randomBytes(16).toString("base64url");
+    this.pending.set(state, {
+      connectorId: connector.id,
+      connectorName: connector.name,
+      verifier: pkce.verifier,
+      clientId,
+      clientSecret,
+      tokenEndpoint: discovery.authServer.tokenEndpoint,
+      resource: discovery.resource.resource,
+      redirectUri: redirect,
+      startedAt: Date.now()
+    });
+    this.sweep();
+    const authorizeUrl = buildAuthorizeUrl({
+      authorizationEndpoint: discovery.authServer.authorizationEndpoint,
+      clientId,
+      redirectUri: redirect,
+      scopes: opts.scopes?.length ? opts.scopes : discovery.resource.scopesSupported,
+      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" }
+    });
+    return { authorizeUrl, discovery };
+  }
+  /** Finish a sign-in from the redirect. Returns the connector that was authorised. */
+  async completeLogin(state, code) {
+    const p = this.pending.get(state);
+    if (!p) throw new OAuthError("This sign-in link is no longer valid. Start the sign-in again.");
+    this.pending.delete(state);
+    const tokens = await exchangeCode({
+      tokenEndpoint: p.tokenEndpoint,
+      code,
+      verifier: p.verifier,
+      clientId: p.clientId,
+      clientSecret: p.clientSecret,
+      redirectUri: p.redirectUri,
+      resource: p.resource
+    });
+    await this.write(p.connectorName, tokens);
+    log7.info(`connector "${p.connectorName}" signed in`);
+    return { connectorId: p.connectorId, connectorName: p.connectorName };
+  }
+  /**
+   * The Authorization header for a mounted connector, refreshing first if the token is close to
+   * expiry. Returns null when the connector was never signed in, which is not an error — most
+   * connectors use a static credential or none.
+   */
+  async authHeader(connectorName) {
+    let tokens = await this.read(connectorName);
+    if (!tokens) return null;
+    if (needsRefresh(tokens, Date.now())) {
+      try {
+        tokens = await refreshTokens(tokens);
+        await this.write(connectorName, tokens);
+      } catch (err) {
+        log7.warn(`could not refresh tokens for "${connectorName}": ${err.message}`);
+        return null;
+      }
+    }
+    return { Authorization: `Bearer ${tokens.accessToken}` };
+  }
+  sweep() {
+    const cutoff = Date.now() - LOGIN_TTL_MS;
+    for (const [state, p] of this.pending) if (p.startedAt < cutoff) this.pending.delete(state);
+  }
+};
+
 // daemon/src/config/config.ts
 import fs6 from "node:fs";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
@@ -2173,11 +2508,11 @@ function writeConfig(cfg) {
 // daemon/src/permissions/secrets.ts
 import fs7 from "node:fs";
 import path7 from "node:path";
-import crypto from "node:crypto";
+import crypto3 from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var exec = promisify(execFile);
-var log7 = logger("secrets");
+var log8 = logger("secrets");
 var SERVICE = "ant-bot";
 var SecretToolBackend = class {
   name = "libsecret (secret-tool)";
@@ -2244,7 +2579,7 @@ var EncryptedFileBackend = class {
   key() {
     if (!fs7.existsSync(this.keyFile)) {
       fs7.mkdirSync(path7.dirname(this.keyFile), { recursive: true });
-      fs7.writeFileSync(this.keyFile, crypto.randomBytes(32), { mode: 384 });
+      fs7.writeFileSync(this.keyFile, crypto3.randomBytes(32), { mode: 384 });
     }
     return fs7.readFileSync(this.keyFile);
   }
@@ -2255,7 +2590,7 @@ var EncryptedFileBackend = class {
       const key = this.key();
       const out = {};
       for (const [k, v] of Object.entries(raw)) {
-        const d = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(v.iv, "base64"));
+        const d = crypto3.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");
       }
@@ -2268,8 +2603,8 @@ var EncryptedFileBackend = class {
     const key = this.key();
     const out = {};
     for (const [k, v] of Object.entries(values)) {
-      const iv = crypto.randomBytes(12);
-      const c = crypto.createCipheriv("aes-256-gcm", key, iv);
+      const iv = crypto3.randomBytes(12);
+      const c = crypto3.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") };
     }
@@ -2304,7 +2639,7 @@ async function pickBackend(fallbackFile) {
   };
   if (process.platform === "darwin" && await has("security", ["-h"])) return new MacKeychainBackend();
   if (process.platform === "linux" && await has("secret-tool", ["--version"])) return new SecretToolBackend();
-  log7.warn("no system keychain available; using the encrypted-file fallback");
+  log8.warn("no system keychain available; using the encrypted-file fallback");
   return new EncryptedFileBackend(fallbackFile);
 }
 var SecretsService = class {
@@ -2376,12 +2711,12 @@ var SecretsService = class {
 };
 
 // daemon/src/app.ts
-var log8 = logger("app");
+var log9 = logger("app");
 async function optionalImport(name, load) {
   try {
     return await load();
   } catch (err) {
-    log8.warn(`${name} module could not be loaded`, err.message);
+    log9.warn(`${name} module could not be loaded`, err.message);
     return null;
   }
 }
@@ -2459,7 +2794,7 @@ async function createApp(opts = {}) {
       const available = new Set(app.secrets?.list() ?? []);
       const { mount, skipped } = planConnectorMount(assigned, available);
       for (const s of skipped) {
-        log8.warn(`connector "${s.connector.name}" not mounted \u2014 missing secret(s): ${s.missing.join(", ")}`);
+        log9.warn(`connector "${s.connector.name}" not mounted \u2014 missing secret(s): ${s.missing.join(", ")}`);
       }
       const servers = {};
       const mounted = [];
@@ -2467,10 +2802,15 @@ async function createApp(opts = {}) {
         const refs = extractSecretRefs(connector.config);
         try {
           const secrets = refs.length ? await app.secrets.resolve(refs) : /* @__PURE__ */ new Map();
-          servers[connector.name] = buildMcpServerConfig(connector, secrets);
+          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) {
-          log8.warn(`connector "${connector.name}" not mounted`, err.message);
+          log9.warn(`connector "${connector.name}" not mounted`, err.message);
         }
       }
       return { servers, mounted };
@@ -2481,9 +2821,10 @@ async function createApp(opts = {}) {
       await pickBackend(cfg.paths.secrets),
       `${cfg.paths.secrets}.index`
     );
-    log8.info(`secrets backend: ${app.secrets.backendName}`);
+    log9.info(`secrets backend: ${app.secrets.backendName}`);
+    app.connectorAuth = new ConnectorAuthService(app.secrets, cfg.port);
   } catch (err) {
-    log8.warn("secrets backend unavailable", err.message);
+    log9.warn("secrets backend unavailable", err.message);
   }
   await wireSkills(app);
   await wireBrowser(app);
@@ -2509,12 +2850,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 log8.warn("skills subsystem unavailable: no SkillStore export");
+    if (!Ctor) return void log9.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) log8.info(`migrated ${moved.length} skill(s) into the plugin layout: ${moved.join(", ")}`);
+      if (moved.length) log9.info(`migrated ${moved.length} skill(s) into the plugin layout: ${moved.join(", ")}`);
       app.skillPluginPath = pluginRoot;
     }
     const filesDir = pluginMod?.skillFilesDir?.(pluginRoot) ?? pluginRoot;
@@ -2527,30 +2868,30 @@ async function wireSkills(app) {
         const installed = took("install");
         const updated = took("update");
         const kept = [...took("skip-modified"), ...took("skip-foreign")];
-        if (installed.length) log8.info(`installed ${installed.length} bundled skill(s): ${installed.join(", ")}`);
-        if (updated.length) log8.info(`updated ${updated.length} bundled skill(s): ${updated.join(", ")}`);
-        if (kept.length) log8.info(`left ${kept.length} locally-modified skill(s) alone: ${kept.join(", ")}`);
+        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(", ")}`);
         const written = [...installed, ...updated, ...took("adopt")];
         const renamed = app.skills?.refreshFromDisk?.(written) ?? [];
-        if (renamed.length) log8.info(`refreshed metadata for ${renamed.length} skill(s): ${renamed.join(", ")}`);
+        if (renamed.length) log9.info(`refreshed metadata for ${renamed.length} skill(s): ${renamed.join(", ")}`);
       } catch (e) {
-        log8.warn("bundled skills not synced", e.message);
+        log9.warn("bundled skills not synced", e.message);
       }
     }
     app.skills.syncFromDisk?.();
     const fixed = app.skills.reconcile?.();
-    if (fixed?.repaired.length) log8.info(`repaired ${fixed.repaired.length} skill path(s): ${fixed.repaired.join(", ")}`);
-    if (fixed?.removed.length) log8.info(`dropped ${fixed.removed.length} skill row(s) with no files on disk`);
-    log8.info(`skills ready (${app.store.listSkills().length} registered)`);
+    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) {
-    log8.warn("skills subsystem unavailable", err.message);
+    log9.warn("skills subsystem unavailable", err.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 log8.warn("browser subsystem unavailable: no BrowserService export");
+    if (!Ctor) return void log9.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"));
@@ -2565,16 +2906,16 @@ async function wireBrowser(app) {
       return s;
     };
     app.browser = svc;
-    log8.info("browser computer service ready");
+    log9.info("browser computer service ready");
   } catch (err) {
-    log8.warn("browser subsystem unavailable", err.message);
+    log9.warn("browser subsystem unavailable", err.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 log8.warn("scheduler subsystem unavailable: no Scheduler export");
+    if (!Ctor) return void log9.warn("scheduler subsystem unavailable: no Scheduler export");
     app.scheduler = new Ctor({
       store: app.store,
       bus: app.bus,
@@ -2582,9 +2923,9 @@ async function wireScheduler(app) {
       getSettings: app.getSettings
     });
     app.scheduler.start?.();
-    log8.info(`scheduler started (${app.store.listRoutines().filter((r) => r.enabled).length} active routines)`);
+    log9.info(`scheduler started (${app.store.listRoutines().filter((r) => r.enabled).length} active routines)`);
   } catch (err) {
-    log8.warn("scheduler subsystem unavailable", err.message);
+    log9.warn("scheduler subsystem unavailable", err.message);
   }
 }
 function drainMailbox(app) {
@@ -2616,7 +2957,7 @@ function workspaceRelative(root, p) {
 
 // daemon/src/bots/groups.ts
 import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
-var log9 = logger("groups");
+var log10 = logger("groups");
 async function routeGroupMessage(args) {
   const { text, members, mentionBotIds, mentionEveryone, settings, cwd } = args;
   if (mentionEveryone) return members;
@@ -2655,7 +2996,7 @@ Which single teammate should own this? Reply with only the slug.`,
     const found = members.find((m) => m.slug === slug);
     if (found) return [found];
   } catch (err) {
-    log9.warn("group router failed; defaulting to first member", err);
+    log10.warn("group router failed; defaulting to first member", err);
   }
   return members.slice(0, 1);
 }
@@ -2870,7 +3211,7 @@ import path10 from "node:path";
 
 // daemon/src/bots/mcpProbe.ts
 import { spawn } from "node:child_process";
-var log10 = logger("mcp-probe");
+var log11 = logger("mcp-probe");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var MAX_DESCRIPTION = 200;
@@ -3031,7 +3372,7 @@ async function probeConnector(config, opts = {}) {
     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) {
-    log10.warn("probe threw", err);
+    log11.warn("probe threw", err);
     return failed(err.message);
   }
 }
@@ -3072,7 +3413,12 @@ function registerOpsRoutes(f, app) {
   });
   f.get("/api/connectors", async () => {
     const available = new Set(app.secrets?.list() ?? []);
-    return store.listConnectors().map((c) => ({ ...c, missingSecrets: computeMissingSecrets(c, available) }));
+    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
+    }));
   });
   f.post("/api/connectors", async (req, reply) => {
     const parsed = CreateConnectorRequest.safeParse(req.body);
@@ -3094,6 +3440,59 @@ function registerOpsRoutes(f, app) {
     store.deleteConnector(req.params.id);
     return { ok: true };
   });
+  f.post(
+    "/api/connectors/:id/login",
+    async (req, reply) => {
+      const connector = store.getConnector(req.params.id);
+      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 ?? {});
+        return { authorizeUrl };
+      } catch (err) {
+        return reply.code(400).send({ error: err.message });
+      }
+    }
+  );
+  f.delete("/api/connectors/:id/login", async (req, reply) => {
+    const connector = store.getConnector(req.params.id);
+    if (!connector) return reply.code(404).send({ error: "No such connector" });
+    await app.connectorAuth?.signOut(connector.name);
+    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>
+         <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>
+         <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));
+      }
+      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"
+        });
+        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));
+      }
+    }
+  );
   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" });
@@ -3346,7 +3745,7 @@ function registerOpsRoutes(f, app) {
 }
 
 // daemon/src/api/server.ts
-var log11 = logger("server");
+var log12 = logger("server");
 var require_ = createRequire(import.meta.url);
 function resolveWebDist() {
   return findWebDist(
@@ -3463,9 +3862,9 @@ async function startServer(opts = {}) {
         if (req.url.startsWith("/api")) return reply.code(404).send({ error: "Not found" });
         return reply.sendFile("index.html");
       });
-      log11.info(`serving UI from ${dist}`);
+      log12.info(`serving UI from ${dist}`);
     } else {
-      log11.warn("web UI not built \u2014 run `pnpm --filter @antbot/ui build`");
+      log12.warn("web UI not built \u2014 run `pnpm --filter @antbot/ui build`");
       fastify.setNotFoundHandler((req, reply) => {
         if (req.url.startsWith("/api")) return reply.code(404).send({ error: "Not found" });
         return reply.type("text/html").send(
@@ -3480,7 +3879,7 @@ async function startServer(opts = {}) {
     }
   }
   fastify.setErrorHandler((err, _req, reply) => {
-    log11.error("request failed", err);
+    log12.error("request failed", err);
     const e = err;
     const code = e.statusCode && e.statusCode >= 400 ? e.statusCode : 500;
     reply.code(code).send({ error: e.message ?? "Internal error" });
@@ -3490,13 +3889,13 @@ async function startServer(opts = {}) {
   await fastify.listen({ port, host });
   const url = `http://${host}:${port}`;
   const delivered = drainMailbox(app);
-  if (delivered) log11.info(`redelivered ${delivered} queued handoff message(s)`);
+  if (delivered) log12.info(`redelivered ${delivered} queued handoff message(s)`);
   const stale = app.store.listBots().filter((b2) => b2.state === "running" || b2.state === "queued");
   for (const b2 of stale) app.store.updateBot(b2.id, { state: "idle" });
   app.db.prepare(`UPDATE messages SET streaming=0 WHERE streaming=1`).run();
   app.db.prepare(`UPDATE approvals SET status='expired', reason='Daemon restarted' WHERE status='pending'`).run();
   app.db.prepare(`UPDATE routine_runs SET status='interrupted', finished_at=? WHERE status='running'`).run(Date.now());
-  log11.info(`ant-bot listening on ${url}`);
+  log12.info(`ant-bot listening on ${url}`);
   return {
     fastify,
     app,