@chibitek/chibi 0.1.155 → 0.1.157

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

@@ -1,249 +0,0 @@
-// 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/mcp-public-registry.js

@@ -1,325 +0,0 @@
-// 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/shared/connector-availability.js

@@ -1,12 +0,0 @@
-const MANAGED_CUSTOM_AUTH_TOOLKITS = new Set(["twitter", "x"]);
-/**
- * Some Composio toolkits no longer include provider-managed credentials.
- * The official OpenMausBot broker cannot offer those connections until its
- * project owns the corresponding OAuth app. Self-hosted Composio projects can
- * still supply their own auth config, so keep this restriction mode-specific.
- */
-export function managedConnectorUnavailableReason(mode, slug) {
-    if (mode !== "managed" || !MANAGED_CUSTOM_AUTH_TOOLKITS.has(slug.trim().toLowerCase()))
-        return null;
-    return "Twitter/X needs your own X Developer app and Composio auth config. Use self-hosted connected apps for now.";
-}