@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -20,6 +20,7 @@ import { tmpdir } from "node:os";
 
 import {
   runProviderChecks,
+  runProviderChecksAsync,
   formatProviderReport,
   summariseProviderIssues,
   type ProviderCheckResult,
@@ -47,6 +48,26 @@ function withEnv(vars: Record<string, string | undefined>, fn: () => void): void
   }
 }
 
+async function withEnvAsync(vars: Record<string, string | undefined>, fn: () => Promise<void>): Promise<void> {
+  const saved: Record<string, string | undefined> = {};
+  for (const [k, v] of Object.entries(vars)) {
+    saved[k] = process.env[k];
+    if (v === undefined) {
+      delete process.env[k];
+    } else {
+      process.env[k] = v;
+    }
+  }
+  try {
+    await fn();
+  } finally {
+    for (const [k, v] of Object.entries(saved)) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  }
+}
+
 function withCwd(nextCwd: string, fn: () => void): void {
   const saved = process.cwd();
   process.chdir(nextCwd);
@@ -57,6 +78,22 @@ function withCwd(nextCwd: string, fn: () => void): void {
   }
 }
 
+async function withCwdAsync(nextCwd: string, fn: () => Promise<void>): Promise<void> {
+  const saved = process.cwd();
+  process.chdir(nextCwd);
+  try {
+    await fn();
+  } finally {
+    process.chdir(saved);
+  }
+}
+
+function normalizeProviderResults(results: ProviderCheckResult[]): string[] {
+  return results
+    .map(r => `${r.name}|${r.label}|${r.category}|${r.status}|${r.message}|${r.detail ?? ""}|${r.required}`)
+    .sort();
+}
+
 const PRESENT_TEST_VALUE = "configured";
 
 // ─── formatProviderReport ─────────────────────────────────────────────────────
@@ -377,6 +414,76 @@ test("runProviderChecks detects custom provider keys from models.json", () => {
   rmSync(tmpHome, { recursive: true, force: true });
 });
 
+test("runProviderChecksAsync matches sync for models.json keys and PATH CLI checks", async () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-async-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-async-repo-")));
+  const agentDir = join(tmpHome, ".gsd", "agent");
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(agentDir, { recursive: true });
+  mkdirSync(binDir, { recursive: true });
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: custom-model",
+      "    provider: custom-provider",
+      "  validation:",
+      "    model: gemini-2.5-pro",
+      "    provider: google-gemini-cli",
+      "---",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(join(agentDir, "models.json"), JSON.stringify({
+    providers: {
+      "custom-provider": {
+        api: "openai-completions",
+        apiKey: "x",
+        baseUrl: "https://example.invalid/v1",
+        models: [{ id: "custom-model", name: "Custom Model" }],
+      },
+    },
+  }));
+
+  const fakeGemini = join(binDir, "gemini");
+  writeFileSync(fakeGemini, "#!/bin/sh\necho mock\n");
+  chmodSync(fakeGemini, 0o755);
+
+  try {
+    await withEnvAsync({
+      HOME: tmpHome,
+      CUSTOM_PROVIDER_API_KEY: undefined,
+      GEMINI_API_KEY: undefined,
+      GOOGLE_API_KEY: undefined,
+      PATH: binDir,
+    }, async () => {
+      await withCwdAsync(repo, async () => {
+        const syncResults = runProviderChecks();
+        const asyncResults = await runProviderChecksAsync();
+
+        assert.deepEqual(normalizeProviderResults(asyncResults), normalizeProviderResults(syncResults));
+        assert.equal(
+          asyncResults.find(r => r.name === "custom-provider")?.status,
+          "ok",
+          "models.json apiKey should satisfy custom provider auth",
+        );
+        assert.equal(
+          asyncResults.find(r => r.name === "google-gemini-cli")?.status,
+          "ok",
+          "gemini CLI binary should satisfy explicit CLI provider",
+        );
+      });
+    });
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+});
+
 test("runProviderChecks reports missing custom provider key without models.json apiKey", () => {
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-custom-missing-home-")));
   const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-custom-missing-repo-")));
@@ -907,6 +1014,143 @@ test("runProviderChecks detects claude.exe in PATH on Windows (#4548)", { skip:
   });
 });
 
