gsd-pi 2.31.2 → 2.32.0-dev.1e39869

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

@@ -0,0 +1,314 @@
+/**
+ * doctor-environment.test.ts — Tests for environment health checks (#1221).
+ *
+ * Tests:
+ *   - Node version detection
+ *   - Dependencies installed check
+ *   - Env file detection
+ *   - Port conflict detection
+ *   - Disk space check
+ *   - Docker detection
+ *   - Project tool detection
+ *   - Doctor issue conversion
+ *   - Report formatting
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  runEnvironmentChecks,
+  runFullEnvironmentChecks,
+  environmentResultsToDoctorIssues,
+  formatEnvironmentReport,
+  checkEnvironmentHealth,
+  type EnvironmentCheckResult,
+} from "../doctor-environment.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+function createProjectDir(files: Record<string, string> = {}): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-env-test-"));
+  for (const [name, content] of Object.entries(files)) {
+    const filePath = join(dir, name);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content);
+  }
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const cleanups: string[] = [];
+
+  try {
+    // ── Node Version Check ─────────────────────────────────────────────
+    console.log("\n=== env: no package.json returns empty ===");
+    {
+      const dir = createProjectDir();
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      // No package.json → no node checks
+      const nodeCheck = results.find(r => r.name === "node_version");
+      assertEq(nodeCheck, undefined, "no node version check without package.json");
+    }
+
+    console.log("\n=== env: package.json without engines returns no node check ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const nodeCheck = results.find(r => r.name === "node_version");
+      assertEq(nodeCheck, undefined, "no node version check without engines field");
+    }
+
+    console.log("\n=== env: package.json with engines returns node check ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({
+          name: "test",
+          version: "1.0.0",
+          engines: { node: ">=18.0.0" },
+        }),
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const nodeCheck = results.find(r => r.name === "node_version");
+      assertTrue(nodeCheck !== undefined, "node version check runs with engines field");
+      // Current node should be >= 18 in CI
+      assertEq(nodeCheck!.status, "ok", "node version meets requirement");
+    }
+
+    // ── Dependencies Check ─────────────────────────────────────────────
+    console.log("\n=== env: missing node_modules detected ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assertTrue(depsCheck !== undefined, "dependencies check runs");
+      assertEq(depsCheck!.status, "error", "missing node_modules is an error");
+      assertTrue(depsCheck!.message.includes("node_modules missing"), "reports missing node_modules");
+    }
+
+    console.log("\n=== env: existing node_modules detected ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assertTrue(depsCheck !== undefined, "dependencies check runs");
+      assertEq(depsCheck!.status, "ok", "existing node_modules is ok");
+    }
+
+    // ── Env File Check ─────────────────────────────────────────────────
+    console.log("\n=== env: .env.example without .env detected ===");
+    {
+      const dir = createProjectDir({
+        ".env.example": "DB_URL=xxx\nAPI_KEY=xxx\n",
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const envCheck = results.find(r => r.name === "env_file");
+      assertTrue(envCheck !== undefined, "env file check runs");
+      assertEq(envCheck!.status, "warning", "missing .env is a warning");
+    }
+
+    console.log("\n=== env: .env.example with .env is ok ===");
+    {
+      const dir = createProjectDir({
+        ".env.example": "DB_URL=xxx\n",
+        ".env": "DB_URL=postgres://localhost/test\n",
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const envCheck = results.find(r => r.name === "env_file");
+      assertTrue(envCheck !== undefined, "env file check runs");
+      assertEq(envCheck!.status, "ok", "present .env is ok");
+    }
+
+    console.log("\n=== env: .env.example with .env.local is ok ===");
+    {
+      const dir = createProjectDir({
+        ".env.example": "DB_URL=xxx\n",
+        ".env.local": "DB_URL=postgres://localhost/test\n",
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const envCheck = results.find(r => r.name === "env_file");
+      assertTrue(envCheck !== undefined, "env file check runs");
+      assertEq(envCheck!.status, "ok", ".env.local counts as present");
+    }
+
+    // ── Disk Space Check ───────────────────────────────────────────────
+    console.log("\n=== env: disk space check returns result ===");
+    if (process.platform !== "win32") {
+      const dir = createProjectDir();
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const diskCheck = results.find(r => r.name === "disk_space");
+      assertTrue(diskCheck !== undefined, "disk space check runs on unix");
+      // Should be ok on dev machines with reasonable disk
+      assertTrue(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
+    }
+
+    // ── Project Tools Check ────────────────────────────────────────────
+    console.log("\n=== env: detects missing python when pyproject.toml exists ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+        "pyproject.toml": "[build-system]\nrequires = ['setuptools']\n",
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const pythonCheck = results.find(r => r.name === "python");
+      // Python is likely installed on CI/dev machines, so just verify the check runs
+      // without error — the result depends on the system
+      assertTrue(true, "python check runs without error");
+    }
+
+    console.log("\n=== env: detects Cargo.toml ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+        "Cargo.toml": "[package]\nname = 'test'\n",
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      // Just verify it runs without error
+      assertTrue(true, "cargo check runs without error");
+    }
+
+    // ── Docker Check ───────────────────────────────────────────────────
+    console.log("\n=== env: no docker check without Dockerfile ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const dockerCheck = results.find(r => r.name === "docker");
+      assertEq(dockerCheck, undefined, "no docker check without Dockerfile");
+    }
+
+    console.log("\n=== env: docker check with Dockerfile ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+        "Dockerfile": "FROM node:22\n",
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const dockerCheck = results.find(r => r.name === "docker");
+      // Docker may or may not be installed on the test machine
+      assertTrue(dockerCheck !== undefined, "docker check runs when Dockerfile present");
+    }
+
+    // ── Doctor Issue Conversion ────────────────────────────────────────
+    console.log("\n=== env: converts results to doctor issues ===");
+    {
+      const results: EnvironmentCheckResult[] = [
+        { name: "node_version", status: "ok", message: "Node.js v22.0.0" },
+        { name: "dependencies", status: "error", message: "node_modules missing" },
+        { name: "env_file", status: "warning", message: ".env missing", detail: "Copy .env.example" },
+      ];
+
+      const issues = environmentResultsToDoctorIssues(results);
+      assertEq(issues.length, 2, "only non-ok results converted");
+      assertEq(issues[0]!.severity, "error", "error severity preserved");
+      assertEq(issues[0]!.code, "env_dependencies", "code prefixed with env_");
+      assertEq(issues[1]!.severity, "warning", "warning severity preserved");
+      assertTrue(issues[1]!.message.includes("Copy .env.example"), "detail included in message");
+    }
+
+    // ── checkEnvironmentHealth integration ──────────────────────────────
+    console.log("\n=== env: checkEnvironmentHealth adds issues to array ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      cleanups.push(dir);
+
+      const issues: any[] = [];
+      await checkEnvironmentHealth(dir, issues);
+      // Should have at least the missing node_modules issue
+      assertTrue(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
+    }
+
+    // ── Report Formatting ──────────────────────────────────────────────
+    console.log("\n=== env: formatEnvironmentReport ===");
+    {
+      const results: EnvironmentCheckResult[] = [
+        { name: "node_version", status: "ok", message: "Node.js v22.0.0" },
+        { name: "dependencies", status: "error", message: "node_modules missing", detail: "Run npm install" },
+        { name: "disk_space", status: "ok", message: "50.2GB free" },
+      ];
+
+      const report = formatEnvironmentReport(results);
+      assertTrue(report.includes("Environment Health:"), "has header");
+      assertTrue(report.includes("Node.js v22.0.0"), "includes ok result");
+      assertTrue(report.includes("node_modules missing"), "includes error result");
+      assertTrue(report.includes("Run npm install"), "includes detail for errors");
+    }
+
+    console.log("\n=== env: formatEnvironmentReport empty ===");
+    {
+      const report = formatEnvironmentReport([]);
+      assertEq(report, "No environment checks applicable.", "empty report message");
+    }
+
+    // ── Full environment checks include git remote ─────────────────────
+    console.log("\n=== env: runFullEnvironmentChecks includes git remote ===");
+    {
+      // runFullEnvironmentChecks adds git remote check
+      // We can't easily test this without a real git repo, but verify it doesn't throw
+      const dir = createProjectDir();
+      cleanups.push(dir);
+      const results = runFullEnvironmentChecks(dir);
+      // No git repo → no remote check, but should not throw
+      assertTrue(true, "runFullEnvironmentChecks does not throw on non-git dir");
+    }
+
+    // ── Port Detection from package.json ───────────────────────────────
+    console.log("\n=== env: port detection from scripts ===");
+    if (process.platform !== "win32") {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({
+          name: "test",
+          scripts: {
+            dev: "next dev --port 3456",
+            start: "node server.js",
+          },
+        }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      // Port 3456 is unlikely to be in use, so no conflicts expected
+      const portConflicts = results.filter(r => r.name === "port_conflict");
+      // Just verify it ran without error
+      assertTrue(true, "port check with script-detected ports runs without error");
+    }
+
+  } finally {
+    for (const dir of cleanups) {
+      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  report();
+}
+
+main();

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

@@ -0,0 +1,298 @@
+/**
+ * doctor-providers.test.ts — Tests for provider & integration health checks.
+ *
+ * Tests:
+ *   - LLM provider key detection from env vars
+ *   - LLM provider key detection from auth.json
+ *   - Missing required provider → error status
+ *   - Backed-off credentials → warning status
+ *   - Remote questions channel check (configured vs missing token)
+ *   - Optional provider unconfigured status
+ *   - formatProviderReport output
+ *   - summariseProviderIssues compaction
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  runProviderChecks,
+  formatProviderReport,
+  summariseProviderIssues,
+  type ProviderCheckResult,
+} from "../doctor-providers.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function withEnv(vars: Record<string, string | undefined>, fn: () => void): 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 {
+    fn();
+  } finally {
+    for (const [k, v] of Object.entries(saved)) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  }
+}
+
+// ─── formatProviderReport ─────────────────────────────────────────────────────
+
+test("formatProviderReport returns fallback for empty results", () => {
+  const out = formatProviderReport([]);
+  assert.equal(out, "No provider checks run.");
+});
+
+test("formatProviderReport shows ok icon for ok status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "ok",
+    message: "Anthropic (Claude) — key present (env)",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("✓"), "should include checkmark for ok");
+  assert.ok(out.includes("Anthropic"), "should include provider name");
+});
+
+test("formatProviderReport shows error icon and detail for error status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "error",
+    message: "Anthropic (Claude) — no API key found",
+    detail: "Set ANTHROPIC_API_KEY or run /gsd keys",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("✗"), "should include cross for error");
+  assert.ok(out.includes("ANTHROPIC_API_KEY"), "should include detail");
+});
+
+test("formatProviderReport shows warning icon for warning status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "slack_bot",
+    label: "Slack Bot",
+    category: "remote",
+    status: "warning",
+    message: "Slack Bot — channel configured but token not found",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("⚠"), "should include warning icon");
+});
+
+test("formatProviderReport groups by category", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm", status: "ok", message: "ok", required: true },
+    { name: "brave", label: "Brave Search", category: "search", status: "unconfigured", message: "not configured", required: false },
+  ];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("LLM Providers"), "should have LLM section");
+  assert.ok(out.includes("Search"), "should have Search section");
+});
+
+test("formatProviderReport omits detail for ok status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "openai",
+    label: "OpenAI",
+    category: "llm",
+    status: "ok",
+    message: "OpenAI — key present (env)",
+    detail: "should not appear",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(!out.includes("should not appear"), "detail should not show for ok");
+});
+
+// ─── summariseProviderIssues ──────────────────────────────────────────────────
+
+test("summariseProviderIssues returns null when no required issues", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm", status: "ok", message: "ok", required: true },
+    { name: "brave", label: "Brave", category: "search", status: "unconfigured", message: "not configured", required: false },
+  ];
+  assert.equal(summariseProviderIssues(results), null);
+});
+
+test("summariseProviderIssues returns error summary for missing required key", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "error",
+    message: "no key",
+    required: true,
+  }];
+  const summary = summariseProviderIssues(results);
+  assert.ok(summary !== null, "should return a summary");
+  assert.ok(summary!.includes("Anthropic"), "should name the provider");
+  assert.ok(summary!.includes("✗"), "should use error icon");
+});
+
+test("summariseProviderIssues returns warning for backed-off required provider", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "warning",
+    message: "backed off",
+    required: true,
+  }];
+  const summary = summariseProviderIssues(results);
+  assert.ok(summary !== null, "should return summary");
+  assert.ok(summary!.includes("⚠"), "should use warning icon");
+});
+
+test("summariseProviderIssues appends count when multiple issues", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm", status: "error", message: "err", required: true },
+    { name: "openai",    label: "OpenAI",    category: "llm", status: "error", message: "err", required: true },
+    { name: "google",    label: "Google",    category: "llm", status: "error", message: "err", required: true },
+  ];
+  const summary = summariseProviderIssues(results);
+  assert.ok(summary!.includes("+2 more"), "should show overflow count");
+});
+
+test("summariseProviderIssues ignores unconfigured optional providers", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm",    status: "ok",           message: "ok", required: true },
+    { name: "brave",     label: "Brave",     category: "search", status: "unconfigured", message: "nc", required: false },
+    { name: "tavily",    label: "Tavily",    category: "search", status: "unconfigured", message: "nc", required: false },
+  ];
+  assert.equal(summariseProviderIssues(results), null, "optional missing providers should not raise issue");
+});
+
+// ─── runProviderChecks — env var detection ────────────────────────────────────
+
+test("runProviderChecks detects Anthropic key from ANTHROPIC_API_KEY env var", () => {
+  // Isolate from real HOME so loadEffectiveGSDPreferences returns null (default → anthropic)
+  // and auth.json lookups hit an empty directory.
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-env-test-")));
+  withEnv({ ANTHROPIC_API_KEY: "sk-ant-test-key", HOME: tmpHome }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when env var set");
+      assert.ok(anthropic!.message.includes("env"), "should report env source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks returns error for Anthropic when no key present", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+  withEnv({ ANTHROPIC_API_KEY: undefined, HOME: tmpHome }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic should be present (default required)");
+      assert.equal(anthropic!.status, "error", "should be error when no key");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks optional providers have required=false", () => {
+  const results = runProviderChecks();
+  const optional = results.filter(r => ["brave", "tavily", "jina", "context7"].includes(r.name));
+  for (const r of optional) {
+    assert.equal(r.required, false, `${r.name} should not be required`);
+  }
+});
+
+test("runProviderChecks optional providers show unconfigured when no key", () => {
+  withEnv(
+    { BRAVE_API_KEY: undefined, TAVILY_API_KEY: undefined, JINA_API_KEY: undefined, CONTEXT7_API_KEY: undefined },
+    () => {
+      const origHome = process.env.HOME;
+      process.env.HOME = mkdtempSync(join(tmpdir(), "gsd-providers-test-"));
+      try {
+        const results = runProviderChecks();
+        const brave = results.find(r => r.name === "brave");
+        assert.ok(brave, "brave should be present");
+        assert.equal(brave!.status, "unconfigured", "should be unconfigured");
+      } finally {
+        rmSync(process.env.HOME!, { recursive: true, force: true });
+        process.env.HOME = origHome;
+      }
+    }
+  );
+});
+
+test("runProviderChecks optional providers show ok when key set", () => {
+  withEnv({ BRAVE_API_KEY: "test-brave-key" }, () => {
+    const results = runProviderChecks();
+    const brave = results.find(r => r.name === "brave");
+    assert.ok(brave, "brave should be present");
+    assert.equal(brave!.status, "ok", "should be ok when env var set");
+  });
+});
+
+// ─── runProviderChecks — auth.json detection ─────────────────────────────────
+
+test("runProviderChecks detects key from auth.json", () => {
+  withEnv({ ANTHROPIC_API_KEY: undefined }, () => {
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(agentDir, { recursive: true });
+
+    // AuthStorage persists credentials with provider ID as the top-level key:
+    // { "anthropic": { "type": "api_key", "key": "..." } }
+    const authData = {
+      anthropic: { type: "api_key", key: "sk-ant-from-auth-json" },
+    };
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+    withEnv({ HOME: tmpHome }, () => {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic should be present");
+      assert.equal(anthropic!.status, "ok", "should be ok with auth.json key");
+      assert.ok(anthropic!.message.includes("auth.json"), "should report auth.json source");
+    });
+
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+});
+
+test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
+  withEnv({ ANTHROPIC_API_KEY: undefined }, () => {
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(agentDir, { recursive: true });
+
+    // Empty key — what onboarding writes when user skips
+    const authData = {
+      anthropic: { type: "api_key", key: "" },
+    };
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+    withEnv({ HOME: tmpHome }, () => {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic should be present");
+      assert.equal(anthropic!.status, "error", "empty placeholder key should count as not configured");
+    });
+
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+});

package/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts

@@ -119,6 +119,9 @@ function mockData(overrides: Partial<VisualizerData> = {}): VisualizerData {
       toolCalls: 40,
       assistantMessages: 20,
       userMessages: 12,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
     discussion: [],
     stats: { missingCount: 0, missingSlices: [], updatedCount: 0, updatedSlices: [], recentEntries: [] },

package/src/resources/extensions/gsd/tests/memory-leak-guards.test.ts

@@ -7,7 +7,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -23,7 +23,11 @@ function createCtx(entries: unknown[]) {
 
 test("clearActivityLogState resets dedup state so identical saves write again", () => {
   clearActivityLogState();
-  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-test-"));
+  // Pre-resolve baseDir so gsdRoot() returns a stable key across calls.
+  // On macOS, /tmp is a symlink to /private/tmp — without realpathSync, the
+  // key changes between the first save (dir doesn't exist, realpathSync throws)
+  // and subsequent saves (dir exists, realpathSync resolves to /private/tmp/...).
+  const baseDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-memleak-test-")));
   try {
     const entries = [{ role: "assistant", content: "test entry" }];
     const ctx = createCtx(entries);
@@ -53,7 +57,7 @@ test("clearActivityLogState resets dedup state so identical saves write again",
 
 test("saveActivityLog writes valid JSONL via streaming", () => {
   clearActivityLogState();
-  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-"));
+  const baseDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-")));
   try {
     const entries = [
       { type: "message", message: { role: "user", content: "hello" } },