@matterailab/orbcode 0.2.2 → 0.2.4

package/dist/mcp/client.js

@@ -0,0 +1,132 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { VERSION } from "../branding.js";
+import { createAuthTransport, hasOAuth } from "./auth.js";
+/** Build the SDK transport for a server config. For http/sse servers with an
+ *  `oauth` block, returns an auth-aware transport whose `authenticate()` runs
+ *  the OAuth flow (browser redirect or M2M) before `start()`. */
+function buildTransport(name, config, intercept) {
+    if (config.type === "sse") {
+        if (hasOAuth(config)) {
+            const auth = createAuthTransport(name, new URL(config.url), "sse", config.oauth, {
+                headers: config.headers ?? {},
+            }, intercept);
+            return { transport: auth.transport, authenticate: auth.authenticate };
+        }
+        return {
+            transport: new SSEClientTransport(new URL(config.url), {
+                requestInit: { headers: config.headers ?? {} },
+            }),
+        };
+    }
+    if (config.type === "http") {
+        if (hasOAuth(config)) {
+            const auth = createAuthTransport(name, new URL(config.url), "http", config.oauth, {
+                headers: config.headers ?? {},
+            }, intercept);
+            return { transport: auth.transport, authenticate: auth.authenticate };
+        }
+        return {
+            transport: new StreamableHTTPClientTransport(new URL(config.url), {
+                requestInit: { headers: config.headers ?? {} },
+            }),
+        };
+    }
+    // stdio (default)
+    return {
+        transport: new StdioClientTransport({
+            command: config.command,
+            args: config.args ?? [],
+            env: config.env,
+            cwd: config.cwd,
+            stderr: "pipe",
+        }),
+    };
+}
+const CONNECT_TIMEOUT_MS = 30_000;
+const CLIENT_INFO = { name: "orbcode", version: VERSION };
+/** Connect to one MCP server and enumerate its tools. The optional
+ *  `authIntercept` lets the caller surface the OAuth URL in the TUI and
+ *  provide the auth code (from the callback or a manual paste). */
+export async function connectMcpServer(name, config, authIntercept) {
+    const { transport, authenticate } = buildTransport(name, config, authIntercept);
+    const client = new Client(CLIENT_INFO, { capabilities: {} });
+    // For OAuth servers, run the auth flow (browser redirect or M2M) before
+    // connecting. This may open a browser and block until the user authorizes.
+    if (authenticate) {
+        await withTimeout(authenticate(), CONNECT_TIMEOUT_MS, `MCP server "${name}" auth timed out`);
+    }
+    // Wrap connect in a timeout so a hung server doesn't block startup.
+    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `MCP server "${name}" timed out`);
+    const tools = await listServerTools(name, client);
+    return {
+        client,
+        tools,
+        close: async () => {
+            try {
+                await transport.close();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                await client.close();
+            }
+            catch {
+                // best-effort
+            }
+        },
+    };
+}
+/** Enumerate tools from a connected client, namespaced as mcp__<server>__<tool>. */
+export async function listServerTools(server, client) {
+    const result = await client.listTools();
+    return (result.tools ?? []).map((tool) => ({
+        name: `mcp__${server}__${tool.name}`,
+        originalName: tool.name,
+        server,
+        description: tool.description,
+        inputSchema: tool.inputSchema ?? { type: "object", properties: {} },
+    }));
+}
+/** Call a tool on a connected client and return a text result for the model. */
+export async function callMcpTool(connection, originalName, args) {
+    const result = await connection.client.callTool({ name: originalName, arguments: args });
+    const content = (result.content ?? []);
+    const parts = [];
+    for (const block of content) {
+        const type = block.type;
+        if (type === "text" && typeof block.text === "string") {
+            parts.push(block.text);
+        }
+        else if (type === "resource") {
+            const resource = block.resource;
+            if (resource && typeof resource.text === "string")
+                parts.push(resource.text);
+        }
+        else if (type === "image") {
+            parts.push(`[image: ${block.mimeType}]`);
+        }
+        else if (type === "audio") {
+            parts.push(`[audio: ${block.mimeType}]`);
+        }
+        else if (type === "resource_link" && typeof block.uri === "string") {
+            parts.push(`[resource: ${block.uri}]`);
+        }
+    }
+    const text = parts.join("\n") || "(empty MCP tool result)";
+    return { text, isError: Boolean(result.isError) };
+}
+function withTimeout(promise, ms, message) {
+    let timer;
+    const cap = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+        timer.unref?.();
+    });
+    return Promise.race([promise, cap]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}

