gufi-cli 0.1.13 → 0.1.16

package/dist/commands/companies.js

@@ -85,6 +85,190 @@ async function apiRequest(path, options = {}, retry = true) {
     }
     return res.json();
 }
+// 💜 Cache for automation name → company mapping
+const automationCompanyCache = new Map();
+// 💜 Cache for module ID → company mapping
+const moduleCompanyCache = new Map();
+// 💜 Cache for entity ID → company mapping
+const entityCompanyCache = new Map();
+// 💜 Detect company from entity ID (searches all user's companies)
+async function detectCompanyFromEntity(entityId) {
+    const searchId = parseInt(entityId, 10);
+    // Must be a valid numeric ID
+    if (isNaN(searchId)) {
+        return undefined;
+    }
+    // Check cache first
+    if (entityCompanyCache.has(entityId)) {
+        const companyId = entityCompanyCache.get(entityId);
+        try {
+            const data = await apiRequest("/api/company/schema", {
+                headers: { "X-Company-ID": companyId },
+            });
+            const modules = data.modules || data.data?.modules || [];
+            for (const mod of modules) {
+                for (const sub of mod.submodules || []) {
+                    for (const ent of sub.entities || []) {
+                        if (ent.id === searchId) {
+                            return { companyId, entity: ent };
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    try {
+        // Get all companies the user has access to
+        const companiesData = await apiRequest("/api/companies");
+        const companies = companiesData.items || companiesData.data || companiesData || [];
+        // Search through each company's schema for the entity
+        for (const company of companies) {
+            try {
+                const data = await apiRequest("/api/company/schema", {
+                    headers: { "X-Company-ID": String(company.id) },
+                });
+                const modules = data.modules || data.data?.modules || [];
+                // Search by entity ID
+                for (const mod of modules) {
+                    for (const sub of mod.submodules || []) {
+                        for (const ent of sub.entities || []) {
+                            if (ent.id === searchId) {
+                                // Found! Cache it
+                                entityCompanyCache.set(entityId, String(company.id));
+                                return { companyId: String(company.id), entity: ent };
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip companies we can't access
+                continue;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+// 💜 Detect company from module ID (searches all user's companies)
+async function detectCompanyFromModule(moduleId) {
+    const searchId = parseInt(moduleId, 10);
+    // Must be a valid numeric ID
+    if (isNaN(searchId)) {
+        return undefined;
+    }
+    // Check cache first
+    if (moduleCompanyCache.has(moduleId)) {
+        const companyId = moduleCompanyCache.get(moduleId);
+        try {
+            const data = await apiRequest("/api/company/schema", {
+                headers: { "X-Company-ID": companyId },
+            });
+            const modules = data.modules || data.data?.modules || [];
+            for (const mod of modules) {
+                for (const sub of mod.submodules || []) {
+                    for (const ent of sub.entities || []) {
+                        if (ent.ui?.moduleId === searchId) {
+                            mod._moduleId = searchId;
+                            return { companyId, module: mod };
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    try {
+        // Get all companies the user has access to
+        const companiesData = await apiRequest("/api/companies");
+        const companies = companiesData.items || companiesData.data || companiesData || [];
+        // Search through each company for the module
+        for (const company of companies) {
+            try {
+                const data = await apiRequest("/api/company/schema", {
+                    headers: { "X-Company-ID": String(company.id) },
+                });
+                const modules = data.modules || data.data?.modules || [];
+                // Search by moduleId in entities
+                for (const mod of modules) {
+                    for (const sub of mod.submodules || []) {
+                        for (const ent of sub.entities || []) {
+                            if (ent.ui?.moduleId === searchId) {
+                                // Found! Cache it
+                                moduleCompanyCache.set(moduleId, String(company.id));
+                                mod._moduleId = searchId;
+                                return { companyId: String(company.id), module: mod };
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip companies we can't access
+                continue;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+// 💜 Detect company from automation ID (searches all user's companies)
+// Only searches by ID to avoid ambiguity with duplicate names
+async function detectCompanyFromAutomation(automationId) {
+    const searchId = parseInt(automationId, 10);
+    // Must be a valid numeric ID
+    if (isNaN(searchId)) {
+        return undefined;
+    }
+    // Check cache first
+    if (automationCompanyCache.has(automationId)) {
+        const companyId = automationCompanyCache.get(automationId);
+        try {
+            const data = await apiRequest("/api/automation-scripts", {
+                headers: { "X-Company-ID": companyId },
+            });
+            const automations = Array.isArray(data) ? data : data.data || [];
+            const automation = automations.find((a) => a.id === searchId);
+            if (automation)
+                return { companyId, automation };
+        }
+        catch { }
+    }
+    try {
+        // Get all companies the user has access to
+        const companiesData = await apiRequest("/api/companies");
+        const companies = companiesData.items || companiesData.data || companiesData || [];
+        // Search through each company for the automation by ID
+        for (const company of companies) {
+            try {
+                const data = await apiRequest("/api/automation-scripts", {
+                    headers: { "X-Company-ID": String(company.id) },
+                });
+                const automations = Array.isArray(data) ? data : data.data || [];
+                // 💜 Search by ID only
+                const automation = automations.find((a) => a.id === searchId);
+                if (automation) {
+                    // Found! Cache by ID
+                    automationCompanyCache.set(String(automation.id), String(company.id));
+                    return { companyId: String(company.id), automation };
+                }
+            }
+            catch {
+                // Skip companies we can't access
+                continue;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
 // ════════════════════════════════════════════════════════════════════
 // gufi companies - List user's companies
 // ════════════════════════════════════════════════════════════════════
@@ -157,7 +341,7 @@ export async function modulesCommand(companyId) {
             const label = (mod.displayName || mod.label || mod.name || "").substring(0, 28).padEnd(28);
             console.log(`  ${chalk.cyan(id)}\t${label}\t${entityCount} entities`);
         }
-        console.log(chalk.gray("\n  💡 Usa: gufi module <module_id> -c " + companyId + " para ver/editar\n"));
+        console.log(chalk.gray("\n  💡 Usa: gufi module <module_id> para ver/editar\n"));
     }
     catch (err) {
         console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
@@ -204,6 +388,7 @@ async function getModuleFromSchema(moduleId, companyId) {
 }
 // ════════════════════════════════════════════════════════════════════
 // gufi module <module_id> [--edit] [--company <id>] - View/edit module JSON
+// 💜 Auto-detects company if not provided (searches by module ID)
 // ════════════════════════════════════════════════════════════════════
 export async function moduleCommand(moduleId, options) {
     if (!isLoggedIn()) {
@@ -211,14 +396,26 @@ export async function moduleCommand(moduleId, options) {
         process.exit(1);
     }
     if (!moduleId) {
-        console.log(chalk.red("\n  ✗ Uso: gufi module <module_id> [--edit] [--company <id>]\n"));
+        console.log(chalk.red("\n  ✗ Uso: gufi module <module_id> [--edit]\n"));
         process.exit(1);
     }
-    const companyId = options?.company;
     console.log(chalk.magenta(`\n  🟣 Módulo ${moduleId}\n`));
+    let companyId;
+    let module;
     try {
-        // Get module from company schema
-        const module = await getModuleFromSchema(moduleId, companyId);
+        // 💜 Auto-detect company
+        console.log(chalk.gray("  Buscando en todas las companies..."));
+        const result = await detectCompanyFromModule(moduleId);
+        if (result) {
+            module = result.module;
+            companyId = result.companyId;
+            console.log(chalk.gray(`  [gufi] Auto-detected company: ${companyId}\n`));
+        }
+        else {
+            console.log(chalk.red(`  ✗ Módulo ${moduleId} no encontrado en ninguna company\n`));
+            console.log(chalk.gray("  💡 Usa: gufi modules <company_id> para ver IDs de módulos\n"));
+            return;
+        }
         const actualModuleId = module._moduleId || moduleId;
         // Show module info
         console.log(chalk.white(`  ID: ${actualModuleId}`));
@@ -353,7 +550,7 @@ export async function moduleUpdateCommand(moduleId, jsonFile, options) {
         process.exit(1);
     }
     if (!moduleId || !jsonFile) {
-        console.log(chalk.red("\n  ✗ Uso: gufi module:update <module_id> <json_file> [--company <id>] [--dry-run]\n"));
+        console.log(chalk.red("\n  ✗ Uso: gufi module:update <module_id> <json_file> [--dry-run]\n"));
         process.exit(1);
     }
     const fs = await import("fs");
@@ -372,10 +569,18 @@ export async function moduleUpdateCommand(moduleId, jsonFile, options) {
         console.log(chalk.yellow("  [DRY RUN] Solo validando, no se guardarán cambios.\n"));
     }
     try {
-        const headers = {};
-        if (options?.company) {
-            headers["X-Company-ID"] = options.company;
+        // 💜 Auto-detect company
+        console.log(chalk.gray("  Detectando company..."));
+        const detected = await detectCompanyFromModule(moduleId);
+        if (!detected) {
+            console.log(chalk.red("  ✗ Módulo no encontrado\n"));
+            process.exit(1);
         }
+        const companyId = detected.companyId;
+        console.log(chalk.gray(`  Company ${companyId} (auto-detected)\n`));
+        const headers = {
+            "X-Company-ID": companyId,
+        };
         // Validate JSON structure locally
         console.log(chalk.gray("  Validando JSON..."));
         if (!newJson.name && !newJson.displayName) {
@@ -562,50 +767,58 @@ options) {
             const desc = (auto.description || "-").substring(0, 30);
             console.log(`  ${chalk.cyan(id)}\t${name}\t${desc}`);
         }
-        console.log(chalk.gray("\n  💡 Usa: gufi automation <nombre> para ver/editar el código\n"));
+        console.log(chalk.gray("\n  💡 Usa: gufi automation <id> para ver/editar el código\n"));
     }
     catch (err) {
         console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
     }
 }
 // ════════════════════════════════════════════════════════════════════
-// gufi automation <name> [--edit] - View/edit automation code by name
+// gufi automation <id> [--edit] - View/edit automation code by ID
+// 💜 Auto-detects company if not provided (searches by ID only)
 // ════════════════════════════════════════════════════════════════════
-export async function automationCommand(automationName, options) {
+export async function automationCommand(automationId, options) {
     if (!isLoggedIn()) {
         console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
         process.exit(1);
     }
-    if (!automationName) {
-        console.log(chalk.red("\n  ✗ Uso: gufi automation <nombre> [--edit] [--company <id>]\n"));
-        console.log(chalk.gray("  Tip: Usa 'gufi automations' para ver la lista\n"));
+    if (!automationId) {
+        console.log(chalk.red("\n  ✗ Uso: gufi automation <id> [--edit]\n"));
+        console.log(chalk.gray("  Tip: Usa 'gufi automations' para ver IDs\n"));
+        process.exit(1);
+    }
+    // 💜 Validate that it's a numeric ID
+    const isNumericId = /^\d+$/.test(automationId);
+    if (!isNumericId && !options?.company) {
+        console.log(chalk.red(`\n  ✗ Usa el ID numérico, no el nombre\n`));
+        console.log(chalk.gray("  Ejemplo: gufi automation 15"));
+        console.log(chalk.gray("  Tip: Usa 'gufi automations' para ver IDs\n"));
         process.exit(1);
     }
-    console.log(chalk.magenta(`\n  🟣 Automation: ${automationName}\n`));
+    console.log(chalk.magenta(`\n  🟣 Automation: ${automationId}\n`));
     try {
-        const headers = {};
-        if (options?.company) {
-            headers["X-Company-ID"] = options.company;
-        }
-        // Get all scripts and find by name
-        const data = await apiRequest("/api/automation-scripts", { headers });
-        const automations = Array.isArray(data) ? data : data.data || [];
-        const automation = automations.find((a) => a.name === automationName || String(a.id) === automationName);
-        if (!automation) {
-            console.log(chalk.red(`  ✗ Automation "${automationName}" no encontrada\n`));
-            console.log(chalk.gray("  💡 Usa: gufi automations para ver la lista\n"));
+        // 💜 Auto-detect company
+        console.log(chalk.gray("  Buscando en todas las companies..."));
+        const result = await detectCompanyFromAutomation(automationId);
+        if (!result) {
+            console.log(chalk.red(`  ✗ Automation ID ${automationId} no encontrada\n`));
+            console.log(chalk.gray("  💡 Usa: gufi automations -c <company> para ver IDs\n"));
             return;
         }
+        const automation = result.automation;
+        const companyId = result.companyId;
+        console.log(chalk.gray(`  [gufi] Auto-detected company: ${companyId}\n`));
         // Show info
         console.log(chalk.white(`  Nombre: ${automation.name}`));
         console.log(chalk.white(`  ID: ${automation.id}`));
+        console.log(chalk.white(`  Company: ${companyId}`));
         if (automation.description) {
             console.log(chalk.white(`  Descripción: ${automation.description}`));
         }
         console.log();
         const jsCode = automation.code || "";
         if (options?.edit) {
-            await editAutomationCode(automation.name, jsCode, options.company);
+            await editAutomationCode(automation.name, jsCode, companyId);
         }
         else if (options?.file) {
             const fs = await import("fs");
@@ -616,7 +829,7 @@ export async function automationCommand(automationName, options) {
             console.log(chalk.gray("  Código JavaScript:"));
             console.log(chalk.gray("  ─".repeat(30)));
             console.log(jsCode || "(vacío)");
-            console.log(chalk.gray("\n  💡 Usa: gufi automation <nombre> --edit para editar\n"));
+            console.log(chalk.gray("\n  💡 Usa: gufi automation <id> --edit para editar\n"));
         }
     }
     catch (err) {
@@ -662,7 +875,7 @@ export async function automationCreateCommand(name, jsFile, options) {
         console.log(chalk.green("\n  ✓ Automation creada!\n"));
         console.log(chalk.white(`  Nombre: ${result.name || name}`));
         console.log(chalk.white(`  Acción: ${result.action || "created/updated"}`));
-        console.log(chalk.gray("\n  💡 Usa: gufi automations -c " + options.company + " para ver la lista\n"));
+        console.log(chalk.gray("\n  💡 Usa: gufi automations para ver la lista\n"));
     }
     catch (err) {
         console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
@@ -721,16 +934,24 @@ export async function entityAutomationsCommand(entityId, options) {
         process.exit(1);
     }
     if (!entityId) {
-        console.log(chalk.red("\n  ✗ Uso: gufi entity:automations <entityId> [--edit] [--company <id>]\n"));
+        console.log(chalk.red("\n  ✗ Uso: gufi entity:automations <entityId> [--edit]\n"));
         console.log(chalk.gray("  Tip: El entityId lo encuentras en el schema o en la URL de la tabla\n"));
         process.exit(1);
     }
     console.log(chalk.magenta(`\n  🟣 Automations de Entity ${entityId}\n`));
     try {
-        const headers = {};
-        if (options?.company) {
-            headers["X-Company-ID"] = options.company;
+        // 💜 Auto-detect company
+        console.log(chalk.gray("  Detectando company..."));
+        const result = await detectCompanyFromEntity(entityId);
+        if (!result) {
+            console.log(chalk.red("  ✗ Entity no encontrada\n"));
+            process.exit(1);
         }
+        const companyId = result.companyId;
+        console.log(chalk.gray(`  Company ${companyId} (auto-detected)\n`));
+        const headers = {
+            "X-Company-ID": companyId,
+        };
         const data = await apiRequest(`/api/entities/${entityId}/automations`, { headers });
         const automations = data.automations || [];
         const availableScripts = data.availableScripts || [];
@@ -753,7 +974,7 @@ export async function entityAutomationsCommand(entityId, options) {
             }
         }
         if (options?.edit) {
-            await editEntityAutomations(entityId, automations, availableScripts, options.company);
+            await editEntityAutomations(entityId, automations, availableScripts, companyId);
         }
         else if (options?.file) {
             const fs = await import("fs");
@@ -788,7 +1009,7 @@ export async function entityAutomationsUpdateCommand(entityId, jsonFile, options
         process.exit(1);
     }
     if (!entityId || !jsonFile) {
-        console.log(chalk.red("\n  ✗ Uso: gufi entity:automations:update <entityId> <json_file> [--company <id>]\n"));
+        console.log(chalk.red("\n  ✗ Uso: gufi entity:automations:update <entityId> <json_file>\n"));
         process.exit(1);
     }
     const fs = await import("fs");
@@ -808,10 +1029,18 @@ export async function entityAutomationsUpdateCommand(entityId, jsonFile, options
     console.log(chalk.gray(`  Archivo: ${jsonFile}`));
     console.log(chalk.gray(`  Automations: ${automations.length}`));
     try {
-        const headers = {};
-        if (options?.company) {
-            headers["X-Company-ID"] = options.company;
+        // 💜 Auto-detect company
+        console.log(chalk.gray("  Detectando company..."));
+        const detected = await detectCompanyFromEntity(entityId);
+        if (!detected) {
+            console.log(chalk.red("  ✗ Entity no encontrada\n"));
+            process.exit(1);
         }
+        const companyId = detected.companyId;
+        console.log(chalk.gray(`  Company ${companyId} (auto-detected)\n`));
+        const headers = {
+            "X-Company-ID": companyId,
+        };
         const result = await apiRequest(`/api/entities/${entityId}/automations`, {
             method: "PUT",
             headers,
@@ -830,6 +1059,92 @@ export async function entityAutomationsUpdateCommand(entityId, jsonFile, options
 /**
  * Interactive editor for entity automations
  */
+// ════════════════════════════════════════════════════════════════════
+// gufi automations:meta - View automation_meta index (debugging)
+// ════════════════════════════════════════════════════════════════════
+export async function automationsMetaCommand(options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Automation Meta (Worker Index)\n"));
+    console.log(chalk.gray("  💡 Esta tabla se sincroniza automáticamente desde entities.automations\n"));
+    try {
+        const headers = {};
+        if (options?.company) {
+            headers["X-Company-ID"] = options.company;
+        }
+        const data = await apiRequest("/api/automation-meta", { headers });
+        const metas = Array.isArray(data) ? data : data.data || [];
+        if (!metas.length) {
+            console.log(chalk.gray("  Sin automations indexadas en esta company.\n"));
+            return;
+        }
+        console.log(chalk.gray("  Entity\t\tTrigger\t\tScript\t\t\tEstado"));
+        console.log(chalk.gray("  ─".repeat(50)));
+        for (const meta of metas) {
+            const entity = String(meta.entity_id).padEnd(8);
+            const trigger = (meta.trigger || "").padEnd(12);
+            const script = (meta.function_name || "").substring(0, 24).padEnd(24);
+            const status = meta.enabled !== false ? chalk.green("✓") : chalk.gray("○");
+            console.log(`  ${chalk.cyan(entity)}\t${trigger}\t${script}\t${status}`);
+        }
+        console.log(chalk.gray(`\n  Total: ${metas.length} automations indexadas`));
+        console.log(chalk.gray("  💡 Usa: gufi entity:automations <entityId> para editar triggers\n"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi automations:executions - View automation execution history
+// ════════════════════════════════════════════════════════════════════
+export async function automationsExecutionsCommand(options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Automation Executions (Historial)\n"));
+    try {
+        const headers = {};
+        if (options?.company) {
+            headers["X-Company-ID"] = options.company;
+        }
+        const limit = options?.limit || "20";
+        let url = `/api/automation-executions?limit=${limit}`;
+        if (options?.script) {
+            url += `&script=${encodeURIComponent(options.script)}`;
+        }
+        const data = await apiRequest(url, { headers });
+        const executions = Array.isArray(data) ? data : data.data || [];
+        if (!executions.length) {
+            console.log(chalk.gray("  Sin ejecuciones recientes.\n"));
+            return;
+        }
+        console.log(chalk.gray("  Fecha\t\t\t\tScript\t\t\t\tEstado\tDuración"));
+        console.log(chalk.gray("  ─".repeat(55)));
+        for (const exec of executions) {
+            const date = exec.created_at
+                ? new Date(exec.created_at).toLocaleString("es-ES", {
+                    day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit"
+                })
+                : "-";
+            const script = (exec.function_name || exec.script_name || "").substring(0, 28).padEnd(28);
+            const status = exec.status === "success" || exec.success
+                ? chalk.green("✓ ok")
+                : exec.status === "error" || exec.error
+                    ? chalk.red("✗ error")
+                    : chalk.yellow("⏳");
+            const duration = exec.duration_ms ? `${exec.duration_ms}ms` : "-";
+            console.log(`  ${date.padEnd(16)}\t${script}\t${status}\t${duration}`);
+        }
+        console.log(chalk.gray(`\n  Mostrando últimas ${executions.length} ejecuciones`));
+        console.log(chalk.gray("  💡 Usa: gufi automations:executions --limit 50 para ver más\n"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
 async function editEntityAutomations(entityId, currentAutomations, availableScripts, companyId) {
     const fs = await import("fs");
     const os = await import("os");
@@ -839,7 +1154,7 @@ async function editEntityAutomations(entityId, currentAutomations, availableScri
     const helpContent = {
         _help: [
             "Edita este array de automations y guarda el archivo.",
-            "Triggers: on_insert, on_update, on_delete, on_click, scheduled",
+            "Triggers: insert, update, delete, click, scheduled",
             "function_name: nombre del script en automation_scripts",
             "enabled: true/false para activar/pausar",
             "cron_pattern: solo para scheduled (ej: '0 9 * * *')",

package/dist/commands/packages.d.ts

@@ -0,0 +1,25 @@
+/**
+ * gufi packages - List and manage marketplace packages
+ * gufi package <id> - View package details
+ * gufi package:create <name> - Create new package
+ * gufi package:add-module <packageId> - Add module to package
+ * gufi package:publish <id> - Publish package
+ */
+export declare function packagesCommand(): Promise<void>;
+export declare function packageCommand(packageId?: string): Promise<void>;
+export declare function packageCreateCommand(name?: string, options?: {
+    description?: string;
+}): Promise<void>;
+export declare function packageDeleteCommand(packageId?: string): Promise<void>;
+export declare function packageAddModuleCommand(packageId?: string, options?: {
+    company?: string;
+    module?: string;
+}): Promise<void>;
+export declare function packageRemoveModuleCommand(packageId?: string, moduleId?: string): Promise<void>;
+export declare function packagePublishCommand(packageId?: string): Promise<void>;
+export declare function packageUnpublishCommand(packageId?: string): Promise<void>;
+export declare function packageSyncCommand(packageId?: string): Promise<void>;
+export declare function packageCheckCommand(packageId?: string): Promise<void>;
+export declare function packageViewsCommand(packageId?: string): Promise<void>;
+export declare function packageAddViewCommand(packageId?: string, viewId?: string): Promise<void>;
+export declare function packageRemoveViewCommand(packageId?: string, packageViewId?: string): Promise<void>;