nstantpage-agent 0.5.10 → 0.5.12

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

package/dist/commands/start.js

@@ -24,7 +24,8 @@ 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.9';
+import { probeLocalPostgres, ensureLocalProjectDb, closeAdminPool } from '../projectDb.js';
+const VERSION = '0.5.12';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
@@ -274,12 +275,32 @@ export async function startCommand(directory, options) {
     if (!fs.existsSync(localConfigPath)) {
         fs.writeFileSync(localConfigPath, JSON.stringify({ projectId }, null, 2), 'utf-8');
     }
+    // 2.5. Auto-detect local PostgreSQL and provision project database
+    let databaseUrl = null;
+    try {
+        const hasPg = await probeLocalPostgres();
+        if (hasPg) {
+            databaseUrl = await ensureLocalProjectDb(projectId);
+            if (databaseUrl) {
+                console.log(chalk.green(`  ✓ Database ready: project_${projectId}`));
+            }
+        }
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  ⚠ PostgreSQL setup failed: ${err.message} (will use PGlite fallback)`));
+    }
+    // Build env vars to pass to the dev server
+    const serverEnv = {};
+    if (databaseUrl) {
+        serverEnv['DATABASE_URL'] = databaseUrl;
+    }
     // 3. Start local server (API + dev server)
     const localServer = new LocalServer({
         projectDir,
         projectId,
         apiPort,
         devPort,
+        env: serverEnv,
     });
     // 4. Create tunnel client
     const tunnel = new TunnelClient({
@@ -373,6 +394,7 @@ export async function startCommand(directory, options) {
         tunnel.disconnect();
         await localServer.stop();
         await disconnectDevice();
+        await closeAdminPool();
         clearProjectConfig(projectId);
         process.exit(0);
     };
@@ -540,6 +562,7 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
             proj.tunnel.disconnect();
             await proj.localServer.stop();
         }
+        await closeAdminPool();
         try {
             await fetch(`${backendUrl}/api/agent/disconnect`, {
                 method: 'POST',
@@ -584,9 +607,25 @@ async function startAdditionalProject(projectId, opts) {
         await new Promise(r => setTimeout(r, 50));
         // ── Phase 1: API server + file fetch + tunnel connect (all parallel) ──
         progress('fetching-files', 'Fetching project files...');
+        // Provision database if PostgreSQL is available
+        let databaseUrl = null;
+        try {
+            const hasPg = await probeLocalPostgres();
+            if (hasPg) {
+                databaseUrl = await ensureLocalProjectDb(projectId);
+                if (databaseUrl) {
+                    console.log(chalk.green(`  ✓ Database ready: project_${projectId}`));
+                }
+            }
+        }
+        catch { }
+        const serverEnv = {};
+        if (databaseUrl)
+            serverEnv['DATABASE_URL'] = databaseUrl;
         const localServer = new LocalServer({
             projectDir, projectId,
             apiPort: allocated.apiPort, devPort: allocated.devPort,
+            env: serverEnv,
         });
         const tunnel = new TunnelClient({
             gatewayUrl: opts.gatewayUrl,

package/dist/devServer.js

@@ -65,6 +65,7 @@ export class DevServer {
                     ...process.env,
                     ...extraEnv,
                     PORT: String(backendPort),
+                    SERVER_PORT: String(backendPort),
                     NODE_ENV: 'development',
                 },
                 shell: true,
@@ -100,7 +101,10 @@ export class DevServer {
             PORT: String(port),
         };
         if (hasBackend) {
-            frontendEnv['VITE_BACKEND_PORT'] = String(port + 1000);
+            const backendPort = port + 1001;
+            frontendEnv['VITE_BACKEND_PORT'] = String(backendPort);
+            // SERVER_PORT is used by vite.config.ts proxy to route /api requests
+            frontendEnv['SERVER_PORT'] = String(backendPort);
         }
         console.log(`  [DevServer] Starting: ${cmd} ${args.join(' ')} (port ${port})`);
         this.process = spawn(cmd, args, {

package/dist/localServer.d.ts

@@ -69,6 +69,12 @@ export declare class LocalServer {
     private packageInstaller;
     private lastHeartbeat;
     constructor(options: LocalServerOptions);
+    /**
+     * Ensure the project database is provisioned and DATABASE_URL is set in the DevServer env.
+     * Called lazily on /live/open and /live/dev to handle the case where PostgreSQL
+     * wasn't available during agent startup but is now (or was never probed).
+     */
+    private ensureDatabase;
     getDevServer(): DevServer;
     getApiPort(): number;
     getDevPort(): number;

package/dist/localServer.js

@@ -22,6 +22,7 @@ import { FileManager } from './fileManager.js';
 import { Checker } from './checker.js';
 import { ErrorStore, structuredErrorToString } from './errorStore.js';
 import { PackageInstaller } from './packageInstaller.js';
+import { probeLocalPostgres, ensureLocalProjectDb } from './projectDb.js';
 // ─── Try to load node-pty for real PTY support ─────────────────
 let ptyModule = null;
 try {
@@ -112,6 +113,38 @@ export class LocalServer {
         this.errorStore = new ErrorStore();
         this.packageInstaller = new PackageInstaller({ projectDir: options.projectDir });
     }
+    /**
+     * Ensure the project database is provisioned and DATABASE_URL is set in the DevServer env.
+     * Called lazily on /live/open and /live/dev to handle the case where PostgreSQL
+     * wasn't available during agent startup but is now (or was never probed).
+     */
+    async ensureDatabase() {
+        // Skip if DATABASE_URL is already set in the env
+        if (this.options.env?.['DATABASE_URL'])
+            return;
+        try {
+            const hasPg = await probeLocalPostgres();
+            if (hasPg) {
+                const dbUrl = await ensureLocalProjectDb(this.options.projectId);
+                if (dbUrl) {
+                    // Update env for future DevServer starts
+                    if (!this.options.env)
+                        this.options.env = {};
+                    this.options.env['DATABASE_URL'] = dbUrl;
+                    // Also update the DevServer's env
+                    this.devServer = new DevServer({
+                        projectDir: this.options.projectDir,
+                        port: this.options.devPort,
+                        env: this.options.env,
+                    });
+                    console.log(`  [LocalServer] Database provisioned: project_${this.options.projectId}`);
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`  [LocalServer] Database provisioning failed: ${err.message}`);
+        }
+    }
     getDevServer() {
         return this.devServer;
     }
@@ -349,13 +382,14 @@ export class LocalServer {
     // ─── /live/terminal ──────────────────────────────────────────
     async handleTerminal(_req, res, body) {
         const data = JSON.parse(body);
-        const { command, cwd } = data;
+        const { command, cwd, timeoutSeconds } = data;
         if (!command) {
             res.statusCode = 400;
             this.json(res, { error: 'Missing command' });
             return;
         }
-        const result = await this.devServer.exec(command);
+        const timeoutMs = timeoutSeconds ? timeoutSeconds * 1000 : undefined;
+        const result = await this.devServer.exec(command, timeoutMs);
         this.json(res, {
             success: result.exitCode === 0,
             exitCode: result.exitCode,
@@ -396,10 +430,46 @@ export class LocalServer {
             parsed = body ? JSON.parse(body) : {};
         }
         catch { }
+        const isAiSession = parsed.isAiSession || false;
+        // Reuse existing AI session if available (prevents spawning new tab per AI command)
+        if (isAiSession) {
+            const existingAiSession = Array.from(terminalSessions.values())
+                .find(s => s.projectId === this.options.projectId && s.isAiSession && !s.exited);
+            if (existingAiSession) {
+                existingAiSession.lastActivity = Date.now();
+                if (parsed.label)
+                    existingAiSession.label = parsed.label;
+                // Write the new command to the existing session's PTY
+                if (parsed.command) {
+                    if (existingAiSession.ptyProcess) {
+                        existingAiSession.ptyProcess.write(parsed.command + '\n');
+                    }
+                    else if (existingAiSession.shell?.stdin) {
+                        existingAiSession.shell.stdin.write(parsed.command + '\n');
+                    }
+                }
+                this.json(res, {
+                    success: true,
+                    reused: true,
+                    session: {
+                        id: existingAiSession.id,
+                        projectId: existingAiSession.projectId,
+                        isAiSession: existingAiSession.isAiSession,
+                        label: existingAiSession.label,
+                        createdAt: existingAiSession.createdAt,
+                        lastActivity: existingAiSession.lastActivity,
+                        exited: false,
+                        exitCode: null,
+                        cols: existingAiSession.cols,
+                        rows: existingAiSession.rows,
+                    },
+                });
+                return;
+            }
+        }
         const sessionId = generateSessionId();
         const cols = parsed.cols || 120;
         const rows = parsed.rows || 30;
-        const isAiSession = parsed.isAiSession || false;
         // Determine shell
         const shellCmd = process.platform === 'win32' ? 'cmd.exe' : (process.env.SHELL || '/bin/bash');
         const shellEnv = { ...process.env, TERM: 'xterm-256color', COLUMNS: String(cols), LINES: String(rows) };
@@ -426,50 +496,31 @@ export class LocalServer {
             }
         }
         if (!ptyProcess && !shell) {
+            // Fallback: raw spawn (no PTY, limited interactivity but works everywhere)
+            // NOTE: 'script' wrapper doesn't work with piped stdio (tcgetattr fails),
+            // so we skip it and go straight to raw shell spawn.
             try {
-                if (process.platform === 'darwin') {
-                    // macOS fallback: use 'script' to allocate a PTY
-                    shell = spawn('script', ['-q', '/dev/null', shellCmd], {
-                        cwd: spawnCwd,
-                        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: spawnCwd,
-                        env: shellEnv,
-                        stdio: ['pipe', 'pipe', 'pipe'],
-                    });
-                }
-                else {
-                    // Windows / other: raw spawn (limited interactivity)
+                shell = spawn(shellCmd, ['-i'], {
+                    cwd: spawnCwd,
+                    env: shellEnv,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch (spawnErr) {
+                console.warn(`  [Terminal] Interactive shell failed: ${spawnErr.message} — trying non-interactive`);
+                try {
                     shell = spawn(shellCmd, [], {
                         cwd: spawnCwd,
                         env: shellEnv,
                         stdio: ['pipe', 'pipe', 'pipe'],
                     });
                 }
-            }
-            catch (scriptErr) {
-                console.warn(`  [Terminal] script fallback failed: ${scriptErr.message} — trying raw spawn`);
-            }
-        }
-        // Last resort: raw spawn with no PTY
-        if (!ptyProcess && !shell) {
-            try {
-                shell = spawn(shellCmd, [], {
-                    cwd: spawnCwd,
-                    env: shellEnv,
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
-            }
-            catch (rawErr) {
-                console.error(`  [Terminal] All spawn methods failed: ${rawErr.message}`);
-                res.statusCode = 500;
-                this.json(res, { success: false, error: `Failed to spawn terminal: ${rawErr.message}` });
-                return;
+                catch (rawErr) {
+                    console.error(`  [Terminal] All spawn methods failed: ${rawErr.message}`);
+                    res.statusCode = 500;
+                    this.json(res, { success: false, error: `Failed to spawn terminal: ${rawErr.message}` });
+                    return;
+                }
             }
         }
         const session = {
@@ -524,9 +575,19 @@ export class LocalServer {
             shell.on('exit', (code) => handleExit(code));
         }
         terminalSessions.set(sessionId, session);
+        // Write initial command to PTY if provided (AI session)
+        if (parsed.command) {
+            if (ptyProcess) {
+                ptyProcess.write(parsed.command + '\n');
+            }
+            else if (shell?.stdin) {
+                shell.stdin.write(parsed.command + '\n');
+            }
+        }
         // Return format matching frontend TerminalSessionInfo
         this.json(res, {
             success: true,
+            reused: false,
             session: {
                 id: sessionId,
                 projectId: this.options.projectId,
@@ -592,7 +653,7 @@ export class LocalServer {
             connected: true,
             projectId: this.options.projectId,
             agent: {
-                version: '0.5.9',
+                version: '0.5.11',
                 hostname: os.hostname(),
                 platform: `${os.platform()} ${os.arch()}`,
             },
@@ -614,9 +675,10 @@ export class LocalServer {
     async handleContainerStats(_req, res) {
         const devStats = this.devServer.getStats();
         const totalMemMb = Math.round(os.totalmem() / (1024 * 1024));
-        const freeMemMb = Math.round(os.freemem() / (1024 * 1024));
-        const usedMemMb = totalMemMb - freeMemMb;
-        const memPercent = totalMemMb > 0 ? Math.round((usedMemMb / totalMemMb) * 100) : 0;
+        // Use process-specific memory from devStats, not system-wide (os.freemem)
+        // os.freemem() on macOS counts filesystem cache as "used", showing ~100%
+        const processMemMb = Math.round(devStats.memoryMb);
+        const memPercent = totalMemMb > 0 ? Math.round((processMemMb / totalMemMb) * 1000) / 10 : 0;
         // Return in the same format as the container stats (ContainerStatsSnapshot)
         // so the frontend terminal panel can display it unchanged.
         this.json(res, {
@@ -624,10 +686,10 @@ export class LocalServer {
             running: this.devServer.isRunning,
             agentMode: true,
             stats: {
-                cpuPercent: devStats.cpuPercent,
-                memoryUsageBytes: usedMemMb * 1024 * 1024,
+                cpuPercent: Math.round(devStats.cpuPercent * 10) / 10,
+                memoryUsageBytes: processMemMb * 1024 * 1024,
                 memoryLimitBytes: totalMemMb * 1024 * 1024,
-                memoryUsageMb: usedMemMb,
+                memoryUsageMb: processMemMb,
                 memoryLimitMb: totalMemMb,
                 memoryPercent: memPercent,
                 diskUsageMb: null,
@@ -659,6 +721,8 @@ export class LocalServer {
     // ─── /live/dev ───────────────────────────────────────────────
     async handleDev(_req, res, body) {
         try {
+            // Ensure database is provisioned before starting backend
+            await this.ensureDatabase();
             // Ensure dependencies are installed
             await this.packageInstaller.ensureDependencies();
             // Start dev server
@@ -694,6 +758,8 @@ export class LocalServer {
     // ─── /live/open ──────────────────────────────────────────────
     async handleOpen(_req, res) {
         try {
+            // Ensure database is provisioned before starting backend
+            await this.ensureDatabase();
             // Ensure deps are installed
             await this.packageInstaller.ensureDependencies();
             // Start dev server if not running

package/dist/projectDb.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Local PostgreSQL database provisioning for the nstantpage agent.
+ *
+ * Mirrors the PreviewGateway's projectDb.ts but for local (non-Docker) environments.
+ * On macOS, this detects Homebrew PostgreSQL (or any PG on localhost:5432).
+ * Each project gets an isolated database: project_{id}
+ *
+ * Usage:
+ *   const url = await ensureLocalProjectDb('131');
+ *   // → "postgresql://username:@127.0.0.1:5432/project_131"
+ */
+/**
+ * Probe for a local PostgreSQL instance.
+ * Returns true if PG is accessible on localhost.
+ */
+export declare function probeLocalPostgres(): Promise<boolean>;
+/**
+ * Check if local PostgreSQL is available (must call probeLocalPostgres first).
+ */
+export declare function isLocalPgAvailable(): boolean;
+/**
+ * Ensure a project database exists and return its DATABASE_URL.
+ * Idempotent — safe to call multiple times.
+ * Returns null if PostgreSQL is not available.
+ */
+export declare function ensureLocalProjectDb(projectId: string): Promise<string | null>;
+/**
+ * Close the admin pool (for graceful shutdown).
+ */
+export declare function closeAdminPool(): Promise<void>;

package/dist/projectDb.js

@@ -0,0 +1,132 @@
+/**
+ * Local PostgreSQL database provisioning for the nstantpage agent.
+ *
+ * Mirrors the PreviewGateway's projectDb.ts but for local (non-Docker) environments.
+ * On macOS, this detects Homebrew PostgreSQL (or any PG on localhost:5432).
+ * Each project gets an isolated database: project_{id}
+ *
+ * Usage:
+ *   const url = await ensureLocalProjectDb('131');
+ *   // → "postgresql://username:@127.0.0.1:5432/project_131"
+ */
+import os from 'os';
+// Connection config — detect environment
+const PG_HOST = process.env.PG_HOST || '127.0.0.1';
+const PG_PORT = process.env.PG_PORT || '5432';
+// Local macOS (Homebrew PG): current OS username, no password, trust auth
+const PG_USER = process.env.PG_USER || os.userInfo().username;
+const PG_PASS = process.env.PG_PASS || '';
+let pgAvailable = null; // null = not yet probed
+let adminPool = null;
+const verifiedDbs = new Set();
+/**
+ * Get or create the admin connection pool (connects to 'postgres' database).
+ */
+async function getAdminPool() {
+    if (!adminPool) {
+        const pg = await import('pg');
+        adminPool = new pg.default.Pool({
+            host: PG_HOST,
+            port: parseInt(PG_PORT),
+            user: PG_USER,
+            password: PG_PASS,
+            database: 'postgres',
+            max: 2,
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 5000,
+        });
+    }
+    return adminPool;
+}
+/**
+ * Probe for a local PostgreSQL instance.
+ * Returns true if PG is accessible on localhost.
+ */
+export async function probeLocalPostgres() {
+    if (pgAvailable !== null)
+        return pgAvailable;
+    try {
+        const pool = await getAdminPool();
+        const client = await pool.connect();
+        await client.query('SELECT 1');
+        client.release();
+        pgAvailable = true;
+        console.log(`  [ProjectDb] Auto-detected PostgreSQL at ${PG_HOST}:${PG_PORT} (user: ${PG_USER})`);
+        return true;
+    }
+    catch (err) {
+        pgAvailable = false;
+        // Reset admin pool so it doesn't hold broken connections
+        if (adminPool) {
+            adminPool.end().catch(() => { });
+            adminPool = null;
+        }
+        console.log(`  [ProjectDb] No PostgreSQL found at ${PG_HOST}:${PG_PORT} — projects will use PGlite fallback (${err.message})`);
+        return false;
+    }
+}
+/**
+ * Check if local PostgreSQL is available (must call probeLocalPostgres first).
+ */
+export function isLocalPgAvailable() {
+    return pgAvailable === true;
+}
+/**
+ * Sanitize project ID to safe database name.
+ */
+function dbName(projectId) {
+    const sanitized = projectId.replace(/[^a-zA-Z0-9_]/g, '_');
+    return `project_${sanitized}`;
+}
+/**
+ * Build a DATABASE_URL for a project.
+ */
+function buildDatabaseUrl(name) {
+    const passStr = PG_PASS ? `:${PG_PASS}` : '';
+    return `postgresql://${PG_USER}${passStr}@${PG_HOST}:${PG_PORT}/${name}`;
+}
+/**
+ * Ensure a project database exists and return its DATABASE_URL.
+ * Idempotent — safe to call multiple times.
+ * Returns null if PostgreSQL is not available.
+ */
+export async function ensureLocalProjectDb(projectId) {
+    if (!pgAvailable)
+        return null;
+    const name = dbName(projectId);
+    // Fast path: already verified this session
+    if (verifiedDbs.has(name)) {
+        return buildDatabaseUrl(name);
+    }
+    try {
+        const pool = await getAdminPool();
+        // Check if database exists
+        const { rows } = await pool.query('SELECT 1 FROM pg_database WHERE datname = $1', [name]);
+        if (rows.length === 0) {
+            // Create database — CREATE DATABASE can't use parameterized queries
+            await pool.query(`CREATE DATABASE ${name}`);
+            console.log(`  [ProjectDb] Created database '${name}' for project ${projectId}`);
+        }
+        verifiedDbs.add(name);
+        return buildDatabaseUrl(name);
+    }
+    catch (err) {
+        // Handle race condition: duplicate_database
+        if (err.code === '42P04') {
+            verifiedDbs.add(name);
+            return buildDatabaseUrl(name);
+        }
+        console.error(`  [ProjectDb] Failed to ensure database for ${projectId}:`, err.message);
+        return null;
+    }
+}
+/**
+ * Close the admin pool (for graceful shutdown).
+ */
+export async function closeAdminPool() {
+    if (adminPool) {
+        await adminPool.end();
+        adminPool = null;
+    }
+}
+//# sourceMappingURL=projectDb.js.map

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.9',
+                    version: '0.5.11',
                     hostname: os.hostname(),
                     platform: `${os.platform()} ${os.arch()}`,
                     deviceId: getDeviceId(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {
@@ -49,17 +49,19 @@
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
     "open": "^10.1.0",
+    "pg": "^8.13.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
     "@types/http-proxy": "^1.17.14",
     "@types/node": "^20.14.0",
+    "@types/pg": "^8.18.0",
     "@types/ws": "^8.5.10",
     "tsx": "^4.19.0",
     "typescript": "^5.5.0"
   },
   "optionalDependencies": {
-    "node-pty": "^1.1.0"
+    "node-pty": "^1.2.0-beta.11"
   }
 }