@chibitek/chibi 0.1.161 → 0.1.162

package/dist-server/server/config.js

@@ -277,13 +277,13 @@ const featureConfigSchema = z.object({
      * marketplace checks) and personal skills (~/.agents/skills,
      * $CODEX_HOME/skills). */
     codexUserMcp: z.boolean().optional(),
-    /** LLM-generated titles for new bot threads. Off until explicitly
-     * enabled; a one-shot that fails or answers junk leaves the first-message
-     * snippet in place — see llmThreadTitlesEnabled. */
+    /** LLM-generated titles for new bot threads. Off until explicitly enabled; a one-shot
+     * that fails or answers junk leaves the first-message snippet in place — see llmThreadTitlesEnabled. */
     llmThreadTitles: z.boolean().optional(),
-    /** Small internal jobs (thread titles) run on Apple Intelligence on this
-     * Mac when it is available. On unless set to false. */
+    /** Small internal jobs (thread titles) run on Apple Intelligence on this Mac when available. On unless false. */
     onDeviceHelpers: z.boolean().optional(),
+    /** Mirror routines into private Mochii tasks (server/routine-mochii-sync.ts). Off unless true; no Settings toggle. */
+    routineMochiiSync: z.boolean().optional(),
 });
 /** Settings → Add-ons: one workspace switch per bundled add-on
  * (shared/addons.ts). Absent means the add-on's own default. Strict, so a
@@ -293,8 +293,8 @@ const addonsConfigSchema = z.object(Object.fromEntries(ADDONS.map((addon) => [ad
  * it survives cleared site data and is shared by every paired client. Hint
  * ids are short renderer-chosen slugs; the list is capped so a buggy client
  * cannot grow the file without bound. */
-/** The setup wizard's progress (src/lib/setup-wizard.ts SetupProgress). */
 const setupProgressSchema = z.object({
+    foundationRoles: z.array(z.enum(["assistant", "inbox", "research", "coder", "community", "ops"])).max(3).optional(),
     picks: z.array(z.string().trim().min(1).max(40)).max(20).optional(),
     chibitek: z.boolean().optional(),
     steps: z.record(z.string().trim().min(1).max(60), z.enum(["done", "skipped"]))

package/dist-server/server/connector-proxy.js

@@ -0,0 +1,249 @@
+// Harness-owned Composio MCP bridge.
+//
+// Provider CLIs only see this stdio server. Ordinary MCP traffic is relayed
+// to the configured Composio Session, but connection requests are converted
+// into first-class OpenMausBot chat cards. The agent never authors an auth
+// URL and credentials never pass through its transcript.
+//
+// stdout is the MCP transport. Never log there.
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+const UPSTREAM = process.env.OMB_CONNECTOR_UPSTREAM_URL ?? "";
+const HARNESS = process.env.OMB_HARNESS_URL ?? "http://127.0.0.1:8799";
+const BOT_ID = process.env.OMB_BOT_ID ?? "";
+const THREAD_ID = process.env.OMB_THREAD_ID ?? "";
+const TOKEN = process.env.OMB_CONNECTOR_TOKEN ?? process.env.OMB_COMMS_TOKEN ?? "";
+const MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
+const INITIALIZE_RELAY_TIMEOUT_MS = 1_000;
+const RELAY_TIMEOUT_MS = 10 * 60_000;
+function parsedHeaders() {
+    try {
+        const value = JSON.parse(process.env.OMB_CONNECTOR_UPSTREAM_HEADERS ?? "{}");
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return {};
+        return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+const upstreamHeaders = parsedHeaders();
+let upstreamSessionId = "";
+const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+function textResult(id, text, isError = false) {
+    return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) } };
+}
+function jsonRpcError(id, message) {
+    return { jsonrpc: "2.0", id, error: { code: -32000, message } };
+}
+function initializeResult(id, protocolVersion) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+            protocolVersion: typeof protocolVersion === "string" && protocolVersion ? protocolVersion : "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "openmausbot-connectors", version: "1" },
+        },
+    };
+}
+async function readBounded(response) {
+    const declared = Number(response.headers.get("content-length") ?? "0");
+    if (declared > MAX_RESPONSE_BYTES)
+        throw new Error("connector response exceeded 20 MB");
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = "";
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > MAX_RESPONSE_BYTES) {
+            await reader.cancel();
+            throw new Error("connector response exceeded 20 MB");
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+}
+function parseUpstream(text, id) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{"))
+        return JSON.parse(trimmed);
+    const frames = trimmed
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trim())
+        .filter((line) => line && line !== "[DONE]")
+        .flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return frames.findLast((frame) => frame.id === id) ?? frames.at(-1) ?? null;
+}
+async function relay(message, timeoutMs = RELAY_TIMEOUT_MS) {
+    if (!UPSTREAM)
+        throw new Error("connected apps are unavailable");
+    const response = await fetch(UPSTREAM, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...upstreamHeaders,
+            ...(upstreamSessionId ? { "mcp-session-id": upstreamSessionId } : {}),
+        },
+        body: JSON.stringify(message),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const nextSession = response.headers.get("mcp-session-id");
+    if (nextSession)
+        upstreamSessionId = nextSession;
+    if (!response.ok)
+        throw new Error(`connector service returned HTTP ${response.status}`);
+    return parseUpstream(await readBounded(response), message.id);
+}
+function connectorAdds(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return [];
+    const toolkits = args.toolkits;
+    if (!Array.isArray(toolkits))
+        return [];
+    const seen = new Set();
+    const requests = [];
+    for (const item of toolkits) {
+        if (typeof item === "string") {
+            const slug = item.trim().toLowerCase();
+            const key = JSON.stringify([slug, ""]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                requests.push({ slug });
+            }
+            continue;
+        }
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const row = item;
+        const action = String(row.action ?? "add").toLowerCase();
+        if (!["add", "connect", "initiate"].includes(action))
+            continue;
+        const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
+        if (typeof slug !== "string")
+            continue;
+        const normalized = slug.trim().toLowerCase();
+        const alias = (typeof row.alias === "string" ? row.alias : typeof row.account === "string" ? row.account : "").trim();
+        const key = JSON.stringify([normalized, alias.toLowerCase()]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        requests.push({ slug: normalized, ...(alias ? { alias } : {}) });
+    }
+    return requests;
+}
+async function showConnectorCards(items) {
+    const response = await fetch(`${HARNESS}/api/internal/connectors/request`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${TOKEN}` },
+        body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, items, resumeKey: randomUUID() }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        throw new Error(String(body.error ?? `could not show connection card (HTTP ${response.status})`));
+    }
+}
+async function handle(message) {
+    const id = message.id;
+    const method = String(message.method ?? "");
+    // OpenCode (and other MCP clients) mark a stdio server failed unless
+    // initialize returns capabilities/serverInfo. Relaying that handshake to
+    // Composio can time out, return a newer protocolVersion, or throw when the
+    // upstream URL never reached the child env — all of which previously
+    // surfaced as a tools/call-shaped {content,isError} payload.
+    if (method === "notifications/initialized" || method === "initialized") {
+        if (UPSTREAM)
+            void relay(message).catch(() => { });
+        return;
+    }
+    if (method === "initialize") {
+        if (UPSTREAM) {
+            try {
+                // Capture the upstream session id when the service is healthy, but
+                // never let a stalled provider prevent the local MCP client from
+                // mounting the connector tools. The client sends initialized only
+                // after this bounded attempt and the local initialize response.
+                await relay(message, INITIALIZE_RELAY_TIMEOUT_MS);
+            }
+            catch {
+                // Best-effort session setup. The client still needs a valid result.
+            }
+        }
+        if (id !== undefined) {
+            const params = (message.params ?? {});
+            send(initializeResult(id, params.protocolVersion));
+        }
+        return;
+    }
+    if (method === "tools/call") {
+        const params = (message.params ?? {});
+        const name = String(params.name ?? "");
+        const requests = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
+        if (requests.length) {
+            await showConnectorCards(requests);
+            const labels = requests.map((r) => (r.alias ? `${r.slug} (${r.alias})` : r.slug)).join(", ");
+            send(textResult(id, `Atomic showed the user a secure connection card for ${labels}. End this turn now. The app will continue the task automatically after the connection finishes.`));
+            return;
+        }
+        if (/WAIT_FOR_CONNECTIONS$/i.test(name)) {
+            send(textResult(id, "Atomic is handling connection completion and will continue the task automatically."));
+            return;
+        }
+    }
+    try {
+        const response = await relay(message);
+        if (response && id !== undefined)
+            send(response);
+    }
+    catch (error) {
+        if (id === undefined)
+            return;
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(id, messageText, true));
+        else
+            send(jsonRpcError(id, messageText));
+    }
+}
+const input = readline.createInterface({ input: process.stdin, terminal: false });
+input.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    let message;
+    try {
+        message = JSON.parse(trimmed);
+    }
+    catch {
+        return;
+    }
+    void handle(message).catch((error) => {
+        if (message.id === undefined)
+            return;
+        const method = String(message.method ?? "");
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(message.id, messageText, true));
+        else
+            send(jsonRpcError(message.id, messageText));
+    });
+});
+input.on("close", () => process.exit(0));

package/dist-server/server/index.js

@@ -176,6 +176,7 @@ import { agentBrowserFrame, agentBrowserIntegration, browserEngineEncryptionKey,
 import { withZipListings } from "./zip-listing.js";
 import { createScreenFrameSource, startPeriodicCapture } from "./screen-frame-source.js";
 import { screenFrameHash, screenSurfaceForTool, screenTouchingTool, settledFrameIsNews } from "./screen-frame-gate.js";
+import { RoutineMochiiSync } from "./routine-mochii-sync.js";
 import { RoutineRequestService } from "./routine-requests.js";
 import { buildBotOverview } from "./bot-overview.js";
 import { ProfileRequestService } from "./profile-requests.js";
@@ -2431,6 +2432,7 @@ function noteNexusLocalMemory(botId) {
     }
 }
 nexusMemory.start();
+const routineMochiiSync = RoutineMochiiSync.start({ dataDir: DATA_DIR, config: () => cfg, listRoutines: () => routines?.listRoutines() ?? [], listRuns: () => routines?.listRuns() ?? [], botName: (id) => store.bot(id)?.name, timeZone: () => routineTimeZone() });
 // Register the Private Bot's Nexus key as soon as there is a Private Bot, so
 // nothing else can register first (Nexus trusts the first key).
 // (Deferred: the store is created further down.)
@@ -11273,7 +11275,7 @@ routines = new RoutineManager({
         }
     },
     interruptGoal: interruptRoutineGroupGoal,
-    onRunChanged: syncRoutineRunToSource,
+    onRunChanged: (run) => { syncRoutineRunToSource(run); routineMochiiSync.poke(); },
     onRunFailed: (run) => {
         if (run.threadId) {
             pendingDelegationWakes.delete(run.threadId);
@@ -25522,7 +25524,7 @@ const gracefulShutdown = createGracefulShutdown({
         () => setupLogins.stopAll(),
         () => flushAllMemoryJournals(),
         // the outbox is already on disk; this only stops its retry timer
-        () => nexusMemory.stop(),
+        () => { nexusMemory.stop(); routineMochiiSync.stop(); },
         () => flushUsageLedger(DATA_DIR),
         () => flushDecisionLog(DATA_DIR),
         () => flushAdminActivity(DATA_DIR),

package/dist-server/server/mcp-public-registry.js

@@ -0,0 +1,325 @@
+// The Plugins window's MCP Marketplace, backed by the official MCP Registry
+// (https://registry.modelcontextprotocol.io, public, no key). This module
+// fetches and normalizes registry pages and turns one entry, or a featured
+// service from shared/mcp-featured.ts, into a config.json `mcpServers` entry.
+// Adding goes through the same rules as every other MCP server: the entry is
+// saved switched off, secrets are kept in its env or headers like any other
+// server's, and nothing here logs a value.
+import { featuredMcpIcon, featuredMcpServer, MCP_FEATURED } from "../shared/mcp-featured.js";
+import { slugMcpName } from "./mcp-registry.js";
+export const MCP_REGISTRY_BASE = "https://registry.modelcontextprotocol.io";
+/** The OAuth bridge Atomic already runs remote servers through (see
+ * electron/chibitek-defaults.mjs MCP_REMOTE_PACKAGE; a test keeps them equal).
+ * Pinned so its saved sign-ins survive a new mcp-remote release. */
+export const MCP_REMOTE_PACKAGE = "mcp-remote@0.14.3";
+const CACHE_MS = 60 * 60 * 1000;
+const CACHE_MAX = 200;
+const TIMEOUT_MS = 8_000;
+const PAGE_SIZE = 30;
+const OFFICIAL = "io.modelcontextprotocol.registry/official";
+export const REGISTRY_OFFLINE_MESSAGE = "The MCP Registry could not be reached. Check your internet connection and try again.";
+export class RegistryUnavailableError extends Error {
+    constructor() {
+        super(REGISTRY_OFFLINE_MESSAGE);
+        this.name = "RegistryUnavailableError";
+    }
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function httpsUrl(value) {
+    const raw = text(value);
+    if (!raw)
+        return undefined;
+    try {
+        const url = new URL(raw);
+        return url.protocol === "https:" ? url.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const featuredByRegistryName = new Map(MCP_FEATURED.filter((server) => server.registryName).map((server) => [server.registryName, server]));
+/** "io.github.acme/thing" -> "acme", "com.notion/mcp" -> "notion.com". */
+export function publisherFor(name) {
+    const namespace = name.split("/")[0] ?? name;
+    if (namespace.startsWith("io.github."))
+        return namespace.slice("io.github.".length);
+    return namespace.split(".").reverse().join(".");
+}
+/** "notion-mcp-server" -> "Notion Mcp Server" when the entry has no title. */
+function titleFor(name) {
+    const leaf = name.split("/").pop() ?? name;
+    return leaf.split(/[-_.]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join(" ") || name;
+}
+function githubOwner(repositoryUrl) {
+    if (!repositoryUrl)
+        return undefined;
+    const match = /^https:\/\/github\.com\/([A-Za-z0-9-]{1,39})(?:\/|$)/.exec(repositoryUrl);
+    return match?.[1];
+}
+function input(kind, raw) {
+    const item = record(raw);
+    const name = text(item.name);
+    if (!name)
+        return null;
+    const description = text(item.description);
+    return {
+        kind,
+        name,
+        ...(description ? { description: description.slice(0, 300) } : {}),
+        required: item.isRequired === true,
+        secret: item.isSecret === true,
+        ...(kind === "header" && text(item.value) ? { template: text(item.value) } : {}),
+    };
+}
+function remotes(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        const item = record(entry);
+        const url = httpsUrl(item.url);
+        // A URL with {placeholders} needs per-person values Atomic cannot guess.
+        if (!url || /[{}]|%7B|%7D/i.test(url))
+            return [];
+        const type = item.type === "sse" ? "sse" : item.type === "streamable-http" ? "http" : null;
+        if (!type)
+            return [];
+        const headers = Array.isArray(item.headers) ? item.headers.map((header) => input("header", header)).filter((header) => header !== null) : [];
+        return [{ type, url, headers }];
+    });
+}
+function packages(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        const item = record(entry);
+        const registryType = text(item.registryType);
+        const identifier = text(item.identifier);
+        if (!registryType || !identifier)
+            return [];
+        const env = Array.isArray(item.environmentVariables)
+            ? item.environmentVariables.map((variable) => input("env", variable)).filter((variable) => variable !== null)
+            : [];
+        return [{
+                registryType,
+                identifier,
+                ...(text(item.version) ? { version: text(item.version) } : {}),
+                ...(text(record(item.transport).type) ? { transport: text(record(item.transport).type) } : {}),
+                ...(text(item.runtimeHint) ? { runtimeHint: text(item.runtimeHint) } : {}),
+                env,
+            }];
+    });
+}
+const SAFE_PACKAGE = /^(@[a-z0-9][\w.-]*\/)?[A-Za-z0-9][\w.-]*$/;
+const SAFE_VERSION = /^[\w.+-]{1,64}$/;
+/** Remote first (nothing to install), then npm, then PyPI. A remote whose
+ * headers are all optional is assumed to sign in with OAuth, so it runs
+ * through the mcp-remote bridge; one that requires a header (an API key) is
+ * kept as a plain URL entry with that header. */
+function installPlan(server) {
+    const remote = server.remotes.find((item) => item.type === "http") ?? server.remotes.find((item) => item.type === "sse");
+    if (remote)
+        return { kind: "remote", remote, oauth: !remote.headers.some((header) => header.required) };
+    const stdio = (item) => !item.transport || item.transport === "stdio";
+    const npm = server.packages.find((item) => item.registryType === "npm" && stdio(item) && SAFE_PACKAGE.test(item.identifier));
+    if (npm)
+        return { kind: "npm", pkg: npm };
+    const pypi = server.packages.find((item) => item.registryType === "pypi" && stdio(item) && SAFE_PACKAGE.test(item.identifier));
+    if (pypi)
+        return { kind: "pypi", pkg: pypi };
+    return null;
+}
+function planInputs(plan) {
+    if (!plan)
+        return [];
+    const list = plan.kind === "remote"
+        ? plan.oauth ? [] : plan.remote.headers.map(({ template: _template, ...header }) => header)
+        : plan.pkg.env;
+    return [...list].sort((a, b) => Number(b.required) - Number(a.required));
+}
+/** One registry list entry to the shape the renderer shows, or null when it
+ * is not the latest version or not usable at all. */
+export function normalizeRegistryEntry(raw) {
+    const entry = record(raw);
+    const server = record(entry.server);
+    const meta = record(record(entry._meta)[OFFICIAL]);
+    if (meta.isLatest === false)
+        return null;
+    if (typeof meta.status === "string" && meta.status !== "active")
+        return null;
+    const name = text(server.name);
+    if (!name)
+        return null;
+    const repositoryUrl = httpsUrl(record(server.repository).url);
+    const websiteUrl = httpsUrl(server.websiteUrl);
+    const featured = featuredByRegistryName.get(name);
+    const icons = Array.isArray(server.icons) ? server.icons : [];
+    const registryIcon = icons.map((icon) => httpsUrl(record(icon).src)).find(Boolean);
+    const owner = githubOwner(repositoryUrl);
+    const iconUrl = featured
+        ? featuredMcpIcon(featured.id)
+        : registryIcon ?? (owner ? `https://github.com/${owner}.png?size=64` : undefined);
+    const normalized = {
+        id: name,
+        name,
+        title: text(server.title) ?? featured?.name ?? titleFor(name),
+        description: (text(server.description) ?? "").slice(0, 400),
+        publisher: publisherFor(name),
+        version: text(server.version) ?? "",
+        ...(repositoryUrl ? { repositoryUrl } : {}),
+        ...(websiteUrl ? { websiteUrl } : {}),
+        remotes: remotes(server.remotes),
+        packages: packages(server.packages),
+        ...(iconUrl ? { iconUrl } : {}),
+        ...(featured ? { featured: featured.id } : {}),
+    };
+    const plan = installPlan(normalized);
+    return { ...normalized, install: plan?.kind ?? null, inputs: planInputs(plan) };
+}
+/** Normalize a page: latest versions only, one card per server name. */
+export function normalizeRegistryPage(body) {
+    const page = record(body);
+    const seen = new Set();
+    const servers = [];
+    for (const raw of Array.isArray(page.servers) ? page.servers : []) {
+        const server = normalizeRegistryEntry(raw);
+        if (!server || seen.has(server.id))
+            continue;
+        seen.add(server.id);
+        servers.push(server);
+    }
+    const nextCursor = text(record(page.metadata).nextCursor);
+    return { servers, ...(nextCursor ? { nextCursor } : {}) };
+}
+/** A registry client with a one-hour in-memory cache. Every failure (offline,
+ * timeout, a registry error) becomes RegistryUnavailableError. */
+export function createMcpPublicRegistry(options = {}) {
+    const doFetch = options.fetch ?? fetch;
+    const base = options.base ?? MCP_REGISTRY_BASE;
+    const now = options.now ?? Date.now;
+    const cache = new Map();
+    async function getJson(url) {
+        const hit = cache.get(url);
+        if (hit && now() - hit.at < CACHE_MS)
+            return hit.value;
+        let response;
+        try {
+            response = await doFetch(url, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(TIMEOUT_MS) });
+        }
+        catch {
+            throw new RegistryUnavailableError();
+        }
+        if (response.status === 404)
+            return null;
+        if (!response.ok)
+            throw new RegistryUnavailableError();
+        let value;
+        try {
+            value = await response.json();
+        }
+        catch {
+            throw new RegistryUnavailableError();
+        }
+        if (cache.size >= CACHE_MAX)
+            cache.delete(cache.keys().next().value);
+        cache.set(url, { at: now(), value });
+        return value;
+    }
+    return {
+        async search({ search, cursor }) {
+            const params = new URLSearchParams({ limit: String(PAGE_SIZE), version: "latest" });
+            const query = search?.trim().slice(0, 100);
+            if (query)
+                params.set("search", query);
+            if (cursor)
+                params.set("cursor", cursor.slice(0, 300));
+            return normalizeRegistryPage(await getJson(`${base}/v0/servers?${params}`));
+        },
+        async get(id) {
+            const body = await getJson(`${base}/v0/servers/${encodeURIComponent(id)}/versions/latest`);
+            return body === null ? null : normalizeRegistryEntry(body);
+        },
+    };
+}
+/** A free config name from the server's own name: "notion", then "notion-2". */
+export function freeMcpName(preferred, taken) {
+    const base = slugMcpName(preferred) || "mcp-server";
+    if (!taken(base))
+        return base;
+    for (let n = 2; n < 100; n += 1) {
+        const candidate = `${base.slice(0, 32 - String(n).length - 1)}-${n}`;
+        if (!taken(candidate))
+            return candidate;
+    }
+    return `${base.slice(0, 23)}-${Date.now().toString(36).slice(-8)}`;
+}
+function bridgeEntry(url) {
+    return { command: "npx", args: ["-y", MCP_REMOTE_PACKAGE, url], env: {} };
+}
+function cleanValues(values) {
+    const out = {};
+    for (const [key, value] of Object.entries(record(values))) {
+        if (typeof value === "string" && value.trim())
+            out[key] = value.trim();
+    }
+    return out;
+}
+/** The config entry a featured service becomes: its official URL through the
+ * OAuth bridge. */
+export function planFeaturedAdd(featured, taken) {
+    return { ok: true, name: freeMcpName(featured.id, taken), entry: bridgeEntry(featured.url), kind: "remote", oauth: true };
+}
+/** The config entry a registry server becomes, with the person's values for
+ * its inputs. Required inputs that are missing are refused with the list, so
+ * the renderer can ask for them. */
+export function planRegistryAdd(server, rawValues, taken) {
+    const values = cleanValues(rawValues);
+    const plan = installPlan(server);
+    if (!plan) {
+        const docker = server.packages.some((item) => item.registryType === "oci" || item.registryType === "docker");
+        return {
+            ok: false,
+            status: 400,
+            code: "unsupported",
+            error: docker
+                ? `${server.title} only ships as a Docker image, which Atomic can't add for you yet. Add it by hand under MCP servers.`
+                : `${server.title} doesn't offer a remote address or an npm or PyPI package, so Atomic can't add it for you. Add it by hand under MCP servers.`,
+        };
+    }
+    const inputs = planInputs(plan);
+    const missing = inputs.filter((item) => item.required && !values[item.name]);
+    if (missing.length) {
+        return { ok: false, status: 400, code: "needs_input", inputs, error: `${server.title} needs ${missing.map((item) => item.name).join(", ")} before it can be added.` };
+    }
+    const name = freeMcpName(server.featured ?? server.name.split("/").pop() ?? server.title, taken);
+    if (plan.kind === "remote") {
+        if (plan.oauth)
+            return { ok: true, name, entry: bridgeEntry(plan.remote.url), kind: "remote", oauth: true };
+        const headers = {};
+        for (const header of plan.remote.headers) {
+            const value = values[header.name];
+            if (!value)
+                continue;
+            // "Bearer {api_key}" -> "Bearer <value>" unless the value already is the whole header.
+            headers[header.name] = header.template && /\{[^}]+\}/.test(header.template) && !/\s/.test(value)
+                ? header.template.replace(/\{[^}]+\}/, value)
+                : value;
+        }
+        return { ok: true, name, entry: { type: plan.remote.type, url: plan.remote.url, headers }, kind: "remote", oauth: false };
+    }
+    const env = {};
+    for (const variable of plan.pkg.env) {
+        if (values[variable.name])
+            env[variable.name] = values[variable.name];
+    }
+    const version = plan.pkg.version && SAFE_VERSION.test(plan.pkg.version) ? plan.pkg.version : undefined;
+    if (plan.kind === "npm") {
+        return { ok: true, name, entry: { command: "npx", args: ["-y", version ? `${plan.pkg.identifier}@${version}` : plan.pkg.identifier], env }, kind: "npm", oauth: false };
+    }
+    return { ok: true, name, entry: { command: "uvx", args: [plan.pkg.identifier], env }, kind: "pypi", oauth: false };
+}
+export { featuredMcpServer };