gufi-cli 0.1.46 → 0.1.48

package/dist/commands/push.js

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
 import path from "path";
-import { pushView, getChangedFiles, loadViewMeta } from "../lib/sync.js";
+import { pushView, getChangedFiles, loadViewMeta, checkVersionConflict } from "../lib/sync.js";
 import { isLoggedIn, getCurrentView } from "../lib/config.js";
 import { validateView } from "../lib/api.js";
 import { scanFilesForXSS, hasBlockingErrors } from "../lib/security.js";
@@ -244,6 +244,19 @@ export async function pushCommand(viewDir) {
         console.log(chalk.yellow(`    • ${file}`));
     });
     console.log();
+    // 💜 Version check (BEFORE anything else)
+    const versionSpinner = ora("Verificando versión...").start();
+    const versionCheck = await checkVersionConflict(dir);
+    if (versionCheck?.hasConflict) {
+        versionSpinner.fail(chalk.red("Conflicto de versión"));
+        console.log(chalk.red(`\n  ✗ ${versionCheck.message}`));
+        console.log(chalk.cyan(`\n  Haz pull primero: gufi view:pull ${meta.viewId}`));
+        console.log(chalk.yellow("\n  ⚠️  Si tienes cambios locales, cópialos a otra carpeta antes del pull.\n"));
+        process.exit(1);
+    }
+    else {
+        versionSpinner.succeed(chalk.green("Versión actualizada"));
+    }
     // 💜 Structure validation (BEFORE pushing)
     const structureSpinner = ora("Validando estructura...").start();
     const structureErrors = validateViewStructure(dir);

package/dist/lib/api.d.ts

@@ -35,8 +35,9 @@ export declare function getViewFiles(viewId: number): Promise<ViewFile[]>;
 /**
  * 💜 Full sync: saves all files and deletes any not in the list
  * This is the ONLY way to push - ensures local and server are in sync
+ * Backend validates lastPulledSnapshot to prevent version conflicts (409)
  */
