postgresai 0.16.0-dev.0 → 0.16.0-dev.1

package/dist/bin/postgres-ai.js

@@ -13425,7 +13425,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.16.0-dev.0",
+  version: "0.16.0-dev.1",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -16256,7 +16256,7 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 // package.json
-var version = "0.16.0-dev.0";
+var version = "0.16.0-dev.1";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -28498,7 +28498,7 @@ function grafanaBaseUrl() {
   return (process.env.PGAI_GRAFANA_LOCAL_URL || "http://localhost:3000").replace(/\/+$/, "");
 }
 function grafanaAdminUser() {
-  return process.env.GF_SECURITY_ADMIN_USER || "admin";
+  return process.env.GF_SECURITY_ADMIN_USER || "monitor";
 }
 function parseVcpus(raw) {
   if (raw === undefined || raw === null || raw === "")
@@ -28575,9 +28575,14 @@ async function resolveDatasourceId(adminPassword, debug = false) {
       return null;
     const list = await res.json().catch(() => []);
     const prom = list.filter((d) => d.type === "prometheus");
-    if (prom.length !== 1) {
+    if (prom.length > 1) {
       if (debug)
-        console.error(`Debug: AAS: expected 1 prometheus datasource, found ${prom.length}`);
+        console.error(`Debug: AAS: ${prom.length} prometheus datasources (ambiguous); not retrying`);
+      return "ambiguous";
+    }
+    if (prom.length === 0) {
+      if (debug)
+        console.error(`Debug: AAS: no prometheus datasource resolvable yet`);
       return null;
     }
     return typeof prom[0].id === "number" ? prom[0].id : null;
@@ -28593,7 +28598,23 @@ async function registerAasCollection(apiKey, instanceId, opts) {
     const labels = resolveAasLabels(opts.instancesPath);
     if (!labels)
       return { ok: false, reason: "could not determine a single (cluster, node_name) target" };
-    const datasourceId = await resolveDatasourceId(opts.grafanaPassword, debug);
+    const maxAttempts = opts.datasourceMaxAttempts ?? 20;
+    const retryDelayMs = opts.datasourceRetryDelayMs ?? 3000;
+    let datasourceId = null;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      const resolved = await resolveDatasourceId(opts.grafanaPassword, debug);
+      if (typeof resolved === "number") {
+        datasourceId = resolved;
+        break;
+      }
+      if (resolved === "ambiguous")
+        break;
+      if (attempt < maxAttempts) {
+        if (debug)
+          console.error(`Debug: AAS: datasource not resolvable yet (attempt ${attempt}/${maxAttempts}); waiting for Grafana…`);
+        await new Promise((resolve4) => setTimeout(resolve4, retryDelayMs));
+      }
+    }
     if (datasourceId == null)
       return { ok: false, reason: "could not resolve the Prometheus datasource id" };
     const saToken = await mintAasServiceAccountToken(opts.grafanaPassword, debug);

package/lib/aas-onboard.ts

@@ -28,7 +28,11 @@ function grafanaBaseUrl(): string {
 }
 
 function grafanaAdminUser(): string {
-  return process.env.GF_SECURITY_ADMIN_USER || "admin";
+  // The monitoring stack's compose hardcodes the Grafana admin user to
+  // "monitor" (GF_SECURITY_ADMIN_USER: monitor), so default to that rather than
+  // Grafana's stock "admin" — otherwise AAS arming logs in as the wrong user
+  // and every datasource lookup 401s. An explicit env override still wins.
+  return process.env.GF_SECURITY_ADMIN_USER || "monitor";
 }
 
 /** Parse a vcpus input (flag/env) to a non-negative integer; 0 = "unknown" fallback. */
@@ -130,17 +134,26 @@ export async function mintAasServiceAccountToken(
  * Resolve the single Prometheus-typed datasource's numeric id on the local
  * Grafana. The monitoring stack's VictoriaMetrics datasource is type
  * "prometheus" (VM speaks PromQL), and the stack registers exactly one such
- * datasource — the same one the collector queries. >1 or 0 → null (skip),
- * matching v1.aas_onboard's discovery contract.
+ * datasource — the same one the collector queries. 0 / API-not-ready → null
+ * (a provisioning transient — the readiness loop retries); >1 → "ambiguous"
+ * (a permanent misconfiguration — the loop stops at once), matching
+ * v1.aas_onboard's >1 skip.
  */
-export async function resolveDatasourceId(adminPassword: string, debug = false): Promise<number | null> {
+export async function resolveDatasourceId(adminPassword: string, debug = false): Promise<number | "ambiguous" | null> {
   try {
     const res = await grafanaApi("GET", "/api/datasources", adminPassword);
     if (!res.ok) return null;
     const list = (await res.json().catch(() => [])) as Array<{ id?: unknown; type?: unknown }>;
     const prom = list.filter((d) => d.type === "prometheus");
-    if (prom.length !== 1) {
-      if (debug) console.error(`Debug: AAS: expected 1 prometheus datasource, found ${prom.length}`);
+    if (prom.length > 1) {
+      // >1 is a permanent misconfiguration, not a provisioning transient: the
+      // datasource count only grows as Grafana provisions, so retrying can never
+      // resolve it. Signal a definitive skip so the readiness loop bails at once.
+      if (debug) console.error(`Debug: AAS: ${prom.length} prometheus datasources (ambiguous); not retrying`);
+      return "ambiguous";
+    }
+    if (prom.length === 0) {
+      if (debug) console.error(`Debug: AAS: no prometheus datasource resolvable yet`);
       return null;
     }
     return typeof prom[0].id === "number" ? prom[0].id : null;
@@ -169,6 +182,10 @@ export async function registerAasCollection(
     apiBaseUrl?: string;
     debug?: boolean;
     fetchImpl?: typeof fetch;
+    // Grafana-readiness polling for the datasource lookup (Grafana has just
+    // been started by `compose up`). Defaults: 20 attempts × 3s.
+    datasourceMaxAttempts?: number;
+    datasourceRetryDelayMs?: number;
   }
 ): Promise<AasRegisterResult> {
   const debug = !!opts.debug;
@@ -178,7 +195,24 @@ export async function registerAasCollection(
     const labels = resolveAasLabels(opts.instancesPath);
     if (!labels) return { ok: false, reason: "could not determine a single (cluster, node_name) target" };
 
-    const datasourceId = await resolveDatasourceId(opts.grafanaPassword, debug);
+    // Grafana was just started by `compose up`; it needs time to create its
+    // admin user, provision datasources, and serve its API. Querying too early
+    // makes the datasource lookup fail transiently, so poll until it resolves
+    // (best-effort, capped — the install never blocks on this).
+    const maxAttempts = opts.datasourceMaxAttempts ?? 20;
+    const retryDelayMs = opts.datasourceRetryDelayMs ?? 3000;
+    let datasourceId: number | null = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const resolved = await resolveDatasourceId(opts.grafanaPassword, debug);
+      if (typeof resolved === "number") { datasourceId = resolved; break; }
+      // "ambiguous" (>1 prometheus datasource) is permanent — retrying can't fix
+      // it, so stop polling immediately instead of waiting out the whole budget.
+      if (resolved === "ambiguous") break;
+      if (attempt < maxAttempts) {
+        if (debug) console.error(`Debug: AAS: datasource not resolvable yet (attempt ${attempt}/${maxAttempts}); waiting for Grafana…`);
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
+    }
     if (datasourceId == null) return { ok: false, reason: "could not resolve the Prometheus datasource id" };
 
     const saToken = await mintAasServiceAccountToken(opts.grafanaPassword, debug);

package/package.json

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

package/test/aas-onboard.test.ts

@@ -198,6 +198,8 @@ describe("registerAasCollection", () => {
       installFetch({ prometheusCount: n });
       const r = await registerAasCollection("apikey-1", "inst-123", {
         grafanaPassword: "pw", instancesPath, vcpus: 8, apiBaseUrl: "https://api.test",
+        // 0/>1 is a definitive skip; cap the readiness retry so the test stays fast.
+        datasourceMaxAttempts: 2, datasourceRetryDelayMs: 0,
       });
       expect(r.ok).toBe(false);
       expect(r.reason).toContain("datasource");
@@ -205,6 +207,88 @@ describe("registerAasCollection", () => {
     }
   });
 
+  test("polls the datasource until Grafana is ready, then registers", async () => {
+    // Grafana isn't ready on the first probes (no prometheus datasource yet),
+    // then it provisions — the readiness retry must keep going and then succeed.
+    let dsProbes = 0;
+    calls = [];
+    fetchSpy = spyOn(globalThis, "fetch").mockImplementation((async (input: unknown, init?: { method?: string; body?: string }) => {
+      const url = String(input);
+      const method = (init?.method || "GET").toUpperCase();
+      calls.push({ url, method, body: init?.body });
+      if (url.includes("/api/serviceaccounts/search")) return res(true, 200, { serviceAccounts: [] });
+      if (url.match(/\/tokens$/) && method === "POST") return res(true, 200, { key: "glsa_mock" });
+      if (url.endsWith("/api/serviceaccounts") && method === "POST") return res(true, 201, { id: 42 });
+      if (url.includes("/api/datasources")) {
+        dsProbes++;
+        return dsProbes < 3
+          ? res(true, 200, [{ id: 3, type: "loki" }]) // not ready yet
+          : res(true, 200, [{ id: 8, type: "prometheus" }, { id: 3, type: "loki" }]);
+      }
+      if (url.includes("/rpc/monitoring_instance_aas_register")) return res(true, 200, {});
+      return res(false, 404, {});
+    }) as unknown as typeof fetch);
+
+    const r = await registerAasCollection("apikey-1", "inst-123", {
+      grafanaPassword: "pw", instancesPath, vcpus: 8, apiBaseUrl: "https://api.test",
+      datasourceMaxAttempts: 6, datasourceRetryDelayMs: 0,
+    });
+    expect(r.ok).toBe(true);
+    expect(dsProbes).toBeGreaterThanOrEqual(3); // kept polling past the not-ready probes
+    const rpc = calls.find((c) => c.url.includes("/rpc/monitoring_instance_aas_register"));
+    expect(rpc).toBeDefined();
+    expect(JSON.parse(rpc!.body!).datasource_id).toBe(8);
+  });
+
+  test(">1 prometheus datasource is a definitive skip: one probe, no retry", async () => {
+    // The >1 case is permanent (the datasource count only grows), so the
+    // readiness loop must bail after a single probe, not burn its whole budget.
+    let dsProbes = 0;
+    calls = [];
+    fetchSpy = spyOn(globalThis, "fetch").mockImplementation((async (input: unknown, init?: { method?: string; body?: string }) => {
+      const url = String(input);
+      const method = (init?.method || "GET").toUpperCase();
+      calls.push({ url, method, body: init?.body });
+      if (url.includes("/api/datasources")) {
+        dsProbes++;
+        return res(true, 200, [{ id: 8, type: "prometheus" }, { id: 9, type: "prometheus" }, { id: 3, type: "loki" }]);
+      }
+      return res(false, 404, {});
+    }) as unknown as typeof fetch);
+
+    const r = await registerAasCollection("apikey-1", "inst-123", {
+      grafanaPassword: "pw", instancesPath, vcpus: 8, apiBaseUrl: "https://api.test",
+      datasourceMaxAttempts: 5, datasourceRetryDelayMs: 0,
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toContain("datasource");
+    expect(dsProbes).toBe(1); // bailed after one probe; did NOT retry 5x
+    expect(calls.some((c) => c.url.includes("/rpc/monitoring_instance_aas_register"))).toBe(false);
+  });
+
+  test("never-ready datasource: polls exactly maxAttempts times, then ok:false", async () => {
+    // Bounds the readiness loop: a never-appearing datasource must probe exactly
+    // maxAttempts times (N probes, N-1 sleeps) and then give up — not loop forever.
+    let dsProbes = 0;
+    calls = [];
+    fetchSpy = spyOn(globalThis, "fetch").mockImplementation((async (input: unknown, init?: { method?: string; body?: string }) => {
+      const url = String(input);
+      const method = (init?.method || "GET").toUpperCase();
+      calls.push({ url, method, body: init?.body });
+      if (url.includes("/api/datasources")) { dsProbes++; return res(true, 200, [{ id: 3, type: "loki" }]); } // never a prometheus
+      return res(false, 404, {});
+    }) as unknown as typeof fetch);
+
+    const r = await registerAasCollection("apikey-1", "inst-123", {
+      grafanaPassword: "pw", instancesPath, vcpus: 8, apiBaseUrl: "https://api.test",
+      datasourceMaxAttempts: 3, datasourceRetryDelayMs: 0,
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toContain("datasource");
+    expect(dsProbes).toBe(3); // bounded: exactly maxAttempts probes
+    expect(calls.some((c) => c.url.includes("/rpc/monitoring_instance_aas_register"))).toBe(false);
+  });
+
   test("mint returning no key → ok:false, no RPC call", async () => {
     installFetch({ mintKey: null });
     const r = await registerAasCollection("apikey-1", "inst-123", {