@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.1

package/packages/server/src/__tests__/provider-probe.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  buildProbeRequest,
+  resolveProbeApiKey,
+  probeProvider,
+  type ProbeInput,
+} from "../provider-probe.js";
+
+describe("buildProbeRequest", () => {
+  it("openai-completions: GET {baseUrl}/models with Authorization: Bearer", () => {
+    const req = buildProbeRequest({
+      baseUrl: "https://api.example.com/v1",
+      apiKey: "sk-abc",
+      api: "openai-completions",
+    });
+    expect(req.url).toBe("https://api.example.com/v1/models");
+    expect(req.headers.Authorization).toBe("Bearer sk-abc");
+  });
+
+  it("openai-completions: handles trailing slash on baseUrl", () => {
+    const req = buildProbeRequest({
+      baseUrl: "https://api.example.com/v1/",
+      apiKey: "sk-abc",
+      api: "openai-completions",
+    });
+    expect(req.url).toBe("https://api.example.com/v1/models");
+  });
+
+  it("openai-responses: same shape as openai-completions", () => {
+    const req = buildProbeRequest({
+      baseUrl: "https://api.example.com/v1",
+      apiKey: "sk-abc",
+      api: "openai-responses",
+    });
+    expect(req.url).toBe("https://api.example.com/v1/models");
+    expect(req.headers.Authorization).toBe("Bearer sk-abc");
+  });
+
+  it("anthropic-messages: x-api-key + anthropic-version, no Authorization", () => {
+    const req = buildProbeRequest({
+      baseUrl: "https://api.anthropic.com",
+      apiKey: "sk-ant-123",
+      api: "anthropic-messages",
+    });
+    expect(req.url).toBe("https://api.anthropic.com/v1/models");
+    expect(req.headers["x-api-key"]).toBe("sk-ant-123");
+    expect(req.headers["anthropic-version"]).toBe("2023-06-01");
+    expect(req.headers.Authorization).toBeUndefined();
+  });
+
+  it("google-generative-ai: key query param, no Authorization", () => {
+    const req = buildProbeRequest({
+      baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+      apiKey: "AIza abc+def",
+      api: "google-generative-ai",
+    });
+    // apiKey must be URL-encoded
+    expect(req.url).toBe(
+      "https://generativelanguage.googleapis.com/v1beta/models?key=AIza%20abc%2Bdef",
+    );
+    expect(req.headers.Authorization).toBeUndefined();
+  });
+
+  it("throws on unknown api type", () => {
+    expect(() =>
+      buildProbeRequest({
+        baseUrl: "https://x",
+        apiKey: "k",
+        api: "unknown-api" as any,
+      }),
+    ).toThrow(/unsupported api/i);
+  });
+});
+
+describe("resolveProbeApiKey", () => {
+  const ORIGINAL_ENV = { ...process.env };
+  beforeEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+  afterEach(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  it("literal key passes through", () => {
+    const result = resolveProbeApiKey({ apiKey: "sk-abc", readProviders: () => ({}) });
+    expect(result).toEqual({ ok: true, key: "sk-abc" });
+  });
+
+  it("$ENV_VAR: reads from process.env when set", () => {
+    process.env.MY_LLM_KEY = "resolved-value";
+    const result = resolveProbeApiKey({ apiKey: "$MY_LLM_KEY", readProviders: () => ({}) });
+    expect(result).toEqual({ ok: true, key: "resolved-value" });
+  });
+
+  it("$ENV_VAR: returns error when env var is missing", () => {
+    delete process.env.NONEXISTENT_VAR;
+    const result = resolveProbeApiKey({ apiKey: "$NONEXISTENT_VAR", readProviders: () => ({}) });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toMatch(/NONEXISTENT_VAR/);
+  });
+
+  it("REDACTED (***): resolves via provider name from readProviders", () => {
+    const result = resolveProbeApiKey({
+      apiKey: "***",
+      name: "my-provider",
+      readProviders: () => ({
+        "my-provider": { baseUrl: "u", apiKey: "stored-key", api: "openai-completions" },
+      }),
+    });
+    expect(result).toEqual({ ok: true, key: "stored-key" });
+  });
+
+  it("REDACTED + stored key is $ENV_VAR: follows env-var resolution", () => {
+    process.env.STORED_ENV = "env-value";
+    const result = resolveProbeApiKey({
+      apiKey: "***",
+      name: "my-provider",
+      readProviders: () => ({
+        "my-provider": { baseUrl: "u", apiKey: "$STORED_ENV", api: "openai-completions" },
+      }),
+    });
+    expect(result).toEqual({ ok: true, key: "env-value" });
+  });
+
+  it("REDACTED without name: returns error", () => {
+    const result = resolveProbeApiKey({ apiKey: "***", readProviders: () => ({}) });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toMatch(/no.*provider/i);
+  });
+
+  it("REDACTED with unknown name: returns error", () => {
+    const result = resolveProbeApiKey({
+      apiKey: "***",
+      name: "missing",
+      readProviders: () => ({}),
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toMatch(/missing/);
+  });
+
+  it("empty key: returns error", () => {
+    const result = resolveProbeApiKey({ apiKey: "", readProviders: () => ({}) });
+    expect(result.ok).toBe(false);
+  });
+});
+
+describe("probeProvider", () => {
+  const baseInput: ProbeInput = {
+    baseUrl: "https://api.example.com/v1",
+    apiKey: "sk-abc",
+    api: "openai-completions",
+  };
+
+  let originalFetch: typeof globalThis.fetch;
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function mockFetch(impl: (url: string, init: RequestInit) => Promise<Response>) {
+    globalThis.fetch = vi.fn(impl) as any;
+  }
+
+  it("2xx with data array returns ok + modelCount + sample (capped at 5)", async () => {
+    const ids = ["m1", "m2", "m3", "m4", "m5", "m6", "m7"];
+    mockFetch(async () =>
+      new Response(JSON.stringify({ data: ids.map((id) => ({ id })) }), { status: 200 }),
+    );
+    const result = await probeProvider(baseInput);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.status).toBe(200);
+      expect(result.modelCount).toBe(7);
+      expect(result.sample).toEqual(["m1", "m2", "m3", "m4", "m5"]);
+    }
+  });
+
+  it("2xx with unexpected body shape: ok with modelCount=0", async () => {
+    mockFetch(async () => new Response(JSON.stringify({ weird: true }), { status: 200 }));
+    const result = await probeProvider(baseInput);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.modelCount).toBe(0);
+      expect(result.sample).toEqual([]);
+    }
+  });
+
+  it("401 returns ok=false with status + error", async () => {
+    mockFetch(async () =>
+      new Response("Invalid API key", { status: 401, statusText: "Unauthorized" }),
+    );
+    const result = await probeProvider(baseInput);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.status).toBe(401);
+      expect(result.error).toMatch(/Invalid API key|Unauthorized|401/);
+    }
+  });
+
+  it("500 returns ok=false with status", async () => {
+    mockFetch(async () => new Response("boom", { status: 500 }));
+    const result = await probeProvider(baseInput);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.status).toBe(500);
+  });
+
+  it("body excerpt is truncated to 500 chars", async () => {
+    const long = "x".repeat(2000);
+    mockFetch(async () => new Response(long, { status: 400 }));
+    const result = await probeProvider(baseInput);
+    expect(result.ok).toBe(false);
+    if (!result.ok && result.error) expect(result.error.length).toBeLessThanOrEqual(500);
+  });
+
+  it("network error: ok=false with error, no status", async () => {
+    mockFetch(async () => {
+      throw new Error("ECONNREFUSED");
+    });
+    const result = await probeProvider(baseInput);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toMatch(/ECONNREFUSED/);
+      expect(result.status).toBeUndefined();
+    }
+  });
+
+  it("timeout aborts the request and returns error", async () => {
+    mockFetch(
+      (_url, init) =>
+        new Promise((_resolve, reject) => {
+          const signal = init.signal as AbortSignal;
+          signal.addEventListener("abort", () => reject(new Error("aborted")));
+        }),
+    );
+    const result = await probeProvider({ ...baseInput, timeoutMs: 20 });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeDefined();
+  });
+
+  it("response never echoes the apiKey", async () => {
+    mockFetch(async () =>
+      new Response(`echoed sk-abc in body`, { status: 401 }),
+    );
+    const result = await probeProvider({ ...baseInput, apiKey: "sk-abc" });
+    // even though upstream echoes the key, our result error should not leak it
+    if (!result.ok && result.error) {
+      expect(result.error).not.toContain("sk-abc");
+    }
+  });
+
+  it("anthropic-messages uses x-api-key header (not Authorization)", async () => {
+    let capturedInit: RequestInit | undefined;
+    mockFetch(async (_url, init) => {
+      capturedInit = init;
+      return new Response(JSON.stringify({ data: [] }), { status: 200 });
+    });
+    await probeProvider({
+      baseUrl: "https://api.anthropic.com",
+      apiKey: "sk-ant-x",
+      api: "anthropic-messages",
+    });
+    const headers = capturedInit!.headers as Record<string, string>;
+    expect(headers["x-api-key"]).toBe("sk-ant-x");
+    expect(headers["anthropic-version"]).toBe("2023-06-01");
+    expect(headers.Authorization).toBeUndefined();
+  });
+
+  it("google-generative-ai uses ?key= query param (no Authorization)", async () => {
+    let capturedUrl: string | undefined;
+    let capturedInit: RequestInit | undefined;
+    mockFetch(async (url, init) => {
+      capturedUrl = url;
+      capturedInit = init;
+      return new Response(JSON.stringify({ data: [] }), { status: 200 });
+    });
+    await probeProvider({
+      baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+      apiKey: "AIzaTest",
+      api: "google-generative-ai",
+    });
+    expect(capturedUrl).toContain("?key=AIzaTest");
+    const headers = (capturedInit!.headers ?? {}) as Record<string, string>;
+    expect(headers.Authorization).toBeUndefined();
+  });
+});

