lua-cli 2.2.7 → 2.2.8-alpha.2

package/dist/common/http.client.js

@@ -0,0 +1,83 @@
+/**
+ * Generic HTTP client with common error handling
+ */
+export class HttpClient {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async request(url, options = {}) {
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...options.headers,
+                },
+            });
+            // Check if response is ok (status 200-299)
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: {
+                        message: `HTTP ${response.status}: ${response.statusText}`,
+                        statusCode: response.status,
+                    },
+                };
+            }
+            // Try to parse JSON response
+            let data;
+            try {
+                data = await response.json();
+            }
+            catch (jsonError) {
+                data = {};
+            }
+            // If the response already has the ApiResponse structure, return it
+            if (typeof data === 'object' && data !== null && 'success' in data) {
+                return data;
+            }
+            // Otherwise, wrap the data in a successful ApiResponse
+            return {
+                success: true,
+                data,
+            };
+        }
+        catch (error) {
+            // Handle network errors, timeouts, etc.
+            return {
+                success: false,
+                error: {
+                    message: error instanceof Error ? error.message : 'Network request failed',
+                    statusCode: 0, // Use 0 to indicate network/connection error
+                },
+            };
+        }
+    }
+    async httpGet(url, headers) {
+        return this.request(this.baseUrl + url, { method: 'GET', headers });
+    }
+    async httpPost(url, data, headers) {
+        return this.request(this.baseUrl + url, {
+            method: 'POST',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    }
+    async httpPut(url, data, headers) {
+        return this.request(this.baseUrl + url, {
+            method: 'PUT',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    }
+    async httpDelete(url, headers) {
+        return this.request(this.baseUrl + url, { method: 'DELETE', headers });
+    }
+    async httpPatch(url, data, headers) {
+        return this.request(this.baseUrl + url, {
+            method: 'PATCH',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    }
+}

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

@@ -0,0 +1,18 @@
+import OrderApi from "../api/order.api.service.js";
+import { OrderResponse, OrderStatus } from "../interfaces/orders.js";
+export default class OrderInstance {
+    private data;
+    private common;
+    private id;
+    private userId;
+    private agentId;
+    private orderId;
+    private orderAPI;
+    constructor(api: OrderApi, order: OrderResponse);
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+    updateStatus(status: OrderStatus): Promise<any>;
+    update(data: Record<string, any>): Promise<any>;
+}

package/dist/common/order.instance.js

@@ -0,0 +1,52 @@
+export default class OrderInstance {
+    constructor(api, order) {
+        this.data = order.data;
+        this.common = order.common;
+        this.id = order.id;
+        this.userId = order.userId;
+        this.agentId = order.agentId;
+        this.orderId = order.orderId;
+        // Make orderAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'orderAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            ...this.data,
+            ...this.common
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            ...this.data,
+            ...this.common
+        };
+    }
+    async updateStatus(status) {
+        const response = await this.orderAPI.updateStatus(status, this.id);
+        this.common = response.common;
+        return {
+            ...this.data,
+            ...this.common
+        };
+    }
+    async update(data) {
+        const response = await this.orderAPI.updateData(data, this.id);
+        this.data = response.data;
+        this.common = response.common;
+        return {
+            ...this.data,
+            ...this.common
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Product } from "../interfaces/product";
+export default class ProductInstance {
+    data: Product;
+    private productAPI;
+    constructor(api: any, product: Product);
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+    update(data: Record<string, any>): Promise<Product>;
+    delete(): Promise<Product>;
+}

package/dist/common/product.instance.js

@@ -0,0 +1,45 @@
+export default class ProductInstance {
+    constructor(api, product) {
+        this.data = product;
+        // Make productAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'productAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            data: this.data
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            data: this.data
+        };
+    }
+    async update(data) {
+        const response = await this.productAPI.update(data, this.data.id);
+        if (response.updated) {
+            this.data = response.product;
+            return this.data;
+        }
+        else {
+            throw new Error('Failed to update product');
+        }
+    }
+    async delete() {
+        const response = await this.productAPI.delete(this.data.id);
+        if (response.deleted) {
+            this.data = {};
+        }
+        return this.data;
+    }
+}

package/dist/common/product.pagination.instance.d.ts

@@ -0,0 +1,23 @@
+import { ProductsResponse } from "../interfaces/product";
+import ProductInstance from "./product.instance";
+export default class ProductPaginationInstance {
+    products: ProductInstance[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        totalCount: number;
+        limit: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+        nextPage: number | null;
+        prevPage: number | null;
+    };
+    private productAPI;
+    constructor(api: any, results: ProductsResponse);
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+    nextPage(): Promise<ProductPaginationInstance>;
+    prevPage(): Promise<ProductPaginationInstance>;
+}

package/dist/common/product.pagination.instance.js

@@ -0,0 +1,53 @@
+import ProductInstance from "./product.instance";
+export default class ProductPaginationInstance {
+    constructor(api, results) {
+        this.products = results.data?.map(product => new ProductInstance(api, product)) || [];
+        this.pagination = results.pagination || {
+            currentPage: 1,
+            totalPages: 1,
+            totalCount: 0,
+            limit: 10,
+            hasNextPage: false,
+            hasPrevPage: false,
+            nextPage: null,
+            prevPage: null
+        };
+        // Make productAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'productAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            products: this.products,
+            pagination: this.pagination
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            products: this.products,
+            pagination: this.pagination
+        };
+    }
+    async nextPage() {
+        if (!this.pagination.nextPage) {
+            throw new Error('No next page');
+        }
+        return await this.productAPI.get(this.pagination.nextPage, this.pagination.limit);
+    }
+    async prevPage() {
+        if (!this.pagination.prevPage) {
+            throw new Error('No previous page');
+        }
+        return await this.productAPI.get(this.pagination.prevPage, this.pagination.limit);
+    }
+}

package/dist/common/product.search.instance.d.ts

@@ -0,0 +1,12 @@
+import { SearchProductsResponse } from "../interfaces/product";
+import { ProductAPI } from "../types";
+import ProductInstance from "./product.instance";
+export default class ProductSearchInstance {
+    products: ProductInstance[];
+    private productAPI;
+    constructor(api: ProductAPI, results: SearchProductsResponse);
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+}

package/dist/common/product.search.instance.js

@@ -0,0 +1,29 @@
+import ProductInstance from "./product.instance";
+export default class ProductSearchInstance {
+    constructor(api, results) {
+        this.products = results.data?.map(product => new ProductInstance(api, product)) || [];
+        // Make productAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'productAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            products: this.products,
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            products: this.products,
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+import { UserData } from "../interfaces/admin";
+import { UserDataAPI } from "../types";
+export default class UserDataInstance {
+    data: Record<string, any>;
+    private userAPI;
+    constructor(api: UserDataAPI, data: UserData);
+    /**
+     * Remove sensitive fields from the data before storing
+     */
+    private sanitizeData;
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+    update(data: Record<string, any>): Promise<any>;
+    clear(): Promise<boolean>;
+}

package/dist/common/user.instance.js

@@ -0,0 +1,63 @@
+export default class UserDataInstance {
+    constructor(api, data) {
+        this.data = this.sanitizeData(data);
+        // Make userAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'userAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Remove sensitive fields from the data before storing
+     */
+    sanitizeData(data) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        // Create a copy of the data to avoid mutating the original
+        const sanitized = { ...data };
+        // Remove sensitive fields
+        const sensitiveFields = ['apiKey', 'agentId', 'userId', 'token', 'secret', 'key'];
+        sensitiveFields.forEach(field => {
+            delete sanitized[field];
+        });
+        return sanitized;
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            data: this.data
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            data: this.data
+        };
+    }
+    async update(data) {
+        try {
+            const response = await this.userAPI.update(data);
+            this.data = this.sanitizeData(response.data);
+            return this.data;
+        }
+        catch (error) {
+            throw new Error('Failed to update user data');
+        }
+    }
+    async clear() {
+        try {
+            await this.userAPI.clear();
+            return true;
+        }
+        catch (error) {
+            throw new Error('Failed to clear user data');
+        }
+    }
+}

package/dist/interfaces/admin.d.ts

@@ -0,0 +1,95 @@
+export interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: {
+        message: string;
+        statusCode?: number;
+    };
+}
+export interface UserData {
+    uid: string;
+    email: string;
+    emailVerified: boolean;
+    fullName: string;
+    mobileNumbers: any[];
+    emailAddresses: any[];
+    country: any;
+    admin: any;
+    channels: Record<string, any>;
+    rights: Record<string, any>;
+    setupPersona: Record<string, any>;
+    notifications: Record<string, any>;
+}
+export interface Organization {
+    id: string;
+    name: string;
+    agents: string[];
+}
+export interface SkillVersion {
+    version: string;
+    createdAt: string;
+    status: string;
+}
+export interface DevVersionResponse {
+    success: boolean;
+    data?: {
+        message: string;
+        skillId: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        statusCode: number;
+    };
+}
+export interface UpdateDevVersionResponse {
+    success: boolean;
+    data?: {
+        message: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        statusCode: number;
+    };
+}
+export interface EmailAddress {
+    address: string;
+    validated: boolean;
+    validatedAt: number;
+    _id: string;
+}
+export interface Country {
+    code: string;
+    name: string;
+}
+export interface Admin {
+    userId: string;
+    orgs: Organization[];
+    id: string;
+    createdAt: number;
+    __v: number;
+}
+export interface Agent {
+    agentId: string;
+    rights: string[];
+    name: string;
+}
+export interface OrganizationAuth {
+    id: string;
+    rights?: string[];
+    agents: Agent[];
+    registeredName: string;
+    country: string;
+    phoneNumber?: string | null;
+    type: string;
+}
+export interface OTPResponse {
+    signInToken: string;
+}
+export interface ApiKeyResponse {
+    message: string;
+    userId: string;
+    apiKey: string;
+    apiId: string;
+}

package/dist/interfaces/admin.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/agent.d.ts

@@ -0,0 +1,86 @@
+export interface Agent {
+    id: string;
+    name: string;
+    persona?: string;
+    welcomeMessage?: string;
+    featuresOverride?: Record<string, any>;
+}
+export interface AgentType {
+    id: string;
+    name: string;
+    features: Record<string, any>;
+    requiredSubAgentMetadata?: string[];
+}
+export interface CreateAgentRequest {
+    id: string;
+    type: string;
+    metadata: Record<string, any>;
+    persona: {
+        agentName: string;
+        businessType: string;
+        brandPersonality: string;
+        brandTraits: string;
+    };
+    features: Record<string, boolean>;
+    channels: any[];
+    org: {
+        registeredName: string;
+    };
+}
+export interface CreateAgentResponse {
+    success: boolean;
+    data?: {
+        agentId: string;
+        name: string;
+        baseAgentId: string;
+        persona: string;
+        createdAt: string;
+        welcomeMessage: string;
+        featuresOverride: Record<string, any>;
+        _id: string;
+        updatedAt: string;
+        __v: number;
+        org: {
+            registeredName: string;
+            type: string;
+            agents: string[];
+            paymentMethods: any[];
+            _id: string;
+            id: string;
+            createdAt: number;
+            __v: number;
+        };
+    };
+    error?: {
+        message: string;
+        error: string;
+        statusCode: number;
+    };
+}
+export interface AgentDetailsResponse {
+    success: boolean;
+    data?: {
+        _id: string;
+        agentId: string;
+        name: string;
+        baseAgentId: string;
+        persona: string;
+        createdAt: string;
+        welcomeMessage: string;
+        featuresOverride: Record<string, any>;
+        updatedAt: string;
+        __v: number;
+        personaConfig: {
+            agentName: string;
+            businessType: string;
+            brandPersonality: string;
+            brandTraits: string;
+        };
+        skills: any[];
+    };
+    error?: {
+        message: string;
+        error: string;
+        statusCode: number;
+    };
+}

package/dist/interfaces/agent.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/baskets.d.ts

@@ -0,0 +1,75 @@
+export declare enum BasketStatus {
+    ACTIVE = "active",
+    CHECKED_OUT = "checked_out",
+    ABANDONED = "abandoned",
+    EXPIRED = "expired"
+}
+export interface BasketItem {
+    id: string;
+    price: number;
+    quantity: number;
+    SKU?: string;
+    addedAt?: string;
+    [key: string]: any;
+}
+export interface BasketData {
+    currency: string;
+    metadata?: any;
+    items: BasketItem[];
+    createdAt: string;
+}
+export interface BasketCommon {
+    status: BasketStatus;
+    totalAmount: string | number;
+    itemCount: number;
+}
+export interface Basket {
+    id: string;
+    userId: string;
+    agentId: string;
+    data: BasketData;
+    common: BasketCommon;
+    createdAt: string;
+    updatedAt: string;
+    __v: number;
+}
+export interface CreateBasketRequest {
+    currency: string;
+    metadata?: any;
+}
+export interface CreateBasketResponse {
+    success: boolean;
+    message: string;
+    data?: Basket;
+}
+export interface GetBasketsResponse {
+    success: boolean;
+    message: string;
+    data?: Basket[];
+}
+export interface AddItemToBasketRequest {
+    id: string;
+    price: number;
+    quantity: number;
+    [key: string]: any;
+}
+export interface AddItemToBasketResponse {
+    success: boolean;
+    message: string;
+    data?: Basket;
+}
+export interface RemoveItemFromBasketResponse {
+    success: boolean;
+    message: string;
+    data?: Basket;
+}
+export interface ClearBasketResponse {
+    success: boolean;
+    message: string;
+    data?: Basket;
+}
+export interface UpdateBasketStatusResponse {
+    success: boolean;
+    message: string;
+    data?: Basket;
+}

package/dist/interfaces/baskets.js

@@ -0,0 +1,7 @@
+export var BasketStatus;
+(function (BasketStatus) {
+    BasketStatus["ACTIVE"] = "active";
+    BasketStatus["CHECKED_OUT"] = "checked_out";
+    BasketStatus["ABANDONED"] = "abandoned";
+    BasketStatus["EXPIRED"] = "expired";
+})(BasketStatus || (BasketStatus = {}));