@chibitek/chibi 0.1.157 → 0.1.158

package/dist-server/server/index.js

@@ -68,7 +68,7 @@ import { turnTimingFinish, turnTimingMark, turnTimingStart } from "./turn-timing
 import { ATOMIC_TEAM_PACKAGE_ID, BUILTIN_CHIBI_REFUSALS, builtinChibiPatchRefusal } from "./builtin-chibi.js";
 import { canAccessTeam, canContactTeamOf, canManagePeer, canReachPeer, canReachTeam, coordinatorSupervises, peerAllowed, peerName, peerRosterSystemPrompt, peerStatus, peerStatusWords, reachablePeers, reachesEveryTeam, roomBoundaryHolds, teamStatusPrompt, PEER_ROSTER_MAX, resolveTeammate, roomPeerRosterSystemPrompt, rosterAbout, roomRosterLine, PEER_ACCESS_HELP } from "./peer-roster.js";
 import { openMausStatusSystemPrompt } from "./openmaus-status-capsule.js";
-import { containerComputerAction, managedImageNeedsUpgrade, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, recentContainerComputerStatus, containerRuntimeStatus, ensureContainerRuntime, localVmRecreatableOnDemand, localVmReplaceableWhenStopped, perBotLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, } from "./container-computer.js";
+import { containerComputerAction, managedImageNeedsUpgrade, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, recentContainerComputerStatus, containerRuntimeStatus, ensureContainerRuntime, containerRuntimeError, localVmRecreatableOnDemand, localVmReplaceableWhenStopped, perBotLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, } from "./container-computer.js";
 import { ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmMaxInstances, localVmAutoStartRuntime, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, threadEventLogMaxBytes, maxConcurrentBotThreads, threadEventLogRetentionDays, saveConfig, showToolCallsEnabled, claudeUserMcpEnabled, userMcpEnabledFor, addonEnabled, skillAuthoringEnabled, sharedComputersEnabled, teamRoomsEnabled, builtInBrowserEnabled, llmThreadTitlesEnabled, onDeviceHelpersEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, browserEngineAttachCdpUrl, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, onConfigSaved, accountBotGrantPolicy, } from "./config.js";
 import { sweepThreadEventLogs } from "./thread-retention.js";
 import { GodModeSwitch } from "./god-mode.js";
@@ -263,6 +263,7 @@ import { createProviderAccountRoutes } from "./routes/provider-accounts.js";
 import { accountStops, injectedModel, restScope } from "./injected-model-rest.js";
 import { accountProvider } from "../shared/provider-accounts.js";
 import { createAccountRoutes } from "./routes/accounts.js";
+import { installNativeVault } from "./vault/runtime.js";
 import { OAuthAccounts, takeOAuthClients } from "./oauth-accounts.js";
 import { DesktopAccountVault, FileAccountVault, UnavailableAccountVault, takeAccountsFromEnvironment } from "./oauth-account-vault.js";
 import { accountConnectorNames } from "./claude-account-connectors.js";
@@ -304,6 +305,7 @@ import { createBoardRoutes } from "./routes/board.js";
 import { readBoardFromNexus } from "./board/nexus-board.js";
 import { LocalModelInventory, localModePlacement, machineMemory } from "./local-models-mode.js";
 import { FailoverGate, MAX_ENGINES_PER_TURN, continuationNote, restingLine } from "./engine-failover.js";
+import { enterSessionFallback, onSessionFallback, ownOrFallback, sessionFallbackSpentLine, withoutSubscription } from "./session-fallback.js";
 import { TURN_ERROR_CATEGORIES } from "../shared/runtime-events.js";
 import { EngineProbes, PROBE_PROMPT, isProbeThread, probeThreadId } from "./engine-probe.js";
 // [jev-verifier] opt-in Jev answer checks after a model switch (server/jev).