-export declare function saveViewFiles(viewId: number, files: ViewFile[], message?: string): Promise<{
+export declare function saveViewFiles(viewId: number, files: ViewFile[], message?: string, lastPulledSnapshot?: number): Promise<{
     snapshot?: number;
     deleted?: number;
 }>;
@@ -65,6 +66,14 @@ export declare function validateFiles(files: Array<{
     file_path: string;
     content: string;
 }>): Promise<ValidationResult>;
+/**
+ * Get the latest snapshot number for a view
+ * Used to check if local version is up-to-date before pushing
+ */
+export declare function getLatestSnapshot(viewId: number): Promise<{
+    view_id: number;
+    latest_snapshot: number;
+}>;
 export interface FileHash {
     hash: string;
     updated_at: string;

package/dist/lib/api.js

@@ -135,11 +135,12 @@ export async function getViewFiles(viewId) {
 /**
  * 💜 Full sync: saves all files and deletes any not in the list
  * This is the ONLY way to push - ensures local and server are in sync
+ * Backend validates lastPulledSnapshot to prevent version conflicts (409)
  */
-export async function saveViewFiles(viewId, files, message) {
+export async function saveViewFiles(viewId, files, message, lastPulledSnapshot) {
     const response = await request(`/api/marketplace/views/${viewId}/files/bulk`, {
         method: "POST",
-        body: JSON.stringify({ files, message, sync: true }),
+        body: JSON.stringify({ files, message, sync: true, lastPulledSnapshot }),
     });
     return response;
 }
@@ -172,6 +173,16 @@ export async function validateFiles(files) {
         body: JSON.stringify({ files }),
     });
 }
+// ════════════════════════════════════════════════════════════════════
+// 💜 Version Check API - For preventing overwrites
+// ════════════════════════════════════════════════════════════════════
+/**
+ * Get the latest snapshot number for a view
+ * Used to check if local version is up-to-date before pushing
+ */
+export async function getLatestSnapshot(viewId) {
+    return request(`/api/marketplace/views/${viewId}/latest-snapshot`);
+}
 /**
  * Get server-side file hashes for a view
  * Used to compare local vs server content and detect real changes

package/dist/lib/sync.d.ts

@@ -7,6 +7,7 @@ export interface ViewMeta {
     viewName: string;
     packageId: number;
     lastSync: string;
+    lastPulledSnapshot?: number;
     files: Record<string, {
         hash: string;
     }>;
@@ -22,6 +23,7 @@ export declare function loadViewMeta(viewDir: string): ViewMeta | null;
 export declare function pullView(viewId: number, viewKey: string, packageId: number): Promise<{
     dir: string;
     fileCount: number;
+    snapshot?: number;
 }>;
 /**
  * 💜 Push local files to Gufi (FULL SYNC)
@@ -33,6 +35,16 @@ export declare function pushView(viewDir?: string, message?: string): Promise<{
     deleted: number;
     snapshot?: number;
 }>;
+/**
+ * 💜 Check if local version matches server exactly
+ * If server snapshot !== local snapshot → conflict (must pull first)
+ */
+export declare function checkVersionConflict(viewDir: string): Promise<{
+    hasConflict: boolean;
+    localSnapshot?: number;
+    serverSnapshot?: number;
+    message?: string;
+} | null>;
 /**
  * Check for local changes that need pushing
  */

package/dist/lib/sync.js

@@ -6,7 +6,7 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import crypto from "crypto";
-import { getViewFiles, saveViewFiles } from "./api.js";
+import { getViewFiles, saveViewFiles, getLatestSnapshot } 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");
@@ -61,6 +61,15 @@ function saveViewMeta(viewDir, meta) {
 export async function pullView(viewId, viewKey, packageId) {
     const viewDir = getViewDir(viewKey);
     ensureDir(viewDir);
+    // 💜 Get current snapshot number from server
+    let currentSnapshot;
+    try {
+        const snapshotInfo = await getLatestSnapshot(viewId);
+        currentSnapshot = snapshotInfo.latest_snapshot;
+    }
+    catch {
+        // If endpoint not available, continue without snapshot tracking
+    }
     const files = await getViewFiles(viewId);
     const fileMeta = {};
     for (const file of files) {
@@ -73,15 +82,16 @@ export async function pullView(viewId, viewKey, packageId) {
     }
     const meta = {
         viewId,
-        viewName: viewKey, // 💜 Store viewKey as viewName for backwards compat
+        viewName: viewKey,
         packageId,
         lastSync: new Date().toISOString(),
+        lastPulledSnapshot: currentSnapshot, // 💜 Must match server exactly to push
         files: fileMeta,
     };
     saveViewMeta(viewDir, meta);
     // Update current view in config
     setCurrentView({ id: viewId, name: viewKey, packageId, localPath: viewDir });
-    return { dir: viewDir, fileCount: files.length };
+    return { dir: viewDir, fileCount: files.length, snapshot: currentSnapshot };
 }
 /**
  * 💜 Push local files to Gufi (FULL SYNC)
@@ -113,10 +123,14 @@ export async function pushView(viewDir, message) {
         newMeta[filePath] = { hash: hashContent(content) };
     }
     // Push ALL files - backend handles sync (deletes files not in request)
-    const result = await saveViewFiles(meta.viewId, allFiles, message);
-    // Update meta with new file list
+    // 💜 Send lastPulledSnapshot for server-side version check (returns 409 on conflict)
+    const result = await saveViewFiles(meta.viewId, allFiles, message, meta.lastPulledSnapshot);
+    // Update meta with new file list and snapshot
     meta.files = newMeta;
     meta.lastSync = new Date().toISOString();
+    if (result.snapshot) {
+        meta.lastPulledSnapshot = result.snapshot; // 💜 Update to new snapshot
+    }
     saveViewMeta(dir, meta);
     return { pushed: allFiles.length, deleted: result.deleted || 0, snapshot: result.snapshot };
 }
@@ -139,6 +153,43 @@ function getLocalFiles(dir, prefix = "") {
     }
     return files;
 }
+/**
+ * 💜 Check if local version matches server exactly
+ * If server snapshot !== local snapshot → conflict (must pull first)
+ */
+export async function checkVersionConflict(viewDir) {
+    const meta = loadViewMeta(viewDir);
+    if (!meta)
+        return null;
+    try {
+        const serverInfo = await getLatestSnapshot(meta.viewId);
+        const serverSnapshot = serverInfo.latest_snapshot;
+        // 💜 If server has versions but we don't have local snapshot tracking,
+        // it means we pulled with an old CLI version - require pull first
+        if (serverSnapshot > 0 && meta.lastPulledSnapshot === undefined) {
+            return {
+                hasConflict: true,
+                localSnapshot: undefined,
+                serverSnapshot,
+                message: `Tu versión local no tiene tracking de versiones. El servidor está en v${serverSnapshot}. Haz pull primero.`
+            };
+        }
+        // 💜 If snapshots don't match, someone else pushed - require pull first
+        if (meta.lastPulledSnapshot !== undefined && serverSnapshot !== meta.lastPulledSnapshot) {
+            return {
+                hasConflict: true,
+                localSnapshot: meta.lastPulledSnapshot,
+                serverSnapshot,
+                message: `Tu versión local (v${meta.lastPulledSnapshot}) no coincide con el servidor (v${serverSnapshot}). Haz pull primero.`
+            };
+        }
+        return { hasConflict: false, localSnapshot: meta.lastPulledSnapshot, serverSnapshot };
+    }
+    catch {
+        // If can't check, allow push (backwards compat)
+        return { hasConflict: false };
+    }
+}
 /**
  * Check for local changes that need pushing
  */

package/dist/mcp.js

@@ -37,6 +37,14 @@ function canWriteLocal() {
     }
 }
 import { getToken, getRefreshToken, loadConfig, isLoggedIn, getTokenForEnv, getRefreshTokenForEnv, setTokenForEnv, getCredentialsForEnv, getCurrentEnv } from "./lib/config.js";
+// 💜 Valid column types (hardcoded to avoid npm dependency on @gufi/column-types)
+const COLUMN_TYPE_NAMES = [
+    "text", "email", "url", "barcode", "signature", "number", "number_int",
+    "number_float", "percentage", "date", "time", "created_at", "select",
+    "multiselect", "relation", "reversed_relation", "users", "boolean",
+    "currency", "phone", "location", "file", "json", "formula", "mirror",
+    "custom", "password"
+];
 // For ES modules __dirname equivalent
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -870,7 +878,11 @@ Example: gufi_view_pull({ view_id: 13 })`,
         description: `📤 Upload local view changes to draft.
 
 Pushes changed files from ~/gufi-dev/view_<id>/ to Gufi draft.
-Creates a snapshot for version history (last 10 kept).
+Creates a snapshot for version history (last 1000 kept).
+
+⚠️ IMPORTANT: Checks if local version is up-to-date before pushing.
+If server has newer version, returns VERSION_CONFLICT error.
+You must pull the latest version first before pushing.
 
 After pushing, use: gufi package:publish <package_id> to publish.
 
@@ -1182,37 +1194,18 @@ 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] },
-                };
+        // 💜 Validate field types BEFORE sending to API
+        // Uses COLUMN_TYPE_NAMES from @gufi/column-types (single source of truth)
+        for (const op of params.operations) {
+            if (op.field?.type && !COLUMN_TYPE_NAMES.includes(op.field.type)) {
+                throw new Error(`Invalid field type: "${op.field.type}". Valid types: ${COLUMN_TYPE_NAMES.join(", ")}`);
             }
-            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: normalizedOps,
+                operations: params.operations,
                 preview: params.preview || false,
                 skip_existing: params.skip_existing || false,
             }),
