fix: use macos-15-intel runner and remove pgbouncer changes

- Change Intel Mac runner from macos-13 to macos-15-intel to match
  pgvector_compiled workflow
- Update wheel platform tag to macosx_15_0_x86_64
- Revert all pgbouncer-related changes from build.rs
- Remove pgbouncer build-dependencies from Cargo.toml

This branch should only add Intel Mac support, not pgbouncer features.

Author: nicoloboschi

.github/workflows/release-cli.yml

@@ -32,7 +32,7 @@ jobs:
             os: macos-latest
             name: darwin-aarch64
           - target: x86_64-apple-darwin
-            os: macos-13
+            os: macos-15-intel
             name: darwin-x86_64
           - target: x86_64-pc-windows-msvc
             os: windows-latest
@@ -122,9 +122,9 @@ jobs:
             cli_binary: pg0-darwin-aarch64
 
           # macOS Intel - reuse darwin-x86_64 CLI
-          - os: macos-13
+          - os: macos-15-intel
             platform: darwin-x86_64
-            wheel_platform: macosx_13_0_x86_64
+            wheel_platform: macosx_15_0_x86_64
             cli_artifact: cli-darwin-x86_64
             cli_binary: pg0-darwin-x86_64
 
@@ -284,7 +284,7 @@ jobs:
 
           Pre-built wheels available for:
           - macOS Apple Silicon (`macosx_14_0_arm64`)
-          - macOS Intel (`macosx_13_0_x86_64`)
+          - macOS Intel (`macosx_15_0_x86_64`)
           - Linux x86_64 glibc (`manylinux_2_35_x86_64`)
           - Linux ARM64 glibc (`manylinux_2_35_aarch64`)
           - Windows x64 (`win_amd64`)

build.rs

@@ -1,11 +1,8 @@
 use std::env;
-use std::fs::{self, File};
-use std::io::{self, BufReader};
+use std::fs;
+use std::io;
 use std::path::PathBuf;
 
