pgserve 2.1.2 → 2.2.0

package/tests/benchmarks/vector-generator.js

@@ -1,368 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Vector Embedding Generator for Benchmarks
- *
- * Generates pre-computed random unit vectors for consistent benchmarking.
- * Excludes embedding API latency from database performance measurements.
- *
- * Usage:
- *   bun tests/benchmarks/vector-generator.js [--count=10000] [--dim=1536]
- *   bun tests/benchmarks/vector-generator.js --all  # Generate all standard fixtures
- */
-
-import fs from 'fs';
-import path from 'path';
-
-const FIXTURES_DIR = path.join(import.meta.dirname, 'fixtures');
-
-/**
- * Generate a random unit vector (normalized L2)
- * @param {number} dimension - Vector dimension
- * @returns {number[]} Normalized vector
- */
-function generateUnitVector(dimension) {
-  // Generate random values from normal distribution (Box-Muller transform)
-  const vector = [];
-  for (let i = 0; i < dimension; i++) {
-    // Use uniform random and transform to approximate normal
-    const u1 = Math.random();
-    const u2 = Math.random();
-    const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-    vector.push(z);
-  }
-
-  // Normalize to unit length (L2 norm = 1)
-  const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-  return vector.map(v => v / norm);
-}
-
-/**
- * Generate embeddings with metadata
- * @param {number} count - Number of embeddings
- * @param {number} dimension - Vector dimension
- * @param {number} seed - Random seed for reproducibility (resets Math.random)
- * @returns {{ vectors: number[][], metadata: object[] }}
- */
-function generateEmbeddings(count, dimension, seed = 42) {
-  // Simple seeded random (LCG)
-  let state = seed;
-  const seededRandom = () => {
-    state = (state * 1664525 + 1013904223) % 4294967296;
-    return state / 4294967296;
-  };
-
-  // Override Math.random temporarily
-  const originalRandom = Math.random;
-  Math.random = seededRandom;
-
-  const vectors = [];
-  const metadata = [];
-
-  const categories = ['technology', 'science', 'business', 'health', 'sports', 'entertainment'];
-  const tenants = ['tenant_a', 'tenant_b', 'tenant_c', 'tenant_d', 'tenant_e'];
-
-  console.log(`Generating ${count.toLocaleString()} vectors of dimension ${dimension}...`);
-  const startTime = performance.now();
-
-  for (let i = 0; i < count; i++) {
-    vectors.push(generateUnitVector(dimension));
-    metadata.push({
-      id: i + 1,
-      category: categories[Math.floor(Math.random() * categories.length)],
-      tenant_id: tenants[Math.floor(Math.random() * tenants.length)],
-      timestamp: new Date(Date.now() - Math.floor(Math.random() * 30 * 24 * 60 * 60 * 1000)).toISOString(),
-      score: Math.random()
-    });
-
-    // Progress indicator
-    if ((i + 1) % 1000 === 0) {
-      process.stdout.write(`\r  Generated ${(i + 1).toLocaleString()} / ${count.toLocaleString()} vectors`);
-    }
-  }
-
-  // Restore original Math.random
-  Math.random = originalRandom;
-
-  const elapsed = ((performance.now() - startTime) / 1000).toFixed(2);
-  console.log(`\n  Completed in ${elapsed}s`);
-
-  return { vectors, metadata };
-}
-
-/**
- * Save embeddings to JSON file
- * @param {string} filename - Output filename
- * @param {{ vectors: number[][], metadata: object[] }} data - Embeddings data
- */
-function saveEmbeddings(filename, data) {
-  const filepath = path.join(FIXTURES_DIR, filename);
-
-  // Ensure fixtures directory exists
-  if (!fs.existsSync(FIXTURES_DIR)) {
-    fs.mkdirSync(FIXTURES_DIR, { recursive: true });
-  }
-
-  // Save with minimal formatting for smaller files
-  const json = JSON.stringify(data);
-  fs.writeFileSync(filepath, json);
-
-  const sizeMB = (Buffer.byteLength(json) / 1024 / 1024).toFixed(2);
-  console.log(`  Saved to ${filepath} (${sizeMB} MB)`);
-
-  return filepath;
-}
-
-/**
- * Load embeddings from JSON file
- * @param {string} filename - Input filename
- * @returns {{ vectors: number[][], metadata: object[] }}
- */
-export function loadEmbeddings(filename) {
-  const filepath = path.join(FIXTURES_DIR, filename);
-
-  if (!fs.existsSync(filepath)) {
-    throw new Error(`Embeddings file not found: ${filepath}. Run: bun tests/benchmarks/vector-generator.js --all`);
-  }
-
-  const data = JSON.parse(fs.readFileSync(filepath, 'utf-8'));
-  console.log(`Loaded ${data.vectors.length.toLocaleString()} vectors from ${filename}`);
-  return data;
-}
-
-/**
- * Get embeddings file path (generates if missing)
- * @param {number} count - Number of embeddings
- * @param {number} dimension - Vector dimension
- * @returns {string} Path to embeddings file
- */
-export function getEmbeddingsPath(count, dimension) {
-  const filename = `embeddings-${count}-${dimension}.json`;
-  const filepath = path.join(FIXTURES_DIR, filename);
-
-  if (!fs.existsSync(filepath)) {
-    console.log(`\nGenerating missing embeddings file: ${filename}`);
-    const data = generateEmbeddings(count, dimension);
-    saveEmbeddings(filename, data);
-  }
-
-  return filepath;
-}
-
-/**
- * Generate query vectors (separate from corpus)
- * @param {number} count - Number of query vectors
- * @param {number} dimension - Vector dimension
- * @returns {number[][]} Query vectors
- */
-export function generateQueryVectors(count, dimension, seed = 12345) {
-  const data = generateEmbeddings(count, dimension, seed);
-  return data.vectors;
-}
-
-/**
- * Format vector for PostgreSQL pgvector
- * @param {number[]} vector - Vector array
- * @returns {string} PostgreSQL vector literal
- */
-export function formatPgVector(vector) {
-  return `[${vector.join(',')}]`;
-}
-
-// ============================================================================
-// RECALL MEASUREMENT (Industry-standard methodology)
-// Based on: ANN-Benchmarks, Qdrant, VectorDBBench
-// ============================================================================
-
-/**
- * Compute L2 (Euclidean) distance squared between two vectors
- * We use squared distance for efficiency (avoids sqrt, maintains ordering)
- * @param {number[]} a - First vector
- * @param {number[]} b - Second vector
- * @returns {number} Squared L2 distance
- */
-export function l2DistanceSquared(a, b) {
-  let sum = 0;
-  for (let i = 0; i < a.length; i++) {
-    const diff = a[i] - b[i];
-    sum += diff * diff;
-  }
-  return sum;
-}
-
-/**
- * Compute ground truth (exact k-NN via brute force)
- * This is the gold standard that approximate results are compared against.
- *
- * @param {number[][]} corpus - All vectors in the database
- * @param {number[][]} queries - Query vectors
- * @param {number} k - Number of nearest neighbors
- * @returns {number[][]} Ground truth: array of k neighbor IDs for each query
- */
-export function computeGroundTruth(corpus, queries, k) {
-  console.log(`  Computing ground truth (brute-force k=${k} for ${queries.length} queries)...`);
-  const startTime = performance.now();
-
-  const groundTruth = [];
-
-  for (let q = 0; q < queries.length; q++) {
-    const query = queries[q];
-
-    // Compute distance to all corpus vectors
-    const distances = [];
-    for (let i = 0; i < corpus.length; i++) {
-      distances.push({
-        id: i + 1, // 1-indexed to match database IDs
-        distance: l2DistanceSquared(query, corpus[i])
-      });
-    }
-
-    // Sort by distance and take top-k
-    distances.sort((a, b) => a.distance - b.distance);
-    groundTruth.push(distances.slice(0, k).map(d => d.id));
-
-    // Progress
-    if ((q + 1) % 10 === 0 || q === queries.length - 1) {
-      process.stdout.write(`\r  Ground truth: ${q + 1}/${queries.length} queries`);
-    }
-  }
-
-  const elapsed = ((performance.now() - startTime) / 1000).toFixed(2);
-  console.log(`\n  Ground truth computed in ${elapsed}s`);
-
-  return groundTruth;
-}
-
-/**
- * Calculate Recall@k
- * Recall = (# of ground truth neighbors found) / k
- *
- * @param {number[][]} approximateResults - IDs returned by approximate search
- * @param {number[][]} groundTruth - IDs from exact brute-force search
- * @param {number} k - Number of neighbors (for normalization)
- * @returns {{ recall: number, perQuery: number[] }} Average recall and per-query recalls
- */
-export function calculateRecall(approximateResults, groundTruth, k) {
-  if (approximateResults.length !== groundTruth.length) {
-    throw new Error(`Result count mismatch: ${approximateResults.length} vs ${groundTruth.length}`);
-  }
-
-  const perQuery = [];
-  let totalRecall = 0;
-
-  for (let i = 0; i < approximateResults.length; i++) {
-    const approxSet = new Set(approximateResults[i]);
-    const truthSet = groundTruth[i];
-
-    // Count how many ground truth neighbors were found
-    let found = 0;
-    for (const truthId of truthSet) {
-      if (approxSet.has(truthId)) {
-        found++;
-      }
-    }
-
-    const queryRecall = found / k;
-    perQuery.push(queryRecall);
-    totalRecall += queryRecall;
-  }
-
-  return {
-    recall: totalRecall / approximateResults.length,
-    perQuery
-  };
-}
-
-/**
- * Get or compute ground truth for a dataset
- * Caches the result to avoid recomputation
- *
- * @param {number[][]} corpus - Corpus vectors
- * @param {number[][]} queries - Query vectors
- * @param {number} k - Number of neighbors
- * @param {string} cacheKey - Unique key for caching
- * @returns {number[][]} Ground truth neighbor IDs
- */
-const groundTruthCache = new Map();
-
-export function getGroundTruth(corpus, queries, k, cacheKey) {
-  const fullKey = `${cacheKey}-k${k}`;
-
-  if (groundTruthCache.has(fullKey)) {
-    console.log(`  Using cached ground truth for ${fullKey}`);
-    return groundTruthCache.get(fullKey);
-  }
-
-  const groundTruth = computeGroundTruth(corpus, queries, k);
-  groundTruthCache.set(fullKey, groundTruth);
-  return groundTruth;
-}
-
-// Standard fixture configurations
-const STANDARD_FIXTURES = [
-  { count: 1000, dimension: 384, desc: 'Small corpus, small model (all-MiniLM)' },
-  { count: 1000, dimension: 1536, desc: 'Small corpus, OpenAI embeddings' },
-  { count: 10000, dimension: 384, desc: 'Medium corpus, small model' },
-  { count: 10000, dimension: 1536, desc: 'Medium corpus, OpenAI embeddings' },
-];
-
-// CLI interface
-if (import.meta.main) {
-  const args = process.argv.slice(2);
-
-  if (args.includes('--help') || args.includes('-h')) {
-    console.log(`
-Vector Embedding Generator for Benchmarks
-
-Usage:
-  bun tests/benchmarks/vector-generator.js [options]
-
-Options:
-  --all              Generate all standard fixtures
-  --count=N          Number of embeddings (default: 10000)
-  --dim=N            Vector dimension (default: 1536)
-  --help, -h         Show this help
-
-Standard Fixtures (--all):
-${STANDARD_FIXTURES.map(f => `  - ${f.count} x ${f.dimension}-dim: ${f.desc}`).join('\n')}
-
-Examples:
-  bun tests/benchmarks/vector-generator.js --all
-  bun tests/benchmarks/vector-generator.js --count=5000 --dim=768
-`);
-    process.exit(0);
-  }
-
-  if (args.includes('--all')) {
-    console.log('\n=== Generating All Standard Fixtures ===\n');
-
-    for (const { count, dimension, desc } of STANDARD_FIXTURES) {
-      console.log(`\n[${count} x ${dimension}-dim] ${desc}`);
-      const data = generateEmbeddings(count, dimension);
-      saveEmbeddings(`embeddings-${count}-${dimension}.json`, data);
-    }
-
-    console.log('\n✓ All fixtures generated successfully\n');
-  } else {
-    // Parse individual options
-    let count = 10000;
-    let dimension = 1536;
-
-    for (const arg of args) {
-      if (arg.startsWith('--count=')) {
-        count = parseInt(arg.split('=')[1], 10);
-      } else if (arg.startsWith('--dim=')) {
-        dimension = parseInt(arg.split('=')[1], 10);
-      }
-    }
-
-    console.log(`\n=== Generating Embeddings ===\n`);
-    console.log(`Count: ${count.toLocaleString()}`);
-    console.log(`Dimension: ${dimension}`);
-
-    const data = generateEmbeddings(count, dimension);
-    saveEmbeddings(`embeddings-${count}-${dimension}.json`, data);
-
-    console.log('\n✓ Done\n');
-  }
-}

