@meshxdata/fops 0.0.1 → 0.0.4

package/src/auth/login.test.js

@@ -1,192 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-vi.mock("execa", () => ({
-  execaSync: vi.fn(),
-}));
-
-vi.mock("inquirer", () => ({
-  default: { prompt: vi.fn() },
-}));
-
-vi.mock("./resolve.js", () => ({
-  CLAUDE_DIR: path.join(os.tmpdir(), ".claude-test-login"),
-  CLAUDE_CREDENTIALS: path.join(os.tmpdir(), ".claude-test-login", ".credentials.json"),
-  CLAUDE_JSON: path.join(os.tmpdir(), ".claude-test-login", ".claude.json"),
-  resolveAnthropicApiKey: vi.fn(() => null),
-  readJsonKey: vi.fn(),
-}));
-
-const { CLAUDE_DIR, CLAUDE_CREDENTIALS } = await import("./resolve.js");
-const { execaSync } = await import("execa");
-const { authHelp, openBrowser, saveApiKey, LOGIN_HTML } = await import("./login.js");
-
-describe("auth/login", () => {
-  beforeEach(() => {
-    if (fs.existsSync(CLAUDE_DIR)) fs.rmSync(CLAUDE_DIR, { recursive: true, force: true });
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(CLAUDE_DIR)) fs.rmSync(CLAUDE_DIR, { recursive: true, force: true });
-  });
-
-  describe("authHelp", () => {
-    it("prints help text about API keys", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      authHelp();
-      expect(spy).toHaveBeenCalled();
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("API key");
-    });
-
-    it("mentions environment variables", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      authHelp();
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("ANTHROPIC_API_KEY");
-      expect(output).toContain("OPENAI_API_KEY");
-    });
-
-    it("mentions credentials file", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      authHelp();
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain(".credentials.json");
-    });
-
-    it("mentions apiKeyHelper", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      authHelp();
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("apiKeyHelper");
-    });
-  });
-
-  describe("openBrowser", () => {
-    it("calls open on darwin", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      const result = openBrowser("https://example.com");
-      expect(execaSync).toHaveBeenCalledWith("open", ["https://example.com"], { reject: false });
-      expect(result).toBe(true);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("calls xdg-open on linux", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "linux" });
-      execaSync.mockReturnValue({});
-      openBrowser("https://example.com");
-      expect(execaSync).toHaveBeenCalledWith("xdg-open", ["https://example.com"], { reject: false });
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("calls start on win32", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "win32" });
-      execaSync.mockReturnValue({});
-      openBrowser("https://example.com");
-      expect(execaSync).toHaveBeenCalledWith("start", ["https://example.com"], { reject: false });
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns false on error", () => {
-      execaSync.mockImplementation(() => { throw new Error("fail"); });
-      expect(openBrowser("https://example.com")).toBe(false);
-    });
-
-    it("returns true on success", () => {
-      execaSync.mockReturnValue({});
-      expect(openBrowser("https://example.com")).toBe(true);
-    });
-  });
-
-  describe("saveApiKey", () => {
-    it("creates directory and saves key", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      saveApiKey("sk-ant-api03-test123");
-      expect(fs.existsSync(CLAUDE_CREDENTIALS)).toBe(true);
-      const creds = JSON.parse(fs.readFileSync(CLAUDE_CREDENTIALS, "utf8"));
-      expect(creds.anthropic_api_key).toBe("sk-ant-api03-test123");
-    });
-
-    it("preserves existing keys", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      fs.mkdirSync(CLAUDE_DIR, { recursive: true });
-      fs.writeFileSync(CLAUDE_CREDENTIALS, JSON.stringify({ openai_api_key: "sk-openai" }));
-      saveApiKey("sk-ant-api03-new");
-      const creds = JSON.parse(fs.readFileSync(CLAUDE_CREDENTIALS, "utf8"));
-      expect(creds.anthropic_api_key).toBe("sk-ant-api03-new");
-      expect(creds.openai_api_key).toBe("sk-openai");
-    });
-
-    it("trims the API key", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      saveApiKey("  sk-ant-api03-trimme  ");
-      const creds = JSON.parse(fs.readFileSync(CLAUDE_CREDENTIALS, "utf8"));
-      expect(creds.anthropic_api_key).toBe("sk-ant-api03-trimme");
-    });
-
-    it("overwrites existing anthropic key", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      fs.mkdirSync(CLAUDE_DIR, { recursive: true });
-      fs.writeFileSync(CLAUDE_CREDENTIALS, JSON.stringify({ anthropic_api_key: "old-key" }));
-      saveApiKey("new-key");
-      const creds = JSON.parse(fs.readFileSync(CLAUDE_CREDENTIALS, "utf8"));
-      expect(creds.anthropic_api_key).toBe("new-key");
-    });
-
-    it("handles corrupted existing credentials", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      fs.mkdirSync(CLAUDE_DIR, { recursive: true });
-      fs.writeFileSync(CLAUDE_CREDENTIALS, "not valid json{{{");
-      saveApiKey("sk-ant-api03-fresh");
-      const creds = JSON.parse(fs.readFileSync(CLAUDE_CREDENTIALS, "utf8"));
-      expect(creds.anthropic_api_key).toBe("sk-ant-api03-fresh");
-    });
-
-    it("returns true", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      expect(saveApiKey("sk-ant-api03-x")).toBe(true);
-    });
-
-    it("prints success message", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      saveApiKey("sk-ant-api03-x");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("Login successful");
-    });
-  });
-
-  describe("LOGIN_HTML", () => {
-    it("contains expected HTML structure", () => {
-      expect(LOGIN_HTML).toContain("<!DOCTYPE html>");
-      expect(LOGIN_HTML).toContain("Foundation CLI Login");
-      expect(LOGIN_HTML).toContain("sk-ant-api");
-    });
-
-    it("contains form elements", () => {
-      expect(LOGIN_HTML).toContain("<form");
-      expect(LOGIN_HTML).toContain("api-key");
-      expect(LOGIN_HTML).toContain("submit-btn");
-    });
-
-    it("contains validation logic", () => {
-      expect(LOGIN_HTML).toContain("sk-ant-api");
-      expect(LOGIN_HTML).toContain("/callback");
-    });
-
-    it("contains success view", () => {
-      expect(LOGIN_HTML).toContain("success-view");
-      expect(LOGIN_HTML).toContain("Login Successful");
-    });
-
-    it("has step-by-step instructions", () => {
-      expect(LOGIN_HTML).toContain("step-num");
-      expect(LOGIN_HTML).toContain("console.anthropic.com");
-    });
-  });
-});

