nstantpage-agent 0.5.18 → 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.18');
+    .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.18';
+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/dist/projectDb.js

@@ -109,6 +109,58 @@ export async function ensureLocalProjectDb(projectId) {
             await pool.query(`CREATE DATABASE ${name}`);
             console.log(`  [ProjectDb] Created database '${name}' for project ${projectId}`);
         }
+        // Ensure the OS user has full access to all objects in the project database.
+        // Tables may have been created by 'postgres' (cloud migrations or container)
+        // but the agent connects as the OS user — grant privileges to prevent permission errors.
+        try {
+            const pg = await import('pg');
+            const projectPool = new pg.default.Pool({
+                host: PG_HOST,
+                port: parseInt(PG_PORT),
+                user: PG_USER,
+                password: PG_PASS,
+                database: name,
+                max: 1,
+                connectionTimeoutMillis: 5000,
+            });
+            try {
+                // Check if there are tables owned by someone else
+                const { rows: foreignTables } = await projectPool.query(`SELECT tablename, tableowner FROM pg_tables WHERE schemaname = 'public' AND tableowner != $1`, [PG_USER]);
+                if (foreignTables.length > 0) {
+                    // Need to grant access — use the admin pool which connects to 'postgres' db,
+                    // but we need a connection to the project db as the owner. Try via psql.
+                    const adminProjectPool = new pg.default.Pool({
+                        host: PG_HOST,
+                        port: parseInt(PG_PORT),
+                        user: foreignTables[0].tableowner, // connect as the table owner
+                        password: '',
+                        database: name,
+                        max: 1,
+                        connectionTimeoutMillis: 5000,
+                    });
+                    try {
+                        await adminProjectPool.query(`GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ${PG_USER}`);
+                        await adminProjectPool.query(`GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ${PG_USER}`);
+                        await adminProjectPool.query(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON TABLES TO ${PG_USER}`);
+                        await adminProjectPool.query(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO ${PG_USER}`);
+                        console.log(`  [ProjectDb] Granted ${PG_USER} access to tables in '${name}' (owned by ${foreignTables[0].tableowner})`);
+                    }
+                    catch (grantErr) {
+                        console.warn(`  [ProjectDb] Could not grant table permissions: ${grantErr.message}`);
+                    }
+                    finally {
+                        await adminProjectPool.end();
+                    }
+                }
+            }
+            finally {
+                await projectPool.end();
+            }
+        }
+        catch (permErr) {
+            // Non-fatal — permissions may or may not be an issue
+            console.warn(`  [ProjectDb] Permission check skipped: ${permErr.message}`);
+        }
         verifiedDbs.add(name);
         return buildDatabaseUrl(name);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.5.18",
+  "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": {