nstantpage-agent 0.5.11 → 0.5.13

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.10');
+    .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.10';
+import { probeLocalPostgres, ensureLocalProjectDb, closeAdminPool, writeDatabaseUrlToEnv } from '../projectDb.js';
+const VERSION = '0.5.13';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
@@ -274,12 +275,33 @@ 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}`));
+                writeDatabaseUrlToEnv(projectDir, databaseUrl);
+            }
+        }
+    }
+    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 +395,7 @@ export async function startCommand(directory, options) {
         tunnel.disconnect();
         await localServer.stop();
         await disconnectDevice();
+        await closeAdminPool();
         clearProjectConfig(projectId);
         process.exit(0);
     };
@@ -540,6 +563,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 +608,26 @@ 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}`));
+                    writeDatabaseUrlToEnv(projectDir, databaseUrl);
+                }
+            }
+        }
+        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, writeDatabaseUrlToEnv } from './projectDb.js';
 // ─── Try to load node-pty for real PTY support ─────────────────
 let ptyModule = null;
 try {
@@ -112,6 +113,40 @@ 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;
+                    // Write to .env so manual `npm run dev` also works
+                    writeDatabaseUrlToEnv(this.options.projectDir, 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 +384,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 +432,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) };
@@ -505,9 +577,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,
@@ -573,7 +655,7 @@ export class LocalServer {
             connected: true,
             projectId: this.options.projectId,
             agent: {
-                version: '0.5.10',
+                version: '0.5.11',
                 hostname: os.hostname(),
                 platform: `${os.platform()} ${os.arch()}`,
             },
@@ -595,9 +677,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, {
@@ -605,10 +688,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,
@@ -640,6 +723,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
@@ -675,6 +760,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,38 @@
+/**
+ * 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>;
+/**
+ * Write DATABASE_URL to the project's .env file so manual `npm run dev` works.
+ * - Creates .env if it doesn't exist
+ * - Updates DATABASE_URL if already present but different
+ * - Appends DATABASE_URL if not present
+ * Idempotent — safe to call multiple times.
+ */
+export declare function writeDatabaseUrlToEnv(projectDir: string, databaseUrl: string): void;
+/**
+ * Close the admin pool (for graceful shutdown).
+ */
+export declare function closeAdminPool(): Promise<void>;

package/dist/projectDb.js

@@ -0,0 +1,172 @@
+/**
+ * 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';
+import fs from 'fs';
+import path from 'path';
+// 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;
+    }
+}
+/**
+ * Write DATABASE_URL to the project's .env file so manual `npm run dev` works.
+ * - Creates .env if it doesn't exist
+ * - Updates DATABASE_URL if already present but different
+ * - Appends DATABASE_URL if not present
+ * Idempotent — safe to call multiple times.
+ */
+export function writeDatabaseUrlToEnv(projectDir, databaseUrl) {
+    const envPath = path.join(projectDir, '.env');
+    try {
+        let content = '';
+        if (fs.existsSync(envPath)) {
+            content = fs.readFileSync(envPath, 'utf-8');
+        }
+        const lines = content.split('\n');
+        const dbLineIdx = lines.findIndex(l => l.startsWith('DATABASE_URL='));
+        if (dbLineIdx >= 0) {
+            // Already has DATABASE_URL — update if different
+            const existing = lines[dbLineIdx].split('=').slice(1).join('=');
+            if (existing === databaseUrl)
+                return; // already correct
+            lines[dbLineIdx] = `DATABASE_URL=${databaseUrl}`;
+        }
+        else {
+            // Append DATABASE_URL
+            // Ensure there's a newline before appending if file doesn't end with one
+            if (content.length > 0 && !content.endsWith('\n')) {
+                lines.push('');
+            }
+            lines.push(`DATABASE_URL=${databaseUrl}`);
+        }
+        fs.writeFileSync(envPath, lines.join('\n'), 'utf-8');
+        console.log(`  [ProjectDb] Wrote DATABASE_URL to ${envPath}`);
+    }
+    catch (err) {
+        console.warn(`  [ProjectDb] Failed to write .env: ${err.message}`);
+    }
+}
+/**
+ * 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.10',
+                    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.11",
+  "version": "0.5.13",
   "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,12 +49,14 @@
     "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"