nstantpage-agent 0.5.19 → 0.5.21

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

package/dist/commands/start.js

@@ -25,7 +25,7 @@ import { TunnelClient } from '../tunnel.js';
 import { LocalServer } from '../localServer.js';
 import { PackageInstaller } from '../packageInstaller.js';
 import { probeLocalPostgres, ensureLocalProjectDb, closeAdminPool, writeDatabaseUrlToEnv } from '../projectDb.js';
-const VERSION = '0.5.19';
+const VERSION = '0.5.21';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it

package/dist/localServer.d.ts

@@ -113,7 +113,19 @@ export declare class LocalServer {
     private handleGracePeriod;
     private handleStats;
     private handleUsage;
+    private handleBuild;
     private handleHealth;
+    /**
+     * Get a pg Pool connected to this project's local database.
+     * Lazily created and cached.
+     */
+    private _dbPool;
+    private getDbPool;
+    private handleDbTables;
+    private handleDbColumns;
+    private handleDbRows;
+    private handleDbQuery;
+    private handleDbCreate;
     private json;
     private collectBody;
 }

package/dist/localServer.js

@@ -14,6 +14,7 @@
  */
 import http from 'http';
 import fs from 'fs';
+import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
@@ -22,7 +23,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';
+import { probeLocalPostgres, ensureLocalProjectDb, isLocalPgAvailable, writeDatabaseUrlToEnv } from './projectDb.js';
 // ─── Try to load node-pty for real PTY support ─────────────────
 let ptyModule = null;
 try {
@@ -243,6 +244,12 @@ export class LocalServer {
             '/live/grace-period': this.handleGracePeriod,
             '/live/stats': this.handleStats,
             '/live/usage': this.handleUsage,
+            '/live/db/tables': this.handleDbTables,
+            '/live/db/columns': this.handleDbColumns,
+            '/live/db/rows': this.handleDbRows,
+            '/live/db/query': this.handleDbQuery,
+            '/live/db/create': this.handleDbCreate,
+            '/live/build': this.handleBuild,
             '/health': this.handleHealth,
         };
         if (handlers[path])
@@ -932,6 +939,80 @@ export class LocalServer {
             },
         });
     }
