feat(cli): add automated pg_upgrade for PostgreSQL major version upgrades

The `postgresai mon update` command now:
- Detects PostgreSQL major version changes (e.g., 15 → 18)
- Automatically runs pg_upgrade using the new postgres image
- Installs old PG binaries in the new container for upgrade
- Uses --link mode for fast, space-efficient upgrades
- Preserves metrics data across major version upgrades

This allows seamless updates when PostgreSQL version changes in
docker-compose.yml without manual intervention or data loss.

Author: claude

cli/bin/postgres-ai.ts

@@ -1069,6 +1069,130 @@ function isDockerRunning(): boolean {
   }
 }
 
+/**
+ * Get PostgreSQL major version from a running container
+ * @returns Major version number (e.g., 15, 17, 18) or null if container not running
+ */
+function getRunningPostgresVersion(containerName: string): number | null {
+  try {
+    const result = spawnSync(
+      "docker",
+      ["exec", containerName, "psql", "-U", "postgres", "-t", "-c", "SHOW server_version_num"],
+      { stdio: "pipe", encoding: "utf8" }
+    );
+    if (result.status === 0 && result.stdout) {
+      const versionNum = parseInt(result.stdout.trim(), 10);
+      if (!isNaN(versionNum)) {
+        return Math.floor(versionNum / 10000); // e.g., 150000 -> 15
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get target PostgreSQL major version from docker-compose.yml
+ * @returns Major version number or null if not found
+ */
+function getTargetPostgresVersion(composeFilePath: string): number | null {
+  try {
+    const content = fs.readFileSync(composeFilePath, "utf8");
+    // Match postgres:XX image tag for sink-postgres service
+    const match = content.match(/sink-postgres:[\s\S]*?image:\s*postgres:(\d+)/);
+    if (match && match[1]) {
+      return parseInt(match[1], 10);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Run pg_upgrade to migrate PostgreSQL data between major versions
+ * Uses the new postgres image with old binaries installed
+ */
+async function runPgUpgrade(
+  oldVersion: number,
+  newVersion: number,
+  projectDir: string
+): Promise<boolean> {
+  console.log(`\nMigrating PostgreSQL data from version ${oldVersion} to ${newVersion}...`);
+
+  const volumeName = "postgres_ai_sink_postgres_data";
+  const containerName = "postgres-ai-pg-upgrade";
+
+  // Build the upgrade script that runs inside the container
+  const upgradeScript = `
+set -e
+
+echo "Installing PostgreSQL ${oldVersion} binaries..."
+apt-get update -qq
+apt-get install -y -qq postgresql-${oldVersion} >/dev/null 2>&1
+
+echo "Preparing data directories..."
+mkdir -p /var/lib/postgresql/${newVersion}/data
+chown postgres:postgres /var/lib/postgresql/${newVersion}/data
+chmod 700 /var/lib/postgresql/${newVersion}/data
+
+# Initialize new data directory
+echo "Initializing new PostgreSQL ${newVersion} cluster..."
+su postgres -c "/usr/lib/postgresql/${newVersion}/bin/initdb -D /var/lib/postgresql/${newVersion}/data"
+
+# Run pg_upgrade
+echo "Running pg_upgrade..."
+cd /var/lib/postgresql
+su postgres -c "/usr/lib/postgresql/${newVersion}/bin/pg_upgrade \\
+  --old-datadir=/var/lib/postgresql/data \\
+  --new-datadir=/var/lib/postgresql/${newVersion}/data \\
+  --old-bindir=/usr/lib/postgresql/${oldVersion}/bin \\
+  --new-bindir=/usr/lib/postgresql/${newVersion}/bin \\
+  --link"
+
+# Replace old data with upgraded data
+echo "Finalizing upgrade..."
+rm -rf /var/lib/postgresql/data.old 2>/dev/null || true
+mv /var/lib/postgresql/data /var/lib/postgresql/data.old
+mv /var/lib/postgresql/${newVersion}/data /var/lib/postgresql/data
+
+echo "PostgreSQL upgrade completed successfully!"
+`;
+
+  try {
+    // Remove any existing upgrade container
+    spawnSync("docker", ["rm", "-f", containerName], { stdio: "ignore" });
+
+    // Run upgrade in a temporary container
+    console.log("Starting upgrade container...");
+    const result = spawnSync(
+      "docker",
+      [
+        "run",
+        "--rm",
+        "--name", containerName,
+        "-v", `${volumeName}:/var/lib/postgresql/data`,
+        `postgres:${newVersion}`,
+        "bash", "-c", upgradeScript
+      ],
+      { stdio: "inherit" }
+    );
+
+    if (result.status === 0) {
+      console.log("✓ PostgreSQL upgrade completed successfully\n");
+      return true;
+    } else {
+      console.error("✗ PostgreSQL upgrade failed");
+      return false;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`PostgreSQL upgrade failed: ${message}`);
+    return false;
+  }
+}
+
 /**
  * Get docker compose command
  */
@@ -1660,43 +1784,103 @@ mon
   });
 mon
   .command("update")
-  .description("update monitoring stack")
+  .description("update monitoring stack (handles PostgreSQL major version upgrades automatically)")
   .action(async () => {
     console.log("Updating PostgresAI monitoring stack...\n");
 
+    let composeFile: string;
+    let projectDir: string;
+
     try {
+      // Get project directory
+      try {
+        ({ composeFile, projectDir } = await resolveOrInitPaths());
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+        return;
+      }
+
       // Check if we're in a git repo
-      const gitDir = path.resolve(process.cwd(), ".git");
+      const gitDir = path.resolve(projectDir, ".git");
       if (!fs.existsSync(gitDir)) {
         console.error("Not a git repository. Cannot update.");
         process.exitCode = 1;
         return;
       }
 
+      // Get current PostgreSQL version from running container (before git pull)
+      const currentPgVersion = getRunningPostgresVersion("sink-postgres");
+      if (currentPgVersion) {
+        console.log(`Current PostgreSQL version: ${currentPgVersion}`);
+      }
+
       // Fetch latest changes
-      console.log("Fetching latest changes...");
-      await execPromise("git fetch origin");
+      console.log("\nFetching latest changes...");
+      await execPromise(`git -C "${projectDir}" fetch origin`);
 
       // Check current branch
-      const { stdout: branch } = await execPromise("git rev-parse --abbrev-ref HEAD");
+      const { stdout: branch } = await execPromise(`git -C "${projectDir}" rev-parse --abbrev-ref HEAD`);
       const currentBranch = branch.trim();
       console.log(`Current branch: ${currentBranch}`);
 
       // Pull latest changes
       console.log("Pulling latest changes...");
-      const { stdout: pullOut } = await execPromise("git pull origin " + currentBranch);
+      const { stdout: pullOut } = await execPromise(`git -C "${projectDir}" pull origin ${currentBranch}`);
       console.log(pullOut);
 
+      // Get target PostgreSQL version from updated docker-compose.yml
+      const targetPgVersion = getTargetPostgresVersion(composeFile);
+      if (targetPgVersion) {
+        console.log(`Target PostgreSQL version: ${targetPgVersion}`);
+      }
+
+      // Check if PostgreSQL major version upgrade is needed
+      const needsPgUpgrade = currentPgVersion && targetPgVersion && currentPgVersion !== targetPgVersion;
+
+      if (needsPgUpgrade) {
+        console.log(`\n⚠ PostgreSQL major version change detected: ${currentPgVersion} → ${targetPgVersion}`);
+
+        // Stop services before upgrade
+        console.log("\nStopping services for PostgreSQL upgrade...");
+        await runCompose(["stop"]);
+
+        // Run pg_upgrade
+        const upgradeSuccess = await runPgUpgrade(currentPgVersion, targetPgVersion, projectDir);
+
+        if (!upgradeSuccess) {
+          console.error("\n✗ PostgreSQL upgrade failed");
+          console.error("Your data is preserved in the original format.");
+          console.error("You can either:");
+          console.error("  1. Fix the issue and run 'postgres-ai mon update' again");
+          console.error("  2. Reset the database: postgres-ai mon reset sink-postgres");
+          process.exitCode = 1;
+          return;
+        }
+      }
+
       // Update Docker images
-      console.log("\nUpdating Docker images...");
+      console.log("Updating Docker images...");
       const code = await runCompose(["pull"]);
 
-      if (code === 0) {
+      if (code !== 0) {
+        console.error("\n✗ Docker image update failed");
+        process.exitCode = 1;
+        return;
+      }
+
+      // Restart services to apply updates
+      console.log("\nRestarting services...");
+      const restartCode = await runCompose(["up", "-d", "--force-recreate"]);
+
+      if (restartCode === 0) {
         console.log("\n✓ Update completed successfully");
-        console.log("\nTo apply updates, restart monitoring services:");
-        console.log("  postgres-ai mon restart");
+        if (needsPgUpgrade) {
+          console.log(`✓ PostgreSQL upgraded from ${currentPgVersion} to ${targetPgVersion}`);
+        }
       } else {
-        console.error("\n✗ Docker image update failed");
+        console.error("\n✗ Failed to restart services");
         process.exitCode = 1;
       }
     } catch (error) {