nstantpage-agent 0.5.4 → 0.5.6

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.4';
+const VERSION = '0.5.6';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
@@ -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);
+                },
             });
         },
     });
@@ -466,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);
@@ -550,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);
@@ -559,47 +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 (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...`));
+            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}`));
+        progress('starting-server', `API server on port ${allocated.apiPort}`);
         // Start dev server (only if dependencies are installed)
         if (!opts.noDev) {
             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}`);
                 }
             }
             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,
@@ -610,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 {
@@ -629,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

@@ -407,15 +407,22 @@ export class LocalServer {
         let ptyProcess = null;
         // Prefer node-pty for real PTY (interactive shell, echo, prompt, resize)
         if (ptyModule) {
-            ptyProcess = ptyModule.spawn(shellCmd, [], {
-                name: 'xterm-256color',
-                cols,
-                rows,
-                cwd: this.options.projectDir,
-                env: shellEnv,
-            });
+            try {
+                ptyProcess = ptyModule.spawn(shellCmd, [], {
+                    name: 'xterm-256color',
+                    cols,
+                    rows,
+                    cwd: this.options.projectDir,
+                    env: shellEnv,
+                });
+            }
+            catch (ptyErr) {
+                console.warn(`  [Terminal] node-pty spawn failed: ${ptyErr.message} — falling back to script`);
+                ptyProcess = null;
+                // Fall through to script/spawn fallbacks below
+            }
         }
-        else if (process.platform === 'darwin') {
+        if (!ptyProcess && !shell && process.platform === 'darwin') {
             // macOS fallback: use 'script' to allocate a PTY
             shell = spawn('script', ['-q', '/dev/null', shellCmd], {
                 cwd: this.options.projectDir,
@@ -423,7 +430,7 @@ export class LocalServer {
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
         }
-        else if (process.platform === 'linux') {
+        else if (!ptyProcess && !shell && process.platform === 'linux') {
             // Linux fallback: 'script' with -c flag
             shell = spawn('script', ['-qc', shellCmd, '/dev/null'], {
                 cwd: this.options.projectDir,
@@ -431,7 +438,7 @@ export class LocalServer {
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
         }
-        else {
+        else if (!ptyProcess && !shell) {
             // Windows / other: raw spawn (limited interactivity)
             shell = spawn(shellCmd, [], {
                 cwd: this.options.projectDir,

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

@@ -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.4",
+  "version": "0.5.6",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {