muonroi-cli 1.8.0 → 1.8.3

package/dist/src/providers/auth/__tests__/openai-oauth.test.js

@@ -1,309 +0,0 @@
-/**
- * Tests for src/providers/auth/openai-oauth.ts
- *
- * Authorization Code + PKCE loopback flow. All HTTP + browser + callback
- * server are mocked.
- */
-import { describe, expect, it, vi } from "vitest";
-import { OpenAIOAuthProvider } from "../openai-oauth.js";
-import { OAuthLoginError, OAuthRefreshError } from "../types.js";
-function makeMockFetch(responses) {
-    let idx = 0;
-    return vi.fn(async (_url, _init) => {
-        const resp = responses[idx++];
-        const r = typeof resp === "function" ? resp() : resp;
-        return {
-            ok: r.ok,
-            status: r.status ?? (r.ok ? 200 : 400),
-            json: r.json ?? (() => Promise.resolve({})),
-            text: r.text ?? (() => Promise.resolve("")),
-        };
-    });
-}
-/**
- * Returns a CallbackServerFn that simulates a browser hitting the callback
- * URL with `?code=<authCode>&state=<state>` shortly after the server binds.
- * The state echoed back is read from the authorize URL passed to onUserCode
- * via a captured side-channel.
- */
-function makeMockCallbackServer(authCode, echoState) {
-    return vi.fn(async (opts) => {
-        const port = opts.port ?? 1455;
-        const path = opts.path ?? "/auth/callback";
-        const url = `http://localhost:${port}${path}`;
-        // Fire the callback asynchronously to simulate the browser round-trip.
-        setTimeout(() => opts.onCode(authCode, echoState()), 1);
-        const server = {
-            port,
-            url,
-            close: vi.fn(),
-        };
-        return server;
-    });
-}
-// ---------------------------------------------------------------------------
-// Happy-path login
-// ---------------------------------------------------------------------------
-describe("OpenAIOAuthProvider.login", () => {
-    it("runs Authorization Code + PKCE loopback flow and returns tokens with email", async () => {
-        const mockFetch = makeMockFetch([
-            // token exchange
-            {
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "acc-tok-fixture",
-                    refresh_token: "refresh_abc",
-                    id_token: "mock-id-token",
-                    expires_in: 3600,
-                    account_id: "acc_789",
-                }),
-            },
-            // userinfo
-            { ok: true, json: () => Promise.resolve({ email: "user@example.com", name: "Test User" }) },
-        ]);
-        let capturedAuthorizeUrl = "";
-        const openBrowser = vi.fn((url) => {
-            capturedAuthorizeUrl = url;
-        });
-        const callbackServer = makeMockCallbackServer("auth_code_xyz", () => {
-            const u = new URL(capturedAuthorizeUrl);
-            return u.searchParams.get("state") ?? "";
-        });
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-            callbackServerFn: callbackServer,
-            openBrowserFn: openBrowser,
-        });
-        const userCodeCb = vi.fn();
-        const tokens = await provider.login({ onUserCode: userCodeCb });
-        // onUserCode receives the authorize URL (both args identical).
-        expect(userCodeCb).toHaveBeenCalled();
-        const [arg0, arg1] = userCodeCb.mock.calls[0];
-        expect(arg0).toBe(arg1);
-        expect(arg0).toContain("https://auth.openai.com/oauth/authorize");
-        expect(arg0).toContain("response_type=code");
-        expect(arg0).toContain("code_challenge_method=S256");
-        expect(arg0).toContain("codex_cli_simplified_flow=true");
-        expect(arg0).toContain("originator=codex_cli_rs");
-        expect(arg0).toContain("api.connectors.read");
-        expect(arg0).not.toContain("access_type=offline");
-        expect(arg0).not.toContain("prompt=consent");
-        expect(arg0).toContain("redirect_uri=http%3A%2F%2Flocalhost%3A1455%2Fauth%2Fcallback");
-        expect(openBrowser).toHaveBeenCalled();
-        expect(tokens.accessToken).toBe("acc-tok-fixture");
-        expect(tokens.refreshToken).toBe("refresh_abc");
-        expect(tokens.accountId).toBe("acc_789");
-        expect(tokens.email).toBe("user@example.com");
-        expect(tokens.expiresAt).toBeGreaterThan(Date.now());
-        // Token exchange POST body should carry the auth code + code_verifier.
-        const [tokenUrl, tokenInit] = mockFetch.mock.calls[0];
-        expect(tokenUrl).toBe("https://auth.openai.com/oauth/token");
-        const body = new URLSearchParams(tokenInit.body);
-        expect(body.get("grant_type")).toBe("authorization_code");
-        expect(body.get("code")).toBe("auth_code_xyz");
-        expect(body.get("redirect_uri")).toBe("http://localhost:1455/auth/callback");
-        expect(body.get("code_verifier")).toBeTruthy();
-    });
-    it("throws OAuthLoginError when token exchange fails", async () => {
-        const mockFetch = makeMockFetch([{ ok: false, status: 400, text: () => Promise.resolve("invalid_grant") }]);
-        let capturedAuthorizeUrl = "";
-        const openBrowser = vi.fn((url) => {
-            capturedAuthorizeUrl = url;
-        });
-        const callbackServer = makeMockCallbackServer("bad_code", () => {
-            const u = new URL(capturedAuthorizeUrl);
-            return u.searchParams.get("state") ?? "";
-        });
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-            callbackServerFn: callbackServer,
-            openBrowserFn: openBrowser,
-        });
-        await expect(provider.login({})).rejects.toThrow(OAuthLoginError);
-    });
-    it("throws on state mismatch (CSRF guard)", async () => {
-        const mockFetch = makeMockFetch([]);
-        const openBrowser = vi.fn();
-        // Callback returns a state that does NOT match the one in the authorize URL.
-        const callbackServer = makeMockCallbackServer("auth_code_xyz", () => "attacker_state");
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-            callbackServerFn: callbackServer,
-            openBrowserFn: openBrowser,
-        });
-        await expect(provider.login({})).rejects.toThrow(OAuthLoginError);
-    });
-    it("falls back to port 1457 when 1455 is occupied", async () => {
-        const mockFetch = makeMockFetch([
-            {
-                ok: true,
-                json: () => Promise.resolve({ access_token: "acc", refresh_token: "r", expires_in: 3600 }),
-            },
-            { ok: true, json: () => Promise.resolve({ email: "u@example.com" }) },
-        ]);
-        let capturedAuthorizeUrl = "";
-        let attempt = 0;
-        const callbackServer = vi.fn(async (opts) => {
-            attempt++;
-            if (attempt === 1) {
-                throw new Error("EADDRINUSE");
-            }
-            const port = opts.port ?? 1457;
-            const url = `http://localhost:${port}${opts.path}`;
-            setTimeout(() => {
-                const u = new URL(capturedAuthorizeUrl);
-                opts.onCode("auth_code", u.searchParams.get("state") ?? "");
-            }, 1);
-            return { port, url, close: vi.fn() };
-        });
-        const openBrowser = vi.fn((url) => {
-            capturedAuthorizeUrl = url;
-        });
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-            callbackServerFn: callbackServer,
-            openBrowserFn: openBrowser,
-        });
-        const tokens = await provider.login({});
-        expect(tokens.accessToken).toBe("acc");
-        expect(attempt).toBe(2);
-        expect(capturedAuthorizeUrl).toContain("redirect_uri=http%3A%2F%2Flocalhost%3A1457%2Fauth%2Fcallback");
-    });
-});
-// ---------------------------------------------------------------------------
-// refresh
-// ---------------------------------------------------------------------------
-describe("OpenAIOAuthProvider.refresh", () => {
-    const expiredTokens = {
-        accessToken: "old-acc-tok",
-        refreshToken: "old-ref-tok",
-        expiresAt: Date.now() - 1,
-        accountId: "acc_789",
-        email: "user@example.com",
-    };
-    it("exchanges refresh token for new tokens", async () => {
-        const mockFetch = makeMockFetch([
-            {
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "new-acc-tok",
-                    refresh_token: "new-ref-tok",
-                    expires_in: 3600,
-                }),
-            },
-        ]);
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-        });
-        const refreshed = await provider.refresh(expiredTokens);
-        expect(refreshed.accessToken).toBe("new-acc-tok");
-        expect(refreshed.refreshToken).toBe("new-ref-tok");
-        expect(refreshed.expiresAt).toBeGreaterThan(Date.now());
-        expect(refreshed.email).toBe("user@example.com");
-        expect(refreshed.accountId).toBe("acc_789");
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toBe("https://auth.openai.com/oauth/token");
-        const body = new URLSearchParams(init.body);
-        expect(body.get("grant_type")).toBe("refresh_token");
-        expect(body.get("refresh_token")).toBe("old-ref-tok");
-    });
-    it("throws OAuthRefreshError on 401 (invalid_grant)", async () => {
-        const mockFetch = makeMockFetch([{ ok: false, status: 401, text: () => Promise.resolve("invalid_grant") }]);
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-        });
-        await expect(provider.refresh(expiredTokens)).rejects.toThrow(OAuthRefreshError);
-    });
-    it("returns tokens unchanged when still valid (not within refresh window)", async () => {
-        const validTokens = {
-            accessToken: "valid-acc-tok",
-            refreshToken: "valid-ref-tok",
-            expiresAt: Date.now() + 10 * 60_000,
-        };
-        const mockFetch = vi.fn();
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-        });
-        const result = await provider.refresh(validTokens);
-        expect(result).toBe(validTokens);
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// revoke
-// ---------------------------------------------------------------------------
-describe("OpenAIOAuthProvider.revoke", () => {
-    it("POSTs to /oauth/revoke with the refresh token", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve({}) });
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-        });
-        const tokens = {
-            accessToken: "acc",
-            refreshToken: "ref.token.long",
-            expiresAt: Date.now() + 3600_000,
-        };
-        await provider.revoke(tokens);
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toBe("https://auth.openai.com/oauth/revoke");
-    });
-    it("does not throw when revoke call fails (best-effort)", async () => {
-        const mockFetch = vi.fn().mockRejectedValue(new Error("network error"));
-        const provider = new OpenAIOAuthProvider({
-            issuer: "https://auth.openai.com",
-            clientId: "test_client",
-            fetchFn: mockFetch,
-        });
-        const tokens = {
-            accessToken: "acc",
-            refreshToken: "ref",
-            expiresAt: Date.now(),
-        };
-        await expect(provider.revoke(tokens)).resolves.not.toThrow();
-    });
-});
-// ---------------------------------------------------------------------------
-// authHeaders
-// ---------------------------------------------------------------------------
-describe("OpenAIOAuthProvider.authHeaders", () => {
-    it("returns Authorization + ChatGPT-Account-ID when accountId present", () => {
-        const provider = new OpenAIOAuthProvider();
-        const tokens = {
-            accessToken: "mock-token",
-            refreshToken: "ref",
-            expiresAt: Date.now() + 3600_000,
-            accountId: "acc_123",
-        };
-        const headers = provider.authHeaders(tokens);
-        expect(headers.Authorization).toBe("Bearer mock-token");
-        expect(headers["ChatGPT-Account-ID"]).toBe("acc_123");
-    });
-    it("omits ChatGPT-Account-ID when accountId absent", () => {
-        const provider = new OpenAIOAuthProvider();
-        const tokens = {
-            accessToken: "mock-token",
-            refreshToken: "ref",
-            expiresAt: Date.now() + 3600_000,
-        };
-        const headers = provider.authHeaders(tokens);
-        expect(headers.Authorization).toBe("Bearer mock-token");
-        expect(headers["ChatGPT-Account-ID"]).toBeUndefined();
-    });
-});
-//# sourceMappingURL=openai-oauth.test.js.map

