add logs

Author: nicoloboschi

README.md

@@ -1,21 +1,28 @@
 # pg0
 
+[![PyPI version](https://badge.fury.io/py/pg0-embedded.svg)](https://pypi.org/project/pg0-embedded/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/pg0-embedded.svg)](https://pypi.org/project/pg0-embedded/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pg0-embedded.svg)](https://pypi.org/project/pg0-embedded/)
+
 **Zero-dependency embedded PostgreSQL** - Run PostgreSQL locally without installation. A single binary that downloads and manages PostgreSQL for you.
 
 Includes **pgvector** for AI/vector workloads out of the box.
 
 ## Features
 
 - **Zero dependencies** - single binary, no installation required
-- **Embedded PostgreSQL 16** with pgvector pre-installed
+- **Embedded PostgreSQL 18** with pgvector 0.8.1 pre-installed
 - **Multiple instances** - run multiple PostgreSQL servers simultaneously
 - Works on macOS (Apple Silicon), Linux (x86_64 & ARM64), and Windows (x64)
+- **Python & Node.js SDKs** - programmatic API for embedding in your applications
 - Bundled `psql` client - no separate installation needed
 - Data persists between restarts
 - **Smart binary selection** - automatically downloads the right binary for your Linux distribution (Debian/Ubuntu vs Alpine)
 
 ## Installation
 
+### CLI Binary
+
 The install script automatically detects your platform and downloads the correct binary:
 
 ```bash
@@ -28,6 +35,51 @@ Or with a custom install directory:
 INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/vectorize-io/pg0/main/install.sh | bash
 ```
 
+### Python SDK
+
+Install via pip:
+
+```bash
+pip install pg0-embedded
+```
+
+Quick start:
+
+```python
+from pg0 import Pg0
+
+# Start PostgreSQL
+pg = Pg0()
+pg.start()
+print(pg.uri)  # postgresql://postgres:postgres@localhost:5432/postgres
+
+# Or use context manager
+with Pg0() as pg:
+    result = pg.execute("SELECT version();")
+    print(result)
+```
+
+See [PyPI package](https://pypi.org/project/pg0-embedded/) for more details.
+
+### Node.js SDK
+
+Install via npm:
+
+```bash
+npm install @vectorize-io/pg0
+```
+
+Quick start:
+
+```typescript
+import { Pg0 } from '@vectorize-io/pg0';
+
+const pg = new Pg0();
+await pg.start();
+console.log(await pg.getUri());
+await pg.stop();
+```
+
 ### Linux Distributions
 
 pg0 provides separate binaries optimized for different Linux distributions:
@@ -162,6 +214,7 @@ pg0 provides the following commands:
 4. **info** - Display instance information (status, connection URI, etc.)
 5. **list** - List all PostgreSQL instances
 6. **psql** - Open an interactive psql shell connected to an instance
+7. **logs** - View PostgreSQL logs for debugging
 
 ### Start PostgreSQL
 
@@ -229,6 +282,26 @@ pg0 psql -c "SELECT version();"
 pg0 psql -f schema.sql
 ```
 
+### View Logs
+
+View PostgreSQL logs for debugging startup issues or errors:
+
+```bash
+# View all logs
+pg0 logs
+
+# View last 50 lines
+pg0 logs -n 50
+
+# Follow logs in real-time (like tail -f)
+pg0 logs --follow
+
+# Logs for a specific instance
+pg0 logs --name myapp
+```
+
+Logs are stored in `~/.pg0/instances/<name>/data/log/`.
+
 ### Using pgvector
 
 pgvector is pre-installed. Just enable it:

sdk/node/src/index.ts

@@ -517,6 +517,18 @@ export function listInstancesSync(): InstanceInfo[] {
   return JSON.parse(runPg0Sync("list", "-o", "json"));
 }
 
+/** List available PostgreSQL extensions. */
+export async function listExtensions(): Promise<string[]> {
+  const { stdout } = await runPg0("list-extensions");
+  return stdout.trim().split("\n").filter(line => line.trim());
+}
+
+/** List available PostgreSQL extensions (synchronous). */
+export function listExtensionsSync(): string[] {
+  const stdout = runPg0Sync("list-extensions");
+  return stdout.trim().split("\n").filter(line => line.trim());
+}
+
 /** Start a PostgreSQL instance (convenience function). */
 export async function start(options: Pg0Options = {}): Promise<InstanceInfo> {
   return new Pg0(options).start();

sdk/python/pg0/__init__.py

@@ -436,6 +436,22 @@ def list_instances() -> list[InstanceInfo]:
     return [InstanceInfo.from_dict(item) for item in data]
 
 
+def list_extensions() -> list[str]:
+    """
+    List available PostgreSQL extensions.
+
+    Returns:
+        List of available extension names
+
+    Example:
+        extensions = pg0.list_extensions()
+        print(extensions)  # ['vector', 'postgis', ...]
+    """
+    result = _run_pg0("list-extensions", check=False)
+    lines = result.stdout.strip().split("\n")
+    return [line.strip() for line in lines if line.strip()]
+
+
 def start(
     name: str = "default",
     port: int = 5432,
@@ -531,6 +547,7 @@ def info(name: str = "default") -> InstanceInfo:
     "Pg0AlreadyRunningError",
     "install",
     "list_instances",
+    "list_extensions",
     "start",
     "stop",
     "drop",

src/main.rs

@@ -125,6 +125,20 @@ enum Commands {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         args: Vec<String>,
     },
+    /// Show PostgreSQL logs
+    Logs {
+        /// Instance name
+        #[arg(long, default_value = DEFAULT_INSTANCE_NAME)]
+        name: String,
+
+        /// Number of lines to show (default: all)
+        #[arg(short = 'n', long)]
+        lines: Option<usize>,
+
+        /// Follow log output (like tail -f)
+        #[arg(short, long)]
+        follow: bool,
+    },
     /// Install a PostgreSQL extension (e.g., pgvector)
     InstallExtension {
         /// Instance name
@@ -865,6 +879,87 @@ fn psql(name: String, args: Vec<String>) -> Result<(), CliError> {
     Ok(())
 }
 
+fn logs(name: String, lines: Option<usize>, follow: bool) -> Result<(), CliError> {
+    let instance_dir = get_instance_dir(&name)?;
+    let log_dir = instance_dir.join("data").join("log");
+
+    if !log_dir.exists() {
+        return Err(CliError::Other(format!(
+            "Log directory not found for instance '{}'. Has PostgreSQL been started?",
+            name
+        )));
+    }
+
+    // Find the most recent log file
+    let mut log_files: Vec<_> = fs::read_dir(&log_dir)?
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().is_file())
+        .collect();
+
+    if log_files.is_empty() {
+        return Err(CliError::Other(format!(
+            "No log files found for instance '{}'",
+            name
+        )));
+    }
+
+    // Sort by modification time, most recent first
+    log_files.sort_by_key(|e| std::cmp::Reverse(
+        e.metadata().and_then(|m| m.modified()).ok()
+    ));
+
+    let log_file = &log_files[0].path();
+
+    if follow {
+        // Follow mode - use tail -f equivalent
+        println!("Following logs for instance '{}' (Ctrl+C to exit):", name);
+        println!("Log file: {}", log_file.display());
+        println!();
+
+        let mut file = fs::File::open(log_file)?;
+        let mut pos = file.metadata()?.len();
+
+        // Print existing content first
+        use std::io::{BufRead, BufReader, Seek, SeekFrom};
+        file.seek(SeekFrom::Start(0))?;
+        let reader = BufReader::new(&file);
+        for line in reader.lines() {
+            println!("{}", line?);
+        }
+
+        // Now follow new content
+        loop {
+            file.seek(SeekFrom::Start(pos))?;
+            let reader = BufReader::new(&file);
+            for line in reader.lines() {
+                println!("{}", line?);
+            }
+            pos = file.metadata()?.len();
+            std::thread::sleep(std::time::Duration::from_millis(100));
+        }
+    } else {
+        // Show logs (optionally limited to N lines)
+        use std::io::{BufRead, BufReader};
+        let file = fs::File::open(log_file)?;
+        let reader = BufReader::new(file);
+        let all_lines: Vec<_> = reader.lines().collect::<Result<_, _>>()?;
+
+        let lines_to_show = if let Some(n) = lines {
+            &all_lines[all_lines.len().saturating_sub(n)..]
+        } else {
+            &all_lines[..]
+        };
+
+        println!("Logs for instance '{}' ({})", name, log_file.display());
+        println!();
+        for line in lines_to_show {
+            println!("{}", line);
+        }
+    }
+
+    Ok(())
+}
+
 fn find_installed_version(installation_dir: &PathBuf) -> Result<String, CliError> {
     if let Ok(entries) = fs::read_dir(installation_dir) {
         for entry in entries.flatten() {
@@ -1070,6 +1165,7 @@ fn main() {
         Commands::Info { name, output } => info(name, output),
         Commands::List { output } => list(output),
         Commands::Psql { name, args } => psql(name, args),
+        Commands::Logs { name, lines, follow } => logs(name, lines, follow),
         Commands::InstallExtension { name, extension } => install_extension(name, extension),
         Commands::ListExtensions => list_extensions(),
     };