+    // ─── /live/build — run production build and return artifacts ──
+    async handleBuild(_req, res) {
+        const projectDir = this.options.projectDir;
+        console.log(`  [LocalServer] Running production build for project ${this.options.projectId}...`);
+        try {
+            // Determine build command
+            const hasBuildScript = fs.existsSync(path.join(projectDir, 'script', 'build.ts'));
+            const buildCmd = hasBuildScript
+                ? 'npx tsx script/build.ts'
+                : 'npx vite build';
+            // Run build
+            const buildResult = await new Promise((resolve) => {
+                const proc = spawn('sh', ['-c', buildCmd], {
+                    cwd: projectDir,
+                    env: { ...process.env, ...this.options.env, NODE_OPTIONS: '--max-old-space-size=512' },
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stdout = '', stderr = '';
+                proc.stdout.on('data', (d) => { stdout += d.toString(); });
+                proc.stderr.on('data', (d) => { stderr += d.toString(); });
+                proc.on('close', (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+                proc.on('error', (err) => resolve({ exitCode: 1, stdout: '', stderr: err.message }));
+            });
+            if (buildResult.exitCode !== 0) {
+                console.error(`  [LocalServer] Build failed: ${buildResult.stderr}`);
+                this.json(res, { success: false, error: buildResult.stderr || 'Build failed' });
+                return;
+            }
+            // Collect dist/ files
+            const distDir = path.join(projectDir, 'dist');
+            if (!fs.existsSync(distDir)) {
+                this.json(res, { success: false, error: 'dist/ not found after build' });
+                return;
+            }
+            const files = {};
+            const collectFiles = (dir, prefix) => {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        collectFiles(fullPath, relPath);
+                    }
+                    else {
+                        // Base64-encode binary files, utf-8 for text
+                        const ext = path.extname(entry.name).toLowerCase();
+                        const isBinary = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.woff', '.woff2', '.ttf', '.eot', '.mp3', '.mp4', '.ogg', '.wav'].includes(ext);
+                        if (isBinary) {
+                            files[relPath] = 'base64:' + fs.readFileSync(fullPath).toString('base64');
+                        }
+                        else {
+                            files[relPath] = fs.readFileSync(fullPath, 'utf-8');
+                        }
+                    }
+                }
+            };
+            collectFiles(distDir, '');
+            // Check for backend
+            const hasBackend = fs.existsSync(path.join(projectDir, 'server', 'index.ts')) ||
+                fs.existsSync(path.join(projectDir, 'server', 'index.js'));
+            console.log(`  [LocalServer] Build completed: ${Object.keys(files).length} files (backend=${hasBackend})`);
+            this.json(res, {
+                success: true,
+                files,
+                fileCount: Object.keys(files).length,
+                hasBackend,
+            });
+        }
+        catch (err) {
+            console.error(`  [LocalServer] Build error: ${err.message}`);
+            res.statusCode = 500;
+            this.json(res, { success: false, error: err.message });
+        }
+    }
     // ─── /health ─────────────────────────────────────────────────
     async handleHealth(_req, res) {
         this.json(res, {
@@ -942,6 +1023,179 @@ export class LocalServer {
             uptime: this.devServer.uptime,
         });
     }
+    // ─── /live/db/* — Data Studio endpoints (local PostgreSQL) ──
+    /**
+     * Get a pg Pool connected to this project's local database.
+     * Lazily created and cached.
+     */
+    _dbPool = null;
+    async getDbPool() {
+        if (this._dbPool)
+            return this._dbPool;
+        const pg = await import('pg');
+        const dbUrl = this.options.env?.['DATABASE_URL'];
+        if (dbUrl) {
+            this._dbPool = new pg.default.Pool({ connectionString: dbUrl, max: 3, idleTimeoutMillis: 30000 });
+        }
+        else {
+            // Fallback: construct from defaults
+            const dbName = `project_${this.options.projectId.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+            this._dbPool = new pg.default.Pool({
+                host: '127.0.0.1', port: 5432,
+                user: os.userInfo().username, password: '',
+                database: dbName, max: 3, idleTimeoutMillis: 30000,
+            });
+        }
+        return this._dbPool;
+    }
+    // GET /live/db/tables
+    async handleDbTables(_req, res) {
+        try {
+            const pool = await this.getDbPool();
+            const { rows: tableRows } = await pool.query(`
+        SELECT c.relname AS table_name
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = 'public' AND c.relkind = 'r'
+        ORDER BY c.relname
+      `);
+            const tables = [];
+            for (const t of tableRows) {
+                try {
+                    const { rows } = await pool.query(`SELECT COUNT(*)::text AS cnt FROM "${t.table_name}"`);
+                    tables.push({ table_name: t.table_name, row_count: rows[0].cnt });
+                }
+                catch {
+                    tables.push({ table_name: t.table_name, row_count: '?' });
+                }
+            }
+            this.json(res, { tables, dbExists: true });
+        }
+        catch (err) {
+            if (err.message?.includes('does not exist')) {
+                this.json(res, { tables: [], dbExists: false, pgAvailable: isLocalPgAvailable() });
+            }
+            else {
+                res.statusCode = 500;
+                this.json(res, { error: err.message });
+            }
+        }
+    }
+    // GET /live/db/columns?table=xxx
+    async handleDbColumns(_req, res, _body, url) {
+        const table = url.searchParams.get('table');
+        if (!table) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing table' });
+            return;
+        }
+        try {
+            const pool = await this.getDbPool();
+            const { rows } = await pool.query(`
+        SELECT column_name, data_type, is_nullable, column_default
+        FROM information_schema.columns
+        WHERE table_schema = 'public' AND table_name = $1
+        ORDER BY ordinal_position
+      `, [table]);
+            this.json(res, { columns: rows });
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { error: err.message });
+        }
+    }
+    // GET /live/db/rows?table=xxx&limit=100&offset=0
+    async handleDbRows(_req, res, _body, url) {
+        const table = url.searchParams.get('table');
+        if (!table) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing table' });
+            return;
+        }
+        const limit = Math.min(parseInt(url.searchParams.get('limit') || '100', 10), 500);
+        const offset = parseInt(url.searchParams.get('offset') || '0', 10);
+        const safe = table.replace(/[^a-zA-Z0-9_]/g, '');
+        try {
+            const pool = await this.getDbPool();
+            const countResult = await pool.query(`SELECT COUNT(*)::int AS total FROM "${safe}"`);
+            const total = countResult.rows[0]?.total || 0;
+            const { rows } = await pool.query(`SELECT * FROM "${safe}" ORDER BY 1 LIMIT $1 OFFSET $2`, [limit, offset]);
+            this.json(res, { rows, total });
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { error: err.message });
+        }
+    }
+    // POST /live/db/query — body: { sql, readOnly? }
+    async handleDbQuery(_req, res, body) {
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            res.statusCode = 400;
+            this.json(res, { error: 'Invalid JSON' });
+            return;
+        }
+        if (!parsed.sql || typeof parsed.sql !== 'string') {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing sql' });
+            return;
+        }
+        const readOnly = parsed.readOnly !== false;
+        try {
+            const pool = await this.getDbPool();
+            const client = await pool.connect();
+            try {
+                await client.query(readOnly ? 'BEGIN READ ONLY' : 'BEGIN');
+                const result = await client.query(parsed.sql);
+                await client.query('COMMIT');
+                this.json(res, {
+                    rows: result.rows,
+                    fields: result.fields?.map((f) => ({ name: f.name, dataTypeID: f.dataTypeID })) || [],
+                    rowCount: result.rowCount || 0,
+                });
+            }
+            catch (err) {
+                await client.query('ROLLBACK').catch(() => { });
+                throw err;
+            }
+            finally {
+                client.release();
+            }
+        }
+        catch (err) {
+            res.statusCode = 400;
+            this.json(res, { error: err.message });
+        }
+    }
+    // POST /live/db/create — create/ensure project database
+    async handleDbCreate(_req, res) {
+        try {
+            const dbUrl = await ensureLocalProjectDb(this.options.projectId);
+            if (dbUrl) {
+                if (!this.options.env)
+                    this.options.env = {};
+                this.options.env['DATABASE_URL'] = dbUrl;
+                writeDatabaseUrlToEnv(this.options.projectDir, dbUrl);
+                // Recreate pool with fresh URL
+                if (this._dbPool) {
+                    await this._dbPool.end().catch(() => { });
+                    this._dbPool = null;
+                }
+                this.json(res, { success: true, database: `project_${this.options.projectId}` });
+            }
+            else {
+                res.statusCode = 503;
+                this.json(res, { error: 'PostgreSQL is not available on this machine' });
+            }
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { error: err.message });
+        }
+    }
     // ─── Helpers ─────────────────────────────────────────────────
     json(res, data) {
         res.setHeader('Content-Type', 'application/json');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {