gufi-cli 0.1.9 → 0.1.10

package/CLAUDE.md

@@ -1569,6 +1569,28 @@ npm install -g gufi-cli
 gufi login
 ```
 
+### 💜 Autenticación Persistente
+
+El CLI guarda las credenciales en `~/.gufi/config.json` para auto-login automático:
+
+```json
+{
+  "apiUrl": "https://gogufi.com",
+  "token": "eyJ...",
+  "refreshToken": "eyJ...",
+  "email": "user@example.com",
+  "password": "secreto"
+}
+```
+
+**Flujo de autenticación:**
+1. Si hay token válido → lo usa
+2. Si token expirado + refreshToken válido → hace refresh automático
+3. Si ambos expirados → auto-login con email/password guardados
+4. Si no hay credenciales → pide `gufi login`
+
+**Importante:** Para persistencia completa, `gufi login` guarda email y password. Si haces login desde el navegador web, el refreshToken del CLI se invalida, pero el CLI hace auto-login automáticamente con las credenciales guardadas.
+
 ### Gestión de Companies y Módulos
 
 ```bash
@@ -1718,9 +1740,9 @@ gufi view:status
 
 | Error | Solución |
 |-------|----------|
-| "No estás logueado" | `gufi login` |
+| "No estás logueado" | `gufi login` (guarda credenciales para auto-login) |
 | "Módulo no encontrado" | Verificar `-c <company_id>` |
-| "Token expirado" | `gufi login` de nuevo |
+| "Token expirado" | Automático: refresh o auto-login con credenciales guardadas |
 | "JSON inválido" | Validar estructura del JSON |
 
 ### Conceptos clave

package/dist/commands/companies.d.ts

@@ -14,6 +14,9 @@ export declare function moduleUpdateCommand(moduleId?: string, jsonFile?: string
     company?: string;
     dryRun?: boolean;
 }): Promise<void>;