package/packages/server/src/__tests__/provider-test-route.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import Fastify from "fastify";
+import { registerProviderRoutes } from "../routes/provider-routes.js";
+
+// Pass-through network guard — we're testing the endpoint contract, not auth
+const allowGuard = async () => {};
+
+function makeApp() {
+  const app = Fastify();
+  registerProviderRoutes(app, { networkGuard: allowGuard as any });
+  return app;
+}
+
+describe("POST /api/providers/test", () => {
+  let originalFetch: typeof globalThis.fetch;
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function mockFetch(impl: (url: string, init: RequestInit) => Promise<Response>) {
+    globalThis.fetch = vi.fn(impl) as any;
+  }
+
+  it("400 when body is invalid", async () => {
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: "not-json",
+      headers: { "content-type": "application/json" },
+    });
+    expect(res.statusCode).toBe(400);
+    await app.close();
+  });
+
+  it("400 when baseUrl missing", async () => {
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: { apiKey: "sk-abc", api: "openai-completions" },
+    });
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.payload);
+    expect(body.error).toMatch(/baseUrl/);
+    await app.close();
+  });
+
+  it("400 when api missing", async () => {
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: { baseUrl: "https://x", apiKey: "sk" },
+    });
+    expect(res.statusCode).toBe(400);
+    await app.close();
+  });
+
+  it("happy path: probe returns ok with modelCount", async () => {
+    mockFetch(async () =>
+      new Response(JSON.stringify({ data: [{ id: "m1" }, { id: "m2" }] }), { status: 200 }),
+    );
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-abc",
+        api: "openai-completions",
+      },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.payload);
+    expect(body.ok).toBe(true);
+    expect(body.modelCount).toBe(2);
+    expect(body.sample).toEqual(["m1", "m2"]);
+    await app.close();
+  });
+
+  it("401 upstream: returns ok=false with status", async () => {
+    mockFetch(async () => new Response("bad key", { status: 401 }));
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-bad",
+        api: "openai-completions",
+      },
+    });
+    // Our endpoint always returns 200 with the structured result
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.payload);
+    expect(body.ok).toBe(false);
+    expect(body.status).toBe(401);
+    await app.close();
+  });
+
+  it("missing $ENV_VAR: returns ok=false without hitting upstream", async () => {
+    delete process.env.PROBE_ROUTE_MISSING;
+    const fetchSpy = vi.fn(async () => new Response("{}", { status: 200 }));
+    globalThis.fetch = fetchSpy as any;
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: {
+        baseUrl: "https://x",
+        apiKey: "$PROBE_ROUTE_MISSING",
+        api: "openai-completions",
+      },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.payload);
+    expect(body.ok).toBe(false);
+    expect(body.error).toMatch(/PROBE_ROUTE_MISSING/);
+    expect(fetchSpy).not.toHaveBeenCalled();
+    await app.close();
+  });
+
+  it("response never echoes the apiKey", async () => {
+    mockFetch(async () => new Response("bad key xyz-secret-abc", { status: 401 }));
+    const app = makeApp();
+    await app.ready();
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/providers/test",
+      payload: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "xyz-secret-abc",
+        api: "openai-completions",
+      },
+    });
+    expect(res.payload).not.toContain("xyz-secret-abc");
+    await app.close();
+  });
+});