package/src/auth/oauth.test.js

@@ -1,118 +0,0 @@
-import { describe, it, expect } from "vitest";
-import crypto from "node:crypto";
-import { OAUTH_CONFIG, generatePKCE, getResultHTML } from "./oauth.js";
-
-describe("auth/oauth", () => {
-  describe("OAUTH_CONFIG", () => {
-    it("has required OAuth fields", () => {
-      expect(OAUTH_CONFIG.authorizationEndpoint).toContain("claude.ai");
-      expect(OAUTH_CONFIG.tokenEndpoint).toContain("claude.ai");
-      expect(typeof OAUTH_CONFIG.clientId).toBe("string");
-      expect(OAUTH_CONFIG.clientId.length).toBeGreaterThan(0);
-      expect(OAUTH_CONFIG.scope).toBe("user:inference");
-    });
-
-    it("authorization endpoint is a valid URL", () => {
-      expect(() => new URL(OAUTH_CONFIG.authorizationEndpoint)).not.toThrow();
-    });
-
-    it("token endpoint is a valid URL", () => {
-      expect(() => new URL(OAUTH_CONFIG.tokenEndpoint)).not.toThrow();
-    });
-
-    it("clientId is a UUID format", () => {
-      expect(OAUTH_CONFIG.clientId).toMatch(
-        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
-      );
-    });
-
-    it("endpoints use HTTPS", () => {
-      expect(OAUTH_CONFIG.authorizationEndpoint).toMatch(/^https:/);
-      expect(OAUTH_CONFIG.tokenEndpoint).toMatch(/^https:/);
-    });
-  });
-
-  describe("generatePKCE", () => {
-    it("returns verifier and challenge", () => {
-      const { verifier, challenge } = generatePKCE();
-      expect(typeof verifier).toBe("string");
-      expect(typeof challenge).toBe("string");
-      expect(verifier.length).toBeGreaterThan(0);
-      expect(challenge.length).toBeGreaterThan(0);
-    });
-
-    it("generates base64url strings (no +, /, = chars)", () => {
-      const { verifier, challenge } = generatePKCE();
-      expect(verifier).toMatch(/^[A-Za-z0-9_-]+$/);
-      expect(challenge).toMatch(/^[A-Za-z0-9_-]+$/);
-    });
-
-    it("generates unique values each time", () => {
-      const a = generatePKCE();
-      const b = generatePKCE();
-      expect(a.verifier).not.toBe(b.verifier);
-      expect(a.challenge).not.toBe(b.challenge);
-    });
-
-    it("challenge is SHA-256 of verifier", () => {
-      const { verifier, challenge } = generatePKCE();
-      const expected = crypto.createHash("sha256").update(verifier).digest("base64url");
-      expect(challenge).toBe(expected);
-    });
-
-    it("verifier is 43 chars (32 bytes base64url)", () => {
-      const { verifier } = generatePKCE();
-      // 32 bytes in base64url = ceil(32 * 4/3) = 43 chars
-      expect(verifier.length).toBe(43);
-    });
-
-    it("challenge is 43 chars (SHA-256 = 32 bytes base64url)", () => {
-      const { challenge } = generatePKCE();
-      expect(challenge.length).toBe(43);
-    });
-  });
-
-  describe("getResultHTML", () => {
-    it("returns success HTML", () => {
-      const html = getResultHTML(true, "All good");
-      expect(html).toContain("<!DOCTYPE html>");
-      expect(html).toContain("Success");
-      expect(html).toContain("All good");
-      expect(html).toContain("#4ade80");
-    });
-
-    it("returns error HTML", () => {
-      const html = getResultHTML(false, "Something failed");
-      expect(html).toContain("Error");
-      expect(html).toContain("Something failed");
-      expect(html).toContain("#f87171");
-    });
-
-    it("success uses checkmark icon", () => {
-      const html = getResultHTML(true, "ok");
-      expect(html).toContain("✓");
-    });
-
-    it("error uses cross icon", () => {
-      const html = getResultHTML(false, "fail");
-      expect(html).toContain("✗");
-    });
-
-    it("escapes message into HTML body", () => {
-      const html = getResultHTML(true, "Token saved");
-      expect(html).toContain("Token saved");
-    });
-
-    it("returns valid HTML with head and body", () => {
-      const html = getResultHTML(true, "test");
-      expect(html).toContain("<head>");
-      expect(html).toContain("<body>");
-      expect(html).toContain("</html>");
-    });
-
-    it("includes Foundation CLI title", () => {
-      const html = getResultHTML(true, "test");
-      expect(html).toContain("Foundation CLI");
-    });
-  });
-});

package/src/auth/resolve.test.js

@@ -1,153 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-vi.mock("execa", () => ({
-  execaSync: vi.fn(),
-}));
-
-describe("auth/resolve", () => {
-  describe("readJsonKey", () => {
-    let readJsonKey;
-
-    beforeEach(async () => {
-      ({ readJsonKey } = await import("./resolve.js"));
-    });
-
-    it("returns first matching string key", () => {
-      expect(readJsonKey({ apiKey: "sk-123" }, ["apiKey"])).toBe("sk-123");
-    });
-
-    it("tries multiple keys in order", () => {
-      expect(readJsonKey({ api_key: "sk-456" }, ["apiKey", "api_key"])).toBe("sk-456");
-    });
-
-    it("returns first match when multiple keys exist", () => {
-      expect(readJsonKey({ apiKey: "first", api_key: "second" }, ["apiKey", "api_key"])).toBe("first");
-    });
-
-    it("trims whitespace", () => {
-      expect(readJsonKey({ apiKey: "  sk-789  " }, ["apiKey"])).toBe("sk-789");
-    });
-
-    it("returns null for empty string", () => {
-      expect(readJsonKey({ apiKey: "  " }, ["apiKey"])).toBe(null);
-    });
-
-    it("returns null for non-string values", () => {
-      expect(readJsonKey({ apiKey: 123 }, ["apiKey"])).toBe(null);
-      expect(readJsonKey({ apiKey: true }, ["apiKey"])).toBe(null);
-      expect(readJsonKey({ apiKey: null }, ["apiKey"])).toBe(null);
-      expect(readJsonKey({ apiKey: [] }, ["apiKey"])).toBe(null);
-      expect(readJsonKey({ apiKey: {} }, ["apiKey"])).toBe(null);
-    });
-
-    it("returns null for null/undefined input", () => {
-      expect(readJsonKey(null, ["apiKey"])).toBe(null);
-      expect(readJsonKey(undefined, ["apiKey"])).toBe(null);
-    });
-
-    it("returns null for non-object input", () => {
-      expect(readJsonKey("string", ["apiKey"])).toBe(null);
-      expect(readJsonKey(42, ["apiKey"])).toBe(null);
-      expect(readJsonKey(true, ["apiKey"])).toBe(null);
-    });
-
-    it("returns null when key is not found", () => {
-      expect(readJsonKey({ other: "value" }, ["apiKey"])).toBe(null);
-    });
-
-    it("skips empty keys and continues", () => {
-      expect(readJsonKey({ first: "", second: "found" }, ["first", "second"])).toBe("found");
-    });
-  });
-
-  describe("resolveAnthropicApiKey", () => {
-    let resolveAnthropicApiKey;
-    const originalEnv = { ...process.env };
-
-    beforeEach(async () => {
-      vi.resetModules();
-      vi.mock("execa", () => ({ execaSync: vi.fn() }));
-      ({ resolveAnthropicApiKey } = await import("./resolve.js"));
-      delete process.env.ANTHROPIC_API_KEY;
-    });
-
-    afterEach(() => {
-      process.env = { ...originalEnv };
-    });
-
-    it("returns env var when set", () => {
-      process.env.ANTHROPIC_API_KEY = "sk-ant-api03-env";
-      expect(resolveAnthropicApiKey()).toBe("sk-ant-api03-env");
-    });
-
-    it("trims env var whitespace", () => {
-      process.env.ANTHROPIC_API_KEY = "  sk-ant-api03-padded  ";
-      expect(resolveAnthropicApiKey()).toBe("sk-ant-api03-padded");
-    });
-
-    it("returns null when nothing is configured", () => {
-      const result = resolveAnthropicApiKey();
-      expect(result === null || typeof result === "string").toBe(true);
-    });
-
-    it("prioritizes env var over files", () => {
-      process.env.ANTHROPIC_API_KEY = "sk-ant-api03-env-wins";
-      // Even if files exist, env should be returned
-      expect(resolveAnthropicApiKey()).toBe("sk-ant-api03-env-wins");
-    });
-  });
-
-  describe("resolveOpenAiApiKey", () => {
-    let resolveOpenAiApiKey;
-    const originalEnv = { ...process.env };
-
-    beforeEach(async () => {
-      vi.resetModules();
-      vi.mock("execa", () => ({ execaSync: vi.fn() }));
-      ({ resolveOpenAiApiKey } = await import("./resolve.js"));
-      delete process.env.OPENAI_API_KEY;
-    });
-
-    afterEach(() => {
-      process.env = { ...originalEnv };
-    });
-
-    it("returns env var when set", () => {
-      process.env.OPENAI_API_KEY = "sk-openai-env";
-      expect(resolveOpenAiApiKey()).toBe("sk-openai-env");
-    });
-
-    it("trims env var whitespace", () => {
-      process.env.OPENAI_API_KEY = "  sk-openai-padded  ";
-      expect(resolveOpenAiApiKey()).toBe("sk-openai-padded");
-    });
-
-    it("returns null when nothing configured", () => {
-      const result = resolveOpenAiApiKey();
-      expect(result === null || typeof result === "string").toBe(true);
-    });
-  });
-
-  describe("CLAUDE_DIR / CLAUDE_JSON / CLAUDE_CREDENTIALS exports", () => {
-    let CLAUDE_DIR, CLAUDE_JSON, CLAUDE_CREDENTIALS;
-
-    beforeEach(async () => {
-      ({ CLAUDE_DIR, CLAUDE_JSON, CLAUDE_CREDENTIALS } = await import("./resolve.js"));
-    });
-
-    it("CLAUDE_DIR points to ~/.claude", () => {
-      expect(CLAUDE_DIR).toBe(path.join(os.homedir(), ".claude"));
-    });
-
-    it("CLAUDE_JSON points to ~/.claude.json", () => {
-      expect(CLAUDE_JSON).toBe(path.join(os.homedir(), ".claude.json"));
-    });
-
-    it("CLAUDE_CREDENTIALS points to ~/.claude/.credentials.json", () => {
-      expect(CLAUDE_CREDENTIALS).toBe(path.join(os.homedir(), ".claude", ".credentials.json"));
-    });
-  });
-});

package/src/config.test.js

@@ -1,70 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import os from "node:os";
-import { PKG, CLI_BRAND, printFoundationBanner } from "./config.js";
-
-describe("config", () => {
-  describe("PKG", () => {
-    it("exports name and version", () => {
-      expect(PKG.name).toBe("@meshxdata/fops");
-      expect(typeof PKG.version).toBe("string");
-      expect(PKG.version).toMatch(/^\d+\.\d+\.\d+/);
-    });
-
-    it("only exposes name and version (no extra fields)", () => {
-      expect(Object.keys(PKG).sort()).toEqual(["name", "version"]);
-    });
-  });
-
-  describe("CLI_BRAND", () => {
-    it("has the expected shape", () => {
-      expect(CLI_BRAND.title).toBe("Foundation Operator CLI");
-      expect(CLI_BRAND.version).toMatch(/^v\d+/);
-      expect(CLI_BRAND.byline).toContain("meshx");
-    });
-
-    it("version matches PKG.version", () => {
-      expect(CLI_BRAND.version).toBe(`v${PKG.version}`);
-    });
-  });
-
-  describe("printFoundationBanner", () => {
-    it("prints CLI info to stdout", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/tmp/test-project");
-      expect(spy).toHaveBeenCalled();
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("Foundation Operator CLI");
-    });
-
-    it("shortens home dir to ~", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      const home = os.homedir();
-      printFoundationBanner(home + "/projects/test");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("~/projects/test");
-    });
-
-    it("does not replace ~ when path is not under homedir", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/opt/data/project");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("/opt/data/project");
-      expect(output).not.toContain("~");
-    });
-
-    it("prints version and byline", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/tmp");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain(CLI_BRAND.version);
-      expect(output).toContain("meshx");
-    });
-
-    it("prints a trailing blank line", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/tmp");
-      // Last call should be empty string (blank line)
-      expect(spy.mock.calls[spy.mock.calls.length - 1][0]).toBe("");
-    });
-  });
-});

