nstantpage-agent 0.5.21 → 0.5.22

package/dist/agentSync.d.ts

@@ -0,0 +1,85 @@
+/**
+ * agentSync.ts — File sync logic 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.
+ *
+ * Also manages an fs.watch file watcher that triggers sync-dirty notifications
+ * through the tunnel to the gateway (which relays to the frontend WebSocket).
+ */
+export type SyncDirection = 'in-sync' | 'backend-ahead' | 'disk-ahead' | 'diverged';
+export interface SyncStatusResult {
+    inSync: boolean;
+    direction: SyncDirection;
+    diskChecksum: string | null;
+    backendChecksum: string | null;
+    diskFileCount: number;
+    backendFileCount: number;
+    modifiedFiles: string[];
+    diskOnlyFiles: string[];
+    backendOnlyFiles: string[];
+    lastSyncedVersionId: string | null;
+    lastSyncedAt: number | null;
+    diskDirty: boolean;
+    computedAt: number;
+}
+export interface PerFileStatus {
+    path: string;
+    status: 'same' | 'modified' | 'disk-only' | 'backend-only';
+    diskSha?: string;
+    backendSha?: string;
+}
+export interface AgentSyncOptions {
+    projectDir: string;
+    projectId: string;
+    backendUrl: string;
+    /** Called when file watcher detects changes — should send sync-dirty via tunnel */
+    onSyncDirty?: (projectId: string) => void;
+}
+export declare class AgentSync {
+    private projectDir;
+    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;
+    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;
+        filesDeleted: number;
+        modifiedFiles: string[];
+        addedFiles: string[];
+        deletedFiles: string[];
+        versionId?: string;
+        message?: string;
+    }>;
+    markSynced(versionId: string): void;
+    private snapshotBaseline;
+    /** Read a single file from disk (for diff view) */
+    readDiskFile(filePath: string): Promise<string | null>;
+    destroy(): void;
+}

package/dist/agentSync.js