package/dist/mcp/config.js

@@ -0,0 +1,270 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getConfigDir } from "../config/settings.js";
+/**
+ * MCP server configuration loader.
+ *
+ * Resolution order (lowest precedence first), mirroring Claude Code:
+ *   1. User scope: `~/.orbcode/settings.json` -> `mcpServers`
+ *   2. Project scope: `.mcp.json` in the cwd and every parent directory
+ *      (closer-to-cwd wins on name collisions)
+ *   3. Local scope: `.orbcode/settings.json` -> `mcpServers` (highest precedence)
+ *
+ * `.mcp.json` is the shared, check-into-git project file (Claude Code compatible).
+ * The `mcpServers` block in settings.json is the per-user/per-machine override.
+ */
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Expand ${VAR} and $VAR references in a string using process.env. */
+function expandEnv(value) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, bare) => {
+        const name = braced ?? bare;
+        return process.env[name] ?? "";
+    });
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Normalize an `oauth` config value: boolean, or an object with grant/scope. */
+function normalizeOAuth(raw) {
+    if (raw === true)
+        return true;
+    if (typeof raw === "string" && raw === "true")
+        return true;
+    if (!isPlainObject(raw))
+        return undefined;
+    if (raw.grantType === "client_credentials") {
+        if (typeof raw.clientId !== "string" || typeof raw.clientSecret !== "string")
+            return undefined;
+        return {
+            grantType: "client_credentials",
+            clientId: String(raw.clientId),
+            clientSecret: String(raw.clientSecret),
+            scope: typeof raw.scope === "string" ? raw.scope : undefined,
+        };
+    }
+    if (raw.grantType === "private_key_jwt") {
+        if (typeof raw.clientId !== "string")
+            return undefined;
+        if (typeof raw.algorithm !== "string")
+            return undefined;
+        const privateKey = typeof raw.privateKey === "string" ? raw.privateKey : isPlainObject(raw.privateKey) ? raw.privateKey : undefined;
+        if (privateKey === undefined)
+            return undefined;
+        return {
+            grantType: "private_key_jwt",
+            clientId: String(raw.clientId),
+            privateKey,
+            algorithm: String(raw.algorithm),
+            scope: typeof raw.scope === "string" ? raw.scope : undefined,
+        };
+    }
+    // Plain object (no grantType) → interactive auth-code flow with optional scope.
+    return { scope: typeof raw.scope === "string" ? raw.scope : undefined };
+}
+/** Validate + normalize a single server config object from disk. */
+function normalizeServerConfig(raw) {
+    if (!isPlainObject(raw))
+        return undefined;
+    const type = typeof raw.type === "string" ? raw.type : "stdio";
+    if (type === "stdio") {
+        if (typeof raw.command !== "string" || !raw.command.trim())
+            return undefined;
+        const config = { type: "stdio", command: expandEnv(raw.command) };
+        if (Array.isArray(raw.args)) {
+            config.args = raw.args.map((a) => expandEnv(String(a)));
+        }
+        if (isPlainObject(raw.env)) {
+            const env = {};
+            for (const [k, v] of Object.entries(raw.env)) {
+                if (typeof v === "string")
+                    env[k] = expandEnv(v);
+            }
+            config.env = env;
+        }
+        if (typeof raw.cwd === "string")
+            config.cwd = expandEnv(raw.cwd);
+        return config;
+    }
+    if (type === "http" || type === "sse") {
+        if (typeof raw.url !== "string" || !raw.url.trim())
+            return undefined;
+        const config = {
+            type,
+            url: expandEnv(raw.url),
+        };
+        if (isPlainObject(raw.headers)) {
+            const headers = {};
+            for (const [k, v] of Object.entries(raw.headers)) {
+                if (typeof v === "string")
+                    headers[k] = expandEnv(v);
+            }
+            ;
+            config.headers = headers;
+        }
+        const oauth = normalizeOAuth(raw.oauth);
+        if (oauth !== undefined)
+            config.oauth = oauth;
+        return config;
+    }
+    return undefined;
+}
+/** Validate + normalize a whole `mcpServers` record. */
+function normalizeServers(raw) {
+    if (!isPlainObject(raw))
+        return {};
+    const servers = {};
+    for (const [name, cfg] of Object.entries(raw)) {
+        if (!/^[A-Za-z0-9_-]+$/.test(name))
+            continue;
+        const normalized = normalizeServerConfig(cfg);
+        if (normalized)
+            servers[name] = normalized;
+    }
+    return servers;
+}
+/** Read `mcpServers` from a settings.json file (user or local scope). */
+function readSettingsServers(filePath) {
+    const json = readJson(filePath);
+    if (!json)
+        return {};
+    return normalizeServers(json.mcpServers);
+}
+/** Read a `.mcp.json` file (project scope). */
+function readMcpJson(filePath) {
+    const json = readJson(filePath);
+    if (!json || !isPlainObject(json.mcpServers))
+        return {};
+    return normalizeServers(json.mcpServers);
+}
+/** Walk from cwd up to the filesystem root, collecting directories (root last). */
+function ancestorDirs(cwd) {
+    const dirs = [];
+    let current = path.resolve(cwd);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        dirs.push(current);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return dirs;
+}
+/**
+ * Load and merge MCP server configs from all scopes. Closer-to-cwd and
+ * higher-precedence scopes override earlier ones on name collisions.
+ */
+export function loadMcpConfig(cwd = process.cwd()) {
+    const servers = {};
+    // 1. User scope (~/.orbcode/settings.json -> mcpServers)
+    const userServers = readSettingsServers(path.join(getConfigDir(), "settings.json"));
+    for (const [name, cfg] of Object.entries(userServers)) {
+        servers[name] = { ...cfg, scope: "user" };
+    }
+    // 2. Project scope (.mcp.json, root -> cwd so cwd wins)
+    for (const dir of ancestorDirs(cwd).reverse()) {
+        const projectServers = readMcpJson(path.join(dir, ".mcp.json"));
+        for (const [name, cfg] of Object.entries(projectServers)) {
+            servers[name] = { ...cfg, scope: "project" };
+        }
+    }
+    // 3. Local scope (.orbcode/settings.json -> mcpServers) — highest precedence
+    const localServers = readSettingsServers(path.join(cwd, ".orbcode", "settings.json"));
+    for (const [name, cfg] of Object.entries(localServers)) {
+        servers[name] = { ...cfg, scope: "local" };
+    }
+    return { servers };
+}
+/** Write a `.mcp.json` file in the cwd (project scope). */
+export function writeProjectMcpJson(cwd, servers) {
+    const config = { mcpServers: servers };
+    fs.writeFileSync(path.join(cwd, ".mcp.json"), JSON.stringify(config, null, "\t") + "\n");
+}
+/** Read just the project-scope `.mcp.json` from the cwd (no parent walk). */
+export function readProjectMcpJson(cwd) {
+    return readMcpJson(path.join(cwd, ".mcp.json"));
+}
+/** Read a settings.json file, returning the full object (not just mcpServers). */
+function readFullSettings(filePath) {
+    return readJson(filePath) ?? {};
+}
+/** Write a settings.json file, preserving existing keys. */
+function writeFullSettings(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, "\t") + "\n", { mode: 0o600 });
+}
+/** Path to the settings file for a given scope. */
+function settingsPathForScope(cwd, scope) {
+    if (scope === "user")
+        return path.join(getConfigDir(), "settings.json");
+    return path.join(cwd, ".orbcode", "settings.json");
+}
+/** Path to the config file for a given scope (`.mcp.json` for project,
+ *  settings.json for user/local). */
+export function configPathForScope(cwd, scope) {
+    if (scope === "project")
+        return path.join(cwd, ".mcp.json");
+    return settingsPathForScope(cwd, scope);
+}
+/** Add (or overwrite) a server in the given scope's config file. */
+export function addMcpServer(cwd, name, config, scope) {
+    if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+        throw new Error(`Invalid server name "${name}". Use only letters, numbers, hyphens, and underscores.`);
+    }
+    if (scope === "project") {
+        const existing = readProjectMcpJson(cwd);
+        existing[name] = config;
+        writeProjectMcpJson(cwd, existing);
+    }
+    else {
+        const filePath = settingsPathForScope(cwd, scope);
+        const settings = readFullSettings(filePath);
+        const servers = normalizeServers(settings.mcpServers);
+        servers[name] = config;
+        settings.mcpServers = servers;
+        writeFullSettings(filePath, settings);
+    }
+}
+/** Remove a server from the given scope's config file. Returns true if it
+ *  existed and was removed, false if it wasn't found. */
+export function removeMcpServer(cwd, name, scope) {
+    if (scope === "project") {
+        const existing = readProjectMcpJson(cwd);
+        if (!(name in existing))
+            return false;
+        delete existing[name];
+        writeProjectMcpJson(cwd, existing);
+        return true;
+    }
+    const filePath = settingsPathForScope(cwd, scope);
+    const settings = readFullSettings(filePath);
+    const servers = normalizeServers(settings.mcpServers);
+    if (!(name in servers))
+        return false;
+    delete servers[name];
+    settings.mcpServers = servers;
+    writeFullSettings(filePath, settings);
+    return true;
+}
+/** Find which scope a server name lives in (highest-precedence scope wins).
+ *  Returns undefined if the name isn't configured anywhere. */
+export function findServerScope(cwd, name) {
+    const { servers } = loadMcpConfig(cwd);
+    return servers[name]?.scope;
+}
+/** Remove a server from whichever scope it's configured in. Returns the scope
+ *  it was removed from, or undefined if not found. */
+export function removeMcpServerAnyScope(cwd, name) {
+    const scope = findServerScope(cwd, name);
+    if (!scope)
+        return undefined;
+    removeMcpServer(cwd, name, scope);
+    return scope;
+}

