@agenthippo-ai/agenthippo 1.110.11 → 1.110.19

package/out/mcp.js

@@ -1,654 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGENTHIPPO_MCP_SERVERS_ENV = exports.ALLOW_INLINE_DATA_TOKEN_ENV = void 0;
-exports.loadMcpServers = loadMcpServers;
-exports.resolveMcpEnvVar = resolveMcpEnvVar;
-exports.resolveMcpServerEnv = resolveMcpServerEnv;
-exports.generateCodexMcpConfig = generateCodexMcpConfig;
-exports.getDefaultMcpConfig = getDefaultMcpConfig;
-exports.loadBundledMcpServers = loadBundledMcpServers;
-exports.resolveHttpMcpHeaders = resolveHttpMcpHeaders;
-exports.referenceHttpMcpHeaders = referenceHttpMcpHeaders;
-exports.formatInlineMcpServers = formatInlineMcpServers;
-exports.serializeInlineMcpServers = serializeInlineMcpServers;
-exports.parseInlineMcpServers = parseInlineMcpServers;
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const credential_context_1 = require("./cli/credential-context");
-const paths_1 = require("./agentpack/paths");
-const agentEnvFile_1 = require("./utils/agentEnvFile");
-// -----------------------------------------------------------------------------
-// Constants
-// -----------------------------------------------------------------------------
-/** Special command value indicating a bundled server reference */
-const ENABLE_BUNDLED_COMMAND = 'enable-bundled';
-/** Special command value indicating a bundled server should be explicitly disabled */
-const DISABLE_BUNDLED_COMMAND = 'disable-bundled';
-/** Name of the MCP config file */
-const MCP_CONFIG_FILE = '.mcp.json';
-/** MCP servers subdirectory in base-prompts */
-const MCP_SERVERS_DIR = 'mcp-servers';
-/**
- * Explicit local-dev opt-in: allow the per-turn data credential to be resolved INLINE into
- * MCP child env / `${credential:dataToken}` placeholders. Off by default — in any real
- * deployment the credential must stay in the broker and reach tools only via the loopback
- * data-plane gateway + turn nonce (secure-obo-design §2). Without this flag, a credential-
- * backed value resolves to nothing and the pack's connector fails closed with its own error.
- */
-exports.ALLOW_INLINE_DATA_TOKEN_ENV = 'AGENTHIPPO_ALLOW_INLINE_DATA_TOKEN';
-function inlineDataTokenAllowed() {
-    return /^(1|true)$/i.test(process.env[exports.ALLOW_INLINE_DATA_TOKEN_ENV]?.trim() ?? '');
-}
-const ENV_PLACEHOLDER = /\$\{env:(\w+)\}/g;
-const CREDENTIAL_PLACEHOLDER = /\$\{credential:(\w+)\}/g;
-// -----------------------------------------------------------------------------
-// Main API
-// -----------------------------------------------------------------------------
-/**
- * Load MCP servers for an agent.
- *
- * All agents (including default) load from:
- *   <workspace>/.agentide/agents/<agentId>/mcp/.mcp.json
- *
- * @param agentId - Agent identifier ('default' or pack name)
- * @param workspaceRoot - Workspace root path
- * @param bundledBasePromptsDir - Path to extension's base-prompts directory (for bundled server resolution)
- */
-async function loadMcpServers(agentId, workspaceRoot, bundledBasePromptsDir) {
-    const mcpDir = (0, paths_1.getAgentMcpDir)(workspaceRoot, agentId || paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID);
-    const configPath = path.join(mcpDir, MCP_CONFIG_FILE);
-    if (!await pathExists(configPath)) {
-        return [];
-    }
-    const bundledMcpDir = bundledBasePromptsDir
-        ? path.join(bundledBasePromptsDir, MCP_SERVERS_DIR)
-        : '';
-    return loadMcpConfigFile(configPath, mcpDir, workspaceRoot, bundledMcpDir);
-}
-/**
- * Load MCP servers from a .mcp.json config file.
- *
- * @param configPath - Path to the .mcp.json file
- * @param mcpDir - Directory containing the .mcp.json (for relative path resolution)
- * @param workspaceRoot - Workspace root for .env file loading
- * @param bundledMcpDir - Path to bundled MCP servers directory
- */
-async function loadMcpConfigFile(configPath, mcpDir, workspaceRoot, bundledMcpDir) {
-    let config;
-    try {
-        const raw = await fs_1.promises.readFile(configPath, 'utf-8');
-        config = JSON.parse(raw);
-    }
-    catch (e) {
-        console.warn(`[AgentIDE] Failed to load MCP config from ${configPath}:`, e);
-        return [];
-    }
-    if (!config.mcpServers) {
-        return [];
-    }
-    // Load .env files for environment variable resolution
-    const envSources = await loadEnvFiles(workspaceRoot, mcpDir);
-    const servers = [];
-    for (const [name, entry] of Object.entries(config.mcpServers)) {
-        try {
-            const server = await resolveServerEntry(name, entry, mcpDir, bundledMcpDir, envSources);
-            if (server) {
-                servers.push(server);
-            }
-        }
-        catch (e) {
-            console.warn(`[AgentIDE] Failed to resolve MCP server '${name}':`, e);
-        }
-    }
-    return servers;
-}
-/**
- * Resolve a server entry to a fully resolved McpServerConfig.
- */
-async function resolveServerEntry(name, entry, mcpDir, bundledMcpDir, envSources) {
-    if (entry.command === DISABLE_BUNDLED_COMMAND) {
-        // Explicitly disabled in .mcp.json; skip this server entirely.
-        return null;
-    }
-    if (entry.command === ENABLE_BUNDLED_COMMAND) {
-        // Resolve bundled server
-        return resolveBundledServer(name, entry, bundledMcpDir, envSources);
-    }
-    // HTTP Streamable MCP server — no subprocess needed
-    if (entry.url) {
-        // `${env:VAR}` in the URL resolves against the serve process env (e.g. the
-        // boot-stable AGENTHIPPO_DATA_MCP_URL of the loopback data-plane gateway).
-        const url = entry.url.replace(ENV_PLACEHOLDER, (_, varName) => resolvePlainEnvVar(varName, envSources)).trim();
-        if (!url) {
-            // Placeholder didn't resolve (e.g. gateway-backed entry loaded outside serve):
-            // drop the server rather than hand engines a broken empty-URL entry.
-            return null;
-        }
-        return {
-            name,
-            label: entry.label ?? name,
-            description: entry.description,
-            command: '',
-            args: [],
-            url,
-            headers: resolveHeaders(entry.headers, envSources),
-            bearerTokenEnv: entry.bearerTokenEnv?.trim() || undefined,
-        };
-    }
-    // Custom stdio server - resolve relative paths from mcpDir
-    return {
-        name,
-        label: entry.label ?? name,
-        description: entry.description,
-        command: entry.command ?? '',
-        args: resolveArgs(entry.args, mcpDir),
-        env: resolveEnv(entry.env, envSources),
-    };
-}
-/**
- * Resolve a bundled server reference.
- */
-async function resolveBundledServer(name, entry, bundledMcpDir, envSources) {
-    const bundled = await loadBundledServerConfig(name, bundledMcpDir);
-    if (!bundled) {
-        return null;
-    }
-    const serverDir = path.join(bundledMcpDir, name);
-    // Merge bundled env with user-provided overrides (user env takes precedence)
-    const mergedEnv = { ...(bundled.env ?? {}) };
-    if (entry.env) {
-        for (const [key, value] of Object.entries(entry.env)) {
-            mergedEnv[key] = value;
-        }
-    }
-    return {
-        name,
-        label: entry.label ?? bundled.label ?? name,
-        description: entry.description ?? bundled.description,
-        command: bundled.command,
-        args: resolveArgs(bundled.args, serverDir),
-        env: resolveEnv(mergedEnv, envSources),
-    };
-}
-/**
- * Load a bundled server config from base-prompts/mcp-servers/<name>/mcp.json.
- */
-async function loadBundledServerConfig(name, bundledMcpDir) {
-    if (!bundledMcpDir) {
-        console.warn(`[AgentIDE] Bundled MCP directory unavailable; cannot resolve '${name}'`);
-        return null;
-    }
-    const configPath = path.join(bundledMcpDir, name, 'mcp.json');
-    if (!await pathExists(configPath)) {
-        console.warn(`[AgentIDE] Bundled server '${name}' not found at ${configPath}`);
-        return null;
-    }
-    try {
-        const raw = await fs_1.promises.readFile(configPath, 'utf-8');
-        const config = JSON.parse(raw);
-        if (!config.command || typeof config.command !== 'string') {
-            console.warn(`[AgentIDE] Invalid bundled server config at ${configPath}: missing command`);
-            return null;
-        }
-        return config;
-    }
-    catch (e) {
-        console.warn(`[AgentIDE] Failed to load bundled server config from ${configPath}:`, e);
-        return null;
-    }
-}
-// -----------------------------------------------------------------------------
-// Variable Resolution
-// -----------------------------------------------------------------------------
-/**
- * Resolve variables in args array.
- * - Relative paths (./) are resolved from serverDir
- * - ${serverDir} is resolved to serverDir
- */
-function resolveArgs(args, serverDir) {
-    if (!args) {
-        return [];
-    }
-    return args.map(arg => {
-        let resolved = arg;
-        // Resolve ${serverDir}
-        resolved = resolved.replace(/\$\{serverDir\}/g, serverDir);
-        // Resolve relative paths
-        if (resolved.startsWith('./') || resolved.startsWith('../')) {
-            resolved = path.resolve(serverDir, resolved);
-        }
-        return resolved;
-    });
-}
-/**
- * Resolve ${env:VAR_NAME} in env values.
- *
- * Lookup order (first match wins):
- * 1. process.env (shell environment)
- * 2. Workspace .env file (<workspace>/.env)
- * 3. MCP directory .env file (<mcpDir>/.env)
- *
- * @param env - Environment variables with ${env:VAR_NAME} placeholders
- * @param envSources - Additional env sources to check (loaded from .env files)
- */
-/**
- * Resolve a single ${env:VAR} reference for MCP child processes.
- *
- * The turn's OBO data token is exposed two ways, BOTH gated behind the explicit
- * local-dev opt-in {@link ALLOW_INLINE_DATA_TOKEN_ENV}:
- *   - `${credential:dataToken}` placeholder (pack-author-facing; handled in resolveEnv).
- *   - A configurable set of env-var aliases for packs that reference the token via
- *     `${env:VAR}` directly (`AGENTHIPPO_DATA_TOKEN_ENV_VARS`, comma-separated; empty
- *     by default — inline aliasing must be declared, never ambient).
- *
- * In a real deployment neither fires: the credential stays in the broker and tools reach
- * it via the loopback data-plane gateway + turn nonce (secure-obo-design §3).
- */
-function resolveMcpEnvVar(varName, envSources = {}) {
-    const aliases = getDataTokenEnvAliases();
-    if (varName === 'dataToken') {
-        const tok = (0, credential_context_1.currentCredential)()?.dataToken?.trim();
-        return tok && inlineDataTokenAllowed() ? tok : '';
-    }
-    if (aliases.includes(varName)) {
-        const tok = (0, credential_context_1.currentCredential)()?.dataToken?.trim();
-        if (tok && inlineDataTokenAllowed()) {
-            return tok;
-        }
-    }
-    return process.env[varName] ?? envSources[varName] ?? '';
-}
-/**
- * Env-var names that resolve to the turn's OBO data token when a pack references
- * `${env:VAR}` directly. Empty by default — set `AGENTHIPPO_DATA_TOKEN_ENV_VARS=VAR1,VAR2`
- * (together with the inline opt-in) to enable. The old implicit `DATABRICKS_TOKEN` default
- * was removed with the disk token path: inline credential exposure is now always explicit.
- */
-function getDataTokenEnvAliases() {
-    const raw = process.env.AGENTHIPPO_DATA_TOKEN_ENV_VARS;
-    if (raw !== undefined) {
-        return raw.split(',').map((v) => v.trim()).filter(Boolean);
-    }
-    return [];
-}
-function envValueUsesCredentialDataToken(value) {
-    return /\$\{credential:dataToken\}/.test(value);
-}
-function resolveEnv(env, envSources = {}) {
-    if (!env) {
-        return undefined;
-    }
-    const resolved = {};
-    for (const [key, value] of Object.entries(env)) {
-        CREDENTIAL_PLACEHOLDER.lastIndex = 0;
-        if (envValueUsesCredentialDataToken(value)) {
-            // Credential-backed secret. Baked into spawn env ONLY behind the explicit
-            // local-dev opt-in — the supported transport is the data-plane gateway, where
-            // the credential never leaves the broker process (secure-obo-design §2).
-            const tok = (0, credential_context_1.currentCredential)()?.dataToken?.trim();
-            if (tok) {
-                if (inlineDataTokenAllowed()) {
-                    resolved[key] = tok;
-                }
-                // else: intentionally unset — the connector fails closed with its own error.
-            }
-            else {
-                // No OBO credential (local dev / non-serve context): fall back to env var.
-                const fallback = process.env[key] ?? envSources[key] ?? '';
-                if (fallback) {
-                    resolved[key] = fallback;
-                }
-            }
-            continue;
-        }
-        resolved[key] = value.replace(ENV_PLACEHOLDER, (_, varName) => resolveMcpEnvVar(varName, envSources));
-    }
-    return resolved;
-}
-/** Resolve MCP server env placeholders (exported for tests). */
-function resolveMcpServerEnv(env, envSources = {}) {
-    return resolveEnv(env, envSources);
-}
-/**
- * Resolve `${env:VAR}` placeholders in HTTP MCP server headers and drop entries that resolve
- * to empty (e.g. an unset token env var) so we never send a header like `Authorization: `.
- * Returns undefined when no usable headers remain.
- */
-function resolveHeaders(headers, envSources = {}) {
-    if (!headers) {
-        return undefined;
-    }
-    const resolved = {};
-    for (const [key, value] of Object.entries(headers)) {
-        const rv = value.replace(ENV_PLACEHOLDER, (_, varName) => resolvePlainEnvVar(varName, envSources));
-        if (rv) {
-            resolved[key] = rv;
-        }
-    }
-    return Object.keys(resolved).length > 0 ? resolved : undefined;
-}
-/** Header values resolve env vars only (no credential/dataToken semantics). */
-function resolvePlainEnvVar(varName, envSources) {
-    return process.env[varName] ?? envSources[varName] ?? '';
-}
-/**
- * Load environment variables from .env files.
- *
- * Checks these locations (later files override earlier):
- * 1. <mcpDir>/.env (pack-specific defaults)
- * 2. <workspace>/.env (workspace secrets)
- *
- * Note: process.env always takes priority over .env files.
- */
-async function loadEnvFiles(workspaceRoot, mcpDir) {
-    const envSources = {};
-    // Load in order of priority (lower priority first, so higher priority overwrites)
-    const envFiles = [
-        path.join(mcpDir, '.env'), // Pack MCP .env (lowest priority)
-        path.join(workspaceRoot, '.env'), // Workspace .env (higher priority)
-    ];
-    for (const envFile of envFiles) {
-        const parsed = await parseEnvFile(envFile);
-        Object.assign(envSources, parsed);
-    }
-    return envSources;
-}
-/**
- * Parse a .env file into a key-value object.
- *
- * Supports:
- * - KEY=value
- * - KEY="quoted value"
- * - KEY='single quoted'
- * - # comments
- * - Empty lines
- */
-async function parseEnvFile(filePath) {
-    try {
-        const content = await fs_1.promises.readFile(filePath, 'utf-8');
-        return (0, agentEnvFile_1.parseEnvContent)(content);
-    }
-    catch {
-        // File doesn't exist or can't be read
-        return {};
-    }
-}
-// -----------------------------------------------------------------------------
-// Codex Config Generation
-// -----------------------------------------------------------------------------
-/**
- * Generate MCP servers section for Codex config.toml
- *
- * Format:
- * [mcp_servers.name]
- * command = "node"
- * args = ["/path/to/dist/index.js"]
- * env = { KEY = "value" }
- */
-function generateCodexMcpConfig(servers, options) {
-    if (servers.length === 0) {
-        return '';
-    }
-    // `default_tools_approval_mode = "approve"` is the Codex per-server key that lets MCP
-    // tools run without an interactive prompt. The value enum is prompt|approve — "auto" is
-    // NOT valid: Codex ≥0.131 silently ignores it, defaults the server to `prompt`, and a
-    // headless `codex exec` turn then auto-Cancels the approval elicitation, surfacing as
-    // "user cancelled MCP tool call" on every tool call (verified live against 0.131.0).
-    // Only emit it in headless/serve auto-approve contexts — the interactive IDE path leaves
-    // it unset so users get Codex's normal approval prompts.
-    const approvalLine = options?.autoApprove ? 'default_tools_approval_mode = "approve"' : undefined;
-    const sections = servers.map(s => {
-        // HTTP Streamable MCP server — codex connects via URL, no subprocess
-        if (s.url) {
-            const urlLines = [
-                `[mcp_servers.${s.name}]`,
-                `url = ${JSON.stringify(s.url)}`,
-            ];
-            if (s.bearerTokenEnv) {
-                // The auth token is read from the codex PROCESS env at request time
-                // (per-spawn codexEnv carries the turn nonce) — the config file itself
-                // stays byte-identical across turns, which is what removes the
-                // cross-user config.toml race (secure-obo-design §3.2).
-                urlLines.push(`bearer_token_env_var = ${JSON.stringify(s.bearerTokenEnv)}`);
-            }
-            if (s.headers && Object.keys(s.headers).length > 0) {
-                const headerEntries = Object.entries(s.headers)
-                    .map(([k, v]) => `${JSON.stringify(k)} = ${JSON.stringify(v)}`)
-                    .join(', ');
-                urlLines.push(`http_headers = { ${headerEntries} }`);
-            }
-            if (approvalLine) {
-                urlLines.push(approvalLine);
-            }
-            return urlLines.join('\n');
-        }
-        const lines = [
-            `[mcp_servers.${s.name}]`,
-            `command = ${JSON.stringify(s.command)}`,
-            `args = ${JSON.stringify(s.args)}`,
-        ];
-        if (approvalLine) {
-            lines.push(approvalLine);
-        }
-        if (s.env && Object.keys(s.env).length > 0) {
-            // Use separate [mcp_servers.name.env] section — codex binary requires this form
-            lines.push('', `[mcp_servers.${s.name}.env]`);
-            for (const [k, v] of Object.entries(s.env)) {
-                // Quote the key: env-var names may contain '.', spaces, etc. that are not valid
-                // TOML bare keys (a bare `my.token` would parse as a nested table).
-                lines.push(`${JSON.stringify(k)} = ${JSON.stringify(v)}`);
-            }
-        }
-        return lines.join('\n');
-    });
-    return '\n# MCP Servers (AgentIDE)\n' + sections.join('\n\n');
-}
-// -----------------------------------------------------------------------------
-// Sync Support
-// -----------------------------------------------------------------------------
-/**
- * Get the default .mcp.json config content for syncing to a workspace.
- * This creates the initial config that users can edit.
- *
- * @param bundledBasePromptsDir - Path to extension's base-prompts directory
- */
-async function getDefaultMcpConfig(bundledBasePromptsDir) {
-    const configPath = path.join(bundledBasePromptsDir, MCP_SERVERS_DIR, MCP_CONFIG_FILE);
-    if (!await pathExists(configPath)) {
-        return null;
-    }
-    try {
-        return await fs_1.promises.readFile(configPath, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-}
-// -----------------------------------------------------------------------------
-// Bundled Server Definitions
-// -----------------------------------------------------------------------------
-async function loadBundledMcpServers(basePromptsDir) {
-    const mcpDir = path.join(basePromptsDir, MCP_SERVERS_DIR);
-    if (!await pathExists(mcpDir)) {
-        return [];
-    }
-    const servers = [];
-    let entries;
-    try {
-        entries = await fs_1.promises.readdir(mcpDir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const serverName = entry.name;
-        const config = await loadBundledServerConfig(serverName, mcpDir);
-        if (!config) {
-            continue;
-        }
-        const serverDir = path.join(mcpDir, serverName);
-        servers.push({
-            name: config.name ?? serverName,
-            label: config.label ?? serverName,
-            description: config.description,
-            command: config.command,
-            args: resolveArgs(config.args, serverDir),
-            env: resolveEnv(config.env),
-        });
-    }
-    return servers;
-}
-/** Env var carrying JSON-serialized {@link InlineMcpServers} into custom engine workers. */
-exports.AGENTHIPPO_MCP_SERVERS_ENV = 'AGENTHIPPO_MCP_SERVERS';
-/**
- * Resolve the final HTTP headers for a URL-based MCP server, applying `bearerTokenEnv`
- * against the ENGINE'S per-turn env (process.env + per-spawn patch). Engines that build
- * their MCP config in memory per turn (claude, custom) call this with the same env they
- * hand the engine subprocess, so the turn nonce lands in the request header without ever
- * touching a shared file.
- */
-function resolveHttpMcpHeaders(server, turnEnv) {
-    const headers = { ...(server.headers ?? {}) };
-    if (server.bearerTokenEnv) {
-        const token = turnEnv[server.bearerTokenEnv]?.trim();
-        if (token) {
-            headers['Authorization'] = `Bearer ${token}`;
-        }
-    }
-    return Object.keys(headers).length > 0 ? headers : undefined;
-}
-/**
- * The variable names the Claude CLI's `${NAME}` config expansion accepts. A `bearerTokenEnv`
- * outside this shape would ship a header the CLI sends verbatim, so it falls back to in-memory
- * resolution instead.
- */
-const CLI_EXPANDABLE_ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-/**
- * Claude-engine variant of {@link resolveHttpMcpHeaders}: emit a `${NAME}` REFERENCE and let the
- * CLI expand it from its own environment at connect time, instead of resolving the secret here.
- *
- * The Agent SDK serializes the whole mcpServers object into `--mcp-config <json>` argv, and
- * /proc/<pid>/cmdline is world-readable — no ptrace gate, unlike environ — so a resolved
- * Authorization header there is visible to every uid on the host and to execve-argv audit
- * tooling. The reference keeps the turn nonce at environ-level exposure, which the engine child
- * already carries for the egress CLI. Expansion verified live on CLI 2.1.220, including the
- * failure mode this relies on: an UNSET name passes through literally and the data gateway
- * rejects it — fail closed, never fail open.
- */
-function referenceHttpMcpHeaders(server, turnEnv) {
-    const name = server.bearerTokenEnv;
-    if (name && !CLI_EXPANDABLE_ENV_NAME.test(name)) {
-        return resolveHttpMcpHeaders(server, turnEnv);
-    }
-    const headers = { ...(server.headers ?? {}) };
-    if (name) {
-        headers['Authorization'] = `Bearer \${${name}}`;
-    }
-    return Object.keys(headers).length > 0 ? headers : undefined;
-}
-/**
- * Convert resolved pack MCP servers to the inline record shape engines consume.
- *
- * stdio servers map to `{ command, args, env }`. HTTP Streamable / SSE servers map to
- * `{ type: 'http', url, headers? }` — the Cursor SDK (`@cursor/sdk` McpServerConfig) accepts
- * this shape inline, so remote MCP servers are available to cursor/custom engines, not just
- * to the Codex engine (which gets them via config.toml).
- *
- * `turnEnv` (when provided) resolves each URL server's `bearerTokenEnv` into a concrete
- * Authorization header — pass the same env the engine subprocess will receive.
- */
-function formatInlineMcpServers(servers, turnEnv) {
-    const mcpServers = {};
-    for (const server of servers) {
-        if (server.url) {
-            const headers = resolveHttpMcpHeaders(server, turnEnv ?? process.env);
-            mcpServers[server.name] = {
-                type: 'http',
-                url: server.url,
-                ...(headers ? { headers } : {}),
-            };
-            continue;
-        }
-        mcpServers[server.name] = {
-            command: server.command,
-            args: server.args,
-            ...(server.env && Object.keys(server.env).length > 0 ? { env: server.env } : {}),
-        };
-    }
-    return mcpServers;
-}
-function serializeInlineMcpServers(servers) {
-    if (Object.keys(servers).length === 0) {
-        return undefined;
-    }
-    return JSON.stringify(servers);
-}
-function parseInlineMcpServers(raw) {
-    if (!raw?.trim()) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return undefined;
-        }
-        return parsed;
-    }
-    catch {
-        return undefined;
-    }
-}
-// -----------------------------------------------------------------------------
-// Helpers
-// -----------------------------------------------------------------------------
-/**
- * Check if a path exists on the filesystem.
- */
-async function pathExists(p) {
-    try {
-        await fs_1.promises.access(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}