nstantpage-agent 0.5.2 → 0.5.4

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.2');
+    .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.2';
+const VERSION = '0.5.4';
 /**
  * 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`));
                 }
             }
         }
@@ -376,15 +376,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 {
@@ -557,14 +563,18 @@ async function startAdditionalProject(projectId, opts) {
         catch (err) {
             console.log(chalk.yellow(`  ⚠ Could not fetch files: ${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)
+            try {
+                await installer.ensureDependencies();
                 console.log(chalk.green(`  ✓ 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`));
+            }
         }
         // Start local server
         const localServer = new LocalServer({
@@ -573,14 +583,20 @@ async function startAdditionalProject(projectId, opts) {
         });
         await localServer.start();
         console.log(chalk.green(`  ✓ API server on port ${allocated.apiPort}`));
-        // Start dev server
+        // 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()) {
+                try {
+                    await localServer.getDevServer().start();
+                    console.log(chalk.green(`  ✓ Dev server on port ${allocated.devPort}`));
+                }
+                catch (err) {
+                    console.log(chalk.yellow(`  ⚠ Dev server: ${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`));
             }
         }
         // Connect project tunnel

package/dist/localServer.d.ts

@@ -17,7 +17,8 @@ import { DevServer } from './devServer.js';
 interface TerminalSession {
     id: string;
     projectId: string;
-    shell: ChildProcess;
+    shell: ChildProcess | null;
+    ptyProcess: any | null;
     outputBuffer: string[];
     createdAt: number;
     lastActivity: number;
@@ -35,6 +36,14 @@ interface TerminalSession {
  * Get a terminal session by ID (used by WS relay in tunnel).
  */
 export declare function getTerminalSession(sessionId: string): TerminalSession | undefined;
+/**
+ * Write data to a terminal session (handles both node-pty and child_process).
+ */
+export declare function writeToTerminalSession(session: TerminalSession, data: string): void;
+/**
+ * Resize a terminal session (only works with node-pty).
+ */
+export declare function resizeTerminalSession(session: TerminalSession, cols: number, rows: number): void;
 /**
  * Attach a real-time listener to a terminal session (for WebSocket relay).
  * Returns a cleanup function to detach.

package/dist/localServer.js

@@ -14,12 +14,22 @@
  */
 import http from 'http';
 import os from 'os';
+import { createRequire } from 'module';
 import { spawn } from 'child_process';
 import { DevServer } from './devServer.js';
 import { FileManager } from './fileManager.js';
 import { Checker } from './checker.js';
 import { ErrorStore, structuredErrorToString } from './errorStore.js';
 import { PackageInstaller } from './packageInstaller.js';
