gufi-cli 0.1.1 → 0.1.2

package/dist/commands/companies.d.ts

@@ -0,0 +1,26 @@
+/**
+ * gufi companies - List and manage companies
+ * gufi modules - List modules of a company
+ * gufi module - View/edit module JSON
+ */
+export declare function companiesCommand(): Promise<void>;
+export declare function modulesCommand(companyId?: string): Promise<void>;
+export declare function moduleCommand(moduleId?: string, options?: {
+    edit?: boolean;
+    company?: string;
+    file?: string;
+}): Promise<void>;
+export declare function moduleUpdateCommand(moduleId?: string, jsonFile?: string, options?: {
+    company?: string;
+    dryRun?: boolean;
+}): Promise<void>;
+export declare function companyCreateCommand(name?: string): Promise<void>;
+export declare function automationsCommand(_moduleId?: string, // Ignored - kept for backwards compatibility
+options?: {
+    company?: string;
+}): Promise<void>;
+export declare function automationCommand(automationName?: string, options?: {
+    edit?: boolean;
+    company?: string;
+    file?: string;
+}): Promise<void>;

package/dist/commands/companies.js

@@ -0,0 +1,513 @@
+/**
+ * gufi companies - List and manage companies
+ * gufi modules - List modules of a company
+ * gufi module - View/edit module JSON
+ */
+import chalk from "chalk";
+import { isLoggedIn, getApiUrl, getToken } from "../lib/config.js";
+const API_URL_BASE = "https://gogufi.com";
+async function apiRequest(path, options = {}) {
+    const token = getToken();
+    const apiUrl = getApiUrl() || API_URL_BASE;
+    const res = await fetch(`${apiUrl}${path}`, {
+        ...options,
+        headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+    if (!res.ok) {
+        const error = await res.text();
+        throw new Error(`API Error ${res.status}: ${error}`);
+    }
+    return res.json();
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi companies - List user's companies
+// ════════════════════════════════════════════════════════════════════
+export async function companiesCommand() {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Gufi Companies\n"));
+    try {
+        const data = await apiRequest("/api/companies");
+        const companies = data.items || data.data || data || [];
+        if (!companies.length) {
+            console.log(chalk.gray("  No tienes companies asignadas.\n"));
+            return;
+        }
+        console.log(chalk.gray("  ID\tNombre\t\t\t\tCreado"));
+        console.log(chalk.gray("  ─".repeat(35)));
+        for (const c of companies) {
+            const id = String(c.id).padEnd(4);
+            const name = (c.name || "").substring(0, 24).padEnd(24);
+            const created = c.created_at ? new Date(c.created_at).toLocaleDateString() : "-";
+            console.log(`  ${chalk.cyan(id)}\t${name}\t${created}`);
+        }
+        console.log(chalk.gray("\n  💡 Usa: gufi modules <company_id> para ver módulos\n"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi modules <company_id> - List modules of a company
+// ════════════════════════════════════════════════════════════════════
+export async function modulesCommand(companyId) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!companyId) {
+        console.log(chalk.red("\n  ✗ Uso: gufi modules <company_id>\n"));
+        console.log(chalk.gray("  Tip: Usa 'gufi companies' para ver tus companies\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta(`\n  🟣 Módulos de Company ${companyId}\n`));
+    try {
+        // Get company schema which includes all modules
+        const data = await apiRequest("/api/company/schema", {
+            headers: { "X-Company-ID": companyId },
+        });
+        const modules = data.modules || data.data?.modules || [];
+        if (!modules.length) {
+            console.log(chalk.gray("  No hay módulos en esta company.\n"));
+            return;
+        }
+        console.log(chalk.gray("  ID\tNombre\t\t\t\tEntidades"));
+        console.log(chalk.gray("  ─".repeat(40)));
+        for (const mod of modules) {
+            // Count entities across all submodules and find moduleId
+            let entityCount = 0;
+            let moduleId;
+            for (const sub of mod.submodules || []) {
+                for (const ent of sub.entities || []) {
+                    entityCount++;
+                    if (!moduleId && ent.ui?.moduleId) {
+                        moduleId = ent.ui.moduleId;
+                    }
+                }
+            }
+            const id = String(moduleId || "?").padEnd(5);
+            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"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// Helper: Get module from company schema
+// ════════════════════════════════════════════════════════════════════
+async function getModuleFromSchema(moduleId, companyId) {
+    const headers = {};
+    if (companyId) {
+        headers["X-Company-ID"] = companyId;
+    }
+    const data = await apiRequest("/api/company/schema", { headers });
+    const modules = data.modules || data.data?.modules || [];
+    // Find module by ID (from entity ui.moduleId) or by name
+    const module = modules.find((m) => {
+        // Check if any entity has the matching moduleId
+        for (const sub of m.submodules || []) {
+            for (const ent of sub.entities || []) {
+                if (String(ent.ui?.moduleId) === String(moduleId)) {
+                    return true;
+                }
+            }
+        }
+        // Also check by name
+        return m.name === moduleId;
+    });
+    if (!module) {
+        throw new Error(`Módulo ${moduleId} no encontrado en esta company`);
+    }
+    // Attach the moduleId to the module object for convenience
+    for (const sub of module.submodules || []) {
+        for (const ent of sub.entities || []) {
+            if (ent.ui?.moduleId) {
+                module._moduleId = ent.ui.moduleId;
+                break;
+            }
+        }
+        if (module._moduleId)
+            break;
+    }
+    return module;
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi module <module_id> [--edit] [--company <id>] - View/edit module JSON
+// ════════════════════════════════════════════════════════════════════
+export async function moduleCommand(moduleId, options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!moduleId) {
+        console.log(chalk.red("\n  ✗ Uso: gufi module <module_id> [--edit] [--company <id>]\n"));
+        process.exit(1);
+    }
+    const companyId = options?.company;
+    console.log(chalk.magenta(`\n  🟣 Módulo ${moduleId}\n`));
+    try {
+        // Get module from company schema
+        const module = await getModuleFromSchema(moduleId, companyId);
+        const actualModuleId = module._moduleId || moduleId;
+        // Show module info
+        console.log(chalk.white(`  ID: ${actualModuleId}`));
+        console.log(chalk.white(`  Nombre: ${module.name || "N/A"}`));
+        console.log(chalk.white(`  Label: ${module.displayName || module.label || module.name}`));
+        // Count entities
+        let entityCount = 0;
+        for (const sub of module.submodules || []) {
+            entityCount += (sub.entities || []).length;
+        }
+        console.log(chalk.white(`  Entidades: ${entityCount}`));
+        console.log();
+        // Build a clean JSON definition for editing
+        const jsonDef = {
+            name: module.name,
+            displayName: module.displayName || module.label,
+            icon: module.icon,
+            submodules: module.submodules,
+        };
+        if (options?.edit) {
+            // Edit mode - open in editor
+            await editModuleJson(String(actualModuleId), jsonDef, companyId);
+        }
+        else if (options?.file) {
+            // Save to file
+            const fs = await import("fs");
+            fs.writeFileSync(options.file, JSON.stringify(jsonDef, null, 2));
+            console.log(chalk.green(`  ✓ JSON guardado en: ${options.file}\n`));
+        }
+        else {
+            // Print JSON
+            console.log(chalk.gray("  JSON Definition:"));
+            console.log(chalk.gray("  ─".repeat(30)));
+            console.log(JSON.stringify(jsonDef, null, 2));
+            console.log(chalk.gray("\n  💡 Usa: gufi module <id> --edit para editar"));
+            console.log(chalk.gray("  💡 Usa: gufi module <id> --file out.json para guardar\n"));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// Edit module JSON interactively
+// ════════════════════════════════════════════════════════════════════
+async function editModuleJson(moduleId, currentJson, companyId) {
+    const fs = await import("fs");
+    const os = await import("os");
+    const path = await import("path");
+    const { spawn } = await import("child_process");
+    // Write to temp file
+    const tempFile = path.join(os.tmpdir(), `gufi-module-${moduleId}.json`);
+    fs.writeFileSync(tempFile, JSON.stringify(currentJson, null, 2));
+    console.log(chalk.gray(`  Abriendo editor... (${tempFile})`));
+    console.log(chalk.gray("  Guarda y cierra el editor para aplicar cambios.\n"));
+    // Determine editor
+    const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+    // Open editor
+    const child = spawn(editor, [tempFile], {
+        stdio: "inherit",
+        shell: true,
+    });
+    await new Promise((resolve, reject) => {
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Editor exited with code ${code}`));
+        });
+        child.on("error", reject);
+    });
+    // Read modified file
+    const newContent = fs.readFileSync(tempFile, "utf-8");
+    let newJson;
+    try {
+        newJson = JSON.parse(newContent);
+    }
+    catch (e) {
+        console.log(chalk.red("\n  ✗ JSON inválido. Cambios no guardados.\n"));
+        return;
+    }
+    // Check if changed
+    if (JSON.stringify(newJson) === JSON.stringify(currentJson)) {
+        console.log(chalk.gray("  Sin cambios.\n"));
+        fs.unlinkSync(tempFile);
+        return;
+    }
+    // Validate by calling updateModule (dry-run first)
+    console.log(chalk.yellow("  ⏳ Validando cambios..."));
+    try {
+        const headers = {};
+        if (companyId) {
+            headers["X-Company-ID"] = companyId;
+        }
+        // Call update endpoint
+        const result = await apiRequest(`/api/modules/${moduleId}`, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify({ json_definition: newJson }),
+        });
+        console.log(chalk.green("\n  ✓ Módulo actualizado correctamente!\n"));
+        // Show what changed
+        if (result.changes) {
+            console.log(chalk.gray("  Cambios aplicados:"));
+            for (const change of result.changes) {
+                console.log(chalk.gray(`    - ${change}`));
+            }
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error al actualizar: ${err.message}`));
+        console.log(chalk.gray(`  El archivo temporal se mantiene en: ${tempFile}\n`));
+        return;
+    }
+    // Cleanup temp file
+    fs.unlinkSync(tempFile);
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi module:update <module_id> <json_file> - Update module from file
+// ════════════════════════════════════════════════════════════════════
+export async function moduleUpdateCommand(moduleId, jsonFile, options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!moduleId || !jsonFile) {
+        console.log(chalk.red("\n  ✗ Uso: gufi module:update <module_id> <json_file> [--company <id>] [--dry-run]\n"));
+        process.exit(1);
+    }
+    const fs = await import("fs");
+    // Read JSON file
+    let newJson;
+    try {
+        const content = fs.readFileSync(jsonFile, "utf-8");
+        newJson = JSON.parse(content);
+    }
+    catch (e) {
+        console.log(chalk.red(`\n  ✗ Error leyendo archivo: ${e.message}\n`));
+        process.exit(1);
+    }
+    console.log(chalk.magenta(`\n  🟣 Actualizando módulo ${moduleId}\n`));
+    if (options?.dryRun) {
+        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;
+        }
+        // Validate first
+        console.log(chalk.gray("  Validando JSON..."));
+        const validateResult = await apiRequest(`/api/modules/${moduleId}/validate`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ json_definition: newJson }),
+        });
+        if (validateResult.errors?.length) {
+            console.log(chalk.red("\n  ✗ Errores de validación:"));
+            for (const err of validateResult.errors) {
+                console.log(chalk.red(`    - ${err}`));
+            }
+            console.log();
+            process.exit(1);
+        }
+        console.log(chalk.green("  ✓ JSON válido"));
+        if (options?.dryRun) {
+            console.log(chalk.gray("\n  [DRY RUN] Validación exitosa. Usa sin --dry-run para aplicar.\n"));
+            return;
+        }
+        // Apply changes
+        console.log(chalk.gray("  Aplicando cambios..."));
+        const result = await apiRequest(`/api/modules/${moduleId}`, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify({ json_definition: newJson }),
+        });
+        console.log(chalk.green("\n  ✓ Módulo actualizado correctamente!\n"));
+        if (result.tablesCreated?.length) {
+            console.log(chalk.gray("  Tablas creadas:"));
+            for (const t of result.tablesCreated) {
+                console.log(chalk.green(`    + ${t}`));
+            }
+        }
+        if (result.columnsAdded?.length) {
+            console.log(chalk.gray("  Columnas añadidas:"));
+            for (const c of result.columnsAdded) {
+                console.log(chalk.green(`    + ${c}`));
+            }
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+        process.exit(1);
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi company:create <name> - Create a new company
+// ════════════════════════════════════════════════════════════════════
+export async function companyCreateCommand(name) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!name) {
+        console.log(chalk.red("\n  ✗ Uso: gufi company:create <nombre>\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta(`\n  🟣 Creando company: ${name}\n`));
+    try {
+        const result = await apiRequest("/api/companies", {
+            method: "POST",
+            body: JSON.stringify({ name }),
+        });
+        const company = result.data || result;
+        console.log(chalk.green("  ✓ Company creada!\n"));
+        console.log(chalk.white(`  ID: ${company.id}`));
+        console.log(chalk.white(`  Nombre: ${company.name}`));
+        console.log(chalk.white(`  Schema: company_${company.id}`));
+        console.log(chalk.gray("\n  💡 Usa: gufi modules " + company.id + " para ver módulos\n"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi automations - List all automation scripts of a company
+// ════════════════════════════════════════════════════════════════════
+export async function automationsCommand(_moduleId, // Ignored - kept for backwards compatibility
+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 Scripts\n"));
+    try {
+        const headers = {};
+        if (options?.company) {
+            headers["X-Company-ID"] = options.company;
+        }
+        const data = await apiRequest("/api/automation-scripts", { headers });
+        const automations = Array.isArray(data) ? data : data.data || [];
+        if (!automations.length) {
+            console.log(chalk.gray("  No hay automation scripts en esta company.\n"));
+            return;
+        }
+        console.log(chalk.gray("  ID\tNombre\t\t\t\tDescripción"));
+        console.log(chalk.gray("  ─".repeat(45)));
+        for (const auto of automations) {
+            const id = String(auto.id).padEnd(4);
+            const name = (auto.name || "").substring(0, 28).padEnd(28);
+            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"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+// ════════════════════════════════════════════════════════════════════
+// gufi automation <name> [--edit] - View/edit automation code by name
+// ════════════════════════════════════════════════════════════════════
+export async function automationCommand(automationName, 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"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta(`\n  🟣 Automation: ${automationName}\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"));
+            return;
+        }
+        // Show info
+        console.log(chalk.white(`  Nombre: ${automation.name}`));
+        console.log(chalk.white(`  ID: ${automation.id}`));
+        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);
+        }
+        else if (options?.file) {
+            const fs = await import("fs");
+            fs.writeFileSync(options.file, jsCode);
+            console.log(chalk.green(`  ✓ Código guardado en: ${options.file}\n`));
+        }
+        else {
+            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"));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+    }
+}
+async function editAutomationCode(automationName, currentCode, companyId) {
+    const fs = await import("fs");
+    const os = await import("os");
+    const path = await import("path");
+    const { spawn } = await import("child_process");
+    // Safe filename
+    const safeName = automationName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const tempFile = path.join(os.tmpdir(), `gufi-automation-${safeName}.js`);
+    fs.writeFileSync(tempFile, currentCode);
+    console.log(chalk.gray(`  Abriendo editor... (${tempFile})`));
+    const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+    const child = spawn(editor, [tempFile], { stdio: "inherit", shell: true });
+    await new Promise((resolve, reject) => {
+        child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`Editor exit ${code}`)));
+        child.on("error", reject);
+    });
+    const newCode = fs.readFileSync(tempFile, "utf-8");
+    if (newCode === currentCode) {
+        console.log(chalk.gray("  Sin cambios.\n"));
+        fs.unlinkSync(tempFile);
+        return;
+    }
+    console.log(chalk.yellow("  ⏳ Guardando cambios..."));
+    try {
+        const headers = {};
+        if (companyId)
+            headers["X-Company-ID"] = companyId;
+        await apiRequest(`/api/automation-scripts/${encodeURIComponent(automationName)}`, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify({ code: newCode }),
+        });
+        console.log(chalk.green("\n  ✓ Automation actualizada!\n"));
+        fs.unlinkSync(tempFile);
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}`));
+        console.log(chalk.gray(`  Archivo temporal: ${tempFile}\n`));
+    }
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * gufi logs - Stream console logs from LivePreview in real-time
+ *
+ * The CLI connects to the Gufi WebSocket server and subscribes to
+ * dev-logs for a specific view. When the LivePreview is open in the
+ * browser, console logs are forwarded to the CLI.
+ */
+export declare function logsCommand(viewDir?: string): Promise<void>;