postgresai 0.14.0 → 0.15.0-dev.2

package/bin/postgres-ai.ts

@@ -11,6 +11,7 @@ import * as crypto from "node:crypto";
 import { Client } from "pg";
 import { startMcpServer } from "../lib/mcp-server";
 import { fetchIssues, fetchIssueComments, createIssueComment, fetchIssue, createIssue, updateIssue, updateIssueComment, fetchActionItem, fetchActionItems, createActionItem, updateActionItem, type ConfigChange } from "../lib/issues";
+import { fetchReports, fetchAllReports, fetchReportFiles, fetchReportFileData, renderMarkdownForTerminal, parseFlexibleDate } from "../lib/reports";
 import { resolveBaseUrls } from "../lib/util";
 import { applyInitPlan, applyUninitPlan, buildInitPlan, buildUninitPlan, connectWithSslFallback, DEFAULT_MONITORING_USER, KNOWN_PROVIDERS, redactPasswordsInSql, resolveAdminConnection, resolveMonitoringPassword, validateProvider, verifyInitSetup } from "../lib/init";
 import { SupabaseClient, resolveSupabaseConfig, extractProjectRefFromUrl, applyInitPlanViaSupabase, verifyInitSetupViaSupabase, fetchPoolerDatabaseUrl, type PgCompatibleError } from "../lib/supabase";
@@ -24,6 +25,18 @@ import { getCheckupEntry } from "../lib/checkup-dictionary";
 import { createCheckupReport, uploadCheckupReportJson, convertCheckupReportJsonToMarkdown, RpcError, formatRpcErrorForDisplay, withRetry } from "../lib/checkup-api";
 import { generateCheckSummary } from "../lib/checkup-summary";
 
+// Node.js version check - require Node 18+
+// Node 14 reached EOL in April 2023, Node 16 in September 2023.
+// Node 18+ is required for native ESM, modern crypto APIs, and security updates.
+const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
+if (nodeVersion < 18) {
+  console.error(`\x1b[31mError: postgresai requires Node 18 or higher.\x1b[0m`);
+  console.error(`You are running Node.js ${process.versions.node}.`);
+  console.error(`Please upgrade to Node.js 20 LTS or Node.js 22 for security updates.`);
+  console.error(`\nDownload: https://nodejs.org/`);
+  process.exit(1);
+}
+
 // Singleton readline interface for stdin prompts
 let rl: ReturnType<typeof createInterface> | null = null;
 function getReadline() {
@@ -2061,6 +2074,85 @@ function checkRunningContainers(): { running: boolean; containers: string[] } {
   }
 }
 
+/**
+ * Register monitoring instance with the API (non-blocking).
+ * Returns immediately, logs result in background.
+ */
+function registerMonitoringInstance(
+  apiKey: string,
+  projectName: string,
+  opts?: { apiBaseUrl?: string; debug?: boolean }
+): void {
+  const { apiBaseUrl } = resolveBaseUrls(opts);
+  const url = `${apiBaseUrl}/rpc/monitoring_instance_register`;
+  const debug = opts?.debug;
+
+  if (debug) {
+    console.log(`\nDebug: Registering monitoring instance...`);
+    console.log(`Debug: POST ${url}`);
+    console.log(`Debug: project_name=${projectName}`);
+  }
+
+  // Fire and forget - don't block the main flow
+  fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      api_token: apiKey,
+      project_name: projectName,
+    }),
+  })
+    .then(async (res) => {
+      const body = await res.text().catch(() => "");
+      if (!res.ok) {
+        if (debug) {
+          console.log(`Debug: Monitoring registration failed: HTTP ${res.status}`);
+          console.log(`Debug: Response: ${body}`);
+        }
+        return;
+      }
+      if (debug) {
+        console.log(`Debug: Monitoring registration response: ${body}`);
+      }
+    })
+    .catch((err) => {
+      if (debug) {
+        console.log(`Debug: Monitoring registration error: ${err.message}`);
+      }
+    });
+}
+
+/**
+ * Update .pgwatch-config file with key=value pairs.
+ * Preserves existing values not being updated.
+ */
+function updatePgwatchConfig(configPath: string, updates: Record<string, string>): void {
+  let lines: string[] = [];
+
+  // Read existing config if it exists
+  if (fs.existsSync(configPath)) {
+    const stats = fs.statSync(configPath);
+    if (!stats.isDirectory()) {
+      const content = fs.readFileSync(configPath, "utf8");
+      lines = content.split(/\r?\n/).filter(l => l.trim() !== "");
+    }
+  }
+
+  // Update or add each key
+  for (const [key, value] of Object.entries(updates)) {
+    const existingIndex = lines.findIndex(l => l.startsWith(key + "="));
+    if (existingIndex >= 0) {
+      lines[existingIndex] = `${key}=${value}`;
+    } else {
+      lines.push(`${key}=${value}`);
+    }
+  }
+
+  fs.writeFileSync(configPath, lines.join("\n") + "\n", { encoding: "utf8", mode: 0o600 });
+}
+
 /**
  * Run docker compose command
  */