+// ─── Try to load node-pty for real PTY support ─────────────────
+let ptyModule = null;
+try {
+    const _require = createRequire(import.meta.url);
+    ptyModule = _require('node-pty');
+}
+catch {
+    // node-pty not available — will fall back to 'script' PTY wrapper
+}
 const terminalSessions = new Map();
 let sessionCounter = 0;
 function generateSessionId() {
@@ -31,6 +41,30 @@ function generateSessionId() {
 export function getTerminalSession(sessionId) {
     return terminalSessions.get(sessionId);
 }
+/**
+ * Write data to a terminal session (handles both node-pty and child_process).
+ */
+export function writeToTerminalSession(session, data) {
+    if (session.ptyProcess) {
+        session.ptyProcess.write(data);
+    }
+    else if (session.shell) {
+        session.shell.stdin?.write(data);
+    }
+}
+/**
+ * Resize a terminal session (only works with node-pty).
+ */
+export function resizeTerminalSession(session, cols, rows) {
+    session.cols = cols;
+    session.rows = rows;
+    if (session.ptyProcess) {
+        try {
+            session.ptyProcess.resize(cols, rows);
+        }
+        catch { }
+    }
+}
 /**
  * Attach a real-time listener to a terminal session (for WebSocket relay).
  * Returns a cleanup function to detach.
@@ -366,17 +400,50 @@ export class LocalServer {
         const isAiSession = parsed.isAiSession || false;
         // Determine shell
         const shellCmd = process.platform === 'win32' ? 'cmd.exe' : (process.env.SHELL || '/bin/bash');
-        const shell = spawn(shellCmd, [], {
-            cwd: this.options.projectDir,
-            env: { ...process.env, TERM: 'xterm-256color', COLUMNS: String(cols), LINES: String(rows) },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        const shellEnv = { ...process.env, TERM: 'xterm-256color', COLUMNS: String(cols), LINES: String(rows) };
         sessionCounter++;
         const label = parsed.label || `Terminal ${sessionCounter}`;
+        let shell = null;
+        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,
+            });
+        }
+        else if (process.platform === 'darwin') {
+            // macOS fallback: use 'script' to allocate a PTY
+            shell = spawn('script', ['-q', '/dev/null', shellCmd], {
+                cwd: this.options.projectDir,
+                env: shellEnv,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        else if (process.platform === 'linux') {
+            // Linux fallback: 'script' with -c flag
+            shell = spawn('script', ['-qc', shellCmd, '/dev/null'], {
+                cwd: this.options.projectDir,
+                env: shellEnv,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        else {
+            // Windows / other: raw spawn (limited interactivity)
+            shell = spawn(shellCmd, [], {
+                cwd: this.options.projectDir,
+                env: shellEnv,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
         const session = {
             id: sessionId,
             projectId: this.options.projectId,
             shell,
+            ptyProcess,
             outputBuffer: [],
             createdAt: Date.now(),
             lastActivity: Date.now(),
@@ -389,39 +456,22 @@ export class LocalServer {
             dataListeners: new Set(),
             exitListeners: new Set(),
         };
-        shell.stdout?.on('data', (data) => {
-            const str = data.toString('utf-8');
+        // Helper to push output to buffer and notify listeners
+        const pushOutput = (str) => {
             session.outputBuffer.push(str);
             session.lastActivity = Date.now();
-            // Keep buffer capped at ~100KB
             while (session.outputBuffer.length > 500)
                 session.outputBuffer.shift();
-            // Notify real-time listeners (WebSocket relay)
             for (const listener of session.dataListeners) {
                 try {
                     listener(str);
                 }
                 catch { }
             }
-        });
-        shell.stderr?.on('data', (data) => {
-            const str = data.toString('utf-8');
-            session.outputBuffer.push(str);
-            session.lastActivity = Date.now();
-            while (session.outputBuffer.length > 500)
-                session.outputBuffer.shift();
-            // Notify real-time listeners
-            for (const listener of session.dataListeners) {
-                try {
-                    listener(str);
-                }
-                catch { }
-            }
-        });
-        shell.on('exit', (code) => {
+        };
+        const handleExit = (code) => {
             session.exited = true;
             session.exitCode = code;
-            // Notify exit listeners
             for (const listener of session.exitListeners) {
                 try {
                     listener(code);
@@ -429,7 +479,17 @@ export class LocalServer {
                 catch { }
             }
             terminalSessions.delete(sessionId);
-        });
+        };
+        if (ptyProcess) {
+            // node-pty: single onData for combined stdout+stderr
+            ptyProcess.onData((data) => pushOutput(data));
+            ptyProcess.onExit(({ exitCode }) => handleExit(exitCode));
+        }
+        else if (shell) {
+            shell.stdout?.on('data', (data) => pushOutput(data.toString('utf-8')));
+            shell.stderr?.on('data', (data) => pushOutput(data.toString('utf-8')));
+            shell.on('exit', (code) => handleExit(code));
+        }
         terminalSessions.set(sessionId, session);
         // Return format matching frontend TerminalSessionInfo
         this.json(res, {
@@ -467,7 +527,7 @@ export class LocalServer {
             this.json(res, { success: false, error: 'Session not found' });
             return;
         }
-        session.shell.stdin?.write(inputData);
+        writeToTerminalSession(session, inputData);
         session.lastActivity = Date.now();
         this.json(res, { success: true });
     }
@@ -490,10 +550,7 @@ export class LocalServer {
             this.json(res, { success: false, error: 'Session not found' });
             return;
         }
-        session.cols = cols || session.cols;
-        session.rows = rows || session.rows;
-        // For real pty we'd call pty.resize(cols, rows), but for child_process
-        // we just update the env (takes effect on next data)
+        resizeTerminalSession(session, cols || session.cols, rows || session.rows);
         this.json(res, { success: true, cols: session.cols, rows: session.rows });
     }
     // ─── /live/agent-status ──────────────────────────────────────
@@ -502,7 +559,7 @@ export class LocalServer {
             connected: true,
             projectId: this.options.projectId,
             agent: {
-                version: '0.5.2',
+                version: '0.5.4',
                 hostname: os.hostname(),
                 platform: `${os.platform()} ${os.arch()}`,
             },
@@ -625,9 +682,18 @@ export class LocalServer {
     }
     // ─── /live/close ─────────────────────────────────────────────
     async handleClose(_req, res) {
-        // Don't stop the dev server on close — user is still working locally.
-        // Just acknowledge.
-        this.json(res, { success: true, message: 'Acknowledged (agent keeps running)' });
+        // Stop the dev server when user explicitly clicks Stop in the UI.
+        // The frontend only calls /live/close from the Stop button, not on navigation.
+        try {
+            if (this.devServer.isRunning) {
+                await this.devServer.stop();
+            }
+            this.json(res, { success: true, message: 'Dev server stopped' });
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { success: false, error: err.message });
+        }
     }
     // ─── /live/heartbeat ────────────────────────────────────────
     async handleHeartbeat(_req, res) {

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.js

@@ -20,7 +20,7 @@ import http from 'http';
 import os from 'os';
 import chalk from 'chalk';
 import { getDeviceId } from './config.js';
-import { getTerminalSession, attachTerminalClient } from './localServer.js';
+import { getTerminalSession, attachTerminalClient, writeToTerminalSession, resizeTerminalSession } from './localServer.js';
 export class TunnelClient {
     ws = null;
     options;
@@ -63,7 +63,7 @@ export class TunnelClient {
                 // Send enhanced agent info with capabilities and deviceId
                 this.send({
                     type: 'agent-info',
-                    version: '0.5.2',
+                    version: '0.5.4',
                     hostname: os.hostname(),
                     platform: `${os.platform()} ${os.arch()}`,
                     deviceId: getDeviceId(),
@@ -215,16 +215,13 @@ export class TunnelClient {
             switch (msg.type) {
                 case 'input':
                     if (typeof msg.data === 'string') {
-                        session.shell.stdin?.write(msg.data);
+                        writeToTerminalSession(session, msg.data);
                         session.lastActivity = Date.now();
                     }
                     break;
                 case 'resize':
                     if (typeof msg.cols === 'number' && typeof msg.rows === 'number') {
-                        session.cols = msg.cols;
-                        session.rows = msg.rows;
-                        // Note: child_process.spawn doesn't support resize natively
-                        // (only node-pty does). We update the stored size for future use.
+                        resizeTerminalSession(session, msg.cols, msg.rows);
                     }
                     break;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {
@@ -58,5 +58,8 @@
     "@types/ws": "^8.5.10",
     "tsx": "^4.19.0",
     "typescript": "^5.5.0"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0"
   }
 }