gufi-cli 0.1.0

package/bin/gufi.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/commands/login.d.ts

@@ -0,0 +1,8 @@
+/**
+ * gufi login - Authenticate with Gufi
+ */
+export declare function loginCommand(options: {
+    api?: string;
+}): Promise<void>;
+export declare function logoutCommand(): Promise<void>;
+export declare function whoamiCommand(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,115 @@
+/**
+ * gufi login - Authenticate with Gufi
+ */
+import readline from "readline";
+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";
+function prompt(question, hidden = false) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        if (hidden) {
+            process.stdout.write(question);
+            let input = "";
+            process.stdin.setRawMode?.(true);
+            process.stdin.resume();
+            process.stdin.on("data", (char) => {
+                const c = char.toString();
+                if (c === "\n" || c === "\r") {
+                    process.stdin.setRawMode?.(false);
+                    process.stdout.write("\n");
+                    rl.close();
+                    resolve(input);
+                }
+                else if (c === "\u0003") {
+                    process.exit();
+                }
+                else if (c === "\u007F") {
+                    if (input.length > 0) {
+                        input = input.slice(0, -1);
+                        process.stdout.write("\b \b");
+                    }
+                }
+                else {
+                    input += c;
+                    process.stdout.write("*");
+                }
+            });
+        }
+        else {
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+        }
+    });
+}
+export async function loginCommand(options) {
+    console.log(chalk.magenta("\n  🟣 Gufi Developer CLI\n"));
+    // Set custom API URL if provided
+    if (options.api) {
+        setApiUrl(options.api);
+        console.log(chalk.gray(`  API: ${options.api}\n`));
+    }
+    // Check if already logged in
+    if (isLoggedIn()) {
+        const config = loadConfig();
+        const spinner = ora("Verificando sesión...").start();
+        const valid = await validateToken();
+        if (valid) {
+            spinner.succeed(chalk.green(`Ya estás logueado como ${config.email}`));
+            const relogin = await prompt("\n¿Quieres iniciar sesión con otra cuenta? (s/N): ");
+            if (relogin.toLowerCase() !== "s") {
+                return;
+            }
+            clearToken();
+        }
+        else {
+            spinner.warn("Sesión expirada");
+            clearToken();
+        }
+    }
+    // Get credentials
+    const email = await prompt("  Email: ");
+    const password = await prompt("  Password: ", true);
+    if (!email || !password) {
+        console.log(chalk.red("\n  ✗ Email y password son requeridos\n"));
+        process.exit(1);
+    }
+    const spinner = ora("Iniciando sesión...").start();
+    try {
+        const { token } = await login(email, password);
+        setToken(token, email);
+        spinner.succeed(chalk.green(`Sesión iniciada como ${email}`));
+        console.log(chalk.gray("\n  Ahora puedes usar: gufi pull <vista>\n"));
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message || "Error al iniciar sesión"));
+        process.exit(1);
+    }
+}
+export async function logoutCommand() {
+    clearToken();
+    console.log(chalk.green("\n  ✓ Sesión cerrada\n"));
+}
+export async function whoamiCommand() {
+    const config = loadConfig();
+    if (!isLoggedIn()) {
+        console.log(chalk.yellow("\n  No estás logueado. Usa: gufi login\n"));
+        return;
+    }
+    const spinner = ora("Verificando...").start();
+    const valid = await validateToken();
+    if (valid) {
+        spinner.succeed(chalk.green(`Logueado como ${config.email}`));
+        console.log(chalk.gray(`  API: ${config.apiUrl}\n`));
+    }
+    else {
+        spinner.fail(chalk.red("Sesión expirada"));
+        console.log(chalk.gray("  Usa: gufi login\n"));
+    }
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,4 @@
+/**
+ * gufi pull - Download view files from Gufi
+ */
+export declare function pullCommand(viewIdentifier?: string): Promise<void>;

package/dist/commands/pull.js

@@ -0,0 +1,96 @@
+/**
+ * gufi pull - Download view files from Gufi
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { listPackages, listViews, getView } from "../lib/api.js";
+import { pullView } from "../lib/sync.js";
+import { isLoggedIn } from "../lib/config.js";
+export async function pullCommand(viewIdentifier) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Gufi Pull\n"));
+    let viewId;
+    let viewName;
+    let packageId;
+    // If view ID provided directly
+    if (viewIdentifier && /^\d+$/.test(viewIdentifier)) {
+        viewId = parseInt(viewIdentifier);
+        const spinner = ora("Obteniendo vista...").start();
+        try {
+            const view = await getView(viewId);
+            viewName = view.name;
+            packageId = view.package_id;
+            spinner.succeed(`Vista: ${viewName}`);
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`No se encontró la vista ${viewId}`));
+            process.exit(1);
+        }
+    }
+    else {
+        // Interactive selection
+        const spinner = ora("Cargando packages...").start();
+        try {
+            const packages = await listPackages();
+            spinner.stop();
+            if (packages.length === 0) {
+                console.log(chalk.yellow("  No tienes packages. Crea uno en Developer Center.\n"));
+                process.exit(0);
+            }
+            console.log(chalk.gray("  Tus packages:\n"));
+            packages.forEach((pkg, i) => {
+                console.log(`  ${chalk.cyan(i + 1)}. ${pkg.name}`);
+            });
+            // For now, use first package (can improve with interactive selection later)
+            const pkg = packages[0];
+            packageId = pkg.pk_id;
+            console.log(chalk.gray(`\n  Usando package: ${pkg.name}\n`));
+            const viewsSpinner = ora("Cargando vistas...").start();
+            const views = await listViews(packageId);
+            viewsSpinner.stop();
+            if (views.length === 0) {
+                console.log(chalk.yellow("  No hay vistas en este package.\n"));
+                process.exit(0);
+            }
+            console.log(chalk.gray("  Vistas disponibles:\n"));
+            views.forEach((view, i) => {
+                console.log(`  ${chalk.cyan(i + 1)}. ${view.name} ${chalk.gray(`(${view.view_type})`)}`);
+            });
+            // If viewIdentifier matches a name
+            let selectedView = viewIdentifier
+                ? views.find(v => v.name.toLowerCase().includes(viewIdentifier.toLowerCase()))
+                : views[0];
+            if (!selectedView) {
+                console.log(chalk.yellow(`\n  No se encontró vista "${viewIdentifier}"\n`));
+                console.log(chalk.gray("  Uso: gufi pull <nombre-vista> o gufi pull <view-id>\n"));
+                process.exit(1);
+            }
+            viewId = selectedView.pk_id;
+            viewName = selectedView.name;
+            console.log(chalk.gray(`\n  Descargando: ${viewName}\n`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(error.message));
+            process.exit(1);
+        }
+    }
+    // Pull the view
+    const pullSpinner = ora("Descargando archivos...").start();
+    try {
+        const result = await pullView(viewId, viewName, packageId);
+        pullSpinner.succeed(chalk.green(`${result.fileCount} archivos descargados`));
+        console.log(chalk.gray(`\n  📁 ${result.dir}\n`));
+        console.log(chalk.gray("  Comandos útiles:"));
+        console.log(chalk.cyan("    cd " + result.dir));
+        console.log(chalk.cyan("    gufi watch") + chalk.gray("  # Auto-sync cambios"));
+        console.log(chalk.cyan("    claude") + chalk.gray("        # Abrir Claude Code"));
+        console.log();
+    }
+    catch (error) {
+        pullSpinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,5 @@
+/**
+ * gufi push - Upload local changes to Gufi
+ */
+export declare function pushCommand(viewDir?: string): Promise<void>;
+export declare function statusCommand(viewDir?: string): Promise<void>;

package/dist/commands/push.js

@@ -0,0 +1,70 @@
+/**
+ * gufi push - Upload local changes to Gufi
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { pushView, getChangedFiles, loadViewMeta } from "../lib/sync.js";
+import { isLoggedIn, getCurrentView } from "../lib/config.js";
+export async function pushCommand(viewDir) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Gufi Push\n"));
+    // Determine view directory
+    const dir = viewDir || getCurrentView()?.localPath || process.cwd();
+    // Check if it's a valid Gufi view directory
+    const meta = loadViewMeta(dir);
+    if (!meta) {
+        console.log(chalk.red("  ✗ No es un directorio de vista Gufi válido."));
+        console.log(chalk.gray("    Usa: gufi pull <vista> primero\n"));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`  Vista: ${meta.viewName}`));
+    console.log(chalk.gray(`  Directorio: ${dir}\n`));
+    // Check for changes
+    const changedFiles = getChangedFiles(dir);
+    if (changedFiles.length === 0) {
+        console.log(chalk.green("  ✓ No hay cambios para subir\n"));
+        return;
+    }
+    console.log(chalk.gray("  Archivos modificados:"));
+    changedFiles.forEach((file) => {
+        console.log(chalk.yellow(`    • ${file}`));
+    });
+    console.log();
+    // Push changes
+    const spinner = ora("Subiendo cambios...").start();
+    try {
+        const result = await pushView(dir);
+        spinner.succeed(chalk.green(`${result.pushed} archivo(s) subido(s)`));
+        console.log(chalk.gray("\n  El preview en Gufi se actualizará automáticamente.\n"));
+    }
+    catch (error) {
+        spinner.fail(chalk.red(error.message));
+        process.exit(1);
+    }
+}
+export async function statusCommand(viewDir) {
+    const dir = viewDir || getCurrentView()?.localPath || process.cwd();
+    const meta = loadViewMeta(dir);
+    if (!meta) {
+        console.log(chalk.red("\n  ✗ No es un directorio de vista Gufi válido.\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Gufi Status\n"));
+    console.log(chalk.gray(`  Vista: ${meta.viewName}`));
+    console.log(chalk.gray(`  View ID: ${meta.viewId}`));
+    console.log(chalk.gray(`  Último sync: ${meta.lastSync}\n`));
+    const changedFiles = getChangedFiles(dir);
+    if (changedFiles.length === 0) {
+        console.log(chalk.green("  ✓ Todo sincronizado\n"));
+    }
+    else {
+        console.log(chalk.yellow("  Archivos modificados:"));
+        changedFiles.forEach((file) => {
+            console.log(chalk.yellow(`    • ${file}`));
+        });
+        console.log(chalk.gray("\n  Usa: gufi push para subir cambios\n"));
+    }
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,4 @@
+/**
+ * gufi watch - Auto-sync file changes to Gufi
+ */
+export declare function watchCommand(viewDir?: string): Promise<void>;

package/dist/commands/watch.js

@@ -0,0 +1,73 @@
+/**
+ * gufi watch - Auto-sync file changes to Gufi
+ */
+import chalk from "chalk";
+import chokidar from "chokidar";
+import path from "path";
+import { pushSingleFile, loadViewMeta } from "../lib/sync.js";
+import { isLoggedIn, getCurrentView } from "../lib/config.js";
+export async function watchCommand(viewDir) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    // Determine view directory
+    const dir = viewDir || getCurrentView()?.localPath || process.cwd();
+    const meta = loadViewMeta(dir);
+    if (!meta) {
+        console.log(chalk.red("\n  ✗ No es un directorio de vista Gufi válido."));
+        console.log(chalk.gray("    Usa: gufi pull <vista> primero\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta("\n  🟣 Gufi Watch\n"));
+    console.log(chalk.gray(`  Vista: ${meta.viewName}`));
+    console.log(chalk.gray(`  Directorio: ${dir}\n`));
+    console.log(chalk.green("  ✓ Observando cambios...\n"));
+    console.log(chalk.gray("  Ctrl+C para salir\n"));
+    // Setup file watcher
+    const watcher = chokidar.watch(dir, {
+        ignored: [
+            /(^|[\/\\])\../, // Hidden files
+            "**/node_modules/**",
+            "**/.gufi-view.json",
+        ],
+        persistent: true,
+        ignoreInitial: true,
+    });
+    // Debounce map to prevent rapid duplicate syncs
+    const debounceMap = new Map();
+    const syncFile = async (filePath) => {
+        const relativePath = path.relative(dir, filePath);
+        // Clear existing debounce
+        const existing = debounceMap.get(relativePath);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        // Set new debounce
+        debounceMap.set(relativePath, setTimeout(async () => {
+            debounceMap.delete(relativePath);
+            try {
+                process.stdout.write(chalk.yellow(`  ↑ ${relativePath}...`));
+                await pushSingleFile(dir, relativePath);
+                process.stdout.write(chalk.green(" ✓\n"));
+            }
+            catch (error) {
+                process.stdout.write(chalk.red(` ✗ ${error.message}\n`));
+            }
+        }, 300));
+    };
+    watcher
+        .on("change", syncFile)
+        .on("add", syncFile)
+        .on("error", (error) => {
+        console.log(chalk.red(`  Error: ${error.message}`));
+    });
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+        console.log(chalk.gray("\n\n  Deteniendo watch...\n"));
+        watcher.close();
+        process.exit(0);
+    });
+    // Keep process alive
+    await new Promise(() => { });
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * Gufi Dev CLI - Main Entry Point
+ *
+ * Commands:
+ *   gufi login          Login to Gufi
+ *   gufi logout         Logout from Gufi
+ *   gufi whoami         Show current user
+ *   gufi pull [view]    Download view files
+ *   gufi push           Upload local changes
+ *   gufi watch          Auto-sync file changes
+ *   gufi status         Show sync status
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Gufi Dev CLI - Main Entry Point
+ *
+ * Commands:
+ *   gufi login          Login to Gufi
+ *   gufi logout         Logout from Gufi
+ *   gufi whoami         Show current user
+ *   gufi pull [view]    Download view files
+ *   gufi push           Upload local changes
+ *   gufi watch          Auto-sync file changes
+ *   gufi status         Show sync status
+ */
+import { Command } from "commander";
+import { loginCommand, logoutCommand, whoamiCommand } from "./commands/login.js";
+import { pullCommand } from "./commands/pull.js";
+import { pushCommand, statusCommand } from "./commands/push.js";
+import { watchCommand } from "./commands/watch.js";
+const program = new Command();
+program
+    .name("gufi")
+    .description("Gufi Developer CLI - Develop Gufi views locally")
+    .version("0.1.0");
+// Auth commands
+program
+    .command("login")
+    .description("Login to Gufi")
+    .option("--api <url>", "Custom API URL")
+    .action(loginCommand);
+program
+    .command("logout")
+    .description("Logout from Gufi")
+    .action(logoutCommand);
+program
+    .command("whoami")
+    .description("Show current logged in user")
+    .action(whoamiCommand);
+// Sync commands
+program
+    .command("pull [view]")
+    .description("Download view files from Gufi")
+    .action(pullCommand);
+program
+    .command("push")
+    .description("Upload local changes to Gufi")
+    .action(pushCommand);
+program
+    .command("watch")
+    .description("Watch for file changes and auto-sync")
+    .action(watchCommand);
+program
+    .command("status")
+    .description("Show sync status")
+    .action(statusCommand);
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Gufi Dev CLI - API Client
+ * Communicates with Gufi Marketplace API
+ */
+export interface ViewFile {
+    id?: number;
+    file_path: string;
+    content: string;
+    language: string;
+    is_entry_point?: boolean;
+}
+export interface View {
+    pk_id: number;
+    name: string;
+    description?: string;
+    view_type: string;
+    package_id: number;
+    config?: Record<string, any>;
+}
+export interface Package {
+    pk_id: number;
+    name: string;
+    description?: string;
+    company_id: number;
+}
+export declare function login(email: string, password: string): Promise<{
+    token: string;
+}>;
+export declare function listPackages(): Promise<Package[]>;
+export declare function listViews(packageId: number): Promise<View[]>;
+export declare function getView(viewId: number): Promise<View>;
+export declare function getViewFiles(viewId: number): Promise<ViewFile[]>;
+export declare function saveViewFiles(viewId: number, files: ViewFile[]): Promise<void>;
+export declare function saveViewFile(viewId: number, file: ViewFile): Promise<void>;
+export declare function validateToken(): Promise<boolean>;

package/dist/lib/api.js

@@ -0,0 +1,83 @@
+/**
+ * Gufi Dev CLI - API Client
+ * Communicates with Gufi Marketplace API
+ */
+import { getToken, getApiUrl } from "./config.js";
+class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+async function request(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}`,
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new ApiError(response.status, `API Error ${response.status}: ${text}`);
+    }
+    return response.json();
+}
+// ============ Auth ============
+export async function login(email, password) {
+    const url = `${getApiUrl()}/api/auth/login`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        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 };
+}
+// ============ Packages ============
+export async function listPackages() {
+    return request("/api/marketplace/developer/packages");
+}
+// ============ Views ============
+export async function listViews(packageId) {
+    return request(`/api/marketplace/packages/${packageId}/views`);
+}
+export async function getView(viewId) {
+    return request(`/api/marketplace/views/${viewId}`);
+}
+export async function getViewFiles(viewId) {
+    return request(`/api/marketplace/views/${viewId}/files`);
+}
+export async function saveViewFiles(viewId, files) {
+    await request(`/api/marketplace/views/${viewId}/files`, {
+        method: "PUT",
+        body: JSON.stringify({ files }),
+    });
+}
+export async function saveViewFile(viewId, file) {
+    await request(`/api/marketplace/views/${viewId}/files`, {
+        method: "PUT",
+        body: JSON.stringify({ files: [file] }),
+    });
+}
+// ============ Validation ============
+export async function validateToken() {
+    try {
+        await request("/api/auth/me");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gufi Dev CLI - Config Management
+ * Stores credentials and settings in ~/.gufi/config.json
+ */
+export interface GufiConfig {
+    apiUrl: string;
+    token?: string;
+    email?: string;
+    currentView?: {
+        id: number;
+        name: string;
+        packageId: number;
+        localPath: string;
+    };
+}
+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 clearToken(): void;
+export declare function isLoggedIn(): boolean;
+export declare function setCurrentView(view: GufiConfig["currentView"]): void;
+export declare function getCurrentView(): GufiConfig["currentView"] | undefined;
+export declare function getApiUrl(): string;
+export declare function setApiUrl(url: string): void;

package/dist/lib/config.js

@@ -0,0 +1,68 @@
+/**
+ * Gufi Dev CLI - Config Management
+ * Stores credentials and settings in ~/.gufi/config.json
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+const CONFIG_DIR = path.join(os.homedir(), ".gufi");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const DEFAULT_CONFIG = {
+    apiUrl: "https://gogufi.com",
+};
+export function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function loadConfig() {
+    ensureConfigDir();
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getToken() {
+    return loadConfig().token;
+}
+export function setToken(token, email) {
+    const config = loadConfig();
+    config.token = token;
+    config.email = email;
+    saveConfig(config);
+}
+export function clearToken() {
+    const config = loadConfig();
+    delete config.token;
+    delete config.email;
+    saveConfig(config);
+}
+export function isLoggedIn() {
+    return !!getToken();
+}
+export function setCurrentView(view) {
+    const config = loadConfig();
+    config.currentView = view;
+    saveConfig(config);
+}
+export function getCurrentView() {
+    return loadConfig().currentView;
+}
+export function getApiUrl() {
+    return loadConfig().apiUrl;
+}
+export function setApiUrl(url) {
+    const config = loadConfig();
+    config.apiUrl = url;
+    saveConfig(config);
+}