gufi-cli 0.1.2 → 0.1.4

package/CLAUDE.md

@@ -987,16 +987,117 @@ interface GufiProps {
 
 ---
 
+### 💜 seedData - Datos de Ejemplo para Demo/Testing
+
+Las vistas pueden incluir datos de ejemplo que se cargan automáticamente al instalar. Esto es útil para demos, testing, y onboarding de nuevos usuarios.
+
+```typescript
+// metadata/seedData.ts
+export interface SeedDataConfig {
+  description: { es: string; en: string };
+  data: { [dataSourceKey: string]: Array<Record<string, any>> };
+  order: string[];  // Orden de creación (importante para referencias)
+}
+
+export const seedData: SeedDataConfig = {
+  description: {
+    es: 'Crea empresas de ejemplo (Singular, FitVending), proyectos y tareas de prueba',
+    en: 'Creates sample companies, projects and test tasks',
+  },
+
+  // Orden de creación - tablas con referencias van después
+  order: ['empresasTable', 'proyectosTable', 'tareasTable'],
+
+  data: {
+    // Empresas/Clientes
+    empresasTable: [
+      {
+        nombre: 'Singular',
+        contacto: 'Contacto Singular',
+        email: 'contacto@singular.es',
+        estado: 'activo'
+      },
+      {
+        nombre: 'FitVending',
+        contacto: 'Equipo FitVending',
+        email: 'info@fitvending.es',
+        estado: 'activo'
+      },
+    ],
+
+    // Proyectos
+    proyectosTable: [
+      {
+        nombre: 'Gufi ERP',
+        descripcion: 'Desarrollo del ERP Gufi',
+        color: '#8B5CF6',
+        estado: 'activo',
+      },
+    ],
+
+    // Tareas - con referencias a otras tablas
+    tareasTable: [
+      {
+        titulo: 'Revisar bug crítico',
+        descripcion: 'Los usuarios reportan problemas',
+        asignado_a: '@currentUser',      // 💜 Token especial: usuario actual
+        asignado_por: '@currentUser',
+        prioridad: 'urgente',
+        estado: 'pendiente',
+        fecha_limite: '@today',           // 💜 Token especial: fecha de hoy
+        proyecto_id: '@ref:proyectosTable.0',  // 💜 Referencia: ID del primer proyecto
+        empresa_id: '@ref:empresasTable.0',    // 💜 Referencia: ID de primera empresa
+      },
+      {
+        titulo: 'Preparar demo',
+        descripcion: 'Demo del módulo de facturación',
+        asignado_a: '@currentUser',
+        prioridad: 'alta',
+        fecha_limite: '@tomorrow',        // 💜 Token especial: mañana
+        empresa_id: '@ref:empresasTable.1',
+      },
+    ],
+  },
+};
+```
+
+**Tokens Especiales:**
+| Token | Descripción |
+|-------|-------------|
+| `@currentUser` | ID del usuario actual (para campos users) |
+| `@today` | Fecha de hoy (YYYY-MM-DD) |
+| `@tomorrow` | Fecha de mañana |
+| `@nextWeek` | Fecha dentro de 7 días |
+| `@ref:tableKey.index` | ID del registro creado en otra tabla |
+
+**Agregar a featureConfig:**
+```typescript
+// core/dataProvider.ts
+import { seedData } from '../metadata/seedData';
+
+export const featureConfig = {
+  dataSources,
+  inputs: featureInputs,
+  seedData,  // 💜 Agregar aquí
+};
+```
+
+**Cargar desde Developer Center:**
+En la página de edición de vista, el Developer Center muestra un botón "Load Sample Data" que ejecuta el seedData en la company seleccionada.
+
+---
+
 ### 💜 Checklist para Nueva Vista
 
 1. [ ] `core/dataProvider.ts` - dataSources + export featureConfig
 2. [ ] `metadata/inputs.ts` - featureInputs configurables
-3. [ ] `metadata/help.es.ts` y `help.en.ts` - Documentación
-4. [ ] `index.tsx` - export featureConfig y default component
-5. [ ] Usar `gufi?.context?.viewSpec` para tablas e inputs
-6. [ ] Usar `gufi?.dataProvider` para CRUD
-7. [ ] Usar `gufi?.utils?.toast*` para notificaciones
-8. [ ] Si hay automation: carpeta `automations/` con .js
+3. [ ] `metadata/seedData.ts` - Datos de ejemplo (opcional pero recomendado)
+4. [ ] `metadata/help.es.ts` y `help.en.ts` - Documentación
+5. [ ] `index.tsx` - export featureConfig y default component
+6. [ ] Usar `gufi?.context?.viewSpec` para tablas e inputs
+7. [ ] Usar `gufi?.dataProvider` para CRUD
+8. [ ] Usar `gufi?.utils?.toast*` para notificaciones
+9. [ ] Si hay automation: carpeta `automations/` con .js
 
 ### View.tsx - Componente Principal
 
@@ -1318,6 +1419,36 @@ gufi automation calcular_stock -c 116 --edit
 gufi automation calcular_stock -c 116 --file script.js
 ```
 
+### Row CRUD (Datos de Tablas)
+
+```bash
+# Listar registros de una tabla
+gufi rows m360_t16192                    # Últimos 20 registros
+gufi rows m360_t16192 -l 50              # Últimos 50 registros
+gufi rows m360_t16192 -f estado=activo   # Filtrar por campo
+
+# Ver un registro específico
+gufi row m360_t16192 123
+
+# Crear registro
+gufi row:create m360_t16192 --data '{"nombre":"Test","estado":"activo"}'
+gufi row:create m360_t16192 --file nuevo.json
+
+# Actualizar registro
+gufi row:update m360_t16192 123 --data '{"estado":"completado"}'
+gufi row:update m360_t16192 123 --file cambios.json
+
+# Eliminar registro
+gufi row:delete m360_t16192 123
+
+# Duplicar registro (copia sin id/timestamps)
+gufi row:duplicate m360_t16192 123
+
+# Crear múltiples registros desde archivo JSON
+gufi rows:create m360_t16192 --file datos.json
+# datos.json debe ser un array: [{"nombre":"A"},{"nombre":"B"}]
+```
+
 ### Desarrollo de Views
 
 ```bash

package/dist/commands/login.js

@@ -82,10 +82,11 @@ export async function loginCommand(options) {
     }
     const spinner = ora("Iniciando sesión...").start();
     try {
-        const { token } = await login(email, password);
-        setToken(token, email);
+        const { token, refreshToken } = await login(email, password);
+        setToken(token, email, refreshToken);
         spinner.succeed(chalk.green(`Sesión iniciada como ${email}`));
-        console.log(chalk.gray("\n  Ahora puedes usar: gufi pull <vista>\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) {
         spinner.fail(chalk.red(error.message || "Error al iniciar sesión"));

package/dist/commands/rows.d.ts

@@ -0,0 +1,46 @@
+/**
+ * gufi rows - CRUD operations on table rows
+ * For quick testing and data manipulation
+ */
+interface RowsOptions {
+    company?: string;
+    limit?: string;
+    offset?: string;
+    sort?: string;
+    order?: string;
+    filter?: string;
+}
+interface RowOptions {
+    company?: string;
+    data?: string;
+    file?: string;
+}
+/**
+ * gufi rows <table> - List rows from a table
+ */
+export declare function rowsListCommand(table: string, options: RowsOptions): Promise<void>;
+/**
+ * gufi row <table> <id> - Get a single row
+ */
+export declare function rowGetCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:create <table> --data '{...}' - Create a row
+ */
+export declare function rowCreateCommand(table: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:update <table> <id> --data '{...}' - Update a row
+ */
+export declare function rowUpdateCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:delete <table> <id> - Delete a row
+ */
+export declare function rowDeleteCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi row:duplicate <table> <id> - Duplicate a row
+ */
+export declare function rowDuplicateCommand(table: string, id: string, options: RowOptions): Promise<void>;
+/**
+ * gufi rows:create <table> --file datos.json - Bulk create rows
+ */
+export declare function rowsBulkCreateCommand(table: string, options: RowOptions): Promise<void>;
+export {};

package/dist/commands/rows.js

@@ -0,0 +1,243 @@
+/**
+ * gufi rows - CRUD operations on table rows
+ * For quick testing and data manipulation
+ */
+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();
+    if (!token) {
+        throw new Error("No estás logueado. Ejecuta: gufi login");
+    }
+    const url = `${getApiUrl()}${endpoint}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            "X-Client": "cli",
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API Error ${response.status}: ${text}`);
+    }
+    return response.json();
+}
+/**
+ * gufi rows <table> - List rows from a table
+ */
+export async function rowsListCommand(table, options) {
+    const spinner = ora("Cargando registros...").start();
+    try {
+        const limit = options.limit || "20";
+        const offset = options.offset || "0";
+        const sort = options.sort || "id";
+        const order = options.order || "DESC";
+        let endpoint = `/api/tables/${table}?_start=${offset}&_end=${parseInt(offset) + parseInt(limit)}&_sort=${sort}&_order=${order}`;
+        if (options.filter) {
+            // Parse filter like "estado=pendiente"
+            const [field, value] = options.filter.split("=");
+            if (field && value) {
+                endpoint += `&${field}=${encodeURIComponent(value)}`;
+            }
+        }
+        const data = await apiRequest(endpoint);
+        spinner.stop();
+        console.log(chalk.magenta(`\n  📋 ${table}\n`));
+        if (!data || data.length === 0) {
+            console.log(chalk.gray("  No hay registros\n"));
+            return;
+        }
+        // Show as table
+        const rows = Array.isArray(data) ? data : [data];
+        // Get columns from first row
+        const columns = Object.keys(rows[0]).slice(0, 6); // Max 6 columns
+        // Header
+        console.log(chalk.gray("  " + columns.map((c) => c.padEnd(15)).join(" ")));
+        console.log(chalk.gray("  " + "─".repeat(columns.length * 16)));
+        // Rows
+        for (const row of rows) {
+            const values = columns.map((col) => {
+                let val = row[col];
+                if (val === null || val === undefined)
+                    val = "-";
+                if (typeof val === "object")
+                    val = JSON.stringify(val).slice(0, 12);
+                return String(val).slice(0, 14).padEnd(15);
+            });
+            console.log("  " + values.join(" "));
+        }
+        console.log(chalk.gray(`\n  Total: ${rows.length} registros\n`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row <table> <id> - Get a single row
+ */
+export async function rowGetCommand(table, id, options) {
+    const spinner = ora("Cargando registro...").start();
+    try {
+        const data = await apiRequest(`/api/tables/${table}/${id}`);
+        spinner.stop();
+        console.log(chalk.magenta(`\n  📄 ${table} #${id}\n`));
+        console.log(JSON.stringify(data, null, 2));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:create <table> --data '{...}' - Create a row
+ */
+export async function rowCreateCommand(table, options) {
+    const spinner = ora("Creando registro...").start();
+    try {
+        let data;
+        if (options.file) {
+            const content = fs.readFileSync(options.file, "utf-8");
+            data = JSON.parse(content);
+        }
+        else if (options.data) {
+            data = JSON.parse(options.data);
+        }
+        else {
+            spinner.fail(chalk.red("Usa --data '{...}' o --file datos.json"));
+            process.exit(1);
+        }
+        const result = await apiRequest(`/api/tables/${table}`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+        spinner.succeed(chalk.green(`Registro creado: ID ${result.id || result.data?.id}`));
+        console.log(chalk.gray(JSON.stringify(result.data || result, null, 2)));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:update <table> <id> --data '{...}' - Update a row
+ */
+export async function rowUpdateCommand(table, id, options) {
+    const spinner = ora("Actualizando registro...").start();
+    try {
+        let data;
+        if (options.file) {
+            const content = fs.readFileSync(options.file, "utf-8");
+            data = JSON.parse(content);
+        }
+        else if (options.data) {
+            data = JSON.parse(options.data);
+        }
+        else {
+            spinner.fail(chalk.red("Usa --data '{...}' o --file datos.json"));
+            process.exit(1);
+        }
+        const result = await apiRequest(`/api/tables/${table}/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(data),
+        });
+        spinner.succeed(chalk.green(`Registro #${id} actualizado`));
+        console.log(chalk.gray(JSON.stringify(result.data || result, null, 2)));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:delete <table> <id> - Delete a row
+ */
+export async function rowDeleteCommand(table, id, options) {
+    const spinner = ora("Eliminando registro...").start();
+    try {
+        await apiRequest(`/api/tables/${table}/${id}`, {
+            method: "DELETE",
+        });
+        spinner.succeed(chalk.green(`Registro #${id} eliminado`));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi row:duplicate <table> <id> - Duplicate a row
+ */
+export async function rowDuplicateCommand(table, id, options) {
+    const spinner = ora("Duplicando registro...").start();
+    try {
+        // Get original row
+        const original = await apiRequest(`/api/tables/${table}/${id}`);
+        // Remove id and timestamps
+        const { id: _, created_at, updated_at, ...data } = original;
+        // Create new row
+        const result = await apiRequest(`/api/tables/${table}`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+        spinner.succeed(chalk.green(`Registro duplicado: #${id} → #${result.id || result.data?.id}`));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+/**
+ * gufi rows:create <table> --file datos.json - Bulk create rows
+ */
+export async function rowsBulkCreateCommand(table, options) {
+    if (!options.file) {
+        console.log(chalk.red("\n  ✗ Usa --file datos.json\n"));
+        process.exit(1);
+    }
+    const spinner = ora("Creando registros...").start();
+    try {
+        const content = fs.readFileSync(options.file, "utf-8");
+        const rows = JSON.parse(content);
+        if (!Array.isArray(rows)) {
+            spinner.fail(chalk.red("El archivo debe contener un array de objetos"));
+            process.exit(1);
+        }
+        let created = 0;
+        let errors = 0;
+        for (const row of rows) {
+            try {
+                await apiRequest(`/api/tables/${table}`, {
+                    method: "POST",
+                    body: JSON.stringify(row),
+                });
+                created++;
+                spinner.text = `Creando registros... ${created}/${rows.length}`;
+            }
+            catch {
+                errors++;
+            }
+        }
+        if (errors === 0) {
+            spinner.succeed(chalk.green(`${created} registros creados`));
+        }
+        else {
+            spinner.warn(chalk.yellow(`${created} creados, ${errors} errores`));
+        }
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -20,5 +20,14 @@
  *   gufi company:create     Create a new company
  *   gufi automations        List automation scripts
  *   gufi automation <name>  View/edit automation code (--edit, --file)
+ *
+ * Row CRUD Commands:
+ *   gufi rows <table>           List rows from a table
+ *   gufi row <table> <id>       Get a single row
+ *   gufi row:create <table>     Create a new row (--data or --file)
+ *   gufi row:update <table> <id> Update a row (--data or --file)
+ *   gufi row:delete <table> <id> Delete a row
+ *   gufi row:duplicate <table> <id> Duplicate a row
+ *   gufi rows:create <table>    Bulk create from JSON file
  */
 export {};

package/dist/index.js

@@ -20,6 +20,15 @@
  *   gufi company:create     Create a new company
  *   gufi automations        List automation scripts
  *   gufi automation <name>  View/edit automation code (--edit, --file)
+ *
+ * Row CRUD Commands:
+ *   gufi rows <table>           List rows from a table
+ *   gufi row <table> <id>       Get a single row
+ *   gufi row:create <table>     Create a new row (--data or --file)
+ *   gufi row:update <table> <id> Update a row (--data or --file)
+ *   gufi row:delete <table> <id> Delete a row
+ *   gufi row:duplicate <table> <id> Duplicate a row
+ *   gufi rows:create <table>    Bulk create from JSON file
  */
 import { Command } from "commander";
 import { loginCommand, logoutCommand, whoamiCommand } from "./commands/login.js";
@@ -29,6 +38,7 @@ 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 { rowsListCommand, rowGetCommand, rowCreateCommand, rowUpdateCommand, rowDeleteCommand, rowDuplicateCommand, rowsBulkCreateCommand, } from "./commands/rows.js";
 const program = new Command();
 program
     .name("gufi")
@@ -114,4 +124,45 @@ program
     .option("-c, --company <id>", "Company ID (if not default)")
     .option("-f, --file <path>", "Save code to file")
     .action(automationCommand);
+// ════════════════════════════════════════════════════════════════════
+// Row CRUD Commands - Create, Read, Update, Delete rows
+// ════════════════════════════════════════════════════════════════════
+program
+    .command("rows <table>")
+    .description("List rows from a table")
+    .option("-l, --limit <n>", "Number of rows to fetch", "20")
+    .option("-o, --offset <n>", "Starting offset", "0")
+    .option("-s, --sort <field>", "Sort by field", "id")
+    .option("--order <dir>", "Sort order (ASC/DESC)", "DESC")
+    .option("-f, --filter <expr>", "Filter expression (field=value)")
+    .action(rowsListCommand);
+program
+    .command("row <table> <id>")
+    .description("Get a single row by ID")
+    .action(rowGetCommand);
+program
+    .command("row:create <table>")
+    .description("Create a new row")
+    .option("-d, --data <json>", "JSON data for the row")
+    .option("-f, --file <path>", "JSON file with row data")
+    .action(rowCreateCommand);
+program
+    .command("row:update <table> <id>")
+    .description("Update a row by ID")
+    .option("-d, --data <json>", "JSON data to update")
+    .option("-f, --file <path>", "JSON file with update data")
+    .action(rowUpdateCommand);
+program
+    .command("row:delete <table> <id>")
+    .description("Delete a row by ID")
+    .action(rowDeleteCommand);
+program
+    .command("row:duplicate <table> <id>")
+    .description("Duplicate an existing row")
+    .action(rowDuplicateCommand);
+program
+    .command("rows:create <table>")
+    .description("Bulk create rows from JSON file")
+    .option("-f, --file <path>", "JSON file with array of rows")
+    .action(rowsBulkCreateCommand);
 program.parse();

package/dist/lib/api.d.ts

@@ -25,6 +25,7 @@ export interface Package {
 }
 export declare function login(email: string, password: string): Promise<{
     token: string;
+    refreshToken?: string;
 }>;
 export declare function listPackages(): Promise<Package[]>;
 export declare function listViews(packageId: number): Promise<View[]>;

package/dist/lib/api.js

@@ -2,7 +2,7 @@
  * Gufi Dev CLI - API Client
  * Communicates with Gufi Marketplace API
  */
-import { getToken, getApiUrl } from "./config.js";
+import { getToken, getApiUrl, getRefreshToken, setToken, loadConfig } from "./config.js";
 class ApiError extends Error {
     status;
     constructor(status, message) {
@@ -11,8 +11,34 @@ class ApiError extends Error {
         this.name = "ApiError";
     }
 }
-async function request(endpoint, options = {}) {
-    const token = getToken();
+// Auto-refresh the token if expired
+async function refreshAccessToken() {
+    const refreshToken = getRefreshToken();
+    if (!refreshToken)
+        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)
+            return null;
+        const data = await response.json();
+        const config = loadConfig();
+        setToken(data.accessToken, config.email || "", data.refreshToken);
+        return data.accessToken;
+    }
+    catch {
+        return null;
+    }
+}
+async function request(endpoint, options = {}, retryOnExpire = true) {
+    let token = getToken();
     if (!token) {
         throw new Error("No estás logueado. Ejecuta: gufi login");
     }
@@ -22,9 +48,17 @@ async function request(endpoint, options = {}) {
         headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${token}`,
+            "X-Client": "cli",
             ...options.headers,
         },
     });
+    // Auto-refresh on 401/403 and retry once
+    if ((response.status === 401 || response.status === 403) && retryOnExpire) {
+        const newToken = await refreshAccessToken();
+        if (newToken) {
+            return request(endpoint, options, false); // Retry with new token
+        }
+    }
     if (!response.ok) {
         const text = await response.text();
         throw new ApiError(response.status, `API Error ${response.status}: ${text}`);
@@ -36,14 +70,17 @@ export async function login(email, password) {
     const url = `${getApiUrl()}/api/auth/login`;
     const response = await fetch(url, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+            "Content-Type": "application/json",
+            "X-Client": "cli", // 💜 Request refresh token in response
+        },
         body: JSON.stringify({ email, password }),
     });
     if (!response.ok) {
         throw new ApiError(response.status, "Credenciales inválidas");
     }
     const data = await response.json();
-    return { token: data.accessToken };
+    return { token: data.accessToken, refreshToken: data.refreshToken };
 }
 // ============ Packages ============
 export async function listPackages() {

package/dist/lib/config.d.ts

@@ -5,6 +5,7 @@
 export interface GufiConfig {
     apiUrl: string;
     token?: string;
+    refreshToken?: string;
     email?: string;
     currentView?: {
         id: number;
@@ -17,7 +18,9 @@ export declare function ensureConfigDir(): void;
 export declare function loadConfig(): GufiConfig;
 export declare function saveConfig(config: GufiConfig): void;
 export declare function getToken(): string | undefined;
-export declare function setToken(token: string, email: string): void;
+export declare function setToken(token: string, email: string, refreshToken?: string): void;
+export declare function getRefreshToken(): string | undefined;
+export declare function setRefreshToken(refreshToken: string): void;
 export declare function clearToken(): void;
 export declare function isLoggedIn(): boolean;
 export declare function setCurrentView(view: GufiConfig["currentView"]): void;

package/dist/lib/config.js

@@ -35,15 +35,27 @@ export function saveConfig(config) {
 export function getToken() {
     return loadConfig().token;
 }
-export function setToken(token, email) {
+export function setToken(token, email, refreshToken) {
     const config = loadConfig();
     config.token = token;
     config.email = email;
+    if (refreshToken) {
+        config.refreshToken = refreshToken;
+    }
+    saveConfig(config);
+}
+export function getRefreshToken() {
+    return loadConfig().refreshToken;
+}
+export function setRefreshToken(refreshToken) {
+    const config = loadConfig();
+    config.refreshToken = refreshToken;
     saveConfig(config);
 }
 export function clearToken() {
     const config = loadConfig();
     delete config.token;
+    delete config.refreshToken;
     delete config.email;
     saveConfig(config);
 }

package/package.json

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