@agenthippo-ai/agenthippo 0.1.0

package/out/mcp.js

@@ -0,0 +1,597 @@
+"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.AGENTHIPPO_DATA_TOKEN_FILE_ENV = void 0;
+exports.loadMcpServers = loadMcpServers;
+exports.resolveMcpEnvVar = resolveMcpEnvVar;
+exports.mcpConfigCacheSignatureSuffix = mcpConfigCacheSignatureSuffix;
+exports.resolveMcpServerEnv = resolveMcpServerEnv;
+exports.generateCodexMcpConfig = generateCodexMcpConfig;
+exports.getDefaultMcpConfig = getDefaultMcpConfig;
+exports.loadBundledMcpServers = loadBundledMcpServers;
+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';
+/**
+ * Env var passed to stdio MCP child processes: path to the per-turn data credential
+ * file (OBO token, etc.). MCP servers read this file on each tool call — spawn env
+ * is fixed at process start and cannot use AsyncLocalStorage.
+ */
+exports.AGENTHIPPO_DATA_TOKEN_FILE_ENV = 'AGENTHIPPO_DATA_TOKEN_FILE';
+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) {
+        return {
+            name,
+            label: entry.label ?? name,
+            description: entry.description,
+            command: '',
+            args: [],
+            url: entry.url,
+            headers: resolveHeaders(entry.headers, envSources),
+        };
+    }
+    // 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:
+ *   - `${credential:dataToken}` placeholder (pack-author-facing; handled in resolveEnv).
+ *   - A configurable set of env-var aliases (default `DATABRICKS_TOKEN`) for packs that
+ *     reference the token via `${env:VAR}` directly. Override the alias list with the
+ *     `AGENTHIPPO_DATA_TOKEN_ENV_VARS` env var (comma-separated) — keeps this helper
+ *     vendor-neutral instead of hardcoding one provider's token name.
+ *
+ * When a turn-scoped data token file exists, the token is NOT baked into spawn env —
+ * MCP servers read it from AGENTHIPPO_DATA_TOKEN_FILE on each tool call instead.
+ */
+function resolveMcpEnvVar(varName, envSources = {}) {
+    const cred = (0, credential_context_1.currentCredential)();
+    const tokenFile = cred?.dataTokenFile;
+    const aliases = getDataTokenEnvAliases();
+    const isDataTokenVar = varName === 'dataToken' || aliases.includes(varName);
+    if (tokenFile && isDataTokenVar) {
+        // Token lives in the per-turn file (AGENTHIPPO_DATA_TOKEN_FILE); don't bake into spawn env.
+        return '';
+    }
+    if (varName === 'dataToken') {
+        return cred?.dataToken?.trim() ?? '';
+    }
+    if (cred?.dataToken?.trim() && aliases.includes(varName)) {
+        return cred.dataToken.trim();
+    }
+    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. Defaults to `DATABRICKS_TOKEN`; override at deploy time via
+ * `AGENTHIPPO_DATA_TOKEN_ENV_VARS=VAR1,VAR2` (empty value → no aliases).
+ */
+function getDataTokenEnvAliases() {
+    const raw = process.env.AGENTHIPPO_DATA_TOKEN_ENV_VARS;
+    if (raw !== undefined) {
+        return raw.split(',').map((v) => v.trim()).filter(Boolean);
+    }
+    return ['DATABRICKS_TOKEN'];
+}
+function envValueUsesCredentialDataToken(value) {
+    return /\$\{credential:dataToken\}/.test(value);
+}
+/** Suffix for Codex config.toml cache invalidation when MCP credential scope changes. */
+function mcpConfigCacheSignatureSuffix() {
+    const cred = (0, credential_context_1.currentCredential)();
+    const aliases = getDataTokenEnvAliases();
+    if (cred?.dataTokenFile) {
+        return `file:${cred.dataTokenFile}:aliases=${aliases.join(',')}`;
+    }
+    if (cred?.dataToken?.trim()) {
+        return `inline-token:aliases=${aliases.join(',')}`;
+    }
+    return `no-token:aliases=${aliases.join(',')}`;
+}
+function resolveEnv(env, envSources = {}) {
+    if (!env) {
+        return undefined;
+    }
+    const resolved = {};
+    const tokenFile = (0, credential_context_1.currentCredential)()?.dataTokenFile;
+    if (tokenFile) {
+        resolved[exports.AGENTHIPPO_DATA_TOKEN_FILE_ENV] = tokenFile;
+    }
+    for (const [key, value] of Object.entries(env)) {
+        CREDENTIAL_PLACEHOLDER.lastIndex = 0;
+        if (envValueUsesCredentialDataToken(value)) {
+            // Credential-backed secret. When a per-turn token file exists, the key is intentionally
+            // NOT set here: the MCP server reads the token from AGENTHIPPO_DATA_TOKEN_FILE
+            // (injected above) on each tool call, so baking it into spawn env would be redundant
+            // and would leak the turn-scoped token into the long-lived child process env.
+            // Prefer the OBO token file, then inline token, then env fallback.
+            if (tokenFile) {
+                // AGENTHIPPO_DATA_TOKEN_FILE already injected above; don't bake the token here.
+            }
+            else if ((0, credential_context_1.currentCredential)()?.dataToken?.trim()) {
+                resolved[key] = (0, credential_context_1.currentCredential)().dataToken.trim();
+            }
+            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 = "auto"` is the documented Codex 0.122+ per-server key
+    // (values: auto/prompt/approve) that lets MCP tools run without an interactive prompt.
+    // Only emit it in headless/serve auto-approve contexts — the interactive IDE path leaves
+    // it unset so users get Codex's normal approval prompts. The previous `approval_mode =
+    // "never"` was an invalid key/value and was silently ignored by the Codex CLI.
+    const approvalLine = options?.autoApprove ? 'default_tools_approval_mode = "auto"' : 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.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)) {
+                lines.push(`${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';
+/**
+ * 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).
+ */
+function formatInlineMcpServers(servers) {
+    const mcpServers = {};
+    for (const server of servers) {
+        if (server.url) {
+            mcpServers[server.name] = {
+                type: 'http',
+                url: server.url,
+                ...(server.headers && Object.keys(server.headers).length > 0 ? { headers: server.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;
+    }
+}

package/out/permissions.js

@@ -0,0 +1,108 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PERMISSIONS = void 0;
+exports.getDefaultPermissions = getDefaultPermissions;
+exports._resetMappingConfigCache = _resetMappingConfigCache;
+exports.parsePermissions = parsePermissions;
+exports.parseManifestPermissions = parseManifestPermissions;
+exports.enforcePermissions = enforcePermissions;
+exports.toClaudeOptions = toClaudeOptions;
+exports.toCodexOptions = toCodexOptions;
+/**
+ * Default runtime permissions.
+ */
+exports.DEFAULT_PERMISSIONS = {
+    fileAccess: 'full',
+};
+const PERMISSION_MAPPING_CONFIG = {
+    defaults: { fileAccess: 'full' },
+    claude: {
+        readOnly: { permissionMode: 'plan', allowDangerouslySkipPermissions: false },
+        workspaceWrite: { permissionMode: 'acceptEdits', allowDangerouslySkipPermissions: false },
+        fullAccess: { permissionMode: 'bypassPermissions', allowDangerouslySkipPermissions: true },
+    },
+    codex: {
+        approvalPolicy: 'never',
+        readOnly: { sandboxMode: 'read-only' },
+        workspaceWrite: { sandboxMode: 'workspace-write' },
+        fullAccess: { sandboxMode: 'danger-full-access' },
+    },
+};
+/**
+ * Get default permissions from static mapping config.
+ */
+function getDefaultPermissions() {
+    return { ...PERMISSION_MAPPING_CONFIG.defaults };
+}
+/**
+ * No-op compatibility hook retained for existing tests/callers.
+ * @internal
+ */
+function _resetMappingConfigCache() {
+    // no-op: config is now static and in-code
+}
+// =============================================================================
+// Parse from Manifest
+// =============================================================================
+/**
+ * Parse permissions from an agent manifest.
+ * Falls back to defaults for missing fields.
+ */
+function parsePermissions(manifest) {
+    const perms = manifest?.spec?.permissions;
+    const defaults = getDefaultPermissions();
+    return {
+        fileAccess: perms?.fileAccess ?? defaults.fileAccess,
+    };
+}
+/**
+ * Parse effective permissions from manifest.
+ */
+function parseManifestPermissions(manifest) {
+    return parsePermissions(manifest);
+}
+// =============================================================================
+// Enforcement
+// =============================================================================
+/**
+ * Resolve effective permissions with user settings taking precedence.
+ */
+function enforcePermissions(_manifestPerms, userPerms) {
+    return {
+        fileAccess: userPerms.fileAccess,
+    };
+}
+/**
+ * Map unified permissions to Claude SDK options.
+ */
+function toClaudeOptions(perms, workspaceFolders) {
+    const modeOpts = perms.fileAccess === 'read-only'
+        ? PERMISSION_MAPPING_CONFIG.claude.readOnly
+        : (perms.fileAccess === 'workspace-write'
+            ? PERMISSION_MAPPING_CONFIG.claude.workspaceWrite
+            : PERMISSION_MAPPING_CONFIG.claude.fullAccess);
+    return {
+        ...modeOpts,
+        // Writable/read-only workspace modes: constrain to workspace folders
+        // Full mode: undefined lets Claude use its defaults
+        additionalDirectories: perms.fileAccess === 'full' ? undefined : workspaceFolders,
+    };
+}
+/**
+ * Map unified permissions to Codex SDK options.
+ */
+function toCodexOptions(perms, workspaceFolders) {
+    const fileOpts = perms.fileAccess === 'read-only'
+        ? PERMISSION_MAPPING_CONFIG.codex.readOnly
+        : (perms.fileAccess === 'workspace-write'
+            ? PERMISSION_MAPPING_CONFIG.codex.workspaceWrite
+            : PERMISSION_MAPPING_CONFIG.codex.fullAccess);
+    return {
+        approvalPolicy: PERMISSION_MAPPING_CONFIG.codex.approvalPolicy,
+        ...fileOpts,
+        additionalDirectories: workspaceFolders,
+    };
+}