gufi-cli 0.1.41 → 0.1.44

package/CLAUDE.md

@@ -10,7 +10,7 @@
 tools/cli/
 ├── src/
 │   ├── index.ts          # Entry point CLI
-│   ├── mcp.ts            # MCP Server (12 tools)
+│   ├── mcp.ts            # MCP Server (15 tools)
 │   ├── commands/         # Comandos CLI
 │   │   ├── context.ts    # gufi context
 │   │   ├── pull.ts       # gufi view:pull
@@ -55,9 +55,9 @@ gufi config:prod
 }
 ```
 
-## MCP Server - 13 Tools
+## MCP Server - 15 Tools
 
-El servidor MCP está en `src/mcp.ts` y expone **13 tools** para que Claude interactúe con Gufi.
+El servidor MCP está en `src/mcp.ts` y expone **15 tools** para que Claude interactúe con Gufi.
 
 ### Tools organizados por categoría
 
@@ -67,10 +67,12 @@ El servidor MCP está en `src/mcp.ts` y expone **13 tools** para que Claude inte
 | | `gufi_whoami` | Usuario, entorno, empresas |
 | | `gufi_docs` | Documentación (`docs/mcp/`) |
 | **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 |
-| **Data** | `gufi_data` | CRUD: list, get, create, update, delete |
+| **Automations** | `gufi_automation_scripts` | Scripts: list, get, create, update, delete |
+| | `gufi_automation_script_test` | Testear script manualmente |
+| | `gufi_automation_meta` | Ver/configurar triggers por entidad |
+| | `gufi_automation_integrations` | Integraciones built-in (Stripe, Nayax, etc.) |
+| | `gufi_automation_executions` | Historial de ejecuciones |
+| **Data** | `gufi_data` | CRUD: list, get, create, update, delete, aggregate |
 | **Env** | `gufi_env` | Variables: list, set, delete |
 | **Views** | `gufi_view_pull` | Descargar vista a local |
 | | `gufi_view_push` | Subir cambios a draft |
@@ -165,12 +167,14 @@ export async function miComando(args: string[], flags: Flags) {
 ```
 gufi view:pull <id>       → ~/gufi-dev/view_<id>/
 # Editar archivos locales
-gufi view:push            → Sync completo
+gufi view:push            → Sync completo + registra automations
 gufi package:publish <id> → Publicar
 ```
 
 **Push = sync completo**: Sube TODOS los archivos, servidor borra los que no vengan.
 
+**Automations**: Si existe `core/automations.ts`, push detecta las automations declaradas y las registra en `__automation_meta__` con `trigger_event='CUSTOM'`.
+
 ## Config (~/.gufi/)
 
 ```

package/README.md

@@ -509,12 +509,11 @@ El MCP expone todas las funcionalidades del CLI como tools que Claude puede usar
 | `gufi_module_update` | Actualizar módulo desde JSON |
 | `gufi_module_create` | Crear módulo nuevo |
 | **Automations** | |
-| `gufi_automations` | Listar scripts de automation |
-| `gufi_automation` | Ver código de un automation |
-| `gufi_automation_create` | Crear/actualizar automation |
-| `gufi_entity_automations` | Ver triggers de una entidad |
-| `gufi_entity_automations_update` | Actualizar triggers |
-| `gufi_automations_executions` | Ver historial de ejecuciones |
+| `gufi_automation_scripts` | CRUD de scripts (list, get, create, update, delete) |
+| `gufi_automation_meta` | Ver/configurar triggers por entidad |
+| `gufi_automation_integrations` | Ver integraciones built-in (Stripe, Nayax, etc.) |
+| `gufi_automation_script_test` | Testear un script manualmente |
+| `gufi_automation_executions` | Ver historial de ejecuciones |
 | **Datos** | |
 | `gufi_rows` | Listar registros de una tabla |
 | `gufi_row` | Ver un registro específico |
@@ -546,7 +545,7 @@ Una vez configurado, puedes hablar naturalmente con Claude:
 → Claude usa gufi_module para leer, modifica, y usa gufi_module_update
 
 "Crea un automation que envíe email cuando un pedido pase a 'enviado'"
-→ Claude usa gufi_automations para ver existentes, crea código, usa gufi_automation_create
+→ Claude usa gufi_automation_scripts para ver existentes, crea código, configura con gufi_automation_meta
 
 "¿Cuántos registros hay en la tabla de clientes?"
 → Claude usa gufi_rows para consultar

package/dist/commands/companies.js

@@ -1496,9 +1496,9 @@ export async function automationExecuteCommand(automationIdOrName, options) {
                 process.exit(1);
             }
         }
-        // 💜 Execute automation via triggerClick endpoint
+        // 💜 Execute automation
         console.log(chalk.yellow("\n  ⏳ Ejecutando..."));