+export declare function moduleCreateCommand(jsonFile?: string, options?: {
+    company?: string;
+}): Promise<void>;
 export declare function companyCreateCommand(name?: string): Promise<void>;
 export declare function automationsCommand(_moduleId?: string, // Ignored - kept for backwards compatibility
 options?: {
@@ -24,3 +27,6 @@ export declare function automationCommand(automationName?: string, options?: {
     company?: string;
     file?: string;
 }): Promise<void>;
+export declare function automationCreateCommand(name?: string, jsFile?: string, options?: {
+    company?: string;
+}): Promise<void>;

package/dist/commands/companies.js

@@ -4,19 +4,81 @@
  * gufi module - View/edit module JSON
  */
 import chalk from "chalk";
-import { isLoggedIn, getApiUrl, getToken } from "../lib/config.js";
+import { isLoggedIn, getApiUrl, getToken, getRefreshToken, setToken, loadConfig } from "../lib/config.js";
 const API_URL_BASE = "https://gogufi.com";
-async function apiRequest(path, options = {}) {
-    const token = getToken();
+// 💜 Auto-login with saved credentials
+async function autoLogin() {
+    const config = loadConfig();
+    if (!config.email || !config.password) {
+        return undefined;
+    }
+    try {
+        console.log(chalk.gray("  [gufi] Auto-login..."));
+        const apiUrl = getApiUrl() || API_URL_BASE;
+        const response = await fetch(`${apiUrl}/api/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Client": "cli" },
+            body: JSON.stringify({ email: config.email, password: config.password }),
+        });
+        if (!response.ok)
+            return undefined;
+        const data = await response.json();
+        setToken(data.accessToken, config.email, data.refreshToken);
+        console.log(chalk.green("  [gufi] Auto-login exitoso"));
+        return data.accessToken;
+    }
+    catch {
+        return undefined;
+    }
+}
+// 💜 Refresh token or auto-login
+async function refreshOrLogin() {
+    const refreshToken = getRefreshToken();
+    const apiUrl = getApiUrl() || API_URL_BASE;
+    if (refreshToken) {
+        try {
+            const response = await fetch(`${apiUrl}/api/auth/refresh`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "X-Client": "cli", "X-Refresh-Token": refreshToken },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const config = loadConfig();
+                setToken(data.accessToken, config.email || "", data.refreshToken);
+                return data.accessToken;
+            }
+        }
+        catch { }
+    }
+    return autoLogin();
+}
+// 💜 API request with auto-login and refresh
+async function apiRequest(path, options = {}, retry = true) {
+    let token = getToken();
     const apiUrl = getApiUrl() || API_URL_BASE;
+    // If no token, try auto-login
+    if (!token) {
+        token = await autoLogin();
+        if (!token) {
+            throw new Error("No estás logueado. Usa: gufi login");
+        }
+    }
     const res = await fetch(`${apiUrl}${path}`, {
         ...options,
         headers: {
             "Authorization": `Bearer ${token}`,
             "Content-Type": "application/json",
+            "X-Client": "cli",
             ...options.headers,
         },
     });
+    // On 401/403, try refresh and retry once
+    if ((res.status === 401 || res.status === 403) && retry) {
+        const newToken = await refreshOrLogin();
+        if (newToken) {
+            return apiRequest(path, options, false);
+        }
+    }
     if (!res.ok) {
         const error = await res.text();
         throw new Error(`API Error ${res.status}: ${error}`);
@@ -251,11 +313,11 @@ async function editModuleJson(moduleId, currentJson, companyId) {
         if (companyId) {
             headers["X-Company-ID"] = companyId;
         }
-        // Call update endpoint
-        const result = await apiRequest(`/api/modules/${moduleId}`, {
+        // Call update endpoint (confirm: true to actually save)
+        const result = await apiRequest(`/api/company/modules/${moduleId}`, {
             method: "PUT",
             headers,
-            body: JSON.stringify({ json_definition: newJson }),
+            body: JSON.stringify({ json: newJson, confirm: true }),
         });
         console.log(chalk.green("\n  ✓ Módulo actualizado correctamente!\n"));
         // Show what changed
@@ -306,19 +368,10 @@ export async function moduleUpdateCommand(moduleId, jsonFile, options) {
         if (options?.company) {
             headers["X-Company-ID"] = options.company;
         }
-        // Validate first
+        // Validate JSON structure locally
         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();
+        if (!newJson.name && !newJson.displayName) {
+            console.log(chalk.red("\n  ✗ JSON debe tener 'name' o 'displayName'\n"));
             process.exit(1);
         }
         console.log(chalk.green("  ✓ JSON válido"));
@@ -326,12 +379,12 @@ export async function moduleUpdateCommand(moduleId, jsonFile, options) {
             console.log(chalk.gray("\n  [DRY RUN] Validación exitosa. Usa sin --dry-run para aplicar.\n"));
             return;
         }
-        // Apply changes
+        // Apply changes (confirm: true to actually save)
         console.log(chalk.gray("  Aplicando cambios..."));
-        const result = await apiRequest(`/api/modules/${moduleId}`, {
+        const result = await apiRequest(`/api/company/modules/${moduleId}`, {
             method: "PUT",
             headers,
-            body: JSON.stringify({ json_definition: newJson }),
+            body: JSON.stringify({ json: newJson, confirm: true }),
         });
         console.log(chalk.green("\n  ✓ Módulo actualizado correctamente!\n"));
         if (result.tablesCreated?.length) {
@@ -353,6 +406,68 @@ export async function moduleUpdateCommand(moduleId, jsonFile, options) {
     }
 }
 // ════════════════════════════════════════════════════════════════════
+// gufi module:create <json_file> --company <id> - Create module from JSON file
+// ════════════════════════════════════════════════════════════════════
+export async function moduleCreateCommand(jsonFile, options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!jsonFile) {
+        console.log(chalk.red("\n  ✗ Uso: gufi module:create <json_file> --company <id>\n"));
+        process.exit(1);
+    }
+    if (!options?.company) {
+        console.log(chalk.red("\n  ✗ Debes especificar --company <id>\n"));
+        console.log(chalk.gray("  Tip: Usa 'gufi companies' para ver tus companies\n"));
+        process.exit(1);
+    }
+    const fs = await import("fs");
+    // Read JSON file
+    let moduleJson;
+    try {
+        const content = fs.readFileSync(jsonFile, "utf-8");
+        moduleJson = JSON.parse(content);
+    }
+    catch (e) {
+        console.log(chalk.red(`\n  ✗ Error leyendo archivo: ${e.message}\n`));
+        process.exit(1);
+    }
+    const moduleName = moduleJson.displayName || moduleJson.label || moduleJson.name || "Nuevo Módulo";
+    console.log(chalk.magenta(`\n  🟣 Creando módulo: ${moduleName}\n`));
+    console.log(chalk.gray(`  Company: ${options.company}`));
+    try {
+        const headers = {
+            "X-Company-ID": options.company,
+        };
+        const result = await apiRequest("/api/company/modules", {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ json: moduleJson }),
+        });
+        const data = result.data || result;
+        console.log(chalk.green("\n  ✓ Módulo creado!\n"));
+        console.log(chalk.white(`  ID: ${data.moduleId || data.id || "N/A"}`));
+        if (data.tablesCreated?.length) {
+            console.log(chalk.gray("  Tablas creadas:"));
+            for (const t of data.tablesCreated) {
+                console.log(chalk.green(`    + ${t}`));
+            }
+        }
+        if (data.entities?.length) {
+            console.log(chalk.gray("  Entidades:"));
+            for (const ent of data.entities) {
+                console.log(chalk.white(`    - ${ent.name} (${ent.kind})`));
+            }
+        }
+        console.log(chalk.gray("\n  💡 Usa: gufi modules " + options.company + " para ver todos los módulos\n"));
+    }
+    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) {
@@ -472,6 +587,52 @@ export async function automationCommand(automationName, options) {
         console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
     }
 }
+// ════════════════════════════════════════════════════════════════════
+// gufi automation:create <name> <js_file> --company <id> - Create/update automation from file
+// ════════════════════════════════════════════════════════════════════
+export async function automationCreateCommand(name, jsFile, options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!name || !jsFile) {
+        console.log(chalk.red("\n  ✗ Uso: gufi automation:create <nombre> <archivo.js> --company <id>\n"));
+        process.exit(1);
+    }
+    if (!options?.company) {
+        console.log(chalk.red("\n  ✗ Debes especificar --company <id>\n"));
+        process.exit(1);
+    }
+    const fs = await import("fs");
+    let code;
+    try {
+        code = fs.readFileSync(jsFile, "utf-8");
+    }
+    catch (e) {
+        console.log(chalk.red(`\n  ✗ Error leyendo archivo: ${e.message}\n`));
+        process.exit(1);
+    }
+    console.log(chalk.magenta(`\n  🟣 Creando automation: ${name}\n`));
+    console.log(chalk.gray(`  Company: ${options.company}`));
+    try {
+        const headers = {
+            "X-Company-ID": options.company,
+        };
+        const result = await apiRequest(`/api/automation-scripts/${encodeURIComponent(name)}`, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify({ code }),
+        });
+        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"));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+        process.exit(1);
+    }
+}
 async function editAutomationCode(automationName, currentCode, companyId) {
     const fs = await import("fs");
     const os = await import("os");

package/dist/commands/env.js

@@ -4,11 +4,55 @@
  */
 import chalk from "chalk";
 import ora from "ora";
-import { getToken, getApiUrl } from "../lib/config.js";
-async function apiRequest(endpoint, options = {}) {
-    const token = getToken();
+import { getToken, getApiUrl, getRefreshToken, setToken, loadConfig } from "../lib/config.js";
+// 💜 Auto-login with saved credentials
+async function autoLogin() {
+    const config = loadConfig();
+    if (!config.email || !config.password)
+        return undefined;
+    try {
+        const response = await fetch(`${getApiUrl()}/api/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Client": "cli" },
+            body: JSON.stringify({ email: config.email, password: config.password }),
+        });
+        if (!response.ok)
+            return undefined;
+        const data = await response.json();
+        setToken(data.accessToken, config.email, data.refreshToken);
+        return data.accessToken;
+    }
+    catch {
+        return undefined;
+    }
+}
+// 💜 Refresh token or auto-login
+async function refreshOrLogin() {
+    const refreshToken = getRefreshToken();
+    if (refreshToken) {
+        try {
+            const response = await fetch(`${getApiUrl()}/api/auth/refresh`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "X-Client": "cli", "X-Refresh-Token": refreshToken },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const config = loadConfig();
+                setToken(data.accessToken, config.email || "", data.refreshToken);
+                return data.accessToken;
+            }
+        }
+        catch { }
+    }
+    return autoLogin();
+}
+// 💜 API request with auto-login and refresh
+async function apiRequest(endpoint, options = {}, retry = true) {
+    let token = getToken();
     if (!token) {
-        throw new Error("No estás logueado. Ejecuta: gufi login");
+        token = await autoLogin();
+        if (!token)
+            throw new Error("No estás logueado. Ejecuta: gufi login");
     }
     const url = `${getApiUrl()}${endpoint}`;
     const response = await fetch(url, {
@@ -20,6 +64,11 @@ async function apiRequest(endpoint, options = {}) {
             ...options.headers,
         },
     });
+    if ((response.status === 401 || response.status === 403) && retry) {
+        const newToken = await refreshOrLogin();
+        if (newToken)
+            return apiRequest(endpoint, options, false);
+    }
     if (!response.ok) {
         const text = await response.text();
         throw new Error(`API Error ${response.status}: ${text}`);

package/dist/commands/login.js

@@ -5,7 +5,7 @@ import prompts from "prompts";
 import chalk from "chalk";
 import ora from "ora";
 import { login, validateToken } from "../lib/api.js";
-import { setToken, isLoggedIn, clearToken, loadConfig, setApiUrl } from "../lib/config.js";
+import { setToken, isLoggedIn, clearToken, loadConfig, setApiUrl, saveConfig } from "../lib/config.js";
 export async function loginCommand(options) {
     console.log(chalk.magenta("\n  🟣 Gufi Developer CLI\n"));
     // Set custom API URL if provided
@@ -62,8 +62,12 @@ export async function loginCommand(options) {
             console.log(chalk.yellow("\n  ⚠️  No se recibió refresh token - sesión durará 1 hora"));
         }
         setToken(token, response.email, refreshToken);
+        // 💜 Persist credentials for auto-login when token expires
+        const config = loadConfig();
+        config.password = response.password;
+        saveConfig(config);
         spinner.succeed(chalk.green(`Sesión iniciada como ${response.email}`));
-        console.log(chalk.gray("\n  Tu sesión se mantendrá activa automáticamente (7 días).\n"));
+        console.log(chalk.gray("\n  Tu sesión se mantendrá activa automáticamente.\n"));
         console.log(chalk.gray("  Ahora puedes usar: gufi pull <vista>\n"));
     }
     catch (error) {

package/dist/commands/rows.js

@@ -5,11 +5,55 @@
 import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
-import { getToken, getApiUrl } from "../lib/config.js";
-async function apiRequest(endpoint, options = {}) {
-    const token = getToken();
+import { getToken, getApiUrl, loadConfig, getRefreshToken, setToken } from "../lib/config.js";
+// 💜 Auto-login with saved credentials
+async function autoLogin() {
+    const config = loadConfig();
+    if (!config.email || !config.password)
+        return undefined;
+    try {
+        const response = await fetch(`${getApiUrl()}/api/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Client": "cli" },
+            body: JSON.stringify({ email: config.email, password: config.password }),
+        });
+        if (!response.ok)
+            return undefined;
+        const data = await response.json();
+        setToken(data.accessToken, config.email, data.refreshToken);
+        return data.accessToken;
+    }
+    catch {
+        return undefined;
+    }
+}
+// 💜 Refresh token or auto-login
+async function refreshOrLogin() {
+    const refreshToken = getRefreshToken();
+    if (refreshToken) {
+        try {
+            const response = await fetch(`${getApiUrl()}/api/auth/refresh`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "X-Client": "cli", "X-Refresh-Token": refreshToken },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const config = loadConfig();
+                setToken(data.accessToken, config.email || "", data.refreshToken);
+                return data.accessToken;
+            }
+        }
+        catch { }
+    }
+    return autoLogin();
+}
+// 💜 API request with auto-login and refresh
+async function apiRequest(endpoint, options = {}, retry = true) {
+    let token = getToken();
     if (!token) {
-        throw new Error("No estás logueado. Ejecuta: gufi login");
+        token = await autoLogin();
+        if (!token)
+            throw new Error("No estás logueado. Ejecuta: gufi login");
     }
     const url = `${getApiUrl()}${endpoint}`;
     const response = await fetch(url, {
@@ -21,6 +65,11 @@ async function apiRequest(endpoint, options = {}) {
             ...options.headers,
         },
     });
+    if ((response.status === 401 || response.status === 403) && retry) {
+        const newToken = await refreshOrLogin();
+        if (newToken)
+            return apiRequest(endpoint, options, false);
+    }
     if (!response.ok) {
         const text = await response.text();
         throw new Error(`API Error ${response.status}: ${text}`);

package/dist/index.d.ts

@@ -17,6 +17,7 @@
  *   gufi modules <id>       List modules of a company
  *   gufi module <id>        View/edit module JSON (--edit, --file)
  *   gufi module:update      Update module from JSON file
+ *   gufi module:create      Create module from JSON file
  *   gufi company:create     Create a new company
  *   gufi automations        List automation scripts
  *   gufi automation <name>  View/edit automation code (--edit, --file)

package/dist/index.js

@@ -17,6 +17,7 @@
  *   gufi modules <id>       List modules of a company
  *   gufi module <id>        View/edit module JSON (--edit, --file)
  *   gufi module:update      Update module from JSON file
+ *   gufi module:create      Create module from JSON file
  *   gufi company:create     Create a new company
  *   gufi automations        List automation scripts
  *   gufi automation <name>  View/edit automation code (--edit, --file)
@@ -37,7 +38,7 @@ import { pushCommand, statusCommand } from "./commands/push.js";
 import { watchCommand } from "./commands/watch.js";
 import { listCommand } from "./commands/list.js";
 import { logsCommand } from "./commands/logs.js";
-import { companiesCommand, modulesCommand, moduleCommand, moduleUpdateCommand, companyCreateCommand, automationsCommand, automationCommand, } from "./commands/companies.js";
+import { companiesCommand, modulesCommand, moduleCommand, moduleUpdateCommand, moduleCreateCommand, companyCreateCommand, automationsCommand, automationCommand, automationCreateCommand, } from "./commands/companies.js";
 import { rowsListCommand, rowGetCommand, rowCreateCommand, rowUpdateCommand, rowDeleteCommand, rowDuplicateCommand, rowsBulkCreateCommand, } from "./commands/rows.js";
 import { envListCommand, envSetCommand, envDeleteCommand, schemaCommand, } from "./commands/env.js";
 const program = new Command();
@@ -94,6 +95,11 @@ program
     .option("-c, --company <id>", "ID de company")
     .option("--dry-run", "Validar sin guardar")
     .action(moduleUpdateCommand);
+program
+    .command("module:create <json_file>")
+    .description("Crear módulo desde archivo JSON")
+    .option("-c, --company <id>", "ID de company (requerido)")
+    .action(moduleCreateCommand);
 // ════════════════════════════════════════════════════════════════════
 // ⚡ Automations
 // ════════════════════════════════════════════════════════════════════
@@ -109,6 +115,11 @@ program
     .option("-c, --company <id>", "ID de company")
     .option("-f, --file <path>", "Exportar a archivo")
     .action(automationCommand);
+program
+    .command("automation:create <name> <js_file>")
+    .description("Crear/actualizar automation desde archivo JS")
+    .option("-c, --company <id>", "ID de company (requerido)")
+    .action(automationCreateCommand);
 // ════════════════════════════════════════════════════════════════════
 // 🔐 Environment Variables
 // ════════════════════════════════════════════════════════════════════

package/dist/lib/api.js

@@ -11,42 +11,64 @@ class ApiError extends Error {
         this.name = "ApiError";
     }
 }
+// 💜 Auto-login with saved credentials
+async function autoLogin() {
+    const config = loadConfig();
+    if (!config.email || !config.password) {
+        console.error("[gufi] No saved credentials for auto-login");
+        return undefined;
+    }
+    try {
+        console.log("[gufi] Auto-login with saved credentials...");
+        const { token, refreshToken } = await login(config.email, config.password);
+        setToken(token, config.email, refreshToken);
+        console.log("[gufi] Auto-login successful");
+        return token;
+    }
+    catch (err) {
+        console.error("[gufi] Auto-login failed:", err);
+        return undefined;
+    }
+}
 // Auto-refresh the token if expired
 async function refreshAccessToken() {
     const refreshToken = getRefreshToken();
-    if (!refreshToken) {
-        console.error("[gufi] No refresh token available");
-        return null;
-    }
-    try {
-        const url = `${getApiUrl()}/api/auth/refresh`;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "X-Client": "cli",
-                "X-Refresh-Token": refreshToken,
-            },
-        });
-        if (!response.ok) {
+    // Try refresh token first
+    if (refreshToken) {
+        try {
+            const url = `${getApiUrl()}/api/auth/refresh`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Client": "cli",
+                    "X-Refresh-Token": refreshToken,
+                },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const config = loadConfig();
+                setToken(data.accessToken, config.email || "", data.refreshToken);
+                console.log("[gufi] Token refreshed successfully");
+                return data.accessToken;
+            }
             console.error(`[gufi] Refresh failed: ${response.status}`);
-            return null;
         }
-        const data = await response.json();
-        const config = loadConfig();
-        setToken(data.accessToken, config.email || "", data.refreshToken);
-        console.log("[gufi] Token refreshed successfully");
-        return data.accessToken;
-    }
-    catch (err) {
-        console.error("[gufi] Refresh error:", err);
-        return null;
+        catch (err) {
+            console.error("[gufi] Refresh error:", err);
+        }
     }
+    // 💜 Fallback: auto-login with saved credentials
+    return autoLogin();
 }
 async function request(endpoint, options = {}, retryOnExpire = true) {
     let token = getToken();
+    // 💜 If no token, try auto-login with saved credentials
     if (!token) {
-        throw new Error("No estás logueado. Ejecuta: gufi login");
+        token = await autoLogin();
+        if (!token) {
+            throw new Error("No estás logueado. Usa: gufi login");
+        }
     }
     const url = `${getApiUrl()}${endpoint}`;
     const response = await fetch(url, {

package/dist/lib/config.d.ts

@@ -7,6 +7,7 @@ export interface GufiConfig {
     token?: string;
     refreshToken?: string;
     email?: string;
+    password?: string;
     currentView?: {
         id: number;
         name: string;

package/dist/lib/config.js

@@ -57,10 +57,13 @@ export function clearToken() {
     delete config.token;
     delete config.refreshToken;
     delete config.email;
+    delete config.password; // 💜 Also clear saved credentials on logout
     saveConfig(config);
 }
 export function isLoggedIn() {
-    return !!getToken();
+    // 💜 True if has token OR has saved credentials for auto-login
+    const config = loadConfig();
+    return !!getToken() || !!(config.email && config.password);
 }
 export function setCurrentView(view) {
     const config = loadConfig();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gufi-cli",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "CLI for developing Gufi Marketplace views locally with Claude Code",
   "bin": {
     "gufi": "./bin/gufi.js"