nstantpage-agent 0.5.23 → 0.5.25

package/dist/agentSync.js

@@ -148,11 +148,11 @@ export class AgentSync {
     }
     // ─── 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) {
+        // 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);
         }
     }

package/dist/commands/start.js

@@ -26,7 +26,7 @@ import { LocalServer } from '../localServer.js';
 import { PackageInstaller } from '../packageInstaller.js';
 import { probeLocalPostgres, ensureLocalProjectDb, closeAdminPool, writeDatabaseUrlToEnv } from '../projectDb.js';
 import { StatusServer } from '../statusServer.js';
-const VERSION = '0.5.22';
+const VERSION = '0.5.24';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
@@ -82,7 +82,7 @@ async function fetchProjectFiles(backendUrl, projectId, projectDir, token) {
         : null;
     if (existingVersion === String(data.versionId)) {
         console.log(chalk.gray(`  Files up-to-date (version ${data.version})`));
-        return { fileCount: data.files.length, isNew: false };
+        return { fileCount: data.files.length, isNew: false, versionId: String(data.versionId) };
     }
     // Write all files to disk in parallel (batch I/O for speed)
     // First, collect unique directories to create
@@ -111,7 +111,7 @@ async function fetchProjectFiles(backendUrl, projectId, projectDir, token) {
     // Write version marker
     fs.writeFileSync(versionFile, String(data.versionId), 'utf-8');
     console.log(chalk.green(`  ✓ ${written} files downloaded (version ${data.version})`));
-    return { fileCount: written, isNew: true };
+    return { fileCount: written, isNew: true, versionId: String(data.versionId) };
 }
 /**
  * Kill any process listening on the given port.
@@ -242,8 +242,10 @@ export async function startCommand(directory, options) {
     console.log(chalk.gray(`  Backend:      ${backendUrl}\n`));
     // 1. Fetch project files from the backend
     const installer = new PackageInstaller({ projectDir });
+    let fetchedVersionId;
     try {
-        const { fileCount, isNew } = await fetchProjectFiles(backendUrl, projectId, projectDir, token);
+        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'))) {
@@ -424,6 +426,10 @@ export async function startCommand(directory, options) {
         console.log(chalk.gray('  Starting local API server...'));
         await localServer.start();
         console.log(chalk.green(`  ✓ API server on port ${apiPort}`));
+        // Set sync baseline so file watcher knows what "clean" looks like
+        if (fetchedVersionId) {
+            localServer.markSynced(fetchedVersionId);
+        }
         // Start dev server unless --no-dev flag
         if (!options.noDev) {
             if (installer.areDependenciesInstalled()) {

package/dist/localServer.d.ts

@@ -81,6 +81,11 @@ export declare class LocalServer {
      */
     private ensureDatabase;
     getDevServer(): DevServer;
+    /**
+     * Set initial sync baseline after fetching project files.
+     * This tells agentSync what "clean" looks like so it can detect local edits.
+     */
+    markSynced(versionId: string): void;
     getApiPort(): number;
     getDevPort(): number;
     start(): Promise<void>;

package/dist/localServer.js

@@ -162,6 +162,16 @@ export class LocalServer {
     getDevServer() {
         return this.devServer;
     }
+    /**
+     * Set initial sync baseline after fetching project files.
+     * This tells agentSync what "clean" looks like so it can detect local edits.
+     */
+    markSynced(versionId) {
+        if (this.agentSync) {
+            this.agentSync.markSynced(versionId);
+            console.log(`  [LocalServer] Sync baseline set (version ${versionId})`);
+        }
+    }
     getApiPort() {
         return this.options.apiPort;
     }

package/dist/tunnel.d.ts

@@ -42,7 +42,7 @@ export declare class TunnelClient {
     private requestsForwarded;
     private connectedAt;
     private lastPongReceived;
-    /** Active WebSocket channels (terminal WS relay through tunnel) */
+    /** Active WebSocket channels (terminal WS + HMR WS relay through tunnel) */
     private wsChannels;
     /** Listeners for status changes (used by tray app) */
     private statusListeners;
@@ -87,14 +87,20 @@ export declare class TunnelClient {
      */
     private handleWsOpen;
     /**
-     * Handle ws-data: frontend sent a message through the terminal WebSocket.
-     * Parse it and route to the terminal session.
+     * Handle ws-data: frontend sent a message through a WebSocket channel.
+     * Routes to either terminal session or dev-server WebSocket.
      */
     private handleWsData;
     /**
-     * Handle ws-close: frontend disconnected the terminal WebSocket.
+     * Handle ws-close: frontend disconnected the terminal WebSocket or HMR WebSocket.
      */
     private handleWsClose;
+    /**
+     * Handle ws-open for dev-server target: open a WebSocket to the local
+     * Vite dev server and relay data bidirectionally through the tunnel.
+     * This enables Vite HMR to work through the cloud preview URL.
+     */
+    private handleWsOpenDevServer;
     /**
      * Handle start-project: gateway wants this agent to start serving a new project.
      * Called when user clicks "Connect" in the web editor's Cloud panel.

package/dist/tunnel.js

@@ -32,7 +32,7 @@ export class TunnelClient {
     requestsForwarded = 0;
     connectedAt = 0;
     lastPongReceived = 0;
-    /** Active WebSocket channels (terminal WS relay through tunnel) */
+    /** Active WebSocket channels (terminal WS + HMR WS relay through tunnel) */
     wsChannels = new Map();
     /** Listeners for status changes (used by tray app) */
     statusListeners = new Set();
@@ -267,13 +267,31 @@ export class TunnelClient {
         });
     }
     /**
-     * Handle ws-data: frontend sent a message through the terminal WebSocket.
-     * Parse it and route to the terminal session.
+     * Handle ws-data: frontend sent a message through a WebSocket channel.
+     * Routes to either terminal session or dev-server WebSocket.
      */
-    handleWsData(wsId, data) {
+    handleWsData(wsId, data, binary) {
         const channel = this.wsChannels.get(wsId);
         if (!channel)
             return;
+        // If this channel has a dev-server WebSocket, forward data directly
+        if (channel.devServerWs) {
+            try {
+                if (channel.devServerWs.readyState === WebSocket.OPEN) {
+                    if (binary) {
+                        channel.devServerWs.send(Buffer.from(data, 'base64'));
+                    }
+                    else {
+                        channel.devServerWs.send(data);
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`  [Tunnel] Failed to forward HMR data to dev server:`, err.message);
+            }
+            return;
+        }
+        // Terminal session handling
         try {
             const msg = JSON.parse(data);
             const session = getTerminalSession(channel.sessionId);
@@ -298,16 +316,79 @@ export class TunnelClient {
         }
     }
     /**
-     * Handle ws-close: frontend disconnected the terminal WebSocket.
+     * Handle ws-close: frontend disconnected the terminal WebSocket or HMR WebSocket.
      */
     handleWsClose(wsId) {
         const channel = this.wsChannels.get(wsId);
         if (channel) {
             if (channel.cleanup)
                 channel.cleanup();
+            // Close dev-server WebSocket if this was an HMR relay
+            if (channel.devServerWs) {
+                try {
+                    channel.devServerWs.close();
+                }
+                catch { }
+            }
             this.wsChannels.delete(wsId);
         }
     }
+    // ─── Dev Server WebSocket Relay (Vite HMR through tunnel) ──
+    /**
+     * Handle ws-open for dev-server target: open a WebSocket to the local
+     * Vite dev server and relay data bidirectionally through the tunnel.
+     * This enables Vite HMR to work through the cloud preview URL.
+     */
+    handleWsOpenDevServer(wsId, url, protocol) {
+        const devPort = this.options.devPort;
+        const wsUrl = `ws://127.0.0.1:${devPort}${url}`;
+        console.log(`  [Tunnel] Opening HMR WS relay: ${wsId} → ${wsUrl}`);
+        const wsOptions = {};
+        const protocols = protocol ? protocol.split(',').map(p => p.trim()) : undefined;
+        const devWs = new WebSocket(wsUrl, protocols, wsOptions);
+        devWs.on('open', () => {
+            console.log(`  [Tunnel] HMR WS connected: ${wsId} → ${wsUrl}`);
+        });
+        devWs.on('message', (data, isBinary) => {
+            // Relay dev server messages back to browser through tunnel
+            if (isBinary) {
+                const buf = data instanceof Buffer ? data : Buffer.from(data);
+                this.send({
+                    type: 'ws-data',
+                    wsId,
+                    data: buf.toString('base64'),
+                    binary: true,
+                });
+            }
+            else {
+                this.send({
+                    type: 'ws-data',
+                    wsId,
+                    data: data.toString(),
+                });
+            }
+        });
+        devWs.on('close', () => {
+            console.log(`  [Tunnel] HMR WS closed: ${wsId}`);
+            this.send({ type: 'ws-close', wsId });
+            this.wsChannels.delete(wsId);
+        });
+        devWs.on('error', (err) => {
+            console.warn(`  [Tunnel] HMR WS error: ${wsId}:`, err.message);
+            this.send({ type: 'ws-close', wsId });
+            this.wsChannels.delete(wsId);
+        });
+        this.wsChannels.set(wsId, {
+            sessionId: `hmr-${wsId}`,
+            cleanup: () => {
+                try {
+                    devWs.close();
+                }
+                catch { }
+            },
+            devServerWs: devWs,
+        });
+    }
     /**
      * Handle start-project: gateway wants this agent to start serving a new project.
      * Called when user clicks "Connect" in the web editor's Cloud panel.
@@ -369,10 +450,15 @@ export class TunnelClient {
                 this.handleHttpRequest(msg);
                 break;
             case 'ws-open':
-                this.handleWsOpen(msg.wsId, msg.sessionId, msg.projectId);
+                if (msg.target === 'dev-server') {
+                    this.handleWsOpenDevServer(msg.wsId, msg.url || '/', msg.protocol);
+                }
+                else {
+                    this.handleWsOpen(msg.wsId, msg.sessionId, msg.projectId);
+                }
                 break;
             case 'ws-data':
-                this.handleWsData(msg.wsId, msg.data);
+                this.handleWsData(msg.wsId, msg.data, msg.binary);
                 break;
             case 'ws-close':
                 this.handleWsClose(msg.wsId);

package/package.json

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