nstantpage-agent 0.5.19 → 0.5.20

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.20');
 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.20';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it

package/dist/localServer.d.ts

@@ -114,6 +114,17 @@ export declare class LocalServer {
     private handleStats;
     private handleUsage;
     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

@@ -22,7 +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';
+import { probeLocalPostgres, ensureLocalProjectDb, isLocalPgAvailable, writeDatabaseUrlToEnv } from './projectDb.js';
 // ─── Try to load node-pty for real PTY support ─────────────────
 let ptyModule = null;
 try {
@@ -243,6 +243,11 @@ 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,
             '/health': this.handleHealth,
         };
         if (handlers[path])
@@ -942,6 +947,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.20",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {