lua-cli 3.0.3 → 3.1.0-alpha.2

package/dist/commands/marketplace.js

@@ -0,0 +1,1593 @@
+/**
+ * Marketplace Command
+ * A command to interact with the Lua Marketplace.
+ */
+import { loadApiKey, checkApiKey } from "../services/auth.js";
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo, } from "../utils/cli.js";
+import { safePrompt } from "../utils/prompt-handler.js";
+import { MarketplaceApiService } from "../api/marketplace.api.service.js";
+import { readSkillConfig } from "../utils/files.js";
+import { validateConfig, validateAgentConfig } from "../utils/dev-helpers.js";
+import { BASE_URLS } from "../config/constants.js";
+import SkillApi from "../api/skills.api.service.js";
+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";
+/**
+ * Main marketplace command - interactive menu.
+ *
+ * Features:
+ * - Role selection (Creator or Installer)
+ * - Creator: List, publish, update, unlist skills, manage versions
+ * - Installer: Browse, search, install, and manage marketplace skills
+ *
+ * @param role - Optional role argument ('create', 'creator', 'install', or 'installer')
+ * @returns Promise that resolves when command completes.
+ */
+export async function marketplaceCommand(role) {
+    return withErrorHandling(async () => {
+        // Step 1: Load and validate configuration
+        const config = readSkillConfig();
+        try {
+            validateConfig(config);
+            validateAgentConfig(config);
+        }
+        catch (error) {
+            console.error(`\n❌ Invalid lua.skill.yaml configuration: ${error.message}\n`);
+            process.exit(1);
+        }
+        // Step 2: Authenticate
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        const marketplaceApi = new MarketplaceApiService(apiKey);
+        let selectedRole = null;
+        // Step 3: Check if role was provided as argument
+        if (role) {
+            const normalizedRole = role.toLowerCase();
+            if (normalizedRole === "create" || normalizedRole === "creator") {
+                selectedRole = "creator";
+            }
+            else if (normalizedRole === "install" ||
+                normalizedRole === "installer") {
+                selectedRole = "installer";
+            }
+            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)");
+                process.exit(1);
+            }
+        }
+        // If role was provided as argument, go directly to that flow
+        if (selectedRole) {
+            if (selectedRole === "creator") {
+                await handleCreatorActions(marketplaceApi, config, apiKey);
+            }
+            else {
+                await handleInstallerActions(marketplaceApi, config, apiKey);
+            }
+            return;
+        }
+        // Otherwise, show interactive selection
+        let exit = false;
+        while (!exit) {
+            const roleAnswer = await safePrompt([
+                {
+                    type: "list",
+                    name: "role",
+                    message: "What would you like to do?",
+                    choices: [
+                        {
+                            name: "As a Creator (Publish & Manage your skills)",
+                            value: "creator",
+                        },
+                        {
+                            name: "As an Installer (Find & Install skills)",
+                            value: "installer",
+                        },
+                        { name: "Exit", value: "exit" },
+                    ],
+                },
+            ]);
+            if (!roleAnswer || roleAnswer.role === "exit") {
+                exit = true;
+                console.log("\n👋 Goodbye!\n");
+                continue;
+            }
+            if (roleAnswer.role === "creator") {
+                await handleCreatorActions(marketplaceApi, config, apiKey);
+            }
+            else if (roleAnswer.role === "installer") {
+                await handleInstallerActions(marketplaceApi, config, apiKey);
+            }
+        }
+    }, "marketplace");
+}
+async function handleCreatorActions(marketplaceApi, config, apiKey) {
+    let back = false;
+    while (!back) {
+        const creatorAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "action",
+                message: "Creator Menu:",
+                choices: [
+                    { name: "List a new skill on the Marketplace", value: "list" },
+                    { name: "Publish a new version of a skill", value: "publish" },
+                    { name: "Update metadata for a listed skill", value: "update" },
+                    { name: "Unlist a skill from the Marketplace", value: "unlist" },
+                    { name: "Unpublish a skill version", value: "unpublish" },
+                    { name: "View my listed skills", value: "view" },
+                    { name: "Back", value: "back" },
+                ],
+            },
+        ]);
+        if (!creatorAnswer || creatorAnswer.action === "back") {
+            back = true;
+            continue;
+        }
+        switch (creatorAnswer.action) {
+            case "list":
+                await listSkillOnMarketplace(marketplaceApi, config, apiKey);
+                continue;
+            case "publish":
+                await publishSkillVersion(marketplaceApi, config, apiKey);
+                continue;
+            case "update":
+                await updateSkillMetadata(marketplaceApi, config);
+                continue;
+            case "unlist":
+                await unlistSkillFromMarketplace(marketplaceApi);
+                continue;
+            case "unpublish":
+                await unpublishSkillVersion(marketplaceApi);
+                continue;
+            case "view":
+                await viewMyListedSkills(marketplaceApi);
+                continue;
+            // Other cases will be added here
+            default:
+                console.log(`\nAction '${creatorAnswer.action}' is not implemented yet.\n`);
+                await safePrompt([
+                    {
+                        type: "input",
+                        name: "continue",
+                        message: "Press Enter to continue...",
+                    },
+                ]);
+                continue;
+        }
+    }
+}
+async function listSkillOnMarketplace(marketplaceApi, config, apiKey) {
+    // 1. Fetch agent skills
+    const agentId = config.agent?.agentId;
+    if (!agentId) {
+        console.error("\n❌ Agent ID not found in configuration.");
+        return;
+    }
+    const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+    writeProgress("🔄 Loading your agent's skills...\n");
+    const agentSkillsResponse = await skillApi.getSkills();
+    if (!agentSkillsResponse.success || !agentSkillsResponse.data) {
+        console.error(`\n❌ Failed to fetch agent skills: ${agentSkillsResponse.message}\n`);
+        return;
+    }
+    const skills = agentSkillsResponse.data.skills || [];
+    if (skills.length === 0) {
+        console.log("\nℹ️  No skills found on this agent.");
+        console.log("💡 Push a skill first using 'lua push skill'.\n");
+        return;
+    }
+    // 2. Prompt user to select a skill to list
+    const skillAnswer = await safePrompt([
+        {
+            type: "list",
+            name: "skill",
+            message: "Which skill would you like to list on the marketplace?",
+            choices: skills.map((s) => ({
+                name: `${s.name}`,
+                value: s,
+            })),
+        },
+    ]);
+    if (!skillAnswer)
+        return;
+    const skillToList = skillAnswer.skill;
+    // 2.5 Check if skill already exists (for re-listing)
+    writeProgress("\n🔄 Checking existing marketplace listings...");
+    let defaultDisplayName;
+    try {
+        const creatorSkills = await marketplaceApi.getCreatorSkills();
+        const existingSkill = creatorSkills?.find((s) => s.sourceSkillId === skillToList.id || s.name === skillToList.name);
+        if (existingSkill) {
+            if (existingSkill.listed) {
+                writeInfo(`\nℹ️  Skill "${skillToList.name}" is already listed on the marketplace as "${existingSkill.displayName}".\n`);
+                return;
+            }
+            writeInfo(`\nℹ️  Skill "${skillToList.name}" was previously listed as "${existingSkill.displayName}". You are re-listing it.`);
+            defaultDisplayName = existingSkill.displayName;
+        }
+    }
+    catch (error) {
+        // Ignore error, treat as new listing
+    }
+    // 3. Prompt for required metadata
+    const metadata = await safePrompt([
+        {
+            type: "input",
+            name: "displayName",
+            message: "Enter a display name for the marketplace:",
+            default: defaultDisplayName,
+            validate: (input) => input && input.trim().length > 0
+                ? true
+                : "Display name cannot be empty.",
+        },
+    ]);
+    if (!metadata)
+        return;
+    // 5. Construct payload and list the skill
+    const payload = {
+        skillId: skillToList.id,
+        displayName: metadata.displayName,
+        // TODO: Add remaining metadata from user
+    };
+    try {
+        writeProgress("\nListing skill on the marketplace...");
+        const marketplaceSkill = await marketplaceApi.listSkill(payload);
+        writeSuccess(`\n✅ Skill "${marketplaceSkill.displayName}" listed successfully!`);
+        writeInfo(`Marketplace Skill ID: ${marketplaceSkill.id}`);
+        writeInfo("💡 You can now publish a version to make it installable.\n");
+    }
+    catch (error) {
+        console.error(`\n❌ Error listing skill: ${error.message}\n`);
+    }
+}
+async function publishSkillVersion(marketplaceApi, config, apiKey) {
+    try {
+        // 1. Fetch creator's listed marketplace skills
+        writeProgress("🔄 Loading your marketplace skills...\n");
+        const creatorSkillsResponse = await marketplaceApi.getCreatorSkills();
+        // Only show listed skills for publishing versions
+        const listedMarketplaceSkills = (creatorSkillsResponse || []).filter((s) => s.listed);
+        if (listedMarketplaceSkills.length === 0) {
+            writeInfo("\nℹ️ You haven't listed any skills on the marketplace yet.");
+            writeInfo("💡 Please list a skill first using the 'List a new skill' option.\n");
+            return;
+        }
+        // 2. Prompt user to select a listed marketplace skill
+        const marketplaceSkillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "marketplaceSkill",
+                message: "Which skill do you want to publish a new version for?",
+                choices: listedMarketplaceSkills.map((s) => ({
+                    name: s.displayName,
+                    value: s,
+                })),
+            },
+        ]);
+        if (!marketplaceSkillAnswer)
+            return;
+        const selectedMarketplaceSkill = marketplaceSkillAnswer.marketplaceSkill;
+        // 3. Fetch agent skills to find the corresponding source skill
+        const agentId = config.agent?.agentId;
+        if (!agentId) {
+            console.error("\n❌ Agent ID not found in configuration.");
+            return;
+        }
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        writeProgress("🔄 Loading your agent's skills...\n");
+        const agentSkillsResponse = await skillApi.getSkills();
+        if (!agentSkillsResponse.success || !agentSkillsResponse.data) {
+            throw new Error(`Failed to fetch agent skills: ${agentSkillsResponse.message}`);
+        }
+        const agentSkills = agentSkillsResponse.data.skills || [];
+        // Try to find by sourceSkillId first, then by name
+        let sourceSkill = agentSkills.find((s) => s.id === selectedMarketplaceSkill.sourceSkillId);
+        if (!sourceSkill) {
+            // Fallback: try matching by name
+            sourceSkill = agentSkills.find((s) => s.name === selectedMarketplaceSkill.name);
+        }
+        if (!sourceSkill) {
+            console.error(`\n❌ Could not find the source skill on your agent.`);
+            writeInfo(`💡 The skill "${selectedMarketplaceSkill.name}" (ID: ${selectedMarketplaceSkill.sourceSkillId}) is missing from agent ${agentId}.`);
+            return;
+        }
+        // 4. Fetch all available versions for that source skill
+        writeProgress(`🔄 Loading versions for ${selectedMarketplaceSkill.displayName}...\n`);
+        const agentSkillVersionsResponse = await skillApi.getSkillVersions(sourceSkill.id);
+        if (!agentSkillVersionsResponse.success) {
+            throw new Error(`Failed to fetch skill versions: ${agentSkillVersionsResponse.message}`);
+        }
+        const availableAgentVersions = agentSkillVersionsResponse.data?.versions || [];
+        if (availableAgentVersions.length === 0) {
+            writeInfo(`\nℹ️ No versions found for ${selectedMarketplaceSkill.displayName}.`);
+            writeInfo("💡 Push a version first using 'lua push skill'.\n");
+            return;
+        }
+        // 4.5 Fetch existing marketplace versions to check status
+        writeProgress(`\n🔄 Checking marketplace version status...`);
+        const marketplaceVersions = await marketplaceApi.getSkillVersions(selectedMarketplaceSkill.id);
+        const getVersionStatus = (version) => {
+            const mpVersion = marketplaceVersions?.find((v) => v.version === version);
+            if (!mpVersion)
+                return { status: "new", label: "📤 Publish" };
+            if (mpVersion.published)
+                return { status: "published", label: "✅ Live" };
+            return { status: "unpublished", label: "🔄 Republish" };
+        };
+        // 5. Prompt user to select an agent version to publish
+        const agentVersionAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "agentVersion",
+                message: "Select a version to publish:",
+                choices: availableAgentVersions
+                    .sort((a, b) => compareVersions(b.version, a.version)) // Sort descending
+                    .map((v) => {
+                    const { status, label } = getVersionStatus(v.version);
+                    return {
+                        name: `${label} - v${v.version} (Created: ${new Date(v.createdDate).toLocaleString()})`,
+                        value: { ...v, _status: status },
+                        disabled: status === "published" ? "Already published" : false,
+                    };
+                }),
+            },
+        ]);
+        if (!agentVersionAnswer)
+            return;
+        const agentVersionToPublish = agentVersionAnswer.agentVersion;
+        if (agentVersionToPublish._status === "unpublished") {
+            writeInfo(`\nℹ️  You are republishing v${agentVersionToPublish.version}. This will make it live again and update its details.\n`);
+        }
+        // 6. Prompt for an optional changelog
+        const existingChangelog = agentVersionToPublish._status === "unpublished"
+            ? marketplaceVersions?.find((v) => v.version === agentVersionToPublish.version)?.changelog
+            : undefined;
+        const changelogAnswer = await safePrompt([
+            {
+                type: "input",
+                name: "changelog",
+                message: "Enter a changelog for this version (optional):",
+                default: existingChangelog,
+            },
+        ]);
+        // 7. Configure environment variables for this version
+        let initialEnvVars;
+        if (agentVersionToPublish._status === "unpublished") {
+            // Republishing: Use THIS version's existing metadata
+            initialEnvVars = marketplaceVersions?.find((v) => v.version === agentVersionToPublish.version)?.envVarsMetadata;
+        }
+        else {
+            // New Version: Default to the LATEST existing version's metadata (if any)
+            const latestVersion = marketplaceVersions?.sort((a, b) => compareVersions(b.version, a.version))[0];
+            if (latestVersion) {
+                initialEnvVars = latestVersion.envVarsMetadata;
+            }
+        }
+        const envVars = await handleEnvVarConfiguration(initialEnvVars);
+        if (envVars === null) {
+            console.log("\nCancelled publishing process.\n");
+            return;
+        }
+        // 8. Publish the version to the marketplace
+        const payload = {
+            versionId: agentVersionToPublish.id,
+            changelog: changelogAnswer?.changelog || undefined,
+            envVars: Object.keys(envVars).length > 0 ? envVars : undefined,
+        };
+        writeProgress(`\n Publishing version to the marketplace...`);
+        const publishedVersion = await marketplaceApi.publishVersion(selectedMarketplaceSkill.id, payload);
+        writeSuccess(`\n✅ Version ${publishedVersion.version} of "${selectedMarketplaceSkill.displayName}" has been submitted for review!`);
+        writeInfo("💡 You will be notified once the review is complete.\n");
+    }
+    catch (error) {
+        console.error(`\n❌ Error publishing skill version: ${error.message}\n`);
+    }
+}
+async function updateSkillMetadata(marketplaceApi, config) {
+    try {
+        // 1. Fetch creator's listed marketplace skills
+        writeProgress("🔄 Loading your marketplace skills...\n");
+        const listedMarketplaceSkills = await marketplaceApi.getCreatorSkills();
+        if (!listedMarketplaceSkills || listedMarketplaceSkills.length === 0) {
+            writeInfo("\nℹ️ You haven't listed any skills on the marketplace yet.");
+            writeInfo("💡 Please list a skill first using the 'List a new skill' option.\n");
+            return;
+        }
+        // 2. Prompt user to select a marketplace skill to update
+        const marketplaceSkillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "marketplaceSkill",
+                message: "Which skill would you like to update?",
+                choices: listedMarketplaceSkills.map((s) => ({
+                    name: s.displayName,
+                    value: s,
+                })),
+            },
+        ]);
+        if (!marketplaceSkillAnswer)
+            return;
+        const marketplaceSkillToUpdate = marketplaceSkillAnswer.marketplaceSkill;
+        let back = false;
+        while (!back) {
+            const actionAnswer = await safePrompt([
+                {
+                    type: "list",
+                    name: "action",
+                    message: `What would you like to update for "${marketplaceSkillToUpdate.displayName}"?`,
+                    choices: [
+                        { name: "Display Name", value: "displayName" },
+                        { name: "Finish Updating", value: "back" },
+                    ],
+                },
+            ]);
+            const action = actionAnswer?.action || "back";
+            if (action === "back") {
+                back = true;
+                continue;
+            }
+            if (action === "displayName") {
+                await updateDisplayName(marketplaceApi, marketplaceSkillToUpdate);
+            }
+        }
+        // Final success message can be removed as each sub-action gives its own feedback.
+    }
+    catch (error) {
+        console.error(`\n❌ Error updating skill metadata: ${error.message}\n`);
+    }
+}
+async function updateDisplayName(marketplaceApi, marketplaceSkill) {
+    const newDisplayNameAnswer = await safePrompt([
+        {
+            type: "input",
+            name: "newDisplayName",
+            message: `Enter the new display name for "${marketplaceSkill.displayName}":`,
+            default: marketplaceSkill.displayName,
+            validate: (input) => input && input.trim().length > 0
+                ? true
+                : "Display name cannot be empty.",
+        },
+    ]);
+    if (!newDisplayNameAnswer)
+        return;
+    const newDisplayName = newDisplayNameAnswer.newDisplayName;
+    const payload = { displayName: newDisplayName };
+    writeProgress(`\nUpdating display name...`);
+    await marketplaceApi.updateSkill(marketplaceSkill.id, payload);
+    writeSuccess(`\n✅ Display name updated successfully to "${newDisplayName}"!\n`);
+    marketplaceSkill.displayName = newDisplayName; // Update in-memory object for sub-menu display
+}
+/**
+ * Unlist a skill from the marketplace
+ */
+async function unlistSkillFromMarketplace(marketplaceApi) {
+    try {
+        // 1. Fetch creator's listed marketplace skills
+        writeProgress("🔄 Loading your marketplace skills...\n");
+        const listedMarketplaceSkills = await marketplaceApi.getCreatorSkills();
+        if (!listedMarketplaceSkills || listedMarketplaceSkills.length === 0) {
+            writeInfo("\nℹ️ You haven't listed any skills on the marketplace yet.");
+            writeInfo("💡 Please list a skill first using the 'List a new skill' option.\n");
+            return;
+        }
+        // Filter to only show listed skills
+        const activeListedSkills = listedMarketplaceSkills.filter((s) => s.listed);
+        if (activeListedSkills.length === 0) {
+            writeInfo("\nℹ️ You don't have any active listings on the marketplace.");
+            writeInfo("💡 All your skills are already unlisted.\n");
+            return;
+        }
+        // 2. Prompt user to select a marketplace skill to unlist
+        const marketplaceSkillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "marketplaceSkill",
+                message: "Which skill would you like to unlist from the marketplace?",
+                choices: activeListedSkills.map((s) => ({
+                    name: `${s.displayName} (${s.name})`,
+                    value: s,
+                })),
+            },
+        ]);
+        if (!marketplaceSkillAnswer)
+            return;
+        const marketplaceSkillToUnlist = marketplaceSkillAnswer.marketplaceSkill;
+        // 3. Confirm the action
+        const confirmAnswer = await safePrompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: `⚠️  Are you sure you want to unlist "${marketplaceSkillToUnlist.displayName}"? This will unpublish all versions and remove it from the marketplace.`,
+                default: false,
+            },
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            writeInfo("\n❌ Unlist cancelled.\n");
+            return;
+        }
+        // 4. Unlist the skill
+        writeProgress("\n🔄 Unlisting skill from marketplace...");
+        await marketplaceApi.unlistSkill(marketplaceSkillToUnlist.id);
+        writeSuccess(`\n✅ "${marketplaceSkillToUnlist.displayName}" has been unlisted from the marketplace.`);
+        writeInfo("💡 You can re-list it anytime using the 'List a new skill' option.\n");
+    }
+    catch (error) {
+        console.error(`\n❌ Error unlisting skill: ${error.message}\n`);
+    }
+}
+/**
+ * Unpublish a specific version of a marketplace skill
+ */
+async function unpublishSkillVersion(marketplaceApi) {
+    try {
+        // 1. Fetch creator's listed marketplace skills
+        writeProgress("🔄 Loading your marketplace skills...\n");
+        const listedMarketplaceSkills = await marketplaceApi.getCreatorSkills();
+        if (!listedMarketplaceSkills || listedMarketplaceSkills.length === 0) {
+            writeInfo("\nℹ️ You haven't listed any skills on the marketplace yet.");
+            writeInfo("💡 Please list a skill first using the 'List a new skill' option.\n");
+            return;
+        }
+        // 2. Prompt user to select a marketplace skill
+        const marketplaceSkillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "marketplaceSkill",
+                message: "Which skill has the version you want to unpublish?",
+                choices: listedMarketplaceSkills.map((s) => ({
+                    name: `${s.displayName} (${s.name})`,
+                    value: s,
+                })),
+            },
+        ]);
+        if (!marketplaceSkillAnswer)
+            return;
+        const selectedMarketplaceSkill = marketplaceSkillAnswer.marketplaceSkill;
+        // 3. Fetch versions for the selected skill
+        writeProgress(`\n🔄 Loading versions for ${selectedMarketplaceSkill.displayName}...\n`);
+        const versions = await marketplaceApi.getSkillVersions(selectedMarketplaceSkill.id);
+        const publishedVersions = (versions || []).filter((v) => v.published);
+        if (publishedVersions.length === 0) {
+            writeInfo(`\nℹ️ No published versions found for "${selectedMarketplaceSkill.displayName}".`);
+            writeInfo("💡 All versions are already unpublished.\n");
+            return;
+        }
+        // 4. Prompt user to select a version to unpublish
+        const versionAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "version",
+                message: "Which version would you like to unpublish?",
+                choices: publishedVersions
+                    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+                    .map((v) => ({
+                    name: `v${v.version} - ${new Date(v.createdAt).toLocaleDateString()}`,
+                    value: v,
+                })),
+            },
+        ]);
+        if (!versionAnswer)
+            return;
+        const versionToUnpublish = versionAnswer.version;
+        // 5. Confirm the action
+        const confirmAnswer = await safePrompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: `⚠️  Are you sure you want to unpublish version ${versionToUnpublish.version} of "${selectedMarketplaceSkill.displayName}"?`,
+                default: false,
+            },
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            writeInfo("\n❌ Unpublish cancelled.\n");
+            return;
+        }
+        // 6. Unpublish the version
+        writeProgress("\n🔄 Unpublishing version...");
+        await marketplaceApi.unpublishVersion(selectedMarketplaceSkill.id, versionToUnpublish.id);
+        writeSuccess(`\n✅ Version ${versionToUnpublish.version} of "${selectedMarketplaceSkill.displayName}" has been unpublished.`);
+        writeInfo("💡 Users can no longer install this version. You can publish it again anytime.\n");
+    }
+    catch (error) {
+        console.error(`\n❌ Error unpublishing version: ${error.message}\n`);
+    }
+}
+/**
+ * View all listed skills created by the user
+ */
+async function viewMyListedSkills(marketplaceApi) {
+    try {
+        writeProgress("🔄 Loading your marketplace skills...\n");
+        const listedMarketplaceSkills = await marketplaceApi.getCreatorSkills();
+        if (!listedMarketplaceSkills || listedMarketplaceSkills.length === 0) {
+            writeInfo("\n📦 You haven't listed any skills on the marketplace yet.");
+            writeInfo("💡 Use 'List a new skill' to get started.\n");
+            return;
+        }
+        // Display summary
+        console.log(`\n📊 You have ${listedMarketplaceSkills.length} skill(s) on the marketplace:\n`);
+        // Display each skill
+        for (const skill of listedMarketplaceSkills) {
+            const statusIcon = skill.listed ? "✅" : "❌";
+            const statusText = skill.listed ? "Listed" : "Unlisted";
+            console.log(`${statusIcon} ${skill.displayName} (${skill.name})`);
+            console.log(`   Status: ${statusText}`);
+            if (skill.description) {
+                console.log(`   Description: ${skill.description}`);
+            }
+            if (skill.category) {
+                console.log(`   Category: ${skill.category}`);
+            }
+            if (skill.tags && skill.tags.length > 0) {
+                console.log(`   Tags: ${skill.tags.join(", ")}`);
+            }
+            if (skill.verified)
+                console.log(`   ✨ Verified Creator`);
+            if (skill.featured)
+                console.log(`   ⭐ Featured Skill`);
+            if (skill.createdAt) {
+                console.log(`   Created: ${new Date(skill.createdAt).toLocaleDateString()}`);
+            }
+            if (skill.updatedAt) {
+                console.log(`   Last Updated: ${new Date(skill.updatedAt).toLocaleDateString()}`);
+            }
+            // Show version info if available
+            if (skill.versions && skill.versions.length > 0) {
+                const publishedVersions = skill.versions.filter((v) => v.published);
+                const totalVersions = skill.versions.length;
+                console.log(`   Versions: ${publishedVersions.length} published / ${totalVersions} total`);
+                if (publishedVersions.length > 0) {
+                    const latestVersion = publishedVersions.sort((a, b) => compareVersions(b.version, a.version))[0];
+                    console.log(`   Latest Published: v${latestVersion.version}`);
+                }
+            }
+            // Show install count if available
+            if (typeof skill.installCount !== "undefined") {
+                console.log(`   Installs: ${skill.installCount}`);
+            }
+            // Show environment variables from latest version
+            const latestVersion = skill.versions && skill.versions.length > 0
+                ? skill.versions.sort((a, b) => compareVersions(b.version, a.version))[0]
+                : null;
+            if (latestVersion &&
+                latestVersion.envVarsMetadata &&
+                Object.keys(latestVersion.envVarsMetadata).length > 0) {
+                const envKeys = Object.keys(latestVersion.envVarsMetadata).join(", ");
+                console.log(`   Environment Variables (latest version): ${envKeys} (${Object.keys(latestVersion.envVarsMetadata).length} configured)`);
+            }
+            console.log(""); // Empty line between skills
+        }
+        // Prompt to continue
+        await safePrompt([
+            {
+                type: "input",
+                name: "continue",
+                message: "Press Enter to continue...",
+            },
+        ]);
+    }
+    catch (error) {
+        console.error(`\n❌ Error loading your skills: ${error.message}\n`);
+    }
+}
+/**
+ * Handle env var configuration
+ * Builds an environment variable configuration object interactively.
+ * Used for both listing new skills and updating existing ones.
+ */
+async function handleEnvVarConfiguration(initialEnvVars) {
+    const detectedKeys = loadSandboxEnvVariables().map((v) => v.key);
+    let envVars = initialEnvVars
+        ? { ...initialEnvVars }
+        : {};
+    let continueManaging = true;
+    while (continueManaging) {
+        const keys = Object.keys(envVars);
+        const statusText = keys.length > 0
+            ? `Current: ${keys.length} configured (${keys.join(", ")})`
+            : "Current: None configured";
+        const actionAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "action",
+                message: `Manage environment variables (${statusText}):`,
+                choices: [
+                    { name: "Add a new variable", value: "add" },
+                    { name: "Edit an existing variable", value: "edit" },
+                    { name: "Delete a variable", value: "delete" },
+                    new inquirer.Separator(),
+                    { name: "Finish and continue", value: "done" },
+                ],
+            },
+        ]);
+        if (!actionAnswer || actionAnswer.action === "done") {
+            continueManaging = false;
+            continue;
+        }
+        const { action } = actionAnswer;
+        switch (action) {
+            case "add":
+                await handleEnvVarAction("add", envVars, detectedKeys);
+                break;
+            case "edit":
+                await handleEnvVarAction("edit", envVars, detectedKeys);
+                break;
+            case "delete":
+                await handleEnvVarAction("delete", envVars, detectedKeys);
+                break;
+        }
+    }
+    return envVars;
+}
+async function handleEnvVarAction(action, envVars, detectedKeys) {
+    const keys = Object.keys(envVars);
+    if (action === "add") {
+        const unconfiguredKeys = detectedKeys.filter((k) => !envVars[k]);
+        const choices = [
+            ...unconfiguredKeys.map((key) => ({
+                name: `From .env file: ${key}`,
+                value: key,
+            })),
+            new inquirer.Separator(),
+            { name: "Manually enter a variable name", value: "manual" },
+            { name: "Back", value: "back" },
+        ];
+        const varNameAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "varName",
+                message: "How would you like to add a variable?",
+                choices,
+            },
+        ]);
+        if (!varNameAnswer || varNameAnswer.varName === "back")
+            return;
+        let keyToAdd = varNameAnswer.varName;
+        if (keyToAdd === "manual") {
+            const manualKeyAnswer = await safePrompt([
+                {
+                    type: "input",
+                    name: "manualKey",
+                    message: "Enter the new variable name:",
+                    validate: (input) => input?.trim().length > 0 ? true : "Name cannot be empty.",
+                },
+            ]);
+            if (!manualKeyAnswer)
+                return;
+            keyToAdd = manualKeyAnswer.manualKey;
+        }
+        await configureEnvVar(keyToAdd, envVars);
+    }
+    else if (action === "edit") {
+        if (keys.length === 0) {
+            writeInfo("\nℹ️ No variables configured yet. Please add one first.\n");
+            return;
+        }
+        const keyAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "key",
+                message: "Which variable do you want to edit?",
+                choices: [
+                    ...keys,
+                    new inquirer.Separator(),
+                    { name: "Back", value: "back" },
+                ],
+            },
+        ]);
+        if (!keyAnswer || keyAnswer.key === "back")
+            return;
+        await configureEnvVar(keyAnswer.key, envVars);
+    }
+    else if (action === "delete") {
+        if (keys.length === 0) {
+            writeInfo("\nℹ️ No variables configured yet.\n");
+            return;
+        }
+        const keyAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "key",
+                message: "Which variable do you want to delete?",
+                choices: [
+                    ...keys,
+                    new inquirer.Separator(),
+                    { name: "Back", value: "back" },
+                ],
+            },
+        ]);
+        if (!keyAnswer || keyAnswer.key === "back")
+            return;
+        delete envVars[keyAnswer.key];
+        writeSuccess(`\n✅ Variable "${keyAnswer.key}" has been removed.\n`);
+    }
+}
+async function configureEnvVar(varName, envVars) {
+    const existing = envVars[varName] || {};
+    const metadata = await safePrompt([
+        {
+            type: "input",
+            name: "description",
+            message: `Description for ${varName}:`,
+            default: existing.description,
+            validate: (input) => input?.trim().length > 0 ? true : "Description cannot be empty.",
+        },
+        {
+            type: "confirm",
+            name: "required",
+            message: "Is this variable required?",
+            default: existing.required !== undefined ? existing.required : true,
+        },
+        {
+            type: "input",
+            name: "example",
+            message: "Example value (optional):",
+            default: existing.example,
+        },
+    ]);
+    if (!metadata)
+        return;
+    envVars[varName] = {
+        description: metadata.description,
+        required: metadata.required,
+        example: metadata.example || undefined,
+    };
+    writeSuccess(`\n✅ Configured ${varName}.\n`);
+}
+async function handleInstallerActions(marketplaceApi, config, apiKey) {
+    let back = false;
+    while (!back) {
+        const installerAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "action",
+                message: "Installer Menu:",
+                choices: [
+                    { name: "Browse & Search for skills", value: "search" },
+                    { name: "Install a skill from the Marketplace", value: "install" },
+                    { name: "Update an installed skill", value: "update" },
+                    { name: "Uninstall a skill", value: "uninstall" },
+                    { name: "List my currently installed skills", value: "installed" },
+                    { name: "Back", value: "back" },
+                ],
+            },
+        ]);
+        if (!installerAnswer || installerAnswer.action === "back") {
+            back = true;
+            continue;
+        }
+        switch (installerAnswer.action) {
+            case "search":
+                await searchMarketplaceSkills(marketplaceApi);
+                continue;
+            case "install":
+                await installMarketplaceSkill(marketplaceApi, config, apiKey);
+                continue;
+            case "update":
+                await updateInstalledSkill(marketplaceApi, config, apiKey);
+                continue;
+            case "uninstall":
+                await uninstallMarketplaceSkill(marketplaceApi, config);
+                continue;
+            case "installed":
+                await listInstalledSkills(marketplaceApi, config);
+                continue;
+            // Other cases will be added here
+            default:
+                console.log(`\nAction '${installerAnswer.action}' is not implemented yet.\n`);
+                await safePrompt([
+                    {
+                        type: "input",
+                        name: "continue",
+                        message: "Press Enter to continue...",
+                    },
+                ]);
+                continue;
+        }
+    }
+}
+/**
+ * Browse and select a skill from marketplace (with optional search)
+ * Returns the selected skill or null if cancelled
+ */
+async function browseAndSelectSkill(marketplaceApi, purpose, publishedVersionsOnly) {
+    try {
+        // 1. Prompt for search query (optional)
+        const searchAnswer = await safePrompt([
+            {
+                type: "input",
+                name: "query",
+                message: "Search for skills (leave empty to browse all):",
+            },
+        ]);
+        if (searchAnswer === null)
+            return null; // User cancelled
+        const searchQuery = searchAnswer?.query?.trim() || "";
+        // 2. Search/browse marketplace skills
+        writeProgress(searchQuery
+            ? `\n🔍 Searching for "${searchQuery}"...`
+            : "\n🔍 Loading marketplace skills...");
+        const filters = {};
+        if (searchQuery)
+            filters.search = searchQuery;
+        if (publishedVersionsOnly !== undefined)
+            filters.publishedVersionsOnly = publishedVersionsOnly;
+        const searchResults = await marketplaceApi.searchSkills(Object.keys(filters).length > 0 ? filters : undefined);
+        const skills = searchResults || [];
+        if (skills.length === 0) {
+            if (searchQuery) {
+                writeInfo(`\n📦 No skills found matching "${searchQuery}".`);
+            }
+            else {
+                writeInfo("\n📦 No skills available on the marketplace yet.");
+            }
+            writeInfo("💡 Be the first to publish a skill!\n");
+            return null;
+        }
+        // 3. Display results
+        console.log(`\n📊 Found ${skills.length} skill${skills.length === 1 ? "" : "s"}:\n`);
+        // 4. Prompt user to select a skill
+        const message = purpose || "Select a skill (or press ESC to go back):";
+        const skillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "skill",
+                message,
+                choices: [
+                    ...skills.map((s) => ({
+                        name: `${s.displayName} - ${s.description || "No description"}`,
+                        value: s,
+                    })),
+                    new inquirer.Separator(),
+                    { name: "← Back to menu", value: null },
+                ],
+            },
+        ]);
+        if (!skillAnswer || !skillAnswer.skill)
+            return null;
+        return skillAnswer.skill;
+    }
+    catch (error) {
+        console.error(`\n❌ Error browsing marketplace: ${error.message}\n`);
+        return null;
+    }
+}
+/**
+ * Browse and search for marketplace skills (view details)
+ */
+async function searchMarketplaceSkills(marketplaceApi) {
+    const selectedSkill = await browseAndSelectSkill(marketplaceApi, "Select a skill to view details:");
+    if (selectedSkill) {
+        await showSkillDetails(marketplaceApi, selectedSkill);
+    }
+}
+/**
+ * Show detailed information about a marketplace skill
+ */
+async function showSkillDetails(marketplaceApi, skill) {
+    try {
+        // Fetch full details
+        writeProgress("\n🔄 Loading skill details...\n");
+        const skillDetails = await marketplaceApi.getSkillById(skill.id);
+        // Display detailed information
+        console.log(`\n${"=".repeat(60)}`);
+        console.log(`📦 ${skillDetails.displayName}`);
+        console.log(`${"=".repeat(60)}\n`);
+        console.log(`Name: ${skillDetails.name}`);
+        console.log(`Created: ${new Date(skillDetails.createdAt).toLocaleDateString()}`);
+        console.log(`Last Updated: ${new Date(skillDetails.updatedAt).toLocaleDateString()}`);
+        if (skillDetails.description) {
+            console.log(`\nDescription: ${skillDetails.description}`);
+        }
+        if (skillDetails.longDescription) {
+            console.log(`\nDetails:\n${skillDetails.longDescription}`);
+        }
+        if (skillDetails.category) {
+            console.log(`\nCategory: ${skillDetails.category}`);
+        }
+        if (skillDetails.tags && skillDetails.tags.length > 0) {
+            console.log(`Tags: ${skillDetails.tags.join(", ")}`);
+        }
+        // Show install count
+        if (typeof skillDetails.installCount !== "undefined") {
+            console.log(`Installs: ${skillDetails.installCount}`);
+        }
+        // Show verified/featured badges
+        if (skillDetails.verified) {
+            console.log(`✅ Verified`);
+        }
+        if (skillDetails.featured) {
+            console.log(`⭐ Featured`);
+        }
+        // Show versions
+        if (skillDetails.versions && skillDetails.versions.length > 0) {
+            const publishedVersions = skillDetails.versions.filter((v) => v.published);
+            console.log(`\nVersions: ${publishedVersions.length} published / ${skillDetails.versions.length} total`);
+            if (publishedVersions.length > 0) {
+                const latestVersion = publishedVersions.sort((a, b) => compareVersions(b.version, a.version))[0];
+                console.log(`Latest: v${latestVersion.version}`);
+                if (latestVersion.tools && latestVersion.tools.length > 0) {
+                    console.log(`\nTools (v${latestVersion.version}):`);
+                    latestVersion.tools.forEach((tool) => {
+                        console.log(`  • ${tool.name || tool.functionName || "Unnamed Tool"}`);
+                        if (tool.description)
+                            console.log(`    ${tool.description}`);
+                    });
+                }
+            }
+        }
+        // Show environment variables from latest version
+        const latestVersion = skillDetails.versions && skillDetails.versions.length > 0
+            ? skillDetails.versions.sort((a, b) => compareVersions(b.version, a.version))[0]
+            : null;
+        if (latestVersion &&
+            latestVersion.envVarsMetadata &&
+            Object.keys(latestVersion.envVarsMetadata).length > 0) {
+            console.log(`\nEnvironment Variables (v${latestVersion.version}):`);
+            for (const [key, meta] of Object.entries(latestVersion.envVarsMetadata)) {
+                const varMeta = meta;
+                const required = varMeta.required ? " (required)" : " (optional)";
+                console.log(`  • ${key}${required}`);
+                if (varMeta.description) {
+                    console.log(`    ${varMeta.description}`);
+                }
+            }
+        }
+        // Show repository and documentation links
+        if (skillDetails.repositoryUrl) {
+            console.log(`\nRepository: ${skillDetails.repositoryUrl}`);
+        }
+        if (skillDetails.documentationUrl) {
+            console.log(`Documentation: ${skillDetails.documentationUrl}`);
+        }
+        console.log(`\n${"=".repeat(60)}\n`);
+        // Prompt to continue
+        await safePrompt([
+            {
+                type: "input",
+                name: "continue",
+                message: "Press Enter to continue...",
+            },
+        ]);
+    }
+    catch (error) {
+        console.error(`\n❌ Error loading skill details: ${error.message}\n`);
+    }
+}
+/**
+ * Install a marketplace skill on the agent
+ */
+async function installMarketplaceSkill(marketplaceApi, config, apiKey) {
+    try {
+        const agentId = config.agent?.agentId;
+        if (!agentId) {
+            console.error("\n❌ No agent ID found in configuration.\n");
+            return;
+        }
+        // 1. Choose how to select the skill
+        const selectionMethodAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "method",
+                message: "How would you like to find the skill?",
+                choices: [
+                    { name: "Browse and select from marketplace", value: "browse" },
+                    { name: "Enter skill name and creator ID directly", value: "direct" },
+                    { name: "Cancel", value: "cancel" },
+                ],
+            },
+        ]);
+        if (!selectionMethodAnswer || selectionMethodAnswer.method === "cancel") {
+            return;
+        }
+        let selectedMarketplaceSkill = null;
+        if (selectionMethodAnswer.method === "browse") {
+            // Browse and select - only show skills with published versions
+            selectedMarketplaceSkill = await browseAndSelectSkill(marketplaceApi, undefined, true);
+            if (!selectedMarketplaceSkill)
+                return; // User cancelled or no skills found
+        }
+        else {
+            // Direct entry
+            const directAnswer = await safePrompt([
+                {
+                    type: "input",
+                    name: "name",
+                    message: "Enter the skill name:",
+                    validate: (input) => input.trim().length > 0 ? true : "Skill name is required",
+                },
+                {
+                    type: "input",
+                    name: "creatorId",
+                    message: "Enter the creator ID:",
+                    validate: (input) => input.trim().length > 0 ? true : "Creator ID is required",
+                },
+            ]);
+            if (!directAnswer)
+                return;
+            // Search for the skill by exact name and creator using API filters
+            writeProgress("\n🔍 Looking up skill...");
+            const searchResults = await marketplaceApi.searchSkills({
+                name: directAnswer.name,
+                creatorId: directAnswer.creatorId,
+                publishedVersionsOnly: true,
+            });
+            const skills = searchResults || [];
+            if (skills.length === 0) {
+                console.error(`\n❌ Skill "${directAnswer.name}" by creator "${directAnswer.creatorId}" not found on the marketplace.\n`);
+                return;
+            }
+            // Should only have one result with exact name + creatorId match
+            selectedMarketplaceSkill = skills[0];
+        }
+        // Check if the skill is already installed on this agent (as a marketplace skill)
+        try {
+            const installedSkills = await marketplaceApi.getInstalledSkills(agentId);
+            const alreadyInstalled = installedSkills?.find((s) => s.marketplaceSkillId === selectedMarketplaceSkill.id);
+            if (alreadyInstalled) {
+                console.error(`\n❌ The skill "${selectedMarketplaceSkill.displayName}" is already installed on this agent.`);
+                writeInfo("💡 Use 'Update an installed skill' to change versions or configuration.\n");
+                return;
+            }
+        }
+        catch (e) {
+            // Silent catch - if we can't check, let the backend handle the error later
+        }
+        try {
+            const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+            const agentSkillsResponse = await skillApi.getSkills();
+            if (agentSkillsResponse.success && agentSkillsResponse.data?.skills) {
+                const agentSkills = agentSkillsResponse.data.skills;
+                const existingSourceSkill = agentSkills.find((s) => s.id === selectedMarketplaceSkill.sourceSkillId);
+                if (existingSourceSkill) {
+                    console.error(`\n❌ You cannot install "${selectedMarketplaceSkill.displayName}" because the source skill already exists on this agent.`);
+                    writeInfo("💡 You already have the original skill on this agent.\n");
+                    return;
+                }
+            }
+        }
+        catch (e) {
+            // Silent catch
+        }
+        // 2. Fetch full skill details including versions
+        writeProgress(`\n🔄 Loading details for ${selectedMarketplaceSkill.displayName}...`);
+        const skillDetails = await marketplaceApi.getSkillById(selectedMarketplaceSkill.id);
+        // 3. Get published versions
+        const versions = await marketplaceApi.getSkillVersions(selectedMarketplaceSkill.id);
+        const publishedVersions = (versions || []).filter((v) => v.published);
+        if (publishedVersions.length === 0) {
+            writeInfo(`\n❌ No published versions available for "${skillDetails.displayName}".`);
+            writeInfo("💡 Please contact the skill creator to publish a version.\n");
+            return;
+        }
+        // 4. Select version to install
+        const versionAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "version",
+                message: "Select a version to install:",
+                choices: publishedVersions
+                    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+                    .map((v) => ({
+                    name: `v${v.version} - ${new Date(v.createdAt).toLocaleDateString()}${v.changelog ? ` - ${v.changelog}` : ""}`,
+                    value: v,
+                })),
+            },
+        ]);
+        if (!versionAnswer)
+            return;
+        const selectedVersion = versionAnswer.version;
+        // 5. Configure environment variables
+        const envVarsConfig = {};
+        const versionEnvVars = selectedVersion.envVarsMetadata || {};
+        if (Object.keys(versionEnvVars).length > 0) {
+            writeInfo("\n📝 Configure environment variables:\n");
+            for (const [key, meta] of Object.entries(versionEnvVars)) {
+                const varMeta = meta;
+                const isRequired = varMeta.required;
+                const description = varMeta.description || "No description";
+                const example = varMeta.example ? ` (e.g., ${varMeta.example})` : "";
+                console.log(`\n${key}${isRequired ? " (required)" : " (optional)"}`);
+                console.log(`  ${description}${example}`);
+                const valueAnswer = await safePrompt([
+                    {
+                        type: "input",
+                        name: "value",
+                        message: `Enter value for ${key}:`,
+                        validate: (input) => {
+                            if (isRequired && !input.trim()) {
+                                return `${key} is required`;
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                if (valueAnswer === null) {
+                    writeInfo("\n❌ Installation cancelled.\n");
+                    return;
+                }
+                if (valueAnswer.value && valueAnswer.value.trim()) {
+                    envVarsConfig[key] = valueAnswer.value.trim();
+                }
+            }
+        }
+        // 6. Confirm installation
+        console.log("\n📋 Installation Summary:");
+        console.log(`  Skill: ${skillDetails.displayName}`);
+        console.log(`  Version: v${selectedVersion.version}`);
+        console.log(`  Agent: ${agentId}`);
+        if (Object.keys(envVarsConfig).length > 0) {
+            console.log(`  Environment Variables: ${Object.keys(envVarsConfig).length} configured`);
+        }
+        const confirmAnswer = await safePrompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Proceed with installation?",
+                default: true,
+            },
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            writeInfo("\n❌ Installation cancelled.\n");
+            return;
+        }
+        // 7. Install the skill
+        writeProgress("\n🔄 Installing skill...");
+        const installPayload = {
+            versionId: selectedVersion.id,
+            envVars: Object.keys(envVarsConfig).length > 0 ? envVarsConfig : undefined,
+        };
+        await marketplaceApi.installSkill(selectedMarketplaceSkill.id, agentId, installPayload);
+        writeSuccess(`\n✅ "${skillDetails.displayName}" v${selectedVersion.version} has been installed successfully!`);
+        writeInfo(`💡 The skill is now available on agent ${agentId}.\n`);
+    }
+    catch (error) {
+        console.error(`\n❌ Error installing skill: ${error.message}\n`);
+    }
+}
+/**
+ * Update an installed marketplace skill (version and/or env vars)
+ */
+async function updateInstalledSkill(marketplaceApi, config, apiKey) {
+    try {
+        const agentId = config.agent?.agentId;
+        if (!agentId) {
+            console.error("\n❌ No agent ID found in configuration.\n");
+            return;
+        }
+        // 1. Fetch installed skills
+        writeProgress(`\n🔄 Loading installed marketplace skills...`);
+        const installedSkills = await marketplaceApi.getInstalledSkills(agentId);
+        if (!installedSkills || installedSkills.length === 0) {
+            writeInfo("\n📦 No marketplace skills installed on this agent yet.");
+            writeInfo("💡 Use 'Install a skill' to get started.\n");
+            return;
+        }
+        // 2. Select which installed skill to update
+        const skillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "skill",
+                message: "Which installed skill would you like to update?",
+                choices: installedSkills.map((s) => ({
+                    name: `${s.title || s.name} (currently v${s.activeVersionId || "unknown"})`,
+                    value: s,
+                })),
+            },
+        ]);
+        if (!skillAnswer)
+            return;
+        const installedSkill = skillAnswer.skill;
+        // 3. Choose what to update
+        const updateChoiceAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "choice",
+                message: "What would you like to update?",
+                choices: [
+                    { name: "Upgrade to a different version", value: "version" },
+                    { name: "Update environment variables", value: "envVars" },
+                    {
+                        name: "Update both version and environment variables",
+                        value: "both",
+                    },
+                    { name: "Cancel", value: "cancel" },
+                ],
+            },
+        ]);
+        if (!updateChoiceAnswer || updateChoiceAnswer.choice === "cancel") {
+            return;
+        }
+        const updateChoice = updateChoiceAnswer.choice;
+        let newVersionId = undefined;
+        let newEnvVars = undefined;
+        // 4. Handle version update
+        if (updateChoice === "version" || updateChoice === "both") {
+            // Fetch skill details to get available versions
+            writeProgress(`\n🔄 Loading available versions...`);
+            const marketplaceSkillId = installedSkill.marketplaceSkillId;
+            if (!marketplaceSkillId) {
+                console.error("\n❌ Skill is missing marketplace skill ID.\n");
+                return;
+            }
+            const versions = await marketplaceApi.getSkillVersions(marketplaceSkillId);
+            const publishedVersions = (versions || []).filter((v) => v.published);
+            if (publishedVersions.length === 0) {
+                writeInfo("\n❌ No published versions available for this skill.\n");
+                return;
+            }
+            const versionAnswer = await safePrompt([
+                {
+                    type: "list",
+                    name: "version",
+                    message: "Select a version to upgrade to:",
+                    choices: publishedVersions
+                        .sort((a, b) => compareVersions(b.version, a.version))
+                        .map((v) => ({
+                        name: `v${v.version}${v.id ===
+                            installedSkill.marketplaceInstallMetadata?.installedVersionId
+                            ? " (current)"
+                            : ""} - ${new Date(v.createdAt).toLocaleDateString()}${v.changelog ? ` - ${v.changelog}` : ""}`,
+                        value: v,
+                    })),
+                },
+            ]);
+            if (!versionAnswer)
+                return;
+            newVersionId = versionAnswer.version.id;
+        }
+        // 5. Handle environment variables update
+        if (updateChoice === "envVars" || updateChoice === "both") {
+            // Fetch current agent environment variables
+            let currentAgentEnvVars = {};
+            try {
+                const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
+                const response = await developerApi.getEnvironmentVariables();
+                if (response.success && response.data?.data) {
+                    currentAgentEnvVars = response.data.data;
+                }
+            }
+            catch (e) {
+                // Silent fail, just don't show current values
+            }
+            const marketplaceSkillId = installedSkill.marketplaceSkillId;
+            if (!marketplaceSkillId) {
+                console.error("\n❌ Skill is missing marketplace skill ID.\n");
+                return;
+            }
+            const skillDetails = await marketplaceApi.getSkillById(marketplaceSkillId);
+            // Determine which version's env vars to use
+            let targetVersion;
+            if (newVersionId) {
+                // Use the new version selected
+                targetVersion = skillDetails.versions?.find((v) => v.id === newVersionId);
+            }
+            else if (installedSkill.marketplaceInstallMetadata?.installedVersionId) {
+                // Use the currently installed version
+                targetVersion = skillDetails.versions?.find((v) => v.id ===
+                    installedSkill.marketplaceInstallMetadata.installedVersionId);
+            }
+            // Fallback to latest version if not found (shouldn't happen usually)
+            if (!targetVersion &&
+                skillDetails.versions &&
+                skillDetails.versions.length > 0) {
+                targetVersion = skillDetails.versions.sort((a, b) => compareVersions(b.version, a.version))[0];
+            }
+            const envVarsMetadata = targetVersion?.envVarsMetadata || {};
+            if (Object.keys(envVarsMetadata).length === 0) {
+                writeInfo("\n📝 This version has no environment variables to configure.\n");
+                if (updateChoice === "envVars") {
+                    return; // Nothing to update
+                }
+            }
+            else {
+                writeInfo("\n📝 Update environment variables:\n");
+                const updatedEnvVars = {};
+                for (const [key, meta] of Object.entries(envVarsMetadata)) {
+                    const varMeta = meta;
+                    const isRequired = varMeta.required;
+                    const description = varMeta.description || "No description";
+                    const example = varMeta.example ? ` (e.g., ${varMeta.example})` : "";
+                    const currentValue = currentAgentEnvVars[key] || "";
+                    console.log(`\n${key}${isRequired ? " (required)" : " (optional)"}`);
+                    console.log(`  ${description}${example}`);
+                    if (currentValue) {
+                        const maskedValue = currentValue.length > 4
+                            ? currentValue.substring(0, 4) +
+                                "*".repeat(Math.min(currentValue.length - 4, 20))
+                            : "*".repeat(currentValue.length);
+                        console.log(`  Current value: ${maskedValue}`);
+                    }
+                    const valueAnswer = await safePrompt([
+                        {
+                            type: "input",
+                            name: "value",
+                            message: `Enter new value for ${key} (leave empty to keep current):`,
+                            default: currentValue,
+                            validate: (input) => {
+                                if (isRequired && !input.trim() && !currentValue) {
+                                    return `${key} is required`;
+                                }
+                                return true;
+                            },
+                        },
+                    ]);
+                    if (valueAnswer === null) {
+                        writeInfo("\n❌ Update cancelled.\n");
+                        return;
+                    }
+                    if (valueAnswer.value &&
+                        valueAnswer.value.trim() &&
+                        valueAnswer.value !== currentValue) {
+                        updatedEnvVars[key] = valueAnswer.value.trim();
+                    }
+                }
+                newEnvVars = updatedEnvVars;
+            }
+        }
+        // 6. Confirm update
+        console.log("\n📋 Update Summary:");
+        console.log(`  Skill: ${installedSkill.title || installedSkill.name}`);
+        console.log(`  Agent: ${agentId}`);
+        if (newVersionId) {
+            console.log(`  New version will be applied`);
+        }
+        if (newEnvVars && Object.keys(newEnvVars).length > 0) {
+            console.log(`  Environment variables: ${Object.keys(newEnvVars).length} to update`);
+        }
+        const confirmAnswer = await safePrompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Proceed with update?",
+                default: true,
+            },
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            writeInfo("\n❌ Update cancelled.\n");
+            return;
+        }
+        // 7. Update the skill
+        writeProgress("\n🔄 Updating installed skill...");
+        const updatePayload = {};
+        if (newVersionId) {
+            updatePayload.versionId = newVersionId;
+        }
+        if (newEnvVars) {
+            updatePayload.envVars = newEnvVars;
+        }
+        if (!installedSkill.marketplaceSkillId) {
+            console.error("\n❌ Skill is missing marketplace skill ID.\n");
+            return;
+        }
+        await marketplaceApi.updateInstallation(installedSkill.marketplaceSkillId, agentId, updatePayload);
+        writeSuccess(`\n✅ "${installedSkill.title || installedSkill.name}" has been updated successfully!`);
+        writeInfo(`💡 The changes are now active on agent ${agentId}.\n`);
+    }
+    catch (error) {
+        console.error(`\n❌ Error updating installed skill: ${error.message}\n`);
+    }
+}
+/**
+ * Uninstall a marketplace skill from the agent
+ */
+async function uninstallMarketplaceSkill(marketplaceApi, config) {
+    try {
+        const agentId = config.agent?.agentId;
+        if (!agentId) {
+            console.error("\n❌ No agent ID found in configuration.\n");
+            return;
+        }
+        // 1. Fetch installed skills
+        writeProgress(`\n🔄 Loading installed marketplace skills...`);
+        const installedSkills = await marketplaceApi.getInstalledSkills(agentId);
+        if (!installedSkills || installedSkills.length === 0) {
+            writeInfo("\n📦 No marketplace skills installed on this agent yet.");
+            writeInfo("💡 Use 'Install a skill' to get started.\n");
+            return;
+        }
+        // 2. Select which installed skill to uninstall
+        const skillAnswer = await safePrompt([
+            {
+                type: "list",
+                name: "skill",
+                message: "Which skill would you like to uninstall?",
+                choices: installedSkills.map((s) => ({
+                    name: `${s.title || s.name} (v${s.activeVersionId || "unknown"})`,
+                    value: s,
+                })),
+            },
+        ]);
+        if (!skillAnswer)
+            return;
+        const installedSkill = skillAnswer.skill;
+        // 3. Confirm uninstallation
+        const confirmAnswer = await safePrompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: `⚠️  Are you sure you want to uninstall "${installedSkill.title || installedSkill.name}"?`,
+                default: false,
+            },
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            writeInfo("\n❌ Uninstall cancelled.\n");
+            return;
+        }
+        if (!installedSkill.marketplaceSkillId) {
+            console.error("\n❌ Skill is missing marketplace skill ID.\n");
+            return;
+        }
+        // 4. Uninstall the skill
+        writeProgress("\n🔄 Uninstalling skill...");
+        await marketplaceApi.uninstallSkill(installedSkill.marketplaceSkillId, agentId);
+        writeSuccess(`\n✅ "${installedSkill.title || installedSkill.name}" has been uninstalled successfully!`);
+        writeInfo(`💡 The skill has been removed from agent ${agentId}.\n`);
+    }
+    catch (error) {
+        console.error(`\n❌ Error uninstalling skill: ${error.message}\n`);
+    }
+}
+/**
+ * List all installed marketplace skills on the agent
+ */
+async function listInstalledSkills(marketplaceApi, config) {
+    try {
+        const agentId = config.agent?.agentId;
+        if (!agentId) {
+            console.error("\n❌ No agent ID found in configuration.\n");
+            return;
+        }
+        writeProgress("\n🔄 Loading installed marketplace skills...\n");
+        const installedSkills = await marketplaceApi.getInstalledSkills(agentId);
+        if (!installedSkills || installedSkills.length === 0) {
+            writeInfo("\n📦 No marketplace skills installed on this agent yet.");
+            writeInfo("💡 Use 'Install a skill' to browse and install skills.\n");
+            return;
+        }
+        // Display summary
+        console.log(`\n📊 You have ${installedSkills.length} marketplace skill${installedSkills.length === 1 ? "" : "s"} installed:\n`);
+        // Display each installed skill
+        for (const skill of installedSkills) {
+            console.log(`📦 ${skill.title || skill.name}`);
+            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}`);
+            }
+            if (skill.marketplaceInstallMetadata?.installedAt) {
+                console.log(`   Installed: ${new Date(skill.marketplaceInstallMetadata.installedAt).toLocaleDateString()}`);
+            }
+            if (skill.marketplaceInstallMetadata?.installedBy) {
+                console.log(`   Installed By: ${skill.marketplaceInstallMetadata.installedBy}`);
+            }
+            console.log(""); // Empty line between skills
+        }
+        // Prompt to continue
+        await safePrompt([
+            {
+                type: "input",
+                name: "continue",
+                message: "Press Enter to continue...",
+            },
+        ]);
+    }
+    catch (error) {
+        console.error(`\n❌ Error loading installed skills: ${error.message}\n`);
+    }
+}