@meshxdata/fops 0.0.1 → 0.0.3

package/src/auth/keychain.test.js

@@ -1,185 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("execa", () => ({
-  execaSync: vi.fn(),
-}));
-
-const { execaSync } = await import("execa");
-const { readClaudeCodeKeychain, saveClaudeCodeKeychain } = await import("./keychain.js");
-
-describe("auth/keychain", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("readClaudeCodeKeychain", () => {
-    it("returns null on non-darwin platforms", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "linux" });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null on win32", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "win32" });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      expect(execaSync).not.toHaveBeenCalled();
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns tokens on darwin when keychain has data", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({
-        stdout: JSON.stringify({
-          claudeAiOauth: {
-            accessToken: "sk-ant-oat01-test",
-            refreshToken: "rt-test",
-          },
-        }),
-      });
-      const result = readClaudeCodeKeychain();
-      expect(result).toEqual({
-        accessToken: "sk-ant-oat01-test",
-        refreshToken: "rt-test",
-      });
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null refreshToken when not in keychain data", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({
-        stdout: JSON.stringify({
-          claudeAiOauth: {
-            accessToken: "sk-ant-oat01-test",
-          },
-        }),
-      });
-      const result = readClaudeCodeKeychain();
-      expect(result).toEqual({
-        accessToken: "sk-ant-oat01-test",
-        refreshToken: null,
-      });
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null on darwin when keychain throws", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockImplementation(() => { throw new Error("not found"); });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null when keychain data has no claudeAiOauth", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({ stdout: JSON.stringify({ other: "data" }) });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null when stdout is not valid JSON", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({ stdout: "not json" });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("calls security find-generic-password on darwin", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({ stdout: "{}" });
-      readClaudeCodeKeychain();
-      expect(execaSync).toHaveBeenCalledWith(
-        "security",
-        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
-        { encoding: "utf8" }
-      );
-      Object.defineProperty(process, "platform", { value: original });
-    });
-  });
-
-  describe("saveClaudeCodeKeychain", () => {
-    it("returns false on non-darwin platforms", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "linux" });
-      expect(saveClaudeCodeKeychain("token")).toBe(false);
-      expect(execaSync).not.toHaveBeenCalled();
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("calls security commands on darwin", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      const result = saveClaudeCodeKeychain("access-token", "refresh-token");
-      expect(result).toBe(true);
-      expect(execaSync).toHaveBeenCalledWith(
-        "security",
-        expect.arrayContaining(["delete-generic-password"])
-      );
-      expect(execaSync).toHaveBeenCalledWith(
-        "security",
-        expect.arrayContaining(["add-generic-password"])
-      );
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("succeeds even when delete fails (no existing entry)", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      let callCount = 0;
-      execaSync.mockImplementation((_cmd, args) => {
-        if (args.includes("delete-generic-password")) {
-          throw new Error("item not found");
-        }
-        return {};
-      });
-      const result = saveClaudeCodeKeychain("access-token");
-      expect(result).toBe(true);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns false when add-generic-password fails", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockImplementation((_cmd, args) => {
-        if (args.includes("add-generic-password")) {
-          throw new Error("keychain locked");
-        }
-        return {};
-      });
-      const result = saveClaudeCodeKeychain("token");
-      expect(result).toBe(false);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("saves without refreshToken when not provided", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      saveClaudeCodeKeychain("access-only");
-      const addCall = execaSync.mock.calls.find((c) => c[1].includes("add-generic-password"));
-      const data = JSON.parse(addCall[1][addCall[1].indexOf("-w") + 1]);
-      expect(data.claudeAiOauth.accessToken).toBe("access-only");
-      expect(data.claudeAiOauth.refreshToken).toBeUndefined();
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("includes refreshToken when provided", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      saveClaudeCodeKeychain("access", "refresh");
-      const addCall = execaSync.mock.calls.find((c) => c[1].includes("add-generic-password"));
-      const data = JSON.parse(addCall[1][addCall[1].indexOf("-w") + 1]);
-      expect(data.claudeAiOauth.accessToken).toBe("access");
-      expect(data.claudeAiOauth.refreshToken).toBe("refresh");
-      Object.defineProperty(process, "platform", { value: original });
-    });
-  });
-});

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"));
-    });
-  });
-});