package/dist/mcp/manager.js

@@ -0,0 +1,277 @@
+import { callMcpTool, connectMcpServer } from "./client.js";
+import { configPathForScope, loadMcpConfig } from "./config.js";
+import { hasStoredAuth, isOAuthConfig } from "./auth.js";
+/**
+ * Owns the lifecycle of all MCP server connections for a session.
+ *
+ * On `start()`, it loads the merged config, filters by the enabled/disabled
+ * lists, connects to each enabled server in parallel, and exposes the union of
+ * their tools as OpenAI-compatible tool definitions. The agent calls
+ * `callTool()` for any `mcp__*` tool name; unknown names return an error.
+ */
+export class McpManager {
+    cwd;
+    connections = new Map();
+    configs = new Map();
+    states = new Map();
+    /** server names the user has explicitly disabled (persisted in settings). */
+    disabled;
+    /** server names the user has explicitly enabled (for unapproved project servers). */
+    enabled;
+    /** project-scope server names that require user approval before connecting. */
+    pendingApproval = new Set();
+    started = false;
+    constructor(cwd, disabled, enabled) {
+        this.cwd = cwd;
+        this.disabled = new Set(disabled);
+        this.enabled = new Set(enabled);
+    }
+    /** Load config and connect to all approved, non-disabled servers. */
+    async start() {
+        if (this.started)
+            return this.snapshot();
+        this.started = true;
+        const { servers } = loadMcpConfig(this.cwd);
+        this.configs.clear();
+        this.states.clear();
+        for (const [name, cfg] of Object.entries(servers)) {
+            this.configs.set(name, cfg);
+            this.states.set(name, {
+                name,
+                scope: cfg.scope,
+                status: "disabled",
+                toolCount: 0,
+                disabled: this.disabled.has(name),
+                detail: undefined,
+            });
+        }
+        // Project-scope servers need explicit approval (they ship in the repo).
+        // User/local-scope servers are trusted (the user wrote them).
+        const toConnect = [];
+        for (const [name, cfg] of this.configs) {
+            if (this.disabled.has(name))
+                continue;
+            if (cfg.scope === "project" && !this.enabled.has(name)) {
+                this.pendingApproval.add(name);
+                this.states.get(name).status = "disabled";
+                this.states.get(name).detail = "awaiting approval";
+                continue;
+            }
+            toConnect.push(name);
+        }
+        // At startup, skip the OAuth browser flow for servers with no stored
+        // tokens — mark them needs-auth so the user can auth explicitly from /mcp.
+        await Promise.all(toConnect.map((name) => this.connectOne(name, { skipUnauthOAuth: true })));
+        return this.snapshot();
+    }
+    /** Connect (or reconnect) a single server by name.
+     *  When `skipUnauthOAuth` is set, OAuth servers with no stored tokens are
+     *  marked needs-auth instead of opening a browser (used at startup).
+     *  When `authIntercept` is provided, the caller controls the OAuth UI
+     *  (surfacing the auth URL, providing the code via callback or paste).
+     *  When `forceOAuth` is set, an http/sse server without an explicit `oauth`
+     *  config is treated as `oauth: true` (auto-detected OAuth — used when the
+     *  user triggers auth after a 401). */
+    async connectOne(name, options) {
+        const cfg = this.configs.get(name);
+        if (!cfg)
+            return;
+        const state = this.states.get(name);
+        const isRemote = cfg.type === "http" || cfg.type === "sse";
+        // At startup, don't open a browser for OAuth servers that haven't been
+        // authenticated yet — surface them as needs-auth so the user can trigger
+        // auth explicitly from the /mcp picker. This applies to both explicitly
+        // configured OAuth servers and any remote server (which may require OAuth
+        // we don't know about yet — we'll find out on the first connect attempt).
+        if (options?.skipUnauthOAuth && isOAuthConfig(cfg) && !hasStoredAuth(name)) {
+            state.status = "needs-auth";
+            state.detail = "not authenticated — press a to authenticate";
+            return;
+        }
+        state.status = "connecting";
+        state.detail = undefined;
+        try {
+            const { scope: _scope, ...serverConfig } = cfg;
+            // Auto-detect: if forceOAuth is set and this is a remote server without
+            // explicit oauth config, inject oauth: true so the auth transport is used.
+            if (options?.forceOAuth && isRemote && !isOAuthConfig(cfg)) {
+                ;
+                serverConfig.oauth = true;
+            }
+            const connection = await connectMcpServer(name, serverConfig, options?.authIntercept);
+            this.connections.set(name, connection);
+            state.status = "connected";
+            state.toolCount = connection.tools.length;
+            state.detail = `${connection.tools.length} tool${connection.tools.length === 1 ? "" : "s"}`;
+            this.pendingApproval.delete(name);
+        }
+        catch (error) {
+            const msg = error.message;
+            // Any remote server that returns 401/unauthorized/invalid_token needs
+            // auth — surface as needs-auth regardless of whether `oauth` was
+            // explicitly configured (auto-detection, like Claude Code).
+            if (isRemote && /unauthorized|auth|401|oauth|invalid_token/i.test(msg)) {
+                state.status = "needs-auth";
+                state.detail = "authentication required — press a to authenticate";
+            }
+            else {
+                state.status = "failed";
+                state.detail = msg;
+            }
+        }
+    }
+    /** Disconnect a single server (keeps config; marks it disabled). */
+    async disconnectOne(name) {
+        const connection = this.connections.get(name);
+        if (connection) {
+            await connection.close();
+            this.connections.delete(name);
+        }
+        const state = this.states.get(name);
+        if (state) {
+            state.status = "disabled";
+            state.toolCount = 0;
+            state.detail = undefined;
+        }
+    }
+    /** Enable a project server (approving it) and connect. Uses
+     *  skipUnauthOAuth so enabling doesn't open a browser — the user auths
+     *  explicitly from /mcp. */
+    async enableServer(name) {
+        this.enabled.add(name);
+        this.disabled.delete(name);
+        const state = this.states.get(name);
+        if (state)
+            state.disabled = false;
+        await this.connectOne(name, { skipUnauthOAuth: true });
+    }
+    /** Disable a server and disconnect it. */
+    async disableServer(name) {
+        this.disabled.add(name);
+        this.enabled.delete(name);
+        const state = this.states.get(name);
+        if (state)
+            state.disabled = true;
+        await this.disconnectOne(name);
+    }
+    /** Re-authenticate a server in the needs-auth state: disconnect, clear
+     *  persisted OAuth tokens, then reconnect with `forceOAuth` so even servers
+     *  without an explicit `oauth` config use the OAuth flow (auto-detect).
+     *  The `authIntercept` lets the TUI surface the auth URL and provide the
+     *  code via callback or paste. */
+    async reauthServer(name, authIntercept) {
+        await this.disconnectOne(name);
+        try {
+            const fs = await import("node:fs");
+            const path = await import("node:path");
+            const { getConfigDir } = await import("../config/settings.js");
+            fs.unlinkSync(path.join(getConfigDir(), "mcp-auth", `${name}.json`));
+        }
+        catch {
+            // best-effort; no stored tokens to clear
+        }
+        this.disabled.delete(name);
+        await this.connectOne(name, { authIntercept, forceOAuth: true });
+    }
+    /** Close every connection. Call on session end / exit. */
+    async stop() {
+        await Promise.all([...this.connections.values()].map((c) => c.close().catch(() => { })));
+        this.connections.clear();
+        this.started = false;
+    }
+    /** All tools from all connected servers, as OpenAI tool definitions. */
+    getTools() {
+        const tools = [];
+        for (const connection of this.connections.values()) {
+            for (const tool of connection.tools) {
+                tools.push({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description ?? `MCP tool ${tool.originalName} from server ${tool.server}`,
+                        parameters: tool.inputSchema ?? {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                });
+            }
+        }
+        return tools;
+    }
+    /** Route an `mcp__<server>__<tool>` call to the right connection. */
+    async callTool(toolName, args) {
+        const match = /^mcp__([^_]+)__(.+)$/.exec(toolName);
+        if (!match) {
+            return { text: `Invalid MCP tool name: ${toolName}`, isError: true };
+        }
+        const [, server, originalName] = match;
+        const connection = this.connections.get(server);
+        if (!connection) {
+            return { text: `MCP server "${server}" is not connected.`, isError: true };
+        }
+        try {
+            return await callMcpTool(connection, originalName, args);
+        }
+        catch (error) {
+            return { text: `MCP tool ${toolName} failed: ${error.message}`, isError: true };
+        }
+    }
+    /** True if `toolName` is an MCP tool managed by this manager. */
+    hasTool(toolName) {
+        return /^mcp__[^_]+__/.test(toolName);
+    }
+    /** Current snapshot for the TUI / status display. */
+    snapshot() {
+        return {
+            servers: [...this.states.values()],
+            tools: [...this.connections.values()].flatMap((c) => c.tools),
+        };
+    }
+    /** Project-scope server names awaiting the user's approval. */
+    getPendingApproval() {
+        return [...this.pendingApproval];
+    }
+    /** Persisted enabled list (for saving to settings). */
+    getEnabled() {
+        return [...this.enabled];
+    }
+    /** Persisted disabled list (for saving to settings). */
+    getDisabled() {
+        return [...this.disabled];
+    }
+    /** All configured server names. */
+    getServerNames() {
+        return [...this.configs.keys()];
+    }
+    /** A config by name (for the TUI detail view). */
+    getConfig(name) {
+        return this.configs.get(name);
+    }
+    /** The file path where a server's config lives (for the TUI detail view). */
+    getConfigPath(name) {
+        const cfg = this.configs.get(name);
+        if (!cfg)
+            return undefined;
+        return configPathForScope(this.cwd, cfg.scope);
+    }
+    /** True if a server uses OAuth (explicitly configured or auto-detected from
+     *  a 401/needs-auth state). Remote servers in needs-auth state are treated
+     *  as OAuth so the detail panel shows "not authenticated". */
+    isOAuthServer(name) {
+        const cfg = this.configs.get(name);
+        if (!cfg)
+            return false;
+        if (isOAuthConfig(cfg))
+            return true;
+        // Auto-detect: a remote server in needs-auth state requires OAuth.
+        const state = this.states.get(name);
+        if (state?.status === "needs-auth" && (cfg.type === "http" || cfg.type === "sse"))
+            return true;
+        return false;
+    }
+    /** True if a server has persisted OAuth tokens (already authenticated). */
+    isAuthenticated(name) {
+        return hasStoredAuth(name);
+    }
+}

package/dist/mcp/types.js

@@ -0,0 +1,8 @@
+/**
+ * MCP server configuration and connection types.
+ *
+ * These are OrbCode's own types (not re-exported from the SDK) so the config
+ * layer stays decoupled from the SDK's internal schema shape. The connection
+ * manager converts these into SDK transports/clients.
+ */
+export {};