gufi-cli 0.1.39 → 0.1.41

package/CLAUDE.md

@@ -55,9 +55,9 @@ gufi config:prod
 }
 ```
 
-## MCP Server - 12 Tools
+## MCP Server - 13 Tools
 
-El servidor MCP está en `src/mcp.ts` y expone **12 tools** para que Claude interactúe con Gufi.
+El servidor MCP está en `src/mcp.ts` y expone **13 tools** para que Claude interactúe con Gufi.
 
 ### Tools organizados por categoría
 
@@ -66,7 +66,7 @@ El servidor MCP está en `src/mcp.ts` y expone **12 tools** para que Claude inte
 | **Context** | `gufi_context` | Schema completo (company, view, package) |
 | | `gufi_whoami` | Usuario, entorno, empresas |
 | | `gufi_docs` | Documentación (`docs/mcp/`) |
-| **Schema** | `gufi_schema_modify` | Operaciones atomicas (add/update/remove) |
+| **Schema** | `gufi_schema_modify` | Operaciones atómicas (add/update/remove) |
 | **Automations** | `gufi_automation` | Scripts: list, get, create |
 | | `gufi_triggers` | Ver/configurar triggers |
 | | `gufi_executions` | Historial de ejecuciones |
@@ -74,6 +74,7 @@ El servidor MCP está en `src/mcp.ts` y expone **12 tools** para que Claude inte
 | **Env** | `gufi_env` | Variables: list, set, delete |
 | **Views** | `gufi_view_pull` | Descargar vista a local |
 | | `gufi_view_push` | Subir cambios a draft |
+| | `gufi_view_test` | Test en headless browser (errores, screenshot) |
 | **Packages** | `gufi_package` | list, get, create, delete, add_module, remove_module, publish |
 
 ### Añadir un nuevo tool MCP

package/README.md

@@ -173,11 +173,12 @@ const { rows } = await api.query(...);  // ERROR!
 ### Llamar automations desde vistas
 
 ```tsx
