lua-cli 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/common/user.instance.js

@@ -142,7 +142,7 @@ export default class UserDataInstance {
     async update(data) {
         try {
             const response = await this.userAPI.update(data);
-            this.data = response.data;
+            this.data = response;
             return this.data;
         }
         catch (error) {

package/dist/config/constants.d.ts

@@ -5,7 +5,7 @@
  * Base URLs for the API, Auth, and Chat - Development
  */
 export declare const BASE_URLS: {
-    readonly API: "https://api.heylua.ai";
+    readonly API: "http://localhost:3001";
     readonly AUTH: "https://auth.heylua.ai";
     readonly CHAT: "https://api.heylua.ai";
     readonly WEBHOOK: "https://webhook.heylua.ai";

package/dist/config/constants.js

@@ -11,7 +11,11 @@
  * Base URLs for the API, Auth, and Chat - Development
  */
 export const BASE_URLS = {
-    API: 'https://api.heylua.ai',
+    // API: 'https://api.heylua.ai',
+    // AUTH: 'https://auth.heylua.ai',
+    // CHAT: 'https://api.heylua.ai',
+    // WEBHOOK: 'https://webhook.heylua.ai',
+    API: 'http://localhost:3001',
     AUTH: 'https://auth.heylua.ai',
     CHAT: 'https://api.heylua.ai',
     WEBHOOK: 'https://webhook.heylua.ai',

package/dist/index.js

@@ -9,7 +9,7 @@
  * For more information: https://docs.heylua.ai
  */
 import { Command } from "commander";
-import { setupAuthCommands, setupSkillCommands } from "./cli/command-definitions.js";
+import { setupAuthCommands, setupSkillCommands, setupMarketplaceCommands } from "./cli/command-definitions.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
@@ -63,12 +63,14 @@ Examples:
   $ lua admin              🔧 Open admin dashboard
   $ lua docs               📖 Open documentation
   $ lua completion         🎯 Enable shell autocomplete
-
-🌙 Documentation: https://docs.heylua.ai
-🌙 Support: https://heylua.ai/support
+  $ lua marketplace        🛍️  Interact with the Lua Marketplace
+ 
+ 🌙 Documentation: https://docs.heylua.ai
+ 🌙 Support: https://heylua.ai/support
 `);
 // Set up all command groups
 setupAuthCommands(program);
 setupSkillCommands(program);
+setupMarketplaceCommands(program);
 // Parse command-line arguments
 program.parse(process.argv);

package/dist/interfaces/marketplace.d.ts

@@ -0,0 +1,99 @@
+export interface EnvVarMetadata {
+    description: string;
+    required: boolean;
+    example?: string;
+}
+/**
+ * Marketplace Skill Version Response
+ */
+export interface MarketplaceVersionResponse {
+    id: string;
+    marketplaceSkillId: string;
+    version: string;
+    description: string;
+    changelog?: string;
+    context?: any;
+    tools?: any;
+    envVarsMetadata?: Record<string, EnvVarMetadata>;
+    approvalStatus: string;
+    published: boolean;
+    approvalNotes?: string;
+    approvedBy?: string;
+    approvedAt?: Date | string;
+    createdBy: string;
+    createdAt: Date | string;
+}
+/**
+ * Complete Marketplace Skill Response with all details and versions
+ */
+export interface MarketplaceSkillWithVersionsResponse {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    longDescription?: string;
+    category?: string;
+    tags: string[];
+    creatorId: string;
+    sourceSkillId: string;
+    listed: boolean;
+    verified: boolean;
+    featured: boolean;
+    published: boolean;
+    installCount: number;
+    activeInstallCount: number;
+    iconUrl?: string;
+    screenshots?: string[];
+    repositoryUrl?: string;
+    documentationUrl?: string;
+    listedAt?: Date | string;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+    versions: MarketplaceVersionResponse[];
+    versionsCount: number;
+    pendingVersionsCount: number;
+    approvedVersionsCount: number;
+}
+/**
+ * Skill Response (including installed marketplace skills)
+ */
+export interface SkillResponse {
+    id: string;
+    name: string;
+    title: string;
+    description: string;
+    public: boolean;
+    agentId: string;
+    active: boolean;
+    activeVersionId?: string;
+    version?: any;
+    versionContext?: string;
+    installedFromMarketplace: boolean;
+    marketplaceSkillId?: string;
+    marketplaceInstallMetadata?: {
+        installedVersionId: string;
+        installedBy: string;
+        installedAt: Date | string;
+    };
+    createdBy: string;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+}
+/**
+ * Unpublish Version Response
+ */
+export interface UnpublishVersionResponse {
+    message: string;
+    success: boolean;
+    skillUnlisted: boolean;
+    versionId: string;
+}
+/**
+ * Unlist Skill Response
+ */
+export interface UnlistSkillResponse {
+    message: string;
+    success: boolean;
+    unlisted: boolean;
+    versionsUnpublished: number;
+}

package/dist/interfaces/marketplace.js

@@ -0,0 +1,2 @@
+// ==================== MARKETPLACE RESPONSE INTERFACES ====================
+export {};

package/dist/types/compile.types.d.ts

@@ -47,47 +47,54 @@ export interface JobMetadata {
 /**
  * Configuration from lua.skill.yaml
  */
-export interface SkillConfig {
-    skill?: {
-        name?: string;
-        version?: string;
-        skillId?: string;
-        description?: string;
-        context?: string;
-        env?: Record<string, string>;
-    };
-    agent?: {
-        agentId?: string;
-        orgId?: string;
-        persona?: string;
-        welcomeMessage?: string;
-    };
-    skills?: Array<{
-        name: string;
-        version: string;
-        skillId: string;
-    }>;
-    webhooks?: Array<{
-        name: string;
-        version: string;
-        webhookId: string;
-    }>;
-    jobs?: Array<{
-        name: string;
-        version: string;
-        jobId: string;
-        schedule?: any;
-    }>;
-    preprocessors?: Array<{
-        name: string;
-        version: string;
-        preprocessorId: string;
-    }>;
-    postprocessors?: Array<{
-        name: string;
-        version: string;
-        postprocessorId: string;
-    }>;
+export interface LegacyYamlConfigSkill {
+    name?: string;
+    version?: string;
+    skillId?: string;
+    description?: string;
+    context?: string;
+    env?: Record<string, string>;
+}
+export interface YamlConfigAgent {
+    agentId?: string;
+    orgId?: string;
+    persona?: string;
+    welcomeMessage?: string;
+}
+export interface YamlConfigSkill {
+    name: string;
+    version: string;
+    skillId: string;
+}
+export interface YamlConfigWebhook {
+    name: string;
+    version: string;
+    webhookId: string;
+}
+export interface YamlConfigJob {
+    name: string;
+    version: string;
+    jobId: string;
+    schedule?: any;
+}
+export interface YamlConfigPreprocessor {
+    name: string;
+    version: string;
+    preprocessorId: string;
+}
+export interface YamlConfigPostprocessor {
+    name: string;
+    version: string;
+    postprocessorId: string;
+}
+export interface YamlConfig {
+    skill?: LegacyYamlConfigSkill;
+    agent?: YamlConfigAgent;
+    skills?: YamlConfigSkill[];
+    webhooks?: YamlConfigWebhook[];
+    jobs?: YamlConfigJob[];
+    preprocessors?: YamlConfigPreprocessor[];
+    postprocessors?: YamlConfigPostprocessor[];
 }
 /**
  * Deployment data format for new deployment system

package/dist/types/compile.types.js

@@ -1,4 +1,5 @@
 /**
  * Type definitions for compile command
  */
+;
 export {};

package/dist/utils/env-loader.utils.d.ts

@@ -0,0 +1,9 @@
+import { EnvCommandContext, EnvVariable } from "../commands/env";
+/**
+ * Load environment variables based on context
+ */
+export declare function loadEnvironmentVariables(context: EnvCommandContext): Promise<EnvVariable[]>;
+/**
+ * Load sandbox environment variables from .env file
+ */
+export declare function loadSandboxEnvVariables(): EnvVariable[];

package/dist/utils/env-loader.utils.js

@@ -0,0 +1,88 @@
+import path from "path";
+import fs from "fs";
+/**
+ * Load environment variables based on context
+ */
+export async function loadEnvironmentVariables(context) {
+    if (context.environment === "sandbox") {
+        return loadSandboxEnvVariables();
+    }
+    else {
+        return loadProductionEnvVariables(context);
+    }
+}
+/**
+ * Load sandbox environment variables from .env file
+ */
+export function loadSandboxEnvVariables() {
+    const envFilePath = path.join(process.cwd(), ".env");
+    if (!fs.existsSync(envFilePath)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(envFilePath, "utf8");
+        return parseEnvContent(content);
+    }
+    catch (error) {
+        console.error("❌ Error reading .env file:", error);
+        return [];
+    }
+}
+/**
+ * Load production environment variables from API
+ */
+async function loadProductionEnvVariables(context) {
+    try {
+        if (!context.developerApi) {
+            throw new Error("Developer API not initialized");
+        }
+        const response = await context.developerApi.getEnvironmentVariables();
+        if (!response.success) {
+            throw new Error(response.error?.message || "Failed to load environment variables");
+        }
+        // The API returns environment variables nested in a 'data' property
+        // Response structure: { success: true, data: { data: { KEY: "value", ... }, _id: "...", ... } }
+        const envData = response.data?.data || response.data;
+        if (envData && typeof envData === "object") {
+            // Filter out metadata fields like _id, agentId, createdAt, updatedAt, __v
+            const metadataKeys = [
+                "_id",
+                "agentId",
+                "data",
+                "createdAt",
+                "updatedAt",
+                "__v",
+            ];
+            return Object.entries(envData)
+                .filter(([key]) => !metadataKeys.includes(key))
+                .map(([key, value]) => ({
+                key,
+                value: String(value),
+            }));
+        }
+        return [];
+    }
+    catch (error) {
+        console.error("❌ Error loading production env variables:", error);
+        return [];
+    }
+}
+/**
+ * Parse .env file content into variables
+ */
+function parseEnvContent(content) {
+    if (!content.trim())
+        return [];
+    return content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#"))
+        .map((line) => {
+        const [key, ...valueParts] = line.split("=");
+        return {
+            key: key?.trim() || "",
+            value: valueParts.join("=") || "",
+        };
+    })
+        .filter((item) => item.key);
+}

package/dist/utils/job-management.d.ts

@@ -2,7 +2,7 @@
  * Job Management Utilities
  * Handles job creation via API and YAML configuration management
  */
-import { SkillConfig } from '../types/compile.types.js';
+import { YamlConfig } from '../types/compile.types.js';
 /**
  * Ensures all detected jobs exist in the YAML config with valid job IDs.
  * If a job doesn't exist or has no ID, creates it via the API.
@@ -11,7 +11,7 @@ import { SkillConfig } from '../types/compile.types.js';
  * @param config - The skill configuration from lua.skill.yaml
  * @returns Updated jobs array with valid job IDs
  */
-export declare function ensureJobsExistInYaml(jobsArray: any[], config: SkillConfig): Promise<any[]>;
+export declare function ensureJobsExistInYaml(jobsArray: any[], config: YamlConfig): Promise<any[]>;
 /**
  * Syncs the server jobs with the YAML configuration.
  * Performs a two-way sync:
@@ -21,4 +21,4 @@ export declare function ensureJobsExistInYaml(jobsArray: any[], config: SkillCon
  * @param config - The skill configuration from lua.skill.yaml
  * @returns Array of messages about sync operations
  */
-export declare function syncServerJobsWithYaml(config: SkillConfig): Promise<string[]>;
+export declare function syncServerJobsWithYaml(config: YamlConfig): Promise<string[]>;

package/dist/utils/postprocessor-management.d.ts

@@ -1,9 +1,9 @@
 /**
  * PostProcessor Management Utilities
  */
-import { SkillConfig } from '../types/compile.types.js';
+import { YamlConfig } from '../types/compile.types.js';
 /**
  * Ensures all detected postprocessors exist in the YAML config with valid IDs.
  */
-export declare function ensurePostProcessorsExistInYaml(postprocessorsArray: any[], config: SkillConfig): Promise<any[]>;
-export declare function syncServerPostProcessorsWithYaml(config: SkillConfig): Promise<string[]>;
+export declare function ensurePostProcessorsExistInYaml(postprocessorsArray: any[], config: YamlConfig): Promise<any[]>;
+export declare function syncServerPostProcessorsWithYaml(config: YamlConfig): Promise<string[]>;

package/dist/utils/preprocessor-management.d.ts

@@ -1,9 +1,9 @@
 /**
  * PreProcessor Management Utilities
  */
-import { SkillConfig } from '../types/compile.types.js';
+import { YamlConfig } from '../types/compile.types.js';
 /**
  * Ensures all detected preprocessors exist in the YAML config with valid IDs.
  */
-export declare function ensurePreProcessorsExistInYaml(preprocessorsArray: any[], config: SkillConfig): Promise<any[]>;
-export declare function syncServerPreProcessorsWithYaml(config: SkillConfig): Promise<string[]>;
+export declare function ensurePreProcessorsExistInYaml(preprocessorsArray: any[], config: YamlConfig): Promise<any[]>;
+export declare function syncServerPreProcessorsWithYaml(config: YamlConfig): Promise<string[]>;

package/dist/utils/semver.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Semantic Versioning Utilities
+ */
+/**
+ * Parses a semantic version string into its components.
+ * Supports standard semver (X.Y.Z) and pre-release tags (X.Y.Z-tag).
+ *
+ * @param version The version string to parse
+ * @returns Object containing major, minor, patch, and preRelease components
+ */
+export declare function parseVersion(version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+    preRelease: string | null;
+};
+/**
+ * Compares two semantic version strings.
+ *
+ * @param version1 First version string
+ * @param version2 Second version string
+ * @returns number:
+ *  - negative if version1 < version2
+ *  - positive if version1 > version2
+ *  - 0 if version1 === version2
+ */
+export declare function compareVersions(version1: string, version2: string): number;

package/dist/utils/semver.js

@@ -0,0 +1,75 @@
+/**
+ * Semantic Versioning Utilities
+ */
+/**
+ * Parses a semantic version string into its components.
+ * Supports standard semver (X.Y.Z) and pre-release tags (X.Y.Z-tag).
+ *
+ * @param version The version string to parse
+ * @returns Object containing major, minor, patch, and preRelease components
+ */
+export function parseVersion(version) {
+    const [versionPart, preReleasePart] = version.split('-');
+    const [major, minor, patch] = versionPart.split('.').map(Number);
+    const preRelease = preReleasePart ? preReleasePart.split('+')[0] : null;
+    return {
+        major: isNaN(major) ? 0 : major,
+        minor: isNaN(minor) ? 0 : minor,
+        patch: isNaN(patch) ? 0 : patch,
+        preRelease
+    };
+}
+/**
+ * Compares two semantic version strings.
+ *
+ * @param version1 First version string
+ * @param version2 Second version string
+ * @returns number:
+ *  - negative if version1 < version2
+ *  - positive if version1 > version2
+ *  - 0 if version1 === version2
+ */
+export function compareVersions(version1, version2) {
+    const v1 = parseVersion(version1);
+    const v2 = parseVersion(version2);
+    // Compare major.minor.patch first
+    if (v1.major !== v2.major)
+        return v1.major - v2.major;
+    if (v1.minor !== v2.minor)
+        return v1.minor - v2.minor;
+    if (v1.patch !== v2.patch)
+        return v1.patch - v2.patch;
+    // If major.minor.patch are equal, compare pre-release identifiers
+    // A version without a pre-release tag is always greater than one with a tag
+    if (v1.preRelease && !v2.preRelease)
+        return -1; // pre-release is lower than release
+    if (!v1.preRelease && v2.preRelease)
+        return 1; // release is higher than pre-release
+    if (!v1.preRelease && !v2.preRelease)
+        return 0; // both are releases
+    // Both have pre-release identifiers, compare them
+    const preReleaseOrder = ['alpha', 'beta', 'rc', 'preview', 'dev'];
+    const getPreReleaseType = (preRelease) => {
+        // Extract the type part (e.g., "alpha" from "alpha.1")
+        const type = preRelease.toLowerCase().split('.')[0].replace(/[0-9]/g, '');
+        const index = preReleaseOrder.indexOf(type);
+        return index === -1 ? preReleaseOrder.length : index; // Unknown types go to end
+    };
+    const type1 = getPreReleaseType(v1.preRelease);
+    const type2 = getPreReleaseType(v2.preRelease);
+    if (type1 !== type2)
+        return type1 - type2;
+    // Same pre-release type, compare the full pre-release string lexicographically
+    // or try to compare numeric parts if they exist (e.g., alpha.1 vs alpha.2)
+    const getPreReleaseNum = (preRelease) => {
+        const parts = preRelease.split('.');
+        const num = parts.length > 1 ? parseInt(parts[parts.length - 1], 10) : -1;
+        return isNaN(num) ? -1 : num;
+    };
+    const num1 = getPreReleaseNum(v1.preRelease);
+    const num2 = getPreReleaseNum(v2.preRelease);
+    if (num1 !== -1 && num2 !== -1 && num1 !== num2) {
+        return num1 - num2;
+    }
+    return v1.preRelease.localeCompare(v2.preRelease);
+}

package/dist/utils/skill-management.d.ts

@@ -2,7 +2,7 @@
  * Skill Management Utilities
  * Handles skill creation via API and YAML configuration management
  */
-import { SkillConfig } from '../types/compile.types.js';
+import { YamlConfig } from '../types/compile.types.js';
 /**
  * Ensures all detected skills exist in the YAML config with valid skill IDs.
  * If a skill doesn't exist or has no ID, creates it via the API.
@@ -11,7 +11,7 @@ import { SkillConfig } from '../types/compile.types.js';
  * @param config - The skill configuration from lua.skill.yaml
  * @returns Updated skills array with valid skill IDs
  */
-export declare function ensureSkillsExistInYaml(skillsArray: any[], config: SkillConfig): Promise<any[]>;
+export declare function ensureSkillsExistInYaml(skillsArray: any[], config: YamlConfig): Promise<any[]>;
 /**
  * Updates the YAML file with skills from the deploy.json file.
  * This ensures the YAML reflects what's actually in the compiled code.
@@ -21,7 +21,7 @@ export declare function ensureSkillsExistInYaml(skillsArray: any[], config: Skil
  * @param deployJsonPath - Path to the deploy.json file
  * @param config - Current skill configuration
  */
-export declare function syncYamlWithDeployJson(deployJsonPath: string, config: SkillConfig): Promise<void>;
+export declare function syncYamlWithDeployJson(deployJsonPath: string, config: YamlConfig): Promise<void>;
 /**
  * Syncs the server skills with the YAML configuration.
  * Performs a two-way sync:
@@ -31,4 +31,4 @@ export declare function syncYamlWithDeployJson(deployJsonPath: string, config: S
  * @param config - The skill configuration from lua.skill.yaml
  * @returns Array of messages about sync operations
  */
-export declare function syncServerSkillsWithYaml(config: SkillConfig): Promise<string[]>;
+export declare function syncServerSkillsWithYaml(config: YamlConfig): Promise<string[]>;

package/dist/utils/webhook-management.d.ts

@@ -2,7 +2,7 @@
  * Webhook Management Utilities
  * Handles webhook creation via API and YAML configuration management
  */
-import { SkillConfig } from '../types/compile.types.js';
+import { YamlConfig } from '../types/compile.types.js';
 /**
  * Ensures all detected webhooks exist in the YAML config with valid webhook IDs.
  * If a webhook doesn't exist or has no ID, creates it via the API.
@@ -11,7 +11,7 @@ import { SkillConfig } from '../types/compile.types.js';
  * @param config - The skill configuration from lua.skill.yaml
  * @returns Updated webhooks array with valid webhook IDs
  */
-export declare function ensureWebhooksExistInYaml(webhooksArray: any[], config: SkillConfig): Promise<any[]>;
+export declare function ensureWebhooksExistInYaml(webhooksArray: any[], config: YamlConfig): Promise<any[]>;
 /**
  * Syncs the server webhooks with the YAML configuration.
  * Performs a two-way sync:
@@ -21,4 +21,4 @@ export declare function ensureWebhooksExistInYaml(webhooksArray: any[], config:
  * @param config - The skill configuration from lua.skill.yaml
  * @returns Array of messages about sync operations
  */
-export declare function syncServerWebhooksWithYaml(config: SkillConfig): Promise<string[]>;
+export declare function syncServerWebhooksWithYaml(config: YamlConfig): Promise<string[]>;