lua-cli 1.2.0 → 1.3.0-alpha.1

package/dist/commands/configure.js

@@ -1,80 +1,105 @@
 import inquirer from "inquirer";
 import { saveApiKey, checkApiKey, requestEmailOTP, verifyOTPAndGetToken, generateApiKey } from "../services/auth.js";
+import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
 export async function configureCommand() {
-    // Choose authentication method
-    const { authMethod } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "authMethod",
-            message: "Choose authentication method:",
-            choices: [
-                { name: "API Key", value: "api-key" },
-                { name: "Email", value: "email" }
-            ]
-        }
-    ]);
-    if (authMethod === "api-key") {
-        // Existing API key flow
-        const answers = await inquirer.prompt([
+    return withErrorHandling(async () => {
+        // Choose authentication method
+        const { authMethod } = await inquirer.prompt([
             {
-                type: "password",
-                name: "apiKey",
-                message: "Enter your API key",
-                mask: "*",
-            },
+                type: "list",
+                name: "authMethod",
+                message: "Choose authentication method:",
+                choices: [
+                    { name: "API Key", value: "api-key" },
+                    { name: "Email", value: "email" }
+                ]
+            }
         ]);
-        const data = await checkApiKey(answers.apiKey);
-        if (!data) {
-            console.error("❌ Invalid API key");
-            process.exit(1);
+        // Clear the authentication method prompt lines
+        clearPromptLines(2);
+        if (authMethod === "api-key") {
+            // Existing API key flow
+            const answers = await inquirer.prompt([
+                {
+                    type: "password",
+                    name: "apiKey",
+                    message: "Enter your API key",
+                    mask: "*",
+                },
+            ]);
+            const data = await checkApiKey(answers.apiKey);
+            if (!data) {
+                console.error("❌ Invalid API key");
+                process.exit(1);
+            }
+            await saveApiKey(answers.apiKey);
+            writeSuccess("✅ API key saved securely.");
         }
-        await saveApiKey(answers.apiKey);
-        console.log("✅ API key saved securely.");
-    }
-    else if (authMethod === "email") {
-        // Email authentication flow
-        const { email } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "email",
-                message: "Enter your email address:",
-                validate: (input) => {
-                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-                    return emailRegex.test(input) || "Please enter a valid email address";
+        else if (authMethod === "email") {
+            // Email authentication flow
+            const { email } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "email",
+                    message: "Enter your email address:",
+                    validate: (input) => {
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        return emailRegex.test(input) || "Please enter a valid email address";
+                    }
                 }
+            ]);
+            // Clear the email prompt lines
+            clearPromptLines(2);
+            writeProgress("📧 Sending OTP to your email...");
+            const otpSent = await requestEmailOTP(email);
+            if (!otpSent) {
+                console.error("❌ Failed to send OTP. Please try again.");
+                process.exit(1);
             }
-        ]);
-        console.log("📧 Sending OTP to your email...");
-        const otpSent = await requestEmailOTP(email);
-        if (!otpSent) {
-            console.error("❌ Failed to send OTP. Please try again.");
-            process.exit(1);
-        }
-        console.log("✅ OTP sent successfully!");
-        const { pin } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "pin",
-                message: "Enter the OTP code:",
-                validate: (input) => {
-                    return input.length === 6 || "OTP must be 6 digits";
+            writeProgress("✅ OTP sent successfully!");
+            // OTP verification with retry logic
+            let otpVerified = false;
+            let attempts = 0;
+            let signInToken = null;
+            const maxAttempts = 3;
+            while (!otpVerified && attempts < maxAttempts) {
+                const { pin } = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "pin",
+                        message: "Enter the OTP code:",
+                        validate: (input) => {
+                            return input.length === 6 || "OTP must be 6 digits";
+                        }
+                    }
+                ]);
+                // Clear the OTP prompt lines
+                clearPromptLines(2);
+                writeProgress("🔐 Verifying OTP...");
+                signInToken = await verifyOTPAndGetToken(email, pin);
+                if (signInToken) {
+                    otpVerified = true;
+                    writeProgress("✅ OTP verified successfully!");
+                    writeProgress("🔑 Generating API key...");
+                }
+                else {
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        console.log(`❌ Invalid OTP. ${maxAttempts - attempts} attempts remaining.`);
+                    }
+                    else {
+                        console.error("❌ Invalid OTP. Maximum attempts reached. Please try again later.");
+                        process.exit(1);
+                    }
                 }
             }
-        ]);
-        console.log("🔐 Verifying OTP...");
-        const signInToken = await verifyOTPAndGetToken(email, pin);
-        if (!signInToken) {
-            console.error("❌ Invalid OTP. Please try again.");
-            process.exit(1);
-        }
-        console.log("✅ OTP verified successfully!");
-        console.log("🔑 Generating API key...");
-        const apiKey = await generateApiKey(signInToken);
-        if (!apiKey) {
-            console.error("❌ Failed to generate API key. Please try again.");
-            process.exit(1);
+            const apiKey = await generateApiKey(signInToken);
+            if (!apiKey) {
+                console.error("❌ Failed to generate API key. Please try again.");
+                process.exit(1);
+            }
+            await saveApiKey(apiKey);
+            writeSuccess("✅ API key generated and saved securely.");
         }
-        await saveApiKey(apiKey);
-        console.log("✅ API key generated and saved securely.");
-    }
+    }, "configuration");
 }

package/dist/commands/deploy-new.d.ts

