fraim-hub 2.0.204

package/dist/src/cli/setup/mcp-config-generator.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateCopilotCliMCPServers = exports.generateGeminiCliMCPServers = exports.generateVSCodeMCPServers = exports.generateGrokMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateClaudeCodeMCPServers = exports.generateClaudeMCPServers = exports.generateStandardMCPServers = exports.mergeTomlMCPServers = exports.extractTomlMcpServerBlock = void 0;
+const mcp_server_builder_1 = require("../mcp/mcp-server-builder");
+const ide_formats_1 = require("../mcp/ide-formats");
+const normalizeTokens = (tokenInput) => {
+    if (!tokenInput)
+        return {};
+    if (typeof tokenInput === 'string') {
+        return tokenInput ? { github: tokenInput } : {};
+    }
+    return tokenInput;
+};
+const findTomlServerBlockRange = (content, server) => {
+    const lines = content.split(/\r?\n/);
+    const serverSection = `mcp_servers.${server}`;
+    const serverHeader = `[${serverSection}]`;
+    const start = lines.findIndex(line => line.trim() === serverHeader);
+    if (start === -1) {
+        return null;
+    }
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        const sectionMatch = lines[i].trim().match(/^\[([^\]]+)\]$/);
+        if (!sectionMatch)
+            continue;
+        const sectionName = sectionMatch[1];
+        if (sectionName === serverSection || sectionName.startsWith(`${serverSection}.`)) {
+            continue;
+        }
+        end = i;
+        break;
+    }
+    return { start, end };
+};
+const extractTomlMcpServerBlock = (content, server) => {
+    const range = findTomlServerBlockRange(content, server);
+    if (!range)
+        return null;
+    const lines = content.split(/\r?\n/);
+    return lines.slice(range.start, range.end).join('\n').trim();
+};
+exports.extractTomlMcpServerBlock = extractTomlMcpServerBlock;
+const removeTomlMcpServerBlock = (content, server) => {
+    const range = findTomlServerBlockRange(content, server);
+    if (!range)
+        return content;
+    const lines = content.split(/\r?\n/);
+    const updated = [...lines.slice(0, range.start), ...lines.slice(range.end)].join('\n');
+    return updated.replace(/\n{3,}/g, '\n\n').trimEnd();
+};
+const appendTomlBlock = (content, block) => {
+    const trimmedContent = content.trimEnd();
+    const trimmedBlock = block.trim();
+    if (!trimmedBlock)
+        return trimmedContent;
+    if (!trimmedContent)
+        return `${trimmedBlock}\n`;
+    return `${trimmedContent}\n\n${trimmedBlock}\n`;
+};
+const mergeTomlMCPServers = (existingContent, generatedContent, servers) => {
+    let merged = existingContent || '';
+    const addedServers = [];
+    const replacedServers = [];
+    const skippedServers = [];
+    for (const server of servers) {
+        const newBlock = (0, exports.extractTomlMcpServerBlock)(generatedContent, server);
+        if (!newBlock) {
+            skippedServers.push(server);
+            continue;
+        }
+        const existingBlock = (0, exports.extractTomlMcpServerBlock)(merged, server);
+        if (existingBlock && existingBlock.trim() === newBlock.trim()) {
+            skippedServers.push(server);
+            continue;
+        }
+        if (existingBlock) {
+            merged = removeTomlMcpServerBlock(merged, server);
+            merged = appendTomlBlock(merged, newBlock);
+            replacedServers.push(server);
+            continue;
+        }
+        merged = appendTomlBlock(merged, newBlock);
+        addedServers.push(server);
+    }
+    return {
+        content: merged.trimEnd() + '\n',
+        addedServers,
+        replacedServers,
+        skippedServers
+    };
+};
+exports.mergeTomlMCPServers = mergeTomlMCPServers;
+// Helper function to add all provider servers with their configs
+const addProviderServers = async (builder, tokens, providerConfigs) => {
+    for (const [providerId, token] of Object.entries(tokens)) {
+        if (token) {
+            // Get provider-specific config if it exists
+            const config = providerConfigs?.[providerId];
+            await builder.addProvider(providerId, token, config);
+        }
+    }
+};
+const generateStandardMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    // Dynamically add provider servers based on available tokens
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('standard');
+    return format.transform(builder.getServers());
+};
+exports.generateStandardMCPServers = generateStandardMCPServers;
+const generateClaudeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    // Claude Desktop does not support HTTPS MCP servers (GitHub, GitLab, Jira)
+    // These cause Claude Desktop to break on boot
+    // See: https://github.com/mathursrus/FRAIM/issues/132
+    // The ClaudeFormat adapter will filter out HTTP servers
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('claude');
+    return format.transform(builder.getServers());
+};
+exports.generateClaudeMCPServers = generateClaudeMCPServers;
+const generateClaudeCodeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('claude-code');
+    return format.transform(builder.getServers());
+};
+exports.generateClaudeCodeMCPServers = generateClaudeCodeMCPServers;
+const generateKiroMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('kiro');
+    return format.transform(builder.getServers());
+};
+exports.generateKiroMCPServers = generateKiroMCPServers;
+const generateCodexMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('codex');
+    return format.transform(builder.getServers());
+};
+exports.generateCodexMCPServers = generateCodexMCPServers;
+const generateGrokMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('grok');
+    return format.transform(builder.getServers());
+};
+exports.generateGrokMCPServers = generateGrokMCPServers;
+const generateVSCodeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('vscode');
+    return format.transform(builder.getServers());
+};
+exports.generateVSCodeMCPServers = generateVSCodeMCPServers;
+const generateGeminiCliMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('gemini-cli');
+    return format.transform(builder.getServers());
+};
+exports.generateGeminiCliMCPServers = generateGeminiCliMCPServers;
+const generateCopilotCliMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('copilot-cli');
+    return format.transform(builder.getServers());
+};
+exports.generateCopilotCliMCPServers = generateCopilotCliMCPServers;
+const generateWindsurfMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('windsurf');
+    return format.transform(builder.getServers());
+};
+exports.generateWindsurfMCPServers = generateWindsurfMCPServers;
+const generateMCPConfig = async (configType, fraimKey, tokenInput, providerConfigs) => {
+    switch (configType) {
+        case 'standard':
+            return await (0, exports.generateStandardMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'claude':
+            return await (0, exports.generateClaudeMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'claude-code':
+            return await (0, exports.generateClaudeCodeMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'kiro':
+            return await (0, exports.generateKiroMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'vscode':
+            return await (0, exports.generateVSCodeMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'gemini-cli':
+            return await (0, exports.generateGeminiCliMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'copilot-cli':
+            return await (0, exports.generateCopilotCliMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'codex':
+            return await (0, exports.generateCodexMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'grok':
+            return await (0, exports.generateGrokMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'windsurf':
+            return await (0, exports.generateWindsurfMCPServers)(fraimKey, tokenInput, providerConfigs);
+        default:
+            throw new Error(`Unsupported config type: ${configType}`);
+    }
+};
+exports.generateMCPConfig = generateMCPConfig;

package/dist/src/cli/setup/provider-prompts.js

@@ -0,0 +1,339 @@
+"use strict";
+// Generic provider prompt system - no hardcoded provider knowledge
+// All provider information comes from the server via ProviderClient
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForProviders = promptForProviders;
+exports.promptForSingleProvider = promptForSingleProvider;
+exports.promptForProviderToken = promptForProviderToken;
+exports.promptForProviderConfig = promptForProviderConfig;
+exports.promptForProviderCredentials = promptForProviderCredentials;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+/**
+ * Prompt user to select multiple providers
+ */
+async function promptForProviders(client, preselectedIds) {
+    console.log(chalk_1.default.blue('\n🔧 Platform Selection'));
+    console.log(chalk_1.default.gray('Which platforms do you want to integrate with?\n'));
+    // Get providers that support integrated mode
+    const integratedProviders = await client.getProvidersWithCapability('integrated');
+    // Default to first integrated provider (typically GitHub)
+    const defaultProviderId = integratedProviders[0]?.id;
+    const choices = integratedProviders.map(provider => ({
+        title: provider.displayName,
+        value: provider.id,
+        selected: preselectedIds?.includes(provider.id) ?? provider.id === defaultProviderId
+    }));
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        console.log(chalk_1.default.yellow(`\nℹ️  Non-interactive mode: defaulting to ${integratedProviders[0]?.displayName || 'first available provider'}`));
+        return [defaultProviderId];
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'multiselect',
+        name: 'providers',
+        message: 'Select platforms (Space to select, Enter to confirm)',
+        choices,
+        min: 1
+    });
+    if (!response.providers || response.providers.length === 0) {
+        const defaultProvider = await client.getProvider(defaultProviderId);
+        console.log(chalk_1.default.yellow(`\nℹ️  No platforms selected, defaulting to ${defaultProvider?.displayName || 'first available provider'}`));
+        return [defaultProviderId];
+    }
+    console.log(chalk_1.default.blue('\n✓ Selected platforms:'));
+    for (const id of response.providers) {
+        const provider = await client.getProvider(id);
+        if (provider) {
+            console.log(chalk_1.default.gray(`  - ${provider.displayName}`));
+        }
+    }
+    console.log();
+    return response.providers;
+}
+/**
+ * Prompt user to select a single provider (for code repo or issue tracking)
+ */
+async function promptForSingleProvider(client, purpose, availableIds) {
+    const purposeLabel = purpose === 'code' ? 'Code Repository' : 'Issue Tracking';
+    const purposeDesc = purpose === 'code' ? 'code hosting' : 'issue tracking';
+    console.log(chalk_1.default.blue(`\n📦 ${purposeLabel} Platform`));
+    console.log(chalk_1.default.gray(`Select the platform for ${purposeDesc}:\n`));
+    // Use capability-based filtering if no explicit filter provided
+    let providers;
+    if (availableIds) {
+        providers = [];
+        for (const id of availableIds) {
+            const provider = await client.getProvider(id);
+            if (provider)
+                providers.push(provider);
+        }
+    }
+    else {
+        providers = await client.getProvidersWithCapability(purpose);
+    }
+    // Default to first available provider
+    const defaultProviderId = providers[0]?.id;
+    const choices = providers.map(provider => ({
+        title: provider.displayName,
+        value: provider.id
+    }));
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        console.log(chalk_1.default.yellow(`\nℹ️  Non-interactive mode: defaulting to ${providers[0]?.displayName || 'first available provider'}`));
+        return defaultProviderId;
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'provider',
+        message: `Select ${purposeDesc} platform`,
+        choices,
+        initial: 0
+    });
+    if (!response.provider) {
+        const defaultProvider = await client.getProvider(defaultProviderId);
+        console.log(chalk_1.default.yellow(`\nℹ️  No platform selected, defaulting to ${defaultProvider?.displayName || 'first available provider'}`));
+        return defaultProviderId;
+    }
+    const provider = await client.getProvider(response.provider);
+    if (provider) {
+        console.log(chalk_1.default.blue(`\n✓ ${purposeLabel}: ${provider.displayName}\n`));
+    }
+    return response.provider;
+}
+/**
+ * Prompt for a provider's token
+ */
+async function promptForProviderToken(client, providerId) {
+    let provider;
+    try {
+        provider = await client.getProvider(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    console.log(chalk_1.default.blue(`\n🔧 ${provider.displayName} Integration Setup`));
+    console.log(`FRAIM requires a ${provider.displayName} token for integration.\n`);
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        throw new Error(`Non-interactive mode: ${provider.displayName} token is missing and cannot prompt.`);
+    }
+    const hasToken = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'hasToken',
+        message: `Do you have a ${provider.displayName} token?`,
+        initial: false
+    });
+    if (!hasToken.hasToken) {
+        if (providerId === 'github') {
+            const loginChoice = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'login',
+                message: `Would you like to login to ${provider.displayName} now using your browser? (Recommended)`,
+                initial: true
+            });
+            if (loginChoice.login) {
+                const { DeviceFlowService } = await Promise.resolve().then(() => __importStar(require('../internal/device-flow-service')));
+                if (!provider.deviceFlowConfig) {
+                    throw new Error(`Device flow configuration not found for provider: ${providerId}`);
+                }
+                const deviceFlow = new DeviceFlowService(provider.deviceFlowConfig);
+                try {
+                    return await deviceFlow.login();
+                }
+                catch (e) {
+                    console.log(chalk_1.default.yellow('\nBrowser login failed or was cancelled. Fallback to manual token entry.'));
+                }
+            }
+        }
+        console.log(chalk_1.default.yellow(`\n📝 To create a ${provider.displayName} token:`));
+        console.log(chalk_1.default.gray(`   ${provider.setupInstructions}`));
+        console.log(chalk_1.default.gray(`   Visit: ${provider.docsUrl}\n`));
+    }
+    let token = null;
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (!token && attempts < maxAttempts) {
+        const tokenResponse = await (0, prompts_1.default)({
+            type: 'password',
+            name: 'token',
+            message: attempts === 0
+                ? `Enter your ${provider.displayName} token`
+                : `Enter your ${provider.displayName} token (attempt ${attempts + 1}/${maxAttempts})`,
+            validate: (value) => {
+                if (!value)
+                    return `${provider.displayName} token is required`;
+                return true;
+            }
+        });
+        if (!tokenResponse.token) {
+            console.log(chalk_1.default.red(`\n❌ ${provider.displayName} token is required.`));
+            attempts++;
+            if (attempts < maxAttempts) {
+                const retry = await (0, prompts_1.default)({
+                    type: 'confirm',
+                    name: 'retry',
+                    message: 'Would you like to try entering the token again?',
+                    initial: true
+                });
+                if (!retry.retry)
+                    break;
+            }
+            continue;
+        }
+        token = tokenResponse.token;
+        console.log(chalk_1.default.green(`✅ ${provider.displayName} token received\n`));
+    }
+    if (!token) {
+        throw new Error(`Failed to get ${provider.displayName} token`);
+    }
+    return token;
+}
+/**
+ * Prompt for additional provider configuration (e.g., Jira URL and email)
+ */
+async function promptForProviderConfig(client, providerId) {
+    let provider;
+    let schema;
+    try {
+        provider = await client.getProvider(providerId);
+        schema = await client.getProviderSchema(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider, getLocalProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${providerId}`);
+        }
+        schema = { configRequirements: getLocalProviderConfigRequirements(providerId) };
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    const requirements = schema.configRequirements;
+    if (requirements.length === 0) {
+        return {};
+    }
+    console.log(chalk_1.default.blue(`\n🔧 ${provider.displayName} Configuration`));
+    console.log(`Additional configuration required for ${provider.displayName}.\n`);
+    const config = {};
+    for (const req of requirements) {
+        if (process.env.FRAIM_NON_INTERACTIVE) {
+            if (req.required) {
+                throw new Error(`Non-interactive mode: Required configuration "${req.displayName}" for ${provider.displayName} is missing.`);
+            }
+            console.log(chalk_1.default.yellow(`\nℹ️  Non-interactive mode: skipping optional configuration "${req.displayName}"`));
+            continue;
+        }
+        const response = await (0, prompts_1.default)({
+            type: req.type === 'email' ? 'text' : req.type === 'url' ? 'text' : 'text',
+            name: 'value',
+            message: `Enter ${req.displayName}`,
+            validate: (value) => {
+                if (req.required && !value) {
+                    return `${req.displayName} is required`;
+                }
+                if (req.type === 'email' && value && !value.includes('@')) {
+                    return 'Please enter a valid email address';
+                }
+                if (req.type === 'url' && value) {
+                    try {
+                        new URL(value.startsWith('http') ? value : `https://${value}`);
+                    }
+                    catch {
+                        return 'Please enter a valid URL';
+                    }
+                }
+                return true;
+            }
+        });
+        if (!response.value && req.required) {
+            throw new Error(`${req.displayName} is required`);
+        }
+        config[req.key] = response.value;
+    }
+    console.log(chalk_1.default.green(`✅ ${provider.displayName} configuration received\n`));
+    return config;
+}
+/**
+ * Get token and config for a provider (handles both token and additional config)
+ */
+async function promptForProviderCredentials(client, providerId, existingToken, existingConfig) {
+    let provider;
+    let schema;
+    try {
+        provider = await client.getProvider(providerId);
+        schema = await client.getProviderSchema(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider, getLocalProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${providerId}`);
+        }
+        schema = { configRequirements: getLocalProviderConfigRequirements(providerId) };
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    // Get token if not provided
+    const token = existingToken || await promptForProviderToken(client, providerId);
+    // Get additional config if needed
+    const requirements = schema.configRequirements;
+    let config;
+    if (requirements.length > 0) {
+        // Check if we have all required config
+        const hasAllConfig = existingConfig && requirements.every(req => !req.required || existingConfig[req.key]);
+        if (!hasAllConfig) {
+            config = await promptForProviderConfig(client, providerId);
+            // Merge with existing config
+            if (existingConfig) {
+                config = { ...existingConfig, ...config };
+            }
+        }
+        else {
+            config = existingConfig;
+        }
+    }
+    return { token, config };
+}

package/dist/src/cli/utils/managed-agent-paths.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManagedNodeRoot = getManagedNodeRoot;
+exports.getPortableNodeBinPath = getPortableNodeBinPath;
+exports.getManagedAgentBinDirs = getManagedAgentBinDirs;
+exports.stripManagedAgentBinDirsFromPath = stripManagedAgentBinDirsFromPath;
+exports.appendBinDirsToPath = appendBinDirsToPath;
+exports.getNpmGlobalBinDirsFromPrefix = getNpmGlobalBinDirsFromPrefix;
+exports.resolveNpmGlobalBinDirs = resolveNpmGlobalBinDirs;
+exports.buildPathWithManagedAgentBins = buildPathWithManagedAgentBins;
+exports.appendManagedAgentBinDirsToProcessPath = appendManagedAgentBinDirsToProcessPath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const script_sync_utils_1 = require("./script-sync-utils");
+function getManagedNodeRoot() {
+    return path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'node');
+}
+function getPortableNodeBinPath() {
+    const nodeRoot = getManagedNodeRoot();
+    if (process.platform === 'win32') {
+        if (fs_1.default.existsSync(nodeRoot)) {
+            const extractedDir = fs_1.default.readdirSync(nodeRoot, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('node-v'))
+                .sort((a, b) => b.name.localeCompare(a.name))[0];
+            if (extractedDir) {
+                return path_1.default.join(nodeRoot, extractedDir.name);
+            }
+        }
+        return nodeRoot;
+    }
+    return path_1.default.join(nodeRoot, 'bin');
+}
+function getManagedAgentBinDirs() {
+    const nodeRoot = getManagedNodeRoot();
+    const portableNodeBin = getPortableNodeBinPath();
+    const candidates = process.platform === 'win32'
+        ? [nodeRoot, portableNodeBin]
+        : [nodeRoot, path_1.default.join(nodeRoot, 'bin'), portableNodeBin];
+    return [...new Set(candidates.filter(Boolean))];
+}
+function normalizePathEntry(entry) {
+    const resolved = path_1.default.resolve(entry.trim());
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+function uniquePathEntries(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries.filter(Boolean)) {
+        const normalized = normalizePathEntry(entry);
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(entry);
+    }
+    return result;
+}
+function stripManagedAgentBinDirsFromPath(basePath) {
+    const managed = new Set(getManagedAgentBinDirs().map(normalizePathEntry));
+    return (basePath ?? process.env.PATH ?? '')
+        .split(path_1.default.delimiter)
+        .filter(Boolean)
+        .filter((entry) => !managed.has(normalizePathEntry(entry)))
+        .join(path_1.default.delimiter);
+}
+function appendBinDirsToPath(basePath, binDirs) {
+    const existing = (basePath ?? '').split(path_1.default.delimiter).filter(Boolean);
+    return uniquePathEntries([...existing, ...binDirs]).join(path_1.default.delimiter);
+}
+function getNpmGlobalBinDirsFromPrefix(prefix) {
+    const trimmed = prefix.trim();
+    if (!trimmed)
+        return [];
+    const resolved = path_1.default.resolve(trimmed);
+    const candidates = process.platform === 'win32'
+        ? [resolved, path_1.default.join(resolved, 'bin')]
+        : [path_1.default.join(resolved, 'bin')];
+    return uniquePathEntries(candidates);
+}
+function buildChildEnv(env) {
+    const childEnv = { ...process.env };
+    for (const [key, value] of Object.entries(env || {})) {
+        if (value === undefined)
+            delete childEnv[key];
+        else
+            childEnv[key] = value;
+    }
+    return childEnv;
+}
+function resolveNpmGlobalBinDirs(basePath, env) {
+    const childEnv = buildChildEnv({
+        ...env,
+        ...(basePath === undefined ? {} : { PATH: basePath }),
+    });
+    const executable = process.platform === 'win32' ? 'cmd.exe' : 'npm';
+    const args = process.platform === 'win32'
+        ? ['/d', '/s', '/c', 'npm', 'prefix', '-g']
+        : ['prefix', '-g'];
+    const result = (0, child_process_1.spawnSync)(executable, args, {
+        encoding: 'utf8',
+        timeout: 5000,
+        env: childEnv,
+    });
+    if (result.status !== 0 || result.error)
+        return [];
+    const output = (result.stdout || '').trim() || (result.stderr || '').trim();
+    const prefix = output.split(/\r?\n/)[0]?.trim() || '';
+    return getNpmGlobalBinDirsFromPrefix(prefix);
+}
+function buildPathWithManagedAgentBins(basePath) {
+    return appendBinDirsToPath(stripManagedAgentBinDirsFromPath(basePath), getManagedAgentBinDirs());
+}
+function appendManagedAgentBinDirsToProcessPath() {
+    process.env.PATH = buildPathWithManagedAgentBins(process.env.PATH);
+}