lua-cli 3.2.0 → 3.4.0

package/dist/commands/persona.js

@@ -10,19 +10,22 @@ import { BASE_URLS } from '../config/constants.js';
 import { safePrompt } from '../utils/prompt-handler.js';
 import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
 import { loadPersonaFromCode, savePersonaToCode } from '../utils/agent-code-utils.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Main Command Entry
+// ─────────────────────────────────────────────────────────────────────────────
 /**
- * Main persona command - manages agent persona
+ * Main persona command - manages agent persona.
  *
- * Features:
- * - Environment selection (sandbox/staging or production)
- * - Sandbox: view, edit, save persona + create versions
- * - Production: list versions, view details, deploy versions
- *
- * @param env - Optional environment argument ('sandbox', 'staging', or 'production')
- * @returns Promise that resolves when command completes
+ * Supports both interactive and non-interactive modes:
+ * - Interactive: prompts for environment and action selection
+ * - Non-interactive (production): use env + action with optional flags
  */
-export async function personaCommand(env) {
+export async function personaCommand(env, action, cmdObj) {
     return withErrorHandling(async () => {
+        const options = {
+            personaVersion: cmdObj?.personaVersion || null,
+            force: cmdObj?.force || false,
+        };
         // Step 1: Load configuration first (to get agentId)
         const config = readSkillConfig();
         validateConfig(config);
@@ -39,7 +42,6 @@ export async function personaCommand(env) {
         let selectedEnvironment;
         // Step 3: Check if environment was provided as argument
         if (env) {
-            // Normalize the environment (staging is an alias for sandbox)
             const normalizedEnv = env.toLowerCase();
             if (normalizedEnv === 'sandbox' || normalizedEnv === 'staging') {
                 selectedEnvironment = 'sandbox';
@@ -50,10 +52,12 @@ export async function personaCommand(env) {
             else {
                 console.error(`❌ Invalid environment: "${env}". Must be "sandbox", "staging", or "production".`);
                 console.log('\nUsage:');
-                console.log('  lua persona                  - Interactive selection');
-                console.log('  lua persona sandbox          - Manage sandbox persona directly');
-                console.log('  lua persona staging          - Manage staging persona (alias for sandbox)');
-                console.log('  lua persona production       - Manage production persona directly');
+                console.log('  lua persona                            Interactive selection');
+                console.log('  lua persona sandbox                    Manage sandbox persona');
+                console.log('  lua persona production                 Manage production persona');
+                console.log('  lua persona production view            View current persona');
+                console.log('  lua persona production versions        List all versions');
+                console.log('  lua persona production deploy -v 5     Deploy version 5');
                 process.exit(1);
             }
         }
@@ -79,24 +83,238 @@ export async function personaCommand(env) {
             agentId,
             apiKey,
         };
-        // Step 5: Start management based on environment
+        // Step 5: Handle based on environment and action
         if (selectedEnvironment === 'sandbox') {
-            await manageSandboxPersona(context);
+            // Sandbox mode is always interactive (editing requires editor)
+            await manageSandboxPersonaInteractive(context);
         }
         else {
-            await manageProductionPersona(context);
+            // Production mode supports non-interactive actions
+            if (action) {
+                await executeProductionNonInteractive(context, action, options);
+            }
+            else {
+                await manageProductionPersonaInteractive(context);
+            }
         }
     }, "persona");
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared Core Functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Fetches all persona versions from the API.
+ */
+async function fetchVersionsCore(context) {
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`❌ API Error: ${response.status} - ${errorText}`);
+            return null;
+        }
+        const data = await response.json();
+        let versions = [];
+        if (Array.isArray(data)) {
+            versions = data;
+        }
+        else if (data.data && Array.isArray(data.data)) {
+            versions = data.data;
+        }
+        else if (data.versions && Array.isArray(data.versions)) {
+            versions = data.versions;
+        }
+        return versions.sort((a, b) => b.createdDate - a.createdDate);
+    }
+    catch (error) {
+        console.error('❌ Error loading persona versions:', error);
+        return null;
+    }
+}
+/**
+ * Displays the current deployed persona.
+ */
+function displayCurrentPersonaCore(versions) {
+    const currentVersion = versions.find(v => v.isCurrent);
+    console.log("\n" + "=".repeat(60));
+    console.log("🤖 Current Production Persona");
+    console.log("=".repeat(60) + "\n");
+    if (currentVersion) {
+        const date = new Date(currentVersion.createdDate);
+        console.log(`Version: ${currentVersion.version} ⭐`);
+        console.log(`Deployed: ${date.toLocaleString()}`);
+        if (currentVersion.createdBy) {
+            console.log(`Created by: ${currentVersion.createdBy}`);
+        }
+        console.log("\n" + "-".repeat(60) + "\n");
+        console.log(currentVersion.persona);
+        console.log("\n" + "=".repeat(60));
+    }
+    else {
+        console.log("⚠️  No persona currently deployed.");
+        console.log("💡 Deploy a version using: lua persona production deploy -v <version>\n");
+        console.log("=".repeat(60));
+    }
+}
+/**
+ * Displays all persona versions.
+ */
+function displayVersionsCore(versions) {
+    console.log("\n" + "=".repeat(60));
+    console.log("🌙 Persona Versions");
+    console.log("=".repeat(60) + "\n");
+    if (versions.length === 0) {
+        console.log("ℹ️  No persona versions found.");
+        console.log("💡 Create a version first from sandbox mode.\n");
+        return;
+    }
+    versions.forEach((v) => {
+        const date = new Date(v.createdDate);
+        const dateStr = date.toLocaleDateString();
+        const timeStr = date.toLocaleTimeString();
+        const currentMark = v.isCurrent ? ' ⭐ CURRENT' : '';
+        const status = v.status === 'draft' ? ' [DRAFT]' : '';
+        console.log(`  Version ${v.version}${status} - ${dateStr} ${timeStr}${currentMark}`);
+    });
+    console.log("\n" + "=".repeat(60));
+    console.log(`Total: ${versions.length} version(s)`);
+}
 /**
- * Manage sandbox persona - edit and save
+ * Deploys a persona version.
  */
-async function manageSandboxPersona(context) {
+async function deployVersionCore(context, version) {
+    writeProgress(`🔄 Deploying persona version ${version}...`);
+    try {
+        const deployResponse = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/version/${version}`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+        if (!deployResponse.ok) {
+            const errorText = await deployResponse.text();
+            console.error(`❌ Deploy Error: ${deployResponse.status} - ${errorText}`);
+            return false;
+        }
+        writeSuccess(`✅ Persona version ${version} deployed successfully to production`);
+        writeInfo("💡 The new persona is now active for all users.");
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Error deploying persona version:', error);
+        return false;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Non-Interactive Mode (Production)
+// ─────────────────────────────────────────────────────────────────────────────
+async function executeProductionNonInteractive(context, action, options) {
+    const validActions = ['view', 'versions', 'deploy'];
+    const normalizedAction = action.toLowerCase();
+    if (!validActions.includes(normalizedAction)) {
+        console.error(`❌ Invalid action: "${action}"`);
+        console.log('\nValid actions for production: view, versions, deploy');
+        console.log('\nExamples:');
+        console.log('  lua persona production view            View current persona');
+        console.log('  lua persona production versions        List all versions');
+        console.log('  lua persona production deploy -v 5     Deploy version 5');
+        console.log('  lua persona production deploy -v latest Deploy latest version');
+        process.exit(1);
+    }
+    writeProgress("🔄 Loading persona versions...");
+    const versions = await fetchVersionsCore(context);
+    if (!versions)
+        process.exit(1);
+    switch (normalizedAction) {
+        case 'view':
+            displayCurrentPersonaCore(versions);
+            break;
+        case 'versions':
+            displayVersionsCore(versions);
+            break;
+        case 'deploy': {
+            if (!options.personaVersion) {
+                console.error('❌ --persona-version is required for deploy action');
+                console.log('\nUsage: lua persona production deploy --persona-version <version>');
+                console.log('       lua persona production deploy -v latest');
+                if (versions.length > 0) {
+                    console.log('\nAvailable versions:');
+                    versions.slice(0, 5).forEach(v => {
+                        const mark = v.isCurrent ? ' (current)' : '';
+                        console.log(`  - ${v.version}${mark}`);
+                    });
+                }
+                process.exit(1);
+            }
+            // Resolve version number
+            let versionNumber;
+            if (options.personaVersion.toLowerCase() === 'latest') {
+                if (versions.length === 0) {
+                    console.error('❌ No versions available to deploy');
+                    process.exit(1);
+                }
+                versionNumber = versions[0].version; // Already sorted newest first
+                console.log(`ℹ️  Latest version is ${versionNumber}`);
+            }
+            else {
+                versionNumber = parseInt(options.personaVersion, 10);
+                if (isNaN(versionNumber)) {
+                    console.error(`❌ Invalid version number: "${options.personaVersion}"`);
+                    process.exit(1);
+                }
+            }
+            // Check if version exists
+            const versionExists = versions.find(v => v.version === versionNumber);
+            if (!versionExists) {
+                console.error(`❌ Version ${versionNumber} not found`);
+                console.log('\nAvailable versions:');
+                versions.forEach(v => console.log(`  - ${v.version}`));
+                process.exit(1);
+            }
+            // Check if already current
+            if (versionExists.isCurrent) {
+                console.log(`ℹ️  Version ${versionNumber} is already deployed.`);
+                return;
+            }
+            // Confirm unless --force
+            if (!options.force) {
+                console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+                console.log("⚠️  This will affect ALL users immediately.\n");
+                const confirmAnswer = await safePrompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `Deploy version ${versionNumber} to production?`,
+                        default: false
+                    }
+                ]);
+                if (!confirmAnswer || !confirmAnswer.confirm) {
+                    console.log("\n❌ Deployment cancelled.\n");
+                    return;
+                }
+            }
+            const success = await deployVersionCore(context, versionNumber);
+            if (!success)
+                process.exit(1);
+            break;
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Interactive Mode (Sandbox)
+// ─────────────────────────────────────────────────────────────────────────────
+async function manageSandboxPersonaInteractive(context) {
     let continueManaging = true;
     while (continueManaging) {
-        // Load current persona directly from code
         const currentPersona = loadPersonaFromCode();
-        // Show menu
         console.log("\n" + "=".repeat(60));
         console.log("🌙 Sandbox Persona Management");
         console.log("=".repeat(60) + "\n");
@@ -130,54 +348,16 @@ async function manageSandboxPersona(context) {
         const { action } = actionAnswer;
         switch (action) {
             case 'view':
-                await viewPersona(currentPersona);
+                await viewPersonaInteractive(currentPersona);
                 break;
             case 'edit':
-                await editSandboxPersona(context, currentPersona);
+                await editSandboxPersonaInteractive(context, currentPersona);
                 break;
             case 'create_version':
-                await createPersonaVersion(context, currentPersona);
+                await createPersonaVersionInteractive(context, currentPersona);
                 break;
             case 'list_versions':
-                await listPersonaVersions(context);
-                break;
-            case 'exit':
-                continueManaging = false;
-                console.log("\n👋 Goodbye!\n");
-                break;
-        }
-    }
-}
-/**
- * Manage production persona - view and deploy versions
- */
-async function manageProductionPersona(context) {
-    let continueManaging = true;
-    while (continueManaging) {
-        console.log("\n" + "=".repeat(60));
-        console.log("🌙 Production Persona Management");
-        console.log("=".repeat(60) + "\n");
-        const actionAnswer = await safePrompt([
-            {
-                type: 'list',
-                name: 'action',
-                message: 'What would you like to do?',
-                choices: [
-                    { name: '👁️  View persona versions', value: 'view' },
-                    { name: '🚀 Deploy persona version', value: 'deploy' },
-                    { name: '❌ Exit', value: 'exit' }
-                ]
-            }
-        ]);
-        if (!actionAnswer)
-            return;
-        const { action } = actionAnswer;
-        switch (action) {
-            case 'view':
-                await listPersonaVersions(context);
-                break;
-            case 'deploy':
-                await deployPersonaVersion(context);
+                await listPersonaVersionsInteractive(context);
                 break;
             case 'exit':
                 continueManaging = false;
@@ -186,10 +366,7 @@ async function manageProductionPersona(context) {
         }
     }
 }
-/**
- * View full persona content
- */
-async function viewPersona(persona) {
+async function viewPersonaInteractive(persona) {
     console.log("\n" + "=".repeat(60));
     console.log("Agent Persona");
     console.log("=".repeat(60));
@@ -208,11 +385,7 @@ async function viewPersona(persona) {
         }
     ]);
 }
-/**
- * Edit sandbox persona
- */
-async function editSandboxPersona(context, currentPersona) {
-    // Provide helpful default if empty
+async function editSandboxPersonaInteractive(context, currentPersona) {
     const defaultPersona = currentPersona || `# Write your agent persona here
 # 
 # Example:
@@ -229,7 +402,6 @@ async function editSandboxPersona(context, currentPersona) {
                 if (!input.trim()) {
                     return 'Persona cannot be empty';
                 }
-                // Remove comment lines for validation
                 const withoutComments = input.split('\n')
                     .filter((line) => !line.trim().startsWith('#'))
                     .join('\n')
@@ -254,10 +426,7 @@ async function editSandboxPersona(context, currentPersona) {
         console.error("❌ Failed to save persona to code");
     }
 }
-/**
- * Create a new persona version
- */
-async function createPersonaVersion(context, currentPersona) {
+async function createPersonaVersionInteractive(context, currentPersona) {
     if (!currentPersona || !currentPersona.trim()) {
         console.log("\n❌ No persona to create version from. Please edit and save a persona first.\n");
         return;
@@ -298,78 +467,37 @@ async function createPersonaVersion(context, currentPersona) {
         console.error('❌ Error creating persona version:', error);
     }
 }
-/**
- * List persona versions
- */
-async function listPersonaVersions(context) {
+async function listPersonaVersionsInteractive(context) {
     writeProgress("🔄 Loading persona versions...");
-    try {
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/versions`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${context.apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            console.error(`\n❌ API Error: ${response.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const data = await response.json();
-        // Handle different response formats
-        let versions = [];
-        if (Array.isArray(data)) {
-            versions = data;
-        }
-        else if (data.data && Array.isArray(data.data)) {
-            versions = data.data;
-        }
-        else if (data.versions && Array.isArray(data.versions)) {
-            versions = data.versions;
-        }
-        if (versions.length === 0) {
-            console.log("\nℹ️  No persona versions found.\n");
-            console.log("💡 Create a version first from sandbox mode.\n");
-            return;
-        }
-        // Sort versions by date (newest first)
-        const sortedVersions = versions.sort((a, b) => {
-            return b.createdDate - a.createdDate;
-        });
-        // Let user select a version to view
-        const versionAnswer = await safePrompt([
-            {
-                type: 'list',
-                name: 'selectedVersionIndex',
-                message: 'Select a persona version to view:',
-                choices: sortedVersions.map((version, index) => {
-                    const date = new Date(version.createdDate);
-                    const dateStr = date.toLocaleDateString();
-                    const timeStr = date.toLocaleTimeString();
-                    const status = version.status === 'draft' ? '[DRAFT]' : '';
-                    const currentMark = version.isCurrent ? ' ⭐ CURRENT' : '';
-                    return {
-                        name: `Version ${version.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
-                        value: index
-                    };
-                })
-            }
-        ]);
-        if (!versionAnswer)
-            return;
-        // Show the selected version's full persona
-        await viewVersionDetails([sortedVersions[versionAnswer.selectedVersionIndex]]);
-    }
-    catch (error) {
-        console.error('❌ Error loading persona versions:', error);
+    const versions = await fetchVersionsCore(context);
+    if (!versions || versions.length === 0) {
+        console.log("\nℹ️  No persona versions found.\n");
+        console.log("💡 Create a version first from sandbox mode.\n");
+        return;
     }
+    const versionAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedVersionIndex',
+            message: 'Select a persona version to view:',
+            choices: versions.map((version, index) => {
+                const date = new Date(version.createdDate);
+                const dateStr = date.toLocaleDateString();
+                const timeStr = date.toLocaleTimeString();
+                const status = version.status === 'draft' ? '[DRAFT]' : '';
+                const currentMark = version.isCurrent ? ' ⭐ CURRENT' : '';
+                return {
+                    name: `Version ${version.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
+                    value: index
+                };
+            })
+        }
+    ]);
+    if (!versionAnswer)
+        return;
+    await viewVersionDetailsInteractive(versions[versionAnswer.selectedVersionIndex]);
 }
-/**
- * View details of a specific version
- */
-async function viewVersionDetails(versions) {
-    const version = versions[0]; // Already pre-selected
+async function viewVersionDetailsInteractive(version) {
     const date = new Date(version.createdDate);
     console.log("\n" + "=".repeat(60));
     console.log(`Persona Version ${version.version}`);
@@ -392,101 +520,90 @@ async function viewVersionDetails(versions) {
         }
     ]);
 }
-/**
- * Deploy a persona version to production
- */
-async function deployPersonaVersion(context) {
-    writeProgress("🔄 Loading persona versions...");
-    try {
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/versions`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${context.apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            console.error(`\n❌ API Error: ${response.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const data = await response.json();
-        // Handle different response formats
-        let versions = [];
-        if (Array.isArray(data)) {
-            versions = data;
-        }
-        else if (data.data && Array.isArray(data.data)) {
-            versions = data.data;
-        }
-        else if (data.versions && Array.isArray(data.versions)) {
-            versions = data.versions;
-        }
-        if (versions.length === 0) {
-            console.log("\nℹ️  No persona versions available to deploy.\n");
-            console.log("💡 Create a version first from sandbox mode.\n");
-            return;
-        }
-        // Sort versions by date (newest first)
-        const sortedVersions = versions.sort((a, b) => b.createdDate - a.createdDate);
+// ─────────────────────────────────────────────────────────────────────────────
+// Interactive Mode (Production)
+// ─────────────────────────────────────────────────────────────────────────────
+async function manageProductionPersonaInteractive(context) {
+    let continueManaging = true;
+    while (continueManaging) {
         console.log("\n" + "=".repeat(60));
-        console.log("🌙 Select Persona Version to Deploy");
+        console.log("🌙 Production Persona Management");
         console.log("=".repeat(60) + "\n");
-        const versionAnswer = await safePrompt([
+        const actionAnswer = await safePrompt([
             {
                 type: 'list',
-                name: 'selectedVersion',
-                message: 'Select version to deploy:',
-                choices: sortedVersions.map((v) => {
-                    const date = new Date(v.createdDate);
-                    const dateStr = date.toLocaleDateString();
-                    const timeStr = date.toLocaleTimeString();
-                    const currentMark = v.isCurrent ? ' ⭐ CURRENTLY DEPLOYED' : '';
-                    const status = v.status === "draft" ? "[DRAFT]" : "";
-                    return {
-                        name: `Version ${v.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
-                        value: v.version
-                    };
-                })
-            }
-        ]);
-        if (!versionAnswer)
-            return;
-        const { selectedVersion } = versionAnswer;
-        // Show confirmation
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy this persona version?',
-                default: false
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View persona versions', value: 'view' },
+                    { name: '🚀 Deploy persona version', value: 'deploy' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
             }
         ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled.\n");
+        if (!actionAnswer)
             return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await listPersonaVersionsInteractive(context);
+                break;
+            case 'deploy':
+                await deployPersonaVersionInteractive(context);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
         }
-        writeProgress("🔄 Deploying persona version...");
-        const deployResponse = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/version/${selectedVersion}`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${context.apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({})
-        });
-        if (!deployResponse.ok) {
-            const errorText = await deployResponse.text();
-            console.error(`\n❌ Deploy Error: ${deployResponse.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${deployResponse.status}`);
-        }
-        writeSuccess(`✅ Persona version ${selectedVersion} deployed successfully to production`);
-        writeInfo("💡 The new persona is now active for all users.");
     }
-    catch (error) {
-        console.error('❌ Error deploying persona version:', error);
+}
+async function deployPersonaVersionInteractive(context) {
+    writeProgress("🔄 Loading persona versions...");
+    const versions = await fetchVersionsCore(context);
+    if (!versions || versions.length === 0) {
+        console.log("\nℹ️  No persona versions available to deploy.\n");
+        console.log("💡 Create a version first from sandbox mode.\n");
+        return;
+    }
+    console.log("\n" + "=".repeat(60));
+    console.log("🌙 Select Persona Version to Deploy");
+    console.log("=".repeat(60) + "\n");
+    const versionAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedVersion',
+            message: 'Select version to deploy:',
+            choices: versions.map((v) => {
+                const date = new Date(v.createdDate);
+                const dateStr = date.toLocaleDateString();
+                const timeStr = date.toLocaleTimeString();
+                const currentMark = v.isCurrent ? ' ⭐ CURRENTLY DEPLOYED' : '';
+                const status = v.status === "draft" ? "[DRAFT]" : "";
+                return {
+                    name: `Version ${v.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
+                    value: v.version
+                };
+            })
+        }
+    ]);
+    if (!versionAnswer)
+        return;
+    const { selectedVersion } = versionAnswer;
+    console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+    console.log("⚠️  This will affect ALL users immediately.\n");
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you absolutely sure you want to deploy this persona version?',
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deployment cancelled.\n");
+        return;
     }
+    await deployVersionCore(context, selectedVersion);
 }
 //# sourceMappingURL=persona.js.map