@@ -0,0 +1,20 @@
+export interface VersionInfo {
+    version: string;
+    createdDate: string;
+    createdBy: string;
+    isCurrent: boolean;
+    createdByEmail: string;
+    createdByFullName: string;
+}
+export interface VersionsResponse {
+    versions: VersionInfo[];
+}
+export interface PublishResponse {
+    message: string;
+    skillId: string;
+    activeVersionId: string;
+    publishedAt: string;
+}
+export declare function fetchVersions(apiKey: string, agentId: string, skillId: string): Promise<VersionsResponse>;
+export declare function publishVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<PublishResponse>;
+export declare function deployCommand(): Promise<void>;

package/dist/commands/deploy-new.js

@@ -0,0 +1,128 @@
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+export async function fetchVersions(apiKey, agentId, skillId) {
+    try {
+        const response = await fetch(`https://api.lua.dev/developer/skills/${agentId}/${skillId}/versions`, {
+            method: "GET",
+            headers: {
+                "accept": "application/json",
+                "Authorization": `Bearer ${apiKey}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch versions: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error("❌ Error fetching versions:", error);
+        throw error;
+    }
+}
+export async function publishVersion(apiKey, agentId, skillId, version) {
+    try {
+        const response = await fetch(`https://api.lua.dev/developer/skills/${agentId}/${skillId}/${version}/publish`, {
+            method: "PUT",
+            headers: {
+                "accept": "application/json",
+                "Authorization": `Bearer ${apiKey}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to publish version: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error("❌ Error publishing version:", error);
+        throw error;
+    }
+}
+function readTomlData() {
+    const tomlPath = path.join(process.cwd(), 'lua.skill.toml');
+    if (!fs.existsSync(tomlPath)) {
+        return null;
+    }
+    const tomlContent = fs.readFileSync(tomlPath, 'utf8');
+    const agentIdMatch = tomlContent.match(/agentId\s*=\s*["']([^"']+)["']/);
+    const skillIdMatch = tomlContent.match(/skillId\s*=\s*["']([^"']+)["']/);
+    if (!agentIdMatch || !skillIdMatch) {
+        return null;
+    }
+    return {
+        agentId: agentIdMatch[1],
+        skillId: skillIdMatch[1]
+    };
+}
+function formatVersionChoice(version) {
+    const currentIndicator = version.isCurrent ? ' (CURRENT)' : '';
+    const date = new Date(version.createdDate).toLocaleDateString();
+    return `${version.version}${currentIndicator} - Created: ${date} by ${version.createdByEmail}`;
+}
+export async function deployCommand() {
+    try {
+        // Check if we're in a skill directory
+        const tomlData = readTomlData();
+        if (!tomlData) {
+            console.error("❌ No lua.skill.toml found or missing agentId/skillId. Please run this command from a skill directory.");
+            process.exit(1);
+        }
+        // Load API key
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua configure' to set up your API key.");
+            process.exit(1);
+        }
+        // Validate API key
+        const userData = await checkApiKey(apiKey);
+        console.log(`✅ Authenticated as ${userData.email}`);
+        // Fetch available versions
+        console.log("🔄 Fetching available versions...");
+        const versionsResponse = await fetchVersions(apiKey, tomlData.agentId, tomlData.skillId);
+        if (!versionsResponse.versions || versionsResponse.versions.length === 0) {
+            console.log("❌ No versions found for this skill.");
+            process.exit(1);
+        }
+        // Sort versions by creation date (newest first)
+        const sortedVersions = versionsResponse.versions.sort((a, b) => new Date(b.createdDate).getTime() - new Date(a.createdDate).getTime());
+        // Let user select a version
+        const { selectedVersion } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedVersion",
+                message: "Select a version to deploy:",
+                choices: sortedVersions.map(version => ({
+                    name: formatVersionChoice(version),
+                    value: version.version
+                }))
+            }
+        ]);
+        // Show warning and confirm deployment
+        const { confirmed } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "⚠️  Warning: This version will be deployed to all users. Do you want to proceed?",
+                default: false
+            }
+        ]);
+        if (!confirmed) {
+            console.log("❌ Deployment cancelled.");
+            process.exit(0);
+        }
+        // Publish the selected version
+        console.log(`🔄 Publishing version ${selectedVersion}...`);
+        const publishResponse = await publishVersion(apiKey, tomlData.agentId, tomlData.skillId, selectedVersion);
+        console.log("✅ Deployment successful!");
+        console.log(`📦 Version: ${publishResponse.activeVersionId}`);
+        console.log(`🆔 Skill ID: ${publishResponse.skillId}`);
+        console.log(`📅 Published at: ${new Date(publishResponse.publishedAt).toLocaleString()}`);
+        console.log(`💬 ${publishResponse.message}`);
+    }
+    catch (error) {
+        console.error("❌ Error during deployment:", error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/deploy.d.ts

@@ -1 +1,20 @@
+export interface VersionInfo {
+    version: string;
+    createdDate: string;
+    createdBy: string;
+    isCurrent: boolean;
+    createdByEmail: string;
+    createdByFullName: string;
+}
+export interface VersionsResponse {
+    versions: VersionInfo[];
+}
+export interface PublishResponse {
+    message: string;
+    skillId: string;
+    activeVersionId: string;
+    publishedAt: string;
+}
+export declare function fetchVersions(apiKey: string, agentId: string, skillId: string): Promise<VersionsResponse>;
+export declare function publishVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<PublishResponse>;
 export declare function deployCommand(): Promise<void>;