nstantpage-agent 0.8.5 → 0.8.7

package/dist/agentSync.d.ts

@@ -3,14 +3,12 @@
  *
  * CORE PRINCIPLE: Disk is ALWAYS the source of truth. ONE-WAY only.
  *
- * When a file changes on disk → push it to the backend DB. No checksums,
- * no comparisons, no conflict resolution. Whatever is on disk wins.
+ * 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
  *
- * 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
+ * No checksums, no comparisons, no diffs. Disk wins. Always.
  */
 export type SyncDirection = 'in-sync' | 'backend-ahead' | 'disk-ahead' | 'diverged';
 export interface SyncStatusResult {
@@ -49,9 +47,9 @@ export declare class AgentSync {
     private fileWatcher;
     private debounceTimer;
     private pendingChangedFiles;
-    private pushing;
+    private syncing;
     private lastVersionId;
-    private lastPushAt;
+    private lastSyncAt;
     constructor(options: AgentSyncOptions);
     startFileWatcher(): void;
     stopFileWatcher(): void;

package/dist/agentSync.js

@@ -3,14 +3,12 @@
  *
  * CORE PRINCIPLE: Disk is ALWAYS the source of truth. ONE-WAY only.
  *
- * When a file changes on disk → push it to the backend DB. No checksums,
- * no comparisons, no conflict resolution. Whatever is on disk wins.
+ * 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
  *
- * 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
+ * No checksums, no comparisons, no diffs. Disk wins. Always.
  */
 import path from 'path';
 import fs from 'fs/promises';
@@ -23,13 +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',
+    '.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('.');
@@ -37,7 +42,7 @@ 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);
 }
 /** Check if a relative path should be skipped (checks every path component) */
@@ -49,6 +54,42 @@ function shouldSkipPath(relPath) {
     }
     return shouldSkip(parts[parts.length - 1], false);
 }
+// ─── Collect All Files (same as sync.ts) ──────────────────────
+async function collectAllFiles(baseDir, currentDir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await fs.readdir(currentDir, { withFileTypes: true });
+    }
+    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;
     projectId;
@@ -58,9 +99,9 @@ export class AgentSync {
     fileWatcher = null;
     debounceTimer = null;
     pendingChangedFiles = new Set();
-    pushing = false;
+    syncing = false;
     lastVersionId = null;
-    lastPushAt = null;
+    lastSyncAt = null;
     constructor(options) {
         this.projectDir = options.projectDir;
         this.projectId = options.projectId;
@@ -86,7 +127,6 @@ export class AgentSync {
                     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);
                     }
@@ -112,10 +152,10 @@ export class AgentSync {
             this.debounceTimer = null;
         }
     }
-    // ─── Sync Status (simplified — just pending file count) ───
+    // ─── Sync Status ─────────────────────────────────────────
     async getSyncStatus() {
         const pending = this.pendingChangedFiles.size;
-        const isDirty = pending > 0 || this.pushing;
+        const isDirty = pending > 0 && !this.syncing;
         return {
             inSync: !isDirty,
             direction: isDirty ? 'disk-ahead' : 'in-sync',
@@ -127,7 +167,7 @@ export class AgentSync {
             diskOnlyFiles: [],
             backendOnlyFiles: [],
             lastSyncedVersionId: this.lastVersionId,
-            lastSyncedAt: this.lastPushAt,
+            lastSyncedAt: this.lastSyncAt,
             diskDirty: isDirty,
             computedAt: Date.now(),
         };
@@ -139,114 +179,93 @@ export class AgentSync {
             status: 'modified',
         }));
     }
-    // ─── Push to Backend ──────────────────────────────────────
+    // ─── Push to Backend (Full Sync) ──────────────────────────
     //
-    // 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.
+    // 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() {
-        const filesToProcess = [...this.pendingChangedFiles];
-        if (filesToProcess.length === 0) {
+        if (this.pendingChangedFiles.size === 0) {
             return {
-                success: true,
-                filesPushed: 0,
-                filesDeleted: 0,
-                modifiedFiles: [],
-                addedFiles: [],
-                deletedFiles: [],
+                success: true, filesPushed: 0, filesDeleted: 0,
+                modifiedFiles: [], addedFiles: [], deletedFiles: [],
                 message: 'Already in sync — no changes to push',
             };
         }
-        if (this.pushing) {
+        if (this.syncing) {
             return {
-                success: true,
-                filesPushed: 0,
-                filesDeleted: 0,
-                modifiedFiles: [],
-                addedFiles: [],
-                deletedFiles: [],
-                message: 'Push already in progress',
+                success: true, filesPushed: 0, filesDeleted: 0,
+                modifiedFiles: [], addedFiles: [], deletedFiles: [],
+                message: 'Sync already in progress',
             };
         }
-        this.pushing = true;
+        this.syncing = 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;
-                }
-                catch {
-                    // File doesn't exist or is binary/unreadable
-                    if (!existsSync(fullPath)) {
-                        deleted.push(relPath);
-                    }
-                }
-            }
-            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',
-                };
-            }
-            const pushUrl = `${this.backendUrl}/api/sandbox/push-files`;
-            const response = await fetch(pushUrl, {
+            // 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' },
-                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}`);
+            if (!syncRes.ok) {
+                const text = await syncRes.text().catch(() => '');
+                throw new Error(`Sync init failed (${syncRes.status}): ${text}`);
+            }
+            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;
+                }
+                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}`);
+                }
+                totalPushed += batch.length;
             }