package/tests/cli-install.test.js

@@ -1,322 +0,0 @@
-/**
- * Tests for src/cli-install.cjs — pgserve install/uninstall/status/url/port.
- *
- * Wave 1 of the canonical-pgserve-pm2-supervision wish (PR #55, issue #56).
- *
- * Strategy: drive the pure paths (config read/write, arg parsing, pm2-args
- * builder) directly. The pm2-spawning paths (install / uninstall) are
- * exercised by spawning the real pgserve binary against a temp HOME so
- * `pm2` is invoked but with no real daemon side-effect when pm2 is
- * either absent OR the test stubs its calls via PATH.
- *
- * No test in this file actually starts pgserve. We only verify the CLI
- * surface — the daemon lifecycle is covered by daemon-control.test.js.
- */
-
-import { test, expect, beforeEach, afterEach, describe } from 'bun:test';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-const REPO_ROOT = path.resolve(__dirname, '..');
-const BIN = path.join(REPO_ROOT, 'bin', 'pgserve-wrapper.cjs');
-
-let tmpHome;
-let stubBin;
-let originalConfigDir;
-let originalPath;
-
-function makeStubPm2(mode = 'success') {
-  // mode: 'success' | 'failure' | 'missing'
-  // Writes a stub `pm2` script into a tempdir we prepend to PATH.
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-stub-pm2-'));
-  if (mode === 'missing') {
-    // Don't create a stub; PATH still has our dir but no pm2 binary.
-    return { dir, calls: [] };
-  }
-  const callLog = path.join(dir, 'calls.log');
-  const exitCode = mode === 'failure' ? 1 : 0;
-  // jlist returns either an empty list (so install proceeds) or a fake
-  // process record (so subsequent install calls hit the idempotent
-  // path). We toggle via a sentinel file the test owns.
-  const script = `#!/usr/bin/env node
-const fs = require('node:fs');
-const args = process.argv.slice(2);
-fs.appendFileSync(${JSON.stringify(callLog)}, JSON.stringify(args) + '\\n');
-if (args[0] === '--version') { process.stdout.write('5.0.0-stub\\n'); process.exit(0); }
-if (args[0] === 'jlist') {
-  const sentinel = ${JSON.stringify(path.join(dir, 'registered'))};
-  if (fs.existsSync(sentinel)) {
-    process.stdout.write(JSON.stringify([{
-      name: 'pgserve',
-      pid: 12345,
-      pm2_env: { status: 'online', pm_uptime: Date.now() - 1000, restart_time: 0 }
-    }]) + '\\n');
-  } else {
-    process.stdout.write('[]\\n');
-  }
-  process.exit(0);
-}
-if (args[0] === 'start') {
-  fs.writeFileSync(${JSON.stringify(path.join(dir, 'registered'))}, '');
-  process.exit(${exitCode});
-}
-if (args[0] === 'delete') {
-  try { fs.unlinkSync(${JSON.stringify(path.join(dir, 'registered'))}); } catch {}
-  process.exit(${exitCode});
-}
-process.exit(0);
-`;
-  const pm2Path = path.join(dir, 'pm2');
-  fs.writeFileSync(pm2Path, script, { mode: 0o755 });
-  return { dir, calls: callLog };
-}
-
-function readCallLog(callsPath) {
-  if (!fs.existsSync(callsPath)) return [];
-  return fs.readFileSync(callsPath, 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
-}
-
-function runCli(args, env = {}) {
-  return spawnSync('node', [BIN, ...args], {
-    encoding: 'utf8',
-    env: {
-      ...process.env,
-      PGSERVE_CONFIG_DIR: tmpHome,
-      PATH: `${stubBin.dir}:${process.env.PATH}`,
-      ...env,
-    },
-  });
-}
-
-beforeEach(() => {
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-cfg-'));
-  stubBin = makeStubPm2('success');
-  originalConfigDir = process.env.PGSERVE_CONFIG_DIR;
-  originalPath = process.env.PATH;
-});
-
-afterEach(() => {
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-  if (stubBin?.dir) fs.rmSync(stubBin.dir, { recursive: true, force: true });
-  if (originalConfigDir === undefined) delete process.env.PGSERVE_CONFIG_DIR;
-  else process.env.PGSERVE_CONFIG_DIR = originalConfigDir;
-  process.env.PATH = originalPath;
-});
-
-describe('pgserve install', () => {
-  test('first install registers under pm2 and writes config', () => {
-    const result = runCli(['install']);
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('installed');
-    expect(result.stdout).toContain('postgres://localhost:8432');
-
-    const config = JSON.parse(fs.readFileSync(path.join(tmpHome, 'config.json'), 'utf8'));
-    expect(config.port).toBe(8432);
-    expect(config.dataDir).toBe(path.join(tmpHome, 'data'));
-    expect(config.registeredAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-
-    const calls = readCallLog(stubBin.calls);
-    const startCall = calls.find((c) => c[0] === 'start');
-    expect(startCall).toBeDefined();
-    expect(startCall).toContain('--name');
-    expect(startCall).toContain('pgserve');
-    expect(startCall).toContain('--max-restarts');
-    expect(startCall).toContain('50');
-    // pm2 ≥ 6.0 dropped `--min-uptime` from the CLI surface — it now lives
-    // only inside ecosystem files. Passing it on the command line aborts
-    // `pm2 start` with `error: unknown option --min-uptime`. Lock that out:
-    // `pgserve install` must NOT pass `--min-uptime` so it stays compatible
-    // across pm2 5.x → 6.x. See cli-install.cjs:HARDENED_DEFAULTS.
-    expect(startCall).not.toContain('--min-uptime');
-    expect(startCall).toContain('--exp-backoff-restart-delay');
-    expect(startCall).toContain('--max-memory-restart');
-    expect(startCall).toContain('4G');
-    expect(startCall).toContain('--kill-timeout');
-    expect(startCall).toContain('60000');
-    expect(startCall).toContain('--interpreter');
-    expect(startCall).toContain('none');
-
-    // pgserve install must launch the foreground multi-tenant server, NOT
-    // the daemon. Daemon mode rejects `--port` (it only accepts --data,
-    // --ram, --log, --no-provision, --listen, --pgvector) and its TCP
-    // listeners require fingerprint+token auth which downstream services
-    // (omni, genie) don't speak. Foreground mode binds plain TCP on
-    // 127.0.0.1:<port> with auto-provisioning. Lock that out:
-    expect(startCall).not.toContain('daemon');
-    // The script-arg handover (after `--`) must include `--port` so the
-    // foreground parser binds the right TCP port.
-    const dashDashIdx = startCall.indexOf('--');
-    const scriptArgs = startCall.slice(dashDashIdx + 1);
-    expect(scriptArgs).toContain('--port');
-    expect(scriptArgs).toContain('--data');
-    expect(scriptArgs).toContain('--log');
-    expect(scriptArgs).not.toContain('daemon');
-  });
-
-  test('second install is idempotent (no second pm2 start)', () => {
-    runCli(['install']);
-    const calls1 = readCallLog(stubBin.calls);
-    const startCount1 = calls1.filter((c) => c[0] === 'start').length;
-    expect(startCount1).toBe(1);
-
-    const result2 = runCli(['install']);
-    expect(result2.status).toBe(0);
-    expect(result2.stdout).toContain('already installed');
-
-    const calls2 = readCallLog(stubBin.calls);
-    const startCount2 = calls2.filter((c) => c[0] === 'start').length;
-    expect(startCount2).toBe(1); // no second start
-  });
-
-  test('--port overrides default', () => {
-    const result = runCli(['install', '--port', '8442']);
-    expect(result.status).toBe(0);
-    const config = JSON.parse(fs.readFileSync(path.join(tmpHome, 'config.json'), 'utf8'));
-    expect(config.port).toBe(8442);
-    expect(result.stdout).toContain('postgres://localhost:8442');
-  });
-
-  test('rejects malformed --port', () => {
-    const result = runCli(['install', '--port', 'not-a-number']);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr).toContain('invalid --port');
-  });
-
-  test('PGSERVE_MAX_MEMORY env overrides the default memory ceiling', () => {
-    const result = runCli(['install'], { PGSERVE_MAX_MEMORY: '8G' });
-    expect(result.status).toBe(0);
-    const calls = readCallLog(stubBin.calls);
-    const startCall = calls.find((c) => c[0] === 'start');
-    // The env value flows through to pm2's --max-memory-restart flag so
-    // operators on big-iron hosts can tune up without a recompile.
-    expect(startCall).toContain('8G');
-    expect(startCall).not.toContain('4G');
-  });
-
-  test('fails clearly when pm2 is missing', () => {
-    // Build a sanitized PATH that has node (so spawnSync can resolve the
-    // interpreter) but explicitly NO directory containing pm2. Skipping
-    // /usr/bin etc. would make the test brittle on different hosts.
-    fs.rmSync(stubBin.dir, { recursive: true, force: true });
-    stubBin = makeStubPm2('missing');
-    const nodeDir = path.dirname(process.execPath);
-    const sanitizedPath = (process.env.PATH || '')
-      .split(':')
-      .filter((p) => {
-        try {
-          return !fs.existsSync(path.join(p, 'pm2'));
-        } catch {
-          return true;
-        }
-      })
-      .concat([nodeDir, stubBin.dir])
-      .join(':');
-    const result = spawnSync('node', [BIN, 'install'], {
-      encoding: 'utf8',
-      env: { ...process.env, PGSERVE_CONFIG_DIR: tmpHome, PATH: sanitizedPath },
-    });
-    expect(result.status).not.toBe(0);
-    expect(result.stderr).toContain('pm2 not found');
-  });
-});
-
-describe('pgserve url / port', () => {
-  test('url after install prints canonical connection string', () => {
-    runCli(['install']);
-    const result = runCli(['url']);
-    expect(result.status).toBe(0);
-    expect(result.stdout.trim()).toBe('postgres://localhost:8432/postgres');
-  });
-
-  test('port after install prints the registered port', () => {
-    runCli(['install', '--port', '8442']);
-    const result = runCli(['port']);
-    expect(result.status).toBe(0);
-    expect(result.stdout.trim()).toBe('8442');
-  });
-
-  test('url before install fails with helpful message', () => {
-    const result = runCli(['url']);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr).toContain('not installed');
-  });
-});
-
-describe('pgserve status', () => {
-  test('status before install reports installed=false (exit 1)', () => {
-    const result = runCli(['status', '--json']);
-    expect(result.status).toBe(1);
-    const out = JSON.parse(result.stdout);
-    expect(out.installed).toBe(false);
-  });
-
-  test('status after install reports running with port from config', () => {
-    runCli(['install', '--port', '8482']);
-    const result = runCli(['status', '--json']);
-    expect(result.status).toBe(0);
-    const out = JSON.parse(result.stdout);
-    expect(out.installed).toBe(true);
-    expect(out.name).toBe('pgserve');
-    expect(out.status).toBe('online');
-    expect(out.port).toBe(8482);
-    expect(out.url).toBe('postgres://localhost:8482/postgres');
-  });
-
-  test('status human-readable output includes port + url', () => {
-    runCli(['install']);
-    const result = runCli(['status']);
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('port');
-    expect(result.stdout).toContain('8432');
-    expect(result.stdout).toContain('postgres://localhost:8432/postgres');
-  });
-});
-
-describe('pgserve uninstall', () => {
-  test('uninstall removes pm2 process but preserves config', () => {
-    runCli(['install']);
-    expect(fs.existsSync(path.join(tmpHome, 'config.json'))).toBe(true);
-
-    const result = runCli(['uninstall']);
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('uninstalled');
-
-    const calls = readCallLog(stubBin.calls);
-    expect(calls.find((c) => c[0] === 'delete' && c[1] === 'pgserve')).toBeDefined();
-
-    // Config preserved so a re-install reuses port/dataDir.
-    expect(fs.existsSync(path.join(tmpHome, 'config.json'))).toBe(true);
-  });
-
-  test('uninstall when not installed is a no-op success', () => {
-    const result = runCli(['uninstall']);
-    expect(result.status).toBe(0);
-    expect(result.stdout).toContain('not registered');
-  });
-});
-
-describe('serve alias', () => {
-  test('pgserve serve --help re-routes to daemon (which postgres-server.js handles)', () => {
-    // We can't fully exercise `serve` without starting a real daemon.
-    // Instead, verify the wrapper's argv-rewrite happens by passing
-    // `serve --bogus-flag` and asserting the wrapper proceeded past the
-    // install short-circuit (i.e. stderr mentions bun, not "pgserve: ...").
-    // Note: bun probe might fail in tests; we don't assert exit code.
-    const result = spawnSync('node', [BIN, 'serve', '--bogus-flag'], {
-      encoding: 'utf8',
-      env: {
-        ...process.env,
-        PGSERVE_CONFIG_DIR: tmpHome,
-        PATH: `${stubBin.dir}:${process.env.PATH}`,
-      },
-    });
-    // Must NOT have hit the install dispatcher (would print
-    // "pgserve: not installed" or similar). Because serve passes through
-    // to the bun + postgres-server.js path, we expect EITHER a bun error
-    // OR a daemon-mode error — never an install-module error.
-    expect(result.stderr).not.toContain('pgserve: not installed');
-    expect(result.stderr).not.toContain('pm2 not found');
-  });
-});