@@ -1824,6 +1817,15 @@ const toolHandlers = {
             // 💜 CLI: Save to ~/gufi-dev/view_<id>/
             const viewDir = path.join(LOCAL_VIEWS_DIR, `view_${viewId}`);
             fs.mkdirSync(viewDir, { recursive: true });
+            // 💜 Get latest snapshot for version tracking
+            let latestSnapshot;
+            try {
+                const snapshotResp = await apiRequest(`/api/marketplace/views/${viewId}/latest-snapshot`, {}, companyId, true, env);
+                latestSnapshot = snapshotResp.latest_snapshot;
+            }
+            catch {
+                // If endpoint not available, continue without snapshot tracking
+            }
             const fileMeta = {};
             for (const file of files) {
                 const filePath = path.join(viewDir, file.file_path.replace(/^\//, ""));
@@ -1833,12 +1835,13 @@ const toolHandlers = {
                     hash: crypto.createHash("sha256").update(file.content, "utf-8").digest("hex")
                 };
             }
-            // Save metadata
+            // Save metadata (with snapshot for version tracking)
             const meta = {
                 viewId,
                 viewName: `view_${viewId}`,
                 packageId: view.package_id || 0,
                 lastSync: new Date().toISOString(),
+                lastPulledSnapshot: latestSnapshot, // 💜 For version conflict detection
                 files: fileMeta,
             };
             fs.writeFileSync(path.join(viewDir, ".gufi-view.json"), JSON.stringify(meta, null, 2));
@@ -1881,12 +1884,24 @@ const toolHandlers = {
             throw new Error("view_id is required");
         }
         let files = [];
+        let lastPulledSnapshot; // 💜 For version conflict detection
         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.`);
             }
+            // 💜 Read metadata for version tracking (backend handles the check)
+            const metaPath = path.join(viewDir, ".gufi-view.json");
+            if (fs.existsSync(metaPath)) {
+                try {
+                    const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+                    lastPulledSnapshot = meta.lastPulledSnapshot;
+                }
+                catch {
+                    // Ignore metadata read errors
+                }
+            }
             // Get all files recursively
             const getFiles = (dir, prefix = "") => {
                 const result = [];
@@ -1921,16 +1936,83 @@ const toolHandlers = {
             const workspaceResponse = await apiRequest(`/api/claude/workspace/view/${viewId}/files`, {}, undefined, true, env);
             files = workspaceResponse.data || workspaceResponse || [];
         }
+        // 💜 VERSION CHECK: Always verify before push (don't rely on backend alone)
+        // This prevents overwriting changes from other developers
+        try {
+            const snapshotResp = await apiRequest(`/api/marketplace/views/${viewId}/latest-snapshot`, {}, undefined, true, env);
+            const serverSnapshot = snapshotResp.latest_snapshot;
+            // If server has versions but we don't have a local snapshot → conflict
+            // (means we pulled with an old CLI that didn't track versions)
+            if (serverSnapshot > 0 && lastPulledSnapshot === undefined) {
+                return {
+                    success: false,
+                    error: "VERSION_CONFLICT",
+                    message: `Tu versión local no tiene tracking de versiones. El servidor está en v${serverSnapshot}.`,
+                    local_snapshot: null,
+                    server_snapshot: serverSnapshot,
+                    _hint: `Haz pull primero para sincronizar: gufi_view_pull({ view_id: ${viewId} }). Si tienes cambios locales, cópialos a otra carpeta antes del pull.`,
+                };
+            }
+            // If snapshots don't match → someone else pushed
+            if (lastPulledSnapshot !== undefined && serverSnapshot !== lastPulledSnapshot) {
+                return {
+                    success: false,
+                    error: "VERSION_CONFLICT",
+                    message: `Tu versión local (v${lastPulledSnapshot}) no coincide con el servidor (v${serverSnapshot}). Alguien más hizo push.`,
+                    local_snapshot: lastPulledSnapshot,
+                    server_snapshot: serverSnapshot,
+                    _hint: `Haz pull primero: gufi_view_pull({ view_id: ${viewId} }). Si tienes cambios locales, cópialos a otra carpeta antes del pull.`,
+                };
+            }
+        }
+        catch (err) {
+            // If we can't check version, log warning but continue (backwards compat)
+            console.error("Warning: Could not verify version before push:", err.message);
+        }
         // 💜 Check for large files (>1000 lines) and suggest splitting
         const LINE_LIMIT = 1000;
         const largeFiles = files
             .map(f => ({ path: f.file_path, lines: f.content.split('\n').length }))
             .filter(f => f.lines > LINE_LIMIT);
         // 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);
+        // 💜 Backend will check lastPulledSnapshot and return 409 if conflict
+        let result;
+        try {
+            result = await apiRequest(`/api/marketplace/views/${viewId}/files/bulk`, {
+                method: "POST",
+                body: JSON.stringify({ files, message: params.message, sync: true, lastPulledSnapshot }),
+            }, undefined, true, env);
+        }
+        catch (err) {
+            // 💜 Handle version conflict from backend
+            if (err.status === 409 || err.error === "VERSION_CONFLICT") {
+                return {
+                    success: false,
+                    error: "VERSION_CONFLICT",
+                    message: err.message || `Conflicto de versión. Haz pull primero.`,
+                    local_snapshot: err.localSnapshot,
+                    server_snapshot: err.serverSnapshot,
+                    _hint: `Haz pull primero: gufi_view_pull({ view_id: ${viewId} }). Si tienes cambios locales, cópialos a otra carpeta antes del pull.`,
+                };
+            }
+            throw err;
+        }
+        // 💜 Update local metadata with new snapshot number (for version tracking)
+        if (useLocal && result.snapshot) {
+            const viewDir = path.join(LOCAL_VIEWS_DIR, `view_${viewId}`);
+            const metaPath = path.join(viewDir, ".gufi-view.json");
+            if (fs.existsSync(metaPath)) {
+                try {
+                    const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+                    meta.lastPulledSnapshot = result.snapshot;
+                    meta.lastSync = new Date().toISOString();
+                    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+                }
+                catch {
+                    // Ignore metadata update errors
+                }
+            }
+        }
         // Get view info for package
         let packageInfo = null;
         const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`, {}, undefined, true, env);

package/package.json

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