-        const result = await apiRequest("/api/automation-scripts/triggerClick", {
+        const result = await apiRequest("/api/automation-scripts/run", {
             method: "POST",
             headers: { "X-Company-ID": companyId },
             body: JSON.stringify({

package/dist/commands/context.js

@@ -367,12 +367,10 @@ function generateRelevantConcepts(dataSources, inputs, automations) {
     // automations concept
     if (automations.length > 0) {
         md += `### Llamar Automations\n`;
-        md += `Puedes ejecutar automations de tipo \`click\` desde la vista:\n`;
+        md += `Puedes ejecutar automations desde la vista con \`gufi.automation()\`:\n`;
         md += "```typescript\n";
-        md += `await gufi.dataProvider.runClickAutomation?.({\n`;
-        md += `  company_id: companyId,\n`;
-        md += `  function_name: "${automations[0]?.function_name || "mi_automation"}",\n`;
-        md += `  input: { /* parámetros */ },\n`;
+        md += `const result = await gufi.automation("${automations[0]?.function_name || "mi_automation"}", {\n`;
+        md += `  // input parameters\n`;
         md += `});\n`;
         md += "```\n\n";
     }

package/dist/commands/integrations.d.ts

@@ -0,0 +1,10 @@
+/**
+ * gufi integrations - List available integrations and their methods
+ *
+ * Usage:
+ *   gufi integrations    # List all integrations with methods
+ */
+/**
+ * List all integrations with their methods
+ */
+export declare function integrationsCommand(): Promise<void>;

package/dist/commands/integrations.js

@@ -0,0 +1,53 @@
+/**
+ * gufi integrations - List available integrations and their methods
+ *
+ * Usage:
+ *   gufi integrations    # List all integrations with methods
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Path to integrations folder
+const INTEGRATIONS_PATH = path.resolve(__dirname, "../../../../backend/src/features/automations/core/api/integrations");
+/**
+ * List all integrations with their methods
+ */
+export async function integrationsCommand() {
+    const integrations = await loadIntegrations();
+    console.log(chalk.bold.magenta("\n🔌 Gufi Integrations\n"));
+    for (const [name, integration] of Object.entries(integrations)) {
+        const methodCount = Object.keys(integration.methods).length;
+        console.log(`  ${chalk.cyan(name.padEnd(12))} ${chalk.gray(integration.meta.description)} ${chalk.yellow(`(${methodCount} methods)`)}`);
+        for (const [methodName, method] of Object.entries(integration.methods)) {
+            console.log(`    ${chalk.white("•")} ${methodName} - ${chalk.gray(method.description)}`);
+        }
+        console.log();
+    }
+}
+async function loadIntegrations() {
+    const integrations = {};
+    const dirs = fs.readdirSync(INTEGRATIONS_PATH, { withFileTypes: true });
+    for (const dir of dirs) {
+        if (!dir.isDirectory())
+            continue;
+        const integrationPath = path.join(INTEGRATIONS_PATH, dir.name, "integration.js");
+        if (!fs.existsSync(integrationPath))
+            continue;
+        try {
+            const module = await import(`file://${integrationPath}`);
+            if (module.meta && module.methods) {
+                integrations[module.meta.name] = {
+                    meta: module.meta,
+                    methods: module.methods,
+                };
+            }
+        }
+        catch (err) {
+            console.error(chalk.yellow(`Warning: Could not load ${dir.name}: ${err.message}`));
+        }
+    }
+    return integrations;
+}

package/dist/index.js

@@ -80,6 +80,7 @@ import { configCommand, configLocalCommand, configProdCommand, configSetCommand,
 import { contextCommand } from "./commands/context.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { docsCommand } from "./commands/docs.js";
+import { integrationsCommand } from "./commands/integrations.js";
 import { startMcpServer } from "./mcp.js";
 import { claudeCommand } from "./commands/claude.js";
 import { createRequire } from "module";
@@ -163,6 +164,13 @@ program
     docsCommand(args);
 });
 // ════════════════════════════════════════════════════════════════════
+// 🔌 Integrations
+// ════════════════════════════════════════════════════════════════════
+program
+    .command("integrations")
+    .description("Listar integraciones disponibles con sus métodos")
+    .action(integrationsCommand);
+// ════════════════════════════════════════════════════════════════════
 // 🏢 Companies & Modules
 // ════════════════════════════════════════════════════════════════════
 program

package/dist/lib/sync.js

@@ -8,6 +8,7 @@ import os from "os";
 import crypto from "crypto";
 import { getViewFiles, saveViewFiles } from "./api.js";
 import { setCurrentView, getCurrentView } from "./config.js";
+// 💜 Views go to ~/gufi-dev/ for local development
 const GUFI_DEV_DIR = path.join(os.homedir(), "gufi-dev");
 const META_FILE = ".gufi-view.json";
 function ensureDir(dir) {

package/dist/mcp.js

@@ -13,14 +13,102 @@
 import * as readline from "readline";
 import * as fs from "fs";
 import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
 import { fileURLToPath } from "url";
-import { getToken, getRefreshToken, loadConfig, isLoggedIn, getTokenForEnv, getRefreshTokenForEnv, setTokenForEnv, getCredentialsForEnv } from "./lib/config.js";
-import { pullView, pushView, getViewDir, loadViewMeta } from "./lib/sync.js";
+// 💜 Local storage for CLI: ~/gufi-dev/
+const LOCAL_VIEWS_DIR = path.join(os.homedir(), "gufi-dev");
+// 💜 Auto-detect if we should use local filesystem or workspace BD
+// In server (Docker), use GUFI_USE_WORKSPACE=true to force workspace BD
+function canWriteLocal() {
+    // Server mode: force workspace BD instead of local filesystem
+    if (process.env.GUFI_USE_WORKSPACE === "true") {
+        return false;
+    }
+    try {
+        fs.mkdirSync(LOCAL_VIEWS_DIR, { recursive: true });
+        const testFile = path.join(LOCAL_VIEWS_DIR, ".write-test");
+        fs.writeFileSync(testFile, "test");
+        fs.unlinkSync(testFile);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+import { getToken, getRefreshToken, loadConfig, isLoggedIn, getTokenForEnv, getRefreshTokenForEnv, setTokenForEnv, getCredentialsForEnv, getCurrentEnv } from "./lib/config.js";
 // For ES modules __dirname equivalent
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // docs/mcp path relative to CLI
 const DOCS_MCP_PATH = path.resolve(__dirname, "../../../docs/mcp");
+// docs/dev-guide path for integration docs
+const DOCS_DEV_GUIDE_PATH = path.resolve(__dirname, "../../../docs/dev-guide");
+/**
+ * Parse frontmatter from markdown content
+ */
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const [, frontmatterStr, body] = match;
+    const frontmatter = {};
+    frontmatterStr.split('\n').forEach(line => {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.slice(0, colonIndex).trim();
+            let value = line.slice(colonIndex + 1).trim();
+            // Remove quotes
+            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            frontmatter[key] = value;
+        }
+    });
+    return { frontmatter, body: body.trim() };
+}
+/**
+ * Get all integration docs from docs/dev-guide/
+ * Returns docs that have group: integrations in frontmatter
+ */
+function getIntegrationDocs() {
+    try {
+        if (!fs.existsSync(DOCS_DEV_GUIDE_PATH)) {
+            return [];
+        }
+        const files = fs.readdirSync(DOCS_DEV_GUIDE_PATH).filter(f => f.endsWith('.md'));
+        const integrations = [];
+        for (const file of files) {
+            const filePath = path.join(DOCS_DEV_GUIDE_PATH, file);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const { frontmatter, body } = parseFrontmatter(content);
+            // Only include docs with group: integrations
+            if (frontmatter.group === 'integrations') {
+                integrations.push({
+                    id: frontmatter.id || file.replace('.md', ''),
+                    title: frontmatter.title || '',
+                    description: frontmatter.description || '',
+                    content: body,
+                });
+            }
+        }
+        // Sort by filename order (2-06, 2-07, etc.)
+        return integrations;
+    }
+    catch (err) {
+        console.error('[MCP] Error reading integration docs:', err);
+        return [];
+    }
+}
+/**
+ * Get a specific integration doc by name/id
+ */
+function getIntegrationDoc(name) {
+    const docs = getIntegrationDocs();
+    return docs.find(d => d.id === name || d.id === name.toLowerCase()) || null;
+}
 // ════════════════════════════════════════════════════════════════════════════
 // Environment Configuration (stateless - passed per request)
 // ════════════════════════════════════════════════════════════════════════════
@@ -32,11 +120,19 @@ const ENV_URLS = {
     dev: "http://localhost:3000",
     local: "http://localhost:3000", // Alias for backwards compatibility
 };
-// Default environment - always prod for safety
-const DEFAULT_ENV = "prod";
+// 💜 Default environment - read from config file (set by Gufi AI based on gufiEnv)
+function getDefaultEnv() {
+    try {
+        const configEnv = getCurrentEnv();
+        return configEnv === "local" ? "dev" : "prod";
+    }
+    catch {
+        return "prod"; // Fallback if config not available
+    }
+}
 /**
  * Get API URL for the specified environment.
- * @param env - 'prod' (default) or 'dev' (localhost:3000 → Cloud SQL Dev)
+ * @param env - 'prod' or 'dev' (localhost:3000). If not specified, uses config's currentEnv.
  *
  * Uses resolveEnv() which is STRICT - invalid values throw errors.
  */
@@ -49,14 +145,14 @@ function getApiUrl(env) {
  * 'local' is treated as alias for 'dev'
  *
  * IMPORTANT: This function is STRICT to prevent accidental prod modifications.
- * - undefined/null → defaults to 'prod' (backwards compatible)
+ * - undefined/null → defaults to config's currentEnv (set by Gufi AI)
  * - '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)
+    // Undefined/null → default to config's currentEnv
     if (env === undefined || env === null || env === "") {
-        return "prod";
+        return getDefaultEnv();
     }
     // Valid values
     if (env === "dev" || env === "local")
@@ -70,7 +166,7 @@ function resolveEnv(env) {
 }
 // Keep for backwards compatibility (some internal functions may use this)
 function getSessionApiUrl() {
-    return ENV_URLS[DEFAULT_ENV];
+    return ENV_URLS[getDefaultEnv()];
 }
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 const viewFilesCache = new Map();
@@ -183,7 +279,7 @@ async function trackAnalytics(data) {
 // API Client (reused from CLI)
 // ════════════════════════════════════════════════════════════════════════════
 async function autoLogin() {
-    return autoLoginWithEnv(DEFAULT_ENV);
+    return autoLoginWithEnv(getDefaultEnv());
 }
 async function autoLoginWithEnv(env) {
     const resolvedEnv = resolveEnv(env);
@@ -210,7 +306,7 @@ async function autoLoginWithEnv(env) {
     }
 }
 async function refreshOrLogin() {
-    return refreshOrLoginWithEnv(DEFAULT_ENV);
+    return refreshOrLoginWithEnv(getDefaultEnv());
 }
 async function refreshOrLoginWithEnv(env) {
     const resolvedEnv = resolveEnv(env);
@@ -552,22 +648,23 @@ const TOOLS = [
             },
         },
     },
+    // ─────────────────────────────────────────────────────────────────────────
+    // Automations (Business Logic)
+    // ─────────────────────────────────────────────────────────────────────────
     {
         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.",
+        description: getDesc("gufi_automation_integrations"),
         inputSchema: {
             type: "object",
             properties: {
                 name: { type: "string", description: "Integration name to get detailed info (optional)" },
+                env: ENV_PARAM,
             },
         },
     },
-    // ─────────────────────────────────────────────────────────────────────────
-    // Automations (Business Logic)
-    // ─────────────────────────────────────────────────────────────────────────
     {
-        name: "gufi_automation",
-        description: getDesc("gufi_automation"),
+        name: "gufi_automation_scripts",
+        description: getDesc("gufi_automation_scripts"),
         inputSchema: {
             type: "object",
             properties: {
@@ -583,33 +680,54 @@ const TOOLS = [
         },
     },
     {
-        name: "gufi_automation_test",
-        description: "Ejecutar/testear un automation script manualmente.\n\nEjemplo:\ngufi_automation_test({\n  company_id: '116',\n  script_name: 'send_email',\n  entity: 'ventas.facturas',\n  trigger_event: 'on_click',\n  row: { id: 123, total: 150 },\n  input: { email_to: 'test@example.com' }  // Para on_click\n})",
+        name: "gufi_automation_script_test",
+        description: `Ejecutar/testear un automation script manualmente.
+
+Ejemplos:
+  # Con entidad (la mayoría de casos)
+  gufi_automation_script_test({
+    company_id: '116',
+    script_name: 'send_email',
+    entity: 'ventas.facturas',  // nombre lógico, se resuelve automáticamente
+    trigger_event: 'on_click',
+    row: { id: 123, total: 150 },
+    input: { email_to: 'test@example.com' }
+  })
+
+  # Script standalone (sin entidad vinculada)
+  gufi_automation_script_test({
+    company_id: '116',
+    script_name: 'daily_report',
+    trigger_event: 'scheduled',
+    input: { date: '2024-01-15' }
+  })
+
+IMPORTANTE: Usa nombres lógicos (module.entity) NO IDs físicos.`,
         inputSchema: {
             type: "object",
             properties: {
                 company_id: { type: "string", description: "Company ID" },
                 script_name: { type: "string", description: "Script name to execute" },
-                entity: { type: "string", description: "Entity name (module.entity format like 'ventas.facturas')" },
-                trigger_event: { type: "string", description: "Trigger event: on_create, on_update, on_delete, on_click" },
-                row: { type: "object", description: "Row data to pass to the script (must include id)" },
-                input: { type: "object", description: "Input data for on_click triggers (goes to context.input)" },
+                entity: { type: "string", description: "Entity name (module.entity format). Optional for standalone scripts." },
+                trigger_event: { type: "string", description: "Trigger event: on_create, on_update, on_delete, on_click, scheduled" },
+                row: { type: "object", description: "Row data (goes to context.row). Include 'id' field." },
+                input: { type: "object", description: "Input data (goes to context.input). For on_click or standalone scripts." },
                 env: ENV_PARAM,
             },
-            required: ["company_id", "script_name", "entity", "trigger_event", "row"],
+            required: ["company_id", "script_name", "trigger_event"],
         },
     },
     {
-        name: "gufi_triggers",
-        description: getDesc("gufi_triggers"),
+        name: "gufi_automation_meta",
+        description: getDesc("gufi_automation_meta"),
         inputSchema: {
             type: "object",
             properties: {
                 entity_id: { type: "string", description: "Entity ID" },
                 company_id: { type: "string", description: "Company ID" },
-                config: {
-                    type: "object",
-                    description: "Trigger config to SET (omit to GET current config). Format: { on_create: [...], on_update: [...], on_delete: [...], on_click: [...] }",
+                automations: {
+                    type: "array",
+                    description: "Array of automations to SET (omit to GET current). Each: { trigger: 'insert'|'update'|'delete'|'click'|'scheduled'|'custom', function_name: 'script_name' }. NOTA: CUSTOM se registra automáticamente al hacer view_push con core/automations.ts",
                 },
                 env: ENV_PARAM,
             },
@@ -617,8 +735,8 @@ const TOOLS = [
         },
     },
     {
-        name: "gufi_executions",
-        description: getDesc("gufi_executions"),
+        name: "gufi_automation_executions",
+        description: getDesc("gufi_automation_executions"),
         inputSchema: {
             type: "object",
             properties: {
@@ -710,6 +828,9 @@ Example: gufi_view_pull({ view_id: 13 })`,
 Pushes changed files from ~/gufi-dev/view_<id>/ to Gufi draft.
 Creates a snapshot for version history (last 10 kept).
 
+⚠️ IMPORTANT: If core/automations.ts exists, declared automations are registered in __automation_meta__.
+Only automations declared in core/automations.ts can be called via gufi.automation().
+
 After pushing, use: gufi package:publish <package_id> to publish.
 
 Example: gufi_view_push({ view_id: 13, message: "Fixed bug in chart" })`,
@@ -732,21 +853,35 @@ Example: gufi_view_push({ view_id: 13, message: "Fixed bug in chart" })`,
             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)" },
+                timeout: { type: "number", description: "Navigation timeout in ms (default: 25000)" },
                 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}]",
+                    description: `Actions to perform. IMPORTANT workflow:
+1. First use 'explore' to list all interactive elements
+2. Then use 'click' with text selector: {type:'click', selector:'text:Button Text'}
+3. Use 'closeModals' to dismiss popups before interacting
+
+Examples:
+- Explore: {type:'explore'}
+- Click by text: {type:'click', selector:'text:Submit'}
+- Click by CSS: {type:'click', selector:'.my-button'}
+- Close modals: {type:'closeModals'}
+- Wait: {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" },
+                            type: { type: "string", description: "Action type: explore (list elements), click, closeModals, fill, clear, select, wait, waitForText, delay, scroll, hover, screenshot, getText, eval" },
+                            selector: { type: "string", description: "CSS selector OR 'text:Button Text' for click by visible text" },
+                            value: { type: "string", description: "Value for fill/select action" },
+                            text: { type: "string", description: "Text to wait for (waitForText)" },
                             ms: { type: "number", description: "Milliseconds for delay action" },
+                            y: { type: "number", description: "Pixels to scroll (scroll without selector)" },
+                            timeout: { type: "number", description: "Timeout for wait actions (default 5000)" },
+                            code: { type: "string", description: "JavaScript code to evaluate (eval action)" },
                         },
                     },
                 },
-                capture_screenshot: { type: "boolean", description: "Include base64 screenshot (default: true)" },
+                capture_screenshot: { type: "boolean", description: "Include base64 screenshot (default: false)" },
                 env: ENV_PARAM,
             },
             required: ["view_id", "company_id"],
@@ -899,7 +1034,7 @@ const toolHandlers = {
     // Context & Info
     // ─────────────────────────────────────────────────────────────────────────
     async gufi_whoami(params) {
-        const env = params.env || DEFAULT_ENV;
+        const env = params.env || getDefaultEnv();
         const config = loadConfig();
         const loggedIn = isLoggedIn();
         let companies = [];
@@ -1143,106 +1278,70 @@ const toolHandlers = {
             hint: "Use gufi_docs({ topic: 'fields' }) to read about field types, or gufi_docs({ search: 'currency' }) to search.",
         };
     },
+    // ─────────────────────────────────────────────────────────────────────────
+    // Automations
+    // ─────────────────────────────────────────────────────────────────────────
     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?"] },
-                ],
-            },
-        };
+        // Read integration docs from centralized docs/dev-guide/
+        const allDocs = getIntegrationDocs();
         if (name) {
-            const integration = integrations[name];
-            if (!integration) {
+            // Get specific integration doc
+            const doc = getIntegrationDoc(name);
+            if (!doc) {
+                // List available integrations on error
+                const available = allDocs
+                    .filter(d => d.id !== 'integrations-overview')
+                    .map(d => d.id);
                 return {
                     error: `Integration '${name}' not found`,
-                    available: Object.keys(integrations),
+                    available_integrations: available,
+                    hint: "Use one of the available integration names, or use gufi_automation_integrations() to see all",
                 };
             }
             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;
-}`,
+                name: doc.id,
+                title: doc.title,
+                description: doc.description,
+                documentation: doc.content,
+                usage: {
+                    step1: "Set up credentials in Environment Variables",
+                    step2: `In automation script: api.${doc.id}.methodName({ params })`,
+                    step3: "See documentation above for methods and examples",
+                },
             };
         }
         // List all integrations
+        const integrations = allDocs.filter(d => d.id !== 'integrations-overview');
+        const overview = allDocs.find(d => d.id === 'integrations-overview');
         return {
-            integrations: Object.values(integrations).map((i) => ({
-                name: i.name,
-                description: i.description,
-                category: i.category,
-                methods: i.methods.map((m) => m.name),
+            overview: overview ? {
+                title: overview.title,
+                description: overview.description,
+                content: overview.content,
+            } : {
+                description: "Connect automations to external services",
+                usage: "api.{integration}.{method}() or api.http() for custom",
+                credentials: "Use env.* variables for API keys",
+            },
+            integrations: integrations.map(d => ({
+                name: d.id,
+                title: d.title,
+                description: d.description,
             })),
-            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 }],
-});`,
+            custom_http: {
+                description: "For APIs without built-in integration, use api.http()",
+                example: `await api.http({
+  url: 'https://api.example.com/endpoint',
+  method: 'POST',
+  headers: { Authorization: 'Bearer ' + env.API_KEY },
+  body: { data: 'value' }
+})`,
+            },
+            hint: "Use gufi_automation_integrations({ name: 'stripe' }) for complete documentation of an integration",
         };
     },
-    // ─────────────────────────────────────────────────────────────────────────
-    // Automations
-    // ─────────────────────────────────────────────────────────────────────────
-    async gufi_automation(params) {
+    async gufi_automation_scripts(params) {
         const { action, company_id, id, name, code, description, env } = params;
         switch (action) {
             case "list": {
@@ -1322,45 +1421,51 @@ const result = await api.stripe.createCheckoutSession({
                 throw new Error(`Unknown action: ${action}. Use: list, get, create, update, delete`);
         }
     },
-    async gufi_automation_test(params) {
+    async gufi_automation_script_test(params) {
         const { company_id, script_name, entity, trigger_event, row, input, env } = params;
-        // Resolve entity to get module_id and table_id
-        const schema = await getCompanySchema(company_id, env);
-        if (!schema?.modules) {
-            throw new Error("Cannot get schema. Make sure company_id is correct.");
+        // Validate: need at least row or input
+        if (!row && !input) {
+            throw new Error("Must provide 'row' or 'input' (or both)");
         }
-        // Parse entity (module.entity format)
-        const parts = entity.split(".");
-        if (parts.length !== 2) {
-            throw new Error(`Invalid entity format: "${entity}". Use module.entity (e.g., 'ventas.facturas')`);
-        }
-        const [moduleName, entityName] = parts;
-        // Find module and entity IDs
         let moduleId = null;
         let tableId = null;
         let tableName = null;
-        for (const mod of schema.modules) {
-            const modMatch = mod.name?.toLowerCase() === moduleName.toLowerCase() ||
-                mod.label?.toLowerCase() === moduleName.toLowerCase();
-            if (!modMatch)
-                continue;
-            moduleId = mod.id;
-            for (const ent of mod.entities || []) {
-                const entMatch = ent.name?.toLowerCase() === entityName.toLowerCase() ||
-                    ent.label?.toLowerCase() === entityName.toLowerCase();
-                if (entMatch) {
-                    tableId = ent.id;
-                    tableName = `m${moduleId}_t${tableId}`;
-                    break;
+        // Resolve entity if provided (optional for standalone scripts)
+        if (entity) {
+            const schema = await getCompanySchema(company_id, env);
+            if (!schema?.modules) {
+                throw new Error("Cannot get schema. Make sure company_id is correct.");
+            }
+            // Parse entity (module.entity format)
+            const parts = entity.split(".");
+            if (parts.length !== 2) {
+                throw new Error(`Invalid entity format: "${entity}". Use module.entity (e.g., 'ventas.facturas')`);
+            }
+            const [moduleName, entityName] = parts;
+            // Find module and entity IDs
+            for (const mod of schema.modules) {
+                const modMatch = mod.name?.toLowerCase() === moduleName.toLowerCase() ||
+                    mod.label?.toLowerCase() === moduleName.toLowerCase();
+                if (!modMatch)
+                    continue;
+                moduleId = mod.id;
+                for (const ent of mod.entities || []) {
+                    const entMatch = ent.name?.toLowerCase() === entityName.toLowerCase() ||
+                        ent.label?.toLowerCase() === entityName.toLowerCase();
+                    if (entMatch) {
+                        tableId = ent.id;
+                        tableName = `m${moduleId}_t${tableId}`;
+                        break;
+                    }
                 }
+                if (tableId)
+                    break;
+            }
+            if (!moduleId || !tableId) {
+                throw new Error(`Entity "${entity}" not found in schema`);
             }
-            if (tableId)
-                break;
-        }
-        if (!moduleId || !tableId) {
-            throw new Error(`Entity "${entity}" not found in schema`);
         }
-        // Call test endpoint (same as backend: accepts row and/or input)
+        // Call test endpoint
         const response = await apiRequest("/api/automation-scripts/test", {
             method: "POST",
             body: JSON.stringify({
@@ -1370,29 +1475,37 @@ const result = await api.stripe.createCheckoutSession({
                 trigger_event,
                 table_id: tableId,
                 table_name: tableName,
-                row,
+                row: row || null,
                 input: input || null,
             }),
             headers: { "X-Company-ID": company_id },
         }, company_id, true, env);
-        return {
+        const result = {
             success: true,
             script_name,
-            entity,
             trigger_event,
-            result: response.data || response,
         };
+        if (entity) {
+            result.entity = entity;
+            result.resolved_table = tableName;
+        }
+        // Include script output if available
+        const scriptOutput = response.data || response;
+        if (scriptOutput && Object.keys(scriptOutput).length > 0) {
+            result.output = scriptOutput;
+        }
+        return result;
     },
-    async gufi_triggers(params) {
-        const { entity_id, company_id, config, env } = params;
-        if (config) {
-            // SET triggers
+    async gufi_automation_meta(params) {
+        const { entity_id, company_id, automations, env } = params;
+        if (automations) {
+            // SET triggers - backend expects array: [{ trigger: 'insert', function_name: 'my_script' }]
             await apiRequest(`/api/entities/${entity_id}/automations`, {
                 method: "PUT",
-                body: JSON.stringify(config),
+                body: JSON.stringify(automations),
                 headers: { "X-Company-ID": company_id },
             }, company_id, true, env);
-            return { success: true, entity_id, config };
+            return { success: true, entity_id, automations };
         }
         else {
             // GET triggers
@@ -1407,7 +1520,7 @@ const result = await api.stripe.createCheckoutSession({
             };
         }
     },
-    async gufi_executions(params) {
+    async gufi_automation_executions(params) {
         let endpoint = `/api/automation-executions?limit=${params.limit || 20}`;
         if (params.script_name) {
             endpoint += `&script=${encodeURIComponent(params.script_name)}`;
@@ -1574,58 +1687,136 @@ const result = await api.stripe.createCheckoutSession({
         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 useLocal = canWriteLocal();
+        // Get view info
         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) {
             return { error: `View ${viewId} not found` };
         }
-        const viewKey = `view_${viewId}`;
-        const packageId = view.package_id || 0;
-        // Pull using sync.ts
-        const result = await pullView(viewId, viewKey, packageId);
-        return {
-            success: true,
-            view_id: viewId,
-            name: view.name,
-            package_id: packageId || null,
-            local_path: result.dir,
-            files_count: result.fileCount,
-            _hint: `📥 View downloaded to ${result.dir}. Use Read/Edit tools to modify files. Then gufi_view_push({ view_id: ${viewId} }) to upload.`,
-        };
+        // Get view files
+        const filesResponse = await apiRequest(`/api/marketplace/views/${viewId}/files`, {}, companyId, true, env);
+        const files = Array.isArray(filesResponse) ? filesResponse : (filesResponse.data || []);
+        if (useLocal) {
+            // 💜 CLI: Save to ~/gufi-dev/view_<id>/
+            const viewDir = path.join(LOCAL_VIEWS_DIR, `view_${viewId}`);
+            fs.mkdirSync(viewDir, { recursive: true });
+            const fileMeta = {};
+            for (const file of files) {
+                const filePath = path.join(viewDir, file.file_path.replace(/^\//, ""));
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, file.content);
+                fileMeta[file.file_path] = {
+                    hash: crypto.createHash("sha256").update(file.content, "utf-8").digest("hex")
+                };
+            }
+            // Save metadata
+            const meta = {
+                viewId,
+                viewName: `view_${viewId}`,
+                packageId: view.package_id || 0,
+                lastSync: new Date().toISOString(),
+                files: fileMeta,
+            };
+            fs.writeFileSync(path.join(viewDir, ".gufi-view.json"), JSON.stringify(meta, null, 2));
+            return {
+                success: true,
+                view_id: viewId,
+                name: view.name,
+                package_id: view.package_id || null,
+                local_path: viewDir,
+                storage: "local",
+                files_count: files.length,
+                _hint: `📥 View downloaded to ${viewDir}/. Use Read/Edit tools to modify files. Then gufi_view_push({ view_id: ${viewId}, env: '${env || 'prod'}' }) to upload.`,
+            };
+        }
+        else {
+            // 💜 Web: Save to Claude Workspace BD
+            const saveResponse = await apiRequest(`/api/claude/workspace/view`, {
+                method: "POST",
+                body: JSON.stringify({ view_id: viewId, files }),
+            }, companyId, true, env);
+            const saveResult = saveResponse.data || saveResponse;
+            const viewFolder = saveResult?.folder || `views/view_${viewId}`;
+            return {
+                success: true,
+                view_id: viewId,
+                name: view.name,
+                package_id: view.package_id || null,
+                local_path: `~/workspace/${viewFolder}`,
+                storage: "workspace",
+                files_count: files.length,
+                _hint: `📥 View downloaded to Claude Workspace. Use Read/Edit tools to modify files. Then gufi_view_push({ view_id: ${viewId} }) to upload.`,
+            };
+        }
     },
     async gufi_view_push(params) {
-        let viewDir;
-        let viewId = params.view_id;
+        const viewId = params.view_id;
         const env = params.env;
-        // If view_id provided, get dir from it
-        if (viewId) {
-            viewDir = getViewDir(`view_${viewId}`);
+        const useLocal = canWriteLocal();
+        if (!viewId) {
+            throw new Error("view_id is required");
+        }
+        let files = [];
+        if (useLocal) {
+            // 💜 CLI: Read from ~/gufi-dev/view_<id>/
+            const viewDir = path.join(LOCAL_VIEWS_DIR, `view_${viewId}`);
+            if (!fs.existsSync(viewDir)) {
+                throw new Error(`View directory not found: ${viewDir}. Run gufi_view_pull first.`);
+            }
+            // Get all files recursively
+            const getFiles = (dir, prefix = "") => {
+                const result = [];
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.name.startsWith("."))
+                        continue;
+                    const fullPath = path.join(prefix, entry.name);
+                    if (entry.isDirectory()) {
+                        result.push(...getFiles(path.join(dir, entry.name), fullPath));
+                    }
+                    else {
+                        result.push(fullPath);
+                    }
+                }
+                return result;
+            };
+            const localFiles = getFiles(viewDir);
+            const langMap = {
+                ".ts": "typescript", ".tsx": "typescript",
+                ".js": "javascript", ".jsx": "javascript",
+                ".css": "css", ".json": "json", ".md": "markdown",
+            };
+            files = localFiles.map(file => ({
+                file_path: "/" + file,
+                content: fs.readFileSync(path.join(viewDir, file), "utf-8"),
+                language: langMap[path.extname(file).toLowerCase()] || "text",
+                is_entry_point: file === "index.tsx",
+            }));
         }
-        // Try to load meta to get view_id if not provided
-        if (!viewId && viewDir) {
-            const meta = loadViewMeta(viewDir);
-            if (meta)
-                viewId = meta.viewId;
+        else {
+            // 💜 Web: Read from Claude Workspace BD
+            const workspaceResponse = await apiRequest(`/api/claude/workspace/view/${viewId}/files`, {}, undefined, true, env);
+            files = workspaceResponse.data || workspaceResponse || [];
         }
-        // Push using sync.ts (with optional message for snapshot)
-        const result = await pushView(viewDir, params.message);
+        // Push to server using apiRequest (supports env)
+        const result = await apiRequest(`/api/marketplace/views/${viewId}/files/bulk`, {
+            method: "POST",
+            body: JSON.stringify({ files, message: params.message, sync: true }),
+        }, undefined, true, env);
         // Get view info for package
         let packageInfo = null;
-        if (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}` };
-            }
+        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}` };
         }
         return {
             success: true,
-            pushed_files: result.pushed,
+            pushed_files: files.length,
             snapshot: result.snapshot || null,
-            status_message: result.pushed > 0
-                ? `📤 Pushed ${result.pushed} file(s) to draft (snapshot #${result.snapshot})`
+            storage: useLocal ? "local" : "workspace",
+            status_message: files.length > 0
+                ? `📤 Pushed ${files.length} file(s) to draft (snapshot #${result.snapshot})`
                 : "No changes to push",
             package: packageInfo,
             _hint: packageInfo
@@ -1640,9 +1831,9 @@ const result = await api.stripe.createCheckoutSession({
             body: JSON.stringify({
                 view_id,
                 company_id,
-                timeout: timeout || 15000,
+                timeout: timeout || 25000,
                 actions: actions || [],
-                capture_screenshot: capture_screenshot !== false,
+                capture_screenshot: capture_screenshot === true,
             }),
         }, company_id, true, env);
         // Format response for Claude readability
@@ -1673,6 +1864,10 @@ const result = await api.stripe.createCheckoutSession({
         }
         // Add DOM info
         response.dom = result.dom;
+        // Add action results (eval results, getText, etc.)
+        if (result.actions?.length > 0) {
+            response.actions = result.actions;
+        }
         // Add screenshot (Claude can view base64 images)
         if (result.screenshot) {
             response.screenshot = result.screenshot;
@@ -1937,7 +2132,7 @@ async function generateViewContextMcp(viewId, includeConcepts, env) {
     }
     // If has automations, suggest viewing them
     if (autoCount > 0 && viewCompanyId) {
-        nextActions.push(`See automations: gufi_automations({ company_id: "${viewCompanyId}" })`);
+        nextActions.push(`See automations: gufi_automation_scripts({ action: "list", company_id: "${viewCompanyId}" })`);
     }
     // Always: docs for field types
     nextActions.push(`Field types reference: gufi_docs({ topic: "fields" })`);
@@ -2040,89 +2235,25 @@ async function generatePackageContextMcp(packageId, includeConcepts, env) {
     return result;
 }
 async function generateCompanyContextMcp(companyId, includeConcepts) {
-    // Use /api/company/schema which has full entity info
-    const schemaResponse = await apiRequest(`/api/company/schema`, {
-        headers: { "X-Company-ID": String(companyId) },
-    }, String(companyId));
-    const modulesRaw = schemaResponse.modules || schemaResponse.data?.modules || [];
+    // 💜 Use centralized /api/schema/export-claude endpoint
+    // This returns the same complete text as "Copy All for Claude" in the frontend
+    const exportText = await apiRequest(`/api/schema/export-claude`, {}, String(companyId));
+    // Get automation scripts for summary
     let automations = [];
     try {
         const automationsResponse = await apiRequest(`/api/automation-scripts`, {}, String(companyId));
         automations = Array.isArray(automationsResponse) ? automationsResponse : automationsResponse.data || [];
     }
     catch { }
-    const modulesInfo = [];
-    for (const mod of modulesRaw) {
-        // Find moduleId from entities
-        let moduleId;
-        for (const sub of mod.submodules || []) {
-            for (const ent of sub.entities || []) {
-                if (ent.ui?.moduleId) {
-                    moduleId = ent.ui.moduleId;
-                    break;
-                }
-            }
-            if (moduleId)
-                break;
-        }
-        const entities = [];
-        for (const sub of mod.submodules || []) {
-            for (const ent of sub.entities || []) {
-                const entityId = ent.ui?.entityId || ent.pk_id || ent.id;
-                entities.push({
-                    name: ent.name,
-                    label: ent.label,
-                    table: moduleId && entityId ? `m${moduleId}_t${entityId}` : null,
-                    fieldCount: ent.fields?.length || 0,
-                    fields: (ent.fields || []).slice(0, 10).map((f) => ({
-                        name: f.name,
-                        type: f.type,
-                        required: f.required || false,
-                    })),
-                });
-            }
-        }
-        modulesInfo.push({
-            id: moduleId,
-            name: mod.name || mod.displayName,
-            displayName: mod.displayName || mod.label,
-            entities,
-        });
-    }
-    // Build summary and next_actions
-    const totalEntities = modulesInfo.reduce((acc, m) => acc + (m.entities?.length || 0), 0);
-    const summary = [
-        `Company ID: ${companyId}`,
-        `${modulesInfo.length} module(s)`,
-        `${totalEntities} table(s)`,
-        `${automations.length} automation(s)`,
-    ].join(" | ");
-    const nextActions = [];
-    // Suggest viewing data from first table
-    if (modulesInfo.length > 0 && modulesInfo[0].entities?.length > 0) {
-        const firstTable = modulesInfo[0].entities[0].table;
-        if (firstTable) {
-            nextActions.push(`View data: gufi_rows({ table: "${firstTable}", limit: 5 })`);
-        }
-    }
-    // If has modules, suggest editing one
-    if (modulesInfo.length > 0 && modulesInfo[0].id) {
-        nextActions.push(`Edit module structure: gufi_module({ module_id: "${modulesInfo[0].id}" })`);
-    }
-    // If has automations, suggest viewing them
-    if (automations.length > 0) {
-        nextActions.push(`View automation code: gufi_automation({ automation_id: "${automations[0].id}" })`);
-    }
-    nextActions.push(`Field types reference: gufi_docs({ topic: "fields" })`);
     const result = {
         type: "company",
-        summary,
-        next_actions: nextActions,
         company_id: companyId,
-        modules: modulesInfo,
-        automations: automations.map((a) => ({
+        // The full schema export with ALL details (fields, automations, permissions, etc.)
+        schema: exportText,
+        // Also provide structured data for programmatic access
+        automation_scripts: automations.map((a) => ({
             id: a.id,
-            name: a.name,
+            name: a.name || a.function_name,
             description: a.description,
         })),
         commands: {

package/package.json

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