gufi-cli 0.1.37 → 0.1.39

package/dist/commands/assistant.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1,377 @@
+/**
+ * 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();
+    });
+}

package/dist/index.js

@@ -82,11 +82,14 @@ import { doctorCommand } from "./commands/doctor.js";
 import { docsCommand } from "./commands/docs.js";
 import { startMcpServer } from "./mcp.js";
 import { claudeCommand } from "./commands/claude.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
 const program = new Command();
 program
     .name("gufi")
     .description("🟣 Gufi CLI - Desarrolla módulos, vistas y automations")
-    .version("0.1.8");
+    .version(pkg.version);
 // ════════════════════════════════════════════════════════════════════
 // 🔐 Auth
 // ════════════════════════════════════════════════════════════════════

package/dist/mcp.js

@@ -37,19 +37,36 @@ const DEFAULT_ENV = "prod";
 /**
  * Get API URL for the specified environment.
  * @param env - 'prod' (default) or 'dev' (localhost:3000 → Cloud SQL Dev)
+ *
+ * Uses resolveEnv() which is STRICT - invalid values throw errors.
  */
 function getApiUrl(env) {
-    const resolvedEnv = (env === "dev" || env === "local" || env === "prod") ? env : DEFAULT_ENV;
+    const resolvedEnv = resolveEnv(env);
     return ENV_URLS[resolvedEnv];
 }
 /**
  * Resolve env parameter to canonical form ('prod' or 'dev')
  * 'local' is treated as alias for 'dev'
+ *
+ * IMPORTANT: This function is STRICT to prevent accidental prod modifications.
+ * - undefined/null → defaults to 'prod' (backwards compatible)
+ * - 'prod', 'dev', 'local' → valid values
+ * - Any other value → THROWS ERROR (prevents typos like 'dve' from hitting prod)
  */
 function resolveEnv(env) {
+    // Undefined/null → default to prod (backwards compatible)
+    if (env === undefined || env === null || env === "") {
+        return "prod";
+    }
+    // Valid values
     if (env === "dev" || env === "local")
         return "dev";
-    return "prod";
+    if (env === "prod")
+        return "prod";
+    // STRICT: Unknown value = ERROR, not silent fallback to prod
+    // This prevents typos like 'dve' or 'Dev' from accidentally modifying prod
+    throw new Error(`Invalid environment: '${env}'. Valid values are 'prod', 'dev', or 'local'. ` +
+        `This error prevents accidental production modifications.`);
 }
 // Keep for backwards compatibility (some internal functions may use this)
 function getSessionApiUrl() {
@@ -871,23 +888,24 @@ const toolHandlers = {
     async gufi_context(params) {
         // Generate intelligent context based on what's requested
         // Always returns FULL context (no more "detail" parameter)
+        const env = params.env;
         // Module-specific context
         if (params.module_id && params.company_id) {
-            return getClaudeOptimizedContext(params.company_id, params.module_id, undefined, true);
+            return getClaudeOptimizedContext(params.company_id, params.module_id, undefined, true, env);
         }
         // Entity-specific context
         if (params.entity_id && params.company_id) {
-            return getClaudeOptimizedContext(params.company_id, undefined, params.entity_id, true);
+            return getClaudeOptimizedContext(params.company_id, undefined, params.entity_id, true, env);
         }
         if (params.view_id) {
-            return generateViewContextMcp(parseInt(params.view_id), true);
+            return generateViewContextMcp(parseInt(params.view_id), true, env);
         }
         else if (params.package_id) {
-            return generatePackageContextMcp(parseInt(params.package_id), true);
+            return generatePackageContextMcp(parseInt(params.package_id), true, env);
         }
         else if (params.company_id) {
             // Company context - always full
-            return getClaudeOptimizedContext(params.company_id, undefined, undefined, true);
+            return getClaudeOptimizedContext(params.company_id, undefined, undefined, true, env);
         }
         else {
             // Auto-detect context from current directory
@@ -922,10 +940,10 @@ const toolHandlers = {
             // 2. Check if we're in a view directory (.gufi-view.json)
             const viewMeta = loadViewMetaFromCwd();
             if (viewMeta) {
-                return generateViewContextMcp(viewMeta.viewId, true);
+                return generateViewContextMcp(viewMeta.viewId, true, env);
             }
             // 3. Fallback: Return packages overview
-            const response = await developerRequest("/my-packages");
+            const response = await developerRequest("/my-packages", {}, true, env);
             const packages = response.data || [];
             return {
                 type: "packages_overview",
@@ -983,7 +1001,7 @@ const toolHandlers = {
                 preview: params.preview || false,
                 skip_existing: params.skip_existing || false,
             }),
-        }, params.company_id);
+        }, params.company_id, true, params.env);
         if (params.preview) {
             return {
                 preview: true,
@@ -1261,7 +1279,7 @@ const toolHandlers = {
         }
         const data = await apiRequest(endpoint, {
             headers: { "X-Company-ID": params.company_id },
-        });
+        }, params.company_id, true, params.env);
         return { executions: data.data || data || [] };
     },
     // ─────────────────────────────────────────────────────────────────────────
