fraim-hub 2.0.204

package/dist/src/cli/mcp/mcp-server-registry.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_MCP_SERVERS = void 0;
+exports.buildProviderMCPServer = buildProviderMCPServer;
+exports.getBaseMCPServer = getBaseMCPServer;
+exports.getProviderMCPServerIds = getProviderMCPServerIds;
+exports.getAllMCPServerIds = getAllMCPServerIds;
+exports.isProviderServer = isProviderServer;
+exports.isHTTPServer = isHTTPServer;
+exports.buildAllBaseServers = buildAllBaseServers;
+const provider_registry_1 = require("../providers/provider-registry");
+const command_resolution_1 = require("./command-resolution");
+const fraim_mcp_latest_launcher_1 = require("./fraim-mcp-latest-launcher");
+exports.BASE_MCP_SERVERS = [
+    {
+        id: 'git',
+        name: 'Git',
+        description: 'Git repository operations (commit, branch, merge, etc.)',
+        buildServer: () => ({
+            command: (0, command_resolution_1.resolveManagedCommand)('npx'),
+            args: ['-y', '@cyanheads/git-mcp-server']
+        })
+    },
+    {
+        id: 'playwright',
+        name: 'Playwright',
+        description: 'Browser automation and testing',
+        buildServer: () => ({
+            command: (0, command_resolution_1.resolveManagedCommand)('npx'),
+            args: ['-y', '@playwright/mcp']
+        })
+    },
+    {
+        id: 'fraim',
+        name: 'FRAIM',
+        description: 'FRAIM job orchestration and mentoring',
+        buildServer: (fraimKey) => {
+            const launcher = (0, fraim_mcp_latest_launcher_1.ensureFraimMcpLatestLauncher)();
+            return {
+                command: launcher.command,
+                args: launcher.args,
+                env: {
+                    // Include API key for IDE configs (Codex, VSCode, etc.)
+                    // The stdio-server will use this if set, otherwise falls back to ~/.fraim/config.json
+                    FRAIM_API_KEY: fraimKey,
+                    FRAIM_REMOTE_URL: 'https://fraim.wellnessatwork.me'
+                }
+            };
+        }
+    }
+];
+// ============================================================================
+// PROVIDER MCP SERVER BUILDER (uses provider registry)
+// ============================================================================
+/**
+ * Build an MCP server for a provider using its definition from the registry
+ */
+async function buildProviderMCPServer(providerId, token, config) {
+    // Get provider definition from registry (server or local fallback)
+    const provider = await (0, provider_registry_1.getProvider)(providerId);
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    if (!provider.mcpServer) {
+        throw new Error(`Provider ${providerId} does not have an MCP server configuration`);
+    }
+    const mcpConfig = provider.mcpServer;
+    // Validate config if provider requires additional config
+    if (provider.hasAdditionalConfig) {
+        const validation = await (0, provider_registry_1.validateProviderConfig)(providerId, config || {});
+        if (!validation.valid) {
+            throw new Error(`${provider.displayName} requires additional configuration: ${validation.missing.join(', ')}`);
+        }
+    }
+    // Build MCP server based on type
+    if (mcpConfig.type === 'http') {
+        return buildHTTPServer(mcpConfig, token);
+    }
+    else {
+        return buildStdioServer(mcpConfig, token, config);
+    }
+}
+/**
+ * Build an HTTP MCP server.
+ * When authHeaderTemplate is absent the provider uses IDE-native OAuth (e.g. GitHub);
+ * write a URL-only entry so the IDE handles the OAuth flow on first tool use.
+ */
+function buildHTTPServer(mcpConfig, token) {
+    if (!mcpConfig.url) {
+        throw new Error('HTTP MCP server requires url');
+    }
+    if (!mcpConfig.authHeaderTemplate) {
+        return {
+            type: 'http',
+            url: mcpConfig.url
+        };
+    }
+    return {
+        type: 'http',
+        url: mcpConfig.url,
+        headers: {
+            Authorization: mcpConfig.authHeaderTemplate.replace('{token}', token)
+        }
+    };
+}
+/**
+ * Build a stdio MCP server
+ */
+function buildStdioServer(mcpConfig, token, config) {
+    if (!mcpConfig.command) {
+        throw new Error('Stdio MCP server requires command');
+    }
+    const resolveTemplate = (template) => {
+        let value = template.replace('{token}', token);
+        if (config) {
+            for (const [configKey, configValue] of Object.entries(config)) {
+                value = value.replace(`{config.${configKey}}`, String(configValue));
+            }
+        }
+        return value;
+    };
+    // Build environment variables from template
+    const env = {};
+    if (mcpConfig.envTemplate) {
+        for (const [key, template] of Object.entries(mcpConfig.envTemplate)) {
+            let value = resolveTemplate(template);
+            // Handle URL normalization for Jira
+            if (key === 'JIRA_URL' && value && !value.startsWith('http')) {
+                value = `https://${value}`;
+            }
+            env[key] = value;
+        }
+    }
+    return {
+        command: (0, command_resolution_1.resolveManagedCommand)(mcpConfig.command),
+        args: (mcpConfig.args || []).map(resolveTemplate),
+        env
+    };
+}
+// ============================================================================
+// REGISTRY LOOKUP FUNCTIONS
+// ============================================================================
+function getBaseMCPServer(id) {
+    return exports.BASE_MCP_SERVERS.find(server => server.id === id);
+}
+async function getProviderMCPServerIds() {
+    // This would need to fetch all providers and filter those with MCP servers
+    // For now, return empty array - this function is not critical
+    return [];
+}
+function getAllMCPServerIds() {
+    // Return only base server IDs
+    // Provider server IDs are dynamic and come from the registry
+    return exports.BASE_MCP_SERVERS.map(s => s.id);
+}
+async function isProviderServer(serverId) {
+    const provider = await (0, provider_registry_1.getProvider)(serverId);
+    return provider !== undefined && provider.mcpServer !== undefined;
+}
+async function isHTTPServer(serverId) {
+    const provider = await (0, provider_registry_1.getProvider)(serverId);
+    return provider?.mcpServer?.type === 'http';
+}
+// ============================================================================
+// BUILDER HELPERS
+// ============================================================================
+function buildAllBaseServers(fraimKey) {
+    const servers = new Map();
+    for (const def of exports.BASE_MCP_SERVERS) {
+        servers.set(def.id, def.buildServer(fraimKey));
+    }
+    return servers;
+}