+
+test("runProviderChecks reports error for required cursor-agent when binary is missing", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: composer-2.5",
+      "    provider: cursor-agent",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-home-")));
+
+  withEnv({
+    HOME: tmpHome,
+    PATH: tmpHome,
+    CURSOR_API_KEY: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const cursor = results.find(r => r.name === "cursor-agent");
+      assert.ok(cursor, "cursor-agent result should exist");
+      assert.equal(cursor!.status, "error", "cursor-agent should error when the CLI binary is missing");
+      assert.ok(cursor!.detail?.includes("Cursor Agent"), "should explain Cursor Agent must be installed");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks does not route OpenAI via unauthenticated cursor-agent binary in PATH", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-route-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: gpt-5.5",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-route-home-")));
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const fakeCursor = join(binDir, "cursor-agent");
+  writeFileSync(fakeCursor, [
+    "#!/bin/sh",
+    "if [ \"$1\" = \"status\" ]; then echo \"Not logged in\"; exit 0; fi",
+    "echo mock",
+    "",
+  ].join("\n"));
+  chmodSync(fakeCursor, 0o755);
+
+  withEnv({
+    HOME: tmpHome,
+    OPENAI_API_KEY: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ""}`,
+  }, () => {
+    try {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const openai = results.find(r => r.name === "openai");
+        assert.ok(openai, "openai result should exist");
+        assert.equal(openai!.status, "error", "binary-only cursor-agent must not satisfy OpenAI routing");
+        assert.ok(openai!.detail?.includes("OPENAI_API_KEY"), "should still tell the user how to configure OpenAI");
+      });
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks routes OpenAI via authenticated cursor-agent CLI", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-auth-route-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: gpt-5.5",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cursor-auth-route-home-")));
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const fakeCursor = join(binDir, "cursor-agent");
+  writeFileSync(fakeCursor, [
+    "#!/bin/sh",
+    "if [ \"$1\" = \"--version\" ]; then echo cursor-agent 1.0; exit 0; fi",
+    "if [ \"$1\" = \"status\" ]; then echo \"Authenticated as user@example.com\"; exit 0; fi",
+    "echo mock",
+    "",
+  ].join("\n"));
+  chmodSync(fakeCursor, 0o755);
+
+  withEnv({
+    HOME: tmpHome,
+    OPENAI_API_KEY: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    CURSOR_API_KEY: undefined,
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ""}`,
+  }, () => {
+    try {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const openai = results.find(r => r.name === "openai");
+        assert.ok(openai, "openai result should exist");
+        assert.equal(openai!.status, "ok", "authenticated cursor-agent should satisfy OpenAI routing");
+        assert.ok(openai!.message.toLowerCase().includes("cursor"), "should mention cursor-agent as source");
+      });
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
 test("PROVIDER_ROUTES includes google-antigravity and google-gemini-cli as routes for google (#2922)", async () => {
   const { readFileSync: readFS } = await import("node:fs");
   const { dirname: dirn, join: joinPath } = await import("node:path");
@@ -915,7 +1159,7 @@ test("PROVIDER_ROUTES includes google-antigravity and google-gemini-cli as route
   const src = readFS(joinPath(__dir, "..", "doctor-providers.ts"), "utf-8");
 
   assert.ok(
-    src.includes('google: ["google-antigravity", "google-gemini-cli"]'),
+    src.includes('google: ["google-antigravity", "google-gemini-cli", "cursor-agent"]'),
     'PROVIDER_ROUTES must prefer "google-antigravity" over "google-gemini-cli" for google (#2922)',
   );
 });