lua-cli 3.0.3 → 3.1.0-alpha.2

package/dist/commands/persona.js

@@ -388,9 +388,11 @@ async function listPersonaVersions(context) {
                 choices: sortedVersions.map((version, index) => {
                     const date = new Date(version.createdDate);
                     const dateStr = date.toLocaleDateString();
-                    const deployedMark = version.isCurrent ? ' ⭐ CURRENT' : '';
+                    const timeStr = date.toLocaleTimeString();
+                    const status = version.status === 'draft' ? '[DRAFT]' : '';
+                    const currentMark = version.isCurrent ? ' ⭐ CURRENT' : '';
                     return {
-                        name: `Version ${version.version} (${dateStr})${deployedMark}`,
+                        name: `Version ${version.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
                         value: index
                     };
                 })
@@ -415,7 +417,9 @@ async function viewVersionDetails(versions) {
     console.log(`Persona Version ${version.version}`);
     console.log("=".repeat(60));
     console.log(`Created: ${date.toLocaleString()}`);
-    console.log(`Status: ${version.isCurrent ? '⭐ CURRENT' : 'Available'}`);
+    const versionStatus = version.status === 'draft' ? '🔨 DRAFT' : '';
+    console.log(`Version Status: ${versionStatus}`);
+    console.log(`Active Status: ${version.isCurrent ? '⭐ CURRENT' : 'Available'}`);
     if (version.createdBy) {
         console.log(`Created by: ${version.createdBy}`);
     }
@@ -480,8 +484,9 @@ async function deployPersonaVersion(context) {
                     const dateStr = date.toLocaleDateString();
                     const timeStr = date.toLocaleTimeString();
                     const currentMark = v.isCurrent ? ' ⭐ CURRENTLY DEPLOYED' : '';
+                    const status = v.status === "draft" ? "[DRAFT]" : "";
                     return {
-                        name: `Version ${v.version} - ${dateStr} ${timeStr}${currentMark}`,
+                        name: `Version ${v.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
                         value: v.version
                     };
                 })

package/dist/common/job.instance.js

@@ -2,7 +2,6 @@
  * Job Instance
  * Provides a convenient interface for interacting with a job
  */
-import UserDataInstance from './user.instance.js';
 import UserDataApi from '../api/user.data.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 /**
@@ -97,8 +96,7 @@ export class JobInstance {
         }
     }
     async user() {
-        const result = await this.userApi.get();
-        return new UserDataInstance(this.userApi, result);
+        return await this.userApi.get();
     }
     /**
      * Converts the job instance to JSON.

package/dist/common/user.instance.d.ts

@@ -1,21 +1,24 @@
 import { Message } from "../interfaces/message.js";
 import { UserDataAPI } from "../types/index.js";
+import { ImmutableUserProfile, UserAgentData } from "../interfaces/user.js";
 /**
  * User data instance class providing a fluent API for managing user data
  * Provides methods for updating and clearing data
  * Supports direct property access (e.g., user.name) instead of user.data.name
  */
 export default class UserDataInstance {
-    data: Record<string, any>;
+    data: UserAgentData;
     private userAPI;
+    _luaProfile: ImmutableUserProfile;
     [key: string]: any;
     /**
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
      * @param data - The user data from the API
+     * @param profile - The immutable user profile data
      * @returns Proxied instance that allows direct access to data properties
      */
-    constructor(api: UserDataAPI, data: any);
+    constructor(api: UserDataAPI, data: any, profile?: ImmutableUserProfile);
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized user data

package/dist/common/user.instance.js

@@ -8,17 +8,34 @@ export default class UserDataInstance {
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
      * @param data - The user data from the API
+     * @param profile - The immutable user profile data
      * @returns Proxied instance that allows direct access to data properties
      */
-    constructor(api, data) {
+    constructor(api, data, profile) {
         // Ensure data is always an object, never null or undefined
-        this.data = data && typeof data === 'object' ? data : {};
+        this.data = data && typeof data === "object" ? data : {};
         // Make userAPI non-enumerable so it doesn't show up in console.log
-        Object.defineProperty(this, 'userAPI', {
+        Object.defineProperty(this, "userAPI", {
             value: api,
             writable: true,
             enumerable: false,
-            configurable: true
+            configurable: true,
+        });
+        // Make _luaProfile non-enumerable and immutable
+        Object.defineProperty(this, "_luaProfile", {
+            get() {
+                return (profile || {
+                    userId: "",
+                    fullName: "",
+                    mobileNumbers: [],
+                    emailAddresses: [],
+                });
+            },
+            set(_) {
+                // silently ignore any attempts to modify
+            },
+            enumerable: false,
+            configurable: false,
         });
         // Return a proxy that allows direct property access
         return new Proxy(this, {
@@ -28,21 +45,31 @@ export default class UserDataInstance {
                     return Reflect.get(target, prop, receiver);
                 }
                 // Otherwise, try to get it from the data object (with null check)
-                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
+                if (typeof prop === "string" &&
+                    target.data &&
+                    typeof target.data === "object" &&
+                    prop in target.data) {
                     return target.data[prop];
                 }
                 return undefined;
             },
             set(target, prop, value, receiver) {
                 // Reserved properties that should be set on the instance itself
-                const reservedProps = ['data', 'userAPI', 'update', 'clear', 'toJSON'];
-                if (typeof prop === 'string' && reservedProps.includes(prop)) {
+                const reservedProps = [
+                    "data",
+                    "userAPI",
+                    "update",
+                    "clear",
+                    "toJSON",
+                    "_luaProfile",
+                ];
+                if (typeof prop === "string" && reservedProps.includes(prop)) {
                     return Reflect.set(target, prop, value, receiver);
                 }
                 // All other properties get set on the data object
-                if (typeof prop === 'string') {
+                if (typeof prop === "string") {
                     // Initialize data object if it doesn't exist
-                    if (!target.data || typeof target.data !== 'object') {
+                    if (!target.data || typeof target.data !== "object") {
                         target.data = {};
                     }
                     target.data[prop] = value;
@@ -55,7 +82,9 @@ export default class UserDataInstance {
                 if (prop in target) {
                     return true;
                 }
-                if (typeof prop === 'string' && target.data && typeof target.data === 'object') {
+                if (typeof prop === "string" &&
+                    target.data &&
+                    typeof target.data === "object") {
                     return prop in target.data;
                 }
                 return false;
@@ -63,7 +92,9 @@ export default class UserDataInstance {
             ownKeys(target) {
                 // Return both instance keys and data keys (with null check)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
+                const dataKeys = target.data && typeof target.data === "object"
+                    ? Object.keys(target.data)
+                    : [];
                 return [...new Set([...instanceKeys, ...dataKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -73,16 +104,19 @@ export default class UserDataInstance {
                     return instanceDesc;
                 }
                 // Then check if it's a data property (with null check)
-                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
+                if (typeof prop === "string" &&
+                    target.data &&
+                    typeof target.data === "object" &&
+                    prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,
                         writable: true,
-                        value: target.data[prop]
+                        value: target.data[prop],
                     };
                 }
                 return undefined;
-            }
+            },
         });
     }
     /**
@@ -96,7 +130,7 @@ export default class UserDataInstance {
      * Custom inspect method for Node.js console.log
      * @returns Formatted user data for console output
      */
-    [Symbol.for('nodejs.util.inspect.custom')]() {
+    [Symbol.for("nodejs.util.inspect.custom")]() {
         return this.data;
     }
     /**
@@ -108,11 +142,11 @@ 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) {
-            throw new Error('Failed to update user data');
+            throw new Error("Failed to update user data");
         }
     }
     /**
@@ -126,7 +160,7 @@ export default class UserDataInstance {
             return true;
         }
         catch (error) {
-            throw new Error('Failed to clear user data');
+            throw new Error("Failed to clear user data");
         }
     }
     /**
@@ -140,7 +174,7 @@ export default class UserDataInstance {
             return true;
         }
         catch (error) {
-            throw new Error('Failed to save user data');
+            throw new Error("Failed to save user data");
         }
     }
     /**
@@ -155,7 +189,7 @@ export default class UserDataInstance {
             return true;
         }
         catch (error) {
-            throw new Error('Failed to send message');
+            throw new Error("Failed to send message");
         }
     }
     //get chat history
@@ -164,7 +198,7 @@ export default class UserDataInstance {
             return await this.userAPI.getChatHistory();
         }
         catch (error) {
-            throw new Error('Failed to get chat history');
+            throw new Error("Failed to get chat history");
         }
     }
 }

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/index.d.ts

@@ -4,7 +4,8 @@
  * This file serves as the main entry point for all interface definitions.
  * It re-exports interfaces and DTOs from various modules for convenient importing.
  */
-export { CreateWebhookDTO, PushWebhookVersionDTO, UpdateWebhookVersionDTO, WebhookVersion, Webhook, GetWebhooksResponse, DeleteWebhookResponse, CreateWebhookResponse, PushWebhookVersionResponse, } from './webhooks.js';
-export { CreateJobDTO, PushJobVersionDTO, UpdateJobVersionDTO, JobSchedule, JobScheduleType, JobRetryConfig, JobVersion, JobExecutionStatus, JobExecution, JobStatus, Job, GetJobsResponse, DeleteJobResponse, CreateJobResponse, PushJobVersionResponse, JobExecutionResponse, GetJobExecutionsResponse, } from './jobs.js';
-export { ApiResponse, Pagination, } from './common.js';
-export { SkillTool, SkillVersion, Skill, GetSkillsResponse, DeleteSkillResponse, } from './skills.js';
+export { CreateWebhookDTO, PushWebhookVersionDTO, UpdateWebhookVersionDTO, WebhookVersion, Webhook, GetWebhooksResponse, DeleteWebhookResponse, CreateWebhookResponse, PushWebhookVersionResponse, } from "./webhooks.js";
+export { CreateJobDTO, PushJobVersionDTO, UpdateJobVersionDTO, JobSchedule, JobScheduleType, JobRetryConfig, JobVersion, JobExecutionStatus, JobExecution, JobStatus, Job, GetJobsResponse, DeleteJobResponse, CreateJobResponse, PushJobVersionResponse, JobExecutionResponse, GetJobExecutionsResponse, } from "./jobs.js";
+export { ApiResponse, Pagination } from "./common.js";
+export { SkillTool, SkillVersion, Skill, GetSkillsResponse, DeleteSkillResponse, } from "./skills.js";
+export { ImmutableUserProfile, UserAgentData } from "./user.js";

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/interfaces/user.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Immutable user profile information from Lua's user database
+ */
+export interface ImmutableUserProfile {
+    userId: string;
+    fullName: string;
+    mobileNumbers: string[];
+    emailAddresses: string[];
+}
+/**
+ * Base user agent data structure
+ */
+export interface UserAgentData extends Record<string, any> {
+    /**
+     * @deprecated Use `user._luaProfile.userId` instead. This property is kept for backwards compatibility and will be removed in a future version.
+     * Note: This refers only to the Lua userId. If you use a custom `userId` property in your app that is not the Lua user ID, ignore this deprecation notice.
+     */
+    userId?: string;
+}

package/dist/interfaces/user.js

@@ -0,0 +1 @@
+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);
+}