package/dist/src/cli/providers/local-provider-registry.js

@@ -0,0 +1,165 @@
+"use strict";
+// Local provider registry - fallback when server is unavailable
+// This is the original provider metadata that was in provider-registry.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalProvider = getLocalProvider;
+exports.getAllLocalProviders = getAllLocalProviders;
+exports.getAllLocalProviderIds = getAllLocalProviderIds;
+exports.isValidLocalProviderId = isValidLocalProviderId;
+exports.getLocalProviderDisplayName = getLocalProviderDisplayName;
+exports.getLocalProviderSetupInstructions = getLocalProviderSetupInstructions;
+exports.getLocalProviderConfigRequirements = getLocalProviderConfigRequirements;
+exports.localRequiresAdditionalConfig = localRequiresAdditionalConfig;
+exports.validateLocalProviderConfig = validateLocalProviderConfig;
+exports.getLocalProvidersWithCapability = getLocalProvidersWithCapability;
+exports.getLocalProviderIdsWithCapability = getLocalProviderIdsWithCapability;
+exports.localProviderHasCapability = localProviderHasCapability;
+// Local provider definitions (fallback data)
+const LOCAL_PROVIDERS = [
+    {
+        id: 'github',
+        displayName: 'GitHub',
+        description: 'GitHub repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.github.com',
+        setupInstructions: 'Run "fraim add-provider github" — your IDE handles OAuth automatically on first use',
+        hasAdditionalConfig: false,
+        mcpServer: {
+            type: 'http',
+            url: 'https://api.githubcopilot.com/mcp/'
+        }
+    },
+    {
+        id: 'gitlab',
+        displayName: 'GitLab',
+        description: 'GitLab repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.gitlab.com',
+        setupInstructions: 'Create a Personal Access Token in your GitLab settings',
+        hasAdditionalConfig: false,
+        mcpServer: {
+            type: 'http',
+            url: 'https://gitlab.com/api/v4/mcp',
+            authHeaderTemplate: 'Bearer {token}'
+        }
+    },
+    {
+        id: 'ado',
+        displayName: 'Azure DevOps',
+        description: 'Azure DevOps repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.microsoft.com/azure/devops',
+        setupInstructions: 'Create a Personal Access Token in Azure DevOps',
+        hasAdditionalConfig: true,
+        mcpServer: {
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', '@azure-devops/mcp', '{config.organization}', '--authentication', 'envvar'],
+            envTemplate: {
+                ADO_MCP_AUTH_TOKEN: '{token}'
+            }
+        }
+    },
+    {
+        id: 'jira',
+        displayName: 'Jira',
+        description: 'Jira issue tracking and project management',
+        capabilities: ['issues'],
+        docsUrl: 'https://support.atlassian.com/jira',
+        setupInstructions: 'Create an API token at https://id.atlassian.com/manage-profile/security/api-tokens',
+        hasAdditionalConfig: true,
+        mcpServer: {
+            type: 'stdio',
+            command: 'uvx',
+            args: ['mcp-atlassian'],
+            envTemplate: {
+                JIRA_URL: '{config.baseUrl}',
+                JIRA_USERNAME: '{config.email}',
+                JIRA_API_TOKEN: '{token}'
+            }
+        }
+    }
+];
+const ADO_CONFIG_REQUIREMENTS = [
+    {
+        key: 'organization',
+        displayName: 'Azure DevOps Organization',
+        description: 'Your Azure DevOps organization name (e.g., contoso)',
+        required: true,
+        type: 'string',
+        cliOptionName: 'organization'
+    }
+];
+const JIRA_CONFIG_REQUIREMENTS = [
+    {
+        key: 'baseUrl',
+        displayName: 'Jira Instance URL',
+        description: 'Your Jira instance URL (e.g., mycompany.atlassian.net)',
+        required: true,
+        type: 'url',
+        cliOptionName: 'url'
+    },
+    {
+        key: 'email',
+        displayName: 'Email Address',
+        description: 'Your Jira account email address',
+        required: true,
+        type: 'email'
+    }
+];
+function getLocalProvider(id) {
+    return LOCAL_PROVIDERS.find(p => p.id === id);
+}
+function getAllLocalProviders() {
+    return [...LOCAL_PROVIDERS];
+}
+function getAllLocalProviderIds() {
+    return LOCAL_PROVIDERS.map(p => p.id);
+}
+function isValidLocalProviderId(id) {
+    return LOCAL_PROVIDERS.some(p => p.id === id);
+}
+function getLocalProviderDisplayName(providerId) {
+    const provider = getLocalProvider(providerId);
+    return provider?.displayName || providerId;
+}
+function getLocalProviderSetupInstructions(providerId) {
+    const provider = getLocalProvider(providerId);
+    return provider?.setupInstructions || '';
+}
+function getLocalProviderConfigRequirements(providerId) {
+    if (providerId === 'ado') {
+        return ADO_CONFIG_REQUIREMENTS;
+    }
+    if (providerId === 'jira') {
+        return JIRA_CONFIG_REQUIREMENTS;
+    }
+    return [];
+}
+function localRequiresAdditionalConfig(providerId) {
+    return getLocalProviderConfigRequirements(providerId).length > 0;
+}
+function validateLocalProviderConfig(providerId, config) {
+    const requirements = getLocalProviderConfigRequirements(providerId);
+    const missing = [];
+    for (const req of requirements) {
+        if (req.required && !config[req.key]) {
+            missing.push(req.key);
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing
+    };
+}
+function getLocalProvidersWithCapability(capability) {
+    return LOCAL_PROVIDERS.filter(provider => provider.capabilities.includes(capability));
+}
+function getLocalProviderIdsWithCapability(capability) {
+    const providers = getLocalProvidersWithCapability(capability);
+    return providers.map(p => p.id);
+}
+function localProviderHasCapability(providerId, capability) {
+    const provider = getLocalProvider(providerId);
+    return provider ? provider.capabilities.includes(capability) : false;
+}

package/dist/src/cli/providers/provider-registry.js

@@ -0,0 +1,230 @@
+"use strict";
+// Provider Registry - Client stub that fetches from server
+// This file maintains the same API as before but calls the server instead of using local data
+// Falls back to local registry when server is unavailable (for tests and offline usage)
+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.getProvider = getProvider;
+exports.getAllProviders = getAllProviders;
+exports.getAllProviderIds = getAllProviderIds;
+exports.isValidProviderId = isValidProviderId;
+exports.getProviderDisplayName = getProviderDisplayName;
+exports.getProviderSetupInstructions = getProviderSetupInstructions;
+exports.getProviderConfigRequirements = getProviderConfigRequirements;
+exports.requiresAdditionalConfig = requiresAdditionalConfig;
+exports.validateProviderConfig = validateProviderConfig;
+exports.getProvidersWithCapability = getProvidersWithCapability;
+exports.getProviderIdsWithCapability = getProviderIdsWithCapability;
+exports.providerHasCapability = providerHasCapability;
+const get_provider_client_1 = require("../api/get-provider-client");
+const local = __importStar(require("./local-provider-registry"));
+// ============================================================================
+// CACHE
+// ============================================================================
+let cachedProviders = null;
+const schemaCache = new Map();
+let useLocalFallback = false;
+async function fetchProviders() {
+    // Don't use cache in test environment to avoid stale data
+    const useCache = process.env.NODE_ENV !== 'test';
+    if (useCache && cachedProviders)
+        return cachedProviders;
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            const providers = await client.getAllProviders();
+            if (useCache) {
+                cachedProviders = providers;
+            }
+            return providers;
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            console.warn('⚠️  Using local provider registry (server unavailable)');
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    const providers = local.getAllLocalProviders();
+    if (useCache) {
+        cachedProviders = providers;
+    }
+    return providers;
+}
+async function fetchProviderSchema(id) {
+    if (schemaCache.has(id)) {
+        return schemaCache.get(id);
+    }
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            const schema = await client.getProviderSchema(id);
+            schemaCache.set(id, schema.configRequirements);
+            return schema.configRequirements;
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    const requirements = local.getLocalProviderConfigRequirements(id);
+    schemaCache.set(id, requirements);
+    return requirements;
+}
+// ============================================================================
+// REGISTRY LOOKUP FUNCTIONS (Same API as before, but async)
+// ============================================================================
+async function getProvider(id) {
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            const provider = await client.getProvider(id);
+            return provider || undefined;
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            console.warn('⚠️  Using local provider registry (server unavailable)');
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    const provider = local.getLocalProvider(id);
+    return provider;
+}
+async function getAllProviders() {
+    return await fetchProviders();
+}
+async function getAllProviderIds() {
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            return await client.getAllProviderIds();
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    return local.getAllLocalProviderIds();
+}
+async function isValidProviderId(id) {
+    const providers = await fetchProviders();
+    return providers.some(p => p.id === id);
+}
+async function getProviderDisplayName(providerId) {
+    const provider = await getProvider(providerId);
+    return provider?.displayName || providerId;
+}
+async function getProviderSetupInstructions(providerId) {
+    const provider = await getProvider(providerId);
+    return provider?.setupInstructions || '';
+}
+async function getProviderConfigRequirements(providerId) {
+    return await fetchProviderSchema(providerId);
+}
+async function requiresAdditionalConfig(providerId) {
+    const requirements = await getProviderConfigRequirements(providerId);
+    return requirements.length > 0;
+}
+async function validateProviderConfig(providerId, config) {
+    const requirements = await getProviderConfigRequirements(providerId);
+    const missing = [];
+    for (const req of requirements) {
+        if (req.required && !config[req.key]) {
+            missing.push(req.key);
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing
+    };
+}
+// ============================================================================
+// CAPABILITY FILTERING FUNCTIONS
+// ============================================================================
+async function getProvidersWithCapability(capability) {
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            return await client.getProvidersWithCapability(capability);
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    return local.getLocalProvidersWithCapability(capability);
+}
+async function getProviderIdsWithCapability(capability) {
+    const providers = await getProvidersWithCapability(capability);
+    return providers.map(p => p.id);
+}
+async function providerHasCapability(providerId, capability) {
+    const provider = await getProvider(providerId);
+    return provider ? provider.capabilities.includes(capability) : false;
+}

package/dist/src/cli/setup/claude-code-telemetry.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Configures Claude Code user-level settings for FRAIM token telemetry.
+ *
+ * Writes OTel env vars to ~/.claude/settings.json so ALL Claude Code
+ * sessions push metrics to the FRAIM local proxy's OTLP receiver.
+ * User-level so it works across all projects without per-project setup.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureClaudeCodeTelemetryEnv = ensureClaudeCodeTelemetryEnv;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const TELEMETRY_ENV = {
+    CLAUDE_CODE_ENABLE_TELEMETRY: '1',
+    OTEL_METRICS_EXPORTER: 'otlp',
+    OTEL_EXPORTER_OTLP_PROTOCOL: 'http/json',
+    OTEL_EXPORTER_OTLP_ENDPOINT: 'http://localhost:4318',
+};
+/**
+ * Ensure Claude Code user-level settings include OTel env vars for token telemetry.
+ * Writes to ~/.claude/settings.json. Merges without overwriting user-set values.
+ */
+function ensureClaudeCodeTelemetryEnv() {
+    const settingsDir = path_1.default.join(os_1.default.homedir(), '.claude');
+    const settingsPath = path_1.default.join(settingsDir, 'settings.json');
+    let settings = {};
+    if (fs_1.default.existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            // Corrupt file — will overwrite
+        }
+    }
+    else if (!fs_1.default.existsSync(settingsDir)) {
+        fs_1.default.mkdirSync(settingsDir, { recursive: true });
+    }
+    const existingEnv = settings.env || {};
+    let added = 0;
+    for (const [key, value] of Object.entries(TELEMETRY_ENV)) {
+        if (!(key in existingEnv)) {
+            existingEnv[key] = value;
+            added++;
+        }
+    }
+    if (added > 0) {
+        settings.env = existingEnv;
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log(chalk_1.default.green(`  ✅ Enabled token telemetry in ~/.claude/settings.json (${added} env vars)`));
+    }
+    else {
+        console.log(chalk_1.default.gray(`  ⏭️ Token telemetry already configured in ~/.claude/settings.json`));
+    }
+}

package/dist/src/cli/setup/codex-local-config.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCodexLocalConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const mcp_config_generator_1 = require("./mcp-config-generator");
+const escapeTomlString = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+const buildFraimCwdBlock = (projectRoot) => `
+[mcp_servers.fraim]
+cwd = "${escapeTomlString(projectRoot)}"
+`;
+const ensureCodexLocalConfig = (projectRoot) => {
+    const codexDir = path_1.default.join(projectRoot, '.codex');
+    const codexConfigPath = path_1.default.join(codexDir, 'config.toml');
+    if (!fs_1.default.existsSync(codexDir)) {
+        fs_1.default.mkdirSync(codexDir, { recursive: true });
+    }
+    const hadExistingFile = fs_1.default.existsSync(codexConfigPath);
+    const existingContent = hadExistingFile ? fs_1.default.readFileSync(codexConfigPath, 'utf8') : '';
+    const generatedContent = buildFraimCwdBlock(projectRoot);
+    const mergeResult = (0, mcp_config_generator_1.mergeTomlMCPServers)(existingContent, generatedContent, ['fraim']);
+    const normalizedExisting = existingContent.replace(/\r\n/g, '\n');
+    const normalizedMerged = mergeResult.content.replace(/\r\n/g, '\n');
+    const shouldWrite = !hadExistingFile || normalizedExisting !== normalizedMerged;
+    if (shouldWrite) {
+        fs_1.default.writeFileSync(codexConfigPath, mergeResult.content);
+    }
+    return {
+        path: codexConfigPath,
+        created: !hadExistingFile,
+        updated: shouldWrite && hadExistingFile
+    };
+};
+exports.ensureCodexLocalConfig = ensureCodexLocalConfig;