package/dist/src/providers/auth/__tests__/token-store.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests for src/providers/auth/token-store.ts
- *
- * Tests keychain-primary path with a mock keytar, and the file-fallback path
- * when keytar is unavailable.
- */
-export {};

package/dist/src/providers/auth/__tests__/token-store.test.js

@@ -1,125 +0,0 @@
-/**
- * Tests for src/providers/auth/token-store.ts
- *
- * Tests keychain-primary path with a mock keytar, and the file-fallback path
- * when keytar is unavailable.
- */
-import { mkdir, readFile, rm } from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// Token-store uses process.env.MUONROI_AUTH_DIR for test overrides.
-// (vi.spyOn(os, "homedir") fails in ESM — non-configurable export.)
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-// NOTE: token values kept < 16 chars to avoid triggering the pre-commit
-// secret scanner's generic-bearer pattern: /token\s*:\s*['"][^'"]{16,}['"]/
-const SAMPLE_TOKENS = {
-    accessToken: "acc-tok-fixture",
-    refreshToken: "ref-tok-fixture",
-    idToken: "id-tok-fixt",
-    accountId: "acc_123",
-    expiresAt: Date.now() + 3600_000,
-    email: "user@example.com",
-};
-// ---------------------------------------------------------------------------
-// Mock keytar store
-// ---------------------------------------------------------------------------
-function makeKeytarMock() {
-    const store = new Map();
-    return {
-        getPassword: vi.fn(async (_svc, account) => store.get(account) ?? null),
-        setPassword: vi.fn(async (_svc, account, password) => {
-            store.set(account, password);
-        }),
-        deletePassword: vi.fn(async (_svc, account) => {
-            if (store.has(account)) {
-                store.delete(account);
-                return true;
-            }
-            return false;
-        }),
-        _store: store,
-    };
-}
-// ---------------------------------------------------------------------------
-// Tests: keychain path
-// ---------------------------------------------------------------------------
-describe("token-store — keychain path", () => {
-    it("saves and loads tokens via keychain", async () => {
-        const kt = makeKeytarMock();
-        // Inject mock keytar via module mock
-        vi.doMock("keytar", () => kt);
-        // Isolate file fallback path — without this, deleteTokens() at the end
-        // of the test would unlink() the real user's ~/.muonroi-cli/auth/openai.json.
-        const tmp = path.join(os.tmpdir(), `muonroi-test-token-store-keychain-${Date.now()}`);
-        process.env.MUONROI_AUTH_DIR = tmp;
-        try {
-            const { saveTokens, loadTokens, deleteTokens } = await import("../token-store.js");
-            await saveTokens("openai", SAMPLE_TOKENS);
-            expect(kt.setPassword).toHaveBeenCalledOnce();
-            const loaded = await loadTokens("openai");
-            expect(loaded).not.toBeNull();
-            expect(loaded.accessToken).toBe(SAMPLE_TOKENS.accessToken);
-            expect(loaded.email).toBe("user@example.com");
-            await deleteTokens("openai");
-            expect(kt.deletePassword).toHaveBeenCalledOnce();
-        }
-        finally {
-            delete process.env.MUONROI_AUTH_DIR;
-            vi.doUnmock("keytar");
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests: file fallback path
-// ---------------------------------------------------------------------------
-describe("token-store — file fallback", () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = path.join(os.tmpdir(), `muonroi-test-token-store-${Date.now()}`);
-        await mkdir(tempDir, { recursive: true });
-        // Override auth dir via env var (token-store reads MUONROI_AUTH_DIR)
-        process.env.MUONROI_AUTH_DIR = tempDir;
-    });
-    afterEach(async () => {
-        delete process.env.MUONROI_AUTH_DIR;
-        await rm(tempDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("saves tokens to file when keytar unavailable", async () => {
-        // Make keytar unavailable
-        vi.doMock("keytar", () => {
-            throw new Error("keytar not available");
-        });
-        const { saveTokens, loadTokens } = await import("../token-store.js");
-        await saveTokens("openai", SAMPLE_TOKENS);
-        const filePath = path.join(tempDir, "openai.json");
-        const raw = await readFile(filePath, "utf8");
-        const parsed = JSON.parse(raw);
-        expect(parsed.accessToken).toBe(SAMPLE_TOKENS.accessToken);
-        const loaded = await loadTokens("openai");
-        expect(loaded).not.toBeNull();
-        expect(loaded.refreshToken).toBe(SAMPLE_TOKENS.refreshToken);
-        vi.doUnmock("keytar");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests: deleteTokens when nothing stored
-// ---------------------------------------------------------------------------
-describe("token-store — deleteTokens no-op", () => {
-    it("does not throw when nothing is stored", async () => {
-        // Point at a non-existent dir so file fallback also has nothing
-        process.env.MUONROI_AUTH_DIR = path.join(os.tmpdir(), `muonroi-nonexistent-${Date.now()}`);
-        vi.doMock("keytar", () => ({
-            getPassword: vi.fn(async () => null),
-            setPassword: vi.fn(async () => { }),
-            deletePassword: vi.fn(async () => false),
-        }));
-        const { deleteTokens } = await import("../token-store.js");
-        await expect(deleteTokens("openai")).resolves.not.toThrow();
-        delete process.env.MUONROI_AUTH_DIR;
-        vi.doUnmock("keytar");
-    });
-});
-//# sourceMappingURL=token-store.test.js.map

package/dist/src/providers/errors.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/errors.test.js

@@ -1,66 +0,0 @@
-/**
- * Tests for src/providers/errors.ts
- * Verifies normalizeError maps various error shapes to the 5 NormalizedErrorKind values.
- */
-import { describe, expect, it } from "vitest";
-import { normalizeError } from "./errors.js";
-describe("normalizeError", () => {
-    it("maps RateLimitError name to rate_limit", () => {
-        const err = Object.assign(new Error("Rate limit exceeded"), { name: "RateLimitError", status: 429 });
-        const n = normalizeError(err);
-        expect(n.kind).toBe("rate_limit");
-        expect(n.status).toBe(429);
-    });
-    it("maps status 429 to rate_limit even without name", () => {
-        const err = Object.assign(new Error("Too many requests"), { status: 429 });
-        const n = normalizeError(err);
-        expect(n.kind).toBe("rate_limit");
-    });
-    it("maps AuthenticationError name to auth", () => {
-        const err = Object.assign(new Error("Invalid API key"), { name: "AuthenticationError", status: 401 });
-        const n = normalizeError(err);
-        expect(n.kind).toBe("auth");
-        expect(n.status).toBe(401);
-    });
-    it("maps status 403 to auth", () => {
-        const err = Object.assign(new Error("Forbidden"), { status: 403 });
-        const n = normalizeError(err);
-        expect(n.kind).toBe("auth");
-    });
-    it("maps content filter message to content_filter", () => {
-        const err = new Error("Content blocked by safety filter");
-        const n = normalizeError(err);
-        expect(n.kind).toBe("content_filter");
-    });
-    it("maps policy violation to content_filter", () => {
-        const err = new Error("This request violates our usage policy");
-        const n = normalizeError(err);
-        expect(n.kind).toBe("content_filter");
-    });
-    it("maps status 500 to server_error", () => {
-        const err = Object.assign(new Error("Internal server error"), { status: 500 });
-        const n = normalizeError(err);
-        expect(n.kind).toBe("server_error");
-    });
-    it("maps status 502 to server_error", () => {
-        const err = Object.assign(new Error("Bad gateway"), { status: 502 });
-        const n = normalizeError(err);
-        expect(n.kind).toBe("server_error");
-    });
-    it("maps unknown error to unknown", () => {
-        const err = new Error("Something weird happened");
-        const n = normalizeError(err);
-        expect(n.kind).toBe("unknown");
-    });
-    it("handles non-Error input", () => {
-        const n = normalizeError("string error");
-        expect(n.kind).toBe("unknown");
-        expect(n.message).toBe("string error");
-    });
-    it("preserves provider_message", () => {
-        const err = new Error("Quota exceeded");
-        const n = normalizeError(err);
-        expect(n.provider_message).toBe("Quota exceeded");
-    });
-});
-//# sourceMappingURL=errors.test.js.map

package/dist/src/providers/gemini.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/gemini.test.js

@@ -1,37 +0,0 @@
-/**
- * Tests for src/providers/gemini.ts
- * Uses recorded JSONL fixtures replayed via mocked streamText.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createMockFullStream, loadFixtureChunks } from "./__test-utils__/load-fixture.js";
-vi.mock("ai", () => ({
-    streamText: vi.fn(),
-}));
-vi.mock("@ai-sdk/google", () => ({
-    createGoogleGenerativeAI: vi.fn(() => vi.fn((model) => ({ modelId: model }))),
-}));
-import { streamText } from "ai";
-import { createGeminiAdapter } from "./gemini.js";
-const mockStreamText = vi.mocked(streamText);
-describe("createGeminiAdapter", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('has id "google"', () => {
-        const adapter = createGeminiAdapter({ model: "gemini-2.5-flash", apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx" });
-        expect(adapter.id).toBe("google");
-    });
-    it("handles single-tool fixture emitting exactly one tool-call", async () => {
-        const chunks = loadFixtureChunks("gemini", "single-tool");
-        mockStreamText.mockReturnValue({ fullStream: createMockFullStream(chunks) });
-        const adapter = createGeminiAdapter({ model: "gemini-2.5-flash", apiKey: "test-key-xxxxxxxxxxxxxxxxxxxx" });
-        const collected = [];
-        for await (const chunk of adapter.stream({ messages: [{ role: "user", content: "search" }] })) {
-            collected.push(chunk);
-        }
-        const toolCalls = collected.filter((c) => c.kind === "tool-call");
-        expect(toolCalls.length).toBe(1);
-        expect(toolCalls[0].toolName).toBe("search");
-    });
-});
-//# sourceMappingURL=gemini.test.js.map

package/dist/src/providers/keychain.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/keychain.test.js

@@ -1,84 +0,0 @@
-/**
- * Tests for src/providers/keychain.ts
- * Mocks keytar and env vars to verify loadKeyForProvider + firstAvailableProvider.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// We'll mock keytar at the module level
-vi.mock("keytar", () => ({
-    getPassword: vi.fn().mockResolvedValue(null),
-}));
-// Mock settings so the settings.json providers fallback doesn't interfere
-vi.mock("../utils/settings.js", () => ({
-    loadUserSettings: () => ({ providers: {} }),
-}));
-import { firstAvailableProvider, loadKeyForProvider, ProviderKeyMissingError } from "./keychain.js";
-describe("loadKeyForProvider", () => {
-    const originalEnv = { ...process.env };
-    beforeEach(() => {
-        // Clear env vars
-        delete process.env.ANTHROPIC_API_KEY;
-        delete process.env.OPENAI_API_KEY;
-        delete process.env.GOOGLE_API_KEY;
-        delete process.env.DEEPSEEK_API_KEY;
-        delete process.env.SILICONFLOW_API_KEY;
-        delete process.env.OLLAMA_API_KEY;
-    });
-    afterEach(() => {
-        // Restore
-        Object.assign(process.env, originalEnv);
-        vi.restoreAllMocks();
-    });
-    it("returns key from env var when keytar returns null", async () => {
-        process.env.OPENAI_API_KEY = "sk-test-openai-key-longer-than-20-chars";
-        const key = await loadKeyForProvider("openai");
-        expect(key).toBe("sk-test-openai-key-longer-than-20-chars");
-    });
-    it("throws ProviderKeyMissingError when no key found for non-ollama provider", async () => {
-        await expect(loadKeyForProvider("openai")).rejects.toThrow(ProviderKeyMissingError);
-    });
-    it("returns empty string for ollama when no key set (keyless)", async () => {
-        const key = await loadKeyForProvider("ollama");
-        expect(key).toBe("");
-    });
-    it("reads from ANTHROPIC_API_KEY env var", async () => {
-        process.env.ANTHROPIC_API_KEY = "sk-ant-test-key-long-enough-for-validation";
-        const key = await loadKeyForProvider("anthropic");
-        expect(key).toBe("sk-ant-test-key-long-enough-for-validation");
-    });
-    it("reads from GOOGLE_API_KEY env var", async () => {
-        process.env.GOOGLE_API_KEY = "AIzaSyB_test_key_longer_than_twenty";
-        const key = await loadKeyForProvider("google");
-        expect(key).toBe("AIzaSyB_test_key_longer_than_twenty");
-    });
-});
-describe("firstAvailableProvider", () => {
-    const originalEnv = { ...process.env };
-    beforeEach(() => {
-        delete process.env.ANTHROPIC_API_KEY;
-        delete process.env.OPENAI_API_KEY;
-        delete process.env.GOOGLE_API_KEY;
-        delete process.env.DEEPSEEK_API_KEY;
-        delete process.env.SILICONFLOW_API_KEY;
-        delete process.env.OLLAMA_API_KEY;
-    });
-    afterEach(() => {
-        Object.assign(process.env, originalEnv);
-        vi.restoreAllMocks();
-    });
-    it("returns anthropic when ANTHROPIC_API_KEY is set", async () => {
-        process.env.ANTHROPIC_API_KEY = "sk-ant-test-key-long-enough-for-validation";
-        const p = await firstAvailableProvider();
-        expect(p).toBe("anthropic");
-    });
-    it("returns openai when only OPENAI_API_KEY is set", async () => {
-        process.env.OPENAI_API_KEY = "sk-test-openai-key-longer-than-20-chars";
-        const p = await firstAvailableProvider();
-        expect(p).toBe("openai");
-    });
-    it("returns ollama as fallback (keyless)", async () => {
-        // No keys set — ollama is keyless so it should be found
-        const p = await firstAvailableProvider();
-        expect(p).toBe("ollama");
-    });
-});
-//# sourceMappingURL=keychain.test.js.map

package/dist/src/providers/mcp-vision-bridge.test.d.ts

@@ -1 +0,0 @@
-export {};