@@ -1154,9 +1156,14 @@ if (!hostedModels) {
 // its add-on's capability, so it loads only while the add-on applies.
 const bundledSkills = [...loadBundledSkills(), ...loadAddonSkillLibraries()];
 const availableSkills = () => mergeSkills(bundledSkills, loadUserSkills(join(DATA_DIR, "skills")));
+// Electron's utility-process parent port is private to the desktop main
+// process. It carries desktop-only messages (approval and browser control,
+// phone secrets, the account vault) without putting them in the renderer.
+// Plain Node/dev launches have no parentPort.
 // SAFETY: Electron's utility-process runtime is the only environment that
 // supplies parentPort; plain Node intentionally leaves it absent.
 const utilityParentPort = process.parentPort;
+installNativeVault(DATA_DIR, utilityParentPort, () => desktopMutationToken, req => authorizedInternalCapability(req.headers.authorization) !== null);
 function postDesktopPrivateMessage(message) {
     if (!utilityParentPort)
         return false;
@@ -3045,12 +3052,19 @@ function turnEngineChoice(botId, threadId, needs, runOn) {
     if (hostedModels || !profile || !task)
         return undefined;
     if (isSubscriptionBot(profile))
-        return subscriptionTurnEngineChoice(profile, threadId);
+        return ownOrFallback(threadId, () => subscriptionTurnEngineChoice(profile, threadId), () => sessionFallbackChoice(profile, threadId, needs, runOn), (stop) => stop instanceof SubscriptionStop, (stop) => new SubscriptionStop(sessionFallbackSpentLine(stop.message)));
     if (isPersonalBot(profile))
         return personalTurnEngineChoice(profile, threadId, needs, runOn);
     const projected = store.projectBotForTask(botId, threadId);
     return projected ? ladderTurnEngineChoice(profile, projected, threadId, needs, runOn) : undefined;
 }
+/** A company subscription bot's conversation on another provider's subscription, same class (server/session-fallback.ts). */
+function sessionFallbackChoice(profile, threadId, needs, runOn) {
+    const projected = store.projectBotForTask(profile.id, threadId);
+    const choice = isPersonalBot(profile) || !projected ? undefined
+        : ladderTurnEngineChoice(withoutSubscription(profile), withoutSubscription(projected), threadId, needs, runOn, true);
+    return choice && choice.selection.instanceId !== projected.modelSelection.instanceId ? { selection: choice.selection, persist: false } : undefined;
+}
 /** A room member's engine at turn start, by turnEngineChoice's rules for
  * the bot's own default (a room turn has no task of its own, so the bot's
  * engine mode decides): resting and signed-out engines passed over, a
@@ -3066,7 +3080,7 @@ function roomTurnEngineChoice(bot, threadId) {
         : ladderTurnEngineChoice(bot, projected, threadId);
     return choice && { selection: choice.selection, persist: false };
 }
-function ladderTurnEngineChoice(profile, projected, threadId, needs, runOn) {
+function ladderTurnEngineChoice(profile, projected, threadId, needs, runOn, subscriptionsOnly = false) {
     const candidates = engineSnapshots.current();
     if (!candidates)
         return undefined;
@@ -3075,7 +3089,7 @@ function ladderTurnEngineChoice(profile, projected, threadId, needs, runOn) {
     const { ladder } = plan;
     const computer = turnComputer(projected, threadId, runOn);
     const context = { candidates, needsDelegation: needsDelegation(tier, profile), computer, refuse: engineTierRefusal(projected), resting: engineResting,
-        keyBandPaused: payPerUse.pausedUntil() !== undefined };
+        keyBandPaused: subscriptionsOnly || payPerUse.pausedUntil() !== undefined };
     const local = (resolution) => localModeTurn(resolution, { tier, context, needs, prefer: [projected.modelSelection.instanceId] });
     const wider = (tried, modelClass) => resolveFailover({
         ladder, classLadder: (cls) => classLadder(classedModels(), cls), failed: projected.modelSelection, context, tried,
@@ -3812,14 +3826,19 @@ function failoverPick(turn, profile, projected, candidates, failedCandidate, res
     const computer = projected ? turnComputer(projected, turn.threadId, attempt.runOn) : undefined;
     // A subscription bot fails over only to another account of its own
     // provider on its side of the personal line; with none left it stops with
-    // its one line (and the client offers Chibi). Never another provider.
+    // its one line, or a company bot's own conversation takes its session fallback (server/session-fallback.ts).
     const subscriptionMove = isSubscriptionBot(profile)
         ? tried.size >= MAX_ENGINES_PER_TURN || !projected
             ? { line: subscriptionLine(profile, candidates) }
             : subscriptionPlacement({ profile, projected, candidates, tried: new Set([...tried, turn.instanceId]), auto: attempt.persist, modelClass: neededClass })
         : undefined;
-    if (subscriptionMove && !subscriptionMove.choice)
+    const fallback = subscriptionMove && !subscriptionMove.choice && projected && !isPersonalBot(profile) && tried.size < MAX_ENGINES_PER_TURN && store.taskByThread(profile.id, turn.threadId);
+    if (fallback && !enterSessionFallback(turn.threadId, false))
+        return { line: sessionFallbackSpentLine(subscriptionMove.line) };
+    if (subscriptionMove && !subscriptionMove.choice && !fallback)
         return { line: subscriptionMove.line };
+    if (fallback)
+        [profile, projected] = [withoutSubscription(profile), withoutSubscription(projected)];
     const personalTurn = isPersonalBot(profile) && !subscriptionMove;
     // The Private Bot prefers personal engines and opted-in local compute,
     // then company compute. startTurn rechecks company cost on every attempt.
@@ -3839,7 +3858,7 @@ function failoverPick(turn, profile, projected, candidates, failedCandidate, res
         classLadder: (modelClass) => classLadder(classedModels(), modelClass),
         failed: attempt.selection,
         context: { candidates, needsDelegation: needsDelegation(tier, profile), computer, refuse: engineTierRefusal(projected), resting: engineResting,
-            keyBandPaused: keyBandPausedFor(turn.threadId) },
+            keyBandPaused: Boolean(fallback) || keyBandPausedFor(turn.threadId) },
         tried,
         modelClass: neededClass,
         mayDrop: true,
@@ -3855,6 +3874,8 @@ function failoverPick(turn, profile, projected, candidates, failedCandidate, res
             context: { candidates, needsDelegation: needsDelegation(tier, profile), computer, refuse: engineTierRefusal(projected), resting: engineResting } })
             : { ...resolution, local: false };
     const choice = placed.choice && placed.local ? { ...placed.choice, modelClass: "Añejo" } : placed.choice;
+    if (!choice && fallback)
+        return { line: subscriptionMove.line };
     if (!choice && turn.failure?.kind === "provider_error")
         return { passthrough: true };
     if (!choice) {
@@ -3864,11 +3885,11 @@ function failoverPick(turn, profile, projected, candidates, failedCandidate, res
         const resting = resolution.skipped.filter((skip) => skip.reason === "resting" || skip.reason === "tried").map((skip) => skip.instanceId);
         const named = restingNamed([turn.instanceId, ...attempt.tried, ...resting]);
         return {
-            line: restingLine(named, restTime, cannotDriveNamed(candidates, resolution.skipped.map((skip) => skip.instanceId), computer)),
+            line: restingLine(named, restTime, cannotDriveNamed(candidates, resolution.skipped.map((skip) => skip.instanceId), computer), { capped: tried.size >= MAX_ENGINES_PER_TURN }),
             category: named.some((engine) => engine.needsSignIn || engine.keyExpired) ? "account" : "failover_exhausted",
         };
     }
-    if (subscriptionMove) { /* subscriptions only: no pay-per-use episode */ }
+    if (subscriptionMove || fallback) { /* subscriptions only: no pay-per-use episode */ }
     else if (personalMove)
         notePersonalPayPerUse(personalMove);
     else
@@ -6973,15 +6994,15 @@ function localVmSetUp() {
 }
 /** The one gate for starting the container engine (App Settings →
  * Computers): the person's switch, the organisation's policy, and a Local VM
- * actually set up here. Returns what it started ("Colima", "Docker
- * Desktop") once the engine answers, or null. */
+ * actually set up here. Returns what it started (Colima, the only engine
+ * Atomic starts; never Docker Desktop) once it answers, or null. */
 async function startLocalVmRuntime() {
     if (!localVmAutoStartRuntime(cfg) || !managedPolicy.computerAllowed("localVm") || !localVmSetUp())
         return null;
     try {
-        const { status, started } = await ensureContainerRuntime();
-        if (started)
-            console.log(`[local-vm] started ${started}: ${status.daemonUp ? "ready" : "still not answering"}`);
+        const { status, started, error } = await ensureContainerRuntime();
+        if (started || error)
+            console[error ? "error" : "log"](`[local-vm] ${started ? `started ${started}: ${status.daemonUp ? "ready" : "still not answering"}` : "not started"}${error ? `. ${error}` : ""}`);
         return started && status.daemonUp ? started : null;
     }
     catch (error) {
@@ -7493,7 +7514,7 @@ async function unusableAutoPin(bot, threadId, plan, runOn) {
     if (pinned === "vm" && !choice.available && !choice.starting && await startLocalVmRuntime()) {
         choice = await computerChoice(bot, pinned);
     }
-    return choice.available || choice.starting ? null : choice.reason ?? `${surfaceLabel(pinned)} is unavailable`;
+    return choice.available || choice.starting ? null : (pinned === "vm" ? containerRuntimeError() : null) ?? choice.reason ?? `${surfaceLabel(pinned)} is unavailable`;
 }
 function continueComputerSelection(threadId, generation, succeeded) {
     const selection = computerSelectionTurns.get(threadId);
@@ -9632,7 +9653,8 @@ async function startTurn(botId, text, opts) {
             : threadBusy(botId, threadId) ? undefined : turnEngineChoice(botId, threadId, { tools: true, vision: turnHasImages(opts?.userMessage) }, opts?.runOn);
     const tierSelection = engineChoice?.persist ? engineChoice.selection : undefined;
     const projectedBot = store.projectBotForTask(botId, threadId);
-    const bot = projectedBot && engineChoice ? { ...projectedBot, modelSelection: engineChoice.selection } : projectedBot;
+    const fallbackBot = projectedBot && !opts?.engine && onSessionFallback(threadId) ? withoutSubscription(projectedBot) : projectedBot;
+    const bot = fallbackBot && engineChoice ? { ...fallbackBot, modelSelection: engineChoice.selection } : fallbackBot;
     if (!bot)
         throw Object.assign(new Error("no such task"), { status: 404 });
     // Routines and legacy peer delivery already have their own completion
@@ -14311,6 +14333,8 @@ async function readyLocalVmForTurn(botId, target, isCurrent = () => true, onNote
                 onNote?.(`Started ${started} for the Local VM`);
                 status = await containerComputerStatus(undefined, undefined, target);
             }
+            else if (containerRuntimeError() && isCurrent())
+                onNote?.(containerRuntimeError());
         }
         noteLocalVmSeen(target, status);
         if (!isCurrent())

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 };

package/dist-server/server/port-in-use.js

@@ -0,0 +1,21 @@
+import { connect } from "node:net";
+/** True when anything accepts TCP on 127.0.0.1:port, not just an Atomic server. */
+export function portInUse(port) {
+    return new Promise((done) => {
+        const socket = connect({ host: "127.0.0.1", port });
+        socket.setTimeout(1000);
+        socket.once("connect", () => { socket.destroy(); done(true); });
+        socket.once("timeout", () => { socket.destroy(); done(false); });
+        socket.once("error", () => done(false));
+    });
+}
+/** The server binds port and port + 1 (webhooks); report the first busy one. */
+export async function reportBusyPort(port, dataDirFlag) {
+    for (const candidate of [port, Number(process.env.OMB_WEBHOOK_PORT || port + 1)]) {
+        if (!(await portInUse(candidate)))
+            continue;
+        console.error(`Port ${candidate} is already in use by another app. Choose a free port, for example: chibi start --port ${port + 20}${dataDirFlag}`);
+        return true;
+    }
+    return false;
+}

package/dist-server/server/session-fallback.js

@@ -0,0 +1,76 @@
+// Session fallback for company subscription bots (docs/chibitek/engine-tiers.md,
+// "Subscription bots: the one failover exception"). When no account of the
+// bot's own provider can take a turn, one conversation may run on the same
+// class from another provider's subscription for up to SESSION_FALLBACK_TURNS
+// turns. The bot's own default never changes; the next turn tries its own
+// provider first again.
+import { SESSION_FALLBACK_TURNS } from "../shared/subscription-bots.js";
+export { SESSION_FALLBACK_TURNS };
+// ponytail: in memory, so a restart gives a conversation its 50 turns again;
+// persist on the task record if that matters.
+const fallbacks = new Map();
+/** The thread's own provider took this turn: it leaves the fallback (its count stays). */
+export function leaveSessionFallback(threadId) {
+    const entry = fallbacks.get(threadId);
+    if (entry)
+        entry.active = false;
+}
+/** Enter (or stay on) the fallback for this thread. A new turn counts one;
+ * a failover within a turn already on it counts nothing. False once the
+ * conversation has used its turns. */
+export function enterSessionFallback(threadId, newTurn) {
+    const entry = fallbacks.get(threadId) ?? { turns: 0, active: false };
+    if (entry.active && !newTurn)
+        return true;
+    if (entry.turns >= SESSION_FALLBACK_TURNS) {
+        entry.active = false;
+        fallbacks.set(threadId, entry);
+        return false;
+    }
+    entry.turns += 1;
+    entry.active = true;
+    fallbacks.set(threadId, entry);
+    return true;
+}
+/** Turn start for a subscription bot: its own provider's engine (which
+ * leaves the fallback), else, on its stop, the fallback's, counted as a
+ * turn. No fallback keeps the stop; past the limit, `spent` of it. */
+export function ownOrFallback(threadId, own, fallback, isStop, spent) {
+    try {
+        const choice = own();
+        leaveSessionFallback(threadId);
+        return choice;
+    }
+    catch (stop) {
+        if (!isStop(stop))
+            throw stop;
+        let choice;
+        try {
+            choice = fallback();
+        }
+        catch {
+            choice = undefined;
+        }
+        if (choice === undefined)
+            throw stop;
+        if (!enterSessionFallback(threadId, true))
+            throw spent(stop);
+        return choice;
+    }
+}
+export function onSessionFallback(threadId) {
+    return fallbacks.get(threadId)?.active === true;
+}
+export function sessionFallbackTurns(threadId) {
+    return fallbacks.get(threadId)?.turns ?? 0;
+}
+/** The bot as a fallback turn runs it: an ordinary company bot, so the
+ * ladder and every gate read it without the provider lock. */
+export function withoutSubscription(bot) {
+    const { subscription: _subscription, ...rest } = bot;
+    return rest;
+}
+/** The line a company subscription bot stops with once its fallback turns are used. */
+export function sessionFallbackSpentLine(line) {
+    return `${line} This conversation already used its ${SESSION_FALLBACK_TURNS} turns on another provider; download a handoff or hand it to another bot.`;
+}

package/dist-server/server/vault/routes.js

@@ -0,0 +1,43 @@
+import { PASS } from "../routes/table.js";
+import { VaultError } from "./store.js";
+/** The owner is supplied by the authenticated host, never from request JSON.
+ * Authorization runs on reads too, and is checked again after reading a body. */
+export function createVaultRoutes(deps) {
+    return async ({ req, res, path, method, auth, json, readBody }) => {
+        if (path !== "/api/vault" && !path.startsWith("/api/vault/"))
+            return PASS;
+        res.setHeader("cache-control", "no-store");
+        const ownerId = deps.owner(req, auth);
+        if (!ownerId)
+            return json(res, 403, { error: "Only the Vault owner can manage saved items." });
+        const store = deps.store();
+        if (!store)
+            return json(res, 503, { error: "Vault encryption is unavailable. Unlock the secure store and try again." });
+        const item = /^\/api\/vault\/([0-9a-f-]{36})$/.exec(path);
+        if (path !== "/api/vault" && !item)
+            return json(res, 404, { error: "Vault item is unavailable." });
+        if (!(path === "/api/vault" ? ["GET", "POST"] : ["PUT", "DELETE"]).includes(method))
+            return json(res, 405, { error: "Method not allowed." });
+        try {
+            if (method === "GET")
+                return json(res, 200, { items: store.list(ownerId) });
+            const body = method === "DELETE" ? undefined : await readBody(req).catch(() => null);
+            if (deps.owner(req, auth) !== ownerId || deps.store() !== store)
+                return json(res, 403, { error: "Vault access changed. Try again." });
+            if (method === "POST")
+                return json(res, 201, { item: store.create(ownerId, body) });
+            if (method === "PUT" && item)
+                return json(res, 200, { item: store.update(ownerId, item[1], body) });
+            if (method === "DELETE" && item) {
+                store.remove(ownerId, item[1]);
+                return json(res, 200, { removed: true });
+            }
+        }
+        catch (error) {
+            // No raw parser, filesystem, crypto or browser error crosses this route.
+            if (error instanceof VaultError)
+                return json(res, 400, { error: error.message });
+            return json(res, 503, { error: "Vault could not complete the request." });
+        }
+    };
+}