nstantpage-agent 0.8.3 → 0.8.5

package/dist/agentSync.d.ts

@@ -1,12 +1,16 @@
 /**
- * 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 a file changes on disk → push it to the backend DB. No checksums,
+ * no comparisons, no conflict resolution. Whatever is on disk wins.
+ *
+ * Flow:
+ *   1. File watcher detects changes (debounced 1s)
+ *   2. Accumulate changed file paths in pendingChangedFiles
+ *   3. Fire onSyncDirty → frontend receives notification
+ *   4. Frontend calls pushToBackend → agent reads pending files from disk → pushes to DB
  */
 export type SyncDirection = 'in-sync' | 'backend-ahead' | 'disk-ahead' | 'diverged';
 export interface SyncStatusResult {
@@ -42,31 +46,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 pushing;
+    private lastVersionId;
+    private lastPushAt;
     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 +68,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,21 @@
 /**
- * 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 a file changes on disk → push it to the backend DB. No checksums,
+ * no comparisons, no conflict resolution. Whatever is on disk wins.
+ *
+ * Flow:
+ *   1. File watcher detects changes (debounced 1s)
+ *   2. Accumulate changed file paths in pendingChangedFiles
+ *   3. Fire onSyncDirty → frontend receives notification
+ *   4. Frontend calls pushToBackend → agent reads pending files from disk → pushes to DB
  */
-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',
@@ -27,23 +30,9 @@ 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',
-]);
 function shouldSkip(name, isDir) {
     if (isDir)
-        return SKIP_DIRS.has(name);
+        return SKIP_DIRS.has(name) || name.startsWith('.');
     if (SKIP_FILES.has(name))
         return true;
     if (name.startsWith('.'))
@@ -51,28 +40,14 @@ function shouldSkip(name, isDir) {
     const ext = path.extname(name);
     return SKIP_EXTENSIONS.has(ext);
 }
-function isUserCreatedFile(filePath) {
-    if (filePath.startsWith('src/') || filePath.startsWith('server/') ||
-        filePath.startsWith('shared/') || filePath.startsWith('public/')) {
-        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');
-}
-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));
+/** 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;
     }
-    return hash.digest('hex');
+    return shouldSkip(parts[parts.length - 1], false);
 }
 export class AgentSync {
     projectDir;
@@ -80,17 +55,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;
+    pushing = false;
+    lastVersionId = null;
+    lastPushAt = null;
     constructor(options) {
         this.projectDir = options.projectDir;
         this.projectId = options.projectId;
@@ -103,28 +73,24 @@ 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)
+            this.fileWatcher = watch(this.projectDir, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
                     return;
-                const parts = filename.split(path.sep);
-                if (parts.some(p => SKIP_DIRS.has(p)))
+                if (shouldSkipPath(filename))
                     return;
-                const basename = path.basename(filename);
-                if (shouldSkip(basename, false))
-                    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 ? '...' : ''}`);
+                    // Notify frontend so it triggers auto-push
+                    if (this.onSyncDirty) {
+                        this.onSyncDirty(this.projectId);
+                    }
+                }, 1000);
             });
             this.fileWatcher.on('error', (err) => {
                 console.warn(`  [AgentSync] File watcher error:`, err.message);
@@ -146,408 +112,147 @@ 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 (simplified — just pending file count) ───
+    async getSyncStatus() {
+        const pending = this.pendingChangedFiles.size;
+        const isDirty = pending > 0 || this.pushing;
+        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.lastPushAt,
+            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 ──────────────────────────────────────
+    //
+    // Reads the pending changed files from disk and pushes them to the DB.
+    // No checksums, no comparison — just read and push.
+    // If a file no longer exists on disk, it's marked as deleted.
+    async pushToBackend() {
+        const filesToProcess = [...this.pendingChangedFiles];
+        if (filesToProcess.length === 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 directories
-            const parts = filePath.split('/');
-            if (parts.some(p => SKIP_DIRS.has(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.pushing) {
             return {
-                inSync: true,
-                direction: 'in-sync',
-                diskChecksum: diskResult.globalChecksum || null,
-                backendChecksum: null,
-                diskFileCount: diskResult.checksums.size,
-                backendFileCount: 0,
+                success: true,
+                filesPushed: 0,
+                filesDeleted: 0,
                 modifiedFiles: [],
-                diskOnlyFiles: [],
-                backendOnlyFiles: [],
-                lastSyncedVersionId: this.lastSyncTimestamp?.versionId || null,
-                lastSyncedAt: this.lastSyncTimestamp?.timestamp || null,
-                diskDirty: this.diskDirty,
-                computedAt: Date.now(),
+                addedFiles: [],
+                deletedFiles: [],
+                message: 'Push 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 });
+        this.pushing = true;
+        try {
+            const files = {};
+            const deleted = [];
+            for (const relPath of filesToProcess) {
+                const fullPath = path.join(this.projectDir, relPath);
+                try {
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    files[relPath] = content;
                 }
-            }
-            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 });
+                catch {
+                    // File doesn't exist or is binary/unreadable
+                    if (!existsSync(fullPath)) {
+                        deleted.push(relPath);
                     }
                 }
             }
-        }
-        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 });
-                }
-            }
-            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 totalChanges = Object.keys(files).length + deleted.length;
+            if (totalChanges === 0) {
+                // All pending files were binary/unreadable — clear them
+                for (const f of filesToProcess)
+                    this.pendingChangedFiles.delete(f);
+                return {
+                    success: true,
+                    filesPushed: 0,
+                    filesDeleted: 0,
+                    modifiedFiles: [],
+                    addedFiles: [],
+                    deletedFiles: [],
+                    message: 'No pushable changes',
+                };
             }
-        }
-        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 };
-        for (const [filePath, backendSha] of backendResult.checksums) {
-            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 (!backendResult.checksums.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 content = diskData.fileContents.get(filePath);
-                if (content !== undefined)
-                    added[filePath] = content;
+            const pushUrl = `${this.backendUrl}/api/sandbox/push-files`;
+            const response = await fetch(pushUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    projectId: parseInt(this.projectId, 10),
+                    files,
+                    deletedFiles: deleted,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Backend push-files failed: ${response.status} ${errorText}`);
             }
-        }
-        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) {
+            const pushResult = await response.json();
+            // Success — remove pushed files from pending
+            for (const f of filesToProcess)
+                this.pendingChangedFiles.delete(f);
+            if (pushResult.versionId)
+                this.lastVersionId = String(pushResult.versionId);
+            this.lastPushAt = Date.now();
+            const fileNames = Object.keys(files);
+            console.log(`  [AgentSync] Pushed ${fileNames.length} files, deleted ${deleted.length}`);
             return {
                 success: true,
-                filesPushed: 0,
-                filesDeleted: 0,
-                modifiedFiles: [],
+                filesPushed: fileNames.length,
+                filesDeleted: deleted.length,
+                modifiedFiles: fileNames,
                 addedFiles: [],
-                deletedFiles: [],
-                message: 'Already in sync — no changes to push',
+                deletedFiles: deleted,
+                versionId: pushResult.versionId ? String(pushResult.versionId) : undefined,
             };
         }
-        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) {
+            // Push failed — keep files in pending for retry
+            console.error(`  [AgentSync] Push 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.pushing = 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.lastPushAt = Date.now();
+        // Clear any pending changes — we just synced, don't re-push fetched files
+        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) {
@@ -564,8 +269,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}`;
@@ -580,8 +284,8 @@ export class AgentSync {
         // 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(() => { });
@@ -592,25 +296,25 @@ export class AgentSync {
         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 };
+        // Clear pending changes from the writes and mark synced
+        this.lastVersionId = String(data.versionId);
+        this.lastPushAt = 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.3",
+  "version": "0.8.5",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {