postgresai 0.16.0-dev.0 → 0.16.0-dev.10

package/test/monitoring.test.ts

@@ -19,6 +19,7 @@ import {
 import {
   registerMonitoringInstance,
   resolveAdoptedProject,
+  planMonitoringRegistration,
 } from "../bin/postgres-ai";
 
 /**
@@ -241,12 +242,13 @@ describe("registerMonitoringInstance", () => {
   });
 
   // Issue platform-all#311: console-provisioned installs pass instance_id so
-  // the platform adopts the provisioned instance instead of self-registering
-  // a duplicate under an auto-created "postgres-ai-monitoring" project.
+  // the platform adopts the provisioned instance and returns its real project
+  // — the CLI sends NO project_name on the adopt path (the hardcoded
+  // "postgres-ai-monitoring" default was removed).
   test("includes instance_id in body when adopting a provisioned instance", async () => {
     const instanceId = "019eb300-3f2a-7a75-b54d-4f10572b25b8";
 
-    await registerMonitoringInstance("key", "postgres-ai-monitoring", opts({ instanceId }));
+    await registerMonitoringInstance("key", undefined, opts({ instanceId }));
 
     const body = JSON.parse(fetchCalls[0].options.body as string);
     expect(body.instance_id).toBe(instanceId);
@@ -255,6 +257,22 @@ describe("registerMonitoringInstance", () => {
     expect(headers["instance-id"]).toBeUndefined();
   });
 
+  test("omits project_name from the body when undefined (adopt path)", async () => {
+    await registerMonitoringInstance("key", undefined, opts({ instanceId: "i" }));
+
+    const body = JSON.parse(fetchCalls[0].options.body as string);
+    // The adopt path sends no name; the platform returns the real project.
+    expect("project_name" in body).toBe(false);
+    expect(body.api_token).toBe("key");
+  });
+
+  test("omits project_name from the body when empty/whitespace", async () => {
+    await registerMonitoringInstance("key", "   ", opts({ instanceId: "i" }));
+
+    const body = JSON.parse(fetchCalls[0].options.body as string);
+    expect("project_name" in body).toBe(false);
+  });
+
   test("omits instance_id from the body for legacy self-registration", async () => {
     await registerMonitoringInstance("key", "my-project", opts());
 
@@ -262,6 +280,8 @@ describe("registerMonitoringInstance", () => {
     // PostgREST matches the 3-arg function via its default — the key must be
     // ABSENT (not null) so legacy CLIs and the new one hit the same overload.
     expect("instance_id" in body).toBe(false);
+    // A real project name still rides in the body for legacy registration.
+    expect(body.project_name).toBe("my-project");
   });
 
   test("a 200 with {project_id, project_name} returns a populated result", async () => {
@@ -323,6 +343,37 @@ describe("registerMonitoringInstance", () => {
   });
 });
 
+describe("planMonitoringRegistration — mon local-install registration decision", () => {
+  test("instance id present → adopt, no project name required", () => {
+    const plan = planMonitoringRegistration({ instanceId: "i-123" });
+    expect(plan.kind).toBe("adopt");
+    expect(plan.projectName).toBeUndefined();
+  });
+
+  test("instance id present + project → adopt, carries the trimmed name", () => {
+    const plan = planMonitoringRegistration({ instanceId: "i-123", project: "  prod-db  " });
+    expect(plan.kind).toBe("adopt");
+    expect(plan.projectName).toBe("prod-db");
+  });
+
+  test("no instance id + no project → error-missing-project (exit 1 path)", () => {
+    const plan = planMonitoringRegistration({});
+    expect(plan.kind).toBe("error-missing-project");
+    expect(plan.projectName).toBeUndefined();
+  });
+
+  test("no instance id + empty/whitespace project → error-missing-project", () => {
+    expect(planMonitoringRegistration({ project: "" }).kind).toBe("error-missing-project");
+    expect(planMonitoringRegistration({ project: "   " }).kind).toBe("error-missing-project");
+  });
+
+  test("no instance id + real project → legacy self-register with the trimmed name", () => {
+    const plan = planMonitoringRegistration({ project: "  my-project  " });
+    expect(plan.kind).toBe("self-register");
+    expect(plan.projectName).toBe("my-project");
+  });
+});
+
 describe("resolveAdoptedProject — what gets persisted to .pgwatch-config", () => {
   test("prefers the numeric project_id over the name (survives renames)", () => {
     expect(resolveAdoptedProject({ projectId: 42, projectName: "prod-db" })).toBe("42");

package/test/util.test.ts

@@ -1,6 +1,31 @@
 import { describe, expect, test } from "bun:test";
 
-import { formatHttpError } from "../lib/util";
+import { formatHttpError, describeFetchError, redactSecretsForLog } from "../lib/util";
+
+describe("describeFetchError", () => {
+  test("surfaces the connection cause + url instead of a bare 'fetch failed'", () => {
+    // Node's fetch (undici) throws TypeError('fetch failed') and stashes the real
+    // reason (ECONNREFUSED etc.) in err.cause — the CLI must surface it, not the
+    // opaque top-level message.
+    const err = Object.assign(new TypeError("fetch failed"), {
+      cause: { code: "ECONNREFUSED", message: "connect ECONNREFUSED 127.0.0.1:1" },
+    });
+    const msg = describeFetchError("Failed to list projects", "http://127.0.0.1:1", err);
+    expect(msg).toContain("Failed to list projects");
+    expect(msg).toContain("could not reach http://127.0.0.1:1");
+    expect(msg).toContain("ECONNREFUSED");
+    expect(msg).not.toBe("fetch failed");
+  });
+
+  test("falls back to cause.message, then to the error message", () => {
+    const withMsg = Object.assign(new TypeError("fetch failed"), {
+      cause: { message: "bad port" },
+    });
+    expect(describeFetchError("op", "http://h:1", withMsg)).toContain("bad port");
+    const bare = new Error("boom");
+    expect(describeFetchError("op", "http://h", bare)).toContain("boom");
+  });
+});
 
 describe("formatHttpError", () => {
   test("appends auth remediation hint on 401 with JSON body", () => {
@@ -41,4 +66,89 @@ describe("formatHttpError", () => {
     expect(msg.indexOf("Invalid token")).toBeGreaterThan(-1);
     expect(msg.indexOf("Invalid token")).toBeLessThan(msg.indexOf("Run 'postgresai auth'"));
   });
+
+  // PostgREST v9's PTxyz custom-status convention carries the RPC's user-facing
+  // `message` in the HTTP reason phrase (statusText); the JSON body holds only
+  // `hint`/`details` (no `message`/`code`). The formatter must surface the
+  // reason phrase as the headline instead of a hardcoded generic label, and
+  // still show the `details` (plural) line.
+  test("surfaces the PostgREST PTxyz reason-phrase message, not a generic label", () => {
+    const msg = formatHttpError(
+      "Failed to submit plan command",
+      403,
+      '{"hint":null,"details":"The LLM-facing Joe surface is gated on the organization\'s ai_enabled setting."}',
+      "AI features disabled for this org — enable in AI Assistant Settings"
+    );
+
+    expect(msg).toContain("HTTP 403");
+    expect(msg).toContain("AI features disabled for this org — enable in AI Assistant Settings");
+    // the real reason must not be masked by the hardcoded generic label
+    expect(msg).not.toContain("Forbidden - access denied");
+    // the supplementary `details` (plural) line is still shown
+    expect(msg).toContain("gated on the organization's ai_enabled setting");
+    // and we never dump the raw JSON object
+    expect(msg).not.toContain('"hint"');
+  });
+
+  test("prefers a JSON body `message` over the reason phrase when both exist", () => {
+    const msg = formatHttpError("op", 400, '{"message":"real message","details":"more"}', "Bad Request");
+    expect(msg).toContain("real message");
+    expect(msg).toContain("more");
+  });
+
+  test("falls back to the generic label for a standard (non-custom) reason phrase", () => {
+    // a bare standard reason phrase must not replace the friendlier generic label
+    const msg = formatHttpError("op", 403, undefined, "Forbidden");
+    expect(msg).toContain("Forbidden - access denied");
+  });
+});
+
+describe("redactSecretsForLog", () => {
+  test("redacts password-named keys at any depth (request body shape)", () => {
+    const body = JSON.stringify({
+      instance_id: "7",
+      action: "/clone",
+      method: "post",
+      data: { protected: false, db: { username: "clone_user", password: "hunter2" } },
+    });
+    const out = redactSecretsForLog(body);
+    expect(out).not.toContain("hunter2");
+    expect(out).toContain('"password":"[REDACTED]"');
+    // Non-secret fields survive untouched.
+    expect(out).toContain('"username":"clone_user"');
+    expect(out).toContain('"action":"/clone"');
+  });
+
+  test("redacts connStr and password in response bodies (clone create/status shape)", () => {
+    const reply = JSON.stringify({
+      id: "c1",
+      db: { connStr: "host=h port=6002 user=joe password=pw-xyz", password: "pw-xyz", username: "joe" },
+    });
+    const out = redactSecretsForLog(reply);
+    expect(out).not.toContain("pw-xyz");
+    expect(out).toContain('"connStr":"[REDACTED]"');
+    expect(out).toContain('"username":"joe"');
+  });
+
+  test("matches key variants case-insensitively (Password, DB_PASSWORD, dbPassword, connstr)", () => {
+    const out = redactSecretsForLog(
+      JSON.stringify({ Password: "a", DB_PASSWORD: "b", dbPassword: "c", connstr: "d", ok: "keep" })
+    );
+    expect(out).not.toContain('"a"');
+    expect(out).not.toContain('"b"');
+    expect(out).not.toContain('"c"');
+    expect(out).not.toContain('"d"');
+    expect(out).toContain('"ok":"keep"');
+  });
+
+  test("traverses arrays (e.g. result rows carrying a password column)", () => {
+    const out = redactSecretsForLog(JSON.stringify({ rows: [{ usename: "app", password: "s3cr3t" }] }));
+    expect(out).not.toContain("s3cr3t");
+    expect(out).toContain('"usename":"app"');
+  });
+
+  test("keeps null secrets as null (shape stays readable) and passes non-JSON through", () => {
+    expect(redactSecretsForLog(JSON.stringify({ password: null }))).toContain('"password":null');
+    expect(redactSecretsForLog("plain text, not json")).toBe("plain text, not json");
+  });
 });