lua-cli 3.2.0-alpha.2 → 3.3.0

package/dist/commands/marketplace.js

@@ -14,18 +14,48 @@ import DeveloperApi from "../api/developer.api.service.js";
 import { loadSandboxEnvVariables } from "../utils/env-loader.utils.js";
 import inquirer from "inquirer";
 import { compareVersions } from "../utils/semver.js";
+// Valid creator actions
+const CREATOR_ACTIONS = ['list', 'publish', 'update', 'unlist', 'unpublish', 'view'];
+// Valid installer actions  
+const INSTALLER_ACTIONS = ['search', 'view', 'install', 'update', 'uninstall', 'installed'];
 /**
- * Main marketplace command - interactive menu.
+ * Shows marketplace usage help
+ */
+function showMarketplaceUsage() {
+    console.log('\nUsage:');
+    console.log('  lua marketplace                               Interactive mode');
+    console.log('  lua marketplace create [action] [options]     Creator actions');
+    console.log('  lua marketplace install [action] [options]    Installer actions');
+    console.log('\nCreator Actions:');
+    console.log('  list      --skill-name <name> --display-name <name>');
+    console.log('  publish   --marketplace-id <id> --version-id <id> [--changelog <text>]');
+    console.log('  update    --marketplace-id <id> --display-name <name>');
+    console.log('  unlist    --marketplace-id <id> [--force]');
+    console.log('  unpublish --marketplace-id <id> --version-id <id> [--force]');
+    console.log('  view');
+    console.log('\nInstaller Actions:');
+    console.log('  search    [--query <text>] [--page <n>] [--limit <n>] [--json]');
+    console.log('  view      --marketplace-id <id> [--json]');
+    console.log('  install   --marketplace-id <id> --version-id <id> [--env-vars <k=v,...>] [--force]');
+    console.log('  update    --skill-name <name> [--version-id <id>] [--env-vars <k=v,...>]');
+    console.log('  uninstall --skill-name <name> [--force]');
+    console.log('  installed [--json]');
+}
+/**
+ * Main marketplace command - interactive menu with non-interactive support.
  *
  * Features:
  * - Role selection (Creator or Installer)
  * - Creator: List, publish, update, unlist skills, manage versions
  * - Installer: Browse, search, install, and manage marketplace skills
+ * - Non-interactive mode via action + flags
  *
  * @param role - Optional role argument ('create', 'creator', 'install', or 'installer')
+ * @param action - Optional action for non-interactive mode
+ * @param options - Options for non-interactive mode
  * @returns Promise that resolves when command completes.
  */
