gufi-cli 0.1.35 → 0.1.36

package/dist/lib/config.d.ts

@@ -42,6 +42,13 @@ export declare function setCurrentEnv(env: "prod" | "local" | "custom"): void;
 export declare function loadConfig(): GufiConfig;
 export declare function saveConfig(config: GufiConfig): void;
 export declare function getToken(): string | undefined;
+export declare function getTokenForEnv(env: "prod" | "dev" | "local"): string | undefined;
+export declare function getRefreshTokenForEnv(env: "prod" | "dev" | "local"): string | undefined;
+export declare function setTokenForEnv(env: "prod" | "dev" | "local", token: string, email: string, refreshToken?: string): void;
+export declare function getCredentialsForEnv(env: "prod" | "dev" | "local"): {
+    email?: string;
+    password?: string;
+} | undefined;
 export declare function setToken(token: string, email: string, refreshToken?: string): void;
 export declare function getRefreshToken(): string | undefined;
 export declare function setRefreshToken(refreshToken: string): void;

package/dist/lib/config.js

@@ -117,6 +117,43 @@ export function saveConfig(config) {
 export function getToken() {
     return loadConfig().token;
 }
+// Get token for a specific environment
+// Note: "dev" maps to "local" internally for backwards compatibility
+export function getTokenForEnv(env) {
+    const file = loadConfigFile();
+    const key = env === "dev" ? "local" : env;
+    return file.environments[key]?.token;
+}
+// Get refresh token for a specific environment
+export function getRefreshTokenForEnv(env) {
+    const file = loadConfigFile();
+    const key = env === "dev" ? "local" : env;
+    return file.environments[key]?.refreshToken;
+}
+// Set token for a specific environment
+export function setTokenForEnv(env, token, email, refreshToken) {
+    const file = loadConfigFile();
+    const key = env === "dev" ? "local" : env;
+    if (!file.environments[key]) {
+        file.environments[key] = { apiUrl: key === "prod" ? "https://gogufi.com" : "http://localhost:3000" };
+    }
+    file.environments[key].token = token;
+    file.environments[key].email = email;
+    if (refreshToken) {
+        file.environments[key].refreshToken = refreshToken;
+    }
+    saveConfigFile(file);
+}
+// Get credentials for a specific environment (for auto-login)
+export function getCredentialsForEnv(env) {
+    const file = loadConfigFile();
+    const key = env === "dev" ? "local" : env;
+    const envConfig = file.environments[key];
+    if (envConfig?.email && envConfig?.password) {
+        return { email: envConfig.email, password: envConfig.password };
+    }
+    return undefined;
+}
 export function setToken(token, email, refreshToken) {
     const config = loadConfig();
     config.token = token;

package/dist/mcp.js

@@ -14,13 +14,47 @@ import * as readline from "readline";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { getToken, getApiUrl, getRefreshToken, setToken, loadConfig, isLoggedIn, getCurrentEnv } from "./lib/config.js";
+import { getToken, getRefreshToken, loadConfig, isLoggedIn, getTokenForEnv, getRefreshTokenForEnv, setTokenForEnv, getCredentialsForEnv } from "./lib/config.js";
 import { pullView, pushView, getViewDir, loadViewMeta } from "./lib/sync.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");
+// ════════════════════════════════════════════════════════════════════════════
+// Environment Configuration (stateless - passed per request)
+// ════════════════════════════════════════════════════════════════════════════
+// IMPORTANT: No more global sessionEnv variable!
+// Each tool call can specify env='local' or env='prod' (default: prod)
+// This prevents cross-session conflicts when multiple Claude instances share the MCP process.
+const ENV_URLS = {
+    prod: "https://gogufi.com",
+    dev: "http://localhost:3000",
+    local: "http://localhost:3000", // Alias for backwards compatibility
+};
+// Default environment - always prod for safety
+const DEFAULT_ENV = "prod";
+/**
+ * Get API URL for the specified environment.
+ * @param env - 'prod' (default) or 'dev' (localhost:3000 → Cloud SQL Dev)
+ */
+function getApiUrl(env) {
+    const resolvedEnv = (env === "dev" || env === "local" || env === "prod") ? env : DEFAULT_ENV;
+    return ENV_URLS[resolvedEnv];
+}
+/**
+ * Resolve env parameter to canonical form ('prod' or 'dev')
+ * 'local' is treated as alias for 'dev'
+ */
+function resolveEnv(env) {
+    if (env === "dev" || env === "local")
+        return "dev";
+    return "prod";
+}
+// Keep for backwards compatibility (some internal functions may use this)
+function getSessionApiUrl() {
+    return ENV_URLS[DEFAULT_ENV];
+}
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 const viewFilesCache = new Map();
 const viewContextCache = new Map();
@@ -49,6 +83,56 @@ function setCachedViewContext(viewId, context) {
     viewContextCache.set(viewId, { data: context, timestamp: Date.now() });
 }
 // ════════════════════════════════════════════════════════════════════════════
+// Automation Code Validation
+// ════════════════════════════════════════════════════════════════════════════
+/**
+ * 💜 Detecta patrones de IDs hardcodeados que rompen entre entornos
+ *
+ * Busca:
+ * - Tablas físicas: m310_t4146 (deben usar nombres lógicos: stock.productos)
+ * - entity_id/tableId hardcodeados: entity_id === 1234
+ *
+ * @param code - Código a validar
+ * @returns Array de warnings (vacío si no hay problemas)
+ */
+function checkForHardcodedIds(code) {
+    const warnings = [];
+    // Pattern 1: Physical table names (m123_t456)
+    const physicalTablePattern = /m\d+_t\d+/g;
+    const physicalMatches = code.match(physicalTablePattern);
+    if (physicalMatches) {
+        const uniqueTables = [...new Set(physicalMatches)];
+        warnings.push(`⚠️ HARDCODED TABLE IDS: Found physical table names: ${uniqueTables.join(', ')}. ` +
+            `Use logical names instead (e.g., 'stock.productos' not 'm310_t4146'). ` +
+            `Physical IDs change between DEV/PROD environments.`);
+    }
+    // Pattern 2: Hardcoded entity_id comparisons (entity_id === 1234 or entity_id == 1234)
+    const entityIdPattern = /entity_id\s*(?:===?|!==?)\s*(\d{3,})/g;
+    const entityMatches = [...code.matchAll(entityIdPattern)];
+    if (entityMatches.length > 0) {
+        const ids = entityMatches.map(m => m[1]);
+        warnings.push(`⚠️ HARDCODED ENTITY_ID: Found comparisons with literal IDs: ${ids.join(', ')}. ` +
+            `Use context.table instead (e.g., table.includes('supplier_orders') not entity_id === 7140).`);
+    }
+    // Pattern 3: Hardcoded tableId comparisons
+    const tableIdPattern = /tableId\s*(?:===?|!==?)\s*(\d{3,})/g;
+    const tableIdMatches = [...code.matchAll(tableIdPattern)];
+    if (tableIdMatches.length > 0) {
+        const ids = tableIdMatches.map(m => m[1]);
+        warnings.push(`⚠️ HARDCODED TABLE_ID: Found comparisons with literal IDs: ${ids.join(', ')}. ` +
+            `Use logical table names instead.`);
+    }
+    // Pattern 4: Hardcoded table_id comparisons (underscore version)
+    const table_idPattern = /table_id\s*(?:===?|!==?)\s*(\d{3,})/g;
+    const table_idMatches = [...code.matchAll(table_idPattern)];
+    if (table_idMatches.length > 0) {
+        const ids = table_idMatches.map(m => m[1]);
+        warnings.push(`⚠️ HARDCODED TABLE_ID: Found comparisons with literal IDs: ${ids.join(', ')}. ` +
+            `Use logical table names instead.`);
+    }
+    return warnings;
+}
+// ════════════════════════════════════════════════════════════════════════════
 // Analytics - Track MCP tool calls
 // ════════════════════════════════════════════════════════════════════════════
 async function trackAnalytics(data) {
@@ -58,7 +142,8 @@ async function trackAnalytics(data) {
             console.error("[MCP Analytics] No token, skipping");
             return;
         }
-        const url = `${getApiUrl()}/api/cli/mcp-analytics`;
+        // Analytics always go to prod
+        const url = `${getApiUrl("prod")}/api/cli/mcp-analytics`;
         console.error(`[MCP Analytics] Tracking ${data.tool_name} to ${url}`);
         const res = await fetch(url, {
             method: "POST",
@@ -81,19 +166,26 @@ async function trackAnalytics(data) {
 // API Client (reused from CLI)
 // ════════════════════════════════════════════════════════════════════════════
 async function autoLogin() {
-    const config = loadConfig();
-    if (!config.email || !config.password)
-        return undefined;
+    return autoLoginWithEnv(DEFAULT_ENV);
+}
+async function autoLoginWithEnv(env) {
+    const resolvedEnv = resolveEnv(env);
+    // ONLY use credentials for the specified env - NO fallback to other env
+    const creds = getCredentialsForEnv(resolvedEnv);
+    if (!creds?.email || !creds?.password) {
+        throw new Error(`No credentials for env '${resolvedEnv}'. Run: gufi config:${resolvedEnv === 'dev' ? 'local' : 'prod'} && gufi login`);
+    }
     try {
-        const response = await fetch(`${getApiUrl()}/api/auth/login`, {
+        const response = await fetch(`${getApiUrl(env)}/api/auth/login`, {
             method: "POST",
             headers: { "Content-Type": "application/json", "X-Client": "mcp" },
-            body: JSON.stringify({ email: config.email, password: config.password }),
+            body: JSON.stringify({ email: creds.email, password: creds.password }),
         });
         if (!response.ok)
             return undefined;
         const data = await response.json();
-        setToken(data.accessToken, config.email, data.refreshToken);
+        // Save token to the correct environment
+        setTokenForEnv(resolvedEnv, data.accessToken, creds.email, data.refreshToken);
         return data.accessToken;
     }
     catch {
@@ -101,32 +193,43 @@ async function autoLogin() {
     }
 }
 async function refreshOrLogin() {
-    const refreshToken = getRefreshToken();
+    return refreshOrLoginWithEnv(DEFAULT_ENV);
+}
+async function refreshOrLoginWithEnv(env) {
+    const resolvedEnv = resolveEnv(env);
+    const refreshToken = getRefreshTokenForEnv(resolvedEnv) || getRefreshToken();
     if (refreshToken) {
         try {
-            const response = await fetch(`${getApiUrl()}/api/auth/refresh`, {
+            const response = await fetch(`${getApiUrl(env)}/api/auth/refresh`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json", "X-Client": "mcp", "X-Refresh-Token": refreshToken },
             });
             if (response.ok) {
                 const data = await response.json();
-                const config = loadConfig();
-                setToken(data.accessToken, config.email || "", data.refreshToken);
+                const creds = getCredentialsForEnv(resolvedEnv) || loadConfig();
+                setTokenForEnv(resolvedEnv, data.accessToken, creds.email || "", data.refreshToken);
                 return data.accessToken;
             }
         }
         catch { }
     }
-    return autoLogin();
+    return autoLoginWithEnv(env);
 }
-async function apiRequest(endpoint, options = {}, companyId, retry = true) {
-    let token = getToken();
+// Simple wrapper - just passes env to apiRequestWithEnv
+async function apiRequest(endpoint, options = {}, companyId, retry = true, env) {
+    return apiRequestWithEnv(endpoint, options, companyId, env, retry);
+}
+async function apiRequestWithEnv(endpoint, options = {}, companyId, env, retry = true) {
+    const resolvedEnv = resolveEnv(env);
+    // ONLY use token for the specified env - NO fallback to prod token
+    let token = getTokenForEnv(resolvedEnv);
+    const apiUrl = getApiUrl(env);
     if (!token) {
-        token = await autoLogin();
+        token = await autoLoginWithEnv(env);
         if (!token)
             throw new Error("Not logged in. Run: gufi login");
     }
-    const url = `${getApiUrl()}${endpoint}`;
+    const url = `${apiUrl}${endpoint}`;
     const headers = {
         "Content-Type": "application/json",
         Authorization: `Bearer ${token}`,
@@ -140,9 +243,9 @@ async function apiRequest(endpoint, options = {}, companyId, retry = true) {
         headers: { ...headers, ...options.headers },
     });
     if ((response.status === 401 || response.status === 403) && retry) {
-        const newToken = await refreshOrLogin();
+        const newToken = await refreshOrLoginWithEnv(env);
         if (newToken)
-            return apiRequest(endpoint, options, companyId, false);
+            return apiRequestWithEnv(endpoint, options, companyId, env, false);
     }
     if (!response.ok) {
         const text = await response.text();
@@ -150,14 +253,17 @@ async function apiRequest(endpoint, options = {}, companyId, retry = true) {
     }
     return response.json();
 }
-async function developerRequest(path, options = {}, retry = true) {
-    let token = getToken();
+async function developerRequest(path, options = {}, retry = true, env) {
+    const resolvedEnv = resolveEnv(env);
+    // ONLY use token for the specified env - NO fallback to prod token
+    let token = getTokenForEnv(resolvedEnv);
+    const apiUrl = getApiUrl(env);
     if (!token) {
-        token = await autoLogin();
+        token = await autoLoginWithEnv(env);
         if (!token)
             throw new Error("Not logged in. Run: gufi login");
     }
-    const res = await fetch(`${getApiUrl()}/api/developer${path}`, {
+    const res = await fetch(`${apiUrl}/api/developer${path}`, {
         ...options,
         headers: {
             Authorization: `Bearer ${token}`,
@@ -167,9 +273,9 @@ async function developerRequest(path, options = {}, retry = true) {
         },
     });
     if ((res.status === 401 || res.status === 403) && retry) {
-        const newToken = await refreshOrLogin();
+        const newToken = await refreshOrLoginWithEnv(env);
         if (newToken)
-            return developerRequest(path, options, false);
+            return developerRequest(path, options, false, env);
     }
     if (!res.ok) {
         const error = await res.text();
@@ -223,12 +329,12 @@ function generateFileId() {
  * Output: { id, url, name, mime, uploaded_at }
  */
 function normalizeFileObject(file) {
-    // Validate required fields
-    if (!file.url || typeof file.url !== "string") {
-        throw new Error("File field error: 'url' is required and must be a string");
+    // Validate required fields - url cannot be empty
+    if (!file.url || typeof file.url !== "string" || file.url.trim() === "") {
+        throw new Error("File field error: 'url' is required and cannot be empty");
     }
-    if (!file.name || typeof file.name !== "string") {
-        throw new Error("File field error: 'name' is required and must be a string");
+    if (!file.name || typeof file.name !== "string" || file.name.trim() === "") {
+        throw new Error("File field error: 'name' is required and cannot be empty");
     }
     // Validate url format (must be company_X/... path or full URL)
     const isValidPath = file.url.startsWith("company_") || file.url.startsWith("http");
@@ -276,14 +382,16 @@ const PHYSICAL_TABLE_RE = /^m\d+_t\d+$/;
 /**
  * Get company schema (cached)
  */
-async function getCompanySchema(companyId) {
-    const cached = schemaCache.get(companyId);
+async function getCompanySchema(companyId, env) {
+    // Include env in cache key to avoid mixing schemas from different environments
+    const cacheKey = `${companyId}:${env || 'prod'}`;
+    const cached = schemaCache.get(cacheKey);
     if (cached && Date.now() - cached.timestamp < SCHEMA_CACHE_TTL) {
         return cached.schema;
     }
     try {
-        const data = await apiRequest("/api/cli/schema", {}, companyId);
-        schemaCache.set(companyId, { schema: data, timestamp: Date.now() });
+        const data = await apiRequest("/api/cli/schema", {}, companyId, true, env);
+        schemaCache.set(cacheKey, { schema: data, timestamp: Date.now() });
         return data;
     }
     catch (err) {
@@ -298,7 +406,7 @@ async function getCompanySchema(companyId) {
  * @param companyId - company ID for schema lookup
  * @returns physical table name or throws error
  */
-async function resolveTableName(tableName, companyId) {
+async function resolveTableName(tableName, companyId, env) {
     // If already physical, return as-is
     if (PHYSICAL_TABLE_RE.test(tableName)) {
         return tableName;
@@ -309,7 +417,7 @@ async function resolveTableName(tableName, companyId) {
         throw new Error(`Invalid table name: "${tableName}". Use physical (m123_t456) or logical (module.entity) format`);
     }
     const [moduleName, entityName] = parts;
-    const schema = await getCompanySchema(companyId);
+    const schema = await getCompanySchema(companyId, env);
     if (!schema?.modules) {
         throw new Error(`Cannot resolve logical table name "${tableName}": schema not available. Use physical name (m123_t456) instead`);
     }
@@ -353,6 +461,8 @@ catch (err) {
 function getDesc(toolName, fallback = "") {
     return toolDescriptions[toolName]?.description || fallback;
 }
+// Environment parameter description (reused across tools)
+const ENV_PARAM = { type: "string", description: "Environment: 'prod' (default) or 'dev'. Use 'dev' for development against localhost:3000" };
 const TOOLS = [
     // ─────────────────────────────────────────────────────────────────────────
     // Context & Info
@@ -368,14 +478,22 @@ const TOOLS = [
                 company_id: { type: "string", description: "Company ID to get context for" },
                 module_id: { type: "string", description: "Module ID to get detailed context for (requires company_id)" },
                 entity_id: { type: "string", description: "Entity ID to get detailed context for (requires company_id)" },
+                env: ENV_PARAM,
             },
         },
     },
     {
         name: "gufi_whoami",
         description: getDesc("gufi_whoami"),
-        inputSchema: { type: "object", properties: {} },
+        inputSchema: {
+            type: "object",
+            properties: {
+                env: { type: "string", description: "Environment: 'prod' (default) or 'local'" },
+            }
+        },
     },
+    // gufi_set_env REMOVED - environment is now passed per-request via 'env' parameter
+    // This prevents cross-session conflicts when multiple Claude instances share the MCP process
     // gufi_schema REMOVED - functionality merged into gufi_context (always full)
     {
         name: "gufi_schema_modify",
@@ -385,6 +503,7 @@ const TOOLS = [
             properties: {
                 company_id: { type: "string", description: "Company ID (optional if user has only one company)" },
                 preview: { type: "boolean", description: "If true, show what would be done without executing (dry run)" },
+                skip_existing: { type: "boolean", description: "If true, skip fields/entities that already exist instead of failing" },
                 operations: {
                     type: "array",
                     description: "Array of operations to execute",
@@ -425,16 +544,34 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
-                action: { type: "string", description: "Action: list, get, create" },
+                action: { type: "string", description: "Action: list, get, create, update, delete" },
                 company_id: { type: "string", description: "Company ID" },
                 id: { type: "string", description: "Script ID (for get)" },
-                name: { type: "string", description: "Script name (for create, snake_case)" },
-                code: { type: "string", description: "JavaScript code (for create)" },
+                name: { type: "string", description: "Script name (for create/update/delete, snake_case)" },
+                code: { type: "string", description: "JavaScript code (for create/update)" },
                 description: { type: "string", description: "Description (for create)" },
+                env: ENV_PARAM,
             },
             required: ["action", "company_id"],
         },
     },
+    {
+        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})",
+        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)" },
+                env: ENV_PARAM,
+            },
+            required: ["company_id", "script_name", "entity", "trigger_event", "row"],
+        },
+    },
     {
         name: "gufi_triggers",
         description: getDesc("gufi_triggers"),
@@ -447,6 +584,7 @@ const TOOLS = [
                     type: "object",
                     description: "Trigger config to SET (omit to GET current config). Format: { on_create: [...], on_update: [...], on_delete: [...], on_click: [...] }",
                 },
+                env: ENV_PARAM,
             },
             required: ["entity_id", "company_id"],
         },
@@ -460,6 +598,7 @@ const TOOLS = [
                 company_id: { type: "string", description: "Company ID" },
                 limit: { type: "number", description: "Number of records (default 20)" },
                 script_name: { type: "string", description: "Filter by script name" },
+                env: ENV_PARAM,
             },
             required: ["company_id"],
         },
@@ -473,7 +612,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
-                action: { type: "string", description: "Action: list, get, create, update, delete" },
+                action: { type: "string", description: "Action: list, get, create, update, delete, aggregate" },
                 table: { type: "string", description: "Table name (logical name like 'ventas.productos' or physical ID)" },
                 company_id: { type: "string", description: "Company ID (required)" },
                 id: { type: "number", description: "Row ID (for get, update, delete)" },
@@ -483,6 +622,13 @@ const TOOLS = [
                 sort: { type: "string", description: "Field to sort by (default: id)" },
                 order: { type: "string", description: "ASC or DESC (default: DESC)" },
                 filter: { type: "string", description: "Filter expression (field=value)" },
+                agg: { type: "string", description: "Aggregation function for 'aggregate' action: count, sum, avg, min, max" },
+                field: { type: "string", description: "Field to aggregate (for 'aggregate' action)" },
+                groupBy: { type: "string", description: "Field to group by (for 'aggregate' action)" },
+                dateField: { type: "string", description: "Date field name for date range filtering (for 'aggregate' action)" },
+                dateFrom: { type: "string", description: "Start date ISO string for date range (for 'aggregate' action)" },
+                dateTo: { type: "string", description: "End date ISO string for date range (for 'aggregate' action)" },
+                env: ENV_PARAM,
             },
             required: ["action", "table", "company_id"],
         },
@@ -500,6 +646,7 @@ const TOOLS = [
                 company_id: { type: "string", description: "Company ID" },
                 key: { type: "string", description: "Variable name (for set/delete)" },
                 value: { type: "string", description: "Variable value (for set)" },
+                env: ENV_PARAM,
             },
             required: ["action", "company_id"],
         },
@@ -523,6 +670,7 @@ Example: gufi_view_pull({ view_id: 13 })`,
             properties: {
                 view_id: { type: "number", description: "View ID to pull" },
                 company_id: { type: "string", description: "Company ID (required for company-specific views)" },
+                env: ENV_PARAM,
             },
             required: ["view_id"],
         },
@@ -543,6 +691,7 @@ Example: gufi_view_push({ view_id: 13, message: "Fixed bug in chart" })`,
             properties: {
                 view_id: { type: "number", description: "View ID to push (optional if in view directory)" },
                 message: { type: "string", description: "Optional commit message for version history" },
+                env: ENV_PARAM,
             },
             required: [],
         },
@@ -562,6 +711,7 @@ Example: gufi_view_push({ view_id: 13, message: "Fixed bug in chart" })`,
                 description: { type: "string", description: "Package description (for create)" },
                 module_id: { type: "string", description: "Module ID (for add_module, remove_module)" },
                 company_id: { type: "string", description: "Source company ID (for add_module)" },
+                env: ENV_PARAM,
             },
             required: ["action"],
         },
@@ -692,13 +842,14 @@ const toolHandlers = {
     // ─────────────────────────────────────────────────────────────────────────
     // Context & Info
     // ─────────────────────────────────────────────────────────────────────────
-    async gufi_whoami() {
+    async gufi_whoami(params) {
+        const env = params.env || DEFAULT_ENV;
         const config = loadConfig();
         const loggedIn = isLoggedIn();
         let companies = [];
         if (loggedIn) {
             try {
-                const data = await apiRequest("/api/companies");
+                const data = await apiRequestWithEnv("/api/companies", {}, undefined, env);
                 const list = data.items || data.data || data || [];
                 companies = list.map((c) => ({ id: c.id, name: c.name }));
             }
@@ -707,14 +858,16 @@ const toolHandlers = {
         return {
             logged_in: loggedIn,
             email: config.email || null,
-            environment: getCurrentEnv(),
-            api_url: getApiUrl(),
+            env: env,
+            api_url: getApiUrl(env),
             companies,
             hint: companies.length > 0
                 ? `Use gufi_context({ company_id: '${companies[0].id}' }) to get schema`
                 : "Login with 'gufi login' first",
+            tip: "Pass env: 'dev' to any tool to use localhost:3000 (Cloud SQL Dev) instead of gogufi.com (prod)",
         };
     },
+    // gufi_set_env REMOVED - use env parameter in each tool instead
     async gufi_context(params) {
         // Generate intelligent context based on what's requested
         // Always returns FULL context (no more "detail" parameter)
@@ -796,12 +949,39 @@ const toolHandlers = {
     //      gufi_context({ company_id: "X", module_id: "Y" })
     //      gufi_context({ company_id: "X", entity_id: "Z" })
     async gufi_schema_modify(params) {
+        // 💜 Map common type aliases to valid Gufi types
+        const TYPE_ALIASES = {
+            textarea: "text",
+            varchar: "text",
+            string: "text",
+            int: "number_int",
+            integer: "number_int",
+            float: "number_float",
+            decimal: "number_float",
+            double: "number_float",
+            bool: "boolean",
+            timestamp: "datetime",
+            money: "currency",
+            tel: "phone",
+            address: "location",
+        };
+        // Process operations: normalize field types
+        const normalizedOps = params.operations.map((op) => {
+            if (op.field?.type && TYPE_ALIASES[op.field.type]) {
+                return {
+                    ...op,
+                    field: { ...op.field, type: TYPE_ALIASES[op.field.type] },
+                };
+            }
+            return op;
+        });
         // Use the new /api/schema/operations endpoint for semantic operations
         const result = await apiRequest("/api/schema/operations", {
             method: "POST",
             body: JSON.stringify({
-                operations: params.operations,
+                operations: normalizedOps,
                 preview: params.preview || false,
+                skip_existing: params.skip_existing || false,
             }),
         }, params.company_id);
         if (params.preview) {
@@ -910,12 +1090,12 @@ const toolHandlers = {
     // Automations
     // ─────────────────────────────────────────────────────────────────────────
     async gufi_automation(params) {
-        const { action, company_id, id, name, code, description } = params;
+        const { action, company_id, id, name, code, description, env } = params;
         switch (action) {
             case "list": {
-                const data = await apiRequest("/api/automation-scripts", {
+                const data = await apiRequestWithEnv("/api/automation-scripts", {
                     headers: { "X-Company-ID": company_id },
-                });
+                }, company_id, env);
                 const automations = Array.isArray(data) ? data : data.data || [];
                 return {
                     scripts: automations.map((a) => ({
@@ -928,9 +1108,9 @@ const toolHandlers = {
             case "get": {
                 if (!id)
                     throw new Error("id required for action 'get'");
-                const data = await apiRequest("/api/automation-scripts", {
+                const data = await apiRequestWithEnv("/api/automation-scripts", {
                     headers: { "X-Company-ID": company_id },
-                });
+                }, company_id, env);
                 const automations = Array.isArray(data) ? data : data.data || [];
                 const found = automations.find((a) => String(a.id) === id);
                 if (!found)
@@ -945,33 +1125,127 @@ const toolHandlers = {
             case "create": {
                 if (!name || !code)
                     throw new Error("name and code required for action 'create'");
-                const response = await apiRequest("/api/automation-scripts", {
+                // 💜 Check for hardcoded IDs that break between environments
+                const createWarnings = checkForHardcodedIds(code);
+                const response = await apiRequestWithEnv("/api/automation-scripts", {
                     method: "POST",
                     body: JSON.stringify({ name, code, description: description || "" }),
                     headers: { "X-Company-ID": company_id },
-                });
-                return { success: true, script: response.data || response };
+                }, company_id, env);
+                const createResult = { success: true, script: response.data || response };
+                if (createWarnings.length > 0) {
+                    createResult.warnings = createWarnings;
+                    createResult.hint = "Use logical table names (e.g., 'stock.productos') and context.table for entity detection";
+                }
+                return createResult;
+            }
+            case "update": {
+                if (!name || !code)
+                    throw new Error("name and code required for action 'update'");
+                // 💜 Check for hardcoded IDs that break between environments
+                const updateWarnings = checkForHardcodedIds(code);
+                const response = await apiRequestWithEnv(`/api/automation-scripts/${encodeURIComponent(name)}`, {
+                    method: "PUT",
+                    body: JSON.stringify({ code }),
+                    headers: { "X-Company-ID": company_id },
+                }, company_id, env);
+                const updateResult = { success: true, script: response.data || response };
+                if (updateWarnings.length > 0) {
+                    updateResult.warnings = updateWarnings;
+                    updateResult.hint = "Use logical table names (e.g., 'stock.productos') and context.table for entity detection";
+                }
+                return updateResult;
+            }
+            case "delete": {
+                if (!name)
+                    throw new Error("name required for action 'delete'");
+                await apiRequestWithEnv(`/api/automation-scripts/${encodeURIComponent(name)}`, {
+                    method: "DELETE",
+                    headers: { "X-Company-ID": company_id },
+                }, company_id, env);
+                return { success: true, deleted: name };
             }
             default:
-                throw new Error(`Unknown action: ${action}. Use: list, get, create`);
+                throw new Error(`Unknown action: ${action}. Use: list, get, create, update, delete`);
         }
     },
+    async gufi_automation_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.");
+        }
+        // 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;
+                }
+            }
+            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)
+        const response = await apiRequest("/api/automation-scripts/test", {
+            method: "POST",
+            body: JSON.stringify({
+                company_id,
+                module_id: moduleId,
+                function_name: script_name,
+                trigger_event,
+                table_id: tableId,
+                table_name: tableName,
+                row,
+                input: input || null,
+            }),
+            headers: { "X-Company-ID": company_id },
+        }, company_id, true, env);
+        return {
+            success: true,
+            script_name,
+            entity,
+            trigger_event,
+            result: response.data || response,
+        };
+    },
     async gufi_triggers(params) {
-        const { entity_id, company_id, config } = params;
+        const { entity_id, company_id, config, env } = params;
         if (config) {
             // SET triggers
             await apiRequest(`/api/entities/${entity_id}/automations`, {
                 method: "PUT",
                 body: JSON.stringify(config),
                 headers: { "X-Company-ID": company_id },
-            }, company_id);
+            }, company_id, true, env);
             return { success: true, entity_id, config };
         }
         else {
             // GET triggers
             const response = await apiRequest(`/api/entities/${entity_id}/automations`, {
                 headers: { "X-Company-ID": company_id },
-            }, company_id);
+            }, company_id, true, env);
             const data = response.data || response;
             return {
                 entity_id,
@@ -995,27 +1269,29 @@ const toolHandlers = {
     // ─────────────────────────────────────────────────────────────────────────
     async gufi_data(params) {
         // 💜 Unified data tool - all CRUD operations in one
-        const { action, company_id } = params;
+        const { action, company_id, env } = params;
         // 💜 Resolve logical table names (module.entity) to physical (m123_t456)
-        const table = await resolveTableName(params.table, company_id);
+        const table = await resolveTableName(params.table, company_id, env);
         switch (action) {
             case "list": {
                 const limit = params.limit || 20;
                 const offset = params.offset || 0;
+                // 💜 IMPORTANTE: Backend espera page/perPage, NO pagination.current/pageSize
                 const body = {
-                    pagination: { current: Math.floor(offset / limit) + 1, pageSize: limit },
+                    page: Math.floor(offset / limit) + 1,
+                    perPage: limit,
                     sorters: [{ field: params.sort || "id", order: params.order || "desc" }],
-                    filters: [],
+                    filter: [], // Backend usa 'filter', no 'filters'
                 };
                 if (params.filter) {
                     const [field, value] = params.filter.split("=");
                     if (field && value)
-                        body.filters.push({ field, operator: "eq", value });
+                        body.filter.push({ field, operator: "eq", value });
                 }
                 const result = await apiRequest(`/api/tables/${table}/list`, {
                     method: "POST",
                     body: JSON.stringify(body),
-                }, company_id);
+                }, company_id, true, env);
                 return { action: "list", table, total: result.total, rows: result.data || [] };
             }
             case "get": {
@@ -1024,7 +1300,7 @@ const toolHandlers = {
                 const result = await apiRequest(`/api/tables/${table}/getOne`, {
                     method: "POST",
                     body: JSON.stringify({ id: params.id }),
-                }, company_id);
+                }, company_id, true, env);
                 return { action: "get", table, id: params.id, row: result.data || result };
             }
             case "create": {
@@ -1033,7 +1309,7 @@ const toolHandlers = {
                 const result = await apiRequest(`/api/tables/${table}`, {
                     method: "POST",
                     body: JSON.stringify(params.data),
-                }, company_id);
+                }, company_id, true, env);
                 return { action: "create", table, success: true, id: result.id || result.data?.id, row: result.data || result };
             }
             case "update": {
@@ -1044,7 +1320,7 @@ const toolHandlers = {
                 const result = await apiRequest(`/api/tables/${table}/${params.id}`, {
                     method: "PUT",
                     body: JSON.stringify(params.data),
-                }, company_id);
+                }, company_id, true, env);
                 return { action: "update", table, success: true, id: params.id, row: result.data || result };
             }
             case "delete": {
@@ -1052,11 +1328,59 @@ const toolHandlers = {
                     throw new Error("id is required for 'delete' action");
                 await apiRequest(`/api/tables/${table}/${params.id}`, {
                     method: "DELETE",
-                }, company_id);
+                }, company_id, true, env);
                 return { action: "delete", table, success: true, id: params.id };
             }
+            case "aggregate": {
+                // 💜 Analytics query using runAnalyticsSpec engine
+                const agg = params.agg || "count";
+                const field = params.field || "id";
+                const groupBy = params.groupBy;
+                const dateField = params.dateField;
+                const dateFrom = params.dateFrom;
+                const dateTo = params.dateTo;
+                // Build analytics spec
+                const spec = {
+                    source: table,
+                    measures: [
+                        { alias: "value", fn: agg, from: "t", field },
+                    ],
+                    filters: [],
+                };
+                // Add groupBy as dimension if provided
+                if (groupBy) {
+                    spec.dimensions = [{ alias: groupBy, from: "t", field: groupBy }];
+                }
+                // Add date range filters if provided
+                if (dateField && dateFrom) {
+                    spec.filters.push({ from: "t", field: dateField, op: ">=", value: dateFrom });
+                }
+                if (dateField && dateTo) {
+                    spec.filters.push({ from: "t", field: dateField, op: "<=", value: dateTo });
+                }
+                // Add simple filter if provided (field=value)
+                if (params.filter) {
+                    const [filterField, filterValue] = params.filter.split("=");
+                    if (filterField && filterValue) {
+                        spec.filters.push({ from: "t", field: filterField, op: "=", value: filterValue });
+                    }
+                }
+                const result = await apiRequest(`/api/analytics/query`, {
+                    method: "POST",
+                    body: JSON.stringify({ spec, ttlSeconds: 60 }),
+                }, company_id, true, env);
+                return {
+                    action: "aggregate",
+                    table,
+                    agg,
+                    field,
+                    groupBy: groupBy || null,
+                    dateRange: dateFrom || dateTo ? { from: dateFrom, to: dateTo } : null,
+                    result: Array.isArray(result) ? result : [result],
+                };
+            }
             default:
-                throw new Error(`Unknown action: ${action}. Use: list, get, create, update, delete`);
+                throw new Error(`Unknown action: ${action}. Use: list, get, create, update, delete, aggregate`);
         }
     },
     // ─────────────────────────────────────────────────────────────────────────
@@ -1281,7 +1605,7 @@ async function getClaudeOptimizedContext(companyId, moduleId, entityId, fullText
     if (entityId)
         params.set("entity_id", entityId);
     const queryString = params.toString();
-    const url = `${getApiUrl()}/api/schema/export-claude${queryString ? "?" + queryString : ""}`;
+    const url = `${getSessionApiUrl()}/api/schema/export-claude${queryString ? "?" + queryString : ""}`;
     let token = getToken();
     if (!token) {
         token = await autoLogin();

package/package.json

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