@kya-os/cli 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/commands/init.js

@@ -1,158 +1,583 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = init;
-const mcp_i_1 = require("@kya-os/mcp-i");
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-const platform_detector_1 = require("../utils/platform-detector");
-const env_manager_1 = require("../utils/env-manager");
-const prompts_1 = require("../utils/prompts");
-const fs_1 = require("fs");
-const path_1 = require("path");
-async function init(options) {
+import { enableMCPIdentity } from "@kya-os/mcp-i";
+import chalk from "chalk";
+import ora from "ora";
+import { detectPlatform, getPlatformSpecificConfig, } from "../utils/platform-detector.js";
+import { EnvManager } from "../utils/env-manager.js";
+import { promptForInit, showSuccess, showError, showWarning, } from "../utils/prompts.js";
+import { existsSync } from "fs";
+import { join } from "path";
+import { cliEffects } from "../effects/cli-integration.js";
+async function checkRegistryHealth(verbose = false) {
+    const healthSpinner = ora("Checking registry status...").start();
+    try {
+        // Check the new health endpoint
+        const healthResponse = await fetch("https://knowthat.ai/api/agents/auto-register/health", {
+            method: "GET",
+            headers: {
+                "User-Agent": "kya-os-cli",
+            },
+            signal: AbortSignal.timeout(10000), // 10 second timeout
+        });
+        if (healthResponse.ok) {
+            const healthData = await healthResponse.json();
+            healthSpinner.succeed("Registry is operational");
+            if (verbose && healthData) {
+                console.log(chalk.gray(`   Service status: ${healthData.status || "healthy"}`));
+            }
+            return { available: true, shouldProceed: true };
+        }
+        else if (healthResponse.status === 503) {
+            healthSpinner.fail("Registry is temporarily unavailable (maintenance mode)");
+            console.log(chalk.yellow("\n⚠️  The registry is undergoing maintenance."));
+            console.log(chalk.yellow("   This usually takes 5-15 minutes."));
+            console.log(chalk.yellow("\n🔧 Options:"));
+            console.log("   1. Wait and try again in a few minutes");
+            console.log("   2. Register manually at: https://knowthat.ai/submit-agent");
+            console.log("   3. Create local config only (skip registration for now)");
+            return { available: false, shouldProceed: false };
+        }
+        else {
+            healthSpinner.warn("Registry status unknown, proceeding with caution...");
+            return { available: false, shouldProceed: true };
+        }
+    }
+    catch (error) {
+        if (error.name === "TimeoutError") {
+            healthSpinner.fail("Registry health check timed out");
+            console.log(chalk.yellow("\n⚠️  Could not reach the registry (network timeout)."));
+            console.log(chalk.yellow("   Check your internet connection."));
+        }
+        else if (error.code === "ENOTFOUND" || error.code === "ECONNREFUSED") {
+            healthSpinner.fail("Registry is unreachable");
+            console.log(chalk.yellow("\n⚠️  Cannot connect to knowthat.ai registry."));
+            console.log(chalk.yellow("   The service may be down or you may have network issues."));
+        }
+        else {
+            healthSpinner.warn("Could not check registry status, proceeding anyway...");
+            if (verbose) {
+                console.log(chalk.gray(`   Error: ${error.message}`));
+            }
+        }
+        console.log(chalk.yellow("\n🔧 Alternatives:"));
+        console.log("   1. Try again in a few minutes");
+        console.log("   2. Register manually at: https://knowthat.ai/submit-agent");
+        console.log("   3. Create local config only (we'll attempt registration anyway)");
+        return { available: false, shouldProceed: true };
+    }
+}
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function attemptRegistrationWithRetry(config, verbose = false, maxRetries = 3) {
+    const baseDelay = 2000; // Start with 2 seconds
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const isLastAttempt = attempt === maxRetries;
+        const spinner = ora(`Registering agent with knowthat.ai... (attempt ${attempt}/${maxRetries})`).start();
+        try {
+            const identity = await enableMCPIdentity(config);
+            spinner.succeed("Creating Agent ID");
+            return { success: true, identity };
+        }
+        catch (error) {
+            spinner.fail(`Registration attempt ${attempt} failed`);
+            const errorInfo = categorizeError(error, verbose);
+            if (errorInfo.category === "CRITICAL" || isLastAttempt) {
+                // Don't retry for critical errors, or if this was the last attempt
+                handleRegistrationError(error, errorInfo, verbose, isLastAttempt);
+                return { success: false, error };
+            }
+            else if (errorInfo.category === "RETRYABLE") {
+                // Calculate exponential backoff delay
+                const delay = baseDelay * Math.pow(2, attempt - 1);
+                console.log(chalk.yellow(`   ${errorInfo.message}`));
+                console.log(chalk.gray(`   Retrying in ${delay / 1000} seconds...`));
+                if (attempt < maxRetries) {
+                    await sleep(delay);
+                }
+            }
+            else {
+                // Unknown error - try once more but show the error
+                if (verbose) {
+                    console.log(chalk.gray(`   ${errorInfo.debugInfo}`));
+                }
+                console.log(chalk.yellow(`   ${errorInfo.message}`));
+                if (attempt < maxRetries) {
+                    console.log(chalk.gray(`   Trying again...`));
+                    await sleep(baseDelay);
+                }
+            }
+        }
+    }
+    return { success: false };
+}
+function categorizeError(error, verbose = false) {
+    const errorMessage = error.message || "";
+    const status = error.response?.status || error.status;
+    const responseData = error.response?.data;
+    // Build debug info
+    let debugInfo = "";
+    if (verbose) {
+        debugInfo = `Error type: ${error.constructor.name}, Status: ${status}`;
+        if (responseData) {
+            debugInfo += `, Response: ${JSON.stringify(responseData, null, 2)}`;
+        }
+    }
+    // Rate limiting
+    if (status === 429 ||
+        errorMessage.includes("429") ||
+        errorMessage.includes("rate limit")) {
+        return {
+            category: "RETRYABLE",
+            message: "Rate limit exceeded. The registry is busy.",
+            debugInfo,
+        };
+    }
+    // Service temporarily unavailable
+    if (status === 503 || errorMessage.includes("503")) {
+        return {
+            category: "RETRYABLE",
+            message: "Registry is temporarily unavailable (maintenance or overload).",
+            debugInfo,
+        };
+    }
+    // Server errors that might be transient
+    if (status === 500 ||
+        status === 502 ||
+        errorMessage.includes("500") ||
+        errorMessage.includes("502")) {
+        return {
+            category: "RETRYABLE",
+            message: "Registry server error. This may be temporary.",
+            debugInfo,
+        };
+    }
+    // Timeout errors
+    if (error.name === "TimeoutError" || errorMessage.includes("timeout")) {
+        return {
+            category: "RETRYABLE",
+            message: "Request timed out. Network or server may be slow.",
+            debugInfo,
+        };
+    }
+    // Network errors
+    if (error.code === "ENOTFOUND" ||
+        error.code === "ECONNREFUSED" ||
+        errorMessage.includes("ENOTFOUND")) {
+        return {
+            category: "RETRYABLE",
+            message: "Cannot reach the registry. Check your internet connection.",
+            debugInfo,
+        };
+    }
+    // Client errors that shouldn't be retried
+    if (status >= 400 && status < 500 && status !== 429) {
+        return {
+            category: "CRITICAL",
+            message: `Registration was rejected by the registry (${status}).`,
+            debugInfo,
+        };
+    }
+    // MCP-I specific errors
+    if (errorMessage.includes("Failed to auto-register agent")) {
+        return {
+            category: "CRITICAL",
+            message: "The registry rejected the registration request.",
+            debugInfo,
+        };
+    }
+    // Unknown error
+    return {
+        category: "UNKNOWN",
+        message: errorMessage || "An unexpected error occurred during registration.",
+        debugInfo,
+    };
+}
+function handleRegistrationError(_error, errorInfo, verbose, isFinalAttempt) {
+    // Show main error message
+    showError(errorInfo.message);
+    // Show debug info if verbose
+    if (verbose && errorInfo.debugInfo) {
+        console.log(chalk.gray("\nDebug information:"));
+        console.log(chalk.gray(errorInfo.debugInfo));
+    }
+    // Show context-specific help
+    if (errorInfo.category === "CRITICAL") {
+        console.log(chalk.yellow("\n🔧 This error cannot be resolved by retrying."));
+        console.log(chalk.yellow("   Possible solutions:"));
+        console.log("   1. Register manually at: https://knowthat.ai/submit-agent");
+        console.log("   2. Check if your agent name is already taken");
+        console.log("   3. Verify your repository URL is accessible");
+        console.log("   4. Contact support if the problem persists");
+    }
+    else if (isFinalAttempt) {
+        console.log(chalk.yellow("\n🔧 Registration failed after multiple attempts."));
+        console.log(chalk.yellow("   Next steps:"));
+        console.log("   1. Wait 5-10 minutes and try again");
+        console.log("   2. Check knowthat.ai status page (if available)");
+        console.log("   3. Register manually at: https://knowthat.ai/submit-agent");
+        console.log("   4. Create local config only: npx kya-os init --skip-registration");
+    }
+    // Show alternative registration method
+    console.log(chalk.cyan("\n📝 Manual registration process:"));
+    console.log("   1. Visit: https://knowthat.ai/submit-agent");
+    console.log("   2. Fill in your agent details");
+    console.log("   3. Get your DID and run: npx kya-os claim <your-agent-id>");
+}
+export async function init(options) {
     try {
         // Detect platform
-        const platformInfo = (0, platform_detector_1.detectPlatform)();
-        console.log(chalk_1.default.cyan('\n🔍 Detected environment:'));
-        console.log(`   Platform: ${chalk_1.default.bold(platformInfo.platform)}`);
+        const platformInfo = detectPlatform();
+        console.log(chalk.cyan("\n🔍 Detected environment:"));
+        console.log(`   Platform: ${chalk.bold(platformInfo.platform)}`);
         if (platformInfo.framework) {
-            console.log(`   Framework: ${chalk_1.default.bold(platformInfo.framework)}`);
+            console.log(`   Framework: ${chalk.bold(platformInfo.framework)}`);
         }
-        console.log(`   Package Manager: ${chalk_1.default.bold(platformInfo.packageManager)}`);
+        console.log(`   Package Manager: ${chalk.bold(platformInfo.packageManager)}`);
         // Check for existing configuration
-        const envManager = new env_manager_1.EnvManager();
-        const existingIdentityFile = (0, fs_1.existsSync)((0, path_1.join)(process.cwd(), '.mcp-identity.json'));
+        const envManager = new EnvManager();
+        const existingIdentityFile = existsSync(join(process.cwd(), ".mcp-identity.json"));
         const existingEnvVars = envManager.getFromProcess();
-        if ((existingIdentityFile || existingEnvVars.MCP_IDENTITY_DID) && !options.force) {
-            (0, prompts_1.showWarning)('MCP-I is already configured in this project.');
-            console.log('Use --force to reconfigure.');
+        if ((existingIdentityFile || existingEnvVars.MCP_IDENTITY_DID) &&
+            !options.force) {
+            showWarning("MCP-I is already configured in this project.");
+            console.log("Use --force to reconfigure.");
             // Show current configuration
             if (existingEnvVars.MCP_IDENTITY_DID) {
-                console.log(`\nCurrent DID: ${chalk_1.default.green(existingEnvVars.MCP_IDENTITY_DID)}`);
+                console.log(`\nCurrent DID: ${chalk.green(existingEnvVars.MCP_IDENTITY_DID)}`);
             }
             return;
         }
         // Prompt for configuration
-        const answers = await (0, prompts_1.promptForInit)({
+        const answers = await promptForInit({
             name: options.name,
             description: options.description,
-            repository: options.repository
+            repository: options.repository,
         });
         // Determine directories configuration
         let directories;
-        if (answers.directories === 'verified') {
-            directories = 'verified';
+        if (answers.directories === "verified") {
+            directories = "verified";
         }
-        else if (answers.directories === 'none') {
-            directories = 'none';
+        else if (answers.directories === "none") {
+            directories = "none";
         }
         else {
             directories = answers.specificDirectories || [];
         }
         // Get platform-specific config
-        const platformConfig = (0, platform_detector_1.getPlatformSpecificConfig)(platformInfo.platform);
+        const platformConfig = getPlatformSpecificConfig(platformInfo.platform);
         let identity;
         let envVars = null;
         if (!options.skipRegistration && answers.confirmRegistration) {
-            // Register agent
-            const spinner = (0, ora_1.default)('Registering agent with knowthat.ai...').start();
-            try {
-                identity = await (0, mcp_i_1.enableMCPIdentity)({
+            // Check registry health first
+            const healthCheck = await checkRegistryHealth(options.verbose);
+            if (!healthCheck.available && !healthCheck.shouldProceed) {
+                console.log("\nYou can still create the configuration files and register later.");
+                answers.confirmEnvCreation = await promptForInit({
+                    confirmEnvCreation: true,
+                }).then((a) => a.confirmEnvCreation);
+            }
+            else {
+                // Register agent with retry logic
+                const registrationResult = await attemptRegistrationWithRetry({
                     name: answers.name,
                     description: answers.description,
                     repository: answers.repository,
                     directories: directories,
                     storage: platformConfig.storage,
                     transport: platformConfig.transport,
-                    mode: 'production',
-                    logLevel: 'silent'
-                });
-                spinner.succeed('Agent registered successfully!');
-                // Extract environment variables
-                envVars = {
-                    MCP_IDENTITY_DID: identity.did,
-                    MCP_IDENTITY_PUBLIC_KEY: identity.publicKey,
-                    MCP_IDENTITY_PRIVATE_KEY: identity.privateKey || '', // Access private key
-                    MCP_IDENTITY_AGENT_ID: identity.agentId || '',
-                    MCP_IDENTITY_AGENT_SLUG: identity.agentSlug || ''
-                };
-                console.log(`\n📝 ${chalk_1.default.bold('Agent Details:')}`);
-                console.log(`   DID: ${chalk_1.default.green(identity.did)}`);
-                console.log(`   Profile: ${chalk_1.default.cyan(`https://knowthat.ai/agents/${envVars.MCP_IDENTITY_AGENT_SLUG}`)}`);
-                // Try to get claim URL
-                try {
-                    const { claimUrl } = await identity.requestEditAccess();
+                    mode: "production",
+                    logLevel: "silent",
+                }, options.verbose);
+                if (registrationResult.success && registrationResult.identity) {
+                    identity = registrationResult.identity;
+                    // Extract environment variables
+                    envVars = {
+                        MCP_IDENTITY_DID: identity.did,
+                        MCP_IDENTITY_PUBLIC_KEY: identity.publicKey,
+                        MCP_IDENTITY_PRIVATE_KEY: identity.privateKey || "",
+                        MCP_IDENTITY_AGENT_ID: identity.agentId || "",
+                        MCP_IDENTITY_AGENT_SLUG: identity.agentSlug || "",
+                    };
+                    // Clear some space for the effect
+                    console.log("\n");
+                    // Show DID generation with Blackhole effect
+                    const didGenerationText = `🔐 ${chalk.bold("Generating Decentralized Identity")}\n` +
+                        `\n` +
+                        `DID: ${chalk.green(identity.did)}`;
+                    await cliEffects.showCustomEffect("blackhole", didGenerationText, {
+                        config: {
+                            duration: 5000, // Increased duration for smoother transition
+                            blackholeColor: "ffffff",
+                            starColors: [
+                                "ffcc0d",
+                                "ff7326",
+                                "ff194d",
+                                "bf2669",
+                                "702a8c",
+                                "049dbf",
+                            ],
+                            finalColor: "00ff00",
+                            useGradient: true,
+                            gradientDirection: "diagonal",
+                            blackholeSize: 0.3,
+                        },
+                        persistent: true, // Keep the DID visible after animation
+                        skipExitPrompt: true, // Don't show "Press any key to exit"
+                    });
+                    // Get claim URL if available
+                    let claimUrl = null;
+                    try {
+                        const result = await identity.requestEditAccess();
+                        claimUrl = result.claimUrl;
+                    }
+                    catch (error) {
+                        // Ignore errors - claim URL is optional
+                    }
+                    // Wait a moment for the effect to finish and let the user see the DID
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    // Gentle fade by adding some spacing before clearing
+                    console.log("\n\n\n");
+                    await new Promise((resolve) => setTimeout(resolve, 300));
+                    // Clear screen and show elegant agent identity card
+                    console.clear();
+                    // Display elegant agent identity card
+                    console.log("\n");
+                    console.log(chalk.cyan("╔═══════════════════════════════════════════════════════════════════════╗"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold.white("                    🤖 AGENT IDENTITY CREATED                          ") +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("╠═══════════════════════════════════════════════════════════════════════╣"));
+                    console.log(chalk.cyan("║                                                                       ║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold("  Agent Name: ") +
+                        chalk.yellow(answers.name.padEnd(57)) +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold("  Description: ") +
+                        chalk.gray((answers.description || "").substring(0, 56).padEnd(56)) +
+                        chalk.cyan("║"));
+                    if (answers.description && answers.description.length > 56) {
+                        console.log(chalk.cyan("║") +
+                            "                " +
+                            chalk.gray(answers.description.substring(56, 112).padEnd(55)) +
+                            chalk.cyan("║"));
+                    }
+                    console.log(chalk.cyan("║                                                                       ║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold("  DID: ") +
+                        chalk.green(identity.did.substring(0, 64).padEnd(64)) +
+                        chalk.cyan("║"));
+                    if (identity.did.length > 64) {
+                        console.log(chalk.cyan("║") +
+                            "        " +
+                            chalk.green(identity.did.substring(64).padEnd(63)) +
+                            chalk.cyan("║"));
+                    }
+                    console.log(chalk.cyan("║                                                                       ║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold("  Profile: ") +
+                        chalk.blue(`https://knowthat.ai/agents/${answers.name}`.padEnd(60)) +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("║                                                                       ║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold.red("  🔐 PRIVATE KEY (KEEP SAFE!): ") +
+                        "                                   " +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("║") +
+                        "     " +
+                        chalk.red(envVars.MCP_IDENTITY_PRIVATE_KEY.substring(0, 60).padEnd(60)) +
+                        " " +
+                        chalk.cyan("║"));
+                    if (envVars.MCP_IDENTITY_PRIVATE_KEY.length > 60) {
+                        console.log(chalk.cyan("║") +
+                            "     " +
+                            chalk.red(envVars.MCP_IDENTITY_PRIVATE_KEY.substring(60, 120).padEnd(60)) +
+                            " " +
+                            chalk.cyan("║"));
+                    }
+                    if (envVars.MCP_IDENTITY_PRIVATE_KEY.length > 120) {
+                        console.log(chalk.cyan("║") +
+                            "     " +
+                            chalk.red(envVars.MCP_IDENTITY_PRIVATE_KEY.substring(120).padEnd(60)) +
+                            " " +
+                            chalk.cyan("║"));
+                    }
+                    console.log(chalk.cyan("║") +
+                        chalk.yellow("     ⚠️  This key controls your agent - never share it!") +
+                        "               " +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("║                                                                       ║"));
                     if (claimUrl) {
-                        console.log(`\n🎯 ${chalk_1.default.bold('Claim your agent:')}`);
-                        console.log(`   ${chalk_1.default.cyan(claimUrl)}`);
-                        console.log(`   ${chalk_1.default.gray('(This link lets you manage your agent)')}`);
+                        console.log(chalk.cyan("╠═══════════════════════════════════════════════════════════════════════╣"));
+                        console.log(chalk.cyan("║                                                                       ║"));
+                        console.log(chalk.cyan("║") +
+                            chalk.bold.yellow("  🎯 CLAIM YOUR AGENT NOW:                                             ") +
+                            chalk.cyan("║"));
+                        console.log(chalk.cyan("║                                                                       ║"));
+                        // Display the full URL without breaking to keep it clickable
+                        console.log(chalk.cyan("╚═══════════════════════════════════════════════════════════════════════╝"));
+                        console.log("");
+                        console.log(chalk.bold.cyan("🔗 Click to claim your agent:"));
+                        console.log(chalk.cyan.underline(claimUrl));
+                        console.log("");
+                        console.log(chalk.cyan("╔═══════════════════════════════════════════════════════════════════════╗"));
+                        console.log(chalk.cyan("║                                                                       ║"));
+                        console.log(chalk.cyan("║") +
+                            chalk.gray("  This link lets you manage your agent and add capabilities.           ") +
+                            chalk.cyan("║"));
+                        console.log(chalk.cyan("║                                                                       ║"));
+                    }
+                    console.log(chalk.cyan("╠═══════════════════════════════════════════════════════════════════════╣"));
+                    console.log(chalk.cyan("║                                                                       ║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.bold.green("  ✅ Agent successfully registered on the KYA-OS network               ") +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("║") +
+                        chalk.gray("     Your AI agent now has a verifiable decentralized identity         ") +
+                        chalk.cyan("║"));
+                    console.log(chalk.cyan("║                                                                       ║"));
+                    console.log(chalk.cyan("╚═══════════════════════════════════════════════════════════════════════╝"));
+                    console.log("\n");
+                    // Interactive prompt
+                    if (claimUrl) {
+                        console.log(chalk.yellow("  Press ENTER to open claim URL in browser, or 'x' to skip and continue..."));
+                        // Wait for user input
+                        const keypress = await new Promise((resolve) => {
+                            import("readline").then((readline) => {
+                                readline.emitKeypressEvents(process.stdin);
+                                if (process.stdin.isTTY) {
+                                    process.stdin.setRawMode(true);
+                                }
+                                const handleKeypress = (str, key) => {
+                                    if (key && key.name === "return") {
+                                        resolve("enter");
+                                    }
+                                    else if (str === "x" || str === "X") {
+                                        resolve("x");
+                                    }
+                                };
+                                process.stdin.once("keypress", handleKeypress);
+                                process.stdin.resume();
+                            });
+                        });
+                        if (process.stdin.isTTY) {
+                            process.stdin.setRawMode(false);
+                        }
+                        if (keypress === "enter") {
+                            // Try to open URL in browser
+                            try {
+                                const open = (await import("open")).default;
+                                await open(claimUrl);
+                                console.log(chalk.green("\n  ✓ Opening claim URL in your browser...\n"));
+                            }
+                            catch (err) {
+                                console.log(chalk.gray("\n  Could not open browser. Please visit the URL manually.\n"));
+                            }
+                        }
+                        else {
+                            console.log(chalk.gray("\n  You can claim your agent later using the URL above.\n"));
+                        }
+                    }
+                    else {
+                        // If no claim URL, just wait for any key
+                        console.log(chalk.gray("  Press any key to continue..."));
+                        await new Promise((resolve) => {
+                            process.stdin.once("data", () => resolve(undefined));
+                            process.stdin.resume();
+                        });
                     }
-                }
-                catch (error) {
-                    // Claim URL might fail due to rate limiting
-                }
-            }
-            catch (error) {
-                spinner.fail('Registration failed');
-                if (error.message?.includes('429')) {
-                    (0, prompts_1.showError)('Rate limit exceeded. Please wait a few minutes and try again.');
-                }
-                else if (error.message?.includes('500')) {
-                    (0, prompts_1.showError)('Server error. The registry might be temporarily down.');
                 }
                 else {
-                    (0, prompts_1.showError)(error.message || 'Failed to register agent');
+                    console.log("\nYou can still create the configuration files and register later.");
+                    answers.confirmEnvCreation = await promptForInit({
+                        confirmEnvCreation: true,
+                    }).then((a) => a.confirmEnvCreation);
                 }
-                console.log('\nYou can still create the configuration files and register later.');
-                answers.confirmEnvCreation = await (0, prompts_1.promptForInit)({ confirmEnvCreation: true }).then(a => a.confirmEnvCreation);
             }
         }
         // Create environment files
         if (answers.confirmEnvCreation && envVars) {
-            console.log(`\n📄 ${chalk_1.default.bold('Creating environment files...')}`);
+            console.log(`\n📄 ${chalk.bold("Creating environment files...")}`);
             try {
-                // Create actual env file
-                const envFile = platformConfig.envFile;
-                await envManager.createEnvFile(envFile, envVars, { force: options.force });
-                console.log(`   ✓ Created ${chalk_1.default.green(envFile)}`);
-                // Create example file
-                const exampleFile = `${envFile}.example`;
-                await envManager.createEnvFile(exampleFile, envVars, { example: true });
-                console.log(`   ✓ Created ${chalk_1.default.green(exampleFile)}`);
-                // Check gitignore
-                const { missing } = envManager.checkGitignore([envFile, '.mcp-identity.json']);
-                if (missing.length > 0) {
-                    envManager.addToGitignore(missing);
-                    console.log(`   ✓ Added to ${chalk_1.default.green('.gitignore')}: ${missing.join(', ')}`);
+                // Use smart insertion with best practices
+                const result = await envManager.smartInsertMcpVariables(envVars, {
+                    force: options.force,
+                });
+                if (result.success) {
+                    // Show operation result
+                    const operation = result.operation === "created"
+                        ? "Created"
+                        : result.operation === "updated"
+                            ? "Updated"
+                            : "Replaced variables in";
+                    console.log(`   ✓ ${operation} ${chalk.green(result.targetFile)}`);
+                    // Show warnings if any
+                    if (result.warnings.length > 0) {
+                        result.warnings.forEach((warning) => {
+                            console.log(`   ${chalk.yellow("⚠")} ${warning}`);
+                        });
+                    }
+                    // Show conflicts if any
+                    if (result.conflicts && result.conflicts.length > 0) {
+                        console.log(`   ${chalk.yellow("⚠")} Found conflicting values in other files:`);
+                        result.conflicts.forEach((conflict) => {
+                            console.log(`     ${conflict.file}: ${conflict.variable}="${conflict.value.substring(0, 20)}..."`);
+                        });
+                        console.log(`   ${chalk.cyan("ℹ")} Using ${result.targetFile} as authoritative source`);
+                    }
+                    // Create backup file with actual values
+                    const backupFile = `${result.targetFile}.backup`;
+                    await envManager.updateEnvFile(backupFile, envVars, {
+                        example: true,
+                    });
+                    console.log(`   ✓ Created ${chalk.green(backupFile)} (backup copy)`);
+                    // Check gitignore
+                    const filesToIgnore = [
+                        result.targetFile,
+                        backupFile,
+                        ".mcp-identity.json",
+                        // Also add common .env files to gitignore
+                        ".env",
+                        ".env.local",
+                        ".env.development",
+                        ".env.dev",
+                    ];
+                    const { missing } = envManager.checkGitignore(filesToIgnore);
+                    if (missing.length > 0) {
+                        envManager.addToGitignore(missing);
+                        console.log(`   ✓ Added to ${chalk.green(".gitignore")}: ${missing.join(", ")}`);
+                    }
+                }
+                else {
+                    showError(`Environment file setup failed: ${result.warnings.join(", ")}`);
                 }
             }
             catch (error) {
-                (0, prompts_1.showError)(`Failed to create environment files: ${error.message}`);
+                showError(`Failed to create environment files: ${error.message}`);
             }
         }
         // Show next steps
-        console.log(`\n📋 ${chalk_1.default.bold('Next Steps:')}`);
-        console.log('\n1. Install the MCP-I package:');
-        console.log(`   ${chalk_1.default.cyan(`${platformInfo.packageManager} install @kya-os/mcp-i`)}`);
-        console.log('\n2. Add to your code:');
-        console.log(`   ${chalk_1.default.cyan('import "@kya-os/mcp-i/auto"')}`);
-        if (platformInfo.platform === 'vercel' || platformInfo.platform === 'nextjs') {
-            console.log('\n3. For production deployment:');
-            console.log('   - Go to Vercel Dashboard → Settings → Environment Variables');
-            console.log('   - Add all MCP_IDENTITY_* variables from .env.local');
-            console.log(`   - Run: ${chalk_1.default.cyan('npx kya-os env copy')} to copy them to clipboard`);
-        }
-        console.log(`\n${chalk_1.default.bold('Platform-specific notes:')}`);
+        console.log(`\n📋 ${chalk.bold("Next Steps:")}`);
+        console.log("\n1. Install the MCP-I package:");
+        console.log(`   ${chalk.cyan(`${platformInfo.packageManager} install @kya-os/mcp-i`)}`);
+        console.log("\n2. Add to your code:");
+        console.log(`   ${chalk.cyan('import "@kya-os/mcp-i/auto"')}`);
+        if (platformInfo.platform === "vercel" ||
+            platformInfo.platform === "nextjs") {
+            console.log("\n3. For production deployment:");
+            console.log("   - Go to Vercel Dashboard → Settings → Environment Variables");
+            console.log("   - Add all MCP_IDENTITY_* variables from .env.local");
+            console.log(`   - Run: ${chalk.cyan("npx kya-os env copy")} to copy them to clipboard`);
+        }
+        console.log(`\n${chalk.bold("Platform-specific notes:")}`);
         platformConfig.instructions.forEach((instruction, i) => {
             console.log(`${i + 1}. ${instruction}`);
         });
-        (0, prompts_1.showSuccess)('MCP-I initialization complete!');
+        showSuccess("MCP-I initialization complete!");
     }
     catch (error) {
-        (0, prompts_1.showError)(error.message || 'Initialization failed');
+        showError(error.message || "Initialization failed");
         process.exit(1);
     }
 }