package/src/doctor.test.js

@@ -1,134 +0,0 @@
-import { describe, it, expect } from "vitest";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const doctorSource = fs.readFileSync(path.join(__dirname, "doctor.js"), "utf8");
-
-// readNetrcToken is not exported, so we inline a copy for testing
-function readNetrcToken(content, machine) {
-  const lines = content.replace(/\r\n/g, "\n").split("\n");
-  let inMachine = false;
-  for (const line of lines) {
-    const tokens = line.trim().split(/\s+/);
-    for (let i = 0; i < tokens.length; i++) {
-      if (tokens[i] === "machine" && tokens[i + 1] === machine) {
-        inMachine = true;
-      } else if (tokens[i] === "machine" && tokens[i + 1] !== machine) {
-        if (inMachine) return null;
-      }
-      if (inMachine && tokens[i] === "password" && tokens[i + 1]) {
-        return tokens[i + 1];
-      }
-    }
-  }
-  return null;
-}
-
-describe("doctor", () => {
-  describe("readNetrcToken", () => {
-    it("returns token for multi-line netrc", () => {
-      const content = `machine github.com\nlogin user\npassword ghp_abc123\n`;
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_abc123");
-    });
-
-    it("returns token for single-line netrc", () => {
-      const content = `machine github.com login user password ghp_abc123`;
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_abc123");
-    });
-
-    it("returns null for wrong machine", () => {
-      const content = `machine gitlab.com\nlogin user\npassword glpat_xyz\n`;
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("returns null for missing password", () => {
-      const content = `machine github.com\nlogin user\n`;
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("handles multiple machines", () => {
-      const content = [
-        "machine gitlab.com login a password glpat_xyz",
-        "machine github.com login b password ghp_123",
-      ].join("\n");
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_123");
-      expect(readNetrcToken(content, "gitlab.com")).toBe("glpat_xyz");
-    });
-
-    it("stops at next machine block", () => {
-      const content = [
-        "machine github.com",
-        "login user",
-        "machine other.com",
-        "password secret",
-      ].join("\n");
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("handles windows line endings", () => {
-      const content = "machine github.com\r\nlogin user\r\npassword ghp_win\r\n";
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_win");
-    });
-
-    it("handles empty content", () => {
-      expect(readNetrcToken("", "github.com")).toBe(null);
-    });
-
-    it("handles whitespace-only content", () => {
-      expect(readNetrcToken("   \n  \n  ", "github.com")).toBe(null);
-    });
-
-    it("handles machine with no following tokens", () => {
-      const content = "machine\ngithub.com\npassword ghp_123";
-      // "machine" without immediate next token matching
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("handles mixed multi-line and single-line entries", () => {
-      const content = [
-        "machine gitlab.com login gl password glpat_abc",
-        "",
-        "machine github.com",
-        "login gh",
-        "password ghp_xyz",
-      ].join("\n");
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_xyz");
-      expect(readNetrcToken(content, "gitlab.com")).toBe("glpat_abc");
-    });
-
-    it("returns first password for a machine", () => {
-      const content = "machine github.com login user password first_token";
-      expect(readNetrcToken(content, "github.com")).toBe("first_token");
-    });
-  });
-
-  describe("KEY_PORTS", () => {
-    it("defines all expected ports", () => {
-      expect(doctorSource).toContain("5432");
-      expect(doctorSource).toContain("Postgres");
-      expect(doctorSource).toContain("9092");
-      expect(doctorSource).toContain("Kafka");
-      expect(doctorSource).toContain("9001");
-      expect(doctorSource).toContain("Backend");
-      expect(doctorSource).toContain("3002");
-      expect(doctorSource).toContain("Frontend");
-      expect(doctorSource).toContain("8081");
-      expect(doctorSource).toContain("Trino");
-      expect(doctorSource).toContain("9083");
-      expect(doctorSource).toContain("Hive Metastore");
-      expect(doctorSource).toContain("8181");
-      expect(doctorSource).toContain("OPA");
-      expect(doctorSource).toContain("18201");
-      expect(doctorSource).toContain("Vault");
-    });
-  });
-
-  describe("runDoctor export", () => {
-    it("is exported as a function", async () => {
-      const { runDoctor } = await import("./doctor.js");
-      expect(typeof runDoctor).toBe("function");
-    });
-  });
-});