-await dataProvider.runClickAutomation?.({
-  company_id, module_id, table_id: entityId,
-  function_name: "my_automation",
-  input: { record_id: 123 },
+// 💜 gufi.automation() - Simple y directo
+const result = await gufi.automation('my_automation', {
+  record_id: 123
 });
+
+// La automation tiene acceso a api.stripe.*, api.nayax.*, etc.
 ```
 
 ## Row CRUD (Datos)

package/dist/commands/install.d.ts

@@ -0,0 +1,21 @@
+/**
+ * gufi install - Instala Gufi Claude como servicio de sistema
+ *
+ * Mac: LaunchAgent que arranca con el sistema
+ * Linux: systemd user service
+ * Windows: Task Scheduler que arranca con login
+ */
+/**
+ * 💜 gufi install - Install as system service
+ */
+export declare function installCommand(options: {
+    port?: number;
+}): Promise<void>;
+/**
+ * 💜 gufi uninstall - Remove system service
+ */
+export declare function uninstallCommand(): Promise<void>;
+/**
+ * 💜 gufi service:status - Check service status
+ */
+export declare function serviceStatusCommand(): Promise<void>;

package/dist/commands/setup-claude.d.ts

@@ -0,0 +1,6 @@
+/**
+ * gufi setup-claude - Configure Claude Code with Gufi MCP
+ *
+ * Creates workspace and configures MCP server
+ */
+export declare function setupClaudeCommand(): Promise<void>;

package/dist/commands/setup-claude.js

@@ -0,0 +1,137 @@
+/**
+ * gufi setup-claude - Configure Claude Code with Gufi MCP
+ *
+ * Creates workspace and configures MCP server
+ */
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { isLoggedIn, loadConfig } from "../lib/config.js";
+const WORKSPACE_DIR = path.join(os.homedir(), "gufi-workspace");
+const CLAUDE_CONFIG_DIR = path.join(os.homedir(), ".claude");
+// Claude Code CLI uses settings.json, NOT claude_desktop_config.json
+const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_CONFIG_DIR, "settings.json");
+const CLAUDE_MD_CONTENT = `# Gufi Workspace
+
+Este es tu espacio de trabajo para Gufi ERP.
+
+## MCP Tools Disponibles
+
+Tienes acceso a todas las herramientas de Gufi:
+
+- \`gufi_context\` - Obtener contexto de empresa, módulos, entidades
+- \`gufi_rows\` / \`gufi_row\` - Leer datos
+- \`gufi_row_create\` / \`gufi_row_update\` - Crear/actualizar datos
+- \`gufi_schema_modify\` - Modificar schema
+- \`gufi_automations\` - Ver automatizaciones
+- \`gufi_docs\` - Leer documentación
+
+## Quick Start
+
+1. Ver tus empresas:
+   \`\`\`
+   Usa gufi_companies para ver las empresas disponibles
+   \`\`\`
+
+2. Obtener contexto de una empresa:
+   \`\`\`
+   Usa gufi_context con company_id para ver módulos y entidades
+   \`\`\`
+
+3. Consultar datos:
+   \`\`\`
+   Usa gufi_rows con el nombre de tabla (ej: m308_t4136)
+   \`\`\`
+
+## Documentación
+
+Para más información, usa:
+\`\`\`
+gufi_docs({ topic: "overview" })
+\`\`\`
+
+---
+Configurado con: gufi setup-claude
+`;
+export async function setupClaudeCommand() {
+    console.log(chalk.magenta(`
+  ╭──────────────────────────────────────────────────────╮
+  │  🐿️  Gufi Claude Code Setup                         │
+  ╰──────────────────────────────────────────────────────╯
+`));
+    // Check login
+    if (!isLoggedIn()) {
+        console.log(chalk.yellow("  ⚠️  Primero debes iniciar sesión."));
+        console.log(chalk.gray("  Ejecuta: gufi login\n"));
+        process.exit(1);
+    }
+    const config = loadConfig();
+    console.log(chalk.gray(`  Usuario: ${config.email}\n`));
+    // Step 1: Create workspace directory
+    const spinnerWorkspace = ora("Creando workspace...").start();
+    try {
+        if (!fs.existsSync(WORKSPACE_DIR)) {
+            fs.mkdirSync(WORKSPACE_DIR, { recursive: true });
+        }
+        // Create CLAUDE.md
+        const claudeMdPath = path.join(WORKSPACE_DIR, "CLAUDE.md");
+        fs.writeFileSync(claudeMdPath, CLAUDE_MD_CONTENT);
+        spinnerWorkspace.succeed(chalk.green(`Workspace creado: ${WORKSPACE_DIR}`));
+    }
+    catch (err) {
+        spinnerWorkspace.fail(chalk.red(`Error creando workspace: ${err.message}`));
+        process.exit(1);
+    }
+    // Step 2: Configure MCP in Claude Code
+    const spinnerMcp = ora("Configurando MCP en Claude Code...").start();
+    try {
+        // Ensure .claude directory exists
+        if (!fs.existsSync(CLAUDE_CONFIG_DIR)) {
+            fs.mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });
+        }
+        // Read existing config or create new
+        let claudeConfig = { mcpServers: {} };
+        if (fs.existsSync(CLAUDE_SETTINGS_FILE)) {
+            try {
+                const existing = fs.readFileSync(CLAUDE_SETTINGS_FILE, "utf8");
+                claudeConfig = JSON.parse(existing);
+                if (!claudeConfig.mcpServers) {
+                    claudeConfig.mcpServers = {};
+                }
+            }
+            catch {
+                // If parse fails, start fresh
+                claudeConfig = { mcpServers: {} };
+            }
+        }
+        // Add/update Gufi MCP server
+        claudeConfig.mcpServers.gufi = {
+            command: "gufi",
+            args: ["mcp"],
+        };
+        // Write config
+        fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(claudeConfig, null, 2));
+        spinnerMcp.succeed(chalk.green("MCP de Gufi configurado en Claude Code"));
+    }
+    catch (err) {
+        spinnerMcp.fail(chalk.red(`Error configurando MCP: ${err.message}`));
+        process.exit(1);
+    }
+    // Success message
+    console.log(chalk.cyan(`
+  ✅ Setup completado!
+
+  Tu workspace está en:
+  ${chalk.white(WORKSPACE_DIR)}
+
+  Para usar Claude Code con Gufi:
+  ${chalk.white("gufi claude")}
+
+  Esto abrirá Claude Code con acceso a:
+  • Todas las herramientas MCP de Gufi
+  • Tu sesión y empresas
+  • Documentación integrada
+`));
+}

