nstantpage-agent 0.5.3 → 0.5.5

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.3');
+    .version('0.5.4');
 program
     .command('login')
     .description('Authenticate with nstantpage.com')

package/dist/commands/start.js

@@ -24,7 +24,7 @@ import { getConfig, getProjectConfig, setProjectConfig, clearProjectConfig, getD
 import { TunnelClient } from '../tunnel.js';
 import { LocalServer } from '../localServer.js';
 import { PackageInstaller } from '../packageInstaller.js';
-const VERSION = '0.5.3';
+const VERSION = '0.5.5';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
@@ -226,20 +226,20 @@ export async function startCommand(directory, options) {
     console.log(chalk.gray(`  Gateway:      ${options.gateway}`));
     console.log(chalk.gray(`  Backend:      ${backendUrl}\n`));
     // 1. Fetch project files from the backend
+    const installer = new PackageInstaller({ projectDir });
     try {
         const { fileCount, isNew } = await fetchProjectFiles(backendUrl, projectId, projectDir, token);
-        // 2. Install dependencies if this is a new download or node_modules is missing
-        const hasNodeModules = fs.existsSync(path.join(projectDir, 'node_modules'));
-        if (isNew || !hasNodeModules) {
+        // 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...'));
-                const installer = new PackageInstaller({ projectDir });
-                const result = await installer.install([], false);
-                if (result.success) {
+                try {
+                    await installer.ensureDependencies();
                     console.log(chalk.green(`  ✓ Dependencies installed`));
                 }
-                else {
-                    console.log(chalk.yellow(`  ⚠ Dependency installation had issues: ${result.output.slice(0, 200)}`));
+                catch (err) {
+                    console.log(chalk.yellow(`  ⚠ Install failed: ${err.message?.slice(0, 200)}`));
+                    console.log(chalk.gray(`    Will retry when dev server starts`));
                 }
             }
         }
@@ -278,6 +278,10 @@ export async function startCommand(directory, options) {
         onStartProject: async (pid) => {
             await startAdditionalProject(pid, {
                 token, backendUrl, gatewayUrl: options.gateway, deviceId, noDev: options.noDev,
+                onProgress: (phase, message) => {
+                    // Send progress through the primary tunnel for multi-project starts
+                    tunnel.sendSetupProgress(pid, phase, message);
+                },
             });
         },
     });
@@ -376,15 +380,21 @@ export async function startCommand(directory, options) {
         console.log(chalk.green(`  ✓ API server on port ${apiPort}`));
         // Start dev server unless --no-dev flag
         if (!options.noDev) {
-            console.log(chalk.gray('  Starting dev server...'));
-            try {
-                const devServer = localServer.getDevServer();
-                await devServer.start();
-                console.log(chalk.green(`  ✓ Dev server on port ${devPort}`));
+            if (installer.areDependenciesInstalled()) {
+                console.log(chalk.gray('  Starting dev server...'));
+                try {
+                    const devServer = localServer.getDevServer();
+                    await devServer.start();
+                    console.log(chalk.green(`  ✓ Dev server on port ${devPort}`));
+                }
+                catch (err) {
+                    console.log(chalk.yellow(`  ⚠ Dev server failed to start: ${err.message}`));
+                    console.log(chalk.gray('    You can start it later from the editor'));
+                }
             }
-            catch (err) {
-                console.log(chalk.yellow(`  ⚠ Dev server failed to start: ${err.message}`));
-                console.log(chalk.gray('    You can start it later from the editor'));
+            else {
+                console.log(chalk.yellow(`  ⚠ Skipping dev server — dependencies not fully installed`));
+                console.log(chalk.gray('    Dev server will start when browser opens the project'));
             }
         }
         else {
@@ -460,6 +470,9 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
             }
             const result = await startAdditionalProject(pid, {
                 token, backendUrl, gatewayUrl: options.gateway, deviceId, noDev: options.noDev,
+                onProgress: (phase, message) => {
+                    standbyTunnel.sendSetupProgress(pid, phase, message);
+                },
             });
             if (result)
                 activeProjects.set(pid, result);
@@ -544,7 +557,9 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
  * sends a start-project command.
  */
 async function startAdditionalProject(projectId, opts) {
+    const progress = opts.onProgress || (() => { });
     console.log(chalk.blue(`\n  📦 Starting project ${projectId}...`));
+    progress('fetching-files', 'Fetching project files...');
     try {
         const allocated = allocatePortsForProject(projectId);
         const projectDir = resolveProjectDir('.', projectId);
@@ -553,37 +568,62 @@ async function startAdditionalProject(projectId, opts) {
         // Fetch project files
         try {
             await fetchProjectFiles(opts.backendUrl, projectId, projectDir, opts.token);
+            progress('fetching-files', 'Project files downloaded');
         }
         catch (err) {
             console.log(chalk.yellow(`  ⚠ Could not fetch files: ${err.message}`));
+            progress('fetching-files', `Warning: ${err.message}`);
         }
-        // Install dependencies
-        const hasNodeModules = fs.existsSync(path.join(projectDir, 'node_modules'));
-        if (!hasNodeModules && fs.existsSync(path.join(projectDir, 'package.json'))) {
+        // Install dependencies (must complete before dev server can start)
+        const installer = new PackageInstaller({ projectDir });
+        if (!installer.areDependenciesInstalled() && fs.existsSync(path.join(projectDir, 'package.json'))) {
             console.log(chalk.gray(`  Installing dependencies...`));
-            const installer = new PackageInstaller({ projectDir });
-            const result = await installer.install([], false);
-            if (result.success)
+            progress('installing-deps', 'Installing npm dependencies...');
+            try {
+                await installer.ensureDependencies();
                 console.log(chalk.green(`  ✓ Dependencies installed`));
+                progress('installing-deps', 'Dependencies installed');
+            }
+            catch (err) {
+                console.log(chalk.red(`  ✗ Install failed: ${err.message}`));
+                console.log(chalk.yellow(`  ⚠ Dev server may fail — retrying install on first request`));
+                progress('installing-deps', `Install failed: ${err.message}`);
+            }
+        }
+        else {
+            progress('installing-deps', 'Dependencies already installed');
         }
         // Start local server
+        progress('starting-server', 'Starting API server...');
         const localServer = new LocalServer({
             projectDir, projectId,
             apiPort: allocated.apiPort, devPort: allocated.devPort,
         });
         await localServer.start();
         console.log(chalk.green(`  ✓ API server on port ${allocated.apiPort}`));
-        // Start dev server
+        progress('starting-server', `API server on port ${allocated.apiPort}`);
+        // Start dev server (only if dependencies are installed)
         if (!opts.noDev) {
-            try {
-                await localServer.getDevServer().start();
-                console.log(chalk.green(`  ✓ Dev server on port ${allocated.devPort}`));
+            if (installer.areDependenciesInstalled()) {
+                progress('starting-dev', 'Starting dev server...');
+                try {
+                    await localServer.getDevServer().start();
+                    console.log(chalk.green(`  ✓ Dev server on port ${allocated.devPort}`));
+                    progress('starting-dev', `Dev server on port ${allocated.devPort}`);
+                }
+                catch (err) {
+                    console.log(chalk.yellow(`  ⚠ Dev server: ${err.message}`));
+                    progress('starting-dev', `Warning: ${err.message}`);
+                }
             }
-            catch (err) {
-                console.log(chalk.yellow(`  ⚠ Dev server: ${err.message}`));
+            else {
+                console.log(chalk.yellow(`  ⚠ Skipping dev server — dependencies not installed`));
+                console.log(chalk.gray(`    Dev server will start when browser opens the project`));
+                progress('starting-dev', 'Skipped — dependencies not installed');
             }
         }
         // Connect project tunnel
+        progress('connecting', 'Connecting tunnel to gateway...');
         const tunnel = new TunnelClient({
             gatewayUrl: opts.gatewayUrl,
             token: opts.token,
@@ -594,10 +634,12 @@ async function startAdditionalProject(projectId, opts) {
         try {
             await tunnel.connect();
             console.log(chalk.green(`  ✓ Tunnel connected for project ${projectId}`));
+            progress('connecting', 'Tunnel connected');
         }
         catch (err) {
             console.log(chalk.yellow(`  ⚠ Tunnel: ${err.message}`));
             tunnel.startBackgroundReconnect();
+            progress('connecting', `Warning: ${err.message} — reconnecting`);
         }
         // Register project with backend
         try {
@@ -613,10 +655,12 @@ async function startAdditionalProject(projectId, opts) {
         }
         catch { }
         console.log(chalk.green(`  ✓ Project ${projectId} is live!\n`));
+        progress('ready', 'Project is live!');
         return { localServer, tunnel };
     }
     catch (err) {
         console.error(chalk.red(`  ✗ Failed to start project ${projectId}: ${err.message}`));
+        progress('error', err.message);
         return null;
     }
 }

package/dist/localServer.js

@@ -559,7 +559,7 @@ export class LocalServer {
             connected: true,
             projectId: this.options.projectId,
             agent: {
-                version: '0.5.3',
+                version: '0.5.4',
                 hostname: os.hostname(),
                 platform: `${os.platform()} ${os.arch()}`,
             },

package/dist/packageInstaller.d.ts

@@ -7,6 +7,8 @@ export interface PackageInstallerOptions {
 }
 export declare class PackageInstaller {
     private projectDir;
+    /** Serializes concurrent install calls */
+    private installLock;
     constructor(options: PackageInstallerOptions);
     /**
      * Install packages into the project.
@@ -18,8 +20,14 @@ export declare class PackageInstaller {
     }>;
     /**
      * Ensure all project dependencies are installed.
+     * Uses a lock to prevent concurrent installs.
      */
     ensureDependencies(): Promise<void>;
+    /**
+     * Check if dependencies are actually installed (not just that node_modules/ exists).
+     * Verifies that at least one key dependency from package.json is present.
+     */
+    areDependenciesInstalled(): boolean;
     /**
      * Detect which package manager is used (pnpm, yarn, npm).
      */

package/dist/packageInstaller.js

@@ -4,9 +4,11 @@
  */
 import { spawn } from 'child_process';
 import path from 'path';
-import { existsSync } from 'fs';
+import fs, { existsSync } from 'fs';
 export class PackageInstaller {
     projectDir;
+    /** Serializes concurrent install calls */
+    installLock = Promise.resolve();
     constructor(options) {
         this.projectDir = options.projectDir;
     }
@@ -18,7 +20,7 @@ export class PackageInstaller {
         const args = this.buildInstallArgs(pm, packages, dev);
         console.log(`  [Installer] ${pm} ${args.join(' ')}`);
         try {
-            const timeout = packages.length === 0 ? 120_000 : 60_000;
+            const timeout = packages.length === 0 ? 300_000 : 120_000;
             const output = await this.runCommand(pm, args, timeout);
             return {
                 success: true,
@@ -36,16 +38,51 @@ export class PackageInstaller {
     }
     /**
      * Ensure all project dependencies are installed.
+     * Uses a lock to prevent concurrent installs.
      */
     async ensureDependencies() {
-        const nodeModules = path.join(this.projectDir, 'node_modules');
-        if (existsSync(nodeModules))
+        // Serialize with any in-flight install
+        await this.installLock;
+        if (this.areDependenciesInstalled())
             return;
-        console.log(`  [Installer] Installing project dependencies...`);
-        const pm = this.detectPackageManager();
-        const args = pm === 'pnpm' ? ['install'] : ['install'];
-        await this.runCommand(pm, args, 120_000);
-        console.log(`  [Installer] Dependencies installed`);
+        // Acquire lock for this install
+        let releaseLock;
+        this.installLock = new Promise(resolve => { releaseLock = resolve; });
+        try {
+            console.log(`  [Installer] Installing project dependencies...`);
+            const pm = this.detectPackageManager();
+            const args = pm === 'pnpm' ? ['install'] : ['install'];
+            await this.runCommand(pm, args, 300_000);
+            console.log(`  [Installer] Dependencies installed`);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * Check if dependencies are actually installed (not just that node_modules/ exists).
+     * Verifies that at least one key dependency from package.json is present.
+     */
+    areDependenciesInstalled() {
+        const nodeModules = path.join(this.projectDir, 'node_modules');
+        if (!existsSync(nodeModules))
+            return false;
+        // Check that at least one real dependency is installed
+        try {
+            const pkgPath = path.join(this.projectDir, 'package.json');
+            if (!existsSync(pkgPath))
+                return true; // no package.json → nothing to install
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const deps = Object.keys(pkg.dependencies || {});
+            if (deps.length === 0)
+                return true; // no deps → nothing needed
+            // Check if the first listed dependency has its folder in node_modules
+            const firstDep = deps[0];
+            return existsSync(path.join(nodeModules, firstDep));
+        }
+        catch {
+            return existsSync(nodeModules);
+        }
     }
     /**
      * Detect which package manager is used (pnpm, yarn, npm).

package/dist/tunnel.d.ts

@@ -25,6 +25,8 @@ interface TunnelClientOptions {
     devPort: number;
     /** Callback when gateway requests starting a new project on this device */
     onStartProject?: (projectId: string) => Promise<void>;
+    /** Callback for setup progress — lets the standby tunnel relay phases to gateway */
+    onSetupProgress?: (projectId: string, phase: string, message: string) => void;
 }
 export declare class TunnelClient {
     private ws;
@@ -82,6 +84,11 @@ export declare class TunnelClient {
      * Called when user clicks "Connect" in the web editor's Cloud panel.
      */
     private handleStartProject;
+    /**
+     * Send setup progress for a project through this tunnel.
+     * Used by the standby tunnel to relay progress from startAdditionalProject to the gateway.
+     */
+    sendSetupProgress(projectId: string, phase: string, message: string): void;
     private send;
     private handleMessage;
     /**

package/dist/tunnel.js

@@ -63,7 +63,7 @@ export class TunnelClient {
                 // Send enhanced agent info with capabilities and deviceId
                 this.send({
                     type: 'agent-info',
-                    version: '0.5.3',
+                    version: '0.5.4',
                     hostname: os.hostname(),
                     platform: `${os.platform()} ${os.arch()}`,
                     deviceId: getDeviceId(),
@@ -253,11 +253,15 @@ export class TunnelClient {
         }
         if (this.options.onStartProject) {
             try {
+                // Send initial progress
+                this.sendSetupProgress(projectId, 'starting', 'Starting project setup...');
                 await this.options.onStartProject(projectId);
+                this.sendSetupProgress(projectId, 'ready', 'Project is live!');
                 this.send({ type: 'start-project-result', projectId, success: true });
             }
             catch (err) {
                 console.error(`  [Tunnel] Failed to start project ${projectId}:`, err.message);
+                this.sendSetupProgress(projectId, 'error', err.message);
                 this.send({ type: 'start-project-result', projectId, success: false, error: err.message });
             }
         }
@@ -265,6 +269,13 @@ export class TunnelClient {
             this.send({ type: 'start-project-result', success: false, error: 'Agent does not support remote project start' });
         }
     }
+    /**
+     * Send setup progress for a project through this tunnel.
+     * Used by the standby tunnel to relay progress from startAdditionalProject to the gateway.
+     */
+    sendSetupProgress(projectId, phase, message) {
+        this.send({ type: 'setup-progress', projectId, phase, message, timestamp: Date.now() });
+    }
     send(msg) {
         if (this.ws?.readyState === WebSocket.OPEN) {
             this.ws.send(JSON.stringify(msg));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.5.3",
+  "version": "0.5.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": {