postgresai 0.15.0-dev.4 → 0.15.0-dev.6

package/bin/postgres-ai.ts

@@ -7,6 +7,7 @@ import * as yaml from "js-yaml";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { fileURLToPath } from "url";
 import * as crypto from "node:crypto";
 import { Client } from "pg";
 import { startMcpServer } from "../lib/mcp-server";
@@ -503,7 +504,11 @@ async function ensureDefaultMonitoringProject(): Promise<PathResolution> {
     }
   }
 
-  // Ensure instances.yml exists as a FILE (avoid Docker creating a directory)
+  // Ensure instances.yml exists as a FILE (avoid Docker creating a directory).
+  // Docker bind-mounts create missing paths as directories; replace if so.
+  if (fs.existsSync(instancesFile) && fs.statSync(instancesFile).isDirectory()) {
+    fs.rmSync(instancesFile, { recursive: true, force: true });
+  }
   if (!fs.existsSync(instancesFile)) {
     const header =
       "# PostgreSQL instances to monitor\n" +
@@ -2071,13 +2076,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 +2243,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")) {
@@ -2279,7 +2307,7 @@ mon
     console.log("This will install, configure, and start the monitoring system\n");
 
     // Ensure we have a project directory with docker-compose.yml even if running from elsewhere
-    const { projectDir } = await resolveOrInitPaths();
+    const { projectDir, instancesFile: instancesPath } = await resolveOrInitPaths();
     console.log(`Project directory: ${projectDir}\n`);
 
     // Save project name to .pgwatch-config if provided (used by reporter container)
@@ -2502,7 +2530,26 @@ mon
         }
       }
     } else {
-      console.log("Step 2: Demo mode enabled - using included demo PostgreSQL database\n");
+      // Demo mode: copy bundled instances.demo.yml → instances.yml so the demo target is active
+      console.log("Step 2: Demo mode enabled - using included demo PostgreSQL database");
+      // Use import.meta.url instead of __dirname — bundlers bake in __dirname at build time.
+      // Check multiple candidate paths (npm package vs repo dev layout).
+      const currentDir = path.dirname(fileURLToPath(import.meta.url));
+      const demoCandidates = [
+        path.resolve(currentDir, "..", "..", "instances.demo.yml"),        // npm: dist/bin -> package root
+        path.resolve(currentDir, "..", "..", "..", "instances.demo.yml"),  // dev: cli/bin -> repo root
+      ];
+      const demoSrc = demoCandidates.find(p => fs.existsSync(p));
+      if (demoSrc) {
+        // Remove directory artifact left by Docker bind-mounts
+        if (fs.existsSync(instancesPath) && fs.statSync(instancesPath).isDirectory()) {
+          fs.rmSync(instancesPath, { recursive: true, force: true });
+        }
+        fs.copyFileSync(demoSrc, instancesPath);
+        console.log("✓ Demo monitoring target configured\n");
+      } else {
+        console.error(`⚠ instances.demo.yml not found — demo target not configured (searched: ${demoCandidates.join(", ")})\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");
   });
 
@@ -2806,7 +2904,7 @@ mon
     console.log(`Project Directory: ${projectDir}`);
     console.log(`Docker Compose File: ${composeFile}`);
     console.log(`Instances File: ${instancesFile}`);
-    if (fs.existsSync(instancesFile)) {
+    if (fs.existsSync(instancesFile) && !fs.statSync(instancesFile).isDirectory()) {
       console.log("\nInstances configuration:\n");
       const text = fs.readFileSync(instancesFile, "utf8");
       process.stdout.write(text);
@@ -3022,7 +3120,7 @@ targets
   .description("list monitoring target databases")
   .action(async () => {
     const { instancesFile: instancesPath, projectDir } = await resolveOrInitPaths();
-    if (!fs.existsSync(instancesPath)) {
+    if (!fs.existsSync(instancesPath) || fs.statSync(instancesPath).isDirectory()) {
       console.error(`instances.yml not found in ${projectDir}`);
       process.exitCode = 1;
       return;
@@ -3088,7 +3186,7 @@ targets
 
     // Check if instance already exists
     try {
-      if (fs.existsSync(file)) {
+      if (fs.existsSync(file) && !fs.statSync(file).isDirectory()) {
         const content = fs.readFileSync(file, "utf8");
         const instances = yaml.load(content) as Instance[] | null || [];
         if (Array.isArray(instances)) {
@@ -3102,7 +3200,8 @@ targets
       }
     } catch (err) {
       // If YAML parsing fails, fall back to simple check
-      const content = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+      const isFile = fs.existsSync(file) && !fs.statSync(file).isDirectory();
+      const content = isFile ? fs.readFileSync(file, "utf8") : "";
       if (new RegExp(`^- name: ${instanceName}$`, "m").test(content)) {
         console.error(`Monitoring target '${instanceName}' already exists`);
         process.exitCode = 1;
@@ -3110,7 +3209,10 @@ targets
       }
     }
 
-    // Add new instance
+    // Add new instance — if instances.yml is a directory (Docker artifact), replace it with a file
+    if (fs.existsSync(file) && fs.statSync(file).isDirectory()) {
+      fs.rmSync(file, { recursive: true, force: true });
+    }
     const body = `- name: ${instanceName}\n  conn_str: ${connStr}\n  preset_metrics: full\n  custom_metrics:\n  is_enabled: true\n  group: default\n  custom_tags:\n    env: production\n    cluster: default\n    node_name: ${instanceName}\n    sink_type: ~sink_type~\n`;
     const content = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
     fs.appendFileSync(file, (content && !/\n$/.test(content) ? "\n" : "") + body, "utf8");
@@ -3121,7 +3223,7 @@ targets
   .description("remove monitoring target database")
   .action(async (name: string) => {
     const { instancesFile: file } = await resolveOrInitPaths();
-    if (!fs.existsSync(file)) {
+    if (!fs.existsSync(file) || fs.statSync(file).isDirectory()) {
       console.error("instances.yml not found");
       process.exitCode = 1;
       return;
@@ -3158,7 +3260,7 @@ targets
   .description("test monitoring target database connectivity")
   .action(async (name: string) => {
     const { instancesFile: instancesPath } = await resolveOrInitPaths();
-    if (!fs.existsSync(instancesPath)) {
+    if (!fs.existsSync(instancesPath) || fs.statSync(instancesPath).isDirectory()) {
       console.error("instances.yml not found");
       process.exitCode = 1;
       return;
@@ -3625,6 +3727,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.6",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -15965,6 +15965,7 @@ var safeDump = renamed("safeDump", "dump");
 import * as fs6 from "fs";
 import * as path6 from "path";
 import * as os3 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import * as crypto2 from "crypto";
 
 // node_modules/pg/esm/index.mjs
@@ -15981,7 +15982,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.6";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -29890,6 +29891,9 @@ async function ensureDefaultMonitoringProject() {
       throw new Error(`Failed to bootstrap docker-compose.yml: ${msg}`);
     }
   }
+  if (fs6.existsSync(instancesFile) && fs6.statSync(instancesFile).isDirectory()) {
+    fs6.rmSync(instancesFile, { recursive: true, force: true });
+  }
   if (!fs6.existsSync(instancesFile)) {
     const header = `# PostgreSQL instances to monitor
 ` + `# Add your instances using: pgai mon targets add <connection-string> <name>
@@ -31138,10 +31142,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 +31263,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");
@@ -31286,7 +31310,7 @@ mon.command("local-install").description("install local monitoring stack (genera
 `);
   console.log(`This will install, configure, and start the monitoring system
 `);
-  const { projectDir } = await resolveOrInitPaths();
+  const { projectDir, instancesFile: instancesPath } = await resolveOrInitPaths();
   console.log(`Project directory: ${projectDir}
 `);
   if (opts.project) {
@@ -31397,13 +31421,13 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
   if (!opts.demo) {
     console.log(`Step 2: Add PostgreSQL Instance to Monitor
 `);
-    const { instancesFile: instancesPath, projectDir: projectDir2 } = await resolveOrInitPaths();
+    const { instancesFile: instancesPath2, projectDir: projectDir2 } = await resolveOrInitPaths();
     const emptyInstancesContent = `# PostgreSQL instances to monitor
 # Add your instances using: postgres-ai mon targets add
 
 `;
-    fs6.writeFileSync(instancesPath, emptyInstancesContent, "utf8");
-    console.log(`Instances file: ${instancesPath}`);
+    fs6.writeFileSync(instancesPath2, emptyInstancesContent, "utf8");
+    console.log(`Instances file: ${instancesPath2}`);
     console.log(`Project directory: ${projectDir2}
 `);
     if (opts.dbUrl) {
@@ -31434,7 +31458,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
     node_name: ${instanceName}
     sink_type: ~sink_type~
 `;
-      fs6.appendFileSync(instancesPath, body, "utf8");
+      fs6.appendFileSync(instancesPath2, body, "utf8");
       console.log(`\u2713 Monitoring target '${instanceName}' added
 `);
       console.log("Testing connection to the added instance...");
@@ -31489,7 +31513,7 @@ You can provide either:`);
     node_name: ${instanceName}
     sink_type: ~sink_type~
 `;
-            fs6.appendFileSync(instancesPath, body, "utf8");
+            fs6.appendFileSync(instancesPath2, body, "utf8");
             console.log(`\u2713 Monitoring target '${instanceName}' added
 `);
             console.log("Testing connection to the added instance...");
@@ -31517,8 +31541,24 @@ 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 currentDir = path6.dirname(fileURLToPath2(import.meta.url));
+    const demoCandidates = [
+      path6.resolve(currentDir, "..", "..", "instances.demo.yml"),
+      path6.resolve(currentDir, "..", "..", "..", "instances.demo.yml")
+    ];
+    const demoSrc = demoCandidates.find((p) => fs6.existsSync(p));
+    if (demoSrc) {
+      if (fs6.existsSync(instancesPath) && fs6.statSync(instancesPath).isDirectory()) {
+        fs6.rmSync(instancesPath, { recursive: true, force: true });
+      }
+      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 (searched: ${demoCandidates.join(", ")})
+`);
+    }
   }
   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
 `);
 });
@@ -31761,7 +31845,7 @@ mon.command("config").description("show monitoring services configuration").acti
   console.log(`Project Directory: ${projectDir}`);
   console.log(`Docker Compose File: ${composeFile}`);
   console.log(`Instances File: ${instancesFile}`);
-  if (fs6.existsSync(instancesFile)) {
+  if (fs6.existsSync(instancesFile) && !fs6.statSync(instancesFile).isDirectory()) {
     console.log(`
 Instances configuration:
 `);
@@ -31936,7 +32020,7 @@ mon.command("check").description("monitoring services system readiness check").a
 var targets = mon.command("targets").description("manage databases to monitor");
 targets.command("list").description("list monitoring target databases").action(async () => {
   const { instancesFile: instancesPath, projectDir } = await resolveOrInitPaths();
-  if (!fs6.existsSync(instancesPath)) {
+  if (!fs6.existsSync(instancesPath) || fs6.statSync(instancesPath).isDirectory()) {
     console.error(`instances.yml not found in ${projectDir}`);
     process.exitCode = 1;
     return;
@@ -31991,7 +32075,7 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
   const db = m[5];
   const instanceName = name && name.trim() ? name.trim() : `${host}-${db}`.replace(/[^a-zA-Z0-9-]/g, "-");
   try {
-    if (fs6.existsSync(file)) {
+    if (fs6.existsSync(file) && !fs6.statSync(file).isDirectory()) {
       const content2 = fs6.readFileSync(file, "utf8");
       const instances = load(content2) || [];
       if (Array.isArray(instances)) {
@@ -32004,13 +32088,17 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
       }
     }
   } catch (err) {
-    const content2 = fs6.existsSync(file) ? fs6.readFileSync(file, "utf8") : "";
+    const isFile = fs6.existsSync(file) && !fs6.statSync(file).isDirectory();
+    const content2 = isFile ? fs6.readFileSync(file, "utf8") : "";
     if (new RegExp(`^- name: ${instanceName}$`, "m").test(content2)) {
       console.error(`Monitoring target '${instanceName}' already exists`);
       process.exitCode = 1;
       return;
     }
   }
+  if (fs6.existsSync(file) && fs6.statSync(file).isDirectory()) {
+    fs6.rmSync(file, { recursive: true, force: true });
+  }
   const body = `- name: ${instanceName}
   conn_str: ${connStr}
   preset_metrics: full
@@ -32030,7 +32118,7 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
 });
 targets.command("remove <name>").description("remove monitoring target database").action(async (name) => {
   const { instancesFile: file } = await resolveOrInitPaths();
-  if (!fs6.existsSync(file)) {
+  if (!fs6.existsSync(file) || fs6.statSync(file).isDirectory()) {
     console.error("instances.yml not found");
     process.exitCode = 1;
     return;
@@ -32059,7 +32147,7 @@ targets.command("remove <name>").description("remove monitoring target database"
 });
 targets.command("test <name>").description("test monitoring target database connectivity").action(async (name) => {
   const { instancesFile: instancesPath } = await resolveOrInitPaths();
-  if (!fs6.existsSync(instancesPath)) {
+  if (!fs6.existsSync(instancesPath) || fs6.statSync(instancesPath).isDirectory()) {
     console.error("instances.yml not found");
     process.exitCode = 1;
     return;
@@ -32426,6 +32514,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.6",
   "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);
+  });
+});

package/test/init.test.ts

@@ -1070,6 +1070,14 @@ describe("CLI commands", () => {
     expect(r.stderr).toMatch(/Reports will be generated locally only/);
   });
 
+  test("cli: mon local-install --demo configures demo monitoring target", () => {
+    // --demo should copy instances.demo.yml to instances.yml and print confirmation.
+    // The command will fail later (no Docker), but we verify the demo target step succeeded.
+    const r = runCli(["mon", "local-install", "--demo"]);
+    expect(r.stdout).toMatch(/Demo mode enabled/);
+    expect(r.stdout).toMatch(/Demo monitoring target configured/);
+  });
+
   test("cli: mon local-install --demo with global --api-key shows error", () => {
     // When --demo is used with global --api-key, it should still be detected and error
     const r = runCli([

package/test/monitoring.test.ts

@@ -259,3 +259,81 @@ describe("registerMonitoringInstance", () => {
     expect(fetchCalls[0].url).toBe("https://custom.api.com/v2/rpc/monitoring_instance_register");
   });
 });
+
+describe("demo mode instances.demo.yml", () => {
+  const repoRoot = path.resolve(import.meta.dir, "..", "..");
+
+  test("instances.demo.yml exists in repo root", () => {
+    const demoFile = path.join(repoRoot, "instances.demo.yml");
+    expect(fs.existsSync(demoFile)).toBe(true);
+  });
+
+  test("instances.demo.yml contains demo target connection", () => {
+    const demoFile = path.join(repoRoot, "instances.demo.yml");
+    const content = fs.readFileSync(demoFile, "utf8");
+    expect(content).toContain("name: target_database");
+    expect(content).toContain("conn_str: postgresql://monitor:monitor_pass@target-db:5432/target_database");
+    expect(content).toContain("is_enabled: true");
+    expect(content).toContain("preset_metrics: full");
+  });
+
+  test("instances.demo.yml has required YAML structure", () => {
+    const demoFile = path.join(repoRoot, "instances.demo.yml");
+    const content = fs.readFileSync(demoFile, "utf8");
+    // Verify it's a YAML list (starts with "- name:")
+    expect(content).toMatch(/^- name: target_database/m);
+    // Verify required fields are present with correct indentation
+    expect(content).toMatch(/^\s+conn_str:/m);
+    expect(content).toMatch(/^\s+preset_metrics: full/m);
+    expect(content).toMatch(/^\s+is_enabled: true/m);
+    // ~sink_type~ is a placeholder replaced per-sink by generate-pgwatch-sources.sh
+    expect(content).toMatch(/^\s+sink_type: ~sink_type~/m);
+  });
+
+  test("instances.yml is gitignored (not tracked)", () => {
+    const gitignore = fs.readFileSync(path.join(repoRoot, ".gitignore"), "utf8");
+    expect(gitignore).toContain("instances.yml");
+  });
+
+  test("demo config can be copied to instances.yml in temp dir", () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "demo-install-test-"));
+    try {
+      const demoSrc = path.join(repoRoot, "instances.demo.yml");
+      const instancesDest = path.join(tempDir, "instances.yml");
+
+      fs.copyFileSync(demoSrc, instancesDest);
+
+      expect(fs.existsSync(instancesDest)).toBe(true);
+      const content = fs.readFileSync(instancesDest, "utf8");
+      expect(content).toContain("name: target_database");
+      expect(content).toContain("conn_str: postgresql://monitor:monitor_pass@target-db:5432/target_database");
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("demo config copy overwrites directory at instances.yml path", () => {
+    // Docker bind-mounts create missing paths as directories; the copy must handle this
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "demo-eisdir-test-"));
+    try {
+      const demoSrc = path.join(repoRoot, "instances.demo.yml");
+      const instancesDest = path.join(tempDir, "instances.yml");
+
+      // Simulate Docker creating a directory at instances.yml path
+      fs.mkdirSync(instancesDest);
+      expect(fs.statSync(instancesDest).isDirectory()).toBe(true);
+
+      // The fix: remove directory then copy
+      if (fs.statSync(instancesDest).isDirectory()) {
+        fs.rmSync(instancesDest, { recursive: true, force: true });
+      }
+      fs.copyFileSync(demoSrc, instancesDest);
+
+      expect(fs.statSync(instancesDest).isFile()).toBe(true);
+      const content = fs.readFileSync(instancesDest, "utf8");
+      expect(content).toContain("name: target_database");
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});