package/dist/mcp.js

@@ -552,6 +552,16 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: "gufi_automation_integrations",
+        description: "List Gufi's built-in integrations (Stripe, Nayax, etc.) and their api.* methods. These are pre-built by Gufi - users can also create custom integrations directly in their automations using api.http() for any external service. Credentials are passed using env.* variables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Integration name to get detailed info (optional)" },
+            },
+        },
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Automations (Business Logic)
     // ─────────────────────────────────────────────────────────────────────────
@@ -713,6 +723,35 @@ Example: gufi_view_push({ view_id: 13, message: "Fixed bug in chart" })`,
             required: [],
         },
     },
+    // 🧪 Test view in headless browser
+    {
+        name: "gufi_view_test",
+        description: getDesc("gufi_view_test"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_id: { type: "number", description: "View ID to test" },
+                company_id: { type: "string", description: "Company ID for authentication context" },
+                timeout: { type: "number", description: "Navigation timeout in ms (default: 15000)" },
+                actions: {
+                    type: "array",
+                    description: "Optional actions to perform after page load: [{type:'click',selector:'.btn'}, {type:'fill',selector:'input',value:'text'}, {type:'wait',selector:'.loaded'}, {type:'delay',ms:1000}]",
+                    items: {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", description: "Action type: click, fill, wait, delay" },
+                            selector: { type: "string", description: "CSS selector for click/fill/wait" },
+                            value: { type: "string", description: "Value for fill action" },
+                            ms: { type: "number", description: "Milliseconds for delay action" },
+                        },
+                    },
+                },
+                capture_screenshot: { type: "boolean", description: "Include base64 screenshot (default: true)" },
+                env: ENV_PARAM,
+            },
+            required: ["view_id", "company_id"],
+        },
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Packages (Marketplace Distribution)
     // ─────────────────────────────────────────────────────────────────────────
@@ -1104,6 +1143,102 @@ const toolHandlers = {
             hint: "Use gufi_docs({ topic: 'fields' }) to read about field types, or gufi_docs({ search: 'currency' }) to search.",
         };
     },
+    async gufi_automation_integrations(params) {
+        const { name } = params;
+        // Static list of available integrations and their methods
+        // Credentials are passed from automations using env.* - no configuration status to check
+        const integrations = {
+            stripe: {
+                name: "stripe",
+                description: "Stripe payment processing - Create checkout sessions, handle payments",
+                category: "payments",
+                docs: "https://stripe.com/docs/api",
+                methods: [
+                    { name: "createCheckoutSession", description: "Create a Stripe Checkout Session for payment", params: ["secretKey", "lineItems", "customerEmail?", "successUrl?", "cancelUrl?"] },
+                ],
+            },
+            nayax: {
+                name: "nayax",
+                description: "Nayax vending machine telemetry - Sync machines, products, sales, alerts",
+                category: "vending",
+                docs: "https://developers.nayax.com/",
+                methods: [
+                    { name: "sync_machines", description: "Sync all machines from Nayax", params: ["token", "tableName"] },
+                    { name: "sync_products", description: "Sync products from Nayax", params: ["token", "tableName"] },
+                    { name: "sync_last_sales", description: "Sync recent sales", params: ["token", "tableName", "machinesTable", "productsTable"] },
+                    { name: "sync_alerts", description: "Sync machine alerts", params: ["token", "tableName", "machinesTable", "productsTable"] },
+                    { name: "sync_machine_products", description: "Sync planograms", params: ["token", "tableName", "machinesTable", "productsTable"] },
+                    { name: "sync_pick_list", description: "Sync low stock items", params: ["token", "tableName", "machinesTable", "productsTable"] },
+                    { name: "sync_single_machine_capacity", description: "Sync and calculate capacity for one machine", params: ["machineId", "token", "machineProductsTable", "machinesTable", "productsTable"] },
+                ],
+            },
+            ourvend: {
+                name: "ourvend",
+                description: "OurVend (RedPanda) vending system - Sync groups, machines, products, sales",
+                category: "vending",
+                docs: "https://ourvend.com/api",
+                methods: [
+                    { name: "sync_groups", description: "Sync machine groups", params: ["user", "password", "tableName"] },
+                    { name: "sync_machines", description: "Sync machines", params: ["user", "password", "tableName", "groupsTable"] },
+                    { name: "sync_products", description: "Sync products", params: ["user", "password", "tableName"] },
+                    { name: "sync_sales", description: "Sync sales", params: ["user", "password", "tableName", "machinesTable", "productsTable", "groupsTable", "dateFrom?", "dateTo?"] },
+                ],
+            },
+            tns: {
+                name: "tns",
+                description: "TNS Colombian accounting - Sync products and categories",
+                category: "accounting",
+                docs: "https://tns.com.co/api",
+                methods: [
+                    { name: "sync_products", description: "Sync products from TNS", params: ["productsTable", "categoriesTable", "env?"] },
+                    { name: "sync_products_from_sales", description: "Sync products that appear in sales", params: ["productsTable", "categoriesTable", "salesTable", "env?"] },
+                    { name: "sync_all_products", description: "Sync all products from catalog", params: ["productsTable", "categoriesTable", "env?"] },
+                ],
+            },
+        };
+        if (name) {
+            const integration = integrations[name];
+            if (!integration) {
+                return {
+                    error: `Integration '${name}' not found`,
+                    available: Object.keys(integrations),
+                };
+            }
+            return {
+                ...integration,
+                methods: integration.methods.map((m) => ({
+                    ...m,
+                    usage: `api.${name}.${m.name}({ ${m.params.map(p => p.replace("?", "")).join(", ")} })`,
+                })),
+                usage_note: "Credentials (tokens, passwords, keys) are passed from automations using env.* variables. Name your env vars however you prefer.",
+                example: `
+// In automation:
+async function my_automation(context, api, logger) {
+  const { env } = context;
+  const result = await api.${name}.${integration.methods[0].name}({
+    ${integration.methods[0].params.filter(p => !p.endsWith("?")).map(p => `${p}: env.MY_${p.toUpperCase()}`).join(",\n    ")}
+  });
+  return result;
+}`,
+            };
+        }
+        // List all integrations
+        return {
+            integrations: Object.values(integrations).map((i) => ({
+                name: i.name,
+                description: i.description,
+                category: i.category,
+                methods: i.methods.map((m) => m.name),
+            })),
+            usage_note: "Credentials are passed from automations using env.* variables. Name your env vars however you prefer.",
+            example: `
+// In automation, use api.{integration}.{method}():
+const result = await api.stripe.createCheckoutSession({
+  secretKey: env.MY_STRIPE_KEY,  // Your env var name
+  lineItems: [{ name: 'Product', amount: 1999, quantity: 1 }],
+});`,
+        };
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Automations
     // ─────────────────────────────────────────────────────────────────────────
@@ -1498,6 +1633,62 @@ const toolHandlers = {
                 : "Changes saved (no package - goes directly to production)",
         };
     },
+    async gufi_view_test(params) {
+        const { view_id, company_id, timeout, actions, capture_screenshot, env } = params;
+        const result = await apiRequest("/api/cli/view-test", {
+            method: "POST",
+            body: JSON.stringify({
+                view_id,
+                company_id,
+                timeout: timeout || 15000,
+                actions: actions || [],
+                capture_screenshot: capture_screenshot !== false,
+            }),
+        }, company_id, true, env);
+        // Format response for Claude readability
+        const response = {
+            success: result.success,
+            view_id: result.view_id,
+            url: result.url,
+            duration_ms: result.duration_ms,
+        };
+        // Add console output if there are errors/warnings
+        if (result.console?.errors?.length > 0) {
+            response.console_errors = result.console.errors;
+        }
+        if (result.console?.warnings?.length > 0) {
+            response.console_warnings = result.console.warnings;
+        }
+        if (result.console?.logs?.length > 0) {
+            response.console_logs = result.console.logs;
+        }
+        // Add JS/network errors
+        if (result.errors?.length > 0) {
+            response.errors = result.errors;
+        }
+        // Add failed API calls
+        const failedCalls = (result.api_calls || []).filter((c) => c.status >= 400);
+        if (failedCalls.length > 0) {
+            response.failed_api_calls = failedCalls;
+        }
+        // Add DOM info
+        response.dom = result.dom;
+        // Add screenshot (Claude can view base64 images)
+        if (result.screenshot) {
+            response.screenshot = result.screenshot;
+        }
+        // Add hint based on results
+        if (!result.success) {
+            response._hint = `View test failed: ${result.error}. Check console_errors and errors for details.`;
+        }
+        else if (result.errors?.length > 0 || result.console?.errors?.length > 0) {
+            response._hint = "View loaded but has errors. Check console_errors and errors arrays.";
+        }
+        else {
+            response._hint = "View loaded successfully. Check screenshot to verify visual appearance.";
+        }
+        return response;
+    },
     // gufi_view_create removed - views are created from UI, edited via pull/push
     // ─────────────────────────────────────────────────────────────────────────
     // Packages

package/package.json

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

package/dist/commands/assistant.d.ts

@@ -1,22 +0,0 @@
-/**
- * gufi assistant - WebSocket bridge between frontend UI and Claude Code
- *
- * 💜 Permite editar vistas desde el frontend usando Claude Code local + MCP
- *
- * Architecture:
- * ┌─────────────┐     WebSocket      ┌─────────────────┐
- * │  Frontend   │◄──────────────────►│ gufi assistant  │
- * │  (UI/Chat)  │   localhost:3005   │   ↓             │
- * └─────────────┘                    │ Claude Code     │
- *                                    │  + MCP Gufi     │
- *                                    └─────────────────┘
- *
- * Usage:
- *   gufi assistant              # Start on default port 3005
- *   gufi assistant --port 3010  # Custom port
- */
-interface AssistantFlags {
-    port?: string | number;
-}
-export declare function assistantCommand(flags?: AssistantFlags): Promise<void>;
-export {};

package/dist/commands/assistant.js

@@ -1,377 +0,0 @@
-/**
- * gufi assistant - WebSocket bridge between frontend UI and Claude Code
- *
- * 💜 Permite editar vistas desde el frontend usando Claude Code local + MCP
- *
- * Architecture:
- * ┌─────────────┐     WebSocket      ┌─────────────────┐
- * │  Frontend   │◄──────────────────►│ gufi assistant  │
- * │  (UI/Chat)  │   localhost:3005   │   ↓             │
- * └─────────────┘                    │ Claude Code     │
- *                                    │  + MCP Gufi     │
- *                                    └─────────────────┘
- *
- * Usage:
- *   gufi assistant              # Start on default port 3005
- *   gufi assistant --port 3010  # Custom port
- */
-import chalk from "chalk";
-import { WebSocketServer, WebSocket } from "ws";
-import { spawn } from "child_process";
-import { isLoggedIn, getCurrentEnv } from "../lib/config.js";
-const DEFAULT_PORT = 4005;
-const clients = new Map();
-/**
- * Parse JSON output - extract final result and session_id for memory
- */
-function parseClaudeJsonLine(line, _requestId, _sendResponse, state) {
-    try {
-        const data = JSON.parse(line);
-        // Return the final result with session_id (check FIRST before generic session_id)
-        if (data.type === "result" && data.result) {
-            return { finalText: data.result, sessionId: data.session_id };
-        }
-        // Capture session_id from init message (not result)
-        if (data.type === "system" && data.session_id) {
-            return { sessionId: data.session_id };
-        }
-        // Log tool usage for terminal visibility
-        if (data.type === "assistant" && data.message?.content) {
-            for (const block of data.message.content) {
-                if (block.type === "tool_use") {
-                    state.lastToolName = block.name;
-                    console.log(chalk.blue(`  🔧 ${block.name}`));
-                }
-            }
-        }
-        if (data.type === "user" && data.message?.content) {
-            for (const block of data.message.content) {
-                if (block.type === "tool_result") {
-                    console.log(chalk.green(`  ✓ completado`));
-                }
-            }
-        }
-        return {};
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Execute Claude Code with a prompt and stream the response
- * Returns the session_id for memory/resume
- */
-async function executeClaudeCode(prompt, viewId, viewName, requestId, sendResponse, existingSessionId = null) {
-    // Build the full prompt with view context
-    const fullPrompt = `
-[Contexto: Estás editando la vista "${viewName}" de Gufi ERP]
-
-REGLAS CRÍTICAS:
-1. SIEMPRE usa los tools MCP para hacer cambios reales. NUNCA digas que hiciste algo sin llamar al tool.
-2. Para modificar archivos: gufi_view_file_update({ view_id, file_path, content })
-3. Para leer archivos: gufi_view_files({ view_id })
-4. El view_id es ${viewId} - úsalo directamente
-5. Responde en español y sé conciso
-
-PROHIBIDO:
-- Decir "He añadido..." sin haber llamado a gufi_view_file_update
-- Inventar que hiciste cambios
-- Responder sin ejecutar los tools necesarios
-
-Instrucción del usuario: ${prompt}
-`.trim();
-    console.log(chalk.cyan(`\n  📝 Request: "${prompt.substring(0, 50)}..."`));
-    console.log(chalk.gray(`     View: "${viewName}" (ID hint: ${viewId})`));
-    return new Promise((resolve, reject) => {
-        // Build args - use --resume if we have a session
-        const args = [
-            "--dangerously-skip-permissions",
-            "-p", // print mode
-            "--output-format", "stream-json",
-            "--verbose",
-        ];
-        if (existingSessionId) {
-            args.push("--resume", existingSessionId);
-            console.log(chalk.gray(`  🔧 Resumiendo sesión ${existingSessionId.substring(0, 8)}...`));
-        }
-        else {
-            console.log(chalk.gray(`  🔧 Nueva sesión de Claude...`));
-        }
-        const claudeProcess = spawn("claude", args, {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env },
-        });
-        // Write prompt to stdin and close it
-        claudeProcess.stdin?.write(fullPrompt);
-        claudeProcess.stdin?.end();
-        console.log(chalk.yellow("  ⏳ Claude Code ejecutando (PID: " + claudeProcess.pid + ")..."));
-        let lineBuffer = "";
-        let lastFinalText = "";
-        let capturedSessionId = existingSessionId;
-        const streamState = {
-            currentText: "",
-            currentToolName: null,
-            currentToolInput: "",
-            lastToolName: null,
-        };
-        claudeProcess.stdout?.on("data", (data) => {
-            const chunk = data.toString();
-            lineBuffer += chunk;
-            // Process complete lines (each JSON object is on its own line)
-            const lines = lineBuffer.split("\n");
-            lineBuffer = lines.pop() || ""; // Keep incomplete line in buffer
-            for (const line of lines) {
-                if (line.trim()) {
-                    const result = parseClaudeJsonLine(line, requestId, sendResponse, streamState);
-                    if (result.finalText) {
-                        lastFinalText = result.finalText;
-                    }
-                    if (result.sessionId) {
-                        capturedSessionId = result.sessionId;
-                    }
-                }
-            }
-        });
-        claudeProcess.stderr?.on("data", (data) => {
-            const text = data.toString();
-            // Log all stderr for debugging
-            console.log(chalk.gray(`  📋 stderr: ${text.substring(0, 100)}`));
-            if (text.toLowerCase().includes("error:") && !text.includes("is_error")) {
-                sendResponse({
-                    type: "error",
-                    id: requestId,
-                    error: text,
-                });
-            }
-        });
-        claudeProcess.on("close", (code) => {
-            // Process any remaining buffer
-            if (lineBuffer.trim()) {
-                const result = parseClaudeJsonLine(lineBuffer, requestId, sendResponse, streamState);
-                if (result.finalText) {
-                    lastFinalText = result.finalText;
-                }
-                if (result.sessionId) {
-                    capturedSessionId = result.sessionId;
-                }
-            }
-            console.log(chalk.gray(`  🏁 Claude terminó con código: ${code}`));
-            if (capturedSessionId) {
-                console.log(chalk.gray(`  📝 Session: ${capturedSessionId.substring(0, 8)}...`));
-            }
-            if (code !== 0) {
-                console.log(chalk.red(`  ❌ Error: código ${code}`));
-                sendResponse({
-                    type: "error",
-                    id: requestId,
-                    error: `Claude process exited with code ${code}`,
-                });
-                reject(new Error(`Claude exited with code ${code}`));
-            }
-            else {
-                console.log(chalk.green(`  ✓ Completado`));
-                sendResponse({
-                    type: "response",
-                    id: requestId,
-                    content: lastFinalText,
-                    done: true,
-                });
-                resolve(capturedSessionId);
-            }
-        });
-        claudeProcess.on("error", (err) => {
-            console.log(chalk.red(`  ❌ Error spawn: ${err.message}`));
-            sendResponse({
-                type: "error",
-                id: requestId,
-                error: `Failed to start Claude: ${err.message}`,
-            });
-            reject(err);
-        });
-        // Store the process for potential cancellation
-        const clientState = [...clients.values()].find((c) => c.currentRequestId === requestId);
-        if (clientState) {
-            clientState.claudeProcess = claudeProcess;
-        }
-    });
-}
-/**
- * Handle incoming WebSocket messages
- */
-async function handleMessage(ws, rawMessage) {
-    const state = clients.get(ws);
-    if (!state)
-        return;
-    const sendResponse = (response) => {
-        if (ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(response));
-        }
-    };
-    try {
-        const message = JSON.parse(rawMessage);
-        switch (message.type) {
-            case "ping":
-                sendResponse({ type: "pong", id: message.id });
-                break;
-            case "cancel":
-                if (state.claudeProcess) {
-                    state.claudeProcess.kill("SIGTERM");
-                    state.claudeProcess = null;
-                    state.currentRequestId = null;
-                    sendResponse({
-                        type: "response",
-                        id: message.id,
-                        content: "Cancelado",
-                        done: true,
-                    });
-                }
-                break;
-            case "clear":
-                // Reset session for new conversation
-                state.sessionId = null;
-                console.log(chalk.yellow("  🗑️ Sesión limpiada"));
-                sendResponse({
-                    type: "status",
-                    id: message.id,
-                    content: "cleared",
-                });
-                break;
-            case "chat":
-                if (!message.viewId || !message.message) {
-                    sendResponse({
-                        type: "error",
-                        id: message.id,
-                        error: "viewId y message son requeridos",
-                    });
-                    return;
-                }
-                state.currentRequestId = message.id;
-                try {
-                    // Pass existing sessionId for memory, get back new/updated sessionId
-                    const newSessionId = await executeClaudeCode(message.message, message.viewId, message.viewName || "Unknown", message.id, sendResponse, state.sessionId);
-                    // Save session for next message
-                    if (newSessionId) {
-                        state.sessionId = newSessionId;
-                    }
-                }
-                catch (error) {
-                    sendResponse({
-                        type: "error",
-                        id: message.id,
-                        error: error.message || "Error desconocido",
-                    });
-                }
-                finally {
-                    state.claudeProcess = null;
-                    state.currentRequestId = null;
-                }
-                break;
-            default:
-                sendResponse({
-                    type: "error",
-                    id: message.id || "unknown",
-                    error: `Tipo de mensaje desconocido: ${message.type}`,
-                });
-        }
-    }
-    catch (error) {
-        sendResponse({
-            type: "error",
-            id: "parse-error",
-            error: `Error parseando mensaje: ${error.message}`,
-        });
-    }
-}
-export async function assistantCommand(flags = {}) {
-    // Check login
-    if (!isLoggedIn()) {
-        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
-        process.exit(1);
-    }
-    // Check Claude Code is installed
-    try {
-        const { execSync } = await import("child_process");
-        execSync("claude --version", { stdio: "ignore" });
-    }
-    catch {
-        console.log(chalk.red("\n  ✗ Claude Code no encontrado."));
-        console.log(chalk.gray("    Instala con: npm install -g @anthropic-ai/claude-code\n"));
-        process.exit(1);
-    }
-    const port = typeof flags.port === "string" ? parseInt(flags.port, 10) : flags.port || DEFAULT_PORT;
-    const env = getCurrentEnv();
-    console.log(chalk.magenta("\n  🟣 Gufi Assistant\n"));
-    console.log(chalk.gray(`  Entorno: ${env === "prod" ? "Producción" : "Local"}`));
-    console.log(chalk.gray(`  Puerto WebSocket: ${port}`));
-    console.log();
-    // Create WebSocket server
-    const wss = new WebSocketServer({ port });
-    wss.on("listening", () => {
-        console.log(chalk.green(`  ✓ WebSocket server escuchando en ws://localhost:${port}`));
-        console.log();
-        console.log(chalk.cyan("  Conecta desde el frontend:"));
-        console.log(chalk.gray(`    1. Abre /developer/views/<id> en Gufi`));
-        console.log(chalk.gray(`    2. Click en "Edit with AI"`));
-        console.log(chalk.gray(`    3. El chat se conecta automáticamente aquí`));
-        console.log();
-        console.log(chalk.yellow("  Ctrl+C para detener\n"));
-    });
-    wss.on("connection", (ws) => {
-        console.log(chalk.green("  → Cliente conectado"));
-        // Initialize client state
-        clients.set(ws, {
-            ws,
-            claudeProcess: null,
-            currentRequestId: null,
-            sessionId: null,
-        });
-        // Send status message
-        ws.send(JSON.stringify({
-            type: "status",
-            id: "init",
-            content: "connected",
-        }));
-        ws.on("message", (data) => {
-            handleMessage(ws, data.toString());
-        });
-        ws.on("close", () => {
-            console.log(chalk.yellow("  ← Cliente desconectado"));
-            // Don't kill Claude process on disconnect - let it finish
-            // The client might reconnect (hot reload, etc.)
-            clients.delete(ws);
-        });
-        ws.on("error", (error) => {
-            console.log(chalk.red(`  ✗ Error WebSocket: ${error.message}`));
-        });
-    });
-    wss.on("error", (error) => {
-        if (error.code === "EADDRINUSE") {
-            console.log(chalk.red(`\n  ✗ Puerto ${port} ya está en uso.`));
-            console.log(chalk.gray(`    Usa: gufi assistant --port <otro-puerto>\n`));
-        }
-        else {
-            console.log(chalk.red(`\n  ✗ Error: ${error.message}\n`));
-        }
-        process.exit(1);
-    });
-    // Handle graceful shutdown
-    process.on("SIGINT", () => {
-        console.log(chalk.yellow("\n  Cerrando servidor..."));
-        // Kill all Claude processes with SIGKILL (force)
-        for (const state of clients.values()) {
-            if (state.claudeProcess) {
-                state.claudeProcess.kill("SIGKILL");
-            }
-        }
-        // Close all WebSocket connections
-        for (const client of wss.clients) {
-            client.terminate();
-        }
-        // Force exit after 1 second max
-        setTimeout(() => {
-            console.log(chalk.green("  ✓ Servidor cerrado\n"));
-            process.exit(0);
-        }, 500);
-        wss.close();
-    });
-}