postgresai 0.14.0-dev.36 → 0.14.0-dev.38

package/dist/bin/postgres-ai.js

@@ -51,8 +51,61 @@ const mcp_server_1 = require("../lib/mcp-server");
 const issues_1 = require("../lib/issues");
 const util_2 = require("../lib/util");
 const init_1 = require("../lib/init");
+const checkup_1 = require("../lib/checkup");
+const checkup_api_1 = require("../lib/checkup-api");
 const execPromise = (0, util_1.promisify)(child_process_1.exec);
 const execFilePromise = (0, util_1.promisify)(child_process_1.execFile);
+function expandHomePath(p) {
+    const s = (p || "").trim();
+    if (!s)
+        return s;
+    if (s === "~")
+        return os.homedir();
+    if (s.startsWith("~/") || s.startsWith("~\\")) {
+        return path.join(os.homedir(), s.slice(2));
+    }
+    return s;
+}
+function createTtySpinner(enabled, initialText) {
+    if (!enabled) {
+        return {
+            update: () => { },
+            stop: () => { },
+        };
+    }
+    const frames = ["|", "/", "-", "\\"];
+    const startTs = Date.now();
+    let text = initialText;
+    let frameIdx = 0;
+    let stopped = false;
+    const render = () => {
+        if (stopped)
+            return;
+        const elapsedSec = ((Date.now() - startTs) / 1000).toFixed(1);
+        const frame = frames[frameIdx % frames.length];
+        frameIdx += 1;
+        process.stdout.write(`\r\x1b[2K${frame} ${text} (${elapsedSec}s)`);
+    };
+    const timer = setInterval(render, 120);
+    render(); // immediate feedback
+    return {
+        update: (t) => {
+            text = t;
+            render();
+        },
+        stop: (finalText) => {
+            if (stopped)
+                return;
+            stopped = true;
+            clearInterval(timer);
+            process.stdout.write("\r\x1b[2K");
+            if (finalText && finalText.trim()) {
+                process.stdout.write(finalText);
+            }
+            process.stdout.write("\n");
+        },
+    };
+}
 function getDefaultMonitoringProjectDir() {
     const override = process.env.PGAI_PROJECT_DIR;
     if (override && override.trim())
@@ -175,8 +228,21 @@ program
     .option("--api-base-url <url>", "API base URL for backend RPC (overrides PGAI_API_BASE_URL)")
     .option("--ui-base-url <url>", "UI base URL for browser routes (overrides PGAI_UI_BASE_URL)");
 program
-    .command("init [conn]")
-    .description("Create a monitoring user, required view(s), and grant required permissions (idempotent)")
+    .command("set-default-project <project>")
+    .description("store default project for checkup uploads")
+    .action(async (project) => {
+    const value = (project || "").trim();
+    if (!value) {
+        console.error("Error: project is required");
+        process.exitCode = 1;
+        return;
+    }
+    config.writeConfig({ defaultProject: value });
+    console.log(`Default project saved: ${value}`);
+});
+program
+    .command("prepare-db [conn]")
+    .description("Prepare database for monitoring: create monitoring user, required view(s), and grant permissions (idempotent)")
     .option("--db-url <url>", "PostgreSQL connection URL (admin) to run the setup against (deprecated; pass it as positional arg)")
     .option("-h, --host <host>", "PostgreSQL host (psql-like)")
     .option("-p, --port <port>", "PostgreSQL port (psql-like)")
@@ -193,9 +259,9 @@ program
     .addHelpText("after", [
     "",
     "Examples:",
-    "  postgresai init postgresql://admin@host:5432/dbname",
-    "  postgresai init \"dbname=dbname host=host user=admin\"",
-    "  postgresai init -h host -p 5432 -U admin -d dbname",
+    "  postgresai prepare-db postgresql://admin@host:5432/dbname",
+    "  postgresai prepare-db \"dbname=dbname host=host user=admin\"",
+    "  postgresai prepare-db -h host -p 5432 -U admin -d dbname",
     "",
     "Admin password:",
     "  --admin-password <password>   or  PGPASSWORD=... (libpq standard)",
@@ -217,16 +283,16 @@ program
     "  PGAI_MON_PASSWORD                   — monitoring password",
     "",
     "Inspect SQL without applying changes:",
-    "  postgresai init <conn> --print-sql",
+    "  postgresai prepare-db <conn> --print-sql",
     "",
     "Verify setup (no changes):",
-    "  postgresai init <conn> --verify",
+    "  postgresai prepare-db <conn> --verify",
     "",
     "Reset monitoring password only:",
-    "  postgresai init <conn> --reset-password --password '...'",
+    "  postgresai prepare-db <conn> --reset-password --password '...'",
     "",
     "Offline SQL plan (no DB connection):",
-    "  postgresai init --print-sql",
+    "  postgresai prepare-db --print-sql",
 ].join("\n"))
     .action(async (conn, opts, cmd) => {
     if (opts.verify && opts.resetPassword) {
@@ -285,7 +351,7 @@ program
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        console.error(`Error: init: ${msg}`);
+        console.error(`Error: prepare-db: ${msg}`);
         // When connection details are missing, show full init help (options + examples).
         if (typeof msg === "string" && msg.startsWith("Connection is required.")) {
             console.error("");
@@ -316,7 +382,7 @@ program
                 includeOptionalPermissions,
             });
             if (v.ok) {
-                console.log("✓ init verify: OK");
+                console.log("✓ prepare-db verify: OK");
                 if (v.missingOptional.length > 0) {
                     console.log("⚠ Optional items missing:");
                     for (const m of v.missingOptional)
@@ -324,7 +390,7 @@ program
                 }
                 return;
             }
-            console.error("✗ init verify failed: missing required items");
+            console.error("✗ prepare-db verify failed: missing required items");
             for (const m of v.missingRequired)
                 console.error(`- ${m}`);
             if (v.missingOptional.length > 0) {
@@ -396,7 +462,7 @@ program
             return;
         }
         const { applied, skippedOptional } = await (0, init_1.applyInitPlan)({ client, plan: effectivePlan });
-        console.log(opts.resetPassword ? "✓ init password reset completed" : "✓ init completed");
+        console.log(opts.resetPassword ? "✓ prepare-db password reset completed" : "✓ prepare-db completed");
         if (skippedOptional.length > 0) {
             console.log("⚠ Some optional steps were skipped (not supported or insufficient privileges):");
             for (const s of skippedOptional)
@@ -422,7 +488,7 @@ program
         if (!message || message === "[object Object]") {
             message = "Unknown error";
         }
-        console.error(`Error: init: ${message}`);
+        console.error(`Error: prepare-db: ${message}`);
         // If this was a plan step failure, surface the step name explicitly to help users diagnose quickly.
         const stepMatch = typeof message === "string" ? message.match(/Failed at step "([^"]+)":/i) : null;
         const failedStep = stepMatch?.[1];
@@ -475,6 +541,233 @@ program
         }
     }
 });