@@ -2145,12 +2237,13 @@ mon
   .option("--api-key <key>", "Postgres AI API key for automated report uploads")
   .option("--db-url <url>", "PostgreSQL connection URL to monitor")
   .option("--tag <tag>", "Docker image tag to use (e.g., 0.14.0, 0.14.0-dev.33)")
+  .option("--project <name>", "Docker Compose project name (default: postgres_ai)")
   .option("-y, --yes", "accept all defaults and skip interactive prompts", false)
-  .action(async (opts: { demo: boolean; apiKey?: string; dbUrl?: string; tag?: string; yes: boolean }) => {
+  .action(async (opts: { demo: boolean; apiKey?: string; dbUrl?: string; tag?: string; project?: string; yes: boolean }) => {
     // Get apiKey from global program options (--api-key is defined globally)
     // This is needed because Commander.js routes --api-key to the global option, not the subcommand's option
     const globalOpts = program.opts<CliOptions>();
-    const apiKey = opts.apiKey || globalOpts.apiKey;
+    let apiKey = opts.apiKey || globalOpts.apiKey;
 
     console.log("\n=================================");
     console.log("  PostgresAI monitoring local install");
@@ -2161,6 +2254,13 @@ mon
     const { projectDir } = await resolveOrInitPaths();
     console.log(`Project directory: ${projectDir}\n`);
 
+    // Save project name to .pgwatch-config if provided (used by reporter container)
+    if (opts.project) {
+      const cfgPath = path.resolve(projectDir, ".pgwatch-config");
+      updatePgwatchConfig(cfgPath, { project_name: opts.project });
+      console.log(`Using project name: ${opts.project}\n`);
+    }
+
     // Update .env with custom tag if provided
     const envFile = path.resolve(projectDir, ".env");
 
@@ -2230,10 +2330,7 @@ mon
         console.log("Using API key provided via --api-key parameter");
         config.writeConfig({ apiKey });
         // Keep reporter compatibility (docker-compose mounts .pgwatch-config)
-        fs.writeFileSync(path.resolve(projectDir, ".pgwatch-config"), `api_key=${apiKey}\n`, {
-          encoding: "utf8",
-          mode: 0o600
-        });
+        updatePgwatchConfig(path.resolve(projectDir, ".pgwatch-config"), { api_key: apiKey });
         console.log("✓ API key saved\n");
       } else if (opts.yes) {
         // Auto-yes mode without API key - skip API key setup
@@ -2252,10 +2349,8 @@ mon
             if (trimmedKey) {
               config.writeConfig({ apiKey: trimmedKey });
               // Keep reporter compatibility (docker-compose mounts .pgwatch-config)
-              fs.writeFileSync(path.resolve(projectDir, ".pgwatch-config"), `api_key=${trimmedKey}\n`, {
-                encoding: "utf8",
-                mode: 0o600
-              });
+              updatePgwatchConfig(path.resolve(projectDir, ".pgwatch-config"), { api_key: trimmedKey });
+              apiKey = trimmedKey;  // Update for later use in registerMonitoringInstance
               console.log("✓ API key saved\n");
               break;
             }
@@ -2442,6 +2537,15 @@ mon
     }
     console.log("✓ Services started\n");
 
+    // Register monitoring instance with API (non-blocking, only if API key is configured)
+    if (apiKey && !opts.demo) {
+      const projectName = opts.project || "postgres-ai-monitoring";
+      registerMonitoringInstance(apiKey, projectName, {
+        apiBaseUrl: globalOpts.apiBaseUrl,
+        debug: !!process.env.DEBUG,
+      });
+    }
+
     // Final summary
     console.log("=================================");
     console.log("  Local install completed!");
@@ -4087,6 +4191,228 @@ issues
     }
   });
 