@@ -0,0 +1,590 @@
+/**
+ * agentSync.ts — File sync logic 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.
+ *
+ * Also manages an fs.watch file watcher that triggers sync-dirty notifications
+ * through the tunnel to the gateway (which relays to the frontend WebSocket).
+ */
+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) ────────────
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', 'out',
+    '.vite-cache', '.cache', '.turbo', 'coverage', 'tools',
+    'script', '.github',
+]);
+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',
+]);
+function shouldSkip(name, isDir) {
+    if (isDir)
+        return SKIP_DIRS.has(name);
+    if (SKIP_FILES.has(name))
+        return true;
+    if (name.startsWith('.'))
+        return true;
+    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));
+    }
+    return hash.digest('hex');
+}
+export class AgentSync {
+    projectDir;
+    projectId;
+    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;
+    constructor(options) {
+        this.projectDir = options.projectDir;
+        this.projectId = options.projectId;
+        this.backendUrl = options.backendUrl;
+        this.onSyncDirty = options.onSyncDirty;
+    }
+    // ─── File Watcher ─────────────────────────────────────────
+    startFileWatcher() {
+        if (this.fileWatcher)
+            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)))
+                    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);
+            });
+            this.fileWatcher.on('error', (err) => {
+                console.warn(`  [AgentSync] File watcher error:`, err.message);
+                this.stopFileWatcher();
+            });
+            console.log(`  [AgentSync] File watcher started for ${this.projectDir}`);
+        }
+        catch (err) {
+            console.warn(`  [AgentSync] Could not start file watcher: ${err.message}`);
+        }
+    }
+    stopFileWatcher() {
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    // ─── Disk Dirty State ─────────────────────────────────────
+    markDiskDirty() {
+        const wasDirty = this.diskDirty;
+        this.diskDirty = true;
+        this.diskChecksumCache = null; // Force recompute
+        // Only notify on transition from clean to dirty
+        if (!wasDirty && 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);
+                }
+            }
+        };
+        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;
+    }
+    // ─── Backend Checksums ────────────────────────────────────
+    async fetchBackendChecksums() {
+        // Check cache first
+        if (this.backendChecksumCache &&
+            Date.now() - this.backendChecksumCache.fetchedAt < this.BACKEND_CACHE_TTL_MS) {
+            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(),
+            };
+            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;
+            filtered.set(filePath, sha);
+        }
+        return filtered;
+    }
+    // ─── Sync Status ──────────────────────────────────────────
+    async getSyncStatus() {
+        const diskResult = await this.getDiskData();
+        const backendResult = await this.fetchBackendChecksums();
+        if (!backendResult) {
+            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(),
+            };
+        }
+        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
+        const inSync = modifiedFiles.length === 0 && diskOnlyFiles.length === 0 && backendOnlyFiles.length === 0;
+        let direction = 'in-sync';
+        if (!inSync) {
+            const hasDiskEdits = modifiedFiles.length > 0 || diskOnlyFiles.length > 0;
+            const hasBackendEdits = backendOnlyFiles.length > 0;
+            let modifiedFromBackend = false;
+            if (modifiedFiles.length > 0 && baseline) {
+                for (const filePath of modifiedFiles) {
+                    const baselineSha = baseline.get(filePath);
+                    const diskSha = diskResult.checksums.get(filePath);
+                    const backendSha = filteredBackend.get(filePath);
+                    if (baselineSha && diskSha === baselineSha && backendSha && backendSha !== baselineSha) {
+                        modifiedFromBackend = true;
+                        break;
+                    }
+                }
+            }
+            if ((hasDiskEdits && !modifiedFromBackend) && hasBackendEdits) {
+                direction = 'diverged';
+            }
+            else if (hasDiskEdits && !modifiedFromBackend && !hasBackendEdits) {
+                direction = 'disk-ahead';
+            }
+            else if (hasBackendEdits || modifiedFromBackend) {
+                direction = 'backend-ahead';
+            }
+            else {
+                direction = '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 [];
+        const baseline = this.syncedBaselineChecksums;
+        const result = [];
+        if (baseline) {
+            for (const [filePath, baselineSha] of baseline) {
+                const currentDiskSha = diskComputed.checksums.get(filePath);
+                const backendSha = backendResult.checksums.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 backendResult.checksums) {
+                    if (!baseline.has(filePath) && !diskComputed.checksums.has(filePath)) {
+                        result.push({ path: filePath, status: 'backend-only', backendSha });
+                    }
+                }
+            }
+        }
+        else {
+            const sortedBackend = [...backendResult.checksums.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 (!backendResult.checksums.has(filePath) && isUserCreatedFile(filePath)) {
+                    result.push({ path: filePath, status: 'disk-only', diskSha });
+                }
+            }
+        }
+        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;
+            }
+        }
+        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) {
+            return {
+                success: true,
+                filesPushed: 0,
+                filesDeleted: 0,
+                modifiedFiles: [],
+                addedFiles: [],
+                deletedFiles: [],
+                message: 'Already in sync — no changes to push',
+            };
+        }
+        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}`);
+        }
+        const pushResult = await pushResponse.json();
+        // Invalidate caches
+        this.diskChecksumCache = null;
+        this.backendChecksumCache = null;
+        // Mark as synced
+        if (pushResult.versionId) {
+            this.markSynced(String(pushResult.versionId));
+        }
+        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 ────────────────────────────────────────
+    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`);
+    }
+    /** Read a single file from disk (for diff view) */
+    async readDiskFile(filePath) {
+        try {
+            const normalized = path.normalize(filePath).replace(/\.\.\//g, '');
+            const fullPath = path.join(this.projectDir, normalized);
+            if (!fullPath.startsWith(this.projectDir))
+                return null;
+            return await fs.readFile(fullPath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    // ─── Cleanup ──────────────────────────────────────────────
+    destroy() {
+        this.stopFileWatcher();
+        this.diskChecksumCache = null;
+        this.backendChecksumCache = null;
+        this.syncedBaselineChecksums = null;
+        this.pendingChangedFiles.clear();
+    }
+}
+//# sourceMappingURL=agentSync.js.map

package/dist/cli.js

@@ -25,7 +25,7 @@ const program = new Command();
 program
     .name('nstantpage')
     .description('Local development agent for nstantpage.com — run projects on your machine, preview in the cloud')
-    .version('0.5.21');
+    .version('0.5.22');
 program
     .command('login')
     .description('Authenticate with nstantpage.com')