-export async function marketplaceCommand(role) {
+export async function marketplaceCommand(role, action, options) {
     return withErrorHandling(async () => {
         // Step 1: Load and validate configuration
         const config = readSkillConfig();
@@ -59,14 +89,32 @@ export async function marketplaceCommand(role) {
             }
             else {
                 console.error(`❌ Invalid role: "${role}". Must be "create" or "install".`);
-                console.log("\nUsage:");
-                console.log("  lua marketplace                  - Interactive selection");
-                console.log("  lua marketplace create           - Creator actions (publish & manage)");
-                console.log("  lua marketplace install          - Installer actions (browse & install)");
+                showMarketplaceUsage();
                 process.exit(1);
             }
         }
-        // If role was provided as argument, go directly to that flow
+        // Step 4: If action is provided, run non-interactive mode
+        if (selectedRole && action) {
+            const normalizedAction = action.toLowerCase();
+            if (selectedRole === "creator") {
+                if (!CREATOR_ACTIONS.includes(normalizedAction)) {
+                    console.error(`❌ Invalid creator action: "${action}"`);
+                    console.log(`\nValid actions: ${CREATOR_ACTIONS.join(', ')}`);
+                    process.exit(1);
+                }
+                await executeCreatorActionNonInteractive(marketplaceApi, config, apiKey, normalizedAction, options || {});
+            }
+            else {
+                if (!INSTALLER_ACTIONS.includes(normalizedAction)) {
+                    console.error(`❌ Invalid installer action: "${action}"`);
+                    console.log(`\nValid actions: ${INSTALLER_ACTIONS.join(', ')}`);
+                    process.exit(1);
+                }
+                await executeInstallerActionNonInteractive(marketplaceApi, config, apiKey, normalizedAction, options || {});
+            }
+            return;
+        }
+        // If role was provided as argument (but no action), go directly to that flow
         if (selectedRole) {
             if (selectedRole === "creator") {
                 await handleCreatorActions(marketplaceApi, config, apiKey);
@@ -111,6 +159,481 @@ export async function marketplaceCommand(role) {
         }
     }, "marketplace");
 }
+/**
+ * Execute creator action in non-interactive mode
+ */
+async function executeCreatorActionNonInteractive(marketplaceApi, config, apiKey, action, options) {
+    switch (action) {
+        case 'list':
+            await listSkillNonInteractive(marketplaceApi, config, apiKey, options);
+            break;
+        case 'publish':
+            await publishVersionNonInteractive(marketplaceApi, config, apiKey, options);
+            break;
+        case 'update':
+            await updateMetadataNonInteractive(marketplaceApi, options);
+            break;
+        case 'unlist':
+            await unlistSkillNonInteractive(marketplaceApi, options);
+            break;
+        case 'unpublish':
+            await unpublishVersionNonInteractive(marketplaceApi, options);
+            break;
+        case 'view':
+            await viewMyListedSkillsNonInteractive(marketplaceApi, options);
+            break;
+    }
+}
+/**
+ * Execute installer action in non-interactive mode
+ */
+async function executeInstallerActionNonInteractive(marketplaceApi, config, apiKey, action, options) {
+    switch (action) {
+        case 'search':
+            await searchSkillsNonInteractive(marketplaceApi, options);
+            break;
+        case 'view':
+            await viewSkillNonInteractive(marketplaceApi, options);
+            break;
+        case 'install':
+            await installSkillNonInteractive(marketplaceApi, config, options);
+            break;
+        case 'update':
+            await updateInstalledSkillNonInteractive(marketplaceApi, config, apiKey, options);
+            break;
+        case 'uninstall':
+            await uninstallSkillNonInteractive(marketplaceApi, config, options);
+            break;
+        case 'installed':
+            await listInstalledSkillsNonInteractive(marketplaceApi, config, options);
+            break;
+    }
+}
+// ============================================================================
+// NON-INTERACTIVE CREATOR ACTIONS
+// ============================================================================
+/**
+ * Non-interactive: List a skill on the marketplace
+ */
+async function listSkillNonInteractive(marketplaceApi, config, apiKey, options) {
+    const { skillName, displayName } = options;
+    if (!skillName || !displayName) {
+        console.error('❌ Missing required options');
+        console.log('\nUsage: lua marketplace create list --skill-name <name> --display-name <name>');
+        process.exit(1);
+    }
+    const agentId = config.agent?.agentId;
+    if (!agentId) {
+        console.error('❌ Agent ID not found in configuration.');
+        process.exit(1);
+    }
+    // Verify skill exists
+    const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+    writeProgress('🔄 Verifying skill...');
+    const agentSkillsResponse = await skillApi.getSkills();
+    if (!agentSkillsResponse.success || !agentSkillsResponse.data) {
+        console.error(`❌ Failed to fetch agent skills: ${agentSkillsResponse.message}`);
+        process.exit(1);
+    }
+    const skill = agentSkillsResponse.data.skills?.find(s => s.name === skillName);
+    if (!skill) {
+        console.error(`❌ Skill not found: ${skillName}`);
+        writeInfo('\nAvailable skills:');
+        agentSkillsResponse.data.skills?.forEach(s => {
+            writeInfo(`  - ${s.name}`);
+        });
+        process.exit(1);
+    }
+    // Check if already listed
+    const creatorSkills = await marketplaceApi.getCreatorSkills();
+    const existingSkill = creatorSkills?.find(s => s.sourceSkillId === skill.id);
+    if (existingSkill?.listed) {
+        console.error(`❌ Skill "${skill.name}" is already listed as "${existingSkill.displayName}".`);
+        process.exit(1);
+    }
+    // List the skill
+    writeProgress('🔄 Listing skill on marketplace...');
+    const marketplaceSkill = await marketplaceApi.listSkill({
+        skillId: skill.id,
+        displayName: displayName,
+    });
+    writeSuccess(`✅ Skill "${marketplaceSkill.displayName}" listed successfully!`);
+    writeInfo(`Marketplace Skill ID: ${marketplaceSkill.id}`);
+    writeInfo('💡 You can now publish a version to make it installable.');
+}
+/**
+ * Non-interactive: Publish a version to the marketplace
+ */
+async function publishVersionNonInteractive(marketplaceApi, config, apiKey, options) {
+    const { marketplaceId, versionId, changelog, envVarsJson } = options;
+    if (!marketplaceId || !versionId) {
+        console.error('❌ Missing required options');
+        console.log('\nUsage: lua marketplace create publish --marketplace-id <id> --version-id <id> [--changelog <text>]');
+        process.exit(1);
+    }
+    // Parse env vars if provided
+    let envVars;
+    if (envVarsJson) {
+        try {
+            envVars = JSON.parse(envVarsJson);
+        }
+        catch (e) {
+            console.error('❌ Invalid --env-vars-json: must be valid JSON');
+            process.exit(1);
+        }
+    }
+    writeProgress('🔄 Publishing version...');
+    const payload = {
+        versionId,
+        changelog: changelog || undefined,
+        envVars: envVars && Object.keys(envVars).length > 0 ? envVars : undefined,
+    };
+    const publishedVersion = await marketplaceApi.publishVersion(marketplaceId, payload);
+    writeSuccess(`✅ Version ${publishedVersion.version} published successfully!`);
+    writeInfo('💡 You will be notified once the review is complete.');
+}
+/**
+ * Non-interactive: Update skill metadata
+ */
+async function updateMetadataNonInteractive(marketplaceApi, options) {
+    const { marketplaceId, displayName } = options;
+    if (!marketplaceId) {
+        console.error('❌ Missing required option: --marketplace-id');
+        console.log('\nUsage: lua marketplace create update --marketplace-id <id> --display-name <name>');
+        process.exit(1);
+    }
+    if (!displayName) {
+        console.error('❌ No update specified. Provide --display-name to update.');
+        process.exit(1);
+    }
+    writeProgress('🔄 Updating skill metadata...');
+    await marketplaceApi.updateSkill(marketplaceId, { displayName });
+    writeSuccess(`✅ Display name updated to "${displayName}"!`);
+}
+/**
+ * Non-interactive: Unlist a skill from the marketplace
+ */
+async function unlistSkillNonInteractive(marketplaceApi, options) {
+    const { marketplaceId, force } = options;
+    if (!marketplaceId) {
+        console.error('❌ Missing required option: --marketplace-id');
+        console.log('\nUsage: lua marketplace create unlist --marketplace-id <id> [--force]');
+        process.exit(1);
+    }
+    if (!force) {
+        console.error('❌ This action requires --force to confirm');
+        console.log('\nUsage: lua marketplace create unlist --marketplace-id <id> --force');
+        process.exit(1);
+    }
+    writeProgress('🔄 Unlisting skill...');
+    await marketplaceApi.unlistSkill(marketplaceId);
+    writeSuccess('✅ Skill unlisted from marketplace.');
+    writeInfo('💡 You can re-list it anytime using the list action.');
+}
+/**
+ * Non-interactive: Unpublish a version
+ */
+async function unpublishVersionNonInteractive(marketplaceApi, options) {
+    const { marketplaceId, versionId, force } = options;
+    if (!marketplaceId || !versionId) {
+        console.error('❌ Missing required options');
+        console.log('\nUsage: lua marketplace create unpublish --marketplace-id <id> --version-id <id> [--force]');
+        process.exit(1);
+    }
+    if (!force) {
+        console.error('❌ This action requires --force to confirm');
+        process.exit(1);
+    }
+    writeProgress('🔄 Unpublishing version...');
+    await marketplaceApi.unpublishVersion(marketplaceId, versionId);
+    writeSuccess('✅ Version unpublished successfully.');
+    writeInfo('💡 Users can no longer install this version.');
+}
+/**
+ * Non-interactive: View my listed skills
+ */
+async function viewMyListedSkillsNonInteractive(marketplaceApi, options) {
+    writeProgress('🔄 Loading your marketplace skills...');
+    const skills = await marketplaceApi.getCreatorSkills();
+    if (!skills || skills.length === 0) {
+        writeInfo('📦 You haven\'t listed any skills on the marketplace yet.');
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(skills, null, 2));
+        return;
+    }
+    console.log(`\n📊 You have ${skills.length} skill(s) on the marketplace:\n`);
+    for (const skill of skills) {
+        const statusIcon = skill.listed ? '✅' : '❌';
+        const statusText = skill.listed ? 'Listed' : 'Unlisted';
+        console.log(`${statusIcon} ${skill.displayName} (${skill.name})`);
+        console.log(`   ID: ${skill.id}`);
+        console.log(`   Status: ${statusText}`);
+        if (skill.versions && skill.versions.length > 0) {
+            const publishedVersions = skill.versions.filter(v => v.published);
+            console.log(`   Versions: ${publishedVersions.length} published / ${skill.versions.length} total`);
+        }
+        console.log('');
+    }
+}
+// ============================================================================
+// NON-INTERACTIVE INSTALLER ACTIONS
+// ============================================================================
+/**
+ * Non-interactive: Search marketplace skills
+ */
+async function searchSkillsNonInteractive(marketplaceApi, options) {
+    const page = options.page ? parseInt(options.page, 10) : 1;
+    const limit = options.limit ? parseInt(options.limit, 10) : 10;
+    writeProgress(options.query ? `🔍 Searching for "${options.query}"...` : '🔍 Loading marketplace skills...');
+    const filters = { page, limit };
+    if (options.query)
+        filters.search = options.query;
+    const results = await marketplaceApi.searchSkills(filters);
+    const skills = results?.data || [];
+    const pagination = results?.pagination;
+    if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    if (skills.length === 0) {
+        writeInfo(options.query
+            ? `📦 No skills found matching "${options.query}".`
+            : '📦 No skills available on the marketplace.');
+        return;
+    }
+    const totalCount = pagination?.totalCount || skills.length;
+    const totalPages = pagination?.totalPages || 1;
+    console.log(`\n📊 Found ${totalCount} skill(s) (Page ${page}/${totalPages}):\n`);
+    for (const skill of skills) {
+        console.log(`📦 ${skill.displayName}`);
+        console.log(`   ID: ${skill.id}`);
+        console.log(`   Name: ${skill.name}`);
+        if (skill.description)
+            console.log(`   Description: ${skill.description}`);
+        if (typeof skill.installCount !== 'undefined')
+            console.log(`   Installs: ${skill.installCount}`);
+        console.log('');
+    }
+}
+/**
+ * Non-interactive: View skill details
+ */
+async function viewSkillNonInteractive(marketplaceApi, options) {
+    const { marketplaceId } = options;
+    if (!marketplaceId) {
+        console.error('❌ Missing required option: --marketplace-id');
+        console.log('\nUsage: lua marketplace install view --marketplace-id <id>');
+        process.exit(1);
+    }
+    writeProgress('🔄 Loading skill details...');
+    const skill = await marketplaceApi.getSkillById(marketplaceId);
+    if (options.json) {
+        console.log(JSON.stringify(skill, null, 2));
+        return;
+    }
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`📦 ${skill.displayName}`);
+    console.log(`${'='.repeat(60)}\n`);
+    console.log(`ID: ${skill.id}`);
+    console.log(`Name: ${skill.name}`);
+    console.log(`Created: ${new Date(skill.createdAt).toLocaleDateString()}`);
+    if (skill.description)
+        console.log(`\nDescription: ${skill.description}`);
+    if (skill.longDescription)
+        console.log(`\nDetails:\n${skill.longDescription}`);
+    if (skill.category)
+        console.log(`\nCategory: ${skill.category}`);
+    if (skill.tags?.length)
+        console.log(`Tags: ${skill.tags.join(', ')}`);
+    if (typeof skill.installCount !== 'undefined')
+        console.log(`Installs: ${skill.installCount}`);
+    if (skill.versions?.length) {
+        const publishedVersions = skill.versions.filter(v => v.published);
+        console.log(`\nVersions: ${publishedVersions.length} published / ${skill.versions.length} total`);
+        if (publishedVersions.length > 0) {
+            const latest = publishedVersions.sort((a, b) => compareVersions(b.version, a.version))[0];
+            console.log(`Latest: v${latest.version} (ID: ${latest.id})`);
+        }
+    }
+    console.log(`\n${'='.repeat(60)}\n`);
+}
+/**
+ * Non-interactive: Install a skill
+ */
+async function installSkillNonInteractive(marketplaceApi, config, options) {
+    const { marketplaceId, versionId, envVars, force } = options;
+    if (!marketplaceId || !versionId) {
+        console.error('❌ Missing required options');
+        console.log('\nUsage: lua marketplace install install --marketplace-id <id> --version-id <id> [--env-vars <k=v,...>]');
+        process.exit(1);
+    }
+    const agentId = config.agent?.agentId;
+    if (!agentId) {
+        console.error('❌ Agent ID not found in configuration.');
+        process.exit(1);
+    }
+    // Parse env vars
+    const envVarsConfig = {};
+    if (envVars) {
+        const pairs = envVars.split(',');
+        for (const pair of pairs) {
+            const [key, ...valueParts] = pair.split('=');
+            if (key && valueParts.length > 0) {
+                envVarsConfig[key.trim()] = valueParts.join('=').trim();
+            }
+        }
+    }
+    if (!force) {
+        writeInfo(`\n📋 Installation Summary:`);
+        writeInfo(`  Marketplace ID: ${marketplaceId}`);
+        writeInfo(`  Version ID: ${versionId}`);
+        writeInfo(`  Agent: ${agentId}`);
+        if (Object.keys(envVarsConfig).length > 0) {
+            writeInfo(`  Env vars: ${Object.keys(envVarsConfig).length} configured`);
+        }
+        console.error('\n❌ Use --force to confirm installation');
+        process.exit(1);
+    }
+    writeProgress('🔄 Installing skill...');
+    await marketplaceApi.installSkill(marketplaceId, agentId, {
+        versionId,
+        envVars: Object.keys(envVarsConfig).length > 0 ? envVarsConfig : undefined,
+    });
+    writeSuccess('✅ Skill installed successfully!');
+    writeInfo(`💡 The skill is now available on agent ${agentId}.`);
+}
+/**
+ * Non-interactive: Update an installed skill
+ */
+async function updateInstalledSkillNonInteractive(marketplaceApi, config, apiKey, options) {
+    const { skillName, versionId, envVars } = options;
+    if (!skillName) {
+        console.error('❌ Missing required option: --skill-name');
+        console.log('\nUsage: lua marketplace install update --skill-name <name> [--version-id <id>] [--env-vars <k=v,...>]');
+        process.exit(1);
+    }
+    const agentId = config.agent?.agentId;
+    if (!agentId) {
+        console.error('❌ Agent ID not found in configuration.');
+        process.exit(1);
+    }
+    // Find the installed skill
+    writeProgress('🔄 Loading installed skills...');
+    const installedSkills = await marketplaceApi.getInstalledSkills(agentId);
+    const installedSkill = installedSkills?.find(s => s.name === skillName ||
+        s.title === skillName);
+    if (!installedSkill) {
+        console.error(`❌ Installed skill not found: ${skillName}`);
+        if (installedSkills?.length) {
+            writeInfo('\nInstalled skills:');
+            installedSkills.forEach(s => {
+                writeInfo(`  - ${s.title || s.name}`);
+            });
+        }
+        process.exit(1);
+    }
+    if (!installedSkill.marketplaceSkillId) {
+        console.error('❌ Skill is missing marketplace skill ID.');
+        process.exit(1);
+    }
+    // Parse env vars
+    let newEnvVars;
+    if (envVars) {
+        newEnvVars = {};
+        const pairs = envVars.split(',');
+        for (const pair of pairs) {
+            const [key, ...valueParts] = pair.split('=');
+            if (key && valueParts.length > 0) {
+                newEnvVars[key.trim()] = valueParts.join('=').trim();
+            }
+        }
+    }
+    const updatePayload = {};
+    if (versionId)
+        updatePayload.versionId = versionId;
+    if (newEnvVars)
+        updatePayload.envVars = newEnvVars;
+    if (!updatePayload.versionId && !updatePayload.envVars) {
+        console.error('❌ No update specified. Provide --version-id or --env-vars.');
+        process.exit(1);
+    }
+    writeProgress('🔄 Updating installed skill...');
+    await marketplaceApi.updateInstallation(installedSkill.marketplaceSkillId, agentId, updatePayload);
+    writeSuccess(`✅ "${installedSkill.title || installedSkill.name}" updated successfully!`);
+}
+/**
+ * Non-interactive: Uninstall a skill
+ */
+async function uninstallSkillNonInteractive(marketplaceApi, config, options) {
+    const { skillName, force } = options;
+    if (!skillName) {
+        console.error('❌ Missing required option: --skill-name');
+        console.log('\nUsage: lua marketplace install uninstall --skill-name <name> [--force]');
+        process.exit(1);
+    }
+    const agentId = config.agent?.agentId;
+    if (!agentId) {
+        console.error('❌ Agent ID not found in configuration.');
+        process.exit(1);
+    }
+    // Find the installed skill
+    writeProgress('🔄 Loading installed skills...');
+    const installedSkills = await marketplaceApi.getInstalledSkills(agentId);
+    const installedSkill = installedSkills?.find(s => s.name === skillName ||
+        s.title === skillName);
+    if (!installedSkill) {
+        console.error(`❌ Installed skill not found: ${skillName}`);
+        process.exit(1);
+    }
+    if (!installedSkill.marketplaceSkillId) {
+        console.error('❌ Skill is missing marketplace skill ID.');
+        process.exit(1);
+    }
+    if (!force) {
+        console.error(`❌ Use --force to confirm uninstalling "${installedSkill.title || installedSkill.name}"`);
+        process.exit(1);
+    }
+    writeProgress('🔄 Uninstalling skill...');
+    await marketplaceApi.uninstallSkill(installedSkill.marketplaceSkillId, agentId);
+    writeSuccess(`✅ "${installedSkill.title || installedSkill.name}" uninstalled successfully!`);
+}
+/**
+ * Non-interactive: List installed skills
+ */
+async function listInstalledSkillsNonInteractive(marketplaceApi, config, options) {
+    const agentId = config.agent?.agentId;
+    if (!agentId) {
+        console.error('❌ Agent ID not found in configuration.');
+        process.exit(1);
+    }
+    writeProgress('🔄 Loading installed marketplace skills...');
+    const skills = await marketplaceApi.getInstalledSkills(agentId);
+    if (!skills || skills.length === 0) {
+        writeInfo('📦 No marketplace skills installed on this agent.');
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(skills, null, 2));
+        return;
+    }
+    console.log(`\n📊 You have ${skills.length} marketplace skill(s) installed:\n`);
+    for (const skill of skills) {
+        console.log(`📦 ${skill.title || skill.name}`);
+        console.log(`   ID: ${skill.id}`);
+        if (skill.marketplaceSkillId) {
+            console.log(`   Marketplace ID: ${skill.marketplaceSkillId}`);
+        }
+        if (skill.activeVersionId) {
+            console.log(`   Version: v${skill.activeVersionId}`);
+        }
+        if (skill.description) {
+            console.log(`   Description: ${skill.description}`);
+        }
+        console.log('');
+    }
+}
 async function handleCreatorActions(marketplaceApi, config, apiKey) {
     let back = false;
     while (!back) {
@@ -1636,3 +2159,4 @@ async function listInstalledSkills(marketplaceApi, config) {
         console.error(`\n❌ Error loading installed skills: ${error.message}\n`);
     }
 }
+//# sourceMappingURL=marketplace.js.map