pgserve 1.1.3-rc.6 → 1.1.3-rc.7

package/.github/workflows/build-all-platforms.yml

@@ -45,17 +45,14 @@ jobs:
         include:
           # Linux x64
           - platform: linux-x64
-            pg_pkg: linux-x64
             output: pgserve-linux-x64
             os: ubuntu-latest
-          # macOS ARM64 (Apple Silicon) - must build on macOS for native binaries
+          # macOS ARM64 (Apple Silicon)
           - platform: darwin-arm64
-            pg_pkg: darwin-arm64
             output: pgserve-darwin-arm64
             os: macos-latest
           # Windows x64 - must build on Windows for --windows-icon
           - platform: windows-x64
-            pg_pkg: windows-x64
             output: pgserve-windows-x64.exe
             os: windows-latest
 
@@ -73,18 +70,6 @@ jobs:
       - name: Install dependencies
         run: bun install
 
-      # Bundle PostgreSQL binaries for standalone exe
-      - name: Bundle PostgreSQL binaries
-        run: |
-          echo "Installing @embedded-postgres/${{ matrix.pg_pkg }}..."
-          npm install @embedded-postgres/${{ matrix.pg_pkg }}
-          mkdir -p embedded-postgres
-          cp -r node_modules/@embedded-postgres/${{ matrix.pg_pkg }}/native/* embedded-postgres/
-          echo "Bundled PostgreSQL binaries:"
-          ls -la embedded-postgres/
-          ls -la embedded-postgres/bin/ || true
-        shell: bash
-
       # Windows: native build with custom icon
       - name: Build for Windows (with icon)
         if: matrix.platform == 'windows-x64'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgserve",
-  "version": "1.1.3-rc.6",
+  "version": "1.1.3-rc.7",
   "description": "Embedded PostgreSQL server with true concurrent connections - zero config, auto-provision databases",
   "main": "src/index.js",
   "type": "module",

package/src/postgres.js

@@ -13,6 +13,7 @@
  * - No locale dependency (works on any system)
  */
 
+/* global fetch, Bun */
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
@@ -45,71 +46,105 @@ function getBinaryCacheDir() {
 }
 
 /**
- * Check if bundled PostgreSQL binaries exist (standalone exe mode)
- * When compiled with `bun build --compile`, the embedded-postgres folder
- * should be bundled alongside the executable.
- * @returns {string|null} Path to bundled binaries or null if not found
- */
-function getBundledBinaryDir() {
-  // Check for embedded-postgres folder relative to the module
-  // This works when binaries are bundled during build
-  const bundledDir = path.join(import.meta.dirname, '..', 'embedded-postgres');
-  if (fs.existsSync(path.join(bundledDir, 'bin'))) {
-    return bundledDir;
-  }
-  return null;
-}
-
-/**
- * Extract bundled PostgreSQL binaries to cache directory.
- * Bun-compiled binaries can read embedded files but cannot execute them directly.
- * We extract to ~/.pgserve/bin/{platform}/ for execution.
+ * Download and extract PostgreSQL binaries on first run.
+ * Downloads from npm registry (@embedded-postgres packages).
  *
- * @returns {Promise<string>} Path to extracted bin directory
+ * @returns {Promise<string>} Path to extracted directory
  */