+program
+    .command("checkup [conn]")
+    .description("generate health check reports directly from PostgreSQL (express mode)")
+    .option("--check-id <id>", `specific check to run: ${Object.keys(checkup_1.CHECK_INFO).join(", ")}, or ALL`, "ALL")
+    .option("--node-name <name>", "node name for reports", "node-01")
+    .option("--output <path>", "output directory for JSON files")
+    .option("--json", "output to stdout as JSON instead of files")
+    .option("--upload", "create a remote checkup report and upload JSON results (requires API key)", false)
+    .option("--project <project>", "project name or ID for remote upload (used with --upload; defaults to config defaultProject)")
+    .addHelpText("after", [
+    "",
+    "Available checks:",
+    ...Object.entries(checkup_1.CHECK_INFO).map(([id, title]) => `  ${id}: ${title}`),
+    "",
+    "Examples:",
+    "  postgresai checkup postgresql://user:pass@host:5432/db",
+    "  postgresai checkup postgresql://user:pass@host:5432/db --check-id A003",
+    "  postgresai checkup postgresql://user:pass@host:5432/db --json",
+    "  postgresai checkup postgresql://user:pass@host:5432/db --output ./reports",
+    "  postgresai checkup postgresql://user:pass@host:5432/db --upload --project my_project",
+    "  postgresai set-default-project my_project",
+    "  postgresai checkup postgresql://user:pass@host:5432/db --upload",
+].join("\n"))
+    .action(async (conn, opts, cmd) => {
+    if (!conn) {
+        // No args — show help like other commands do (instead of a bare error).
+        cmd.outputHelp();
+        process.exitCode = 1;
+        return;
+    }
+    // Preflight: validate/create output directory BEFORE connecting / running checks.
+    // This avoids waiting on network/DB work only to fail at the very end.
+    let outputPath;
+    if (opts.output && !opts.json) {
+        const outputDir = expandHomePath(opts.output);
+        outputPath = path.isAbsolute(outputDir) ? outputDir : path.resolve(process.cwd(), outputDir);
+        if (!fs.existsSync(outputPath)) {
+            try {
+                fs.mkdirSync(outputPath, { recursive: true });
+            }
+            catch (e) {
+                const errAny = e;
+                const code = typeof errAny?.code === "string" ? errAny.code : "";
+                const msg = errAny instanceof Error ? errAny.message : String(errAny);
+                if (code === "EACCES" || code === "EPERM" || code === "ENOENT") {
+                    console.error(`Error: Failed to create output directory: ${outputPath}`);
+                    console.error(`Reason: ${msg}`);
+                    console.error("Tip: choose a writable path, e.g. --output ./reports or --output ~/reports");
+                    process.exitCode = 1;
+                    return;
+                }
+                throw e;
+            }
+        }
+    }
+    // Preflight: validate upload flags/credentials BEFORE connecting / running checks.
+    // This allows "fast-fail" for missing API key / project name.
+    let uploadCfg;
+    if (opts.upload) {
+        const rootOpts = program.opts();
+        const { apiKey } = getConfig(rootOpts);
+        if (!apiKey) {
+            console.error("Error: API key is required for --upload");
+            console.error("Tip: run 'postgresai auth' or pass --api-key / set PGAI_API_KEY");
+            process.exitCode = 1;
+            return;
+        }
+        const cfg = config.readConfig();
+        const { apiBaseUrl } = (0, util_2.resolveBaseUrls)(rootOpts, cfg);
+        const project = ((opts.project || cfg.defaultProject) || "").trim();
+        if (!project) {
+            console.error("Error: --project is required (or set a default via 'postgresai set-default-project <project>')");
+            process.exitCode = 1;
+            return;
+        }
+        const epoch = Math.floor(Date.now() / 1000);
+        uploadCfg = {
+            apiKey,
+            apiBaseUrl,
+            project,
+            epoch,
+        };
+    }
+    // Use the same SSL behavior as prepare-db:
+    // - Default: sslmode=prefer (try SSL first, fallback to non-SSL)
+    // - Respect PGSSLMODE env and ?sslmode=... in connection URI
+    const adminConn = (0, init_1.resolveAdminConnection)({
+        conn,
+        envPassword: process.env.PGPASSWORD,
+    });
+    let client;
+    const spinnerEnabled = !!process.stdout.isTTY && !opts.json;
+    const spinner = createTtySpinner(spinnerEnabled, "Connecting to Postgres");
+    try {
+        spinner.update("Connecting to Postgres");
+        const connResult = await (0, init_1.connectWithSslFallback)(pg_1.Client, adminConn);
+        client = connResult.client;
+        let reports;
+        let uploadSummary;
+        if (opts.checkId === "ALL") {
+            reports = await (0, checkup_1.generateAllReports)(client, opts.nodeName, (p) => {
+                spinner.update(`Running ${p.checkId}: ${p.checkTitle} (${p.index}/${p.total})`);
+            });
+        }
+        else {
+            const checkId = opts.checkId.toUpperCase();
+            const generator = checkup_1.REPORT_GENERATORS[checkId];
+            if (!generator) {
+                spinner.stop();
+                console.error(`Unknown check ID: ${opts.checkId}`);
+                console.error(`Available: ${Object.keys(checkup_1.CHECK_INFO).join(", ")}, ALL`);
+                process.exitCode = 1;
+                return;
+            }
+            spinner.update(`Running ${checkId}: ${checkup_1.CHECK_INFO[checkId] || checkId}`);
+            reports = { [checkId]: await generator(client, opts.nodeName) };
+        }
+        // Optional: upload to PostgresAI API.
+        if (uploadCfg) {
+            spinner.update("Creating remote checkup report");
+            const created = await (0, checkup_api_1.createCheckupReport)({
+                apiKey: uploadCfg.apiKey,
+                apiBaseUrl: uploadCfg.apiBaseUrl,
+                project: uploadCfg.project,
+                epoch: uploadCfg.epoch,
+            });
+            const reportId = created.reportId;
+            // Keep upload progress out of stdout when --json is used.
+            const logUpload = (msg) => {
+                if (opts.json)
+                    console.error(msg);
+            };
+            logUpload(`Created remote checkup report: ${reportId}`);
+            const uploaded = [];
+            for (const [checkId, report] of Object.entries(reports)) {
+                spinner.update(`Uploading ${checkId}.json`);
+                const jsonText = JSON.stringify(report, null, 2);
+                const r = await (0, checkup_api_1.uploadCheckupReportJson)({
+                    apiKey: uploadCfg.apiKey,
+                    apiBaseUrl: uploadCfg.apiBaseUrl,
+                    reportId,
+                    filename: `${checkId}.json`,
+                    checkId,
+                    jsonText,
+                });
+                uploaded.push({ checkId, filename: `${checkId}.json`, chunkId: r.reportChunkId });
+            }
+            logUpload("Upload completed");
+            uploadSummary = { project: uploadCfg.project, reportId, uploaded };
+        }
+        spinner.stop();
+        // Output results
+        if (opts.json) {
+            console.log(JSON.stringify(reports, null, 2));
+        }
+        else if (opts.output) {
+            // Write to files
+            // outputPath is preflight-validated above
+            const outDir = outputPath || path.resolve(process.cwd(), expandHomePath(opts.output));
+            for (const [checkId, report] of Object.entries(reports)) {
+                const filePath = path.join(outDir, `${checkId}.json`);
+                fs.writeFileSync(filePath, JSON.stringify(report, null, 2), "utf8");
+                console.log(`✓ ${checkId}: ${filePath}`);
+            }
+        }
+        else if (uploadSummary) {
+            // Default with --upload: show upload result instead of local-only summary.
+            console.log("\nCheckup report uploaded");
+            console.log("======================\n");
+            console.log(`Project: ${uploadSummary.project}`);
+            console.log(`Report ID: ${uploadSummary.reportId}`);
+            console.log("View in Console: console.postgres.ai → Support → checkup reports");
+            console.log("");
+            console.log("Files:");
+            for (const item of uploadSummary.uploaded) {
+                console.log(`- ${item.checkId}: ${item.filename}`);
+            }
+        }
+        else {
+            // Default: print summary
+            console.log("\nHealth Check Reports Generated:");
+            console.log("================================\n");
+            for (const [checkId, report] of Object.entries(reports)) {
+                const r = report;
+                console.log(`${checkId}: ${r.checkTitle}`);
+                if (r.results && r.results[opts.nodeName]) {
+                    const nodeData = r.results[opts.nodeName];
+                    if (nodeData.postgres_version) {
+                        console.log(`  PostgreSQL: ${nodeData.postgres_version.version}`);
+                    }
+                    if (checkId === "A007" && nodeData.data) {
+                        const count = Object.keys(nodeData.data).length;
+                        console.log(`  Altered settings: ${count}`);
+                    }
+                    if (checkId === "A004" && nodeData.data) {
+                        if (nodeData.data.database_sizes) {
+                            const dbCount = Object.keys(nodeData.data.database_sizes).length;
+                            console.log(`  Databases: ${dbCount}`);
+                        }
+                        if (nodeData.data.general_info?.cache_hit_ratio) {
+                            console.log(`  Cache hit ratio: ${nodeData.data.general_info.cache_hit_ratio.value}%`);
+                        }
+                    }
+                }
+            }
+            console.log("\nUse --json for full output or --output <dir> to save files");
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        if (error instanceof checkup_api_1.RpcError) {
+            for (const line of (0, checkup_api_1.formatRpcErrorForDisplay)(error)) {
+                console.error(line);
+            }
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${message}`);
+        }
+        process.exitCode = 1;
+    }
+    finally {
+        if (client) {
+            await client.end();
+        }
+    }
+});
 /**
  * Stub function for not implemented commands
  */
@@ -609,8 +902,8 @@ program.command("help", { isDefault: true }).description("show help").action(()
 // Monitoring services management
 const mon = program.command("mon").description("monitoring services management");
 mon
-    .command("quickstart")
-    .description("complete setup (generate config, start monitoring services)")
+    .command("local-install")
+    .description("install local monitoring stack (generate config, start services)")
     .option("--demo", "demo mode with sample database", false)
     .option("--api-key <key>", "Postgres AI API key for automated report uploads")
     .option("--db-url <url>", "PostgreSQL connection URL to monitor")
@@ -618,7 +911,7 @@ mon
     .option("-y, --yes", "accept all defaults and skip interactive prompts", false)
     .action(async (opts) => {
     console.log("\n=================================");
-    console.log("  PostgresAI Monitoring Quickstart");
+    console.log("  PostgresAI monitoring local install");
     console.log("=================================\n");
     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
@@ -650,8 +943,8 @@ mon
     if (opts.demo && opts.apiKey) {
         console.error("✗ Cannot use --api-key with --demo mode");
         console.error("✗ Demo mode is for testing only and does not support API key integration");
-        console.error("\nUse demo mode without API key: postgres-ai mon quickstart --demo");
-        console.error("Or use production mode with API key: postgres-ai mon quickstart --api-key=your_key");
+        console.error("\nUse demo mode without API key: postgres-ai mon local-install --demo");
+        console.error("Or use production mode with API key: postgres-ai mon local-install --api-key=your_key");
         process.exitCode = 1;
         return;
     }
@@ -893,7 +1186,7 @@ mon
     console.log("✓ Services started\n");
     // Final summary
     console.log("=================================");
-    console.log("  🎉 Quickstart setup completed!");
+    console.log("  Local install completed!");
     console.log("=================================\n");
     console.log("What's running:");
     if (opts.demo) {
@@ -1409,10 +1702,24 @@ targets
 // Authentication and API key management
 program
     .command("auth")
-    .description("authenticate via browser and obtain API key")
+    .description("authenticate via browser (OAuth) or store API key directly")
+    .option("--set-key <key>", "store API key directly without OAuth flow")
     .option("--port <port>", "local callback server port (default: random)", parseInt)
     .option("--debug", "enable debug output")
     .action(async (opts) => {
+    // If --set-key is provided, store it directly without OAuth
+    if (opts.setKey) {
+        const trimmedKey = opts.setKey.trim();
+        if (!trimmedKey) {
+            console.error("Error: API key cannot be empty");
+            process.exitCode = 1;
+            return;
+        }
+        config.writeConfig({ apiKey: trimmedKey });
+        console.log(`API key saved to ${config.getConfigPath()}`);
+        return;
+    }
+    // Otherwise, proceed with OAuth flow
     const pkce = require("../lib/pkce");
     const authServer = require("../lib/auth-server");
     console.log("Starting authentication flow...\n");
@@ -1599,8 +1906,9 @@ program
 });
 program
     .command("add-key <apiKey>")
-    .description("store API key")
+    .description("store API key (deprecated: use 'auth --set-key' instead)")
     .action(async (apiKey) => {
+    console.warn("Warning: 'add-key' is deprecated. Use 'auth --set-key <key>' instead.\n");
     config.writeConfig({ apiKey });
     console.log(`API key saved to ${config.getConfigPath()}`);
 });
@@ -1717,7 +2025,7 @@ mon
     const { projectDir } = await resolveOrInitPaths();
     const cfgPath = path.resolve(projectDir, ".pgwatch-config");
     if (!fs.existsSync(cfgPath)) {
-        console.error("Configuration file not found. Run 'postgres-ai mon quickstart' first.");
+        console.error("Configuration file not found. Run 'postgres-ai mon local-install' first.");
         process.exitCode = 1;
         return;
     }