gufi-cli 0.1.0

package/dist/lib/sync.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Gufi Dev CLI - Sync Library
+ * Handles bidirectional file synchronization
+ */
+export interface ViewMeta {
+    viewId: number;
+    viewName: string;
+    packageId: number;
+    lastSync: string;
+    files: Record<string, {
+        hash: string;
+        mtime: number;
+    }>;
+}
+export declare function getViewDir(viewName: string): string;
+export declare function loadViewMeta(viewDir: string): ViewMeta | null;
+/**
+ * Pull view files from Gufi to local directory
+ */
+export declare function pullView(viewId: number, viewName: string, packageId: number): Promise<{
+    dir: string;
+    fileCount: number;
+}>;
+/**
+ * Push local files to Gufi
+ */
+export declare function pushView(viewDir?: string): Promise<{
+    pushed: number;
+}>;
+/**
+ * Check for local changes that need pushing
+ */
+export declare function getChangedFiles(viewDir: string): string[];
+/**
+ * Push a single file
+ */
+export declare function pushSingleFile(viewDir: string, relativePath: string): Promise<void>;

package/dist/lib/sync.js

@@ -0,0 +1,188 @@
+/**
+ * Gufi Dev CLI - Sync Library
+ * Handles bidirectional file synchronization
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { getViewFiles, saveViewFile } from "./api.js";
+import { setCurrentView, getCurrentView } from "./config.js";
+const GUFI_DEV_DIR = path.join(os.homedir(), "gufi-dev");
+const META_FILE = ".gufi-view.json";
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function hashContent(content) {
+    // Simple hash for change detection
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash.toString(16);
+}
+function getLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const langMap = {
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".css": "css",
+        ".json": "json",
+        ".md": "markdown",
+    };
+    return langMap[ext] || "text";
+}
+export function getViewDir(viewName) {
+    return path.join(GUFI_DEV_DIR, viewName.toLowerCase().replace(/\s+/g, "-"));
+}
+export function loadViewMeta(viewDir) {
+    const metaPath = path.join(viewDir, META_FILE);
+    if (!fs.existsSync(metaPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveViewMeta(viewDir, meta) {
+    const metaPath = path.join(viewDir, META_FILE);
+    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+}
+/**
+ * Pull view files from Gufi to local directory
+ */
+export async function pullView(viewId, viewName, packageId) {
+    const viewDir = getViewDir(viewName);
+    ensureDir(viewDir);
+    const files = await getViewFiles(viewId);
+    const fileMeta = {};
+    for (const file of files) {
+        const filePath = path.join(viewDir, file.file_path.replace(/^\//, ""));
+        ensureDir(path.dirname(filePath));
+        fs.writeFileSync(filePath, file.content);
+        fileMeta[file.file_path] = {
+            hash: hashContent(file.content),
+            mtime: Date.now(),
+        };
+    }
+    const meta = {
+        viewId,
+        viewName,
+        packageId,
+        lastSync: new Date().toISOString(),
+        files: fileMeta,
+    };
+    saveViewMeta(viewDir, meta);
+    // Update current view in config
+    setCurrentView({ id: viewId, name: viewName, packageId, localPath: viewDir });
+    return { dir: viewDir, fileCount: files.length };
+}
+/**
+ * Push local files to Gufi
+ */
+export async function pushView(viewDir) {
+    const dir = viewDir || getCurrentView()?.localPath;
+    if (!dir) {
+        throw new Error("No hay vista activa. Usa: gufi pull <vista>");
+    }
+    const meta = loadViewMeta(dir);
+    if (!meta) {
+        throw new Error("No se encontró metadata de vista. ¿Hiciste pull primero?");
+    }
+    const localFiles = getLocalFiles(dir);
+    let pushed = 0;
+    for (const file of localFiles) {
+        const content = fs.readFileSync(path.join(dir, file), "utf-8");
+        const hash = hashContent(content);
+        const filePath = "/" + file;
+        // Check if file changed
+        const oldMeta = meta.files[filePath];
+        if (oldMeta && oldMeta.hash === hash) {
+            continue; // No changes
+        }
+        // Push to Gufi
+        await saveViewFile(meta.viewId, {
+            file_path: filePath,
+            content,
+            language: getLanguage(file),
+            is_entry_point: file === "index.tsx",
+        });
+        // Update meta
+        meta.files[filePath] = { hash, mtime: Date.now() };
+        pushed++;
+    }
+    meta.lastSync = new Date().toISOString();
+    saveViewMeta(dir, meta);
+    return { pushed };
+}
+/**
+ * Get list of local files (excluding meta and hidden)
+ */
+function getLocalFiles(dir, prefix = "") {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue; // Skip hidden files
+        const fullPath = path.join(prefix, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...getLocalFiles(path.join(dir, entry.name), fullPath));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+/**
+ * Check for local changes that need pushing
+ */
+export function getChangedFiles(viewDir) {
+    const meta = loadViewMeta(viewDir);
+    if (!meta)
+        return [];
+    const changed = [];
+    const localFiles = getLocalFiles(viewDir);
+    for (const file of localFiles) {
+        const content = fs.readFileSync(path.join(viewDir, file), "utf-8");
+        const hash = hashContent(content);
+        const filePath = "/" + file;
+        const oldMeta = meta.files[filePath];
+        if (!oldMeta || oldMeta.hash !== hash) {
+            changed.push(file);
+        }
+    }
+    return changed;
+}
+/**
+ * Push a single file
+ */
+export async function pushSingleFile(viewDir, relativePath) {
+    const meta = loadViewMeta(viewDir);
+    if (!meta) {
+        throw new Error("No se encontró metadata de vista");
+    }
+    const fullPath = path.join(viewDir, relativePath);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const filePath = "/" + relativePath.replace(/\\/g, "/");
+    await saveViewFile(meta.viewId, {
+        file_path: filePath,
+        content,
+        language: getLanguage(relativePath),
+        is_entry_point: relativePath === "index.tsx",
+    });
+    // Update meta
+    meta.files[filePath] = {
+        hash: hashContent(content),
+        mtime: Date.now(),
+    };
+    meta.lastSync = new Date().toISOString();
+    saveViewMeta(viewDir, meta);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "gufi-cli",
+  "version": "0.1.0",
+  "description": "CLI for developing Gufi Marketplace views locally with Claude Code",
+  "bin": {
+    "gufi": "./bin/gufi.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/juanbp23/gogufi"
+  },
+  "homepage": "https://gogufi.com",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "start": "node bin/gufi.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "commander": "^12.0.0",
+    "node-fetch": "^3.3.2",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["gufi", "developer", "cli", "marketplace"],
+  "author": "Gufi",
+  "license": "MIT"
+}

package/src/commands/login.ts

@@ -0,0 +1,124 @@
+/**
+ * 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: string, hidden = false): Promise<string> {
+  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: { api?: string }): Promise<void> {
+  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: any) {
+    spinner.fail(chalk.red(error.message || "Error al iniciar sesión"));
+    process.exit(1);
+  }
+}
+
+export async function logoutCommand(): Promise<void> {
+  clearToken();
+  console.log(chalk.green("\n  ✓ Sesión cerrada\n"));
+}
+
+export async function whoamiCommand(): Promise<void> {
+  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/src/commands/pull.ts

@@ -0,0 +1,113 @@
+/**
+ * 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?: string): Promise<void> {
+  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: number;
+  let viewName: string;
+  let packageId: number;
+
+  // 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: any) {
+      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: any) {
+      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: any) {
+    pullSpinner.fail(chalk.red(error.message));
+    process.exit(1);
+  }
+}

package/src/commands/push.ts

@@ -0,0 +1,85 @@
+/**
+ * gufi push - Upload local changes to Gufi
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import path from "path";
+import { pushView, getChangedFiles, loadViewMeta } from "../lib/sync.js";
+import { isLoggedIn, getCurrentView } from "../lib/config.js";
+
+export async function pushCommand(viewDir?: string): Promise<void> {
+  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: any) {
+    spinner.fail(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+export async function statusCommand(viewDir?: string): Promise<void> {
+  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/src/commands/watch.ts

@@ -0,0 +1,89 @@
+/**
+ * gufi watch - Auto-sync file changes to Gufi
+ */
+
+import chalk from "chalk";
+import chokidar from "chokidar";
+import path from "path";
+import { pushSingleFile, loadViewMeta, getViewDir } from "../lib/sync.js";
+import { isLoggedIn, getCurrentView } from "../lib/config.js";
+
+export async function watchCommand(viewDir?: string): Promise<void> {
+  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<string, NodeJS.Timeout>();
+
+  const syncFile = async (filePath: string) => {
+    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: any) {
+          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(() => {});
+}