lua-cli 3.0.2 → 3.1.0-alpha.1

package/dist/api/job.api.service.d.ts

@@ -83,7 +83,9 @@ export default class JobApi extends HttpClient {
      * @returns Promise resolving to an ApiResponse containing an array of jobs with their versions
      * @throws Error if the API request fails or the agent is not found
      */
-    getJobs(): Promise<ApiResponse<GetJobsResponse>>;
+    getJobs(options?: {
+        includeDynamic?: boolean;
+    }): Promise<ApiResponse<GetJobsResponse>>;
     /**
      * Retrieves a job by its unique identifier
      * @param jobId - The unique identifier of the job to retrieve

package/dist/api/job.api.service.js

@@ -22,8 +22,13 @@ export default class JobApi extends HttpClient {
      * @returns Promise resolving to an ApiResponse containing an array of jobs with their versions
      * @throws Error if the API request fails or the agent is not found
      */
-    async getJobs() {
-        return this.httpGet(`/developer/jobs/${this.agentId}`, {
+    async getJobs(options = {}) {
+        const queryParams = new URLSearchParams();
+        if (options.includeDynamic) {
+            queryParams.append('includeDynamic', 'true');
+        }
+        const url = `/developer/jobs/${this.agentId}?${queryParams.toString()}`;
+        return this.httpGet(url, {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }

package/dist/api/logs.api.service.d.ts

@@ -15,21 +15,19 @@ export default class LogsApi extends HttpClient {
     constructor(baseUrl: string, apiKey: string);
     /**
      * Retrieves logs for an agent
-     * @param agentId - The unique identifier of the agent
+     * @param agentId - The ID of the agent
      * @param limit - Number of logs per page (default: 20)
      * @param page - Page number (default: 1)
+     * @param skillId - Optional skill ID to filter logs
+     * @param logType - Optional log type to filter logs
      * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
      */
-    getAgentLogs(agentId: string, limit?: number, page?: number): Promise<ApiResponse<LogsResponse>>;
-    /**
-     * Retrieves logs for a specific skill
-     * @param agentId - The unique identifier of the agent
-     * @param skillId - The unique identifier of the skill
-     * @param limit - Number of logs per page (default: 20)
-     * @param page - Page number (default: 1)
-     * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
-     */
-    getSkillLogs(agentId: string, skillId: string, limit?: number, page?: number): Promise<ApiResponse<LogsResponse>>;
+    getAgentLogs(agentId: string, limit: number, page: number, filters?: {
+        primitiveType?: "skill" | "job" | "webhook" | "preprocessor" | "postprocessor";
+        primitiveId?: string;
+        primitiveName?: string;
+        toolId?: string;
+        toolName?: string;
+        logType?: string;
+    }): Promise<ApiResponse<LogsResponse>>;
 }

package/dist/api/logs.api.service.js

@@ -15,28 +15,31 @@ export default class LogsApi extends HttpClient {
     }
     /**
      * Retrieves logs for an agent
-     * @param agentId - The unique identifier of the agent
+     * @param agentId - The ID of the agent
      * @param limit - Number of logs per page (default: 20)
      * @param page - Page number (default: 1)
+     * @param skillId - Optional skill ID to filter logs
+     * @param logType - Optional log type to filter logs
      * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
      */
-    async getAgentLogs(agentId, limit = 20, page = 1) {
-        return this.httpGet(`/developer/agents/${agentId}/logs?limit=${limit}&page=${page}`, {
-            Authorization: `Bearer ${this.apiKey}`,
+    async getAgentLogs(agentId, limit, page, filters = {}) {
+        const queryParams = new URLSearchParams({
+            limit: limit.toString(),
+            page: page.toString(),
         });
-    }
-    /**
-     * Retrieves logs for a specific skill
-     * @param agentId - The unique identifier of the agent
-     * @param skillId - The unique identifier of the skill
-     * @param limit - Number of logs per page (default: 20)
-     * @param page - Page number (default: 1)
-     * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
-     */
-    async getSkillLogs(agentId, skillId, limit = 20, page = 1) {
-        return this.httpGet(`/developer/skills/${agentId}/${skillId}/logs?limit=${limit}&page=${page}`, {
+        if (filters.primitiveType)
+            queryParams.append("primitiveType", filters.primitiveType);
+        if (filters.primitiveId)
+            queryParams.append("primitiveId", filters.primitiveId);
+        if (filters.primitiveName)
+            queryParams.append("primitiveName", filters.primitiveName);
+        if (filters.toolId)
+            queryParams.append("toolId", filters.toolId);
+        if (filters.toolName)
+            queryParams.append("toolName", filters.toolName);
+        if (filters.logType)
+            queryParams.append("logType", filters.logType);
+        return this.httpGet(`/developer/agents/${agentId}/logs?${queryParams.toString()}`, {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }

package/dist/api/user.data.api.service.d.ts

@@ -18,7 +18,7 @@ export default class UserDataApi extends HttpClient implements UserDataAPI {
      * @returns Promise resolving to a UserDataInstance containing the user's data
      * @throws Error if the user data cannot be retrieved or the request fails
      */
-    get(): Promise<UserDataInstance>;
+    get(userId?: string): Promise<UserDataInstance>;
     /**
      * Updates the current user's data for the specific agent
      * @param data - The data object containing fields to update or add to user data

package/dist/api/user.data.api.service.js

@@ -18,14 +18,21 @@ export default class UserDataApi extends HttpClient {
      * @returns Promise resolving to a UserDataInstance containing the user's data
      * @throws Error if the user data cannot be retrieved or the request fails
      */
-    async get() {
-        const response = await this.httpGet(`/developer/user/data/agent/${this.agentId}`, {
+    async get(userId) {
+        let url = `/developer/user/data/agent/${this.agentId}`;
+        if (userId) {
+            url += `/user/${userId}`;
+        }
+        const response = await this.httpGet(url, {
             Authorization: `Bearer ${this.apiKey}`,
         });
         if (!response.success) {
             throw new Error(response.error?.message || 'Failed to get user data');
         }
-        return new UserDataInstance(this, response.data);
+        // Extract profile data and remove from response
+        const profile = response.data?._luaProfile;
+        const { _luaProfile, ...data } = response.data || {};
+        return new UserDataInstance(this, data, profile);
     }
     /**
      * Updates the current user's data for the specific agent
@@ -40,7 +47,9 @@ export default class UserDataApi extends HttpClient {
         if (!response.success) {
             throw new Error(response.error?.message || 'Failed to update user data');
         }
-        return response.data;
+        // Extract profile if present and remove from response
+        const { _luaProfile, ...cleanData } = response.data || {};
+        return cleanData;
     }
     /**
      * Clears all user data for the current user and specific agent

package/dist/api-exports.d.ts

@@ -46,7 +46,7 @@ export declare const User: {
      *
      * @returns Promise resolving to user data
      */
-    get(): Promise<UserDataInstance>;
+    get(userId?: string): Promise<UserDataInstance>;
     /**
      * Gets the chat history for the current user.
      *

package/dist/api-exports.js

@@ -42,9 +42,9 @@ export const User = {
      *
      * @returns Promise resolving to user data
      */
-    async get() {
+    async get(userId) {
         const instance = await getUserInstance();
-        return instance.get();
+        return instance.get(userId);
     },
     /**
      * Gets the chat history for the current user.

package/dist/commands/logs.js

@@ -9,6 +9,11 @@ import { readSkillConfig } from "../utils/files.js";
 import { withErrorHandling, writeSuccess, writeInfo, writeError, clearPromptLines } from "../utils/cli.js";
 import LogsApi from '../api/logs.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
+import SkillApi from "../api/skills.api.service.js";
+import JobApi from "../api/job.api.service.js";
+import WebhookApi from "../api/webhook.api.service.js";
+import PreprocessorApi from "../api/preprocessor.api.service.js";
+import PostprocessorApi from "../api/postprocessor.api.service.js";
 /**
  * Main logs command - displays agent/skill logs with navigation
  *
@@ -45,102 +50,147 @@ export async function logsCommand() {
                 message: "What logs do you want to view?",
                 choices: [
                     { name: "📋 All agent logs", value: "all" },
-                    { name: "🎯 Specific skill logs", value: "skill" }
-                ]
-            }
+                    { name: "🔎 Filter logs", value: "filter" },
+                ],
+            },
         ]);
         clearPromptLines(2);
         if (viewType === "all") {
             await viewAgentLogs(logsApi, agentId);
         }
         else {
-            await viewSkillLogs(logsApi, agentId, config);
+            await filterAndShowLogs(logsApi, agentId, apiKey);
         }
     }, "logs viewing");
 }
-/**
- * View all logs for an agent with pagination
- */
-async function viewAgentLogs(logsApi, agentId) {
-    let currentPage = 1;
-    const limit = 20;
-    let keepViewing = true;
-    while (keepViewing) {
-        const response = await logsApi.getAgentLogs(agentId, limit, currentPage);
-        if (!response.success) {
-            writeError(`❌ Error: ${response.error?.message || 'Unknown error'}`);
-            process.exit(1);
+async function filterAndShowLogs(logsApi, agentId, apiKey) {
+    const apiServices = {
+        skill: new SkillApi(BASE_URLS.API, apiKey, agentId),
+        job: new JobApi(BASE_URLS.API, apiKey, agentId),
+        webhook: new WebhookApi(BASE_URLS.API, apiKey, agentId),
+        preprocessor: new PreprocessorApi(BASE_URLS.API, apiKey, agentId),
+        postprocessor: new PostprocessorApi(BASE_URLS.API, apiKey, agentId),
+    };
+    let keepFiltering = true;
+    while (keepFiltering) {
+        const { filterType } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "filterType",
+                message: "Filter by:",
+                choices: [
+                    { name: "📋 All logs", value: "all" },
+                    new inquirer.Separator(),
+                    { name: "Skills", value: "skill" },
+                    { name: "Jobs", value: "job" },
+                    { name: "Webhooks", value: "webhook" },
+                    { name: "Preprocessors", value: "preprocessor" },
+                    { name: "Postprocessors", value: "postprocessor" },
+                    new inquirer.Separator(),
+                    { name: "← Back", value: "back" },
+                    new inquirer.Separator(),
+                ],
+            },
+        ]);
+        if (filterType === "all") {
+            await viewAgentLogs(logsApi, agentId);
+            return; // Exit to main command menu
         }
-        const data = response.data;
-        displayLogs(data.logs, data.pagination, "All Agent Logs");
-        // Navigation menu
-        const { action } = await inquirer.prompt([
+        if (filterType === "back") {
+            await logsCommand();
+            return; // Exit to main command menu
+        }
+        const primitiveType = filterType;
+        const capitalizedType = primitiveType.charAt(0).toUpperCase() + primitiveType.slice(1);
+        let response;
+        let items = [];
+        switch (primitiveType) {
+            case "skill":
+                response = await apiServices.skill.getSkills();
+                items = response.data?.skills || [];
+                break;
+            case "job":
+                response = await apiServices.job.getJobs({ includeDynamic: true });
+                items = response.data?.jobs || [];
+                break;
+            case "webhook":
+                response = await apiServices.webhook.getWebhooks();
+                items = response.data?.webhooks || [];
+                break;
+            case "preprocessor":
+                response = await apiServices.preprocessor.getPreProcessors();
+                items = response.data?.preprocessors || [];
+                break;
+            case "postprocessor":
+                response = await apiServices.postprocessor.getPostProcessors();
+                items = response.data?.postprocessors || [];
+                break;
+            default:
+                writeError("❌ Invalid filter type selected.");
+                continue;
+        }
+        if (!response || !response.success || !response.data) {
+            writeError(`❌ Could not fetch ${primitiveType}s from the API.`);
+            continue;
+        }
+        if (items.length === 0) {
+            writeInfo(`ℹ️ No ${primitiveType}s found for this agent.\n`);
+            continue;
+        }
+        const { selectedId } = await inquirer.prompt([
             {
                 type: "list",
-                name: "action",
-                message: "Navigation:",
-                choices: getNavigationChoices(data.pagination)
-            }
+                name: "selectedId",
+                message: `Select a ${primitiveType}:`,
+                choices: [
+                    { name: `All ${capitalizedType}s`, value: "all" },
+                    new inquirer.Separator(),
+                    ...items.map((item) => ({
+                        name: item.name,
+                        value: item.id,
+                    })),
+                    new inquirer.Separator(),
+                    { name: "← Back", value: "back" },
+                    new inquirer.Separator(),
+                ],
+            },
         ]);
-        clearPromptLines(2);
-        keepViewing = await handleNavigation(action, data.pagination, (page) => {
-            currentPage = page;
-        });
+        if (selectedId === "back") {
+            continue;
+        }
+        const filters = {
+            primitiveType,
+        };
+        if (selectedId !== "all") {
+            filters.primitiveId = selectedId;
+        }
+        await viewAgentLogs(logsApi, agentId, filters);
+        return;
     }
 }
 /**
- * View logs for a specific skill with pagination
+ * View all logs for an agent with pagination
  */
-async function viewSkillLogs(logsApi, agentId, config) {
-    // Get skills from config
-    const skills = config?.skills || [];
-    if (skills.length === 0) {
-        writeError("❌ No skills found in lua.skill.yaml");
-        writeInfo("💡 Run 'lua push' to deploy skills first.\n");
-        return;
-    }
-    // Let user select a skill
-    const skillChoices = skills.map((skill) => ({
-        name: `${skill.name} (${skill.skillId || 'No ID'})`,
-        value: skill.skillId
-    }));
-    skillChoices.push({
-        name: '← Back to main menu',
-        value: null
-    });
-    const { skillId } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "skillId",
-            message: "Select a skill:",
-            choices: skillChoices
-        }
-    ]);
-    if (!skillId) {
-        return;
-    }
-    clearPromptLines(2);
+async function viewAgentLogs(logsApi, agentId, filters = {}) {
     let currentPage = 1;
     const limit = 20;
     let keepViewing = true;
-    const selectedSkill = skills.find((s) => s.skillId === skillId);
-    const skillName = selectedSkill?.name || skillId;
     while (keepViewing) {
-        const response = await logsApi.getSkillLogs(agentId, skillId, limit, currentPage);
+        const response = await logsApi.getAgentLogs(agentId, limit, currentPage, filters);
         if (!response.success) {
             writeError(`❌ Error: ${response.error?.message || 'Unknown error'}`);
             process.exit(1);
         }
         const data = response.data;
-        displayLogs(data.logs, data.pagination, `Logs for ${skillName}`);
+        displayLogs(data.logs, data.pagination, "All Agent Logs");
         // Navigation menu
         const { action } = await inquirer.prompt([
             {
                 type: "list",
                 name: "action",
                 message: "Navigation:",
-                choices: getNavigationChoices(data.pagination)
-            }
+                choices: getNavigationChoices(data.pagination),
+            },
         ]);
         clearPromptLines(2);
         keepViewing = await handleNavigation(action, data.pagination, (page) => {
@@ -167,11 +217,21 @@ function displayLogs(logs, pagination, title) {
         const icon = getLogIcon(log.subType);
         const color = getLogColor(log.subType);
         console.log(color(`${icon} [${timestamp}] ${log.subType.toUpperCase()}`));
-        if (log.metadata.skillName) {
-            console.log(chalk.gray(`   Skill: ${log.metadata.skillName}`));
+        const { primitiveType, primitiveId, primitiveName, toolName, toolId } = log.metadata;
+        const capitalizedType = primitiveType
+            ? primitiveType.charAt(0).toUpperCase() + primitiveType.slice(1)
+            : "Item";
+        if (primitiveName) {
+            console.log(chalk.gray(`   ${capitalizedType} Name: ${primitiveName}`));
         }
-        if (log.metadata.toolId) {
-            console.log(chalk.gray(`   Tool: ${log.metadata.toolId}`));
+        if (primitiveId) {
+            console.log(chalk.gray(`   ${capitalizedType} ID:   ${primitiveId}`));
+        }
+        // Only show tool information for skills
+        if (primitiveType === "skill") {
+            if (toolName) {
+                console.log(chalk.gray(`   Tool Name: ${toolName}`));
+            }
         }
         if (log.duration !== undefined) {
             console.log(chalk.gray(`   Duration: ${log.duration}ms`));

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