-            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}`);
+            // 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: fileNames.length,
-                filesDeleted: deleted.length,
+                filesPushed: totalPushed,
+                filesDeleted: 0,
                 modifiedFiles: fileNames,
                 addedFiles: [],
-                deletedFiles: deleted,
-                versionId: pushResult.versionId ? String(pushResult.versionId) : undefined,
+                deletedFiles: [],
+                versionId: String(syncData.versionId),
             };
         }
         catch (err) {
-            // Push failed — keep files in pending for retry
-            console.error(`  [AgentSync] Push failed:`, err.message);
+            console.error(`  [AgentSync] Sync failed:`, err.message);
             throw err;
         }
         finally {
-            this.pushing = false;
+            this.syncing = false;
         }
     }
     // ─── Sync Markers (for compatibility with start.ts) ───────
     markSynced(versionId) {
         this.lastVersionId = versionId;
-        this.lastPushAt = Date.now();
-        // Clear any pending changes — we just synced, don't re-push fetched files
+        this.lastSyncAt = Date.now();
         this.pendingChangedFiles.clear();
         if (this.debounceTimer) {
             clearTimeout(this.debounceTimer);
@@ -281,7 +300,6 @@ 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 fp = path.join(this.projectDir, file.path);
@@ -290,7 +308,6 @@ export class AgentSync {
         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) {
@@ -301,9 +318,8 @@ export class AgentSync {
             }));
             written += batch.length;
         }
-        // Clear pending changes from the writes and mark synced
         this.lastVersionId = String(data.versionId);
-        this.lastPushAt = Date.now();
+        this.lastSyncAt = Date.now();
         this.pendingChangedFiles.clear();
         if (this.debounceTimer) {
             clearTimeout(this.debounceTimer);

package/dist/commands/start.js

@@ -268,13 +268,16 @@ export async function startCommand(directory, options) {
     console.log(chalk.gray(`  API server:   port ${apiPort}`));
     console.log(chalk.gray(`  Gateway:      ${options.gateway}`));
     console.log(chalk.gray(`  Backend:      ${backendUrl}\n`));
-    // 1. Fetch project files from the backend
+    // Determine if this is a user-managed local directory (--dir flag or explicit path)
+    // For local projects: disk is truth, NEVER overwrite disk from DB
+    const isLocalDir = !!(options.dir) || directory !== '.';
+    // 1. Fetch or sync project files
     const installer = new PackageInstaller({ projectDir });
     let fetchedVersionId;
-    try {
-        const { fileCount, isNew, versionId } = await fetchProjectFiles(backendUrl, projectId, projectDir, token);
-        fetchedVersionId = versionId;
-        // 2. Install dependencies if needed (verifies actual packages, not just folder)
+    if (isLocalDir) {
+        // Local project — SKIP DB→disk fetch. Disk is truth.
+        console.log(chalk.gray(`  Local project — using files from disk (not fetching from DB)`));
+        // Install dependencies if needed
         if (!installer.areDependenciesInstalled()) {
             if (fs.existsSync(path.join(projectDir, 'package.json'))) {
                 console.log(chalk.gray('  Installing dependencies...'));
@@ -292,13 +295,37 @@ export async function startCommand(directory, options) {
             console.log(chalk.gray(`  Dependencies already installed`));
         }
     }
-    catch (err) {
-        console.log(chalk.yellow(`  ⚠ Could not fetch project files: ${err.message}`));
-        console.log(chalk.gray('    Continuing with existing local files (if any)...'));
-        if (!fs.existsSync(path.join(projectDir, 'package.json'))) {
-            console.log(chalk.red(`\n✗ No package.json found and cannot fetch files from backend.`));
-            console.log(chalk.gray('  Check your project ID and authentication.'));
-            process.exit(1);
+    else {
+        // Cloud/managed project — fetch files from DB to disk
+        try {
+            const { fileCount, isNew, versionId } = await fetchProjectFiles(backendUrl, projectId, projectDir, token);
+            fetchedVersionId = versionId;
+            // 2. Install dependencies if needed (verifies actual packages, not just folder)
+            if (!installer.areDependenciesInstalled()) {
+                if (fs.existsSync(path.join(projectDir, 'package.json'))) {
+                    console.log(chalk.gray('  Installing dependencies...'));
+                    try {
+                        await installer.ensureDependencies();
+                        console.log(chalk.green(`  ✓ Dependencies installed`));
+                    }
+                    catch (err) {
+                        console.log(chalk.yellow(`  ⚠ Install failed: ${err.message?.slice(0, 200)}`));
+                        console.log(chalk.gray(`    Will retry when dev server starts`));
+                    }
+                }
+            }
+            else {
+                console.log(chalk.gray(`  Dependencies already installed`));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ⚠ Could not fetch project files: ${err.message}`));
+            console.log(chalk.gray('    Continuing with existing local files (if any)...'));
+            if (!fs.existsSync(path.join(projectDir, 'package.json'))) {
+                console.log(chalk.red(`\n✗ No package.json found and cannot fetch files from backend.`));
+                console.log(chalk.gray('  Check your project ID and authentication.'));
+                process.exit(1);
+            }
         }
     }
     // Save .nstantpage.json for future runs

package/package.json

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