postgresai 0.15.0-dev.4 → 0.15.0-dev.5

package/bin/postgres-ai.ts

@@ -477,14 +477,14 @@ async function ensureDefaultMonitoringProject(): Promise<PathResolution> {
     fs.mkdirSync(projectDir, { recursive: true, mode: 0o700 });
   }
 
-  if (!fs.existsSync(composeFile)) {
-    const refs = [
-      process.env.PGAI_PROJECT_REF,
-      pkg.version,
-      `v${pkg.version}`,
-      "main",
-    ].filter((v): v is string => Boolean(v && v.trim()));
+  const refs = [
+    process.env.PGAI_PROJECT_REF,
+    pkg.version,
+    `v${pkg.version}`,
+    "main",
+  ].filter((v): v is string => Boolean(v && v.trim()));
 
+  if (!fs.existsSync(composeFile)) {
     let lastErr: unknown;
     for (const ref of refs) {
       const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/docker-compose.yml`;
@@ -503,6 +503,21 @@ async function ensureDefaultMonitoringProject(): Promise<PathResolution> {
     }
   }
 
+  // Download instances.demo.yml (demo target template) if not present
+  const demoFile = path.resolve(projectDir, "instances.demo.yml");
+  if (!fs.existsSync(demoFile)) {
+    for (const ref of refs) {
+      const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/instances.demo.yml`;
+      try {
+        const text = await downloadText(url);
+        fs.writeFileSync(demoFile, text, { encoding: "utf8", mode: 0o600 });
+        break;
+      } catch {
+        // non-fatal — demo file is optional
+      }
+    }
+  }
+
   // Ensure instances.yml exists as a FILE (avoid Docker creating a directory)
   if (!fs.existsSync(instancesFile)) {
     const header =
@@ -2071,13 +2086,16 @@ function isDockerRunning(): boolean {
 }
 
 /**
- * Get docker compose command
+ * Get docker compose command.
+ * Prefer "docker compose" (V2 plugin) over legacy "docker-compose" (V1 standalone)
+ * because docker-compose V1 (<=1.29) is incompatible with modern Docker engines
+ * (KeyError: 'ContainerConfig' on container recreation).
  */
 function getComposeCmd(): string[] | null {
   const tryCmd = (cmd: string, args: string[]): boolean =>
     spawnSync(cmd, args, { stdio: "ignore", timeout: 5000 } as Parameters<typeof spawnSync>[2]).status === 0;
-  if (tryCmd("docker-compose", ["version"])) return ["docker-compose"];
   if (tryCmd("docker", ["compose", "version"])) return ["docker", "compose"];
+  if (tryCmd("docker-compose", ["version"])) return ["docker-compose"];
   return null;
 }
 
@@ -2235,6 +2253,26 @@ async function runCompose(args: string[], grafanaPassword?: string): Promise<num
     }
   }
 