+// Reports management
+const reports = program.command("reports").description("checkup reports management");
+
+reports
+  .command("list")
+  .description("list checkup reports")
+  .option("--project-id <id>", "filter by project id", (v: string) => parseInt(v, 10))
+  .option("--status <status>", "filter by status (e.g., completed)")
+  .option("--limit <n>", "max number of reports to return (default: 20)", (v: string) => parseInt(v, 10))
+  .option("--before <date>", "show reports created before this date (YYYY-MM-DD, DD.MM.YYYY, etc.)")
+  .option("--all", "fetch all reports (paginated automatically)")
+  .option("--debug", "enable debug output")
+  .option("--json", "output raw JSON")
+  .action(async (opts: { projectId?: number; status?: string; limit?: number; before?: string; all?: boolean; debug?: boolean; json?: boolean }) => {
+    const spinner = createTtySpinner(process.stdout.isTTY ?? false, "Fetching reports...");
+    try {
+      const rootOpts = program.opts<CliOptions>();
+      const cfg = config.readConfig();
+      const { apiKey } = getConfig(rootOpts);
+      if (!apiKey) {
+        spinner.stop();
+        console.error("API key is required. Run 'pgai auth' first or set --api-key.");
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.all && opts.before) {
+        spinner.stop();
+        console.error("--all and --before cannot be used together");
+        process.exitCode = 1;
+        return;
+      }
+      const { apiBaseUrl } = resolveBaseUrls(rootOpts, cfg);
+
+      let result;
+      if (opts.all) {
+        result = await fetchAllReports({
+          apiKey,
+          apiBaseUrl,
+          projectId: opts.projectId,
+          status: opts.status,
+          limit: opts.limit,
+          debug: !!opts.debug,
+        });
+      } else {
+        result = await fetchReports({
+          apiKey,
+          apiBaseUrl,
+          projectId: opts.projectId,
+          status: opts.status,
+          limit: opts.limit,
+          beforeDate: opts.before ? parseFlexibleDate(opts.before) : undefined,
+          debug: !!opts.debug,
+        });
+      }
+      spinner.stop();
+      printResult(result, opts.json);
+    } catch (err) {
+      spinner.stop();
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(message);
+      process.exitCode = 1;
+    }
+  });
+
+reports
+  .command("files [reportId]")
+  .description("list files of a checkup report (metadata only, no content)")
+  .option("--type <type>", "filter by file type: json, md")
+  .option("--check-id <id>", "filter by check ID (e.g., H002)")
+  .option("--debug", "enable debug output")
+  .option("--json", "output raw JSON")
+  .action(async (reportId: string | undefined, opts: { type?: "json" | "md"; checkId?: string; debug?: boolean; json?: boolean }) => {
+    const spinner = createTtySpinner(process.stdout.isTTY ?? false, "Fetching report files...");
+    try {
+      const rootOpts = program.opts<CliOptions>();
+      const cfg = config.readConfig();
+      const { apiKey } = getConfig(rootOpts);
+      if (!apiKey) {
+        spinner.stop();
+        console.error("API key is required. Run 'pgai auth' first or set --api-key.");
+        process.exitCode = 1;
+        return;
+      }
+      let numericId: number | undefined;
+      if (reportId !== undefined) {
+        numericId = parseInt(reportId, 10);
+        if (isNaN(numericId)) {
+          spinner.stop();
+          console.error("reportId must be a number");
+          process.exitCode = 1;
+          return;
+        }
+      }
+      if (numericId === undefined && !opts.checkId) {
+        spinner.stop();
+        console.error("Either reportId or --check-id is required");
+        process.exitCode = 1;
+        return;
+      }
+      const { apiBaseUrl } = resolveBaseUrls(rootOpts, cfg);
+
+      const result = await fetchReportFiles({
+        apiKey,
+        apiBaseUrl,
+        reportId: numericId,
+        type: opts.type,
+        checkId: opts.checkId,
+        debug: !!opts.debug,
+      });
+      spinner.stop();
+      printResult(result, opts.json);
+    } catch (err) {
+      spinner.stop();
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(message);
+      process.exitCode = 1;
+    }
+  });
+
+reports
+  .command("data [reportId]")
+  .description("get checkup report file data (includes content)")
+  .option("--type <type>", "filter by file type: json, md")
+  .option("--check-id <id>", "filter by check ID (e.g., H002)")
+  .option("--formatted", "render markdown with ANSI styling (experimental)")
+  .option("-o, --output <dir>", "save files to directory (uses original filenames)")
+  .option("--debug", "enable debug output")
+  .option("--json", "output raw JSON")
+  .action(async (reportId: string | undefined, opts: { type?: "json" | "md"; checkId?: string; formatted?: boolean; output?: string; debug?: boolean; json?: boolean }) => {
+    const spinner = createTtySpinner(process.stdout.isTTY ?? false, "Fetching report data...");
+    try {
+      const rootOpts = program.opts<CliOptions>();
+      const cfg = config.readConfig();
+      const { apiKey } = getConfig(rootOpts);
+      if (!apiKey) {
+        spinner.stop();
+        console.error("API key is required. Run 'pgai auth' first or set --api-key.");
+        process.exitCode = 1;
+        return;
+      }
+      let numericId: number | undefined;
+      if (reportId !== undefined) {
+        numericId = parseInt(reportId, 10);
+        if (isNaN(numericId)) {
+          spinner.stop();
+          console.error("reportId must be a number");
+          process.exitCode = 1;
+          return;
+        }
+      }
+      if (numericId === undefined && !opts.checkId) {
+        spinner.stop();
+        console.error("Either reportId or --check-id is required");
+        process.exitCode = 1;
+        return;
+      }
+      const { apiBaseUrl } = resolveBaseUrls(rootOpts, cfg);
+
+      // Default to "md" for terminal output (human-readable); --json and --output get all types
+      const effectiveType = opts.type ?? (!opts.json && !opts.output ? "md" as const : undefined);
+      const result = await fetchReportFileData({
+        apiKey,
+        apiBaseUrl,
+        reportId: numericId,
+        type: effectiveType,
+        checkId: opts.checkId,
+        debug: !!opts.debug,
+      });
+      spinner.stop();
+
+      if (opts.output) {
+        const dir = path.resolve(opts.output);
+        fs.mkdirSync(dir, { recursive: true });
+        for (const f of result) {
+          const safeName = path.basename(f.filename);
+          const filePath = path.join(dir, safeName);
+          const content = f.type === "json"
+            ? JSON.stringify(tryParseJson(f.data), null, 2)
+            : f.data;
+          fs.writeFileSync(filePath, content, "utf-8");
+          console.log(filePath);
+        }
+      } else if (opts.json) {
+        const processed = result.map((f) => ({
+          ...f,
+          data: f.type === "json" ? tryParseJson(f.data) : f.data,
+        }));
+        printResult(processed, true);
+      } else if (opts.formatted && process.stdout.isTTY) {
+        for (const f of result) {
+          if (result.length > 1) {
+            console.log(`\x1b[1m--- ${f.filename} (${f.check_id}, ${f.type}) ---\x1b[0m`);
+          }
+          if (f.type === "md") {
+            console.log(renderMarkdownForTerminal(f.data));
+          } else if (f.type === "json") {
+            const parsed = tryParseJson(f.data);
+            console.log(typeof parsed === "string" ? parsed : JSON.stringify(parsed, null, 2));
+          } else {
+            console.log(f.data);
+          }
+        }
+      } else {
+        for (const f of result) {
+          if (result.length > 1) {
+            console.log(`--- ${f.filename} (${f.check_id}, ${f.type}) ---`);
+          }
+          console.log(f.data);
+        }
+      }
+    } catch (err) {
+      spinner.stop();
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(message);
+      process.exitCode = 1;
+    }
+  });
+
+function tryParseJson(s: string): unknown {
+  try { return JSON.parse(s); } catch { return s; }
+}
+
 // MCP server
 const mcp = program.command("mcp").description("MCP server integration");