-async function extractBundledBinaries() {
+async function downloadPostgresBinaries() {
   const platform = os.platform();
   const cacheDir = getBinaryCacheDir();
   const cacheBinDir = path.join(cacheDir, 'bin');
   const initdbName = platform === 'win32' ? 'initdb.exe' : 'initdb';
   const postgresName = platform === 'win32' ? 'postgres.exe' : 'postgres';
 
-  // Check if already extracted
+  // Check if already downloaded
   if (fs.existsSync(path.join(cacheBinDir, initdbName)) &&
       fs.existsSync(path.join(cacheBinDir, postgresName))) {
     return cacheDir;
   }
 
-  // Get bundled directory
-  const bundledDir = getBundledBinaryDir();
-  if (!bundledDir) {
-    return null;
+  const platformKey = getPlatformKey();
+  const pkgName = `@embedded-postgres/${platformKey}`;
+  const pkgVersion = '17.7.0-beta.15';
+
+  console.log(`[pgserve] PostgreSQL binaries not found.`);
+  console.log(`[pgserve] Downloading ${pkgName}@${pkgVersion}...`);
+
+  // Get tarball URL from npm registry
+  const registryUrl = `https://registry.npmjs.org/${pkgName}`;
+  const registryRes = await fetch(registryUrl);
+  if (!registryRes.ok) {
+    throw new Error(`Failed to fetch package info: ${registryRes.status}`);
   }
+  const pkgInfo = await registryRes.json();
+  const tarballUrl = pkgInfo.versions[pkgVersion]?.dist?.tarball;
 
-  console.log('[pgserve] Extracting PostgreSQL binaries...');
+  if (!tarballUrl) {
+    throw new Error(`Version ${pkgVersion} not found for ${pkgName}`);
+  }
+
+  // Download tarball
+  console.log(`[pgserve] Downloading from npm registry...`);
+  const tarballRes = await fetch(tarballUrl);
+  if (!tarballRes.ok) {
+    throw new Error(`Failed to download tarball: ${tarballRes.status}`);
+  }
+
+  const tarballBuffer = await tarballRes.arrayBuffer();
+  const tarballSize = (tarballBuffer.byteLength / 1024 / 1024).toFixed(1);
+  console.log(`[pgserve] Downloaded ${tarballSize} MB`);
 
-  // Create cache directory
+  // Create temp file for tarball
+  const tempDir = path.join(os.tmpdir(), `pgserve-download-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const tarballPath = path.join(tempDir, 'package.tgz');
+  fs.writeFileSync(tarballPath, Buffer.from(tarballBuffer));
+
+  // Extract tarball using tar (available on all platforms via bun/node)
+  console.log(`[pgserve] Extracting binaries...`);
   fs.mkdirSync(cacheDir, { recursive: true });
 
-  // Copy bundled binaries to cache
-  // Use recursive copy to get bin/, lib/, share/ directories
-  await copyRecursive(bundledDir, cacheDir);
+  // Use Bun.spawn for extraction
+  const extractProc = Bun.spawn(['tar', '-xzf', tarballPath, '-C', tempDir], {
+    stdout: 'pipe',
+    stderr: 'pipe'
+  });
+  await extractProc.exited;
+
+  // Copy native/* to cache dir
+  const nativeDir = path.join(tempDir, 'package', 'native');
+  if (!fs.existsSync(nativeDir)) {
+    throw new Error('Extracted package does not contain native/ directory');
+  }
+
+  // Copy files recursively
+  await copyDirRecursive(nativeDir, cacheDir);
 
   // Make executables executable (Unix only)
   if (platform !== 'win32') {
     const binDir = path.join(cacheDir, 'bin');
-    const files = fs.readdirSync(binDir);
-    for (const file of files) {
-      const filePath = path.join(binDir, file);
-      try {
-        fs.chmodSync(filePath, 0o755);
-      } catch {
-        // Ignore permission errors for non-executables
+    if (fs.existsSync(binDir)) {
+      const files = fs.readdirSync(binDir);
+      for (const file of files) {
+        const filePath = path.join(binDir, file);
+        try {
+          fs.chmodSync(filePath, 0o755);
+        } catch {
+          // Ignore
+        }
       }
     }
   }
 
-  console.log(`[pgserve] Binaries extracted to ${cacheDir}`);
+  // Cleanup temp
+  try {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+
+  console.log(`[pgserve] PostgreSQL binaries installed to ${cacheDir}`);
   return cacheDir;
 }
 
@@ -118,7 +153,7 @@ async function extractBundledBinaries() {
  * @param {string} src - Source directory
  * @param {string} dest - Destination directory
  */
-async function copyRecursive(src, dest) {
+async function copyDirRecursive(src, dest) {
   const entries = fs.readdirSync(src, { withFileTypes: true });
 
   for (const entry of entries) {
@@ -127,11 +162,9 @@ async function copyRecursive(src, dest) {
 
     if (entry.isDirectory()) {
       fs.mkdirSync(destPath, { recursive: true });
-      await copyRecursive(srcPath, destPath);
+      await copyDirRecursive(srcPath, destPath);
     } else {
-      // Read and write file (works with Bun's virtual filesystem)
-      const content = fs.readFileSync(srcPath);
-      fs.writeFileSync(destPath, content);
+      fs.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -233,22 +266,20 @@ async function getBinaryPaths() {
     return { initdb: cachedInitdb, postgres: cachedPostgres, binDir: cacheBinDir, libDir };
   }
 
-  // Priority 2: Check for bundled binaries and extract if found (standalone exe mode)
-  const bundledDir = getBundledBinaryDir();
-  if (bundledDir) {
-    const extractedDir = await extractBundledBinaries();
-    if (extractedDir) {
-      const extractedBinDir = path.join(extractedDir, 'bin');
-      const extractedInitdb = path.join(extractedBinDir, 'initdb' + exeSuffix);
-      const extractedPostgres = path.join(extractedBinDir, 'postgres' + exeSuffix);
-
-      if (fs.existsSync(extractedInitdb) && fs.existsSync(extractedPostgres)) {
-        const libDir = path.join(extractedDir, 'lib');
-        if ((platform === 'linux' || platform === 'darwin') && fs.existsSync(libDir)) {
-          ensureLibrarySymlinks(libDir, platform);
-        }
-        return { initdb: extractedInitdb, postgres: extractedPostgres, binDir: extractedBinDir, libDir };
+  // Priority 2: Download binaries if not found (standalone exe mode)
+  // This downloads from npm registry on first run
+  const downloadedDir = await downloadPostgresBinaries();
+  if (downloadedDir) {
+    const downloadedBinDir = path.join(downloadedDir, 'bin');
+    const downloadedInitdb = path.join(downloadedBinDir, 'initdb' + exeSuffix);
+    const downloadedPostgres = path.join(downloadedBinDir, 'postgres' + exeSuffix);
+
+    if (fs.existsSync(downloadedInitdb) && fs.existsSync(downloadedPostgres)) {
+      const libDir = path.join(downloadedDir, 'lib');
+      if ((platform === 'linux' || platform === 'darwin') && fs.existsSync(libDir)) {
+        ensureLibrarySymlinks(libDir, platform);
       }
+      return { initdb: downloadedInitdb, postgres: downloadedPostgres, binDir: downloadedBinDir, libDir };
     }
   }