@@ -1387,10 +1405,10 @@ const toolHandlers = {
     // Environment Variables
     // ─────────────────────────────────────────────────────────────────────────
     async gufi_env(params) {
-        const { action, company_id, key, value } = params;
+        const { action, company_id, key, value, env } = params;
         switch (action) {
             case "list": {
-                const data = await apiRequest("/api/cli/env", {}, company_id);
+                const data = await apiRequest("/api/cli/env", {}, company_id, true, env);
                 return { variables: data || [] };
             }
             case "set": {
@@ -1399,7 +1417,7 @@ const toolHandlers = {
                 await apiRequest("/api/cli/env", {
                     method: "POST",
                     body: JSON.stringify({ key, value }),
-                }, company_id);
+                }, company_id, true, env);
                 return { success: true, key };
             }
             case "delete": {
@@ -1407,7 +1425,7 @@ const toolHandlers = {
                     throw new Error("key required for action 'delete'");
                 await apiRequest(`/api/cli/env/${encodeURIComponent(key)}`, {
                     method: "DELETE",
-                }, company_id);
+                }, company_id, true, env);
                 return { success: true, key };
             }
             default:
@@ -1420,8 +1438,9 @@ const toolHandlers = {
     async gufi_view_pull(params) {
         const viewId = params.view_id;
         const companyId = params.company_id;
+        const env = params.env;
         // Get view info for package_id (pass company_id for access check)
-        const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`, {}, companyId);
+        const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`, {}, companyId, true, env);
         const view = viewResponse.data || viewResponse;
         // 💜 Backend returns pk_id, not id
         if (!view || !view.pk_id) {
@@ -1444,6 +1463,7 @@ const toolHandlers = {
     async gufi_view_push(params) {
         let viewDir;
         let viewId = params.view_id;
+        const env = params.env;
         // If view_id provided, get dir from it
         if (viewId) {
             viewDir = getViewDir(`view_${viewId}`);
@@ -1459,7 +1479,7 @@ const toolHandlers = {
         // Get view info for package
         let packageInfo = null;
         if (viewId) {
-            const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`);
+            const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`, {}, undefined, true, env);
             const view = viewResponse.data || viewResponse;
             if (view.package_id) {
                 packageInfo = { id: view.package_id, publish_cmd: `gufi package:publish ${view.package_id}` };
@@ -1483,10 +1503,10 @@ const toolHandlers = {
     // Packages
     // ─────────────────────────────────────────────────────────────────────────
     async gufi_package(params) {
-        const { action, id, name, description, module_id, company_id } = params;
+        const { action, id, name, description, module_id, company_id, env } = params;
         switch (action) {
             case "list": {
-                const response = await developerRequest("/my-packages");
+                const response = await developerRequest("/my-packages", {}, true, env);
                 const packages = response.data || [];
                 return {
                     packages: packages.map((p) => ({
@@ -1502,11 +1522,11 @@ const toolHandlers = {
             case "get": {
                 if (!id)
                     throw new Error("id required for action 'get'");
-                const response = await developerRequest(`/packages/${id}`);
+                const response = await developerRequest(`/packages/${id}`, {}, true, env);
                 const pkg = response.data;
                 let views = [];
                 try {
-                    const viewsResponse = await developerRequest(`/packages/${id}/views`);
+                    const viewsResponse = await developerRequest(`/packages/${id}/views`, {}, true, env);
                     views = viewsResponse.data || [];
                 }
                 catch { }
@@ -1543,13 +1563,13 @@ const toolHandlers = {
                         version: "1.0.0",
                         status: "draft",
                     }),
-                });
+                }, true, env);
                 return { success: true, package: response.data };
             }
             case "delete": {
                 if (!id)
                     throw new Error("id required for action 'delete'");
-                await developerRequest(`/packages/${id}`, { method: "DELETE" });
+                await developerRequest(`/packages/${id}`, { method: "DELETE" }, true, env);
                 return { success: true };
             }
             case "add_module": {
@@ -1561,7 +1581,7 @@ const toolHandlers = {
                         companyId: parseInt(company_id),
                         moduleId: parseInt(module_id),
                     }),
-                });
+                }, true, env);
                 return { success: true, module: response.data };
             }
             case "remove_module": {
@@ -1569,7 +1589,7 @@ const toolHandlers = {
                     throw new Error("id and module_id required for action 'remove_module'");
                 await developerRequest(`/packages/${id}/modules/${module_id}`, {
                     method: "DELETE",
-                });
+                }, true, env);
                 return { success: true };
             }
             case "publish": {
@@ -1577,7 +1597,7 @@ const toolHandlers = {
                     throw new Error("id required for action 'publish'");
                 const response = await developerRequest(`/packages/${id}/publish`, {
                     method: "POST",
-                });
+                }, true, env);
                 return { success: true, status: response.data?.status, version: response.data?.version };
             }
             default:
@@ -1596,8 +1616,9 @@ const toolHandlers = {
  * @param moduleId - Optional module ID to filter by
  * @param entityId - Optional entity ID to filter by
  * @param fullText - If true, return as plain text. Otherwise return structured.
+ * @param env - Environment: 'prod' (default) or 'dev'
  */
-async function getClaudeOptimizedContext(companyId, moduleId, entityId, fullText = true) {
+async function getClaudeOptimizedContext(companyId, moduleId, entityId, fullText = true, env) {
     // Build query params
     const params = new URLSearchParams();
     if (moduleId)
@@ -1605,12 +1626,14 @@ async function getClaudeOptimizedContext(companyId, moduleId, entityId, fullText
     if (entityId)
         params.set("entity_id", entityId);
     const queryString = params.toString();
-    const url = `${getSessionApiUrl()}/api/schema/export-claude${queryString ? "?" + queryString : ""}`;
-    let token = getToken();
+    const apiUrl = getApiUrl(env);
+    const url = `${apiUrl}/api/schema/export-claude${queryString ? "?" + queryString : ""}`;
+    const resolvedEnv = resolveEnv(env);
+    let token = getTokenForEnv(resolvedEnv);
     if (!token) {
-        token = await autoLogin();
+        token = await autoLoginWithEnv(env);
         if (!token)
-            throw new Error("Not logged in. Run: gufi login");
+            throw new Error(`Not logged in for env '${resolvedEnv}'. Run: gufi login`);
     }
     const headers = {
         Authorization: `Bearer ${token}`,
@@ -1645,15 +1668,15 @@ async function getClaudeOptimizedContext(companyId, moduleId, entityId, fullText
         schema,
     };
 }
-async function generateViewContextMcp(viewId, includeConcepts) {
+async function generateViewContextMcp(viewId, includeConcepts, env) {
     // Use apiRequest for view details
-    const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`);
+    const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`, {}, undefined, true, env);
     const view = viewResponse.data || viewResponse;
     // Get package info if exists
     let pkg = null;
     if (view.package_id) {
         try {
-            const pkgResponse = await developerRequest(`/packages/${view.package_id}`);
+            const pkgResponse = await developerRequest(`/packages/${view.package_id}`, {}, true, env);
             pkg = pkgResponse.data || pkgResponse;
         }
         catch { }
@@ -1681,17 +1704,17 @@ async function generateViewContextMcp(viewId, includeConcepts) {
         try {
             const modulesResponse = await apiRequest(`/api/company/schema`, {
                 headers: { "X-Company-ID": String(viewCompanyId) },
-            }, String(viewCompanyId));
+            }, String(viewCompanyId), true, env);
             modules = modulesResponse.modules || modulesResponse.data?.modules || [];
         }
         catch { }
         try {
-            const automationsResponse = await apiRequest(`/api/automation-scripts`, {}, String(viewCompanyId));
+            const automationsResponse = await apiRequest(`/api/automation-scripts`, {}, String(viewCompanyId), true, env);
             automations = Array.isArray(automationsResponse) ? automationsResponse : automationsResponse.data || [];
         }
         catch { }
         try {
-            const envResponse = await apiRequest(`/api/cli/env`, {}, String(viewCompanyId));
+            const envResponse = await apiRequest(`/api/cli/env`, {}, String(viewCompanyId), true, env);
             envVars = Array.isArray(envResponse) ? envResponse : envResponse.data || [];
         }
         catch { }
@@ -1756,14 +1779,14 @@ async function generateViewContextMcp(viewId, includeConcepts) {
     }
     return result;
 }
-async function generatePackageContextMcp(packageId, includeConcepts) {
+async function generatePackageContextMcp(packageId, includeConcepts, env) {
     // Use developerRequest which has correct path /api/developer/...
-    const response = await developerRequest(`/packages/${packageId}`);
+    const response = await developerRequest(`/packages/${packageId}`, {}, true, env);
     const pkg = response.data || response;
     // Get views
     let views = [];
     try {
-        const viewsResponse = await developerRequest(`/packages/${packageId}/views`);
+        const viewsResponse = await developerRequest(`/packages/${packageId}/views`, {}, true, env);
         views = viewsResponse.data || [];
     }
     catch { }

package/package.json

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

package/dist/commands/install.d.ts

@@ -1,21 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,137 +0,0 @@
-/**
- * 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
-`));
-}