package/packages/server/src/__tests__/restart-helper.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Tests for the cross-platform restart orchestrator.
+ * See change: fix-windows-server-parity.
+ */
+import { describe, it, expect } from "vitest";
+import { buildOrchestratorScript } from "../restart-helper.js";
+
+describe("buildOrchestratorScript", () => {
+  const baseParams = {
+    cliPath: "/tmp/cli.ts",
+    loader: "file:///tmp/jiti-register.mjs",
+    port: 8000,
+    extraArgs: [] as string[],
+    execPath: "/usr/bin/node",
+  };
+
+  it("produces a self-contained Node script (no shell/lsof/curl)", () => {
+    const script = buildOrchestratorScript(baseParams);
+    expect(script).not.toMatch(/\blsof\b/);
+    expect(script).not.toMatch(/\bcurl\b/);
+    expect(script).not.toMatch(/\bsh\s+-c\b/);
+    // Uses Node built-ins
+    expect(script).toMatch(/require\("node:net"\)/);
+    expect(script).toMatch(/require\("node:http"\)/);
+    expect(script).toMatch(/require\("node:child_process"\)/);
+  });
+
+  it("embeds the port as a number literal", () => {
+    const script = buildOrchestratorScript({ ...baseParams, port: 12345 });
+    expect(script).toMatch(/const PORT = 12345/);
+  });
+
+  it("embeds the loader as a --import arg when provided", () => {
+    const script = buildOrchestratorScript(baseParams);
+    // ARGS should be a JSON array containing --import and the loader
+    expect(script).toMatch(/const ARGS = \[.*"--import".*"file:\/\/\/tmp\/jiti-register\.mjs"/);
+    // On POSIX, cliPath stays RAW — jiti's resolver misbehaves on file:// URL entries.
+    expect(script).toMatch(/"\/tmp\/cli\.ts"/);
+    expect(script).not.toContain(JSON.stringify("file:///tmp/cli.ts"));
+    expect(script).toMatch(/"start"/);
+  });
+
+  it("omits --import when loader is empty", () => {
+    const script = buildOrchestratorScript({ ...baseParams, loader: "" });
+    expect(script).not.toMatch(/"--import"/);
+    // No loader + POSIX host → raw entry.
+    expect(script).toMatch(/"\/tmp\/cli\.ts"/);
+    expect(script).not.toContain(JSON.stringify("file:///tmp/cli.ts"));
+    expect(script).toMatch(/"start"/);
+  });
+
+  it("appends extra args (e.g. --dev) after 'start'", () => {
+    const script = buildOrchestratorScript({ ...baseParams, extraArgs: ["--dev"] });
+    // ARGS array should have "start" immediately followed by "--dev"
+    expect(script).toMatch(/"start","--dev"/);
+  });
+
+  it("wraps Windows cliPath as file:// URL when loader is jiti AND host is Windows (Node parses drive letters as URL schemes)", () => {
+    // NOTE: shouldUrlWrapEntry consults process.platform. This test runs on
+    // Linux CI, so the wrap branch isn't directly exercised here — but the
+    // UNIT test for shouldUrlWrapEntry itself covers the win32 contract.
+    // Here we verify the tree of what buildOrchestratorScript emits on the
+    // host platform (Linux): raw entry even with a Windows-styled path.
+    const winParams = {
+      ...baseParams,
+      cliPath: "B:\\Dev\\BB\\pi-agent-dashboard\\packages\\server\\src\\cli.ts",
+      loader: "file:///B:/Dev/Nodejs/global/node_modules/@mariozechner/jiti/lib/jiti-register.mjs",
+      execPath: "C:\\Program Files\\nodejs\\node.exe",
+    };
+    const script = buildOrchestratorScript(winParams);
+    expect(script).toContain(JSON.stringify(winParams.execPath));
+    expect(script).toContain(JSON.stringify(winParams.loader));
+    // Host is Linux → entry stays raw (tested branch here).
+    expect(script).toContain(JSON.stringify(winParams.cliPath));
+  });
+
+  it("keeps cliPath as RAW path when loader is tsx (tsx rejects file:// URL entries)", () => {
+    // Regression: tsx's ESM hook treats the entry as a user-typed specifier
+    // and attempts bare/relative resolution. A file:// URL becomes "<cwd>/file:/..."
+    // and crashes with ERR_MODULE_NOT_FOUND. This is the Linux dev-loop case
+    // (jiti not in repo node_modules, tsx fallback picked up).
+    const tsxParams = {
+      cliPath: "/home/u/repo/packages/server/src/cli.ts",
+      loader: "file:///home/u/repo/node_modules/tsx/dist/esm/index.mjs",
+      port: 8000,
+      extraArgs: [] as string[],
+      execPath: "/usr/bin/node",
+    };
+    const script = buildOrchestratorScript(tsxParams);
+    // Loader is still URL-wrapped (Node's --import requires file://)
+    expect(script).toContain(JSON.stringify(tsxParams.loader));
+    // Entry is the RAW path, NOT a file:// URL
+    expect(script).toContain(JSON.stringify(tsxParams.cliPath));
+    // Negative: must NOT contain the file:// URL form of the entry
+    const urlForm = "file://" + tsxParams.cliPath;
+    expect(script).not.toContain(JSON.stringify(urlForm));
+  });
+
+  it("references ~/.pi/dashboard/restart.log for failure logging", () => {
+    const script = buildOrchestratorScript(baseParams);
+    expect(script).toMatch(/restart\.log/);
+    expect(script).toMatch(/fs\.appendFileSync/);
+  });
+
+  it("health-check target is /api/health on the configured port", () => {
+    const script = buildOrchestratorScript({ ...baseParams, port: 8765 });
+    expect(script).toMatch(/\/api\/health/);
+    expect(script).toMatch(/const PORT = 8765/);
+    expect(script).toMatch(/port: PORT/);
+  });
+});