+  // Load VM auth credentials from .env if not already set
+  const envFilePath = path.resolve(projectDir, ".env");
+  if (fs.existsSync(envFilePath)) {
+    try {
+      const envContent = fs.readFileSync(envFilePath, "utf8");
+      if (!env.VM_AUTH_USERNAME) {
+        const m = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
+        if (m) env.VM_AUTH_USERNAME = m[1].trim().replace(/^["']|["']$/g, '');
+      }
+      if (!env.VM_AUTH_PASSWORD) {
+        const m = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
+        if (m) env.VM_AUTH_PASSWORD = m[1].trim().replace(/^["']|["']$/g, '');
+      }
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.warn(`Warning: Could not read VM auth from .env: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+
   // On macOS, self-node-exporter can't mount host root filesystem - skip it
   const finalArgs = [...args];
   if (process.platform === "darwin" && args.includes("up")) {
@@ -2502,7 +2540,16 @@ mon
         }
       }
     } else {
-      console.log("Step 2: Demo mode enabled - using included demo PostgreSQL database\n");
+      // Demo mode: copy instances.demo.yml → instances.yml so the demo target is active
+      console.log("Step 2: Demo mode enabled - using included demo PostgreSQL database");
+      const { instancesFile: instancesPath, projectDir } = await resolveOrInitPaths();
+      const demoSrc = path.resolve(projectDir, "instances.demo.yml");
+      if (fs.existsSync(demoSrc)) {
+        fs.copyFileSync(demoSrc, instancesPath);
+        console.log("✓ Demo monitoring target configured\n");
+      } else {
+        console.error("⚠ instances.demo.yml not found — demo target not configured\n");
+      }
     }
 
     // Step 3: Update configuration
@@ -2518,6 +2565,8 @@ mon
     console.log(opts.demo ? "Step 4: Configuring Grafana security..." : "Step 4: Configuring Grafana security...");
     const cfgPath = path.resolve(projectDir, ".pgwatch-config");
     let grafanaPassword = "";
+    let vmAuthUsername = "";
+    let vmAuthPassword = "";
 
     try {
       if (fs.existsSync(cfgPath)) {
@@ -2556,7 +2605,53 @@ mon
       grafanaPassword = "demo";
     }
 
+    // Generate VictoriaMetrics auth credentials
+    try {
+      const envFile = path.resolve(projectDir, ".env");
+
+      // Read existing VM auth from .env if present
+      if (fs.existsSync(envFile)) {
+        const envContent = fs.readFileSync(envFile, "utf8");
+        const userMatch = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
+        const passMatch = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
+        if (userMatch) vmAuthUsername = userMatch[1].trim().replace(/^["']|["']$/g, '');
+        if (passMatch) vmAuthPassword = passMatch[1].trim().replace(/^["']|["']$/g, '');
+      }
+
+      if (!vmAuthUsername || !vmAuthPassword) {
+        console.log("Generating VictoriaMetrics auth credentials...");
+        vmAuthUsername = vmAuthUsername || "vmauth";
+        if (!vmAuthPassword) {
+          const { stdout: vmPass } = await execPromise("openssl rand -base64 12 | tr -d '\n'");
+          vmAuthPassword = vmPass.trim();
+        }
+
+        // Update .env file with VM auth credentials
+        let envContent = "";
+        if (fs.existsSync(envFile)) {
+          envContent = fs.readFileSync(envFile, "utf8");
+        }
+        const envLines = envContent.split(/\r?\n/)
+          .filter((l) => !/^VM_AUTH_USERNAME=/.test(l) && !/^VM_AUTH_PASSWORD=/.test(l))
+          .filter((l, i, arr) => !(i === arr.length - 1 && l === ''));
+        envLines.push(`VM_AUTH_USERNAME=${vmAuthUsername}`);
+        envLines.push(`VM_AUTH_PASSWORD=${vmAuthPassword}`);
+        fs.writeFileSync(envFile, envLines.join("\n") + "\n", { encoding: "utf8", mode: 0o600 });
+      }
+
+      console.log("✓ VictoriaMetrics auth configured\n");
+    } catch (error) {
+      console.error("⚠ Could not generate VictoriaMetrics auth credentials automatically");
+      if (process.env.DEBUG) {
+        console.warn(`  ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+
     // Step 5: Start services
+    // Remove stopped containers left by "run --rm" dependencies (e.g. config-init)
+    // to avoid docker-compose v1 'ContainerConfig' error on recreation.
+    // Best-effort: ignore exit code — container may not exist, failure here is non-fatal.
+    await runCompose(["rm", "-f", "-s", "config-init"]);
     console.log("Step 5: Starting monitoring services...");
     const code2 = await runCompose(["up", "-d", "--force-recreate"], grafanaPassword);
     if (code2 !== 0) {
@@ -2606,6 +2701,9 @@ mon
     console.log("🚀 MAIN ACCESS POINT - Start here:");
     console.log("   Grafana Dashboard: http://localhost:3000");
     console.log(`   Login: monitor / ${grafanaPassword}`);
+    if (vmAuthUsername && vmAuthPassword) {
+      console.log(`   VictoriaMetrics Auth: ${vmAuthUsername} / ${vmAuthPassword}`);
+    }
     console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
   });
 
@@ -3625,6 +3723,19 @@ mon
     console.log("  URL:      http://localhost:3000");
     console.log("  Username: monitor");
     console.log(`  Password: ${password}`);
+
+    // Show VM auth credentials from .env
+    const envFile = path.resolve(projectDir, ".env");
+    if (fs.existsSync(envFile)) {
+      const envContent = fs.readFileSync(envFile, "utf8");
+      const vmUser = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
+      const vmPass = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
+      if (vmUser && vmPass) {
+        console.log("\nVictoriaMetrics credentials:");
+        console.log(`  Username: ${vmUser[1].trim().replace(/^["']|["']$/g, '')}`);
+        console.log(`  Password: ${vmPass[1].trim().replace(/^["']|["']$/g, '')}`);
+      }
+    }
     console.log("");
   });
 

package/dist/bin/postgres-ai.js

@@ -13151,7 +13151,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.15.0-dev.4",
+  version: "0.15.0-dev.5",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -15981,7 +15981,7 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 // package.json
-var version = "0.15.0-dev.4";
+var version = "0.15.0-dev.5";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -29867,13 +29867,13 @@ async function ensureDefaultMonitoringProject() {
   if (!fs6.existsSync(projectDir)) {
     fs6.mkdirSync(projectDir, { recursive: true, mode: 448 });
   }
+  const refs = [
+    process.env.PGAI_PROJECT_REF,
+    package_default.version,
+    `v${package_default.version}`,
+    "main"
+  ].filter((v) => Boolean(v && v.trim()));
   if (!fs6.existsSync(composeFile)) {
-    const refs = [
-      process.env.PGAI_PROJECT_REF,
-      package_default.version,
-      `v${package_default.version}`,
-      "main"
-    ].filter((v) => Boolean(v && v.trim()));
     let lastErr;
     for (const ref of refs) {
       const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/docker-compose.yml`;
@@ -29890,6 +29890,17 @@ async function ensureDefaultMonitoringProject() {
       throw new Error(`Failed to bootstrap docker-compose.yml: ${msg}`);
     }
   }
+  const demoFile = path6.resolve(projectDir, "instances.demo.yml");
+  if (!fs6.existsSync(demoFile)) {
+    for (const ref of refs) {
+      const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/instances.demo.yml`;
+      try {
+        const text = await downloadText(url);
+        fs6.writeFileSync(demoFile, text, { encoding: "utf8", mode: 384 });
+        break;
+      } catch {}
+    }
+  }
   if (!fs6.existsSync(instancesFile)) {
     const header = `# PostgreSQL instances to monitor
 ` + `# Add your instances using: pgai mon targets add <connection-string> <name>
@@ -31138,10 +31149,10 @@ function isDockerRunning() {
 }
 function getComposeCmd() {
   const tryCmd = (cmd, args) => spawnSync2(cmd, args, { stdio: "ignore", timeout: 5000 }).status === 0;
-  if (tryCmd("docker-compose", ["version"]))
-    return ["docker-compose"];
   if (tryCmd("docker", ["compose", "version"]))
     return ["docker", "compose"];
+  if (tryCmd("docker-compose", ["version"]))
+    return ["docker-compose"];
   return null;
 }
 function checkRunningContainers() {
@@ -31259,6 +31270,26 @@ async function runCompose(args, grafanaPassword) {
       }
     }
   }
+  const envFilePath = path6.resolve(projectDir, ".env");
+  if (fs6.existsSync(envFilePath)) {
+    try {
+      const envContent = fs6.readFileSync(envFilePath, "utf8");
+      if (!env.VM_AUTH_USERNAME) {
+        const m = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
+        if (m)
+          env.VM_AUTH_USERNAME = m[1].trim().replace(/^["']|["']$/g, "");
+      }
+      if (!env.VM_AUTH_PASSWORD) {
+        const m = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
+        if (m)
+          env.VM_AUTH_PASSWORD = m[1].trim().replace(/^["']|["']$/g, "");
+      }
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.warn(`Warning: Could not read VM auth from .env: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
   const finalArgs = [...args];
   if (process.platform === "darwin" && args.includes("up")) {
     finalArgs.push("--scale", "self-node-exporter=0");
@@ -31517,8 +31548,17 @@ You can provide either:`);
       }
     }
   } else {
-    console.log(`Step 2: Demo mode enabled - using included demo PostgreSQL database
+    console.log("Step 2: Demo mode enabled - using included demo PostgreSQL database");
+    const { instancesFile: instancesPath, projectDir: projectDir2 } = await resolveOrInitPaths();
+    const demoSrc = path6.resolve(projectDir2, "instances.demo.yml");
+    if (fs6.existsSync(demoSrc)) {
+      fs6.copyFileSync(demoSrc, instancesPath);
+      console.log(`\u2713 Demo monitoring target configured
+`);
+    } else {
+      console.error(`\u26A0 instances.demo.yml not found \u2014 demo target not configured
 `);
+    }
   }
   console.log(opts.demo ? "Step 3: Updating configuration..." : "Step 3: Updating configuration...");
   const code1 = await runCompose(["run", "--rm", "sources-generator"]);
@@ -31531,6 +31571,8 @@ You can provide either:`);
   console.log(opts.demo ? "Step 4: Configuring Grafana security..." : "Step 4: Configuring Grafana security...");
   const cfgPath = path6.resolve(projectDir, ".pgwatch-config");
   let grafanaPassword = "";
+  let vmAuthUsername = "";
+  let vmAuthPassword = "";
   try {
     if (fs6.existsSync(cfgPath)) {
       const stats = fs6.statSync(cfgPath);
@@ -31568,6 +31610,45 @@ You can provide either:`);
 `);
     grafanaPassword = "demo";
   }
+  try {
+    const envFile2 = path6.resolve(projectDir, ".env");
+    if (fs6.existsSync(envFile2)) {
+      const envContent = fs6.readFileSync(envFile2, "utf8");
+      const userMatch = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
+      const passMatch = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
+      if (userMatch)
+        vmAuthUsername = userMatch[1].trim().replace(/^["']|["']$/g, "");
+      if (passMatch)
+        vmAuthPassword = passMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    if (!vmAuthUsername || !vmAuthPassword) {
+      console.log("Generating VictoriaMetrics auth credentials...");
+      vmAuthUsername = vmAuthUsername || "vmauth";
+      if (!vmAuthPassword) {
+        const { stdout: vmPass } = await execPromise(`openssl rand -base64 12 | tr -d '
+'`);
+        vmAuthPassword = vmPass.trim();
+      }
+      let envContent = "";
+      if (fs6.existsSync(envFile2)) {
+        envContent = fs6.readFileSync(envFile2, "utf8");
+      }
+      const envLines2 = envContent.split(/\r?\n/).filter((l) => !/^VM_AUTH_USERNAME=/.test(l) && !/^VM_AUTH_PASSWORD=/.test(l)).filter((l, i2, arr) => !(i2 === arr.length - 1 && l === ""));
+      envLines2.push(`VM_AUTH_USERNAME=${vmAuthUsername}`);
+      envLines2.push(`VM_AUTH_PASSWORD=${vmAuthPassword}`);
+      fs6.writeFileSync(envFile2, envLines2.join(`
+`) + `
+`, { encoding: "utf8", mode: 384 });
+    }
+    console.log(`\u2713 VictoriaMetrics auth configured
+`);
+  } catch (error2) {
+    console.error("\u26A0 Could not generate VictoriaMetrics auth credentials automatically");
+    if (process.env.DEBUG) {
+      console.warn(`  ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  }
+  await runCompose(["rm", "-f", "-s", "config-init"]);
   console.log("Step 5: Starting monitoring services...");
   const code2 = await runCompose(["up", "-d", "--force-recreate"], grafanaPassword);
   if (code2 !== 0) {
@@ -31615,6 +31696,9 @@ You can provide either:`);
   console.log("\uD83D\uDE80 MAIN ACCESS POINT - Start here:");
   console.log("   Grafana Dashboard: http://localhost:3000");
   console.log(`   Login: monitor / ${grafanaPassword}`);
+  if (vmAuthUsername && vmAuthPassword) {
+    console.log(`   VictoriaMetrics Auth: ${vmAuthUsername} / ${vmAuthPassword}`);
+  }
   console.log(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 `);
 });
@@ -32426,6 +32510,18 @@ Grafana credentials:`);
   console.log("  URL:      http://localhost:3000");
   console.log("  Username: monitor");
   console.log(`  Password: ${password}`);
+  const envFile = path6.resolve(projectDir, ".env");
+  if (fs6.existsSync(envFile)) {
+    const envContent = fs6.readFileSync(envFile, "utf8");
+    const vmUser = envContent.match(/^VM_AUTH_USERNAME=([^\r\n]+)/m);
+    const vmPass = envContent.match(/^VM_AUTH_PASSWORD=([^\r\n]+)/m);
+    if (vmUser && vmPass) {
+      console.log(`
+VictoriaMetrics credentials:`);
+      console.log(`  Username: ${vmUser[1].trim().replace(/^["']|["']$/g, "")}`);
+      console.log(`  Password: ${vmPass[1].trim().replace(/^["']|["']$/g, "")}`);
+    }
+  }
   console.log("");
 });
 function interpretEscapes2(str2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresai",
-  "version": "0.15.0-dev.4",
+  "version": "0.15.0-dev.5",
   "description": "postgres_ai CLI",
   "license": "Apache-2.0",
   "private": false,

package/test/compose-cmd.test.ts

@@ -0,0 +1,120 @@
+import { describe, test, expect } from "bun:test";
+
+/**
+ * Test getComposeCmd() selection logic.
+ * WARNING: This replicates the logic from postgres-ai.ts. If the production
+ * function changes, this replica must be updated to match.
+ * Since the function is internal to postgres-ai.ts, we replicate its logic
+ * with an injectable command checker (same pattern as monitoring.test.ts).
+ */
+function getComposeCmd(
+  tryCmd: (cmd: string, args: string[]) => boolean,
+): string[] | null {
+  if (tryCmd("docker", ["compose", "version"])) return ["docker", "compose"];
+  if (tryCmd("docker-compose", ["version"])) return ["docker-compose"];
+  return null;
+}
+
+describe("getComposeCmd", () => {
+  test("prefers docker compose V2 when both are available", () => {
+    const result = getComposeCmd(() => true);
+    expect(result).toEqual(["docker", "compose"]);
+  });
+
+  test("falls back to docker-compose V1 when V2 is unavailable", () => {
+    const result = getComposeCmd((cmd, args) => {
+      // V2 plugin fails, V1 standalone succeeds
+      if (cmd === "docker" && args[0] === "compose") return false;
+      if (cmd === "docker-compose") return true;
+      return false;
+    });
+    expect(result).toEqual(["docker-compose"]);
+  });
+
+  test("returns null when neither is available", () => {
+    const result = getComposeCmd(() => false);
+    expect(result).toBeNull();
+  });
+
+  test("does not check V1 when V2 succeeds", () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    getComposeCmd((cmd, args) => {
+      calls.push({ cmd, args });
+      return cmd === "docker" && args[0] === "compose";
+    });
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual({ cmd: "docker", args: ["compose", "version"] });
+  });
+
+  test("checks V2 first, then V1", () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    getComposeCmd((cmd, args) => {
+      calls.push({ cmd, args });
+      return false;
+    });
+    expect(calls).toHaveLength(2);
+    expect(calls[0]).toEqual({ cmd: "docker", args: ["compose", "version"] });
+    expect(calls[1]).toEqual({ cmd: "docker-compose", args: ["version"] });
+  });
+});
+
+/**
+ * Test the monitoring startup sequence's container cleanup logic.
+ * Before "up --force-recreate", stopped containers from "run --rm" dependencies
+ * (e.g. config-init) must be removed to avoid docker-compose v1's
+ * KeyError: 'ContainerConfig' bug.
+ *
+ * We replicate the relevant sequence from the monitoring start command
+ * with an injectable runCompose to verify ordering and error tolerance.
+ */
+async function monitoringStartSequence(
+  runCompose: (args: string[]) => Promise<number>,
+): Promise<number> {
+  // Best-effort: remove stopped containers left by "run --rm" dependencies
+  await runCompose(["rm", "-f", "-s", "config-init"]);
+  // Start services
+  const code = await runCompose(["up", "-d", "--force-recreate"]);
+  return code;
+}
+
+describe("monitoring start: config-init cleanup", () => {
+  test("calls rm before up", async () => {
+    const calls: string[][] = [];
+    await monitoringStartSequence(async (args) => {
+      calls.push(args);
+      return 0;
+    });
+    expect(calls).toHaveLength(2);
+    expect(calls[0]).toEqual(["rm", "-f", "-s", "config-init"]);
+    expect(calls[1]).toEqual(["up", "-d", "--force-recreate"]);
+  });
+
+  test("continues to up even when rm fails", async () => {
+    const calls: string[][] = [];
+    await monitoringStartSequence(async (args) => {
+      calls.push(args);
+      // rm returns non-zero (container doesn't exist)
+      if (args[0] === "rm") return 1;
+      return 0;
+    });
+    expect(calls).toHaveLength(2);
+    expect(calls[0][0]).toBe("rm");
+    expect(calls[1][0]).toBe("up");
+  });
+
+  test("returns up exit code, not rm exit code", async () => {
+    // rm fails but up succeeds → overall success
+    const result1 = await monitoringStartSequence(async (args) => {
+      if (args[0] === "rm") return 1;
+      return 0;
+    });
+    expect(result1).toBe(0);
+
+    // rm succeeds but up fails → overall failure
+    const result2 = await monitoringStartSequence(async (args) => {
+      if (args[0] === "up") return 2;
+      return 0;
+    });
+    expect(result2).toBe(2);
+  });
+});