nstantpage-agent 0.8.4 → 0.8.6

package/dist/agentSync.d.ts

@@ -1,12 +1,14 @@
 /**
- * agentSync.ts — File sync logic for the local agent.
+ * agentSync.ts — Simplified file sync for the local agent.
  *
- * Mirrors the gateway's syncStatus.ts but runs entirely on the user's machine.
- * Computes disk checksums, fetches backend checksums via HTTP, compares them,
- * and provides push-to-backend capability.
+ * CORE PRINCIPLE: Disk is ALWAYS the source of truth. ONE-WAY only.
  *
- * Also manages an fs.watch file watcher that triggers sync-dirty notifications
- * through the tunnel to the gateway (which relays to the frontend WebSocket).
+ * When files change on disk → do a FULL SYNC (same as `nstantpage sync`):
+ *   1. POST /api/projects/{id}/sync — new version + clear ALL FullFiles
+ *   2. Collect ALL disk files
+ *   3. POST /api/sandbox/push-files — push ALL files in batches
+ *
+ * No checksums, no comparisons, no diffs. Disk wins. Always.
  */
 export type SyncDirection = 'in-sync' | 'backend-ahead' | 'disk-ahead' | 'diverged';
 export interface SyncStatusResult {
@@ -42,31 +44,17 @@ export declare class AgentSync {
     private projectId;
     private backendUrl;
     private onSyncDirty?;
-    private diskDirty;
-    private diskChecksumCache;
-    private backendChecksumCache;
-    private lastSyncTimestamp;
-    private syncedBaselineChecksums;
     private fileWatcher;
     private debounceTimer;
     private pendingChangedFiles;
-    private readonly DISK_CACHE_TTL_MS;
-    private readonly BACKEND_CACHE_TTL_MS;
+    private syncing;
+    private lastVersionId;
+    private lastSyncAt;
     constructor(options: AgentSyncOptions);
     startFileWatcher(): void;
     stopFileWatcher(): void;
-    private markDiskDirty;
-    private computeDiskChecksums;
-    private getDiskData;
-    private fetchBackendChecksums;
-    private filterBackendChecksums;
     getSyncStatus(): Promise<SyncStatusResult>;
     getPerFileStatus(): Promise<PerFileStatus[]>;
-    getDiskChanges(): Promise<{
-        modified: Record<string, string>;
-        added: Record<string, string>;
-        deleted: string[];
-    }>;
     pushToBackend(): Promise<{
         success: boolean;
         filesPushed: number;
@@ -78,13 +66,11 @@ export declare class AgentSync {
         message?: string;
     }>;
     markSynced(versionId: string): void;
-    private snapshotBaseline;
     /** Read a single file from disk (for diff view) */
     readDiskFile(filePath: string): Promise<string | null>;
     /**
      * Pull files from the backend DB and write them to disk.
-     * This fetches ALL project files and overwrites local versions.
-     * Files that exist only on disk (not in DB) are left untouched.
+     * After writing, clears pending changes (the writes would trigger the watcher).
      */
     pullFromBackend(): Promise<{
         success: boolean;

package/dist/agentSync.js

@@ -1,18 +1,19 @@
 /**
- * agentSync.ts — File sync logic for the local agent.
+ * agentSync.ts — Simplified file sync for the local agent.
  *
- * Mirrors the gateway's syncStatus.ts but runs entirely on the user's machine.
- * Computes disk checksums, fetches backend checksums via HTTP, compares them,
- * and provides push-to-backend capability.
+ * CORE PRINCIPLE: Disk is ALWAYS the source of truth. ONE-WAY only.
  *
- * Also manages an fs.watch file watcher that triggers sync-dirty notifications
- * through the tunnel to the gateway (which relays to the frontend WebSocket).
+ * When files change on disk → do a FULL SYNC (same as `nstantpage sync`):
+ *   1. POST /api/projects/{id}/sync — new version + clear ALL FullFiles
+ *   2. Collect ALL disk files
+ *   3. POST /api/sandbox/push-files — push ALL files in batches
+ *
+ * No checksums, no comparisons, no diffs. Disk wins. Always.
  */
-import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs/promises';
 import { watch, existsSync } from 'fs';
-// ─── Skip Patterns (same as gateway syncStatus.ts) ────────────
+// ─── Skip Patterns ────────────────────────────────────────────
 const SKIP_DIRS = new Set([
     'node_modules', '.git', 'dist', 'build', '.next', 'out',
     '.vite-cache', '.cache', '.turbo', 'coverage', 'tools',
@@ -20,27 +21,20 @@ const SKIP_DIRS = new Set([
 ]);
 const SKIP_FILES = new Set([
     '.DS_Store', 'Thumbs.db', '.diagramgpt-meta.json',
-    'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock',
-    '.npmrc', '.gitignore', 'README.md',
 ]);
 const SKIP_EXTENSIONS = new Set([
-    '.map', '.log', '.tmp', '.swp', '.swo', '.svg', '.png', '.jpg', '.jpeg',
-    '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot',
-]);
-const TEMPLATE_SCAFFOLD_FILES = new Set([
-    'vite.config.ts', 'vite.config.js',
-    'postcss.config.ts', 'postcss.config.js',
-    'tailwind.config.ts', 'tailwind.config.js',
-    'tsconfig.json', 'tsconfig.app.json', 'tsconfig.node.json',
-    'eslint.config.js', '.eslintrc.js', '.eslintrc.cjs',
-    'drizzle.config.ts',
-    'pnpm-workspace.yaml',
-    'project-manifest.json',
-    'babel-plugin-inject-jsx-meta.ts',
-    '.env', '.npmrc', '.gitignore',
-    'package.json', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock',
-    'README.md', 'index.html',
+    '.map', '.log', '.tmp', '.swp', '.swo',
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.tiff',
+    '.mp4', '.mp3', '.wav', '.ogg', '.webm', '.avi',
+    '.zip', '.tar', '.gz', '.rar', '.7z',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+    '.exe', '.dll', '.so', '.dylib',
+    '.sqlite', '.db',
+    '.svg',
 ]);
+/** Max file size to sync (1MB) */
+const MAX_FILE_SIZE = 1_048_576;
 function shouldSkip(name, isDir) {
     if (isDir)
         return SKIP_DIRS.has(name) || name.startsWith('.');
@@ -48,31 +42,53 @@ function shouldSkip(name, isDir) {
         return true;
     if (name.startsWith('.'))
         return true;
-    const ext = path.extname(name);
+    const ext = path.extname(name).toLowerCase();
     return SKIP_EXTENSIONS.has(ext);
 }
-function isUserCreatedFile(filePath) {
-    if (filePath.startsWith('src/') || filePath.startsWith('server/') ||
-        filePath.startsWith('shared/') || filePath.startsWith('public/')) {
-        return true;
+/** Check if a relative path should be skipped (checks every path component) */
+function shouldSkipPath(relPath) {
+    const parts = relPath.split(/[\/\\]/);
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (shouldSkip(parts[i], true))
+            return true;
     }
-    const basename = path.basename(filePath);
-    if (TEMPLATE_SCAFFOLD_FILES.has(basename))
-        return false;
-    return true;
-}
-// ─── Checksum Computation ─────────────────────────────────────
-function sha256(content) {
-    return crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
+    return shouldSkip(parts[parts.length - 1], false);
 }
-function computeGlobalChecksum(fileContents) {
-    const hash = crypto.createHash('sha256');
-    const sortedPaths = [...fileContents.keys()].sort();
-    for (const filePath of sortedPaths) {
-        hash.update(filePath);
-        hash.update(fileContents.get(filePath));
+// ─── Collect All Files (same as sync.ts) ──────────────────────
+async function collectAllFiles(baseDir, currentDir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await fs.readdir(currentDir, { withFileTypes: true });
     }
-    return hash.digest('hex');
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            if (shouldSkip(entry.name, true))
+                continue;
+            const sub = await collectAllFiles(baseDir, fullPath);
+            files.push(...sub);
+        }
+        else if (entry.isFile()) {
+            if (shouldSkip(entry.name, false))
+                continue;
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.size > MAX_FILE_SIZE)
+                    continue;
+                const content = await fs.readFile(fullPath, 'utf-8');
+                if (content.includes('\0'))
+                    continue; // binary
+                const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+                files.push({ relativePath, content });
+            }
+            catch { /* unreadable — skip */ }
+        }
+    }
+    return files;
 }
 export class AgentSync {
     projectDir;
@@ -80,17 +96,12 @@ export class AgentSync {
     backendUrl;
     onSyncDirty;
     // State
-    diskDirty = false;
-    diskChecksumCache = null;
-    backendChecksumCache = null;
-    lastSyncTimestamp = null;
-    syncedBaselineChecksums = null;
     fileWatcher = null;
     debounceTimer = null;
     pendingChangedFiles = new Set();
-    // Cache TTLs
-    DISK_CACHE_TTL_MS = 5000;
-    BACKEND_CACHE_TTL_MS = 15000;
+    syncing = false;
+    lastVersionId = null;
+    lastSyncAt = null;
     constructor(options) {
         this.projectDir = options.projectDir;
         this.projectId = options.projectId;
@@ -103,28 +114,23 @@ export class AgentSync {
             return;
         if (!existsSync(this.projectDir))
             return;
-        /** Track whether we're currently writing files (skip self-triggered events) */
-        let selfWriting = false;
         try {
-            this.fileWatcher = watch(this.projectDir, { recursive: true }, (eventType, filename) => {
-                if (!filename || selfWriting)
-                    return;
-                const parts = filename.split(path.sep);
-                if (parts.some(p => SKIP_DIRS.has(p) || (p.startsWith('.') && p !== '.')))
+            this.fileWatcher = watch(this.projectDir, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
                     return;
-                const basename = path.basename(filename);
-                if (shouldSkip(basename, false))
+                if (shouldSkipPath(filename))
                     return;
-                // Accumulate changed filenames
                 this.pendingChangedFiles.add(filename);
                 if (this.debounceTimer)
                     clearTimeout(this.debounceTimer);
                 this.debounceTimer = setTimeout(() => {
-                    const changedFiles = [...this.pendingChangedFiles];
-                    this.pendingChangedFiles.clear();
-                    this.markDiskDirty();
-                    console.log(`  [AgentSync] File change detected: ${changedFiles.length} file(s) — ${changedFiles.slice(0, 5).join(', ')}${changedFiles.length > 5 ? '...' : ''}`);
-                }, 500);
+                    const count = this.pendingChangedFiles.size;
+                    const preview = [...this.pendingChangedFiles].slice(0, 5).join(', ');
+                    console.log(`  [AgentSync] Change detected: ${count} file(s) — ${preview}${count > 5 ? '...' : ''}`);
+                    if (this.onSyncDirty) {
+                        this.onSyncDirty(this.projectId);
+                    }
+                }, 1000);
             });
             this.fileWatcher.on('error', (err) => {
                 console.warn(`  [AgentSync] File watcher error:`, err.message);
@@ -146,410 +152,126 @@ export class AgentSync {
             this.debounceTimer = null;
         }
     }
-    // ─── Disk Dirty State ─────────────────────────────────────
-    markDiskDirty() {
-        this.diskDirty = true;
-        this.diskChecksumCache = null; // Force recompute
-        // Notify on every change — the debounce timer in the file watcher
-        // already batches rapid changes, so this fires at most once per debounce window.
-        if (this.onSyncDirty) {
-            this.onSyncDirty(this.projectId);
-        }
-    }
-    // ─── Disk Checksums ───────────────────────────────────────
-    async computeDiskChecksums() {
-        const checksums = new Map();
-        const fileContents = new Map();
-        if (!existsSync(this.projectDir)) {
-            return { checksums, fileContents, globalChecksum: '' };
-        }
-        // Phase 1: Collect all file paths
-        const filePaths = [];
-        const collectPaths = async (dir) => {
-            let entries;
-            try {
-                entries = await fs.readdir(dir, { withFileTypes: true });
-            }
-            catch {
-                return;
-            }
-            for (const entry of entries) {
-                if (shouldSkip(entry.name, entry.isDirectory()))
-                    continue;
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    await collectPaths(fullPath);
-                }
-                else {
-                    const relPath = path.relative(this.projectDir, fullPath);
-                    if (relPath.startsWith('dist/') || relPath.startsWith('build/'))
-                        continue;
-                    filePaths.push(fullPath);
-                }
-            }
+    // ─── Sync Status ─────────────────────────────────────────
+    async getSyncStatus() {
+        const pending = this.pendingChangedFiles.size;
+        const isDirty = pending > 0 && !this.syncing;
+        return {
+            inSync: !isDirty,
+            direction: isDirty ? 'disk-ahead' : 'in-sync',
+            diskChecksum: null,
+            backendChecksum: null,
+            diskFileCount: 0,
+            backendFileCount: 0,
+            modifiedFiles: [...this.pendingChangedFiles].sort(),
+            diskOnlyFiles: [],
+            backendOnlyFiles: [],
+            lastSyncedVersionId: this.lastVersionId,
+            lastSyncedAt: this.lastSyncAt,
+            diskDirty: isDirty,
+            computedAt: Date.now(),
         };
-        await collectPaths(this.projectDir);
-        // Phase 2: Read files in parallel batches of 50
-        const BATCH_SIZE = 50;
-        for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-            const batch = filePaths.slice(i, i + BATCH_SIZE);
-            await Promise.all(batch.map(async (fullPath) => {
-                try {
-                    const content = await fs.readFile(fullPath, 'utf-8');
-                    const relPath = path.relative(this.projectDir, fullPath);
-                    checksums.set(relPath, sha256(content));
-                    fileContents.set(relPath, content);
-                }
-                catch {
-                    // Binary file or unreadable — skip
-                }
-            }));
-        }
-        const globalChecksum = computeGlobalChecksum(fileContents);
-        return { checksums, fileContents, globalChecksum };
     }
-    async getDiskData() {
-        // Use cache if fresh and not dirty
-        if (this.diskChecksumCache && !this.diskDirty &&
-            Date.now() - this.diskChecksumCache.computedAt < this.DISK_CACHE_TTL_MS) {
-            return this.diskChecksumCache;
-        }
-        const computed = await this.computeDiskChecksums();
-        this.diskChecksumCache = { ...computed, computedAt: Date.now() };
-        if (this.diskDirty)
-            this.diskDirty = false;
-        return computed;
+    // ─── Per-File Status ──────────────────────────────────────
+    async getPerFileStatus() {
+        return [...this.pendingChangedFiles].sort().map(f => ({
+            path: f,
+            status: 'modified',
+        }));
     }
-    // ─── Backend Checksums ────────────────────────────────────
-    async fetchBackendChecksums() {
-        // Check cache first
-        if (this.backendChecksumCache &&
-            Date.now() - this.backendChecksumCache.fetchedAt < this.BACKEND_CACHE_TTL_MS) {
+    // ─── Push to Backend (Full Sync) ──────────────────────────
+    //
+    // Does EXACTLY what `nstantpage sync` does:
+    //   1. POST /api/projects/{id}/sync — new version + clear ALL FullFiles
+    //   2. Collect ALL files from disk
+    //   3. POST /api/sandbox/push-files — push ALL files in batches of 100
+    async pushToBackend() {
+        if (this.pendingChangedFiles.size === 0) {
             return {
-                checksums: this.backendChecksumCache.checksums,
-                globalChecksum: this.backendChecksumCache.globalChecksum,
-                versionId: this.backendChecksumCache.versionId,
-                fileCount: this.backendChecksumCache.checksums.size,
-            };
-        }
-        try {
-            const url = `${this.backendUrl}/api/sandbox/file-checksums?projectId=${this.projectId}`;
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 10000);
-            const response = await fetch(url, { signal: controller.signal });
-            clearTimeout(timeout);
-            if (!response.ok) {
-                console.warn(`  [AgentSync] file-checksums returned ${response.status}`);
-                return null;
-            }
-            const data = await response.json();
-            const checksums = new Map(Object.entries(data.files));
-            const result = {
-                checksums,
-                globalChecksum: data.checksum,
-                versionId: String(data.versionId),
-                fileCount: data.fileCount,
-            };
-            this.backendChecksumCache = {
-                ...result,
-                fetchedAt: Date.now(),
+                success: true, filesPushed: 0, filesDeleted: 0,
+                modifiedFiles: [], addedFiles: [], deletedFiles: [],
+                message: 'Already in sync — no changes to push',
             };
-            return result;
         }
-        catch (error) {
-            if (error.name === 'AbortError') {
-                console.warn(`  [AgentSync] Backend checksum request timed out`);
-            }
-            else {
-                console.warn(`  [AgentSync] Error fetching backend checksums:`, error.message);
-            }
-            return null;
-        }
-    }
-    // ─── Filter backend checksums (same skip rules as disk scan) ──
-    filterBackendChecksums(backendChecksums) {
-        const filtered = new Map();
-        for (const [filePath, sha] of backendChecksums) {
-            const basename = path.basename(filePath);
-            const ext = path.extname(filePath);
-            if (SKIP_FILES.has(basename))
-                continue;
-            if (basename.startsWith('.'))
-                continue;
-            if (SKIP_EXTENSIONS.has(ext))
-                continue;
-            // Match disk scan: skip files inside SKIP_DIRS or dotfile directories
-            const parts = filePath.split('/');
-            if (parts.some(p => SKIP_DIRS.has(p) || (p.startsWith('.') && p !== '.')))
-                continue;
-            // Match disk scan: skip dist/ and build/ top-level paths
-            if (filePath.startsWith('dist/') || filePath.startsWith('build/'))
-                continue;
-            filtered.set(filePath, sha);
-        }
-        return filtered;
-    }
-    // ─── Sync Status ──────────────────────────────────────────
-    async getSyncStatus() {
-        const diskResult = await this.getDiskData();
-        const backendResult = await this.fetchBackendChecksums();
-        if (!backendResult) {
+        if (this.syncing) {
             return {
-                inSync: true,
-                direction: 'in-sync',
-                diskChecksum: diskResult.globalChecksum || null,
-                backendChecksum: null,
-                diskFileCount: diskResult.checksums.size,
-                backendFileCount: 0,
-                modifiedFiles: [],
-                diskOnlyFiles: [],
-                backendOnlyFiles: [],
-                lastSyncedVersionId: this.lastSyncTimestamp?.versionId || null,
-                lastSyncedAt: this.lastSyncTimestamp?.timestamp || null,
-                diskDirty: this.diskDirty,
-                computedAt: Date.now(),
+                success: true, filesPushed: 0, filesDeleted: 0,
+                modifiedFiles: [], addedFiles: [], deletedFiles: [],
+                message: 'Sync already in progress',
             };
         }
-        const filteredBackend = this.filterBackendChecksums(backendResult.checksums);
-        const baseline = this.syncedBaselineChecksums;
-        const modifiedFiles = [];
-        const diskOnlyFiles = [];
-        const backendOnlyFiles = [];
-        if (baseline) {
-            // Baseline mode: detect user edits since last sync
-            for (const [filePath, baselineSha] of baseline) {
-                const currentDiskSha = diskResult.checksums.get(filePath);
-                if (!currentDiskSha) {
-                    if (filteredBackend.has(filePath)) {
-                        modifiedFiles.push(filePath);
-                    }
-                }
-                else if (currentDiskSha !== baselineSha) {
-                    modifiedFiles.push(filePath);
-                }
-            }
-            for (const [filePath] of diskResult.checksums) {
-                if (!baseline.has(filePath) && isUserCreatedFile(filePath)) {
-                    diskOnlyFiles.push(filePath);
-                }
-            }
-            for (const [filePath, backendSha] of filteredBackend) {
-                if (!baseline.has(filePath) && !diskResult.checksums.has(filePath)) {
-                    backendOnlyFiles.push(filePath);
-                }
-                else if (baseline.has(filePath) && diskResult.checksums.has(filePath)) {
-                    const baselineSha = baseline.get(filePath);
-                    const diskSha = diskResult.checksums.get(filePath);
-                    if (backendSha !== baselineSha && diskSha === baselineSha) {
-                        if (!modifiedFiles.includes(filePath))
-                            modifiedFiles.push(filePath);
-                    }
-                }
-            }
-        }
-        else {
-            // No baseline: direct disk vs backend comparison
-            for (const [filePath, backendSha] of filteredBackend) {
-                const diskSha = diskResult.checksums.get(filePath);
-                if (!diskSha) {
-                    backendOnlyFiles.push(filePath);
-                }
-                else if (diskSha !== backendSha) {
-                    modifiedFiles.push(filePath);
-                }
-            }
-            for (const [filePath] of diskResult.checksums) {
-                if (!filteredBackend.has(filePath) && isUserCreatedFile(filePath)) {
-                    diskOnlyFiles.push(filePath);
-                }
-            }
-        }
-        // Determine direction
-        // Disk is always the source of truth. DB only changes via push or AI coding agent
-        // (which updates both disk+DB simultaneously). So direction is only ever
-        // 'in-sync' or 'disk-ahead'. backendOnlyFiles are stale DB remnants, not "newer" files.
-        const inSync = modifiedFiles.length === 0 && diskOnlyFiles.length === 0 && backendOnlyFiles.length === 0;
-        const direction = inSync ? 'in-sync' : 'disk-ahead';
-        return {
-            inSync,
-            direction,
-            diskChecksum: diskResult.globalChecksum || null,
-            backendChecksum: backendResult.globalChecksum || null,
-            diskFileCount: diskResult.checksums.size,
-            backendFileCount: backendResult.checksums.size,
-            modifiedFiles: modifiedFiles.sort(),
-            diskOnlyFiles: diskOnlyFiles.sort(),
-            backendOnlyFiles: backendOnlyFiles.sort(),
-            lastSyncedVersionId: this.lastSyncTimestamp?.versionId || null,
-            lastSyncedAt: this.lastSyncTimestamp?.timestamp || null,
-            diskDirty: this.diskDirty,
-            computedAt: Date.now(),
-        };
-    }
-    // ─── Per-File Status (Detailed) ───────────────────────────
-    async getPerFileStatus() {
-        const diskComputed = await this.computeDiskChecksums();
-        const backendResult = await this.fetchBackendChecksums();
-        if (!backendResult)
-            return [];
-        // Use filtered backend checksums (same skip rules as disk scan) for consistency with getSyncStatus
-        const filteredBackend = this.filterBackendChecksums(backendResult.checksums);
-        const baseline = this.syncedBaselineChecksums;
-        const result = [];
-        if (baseline) {
-            for (const [filePath, baselineSha] of baseline) {
-                const currentDiskSha = diskComputed.checksums.get(filePath);
-                const backendSha = filteredBackend.get(filePath);
-                if (!currentDiskSha) {
-                    if (backendSha) {
-                        result.push({ path: filePath, status: 'modified', backendSha });
-                    }
-                }
-                else if (currentDiskSha !== baselineSha) {
-                    result.push({ path: filePath, status: 'modified', diskSha: currentDiskSha, backendSha });
-                }
-            }
-            for (const [filePath, diskSha] of diskComputed.checksums) {
-                if (!baseline.has(filePath) && isUserCreatedFile(filePath)) {
-                    result.push({ path: filePath, status: 'disk-only', diskSha });
-                }
-            }
-            if (this.lastSyncTimestamp && this.lastSyncTimestamp.versionId !== backendResult.versionId) {
-                for (const [filePath, backendSha] of filteredBackend) {
-                    if (!baseline.has(filePath) && !diskComputed.checksums.has(filePath)) {
-                        result.push({ path: filePath, status: 'backend-only', backendSha });
-                    }
-                }
-            }
-        }
-        else {
-            const sortedBackend = [...filteredBackend.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-            for (const [filePath, backendSha] of sortedBackend) {
-                const diskSha = diskComputed.checksums.get(filePath);
-                if (diskSha) {
-                    result.push({
-                        path: filePath,
-                        status: diskSha === backendSha ? 'same' : 'modified',
-                        diskSha,
-                        backendSha,
-                    });
-                }
-                else {
-                    result.push({ path: filePath, status: 'backend-only', backendSha });
-                }
+        this.syncing = true;
+        try {
+            // Step 1: Create new version + clear all FullFiles
+            const syncRes = await fetch(`${this.backendUrl}/api/projects/${this.projectId}/sync`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (!syncRes.ok) {
+                const text = await syncRes.text().catch(() => '');
+                throw new Error(`Sync init failed (${syncRes.status}): ${text}`);
             }
-            const sortedDisk = [...diskComputed.checksums.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-            for (const [filePath, diskSha] of sortedDisk) {
-                if (!filteredBackend.has(filePath) && isUserCreatedFile(filePath)) {
-                    result.push({ path: filePath, status: 'disk-only', diskSha });
+            const syncData = await syncRes.json();
+            console.log(`  [AgentSync] New version ${syncData.versionNumber} created (old files cleared)`);
+            // Step 2: Collect ALL files from disk
+            const allFiles = await collectAllFiles(this.projectDir, this.projectDir);
+            // Step 3: Push in batches of 100
+            const BATCH_SIZE = 100;
+            let totalPushed = 0;
+            for (let i = 0; i < allFiles.length; i += BATCH_SIZE) {
+                const batch = allFiles.slice(i, i + BATCH_SIZE);
+                const filesMap = {};
+                for (const f of batch) {
+                    filesMap[f.relativePath] = f.content;
                 }
-            }
-        }
-        result.sort((a, b) => a.path.localeCompare(b.path));
-        return result;
-    }
-    // ─── Disk Changes (for push-to-backend) ───────────────────
-    async getDiskChanges() {
-        const diskData = await this.getDiskData();
-        const backendResult = await this.fetchBackendChecksums();
-        const modified = {};
-        const added = {};
-        const deleted = [];
-        if (!backendResult)
-            return { modified, added, deleted };
-        // Use filtered backend checksums so dotfile dirs (.angular etc) and skip patterns are excluded
-        const filteredBackend = this.filterBackendChecksums(backendResult.checksums);
-        for (const [filePath, backendSha] of filteredBackend) {
-            const diskSha = diskData.checksums.get(filePath);
-            if (!diskSha) {
-                deleted.push(filePath);
-            }
-            else if (diskSha !== backendSha) {
-                const content = diskData.fileContents.get(filePath);
-                if (content !== undefined)
-                    modified[filePath] = content;
-            }
-        }
-        for (const [filePath] of diskData.checksums) {
-            if (!filteredBackend.has(filePath) && isUserCreatedFile(filePath)) {
-                if (this.syncedBaselineChecksums) {
-                    const baselineSha = this.syncedBaselineChecksums.get(filePath);
-                    if (baselineSha && baselineSha === diskData.checksums.get(filePath)) {
-                        continue; // Unchanged since initial sync — template noise
-                    }
+                const pushRes = await fetch(`${this.backendUrl}/api/sandbox/push-files`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        projectId: parseInt(this.projectId, 10),
+                        files: filesMap,
+                    }),
+                });
+                if (!pushRes.ok) {
+                    const text = await pushRes.text().catch(() => '');
+                    throw new Error(`Push batch failed (${pushRes.status}): ${text}`);
                 }
-                const content = diskData.fileContents.get(filePath);
-                if (content !== undefined)
-                    added[filePath] = content;
+                totalPushed += batch.length;
             }
-        }
-        return { modified, added, deleted };
-    }
-    // ─── Push to Backend ──────────────────────────────────────
-    async pushToBackend() {
-        const changes = await this.getDiskChanges();
-        const totalChanges = Object.keys(changes.modified).length +
-            Object.keys(changes.added).length +
-            changes.deleted.length;
-        if (totalChanges === 0) {
+            // Done — clear pending
+            this.pendingChangedFiles.clear();
+            this.lastVersionId = String(syncData.versionId);
+            this.lastSyncAt = Date.now();
+            const fileNames = allFiles.map(f => f.relativePath);
+            console.log(`  [AgentSync] Full sync complete: ${totalPushed} files pushed (version ${syncData.versionNumber})`);
             return {
                 success: true,
-                filesPushed: 0,
+                filesPushed: totalPushed,
                 filesDeleted: 0,
-                modifiedFiles: [],
+                modifiedFiles: fileNames,
                 addedFiles: [],
                 deletedFiles: [],
-                message: 'Already in sync — no changes to push',
+                versionId: String(syncData.versionId),
             };
         }
-        const allFiles = { ...changes.modified, ...changes.added };
-        const pushUrl = `${this.backendUrl}/api/sandbox/push-files`;
-        const pushResponse = await fetch(pushUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                projectId: parseInt(this.projectId, 10),
-                files: allFiles,
-                deletedFiles: changes.deleted,
-            }),
-        });
-        if (!pushResponse.ok) {
-            const errorText = await pushResponse.text();
-            throw new Error(`Backend push-files failed: ${pushResponse.status} ${errorText}`);
+        catch (err) {
+            console.error(`  [AgentSync] Sync failed:`, err.message);
+            throw err;
         }
-        const pushResult = await pushResponse.json();
-        // Invalidate caches
-        this.diskChecksumCache = null;
-        this.backendChecksumCache = null;
-        // Mark as synced
-        if (pushResult.versionId) {
-            this.markSynced(String(pushResult.versionId));
+        finally {
+            this.syncing = false;
         }
-        console.log(`  [AgentSync] Pushed ${Object.keys(allFiles).length} files, deleted ${changes.deleted.length}`);
-        return {
-            success: true,
-            filesPushed: Object.keys(allFiles).length,
-            filesDeleted: changes.deleted.length,
-            modifiedFiles: Object.keys(changes.modified),
-            addedFiles: Object.keys(changes.added),
-            deletedFiles: changes.deleted,
-            versionId: pushResult.versionId ? String(pushResult.versionId) : undefined,
-        };
     }
-    // ─── Sync Markers ────────────────────────────────────────
+    // ─── Sync Markers (for compatibility with start.ts) ───────
     markSynced(versionId) {
-        this.lastSyncTimestamp = { versionId, timestamp: Date.now() };
-        this.diskDirty = false;
-        this.diskChecksumCache = null;
-        this.backendChecksumCache = null;
-        // Snapshot current disk checksums as baseline (fire-and-forget)
-        this.snapshotBaseline().catch(err => console.warn(`  [AgentSync] Failed to snapshot baseline:`, err.message));
-    }
-    async snapshotBaseline() {
-        const computed = await this.computeDiskChecksums();
-        this.syncedBaselineChecksums = computed.checksums;
-        this.diskChecksumCache = { ...computed, computedAt: Date.now() };
-        console.log(`  [AgentSync] Baseline snapshot: ${computed.checksums.size} files`);
+        this.lastVersionId = versionId;
+        this.lastSyncAt = Date.now();
+        this.pendingChangedFiles.clear();
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        console.log(`  [AgentSync] Marked synced at version ${versionId}`);
     }
     /** Read a single file from disk (for diff view) */
     async readDiskFile(filePath) {
@@ -566,8 +288,7 @@ export class AgentSync {
     }
     /**
      * Pull files from the backend DB and write them to disk.
-     * This fetches ALL project files and overwrites local versions.
-     * Files that exist only on disk (not in DB) are left untouched.
+     * After writing, clears pending changes (the writes would trigger the watcher).
      */
     async pullFromBackend() {
         const url = `${this.backendUrl}/api/sandbox/files?projectId=${this.projectId}`;
@@ -579,40 +300,37 @@ export class AgentSync {
         if (!data.files || data.files.length === 0) {
             return { success: true, filesWritten: 0 };
         }
-        // Ensure directories exist
         const dirsToCreate = new Set();
         for (const file of data.files) {
-            const filePath = path.join(this.projectDir, file.path);
-            dirsToCreate.add(path.dirname(filePath));
+            const fp = path.join(this.projectDir, file.path);
+            dirsToCreate.add(path.dirname(fp));
         }
         for (const dir of dirsToCreate) {
             await fs.mkdir(dir, { recursive: true }).catch(() => { });
         }
-        // Write files in parallel batches
         const BATCH_SIZE = 50;
         let written = 0;
         for (let i = 0; i < data.files.length; i += BATCH_SIZE) {
             const batch = data.files.slice(i, i + BATCH_SIZE);
             await Promise.all(batch.map(async (file) => {
-                const filePath = path.join(this.projectDir, file.path);
-                await fs.writeFile(filePath, file.content, 'utf-8');
+                const fp = path.join(this.projectDir, file.path);
+                await fs.writeFile(fp, file.content, 'utf-8');
             }));
             written += batch.length;
         }
-        // Invalidate caches and re-establish baseline
-        this.diskChecksumCache = null;
-        this.backendChecksumCache = null;
-        const versionId = String(data.versionId);
-        this.markSynced(versionId);
-        console.log(`  [AgentSync] Pulled ${written} files from backend (version ${versionId})`);
-        return { success: true, filesWritten: written, versionId };
+        this.lastVersionId = String(data.versionId);
+        this.lastSyncAt = Date.now();
+        this.pendingChangedFiles.clear();
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        console.log(`  [AgentSync] Pulled ${written} files from backend (version ${data.versionId})`);
+        return { success: true, filesWritten: written, versionId: String(data.versionId) };
     }
     // ─── Cleanup ──────────────────────────────────────────────
     destroy() {
         this.stopFileWatcher();
-        this.diskChecksumCache = null;
-        this.backendChecksumCache = null;
-        this.syncedBaselineChecksums = null;
         this.pendingChangedFiles.clear();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {