gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

package/packages/mcp-server/src/secure-env-collect.test.ts

@@ -1,265 +1,260 @@
-// @gsd-build/mcp-server — Tests for secure_env_collect MCP tool
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// @gsd-build/mcp-server — Behaviour tests for secure_env_collect MCP tool
 //
-// Tests the secure_env_collect tool registered in createMcpServer.
-// Uses a mock MCP server to intercept tool registration and elicitInput calls.
-
-import { describe, it, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { createMcpServer } from './server.js';
-import { SessionManager } from './session-manager.js';
-
-// ---------------------------------------------------------------------------
-// Mock infrastructure
-// ---------------------------------------------------------------------------
-
-/**
- * We intercept McpServer construction by monkey-patching the dynamic import.
- * Instead, we'll test the tool handler indirectly through the exported
- * createMcpServer function — capturing the registered tool handlers.
- *
- * Since createMcpServer dynamically imports McpServer, we need to test at
- * a level that exercises the tool handler logic. We do this by extracting
- * the tool handler through the server.tool() calls.
- */
-
-interface RegisteredTool {
-  name: string;
-  description: string;
-  params: Record<string, unknown>;
-  handler: (args: Record<string, unknown>) => Promise<unknown>;
-}
-
-interface ToolResult {
+// Drives `secureEnvCollectHandler` directly with a fake `elicitInput`
+// function. No mock McpServer, no DI seam on `createMcpServer` — the
+// handler is an exported top-level function that takes the elicitation
+// callback as a parameter. Production `createMcpServer` wraps it with
+// `server.server.elicitInput`.
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  writeFileSync,
+  readFileSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { secureEnvCollectHandler, type ElicitInputFn } from "./server.js";
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+type ElicitResponse = {
+  action: "accept" | "cancel" | "decline";
+  content?: Record<string, unknown>;
+};
+
+interface ToolContentShape {
   content?: Array<{ type: string; text: string }>;
   isError?: boolean;
 }
 
-/**
- * Mock McpServer that captures tool registrations and provides
- * a controllable elicitInput response.
- */
-class MockMcpServer {
-  registeredTools: RegisteredTool[] = [];
-  elicitResponse: { action: string; content?: Record<string, unknown> } = { action: 'accept', content: {} };
-
-  server = {
-    elicitInput: async (_params: unknown) => {
-      return this.elicitResponse;
-    },
-  };
-
-  tool(name: string, description: string, params: Record<string, unknown>, handler: (args: Record<string, unknown>) => Promise<unknown>) {
-    this.registeredTools.push({ name, description, params, handler });
-  }
-
-  async connect(_transport: unknown) { /* no-op */ }
-  async close() { /* no-op */ }
-
-  getToolHandler(name: string): ((args: Record<string, unknown>) => Promise<unknown>) | undefined {
-    return this.registeredTools.find((t) => t.name === name)?.handler;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helper to create a mock MCP server with secure_env_collect registered
-// ---------------------------------------------------------------------------
-
-/**
- * Since createMcpServer uses dynamic import for McpServer, we can't easily
- * mock it. Instead, we test the env-writer utilities directly (in env-writer.test.ts)
- * and test the tool integration by verifying:
- * 1. The tool exists in the registered tools list
- * 2. The handler produces correct results with mock data
- *
- * For handler-level testing, we create a standalone test that replicates
- * the tool handler logic with a controllable mock.
- */
-
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `${prefix}-`));
 }
 
-// ---------------------------------------------------------------------------
-// Integration test — verify tool is registered
-// ---------------------------------------------------------------------------
-
-describe('secure_env_collect tool registration', () => {
-  it('createMcpServer registers secure_env_collect tool', async () => {
-    // This test verifies the tool exists — createMcpServer internally calls
-    // server.tool('secure_env_collect', ...) which we can't intercept without
-    // module mocking, but we can verify the server creates successfully
-    const sm = new SessionManager();
-    try {
-      const { server } = await createMcpServer(sm);
-      assert.ok(server, 'server should be created');
-      // The McpServer internally tracks registered tools — we verify no error
-    } finally {
-      await sm.cleanup();
-    }
-  });
-});
+function textOf(result: unknown): string {
+  const r = result as ToolContentShape;
+  return (r.content ?? []).map((c) => c.text).join("\n");
+}
 
-// ---------------------------------------------------------------------------
-// Handler logic tests — using env-writer directly to test the flow
-// ---------------------------------------------------------------------------
-
-describe('secure_env_collect handler logic', () => {
-  it('skips keys that already exist in .env', async () => {
-    const tmp = makeTempDir('sec-collect');
-    try {
-      const envPath = join(tmp, '.env');
-      writeFileSync(envPath, 'ALREADY_SET=existing-value\n');
-
-      // Import the utility directly to test the pre-check logic
-      const { checkExistingEnvKeys } = await import('./env-writer.js');
-      const existing = await checkExistingEnvKeys(['ALREADY_SET', 'NEW_KEY'], envPath);
-      assert.deepStrictEqual(existing, ['ALREADY_SET']);
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  });
+/** Build a fake elicitInput that returns a pre-programmed response and records calls. */
+function fakeElicit(response: ElicitResponse): {
+  fn: ElicitInputFn;
+  calls: unknown[];
+} {
+  const calls: unknown[] = [];
+  const fn: ElicitInputFn = async (params) => {
+    calls.push(params);
+    return response;
+  };
+  return { fn, calls };
+}
 
-  it('writes collected values to .env without returning secret values', async () => {
-    const tmp = makeTempDir('sec-collect');
-    try {
-      const envPath = join(tmp, '.env');
-      const savedKey = process.env.SEC_COLLECT_TEST_KEY;
-
-      const { applySecrets } = await import('./env-writer.js');
-      const { applied, errors } = await applySecrets(
-        [{ key: 'SEC_COLLECT_TEST_KEY', value: 'super-secret-value' }],
-        'dotenv',
-        { envFilePath: envPath },
-      );
+// ─── Tests ─────────────────────────────────────────────────────────────
 
-      assert.deepStrictEqual(applied, ['SEC_COLLECT_TEST_KEY']);
-      assert.deepStrictEqual(errors, []);
+describe("secure_env_collect — handler behaviour", () => {
+  let tmp: string;
 
-      // Verify the value was written
-      const content = readFileSync(envPath, 'utf8');
-      assert.ok(content.includes('SEC_COLLECT_TEST_KEY=super-secret-value'));
+  beforeEach(() => {
+    tmp = makeTempDir("sec-collect");
+  });
 
-      // Verify process.env was hydrated
-      assert.equal(process.env.SEC_COLLECT_TEST_KEY, 'super-secret-value');
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
 
-      // Cleanup
-      if (savedKey === undefined) delete process.env.SEC_COLLECT_TEST_KEY;
-      else process.env.SEC_COLLECT_TEST_KEY = savedKey;
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
+  it("short-circuits with 'already set' when every key exists", async () => {
+    const envPath = join(tmp, ".env");
+    writeFileSync(envPath, "FIRST=1\nSECOND=2\n");
+
+    const { fn, calls } = fakeElicit({ action: "accept", content: {} });
+
+    const result = await secureEnvCollectHandler(
+      {
+        projectDir: tmp,
+        keys: [{ key: "FIRST" }, { key: "SECOND" }],
+        destination: "dotenv",
+        // envFilePath omitted — handler defaults to '.env' inside projectDir.
+        // Passing an absolute envFilePath trips the realpath-vs-symlink
+        // containment check on macOS tmpdirs (/var vs /private/var).
+      },
+      fn,
+    );
+
+    const text = textOf(result);
+    assert.match(text, /already set/);
+    assert.match(text, /FIRST/);
+    assert.match(text, /SECOND/);
+    // Elicit was NOT called — short-circuit path.
+    assert.equal(calls.length, 0);
   });
 
-  it('auto-detects vercel destination from vercel.json', async () => {
-    const tmp = makeTempDir('sec-collect');
-    try {
-      writeFileSync(join(tmp, 'vercel.json'), '{}');
-      const { detectDestination } = await import('./env-writer.js');
-      assert.equal(detectDestination(tmp), 'vercel');
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
+  it("writes provided values to .env and never returns the secret in output", async () => {
+    const envPath = join(tmp, ".env");
+
+    const { fn } = fakeElicit({
+      action: "accept",
+      content: { SEC_KEY_WRITE: "sk-definitely-not-in-output-xyz" },
+    });
+
+    const result = await secureEnvCollectHandler(
+      {
+        projectDir: tmp,
+        keys: [{ key: "SEC_KEY_WRITE" }],
+        destination: "dotenv",
+      },
+      fn,
+    );
+
+    const text = textOf(result);
+    // .env must contain the value.
+    assert.match(
+      readFileSync(envPath, "utf-8"),
+      /SEC_KEY_WRITE=sk-definitely-not-in-output-xyz/,
+    );
+    // But the tool output must NOT — this is the contract the tool name promises.
+    assert.ok(
+      !text.includes("sk-definitely-not-in-output-xyz"),
+      `tool output must not contain secret. got: ${text}`,
+    );
+    assert.match(text, /SEC_KEY_WRITE.*applied/);
+
+    // Cleanup the process.env hydration applySecrets does.
+    delete process.env.SEC_KEY_WRITE;
   });
 
-  it('handles empty form values as skipped', async () => {
-    // Simulate what happens when user leaves a field empty in the form
-    const formContent: Record<string, string> = {
-      'API_KEY': 'provided-value',
-      'OPTIONAL_KEY': '',        // empty = skip
-    };
-
-    const provided: Array<{ key: string; value: string }> = [];
-    const skipped: string[] = [];
-
-    for (const [key, raw] of Object.entries(formContent)) {
-      const value = typeof raw === 'string' ? raw.trim() : '';
-      if (value.length > 0) {
-        provided.push({ key, value });
-      } else {
-        skipped.push(key);
-      }
-    }
+  it("separates empty form fields into 'skipped' without writing them", async () => {
+    const envPath = join(tmp, ".env");
+
+    const { fn } = fakeElicit({
+      action: "accept",
+      content: {
+        FILLED_KEY: "real-value",
+        // Empty string — the handler MUST classify this as skipped.
+        EMPTY_KEY: "",
+        // Whitespace-only — must also classify as skipped (trim).
+        WS_KEY: "   ",
+      },
+    });
+
+    const result = await secureEnvCollectHandler(
+      {
+        projectDir: tmp,
+        keys: [
+          { key: "FILLED_KEY" },
+          { key: "EMPTY_KEY" },
+          { key: "WS_KEY" },
+        ],
+        destination: "dotenv",
+      },
+      fn,
+    );
+
+    const text = textOf(result);
+    assert.match(text, /FILLED_KEY.*applied/, "FILLED_KEY should be applied");
+    assert.match(text, /EMPTY_KEY.*skipped/, "EMPTY_KEY should be skipped");
+    assert.match(text, /WS_KEY.*skipped/, "WS_KEY should be skipped");
+
+    // The .env must only contain the filled key.
+    const envContent = readFileSync(envPath, "utf-8");
+    assert.match(envContent, /FILLED_KEY=real-value/);
+    assert.ok(
+      !envContent.includes("EMPTY_KEY="),
+      "empty form field must not be written to .env",
+    );
+    assert.ok(
+      !envContent.includes("WS_KEY="),
+      "whitespace-only form field must not be written to .env",
+    );
+
+    delete process.env.FILLED_KEY;
+  });
 
-    assert.deepStrictEqual(provided, [{ key: 'API_KEY', value: 'provided-value' }]);
-    assert.deepStrictEqual(skipped, ['OPTIONAL_KEY']);
+  it("handles a mix of existing, new, and skipped keys in one call", async () => {
+    const envPath = join(tmp, ".env");
+    writeFileSync(envPath, "EXISTING_MIX=already-here\n");
+
+    const { fn, calls } = fakeElicit({
+      action: "accept",
+      content: { NEW_MIX: "new-value", SKIP_MIX: "" },
+    });
+
+    const result = await secureEnvCollectHandler(
+      {
+        projectDir: tmp,
+        keys: [
+          { key: "EXISTING_MIX" },
+          { key: "NEW_MIX" },
+          { key: "SKIP_MIX" },
+        ],
+        destination: "dotenv",
+      },
+      fn,
+    );
+
+    const text = textOf(result);
+    assert.match(text, /EXISTING_MIX.*already set/);
+    assert.match(text, /NEW_MIX.*applied/);
+    assert.match(text, /SKIP_MIX.*skipped/);
+    // Only the new one was elicited for (existing was pre-filtered).
+    assert.equal(calls.length, 1);
+
+    delete process.env.NEW_MIX;
   });
 
-  it('result text never contains secret values', async () => {
-    const tmp = makeTempDir('sec-collect');
-    try {
-      const envPath = join(tmp, '.env');
-      const savedKey = process.env.RESULT_TEXT_TEST;
-
-      const { applySecrets } = await import('./env-writer.js');
-      const { applied } = await applySecrets(
-        [{ key: 'RESULT_TEXT_TEST', value: 'sk-super-secret-abc123' }],
-        'dotenv',
-        { envFilePath: envPath },
+  it("returns a cancellation message when user declines the form", async () => {
+    const envPath = join(tmp, ".env");
+
+    const { fn } = fakeElicit({ action: "cancel" });
+
+    const result = await secureEnvCollectHandler(
+      {
+        projectDir: tmp,
+        keys: [{ key: "CANCELLED_KEY" }],
+        destination: "dotenv",
+      },
+      fn,
+    );
+
+    const text = textOf(result);
+    assert.match(text, /cancelled/i);
+    // No .env write on cancel: either the file wasn't created at all, or
+    // if it was it doesn't contain the key.
+    const { existsSync: exists } = await import("node:fs");
+    if (exists(envPath)) {
+      assert.ok(
+        !readFileSync(envPath, "utf-8").includes("CANCELLED_KEY="),
+        ".env should not contain key on cancel",
       );
-
-      // Simulate building result text (same logic as the tool handler)
-      const lines: string[] = [
-        'destination: dotenv (auto-detected)',
-        ...applied.map((k) => `✓ ${k}: applied`),
-      ];
-      const resultText = lines.join('\n');
-
-      // The result MUST NOT contain the secret value
-      assert.ok(!resultText.includes('sk-super-secret-abc123'), 'result text must not contain secret value');
-      assert.ok(resultText.includes('RESULT_TEXT_TEST'), 'result text should contain key name');
-
-      // Cleanup
-      if (savedKey === undefined) delete process.env.RESULT_TEXT_TEST;
-      else process.env.RESULT_TEXT_TEST = savedKey;
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
     }
   });
 
-  it('handles multiple keys with mixed existing/new/skipped', async () => {
-    const tmp = makeTempDir('sec-collect');
-    try {
-      const envPath = join(tmp, '.env');
-      writeFileSync(envPath, 'EXISTING_A=already-here\n');
-      const savedB = process.env.NEW_B;
-      const savedC = process.env.SKIP_C;
-
-      const { checkExistingEnvKeys, applySecrets } = await import('./env-writer.js');
-
-      const allKeys = ['EXISTING_A', 'NEW_B', 'SKIP_C'];
-      const existing = await checkExistingEnvKeys(allKeys, envPath);
-      assert.deepStrictEqual(existing, ['EXISTING_A']);
-
-      // Simulate form response: NEW_B has value, SKIP_C is empty
-      const formContent = { NEW_B: 'new-value', SKIP_C: '' };
-      const provided: Array<{ key: string; value: string }> = [];
-      const skipped: string[] = [];
-
-      for (const key of allKeys.filter((k) => !existing.includes(k))) {
-        const raw = formContent[key as keyof typeof formContent] ?? '';
-        if (raw.trim().length > 0) provided.push({ key, value: raw.trim() });
-        else skipped.push(key);
-      }
-
-      const { applied, errors } = await applySecrets(provided, 'dotenv', { envFilePath: envPath });
-
-      assert.deepStrictEqual(applied, ['NEW_B']);
-      assert.deepStrictEqual(skipped, ['SKIP_C']);
-      assert.deepStrictEqual(errors, []);
-      assert.deepStrictEqual(existing, ['EXISTING_A']);
-
-      // Cleanup
-      if (savedB === undefined) delete process.env.NEW_B;
-      else process.env.NEW_B = savedB;
-      if (savedC === undefined) delete process.env.SKIP_C;
-      else process.env.SKIP_C = savedC;
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
+  it("auto-detects destination from project files when not specified", async () => {
+    // No vercel/convex signals — falls back to dotenv.
+    const { fn } = fakeElicit({
+      action: "accept",
+      content: { AUTO_DETECT_KEY: "auto-value" },
+    });
+
+    const result = await secureEnvCollectHandler(
+      {
+        projectDir: tmp,
+        keys: [{ key: "AUTO_DETECT_KEY" }],
+        // Intentionally omit `destination` — handler should auto-detect.
+      },
+      fn,
+    );
+
+    const text = textOf(result);
+    assert.match(
+      text,
+      /auto-detected/,
+      "result should announce an auto-detected destination",
+    );
+
+    delete process.env.AUTO_DETECT_KEY;
   });
 });