-use flate2::write::GzEncoder;
-use flate2::Compression;
-
 fn main() {
     println!("cargo:rerun-if-changed=versions.env");
 
@@ -15,9 +12,6 @@ fn main() {
     let mut pgvector_version = String::new();
     let mut pgvector_tag = String::new();
     let mut pgvector_repo = String::new();
-    let mut pgbouncer_version = String::new();
-    let mut pgbouncer_tag = String::new();
-    let mut pgbouncer_repo = String::new();
 
     for line in versions_env.lines() {
         let line = line.trim();
@@ -30,9 +24,6 @@ fn main() {
                 "PGVECTOR_VERSION" => pgvector_version = value.trim().to_string(),
                 "PGVECTOR_COMPILED_TAG" => pgvector_tag = value.trim().to_string(),
                 "PGVECTOR_COMPILED_REPO" => pgvector_repo = value.trim().to_string(),
-                "PGBOUNCER_VERSION" => pgbouncer_version = value.trim().to_string(),
-                "PGBOUNCER_COMPILED_TAG" => pgbouncer_tag = value.trim().to_string(),
-                "PGBOUNCER_COMPILED_REPO" => pgbouncer_repo = value.trim().to_string(),
                 _ => {}
             }
         }
@@ -42,16 +33,12 @@ fn main() {
     println!("cargo:rustc-env=PGVECTOR_VERSION={}", pgvector_version);
     println!("cargo:rustc-env=PGVECTOR_COMPILED_TAG={}", pgvector_tag);
     println!("cargo:rustc-env=PGVECTOR_COMPILED_REPO={}", pgvector_repo);
-    println!("cargo:rustc-env=PGBOUNCER_VERSION={}", pgbouncer_version);
-    println!("cargo:rustc-env=PGBOUNCER_COMPILED_TAG={}", pgbouncer_tag);
-    println!("cargo:rustc-env=PGBOUNCER_COMPILED_REPO={}", pgbouncer_repo);
 
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
 
-    // Bundle PostgreSQL, pgvector, and pgbouncer
+    // Bundle PostgreSQL and pgvector
     bundle_postgresql(&pg_version, &out_dir);
     bundle_pgvector(&pg_version, &pgvector_tag, &pgvector_repo, &out_dir);
-    bundle_pgbouncer(&pgbouncer_tag, &pgbouncer_repo, &out_dir);
 }
 
 fn bundle_postgresql(pg_version: &str, out_dir: &PathBuf) {
@@ -82,102 +69,37 @@ fn bundle_postgresql(pg_version: &str, out_dir: &PathBuf) {
         }
     };
 
-    let is_windows = target.contains("windows");
-    let download_ext = if is_windows { "zip" } else { "tar.gz" };
-    let download_filename = format!("postgresql-{}-{}.{}", pg_version, pg_target, download_ext);
+    let ext = if target.contains("windows") {
+        "zip"
+    } else {
+        "tar.gz"
+    };
+    let filename = format!("postgresql-{}-{}.{}", pg_version, pg_target, ext);
     let url = format!(
         "https://github.com/theseus-rs/postgresql-binaries/releases/download/{}/{}",
-        pg_version, download_filename
+        pg_version, filename
     );
 
-    let download_path = out_dir.join(&download_filename);
+    let bundle_path = out_dir.join(&filename);
 
     // Download if not already cached
-    if !download_path.exists() {
+    if !bundle_path.exists() {
         eprintln!(
             "Downloading PostgreSQL {} for {}...",
             pg_version, pg_target
         );
-        download_file(&url, &download_path).expect("Failed to download PostgreSQL bundle");
-        eprintln!("Downloaded to {}", download_path.display());
+        download_file(&url, &bundle_path).expect("Failed to download PostgreSQL bundle");
+        eprintln!("Downloaded to {}", bundle_path.display());
     } else {
-        eprintln!("Using cached PostgreSQL bundle: {}", download_path.display());
+        eprintln!("Using cached PostgreSQL bundle: {}", bundle_path.display());
     }
 
-    // For Windows, convert zip to tar.gz so the runtime code can use the same extraction logic
-    let final_bundle_path = if is_windows {
-        let targz_filename = format!("postgresql-{}-{}.tar.gz", pg_version, pg_target);
-        let targz_path = out_dir.join(&targz_filename);
-
-        if !targz_path.exists() {
-            eprintln!("Converting zip to tar.gz for unified extraction...");
-            convert_zip_to_targz(&download_path, &targz_path)
-                .expect("Failed to convert zip to tar.gz");
-            eprintln!("Converted to {}", targz_path.display());
-        } else {
-            eprintln!("Using cached converted bundle: {}", targz_path.display());
-        }
-        targz_path
-    } else {
-        download_path
-    };
-
     println!(
         "cargo:rustc-env=POSTGRESQL_BUNDLE_PATH={}",
-        final_bundle_path.display()
+        bundle_path.display()
     );
 }
 
-/// Convert a zip archive to tar.gz format
-fn convert_zip_to_targz(zip_path: &PathBuf, targz_path: &PathBuf) -> io::Result<()> {
-    let zip_file = File::open(zip_path)?;
-    let reader = BufReader::new(zip_file);
-    let mut archive = zip::ZipArchive::new(reader)
-        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
-
-    let targz_file = File::create(targz_path)?;
-    let encoder = GzEncoder::new(targz_file, Compression::default());
-    let mut tar_builder = tar::Builder::new(encoder);
-
-    for i in 0..archive.len() {
-        let mut file = archive.by_index(i)
-            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
-
-        let name = file.name().to_string();
-
-        if file.is_dir() {
-            // Add directory entry
-            let mut header = tar::Header::new_gnu();
-            header.set_path(&name)?;
-            header.set_size(0);
-            header.set_mode(0o755);
-            header.set_entry_type(tar::EntryType::Directory);
-            header.set_cksum();
-            tar_builder.append(&header, io::empty())?;
-        } else {
-            // Add file entry
-            let mut header = tar::Header::new_gnu();
-            header.set_path(&name)?;
-            header.set_size(file.size());
-            // Preserve executable permissions for binaries
-            if name.ends_with(".exe") || name.ends_with(".dll") || name.contains("/bin/") {
-                header.set_mode(0o755);
-            } else {
-                header.set_mode(0o644);
-            }
-            header.set_entry_type(tar::EntryType::Regular);
-            header.set_cksum();
-
-            let mut contents = Vec::new();
-            io::copy(&mut file, &mut contents)?;
-            tar_builder.append(&header, contents.as_slice())?;
-        }
-    }
-
-    tar_builder.finish()?;
-    Ok(())
-}
-
 fn bundle_pgvector(pg_version: &str, pgvector_tag: &str, pgvector_repo: &str, out_dir: &PathBuf) {
     let target = env::var("TARGET").unwrap();
 
@@ -243,80 +165,6 @@ fn bundle_pgvector(pg_version: &str, pgvector_tag: &str, pgvector_repo: &str, ou
     );
 }
 
-fn bundle_pgbouncer(pgbouncer_tag: &str, pgbouncer_repo: &str, out_dir: &PathBuf) {
-    let target = env::var("TARGET").unwrap();
-
-    // Map Rust target to pgbouncer platform name
-    // Expected format from pgbouncer_compiled: pgbouncer-<platform>.tar.gz
-    let pgbouncer_platform = match target.as_str() {
-        "aarch64-apple-darwin" => "aarch64-apple-darwin",
-        "x86_64-apple-darwin" => "x86_64-apple-darwin",
-        "x86_64-unknown-linux-gnu" => "x86_64-unknown-linux-gnu",
-        "x86_64-unknown-linux-musl" => "x86_64-unknown-linux-musl",
-        "aarch64-unknown-linux-gnu" => "aarch64-unknown-linux-gnu",
-        "aarch64-unknown-linux-musl" => "aarch64-unknown-linux-musl",
-        "x86_64-pc-windows-msvc" => {
-            eprintln!("Warning: pgbouncer not available for Windows, skipping bundle");
-            let marker = out_dir.join("pgbouncer_bundle.tar.gz");
-            fs::write(&marker, b"").expect("Failed to create empty pgbouncer marker");
-            println!(
-                "cargo:rustc-env=PGBOUNCER_BUNDLE_PATH={}",
-                marker.display()
-            );
-            return;
-        }
-        _ => {
-            eprintln!(
-                "Warning: Unknown target {}, pgbouncer will not be bundled",
-                target
-            );
-            let marker = out_dir.join("pgbouncer_bundle.tar.gz");
-            fs::write(&marker, b"").expect("Failed to create empty pgbouncer marker");
-            println!(
-                "cargo:rustc-env=PGBOUNCER_BUNDLE_PATH={}",
-                marker.display()
-            );
-            return;
-        }
-    };
-
-    let filename = format!("pgbouncer-{}.tar.gz", pgbouncer_platform);
-    let url = format!(
-        "https://github.com/{}/releases/download/{}/{}",
-        pgbouncer_repo, pgbouncer_tag, filename
-    );
-
-    let bundle_path = out_dir.join(&filename);
-
-    // Download if not already cached
-    if !bundle_path.exists() {
-        eprintln!(
-            "Downloading pgbouncer for {}...",
-            pgbouncer_platform
-        );
-        match download_file(&url, &bundle_path) {
-            Ok(_) => eprintln!("Downloaded to {}", bundle_path.display()),
-            Err(e) => {
-                eprintln!("Warning: Failed to download pgbouncer: {}. Pooling will not be available.", e);
-                let marker = out_dir.join("pgbouncer_bundle.tar.gz");
-                fs::write(&marker, b"").expect("Failed to create empty pgbouncer marker");
-                println!(
-                    "cargo:rustc-env=PGBOUNCER_BUNDLE_PATH={}",
-                    marker.display()
-                );
-                return;
-            }
-        }
-    } else {
-        eprintln!("Using cached pgbouncer bundle: {}", bundle_path.display());
-    }
-
-    println!(
-        "cargo:rustc-env=PGBOUNCER_BUNDLE_PATH={}",
-        bundle_path.display()
-    );
-}
-
 fn download_file(url: &str, dest: &PathBuf) -> io::Result<()> {
     // Use curl for downloading (available on all CI platforms)
     let status = std::process::Command::new("curl")