muonroi-cli 1.8.0 → 1.8.3

package/dist/src/ee/artifact-cache.test.js

@@ -1,69 +0,0 @@
-import { rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { __artifactCacheSize, __resetArtifactCacheForTests, __setArtifactCacheDiskPathForTests, __setArtifactCacheMaxForTests, appendArtifactToDisk, findArtifactByQuery, findArtifactOnDisk, flushArtifactDiskWrites, getArtifact, recordArtifact, } from "./artifact-cache.js";
-// Redirect the disk spill to a temp file for EVERY test so recordArtifact never
-// writes the real ~/.muonroi-cli/artifact-cache.jsonl.
-const diskFile = path.join(os.tmpdir(), `muonroi-artifact-cache-test-${process.pid}.jsonl`);
-beforeEach(() => __setArtifactCacheDiskPathForTests(diskFile));
-afterEach(async () => {
-    __resetArtifactCacheForTests();
-    delete process.env.MUONROI_ARTIFACT_CACHE_DISK;
-    await rm(diskFile, { force: true });
-});
-describe("artifact-cache (in-memory tier — durable rehydrate when EE is down)", () => {
-    it("records and retrieves an elided output by toolCallId", () => {
-        recordArtifact("call_7", "read_file", "FULL CONTENT of src/auth.ts");
-        expect(getArtifact("call_7")).toEqual({ toolName: "read_file", content: "FULL CONTENT of src/auth.ts" });
-        expect(getArtifact("missing")).toBeNull();
-    });
-    it("no-ops on empty id or empty content", () => {
-        recordArtifact("", "read_file", "x");
-        recordArtifact("call_x", "read_file", "");
-        expect(__artifactCacheSize()).toBe(0);
-    });
-    it("findArtifactByQuery extracts the id from the contract query strings", () => {
-        recordArtifact("abc123", "grep", "GREP HITS");
-        expect(findArtifactByQuery("tool-artifact id=abc123")?.content).toBe("GREP HITS");
-        expect(findArtifactByQuery("full tool result id=abc123")?.toolCallId).toBe("abc123");
-        expect(findArtifactByQuery("tool-artifact  ID = abc123")?.content).toBe("GREP HITS"); // spacing/case
-        expect(findArtifactByQuery("tool-artifact id=nope")).toBeNull(); // not cached
-        expect(findArtifactByQuery("no id here")).toBeNull(); // no id=
-    });
-    it("evicts the oldest entries past the LRU cap; re-recording refreshes recency", () => {
-        __setArtifactCacheMaxForTests(2);
-        recordArtifact("a", "t", "A");
-        recordArtifact("b", "t", "B");
-        recordArtifact("a", "t", "A2"); // touch 'a' → now 'b' is oldest
-        recordArtifact("c", "t", "C"); // evicts 'b'
-        expect(getArtifact("a")?.content).toBe("A2");
-        expect(getArtifact("c")?.content).toBe("C");
-        expect(getArtifact("b")).toBeNull();
-        expect(__artifactCacheSize()).toBe(2);
-    });
-});
-describe("artifact-cache (disk spill — survives a process restart)", () => {
-    it("rehydrates from disk after the in-memory tier is gone (simulated restart)", async () => {
-        recordArtifact("call_disk", "read_file", "PERSISTED CONTENT");
-        await flushArtifactDiskWrites();
-        // Simulate a restart: in-memory tier cleared, but the disk file persists.
-        __resetArtifactCacheForTests();
-        __setArtifactCacheDiskPathForTests(diskFile);
-        expect(findArtifactByQuery("tool-artifact id=call_disk")).toBeNull(); // memory gone
-        const onDisk = await findArtifactOnDisk("tool-artifact id=call_disk");
-        expect(onDisk?.content).toBe("PERSISTED CONTENT");
-        expect(onDisk?.toolName).toBe("read_file");
-    });
-    it("newest record for an id wins on disk", async () => {
-        await appendArtifactToDisk("dup", "t", "OLD");
-        await appendArtifactToDisk("dup", "t", "NEW");
-        expect((await findArtifactOnDisk("tool-artifact id=dup"))?.content).toBe("NEW");
-    });
-    it("respects MUONROI_ARTIFACT_CACHE_DISK=0 (no disk read)", async () => {
-        await appendArtifactToDisk("x", "t", "C");
-        process.env.MUONROI_ARTIFACT_CACHE_DISK = "0";
-        expect(await findArtifactOnDisk("tool-artifact id=x")).toBeNull();
-    });
-});
-//# sourceMappingURL=artifact-cache.test.js.map

package/dist/src/ee/auth.test.d.ts

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

package/dist/src/ee/auth.test.js

@@ -1,59 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { getEmbeddingModelVersion, loadEEAuthToken, refreshAuthToken } from "./auth.js";
-describe("loadEEAuthToken", () => {
-    let tmpHome;
-    beforeEach(async () => {
-        tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "ee-auth-test-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
-    });
-    it("returns token when ~/.experience/config.json exists", async () => {
-        const dir = path.join(tmpHome, ".experience");
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, "config.json"), JSON.stringify({
-            authToken: "test-token-abc123",
-            embeddingModelVersion: "nomic-embed-text-v1.5",
-        }));
-        const token = await loadEEAuthToken({ home: tmpHome });
-        expect(token).toBe("test-token-abc123");
-    });
-    it("returns null when ~/.experience/config.json is absent (no throw)", async () => {
-        const token = await loadEEAuthToken({ home: tmpHome });
-        expect(token).toBeNull();
-    });
-    it("sets embeddingModelVersion from config", async () => {
-        const dir = path.join(tmpHome, ".experience");
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, "config.json"), JSON.stringify({
-            authToken: "tok",
-            embeddingModelVersion: "custom-v2",
-        }));
-        await loadEEAuthToken({ home: tmpHome });
-        expect(getEmbeddingModelVersion()).toBe("custom-v2");
-    });
-});
-describe("refreshAuthToken", () => {
-    let tmpHome;
-    beforeEach(async () => {
-        tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "ee-auth-ref-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
-    });
-    it("re-reads config.json and updates the cached value", async () => {
-        const dir = path.join(tmpHome, ".experience");
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, "config.json"), JSON.stringify({ authToken: "old-token" }));
-        const first = await loadEEAuthToken({ home: tmpHome });
-        expect(first).toBe("old-token");
-        // Write new token
-        await fs.writeFile(path.join(dir, "config.json"), JSON.stringify({ authToken: "new-token" }));
-        const second = await refreshAuthToken({ home: tmpHome });
-        expect(second).toBe("new-token");
-    });
-});
-//# sourceMappingURL=auth.test.js.map

package/dist/src/ee/bridge.test.d.ts

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

package/dist/src/ee/bridge.test.js

@@ -1,230 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// ─── Hoisted mocks (must be at module top-level for vi.mock hoisting) ──────────
-const mockCore = vi.hoisted(() => ({
-    classifyViaBrain: vi.fn().mockResolvedValue("generate"),
-    searchCollection: vi.fn().mockResolvedValue([{ id: "p1", score: 0.9, payload: { text: "test" } }]),
-    routeModel: vi.fn().mockResolvedValue({
-        tier: "balanced",
-        model: "claude-sonnet-4-6",
-        confidence: 0.8,
-        source: "brain",
-        reason: "test",
-        taskHash: "abc123",
-    }),
-    routeFeedback: vi.fn().mockResolvedValue(true),
-    getEmbeddingRaw: vi.fn().mockResolvedValue([0.1, 0.2, 0.3]),
-}));
-const mockRequire = vi.hoisted(() => vi.fn().mockReturnValue(mockCore));
-const mockAccess = vi.hoisted(() => vi.fn().mockResolvedValue(undefined));
-vi.mock("node:module", () => ({
-    createRequire: vi.fn().mockReturnValue(mockRequire),
-}));
-vi.mock("node:fs", () => ({
-    promises: { access: mockAccess },
-}));
-// ─── Import module under test (after mocks) ────────────────────────────────────
-import { classifyViaBrain, getEmbeddingRaw, resetBridge, routeFeedback, routeModel, searchCollection, } from "./bridge.js";
-// ─── Tests ─────────────────────────────────────────────────────────────────────
-describe("bridge — loaded core", () => {
-    beforeEach(() => {
-        resetBridge();
-        mockAccess.mockResolvedValue(undefined);
-        mockRequire.mockReturnValue(mockCore);
-        vi.clearAllMocks();
-        mockAccess.mockResolvedValue(undefined);
-        mockRequire.mockReturnValue(mockCore);
-        mockCore.classifyViaBrain.mockResolvedValue("generate");
-        mockCore.searchCollection.mockResolvedValue([{ id: "p1", score: 0.9, payload: { text: "test" } }]);
-        mockCore.routeModel.mockResolvedValue({
-            tier: "balanced",
-            model: "claude-sonnet-4-6",
-            confidence: 0.8,
-            source: "brain",
-            reason: "test",
-            taskHash: "abc123",
-        });
-        mockCore.routeFeedback.mockResolvedValue(true);
-        mockCore.getEmbeddingRaw.mockResolvedValue([0.1, 0.2, 0.3]);
-    });
-    afterEach(() => {
-        resetBridge();
-    });
-    it("Test 1: classifyViaBrain returns classification string when core loaded", async () => {
-        const result = await classifyViaBrain("write a function to sort an array");
-        expect(result).toBe("generate");
-        expect(mockCore.classifyViaBrain).toHaveBeenCalledWith("write a function to sort an array", 5000, undefined);
-    });
-    it("Test 2: searchCollection returns EEPoint[] when core loaded", async () => {
-        const vector = [0.1, 0.2, 0.3];
-        const result = await searchCollection("my-collection", vector, 5);
-        expect(result).toEqual([{ id: "p1", score: 0.9, payload: { text: "test" } }]);
-        expect(mockCore.searchCollection).toHaveBeenCalledWith("my-collection", vector, 5, undefined);
-    });
-    it("Test 3: routeModel returns EERouteResult when core loaded", async () => {
-        const result = await routeModel("code-generation", { cwd: "/home/user" }, "bun");
-        expect(result).toEqual({
-            tier: "balanced",
-            model: "claude-sonnet-4-6",
-            confidence: 0.8,
-            source: "brain",
-            reason: "test",
-            taskHash: "abc123",
-        });
-        expect(mockCore.routeModel).toHaveBeenCalledWith("code-generation", { cwd: "/home/user" }, "bun");
-    });
-    it("Test 4: routeFeedback returns true when core loaded", async () => {
-        const result = await routeFeedback("abc123", "balanced", "claude-sonnet-4-6", "success", 0, 1500);
-        expect(result).toBe(true);
-        expect(mockCore.routeFeedback).toHaveBeenCalledWith("abc123", "balanced", "claude-sonnet-4-6", "success", 0, 1500);
-    });
-    it("Test 5: getEmbeddingRaw returns number[] when core loaded", async () => {
-        const result = await getEmbeddingRaw("hello world");
-        expect(result).toEqual([0.1, 0.2, 0.3]);
-        expect(mockCore.getEmbeddingRaw).toHaveBeenCalledWith("hello world", undefined);
-    });
-});
-describe("bridge — missing core (BRIDGE-02)", () => {
-    beforeEach(() => {
-        resetBridge();
-        vi.clearAllMocks();
-        // Simulate file not found
-        mockAccess.mockRejectedValue(new Error("ENOENT: no such file or directory"));
-    });
-    afterEach(() => {
-        resetBridge();
-    });
-    it("Test 6: classifyViaBrain returns null when core file missing", async () => {
-        const result = await classifyViaBrain("some prompt");
-        expect(result).toBeNull();
-    });
-    it("Test 7: searchCollection returns [] when core file missing", async () => {
-        const result = await searchCollection("col", [0.1], 3);
-        expect(result).toEqual([]);
-    });
-    it("Test 8: routeModel returns null when core file missing", async () => {
-        const result = await routeModel("task", {}, "bun");
-        expect(result).toBeNull();
-    });
-    it("Test 9: routeFeedback returns false when core file missing", async () => {
-        const result = await routeFeedback("hash", "tier", "model", "success", 0, null);
-        expect(result).toBe(false);
-    });
-    it("Test 10: getEmbeddingRaw returns null when core file missing", async () => {
-        const result = await getEmbeddingRaw("text");
-        expect(result).toBeNull();
-    });
-    it("Test 11: console.warn called with 'experience-core.js not found' message when file missing", async () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        await classifyViaBrain("prompt");
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("experience-core.js not found"));
-        warnSpy.mockRestore();
-    });
-});
-describe("bridge — require throws (BRIDGE-02)", () => {
-    beforeEach(() => {
-        resetBridge();
-        vi.clearAllMocks();
-        // File exists but require() throws
-        mockAccess.mockResolvedValue(undefined);
-        mockRequire.mockImplementation(() => {
-            throw new Error("corrupt module: unexpected token");
-        });
-    });
-    afterEach(() => {
-        resetBridge();
-        // Restore mockRequire to default behavior for subsequent test groups
-        mockRequire.mockReturnValue(mockCore);
-    });
-    it("Test 12: classifyViaBrain returns null when require throws", async () => {
-        const result = await classifyViaBrain("prompt");
-        expect(result).toBeNull();
-    });
-    it("Test 13: searchCollection returns [] when require throws", async () => {
-        const result = await searchCollection("col", [0.1], 3);
-        expect(result).toEqual([]);
-    });
-    it("Test 14: routeModel returns null when require throws", async () => {
-        const result = await routeModel("task", {}, "bun");
-        expect(result).toBeNull();
-    });
-    it("Test 15: routeFeedback returns false when require throws", async () => {
-        const result = await routeFeedback("hash", "tier", "model", "fail", 1, null);
-        expect(result).toBe(false);
-    });
-    it("Test 16: getEmbeddingRaw returns null when require throws", async () => {
-        const result = await getEmbeddingRaw("text");
-        expect(result).toBeNull();
-    });
-    it("Test 17: console.warn called with 'failed to load' message when require throws", async () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        await classifyViaBrain("prompt");
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("failed to load"));
-        warnSpy.mockRestore();
-    });
-});
-describe("bridge — lazy singleton", () => {
-    beforeEach(() => {
-        resetBridge();
-        vi.clearAllMocks();
-        mockAccess.mockResolvedValue(undefined);
-        mockRequire.mockReturnValue(mockCore);
-        mockCore.classifyViaBrain.mockResolvedValue("generate");
-    });
-    afterEach(() => {
-        resetBridge();
-    });
-    it("Test 18: second call to classifyViaBrain does NOT re-attempt load (lazy singleton)", async () => {
-        await classifyViaBrain("first call");
-        await classifyViaBrain("second call");
-        // mockRequire should only be called once (when loading the core)
-        expect(mockRequire).toHaveBeenCalledTimes(1);
-    });
-});
-describe("bridge — resetBridge", () => {
-    beforeEach(() => {
-        resetBridge();
-        vi.clearAllMocks();
-        mockAccess.mockResolvedValue(undefined);
-        mockRequire.mockReturnValue(mockCore);
-        mockCore.classifyViaBrain.mockResolvedValue("generate");
-    });
-    afterEach(() => {
-        resetBridge();
-    });
-    it("Test 19: resetBridge allows re-attempt on next call", async () => {
-        // First call loads the core
-        await classifyViaBrain("first");
-        expect(mockRequire).toHaveBeenCalledTimes(1);
-        // Reset clears state
-        resetBridge();
-        // Second call after reset should re-attempt load
-        await classifyViaBrain("second");
-        expect(mockRequire).toHaveBeenCalledTimes(2);
-    });
-});
-describe("bridge — config isolation (BRIDGE-03)", () => {
-    it("Test 20: classifyViaBrain signature does NOT accept config args (type-level check)", async () => {
-        // This test verifies via TypeScript @ts-expect-error that config args are rejected
-        // If type check passes (no error here), the function signature correctly excludes config params
-        // Valid call — should compile
-        const _validCall = () => classifyViaBrain("prompt");
-        const _validCallWithTimeout = () => classifyViaBrain("prompt", 3000);
-        // These would cause @ts-expect-error if uncommented:
-        const _invalidCall = () => classifyViaBrain("prompt", 3000, "http://localhost:6333");
-        expect(_validCall).toBeDefined();
-        expect(_validCallWithTimeout).toBeDefined();
-    });
-    it("Test 21: searchCollection signature does NOT accept qdrantUrl/ollamaUrl/brainModel", async () => {
-        // Valid signature
-        const _validCall = () => searchCollection("col", [0.1], 5);
-        const _validCallWithSignal = () => searchCollection("col", [0.1], 5, new AbortController().signal);
-        expect(_validCall).toBeDefined();
-        expect(_validCallWithSignal).toBeDefined();
-    });
-    it("Test 22: routeModel signature does NOT accept config params", async () => {
-        // Valid signature: (task, context, runtime)
-        const _validCall = () => routeModel("task", { key: "value" }, "bun");
-        expect(_validCall).toBeDefined();
-    });
-});
-//# sourceMappingURL=bridge.test.js.map

package/dist/src/ee/client.test.d.ts

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

package/dist/src/ee/client.test.js

@@ -1,181 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createEEClient, resetEEClientState } from "./client.js";
-const mockReq = {
-    toolName: "bash",
-    toolInput: { command: "ls" },
-    cwd: "/tmp",
-    tenantId: "local",
-    scope: { kind: "global" },
-};
-const mockPayload = {
-    toolName: "bash",
-    toolInput: { command: "ls" },
-    outcome: { success: true, exitCode: 0, durationMs: 10 },
-    cwd: "/tmp",
-    tenantId: "local",
-    scope: { kind: "global" },
-};
-describe("EEClient - health", () => {
-    it("Test 1: health 200 returns { ok: true, status: 200 }", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        const result = await ee.health();
-        expect(result).toEqual({ ok: true, status: 200 });
-    });
-    it("Test 2: health 502 returns { ok: false, status: 502 } without throwing", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 502 });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        const result = await ee.health();
-        expect(result).toEqual({ ok: false, status: 502 });
-    });
-});
-describe("EEClient - intercept", () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        resetEEClientState(); // clear cache + circuit between tests
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it("Test 3: intercept allow — returns decision:allow", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ decision: "allow" }),
-        });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        const result = await ee.intercept(mockReq);
-        expect(result.decision).toBe("allow");
-    });
-    it("Test 4: intercept block — returns decision:block with reason", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ decision: "block", reason: "dangerous command" }),
-        });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        const result = await ee.intercept(mockReq);
-        expect(result.decision).toBe("block");
-        expect(result.reason).toBe("dangerous command");
-    });
-    it("Test 5: intercept 5xx falls back to { decision: 'allow', reason: 'ee-unreachable' }", async () => {
-        const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 503 });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        const result = await ee.intercept(mockReq);
-        expect(result.decision).toBe("allow");
-        expect(result.reason).toBe("ee-unreachable");
-        consoleSpy.mockRestore();
-    });
-    it("Test 6: intercept timeout falls back to { decision: 'allow', reason: 'ee-unreachable' }", async () => {
-        // Simulate a fetch that aborts due to timeout signal
-        const mockFetch = vi.fn().mockImplementation((_url, opts) => {
-            return new Promise((_resolve, reject) => {
-                // Listen to the abort signal and reject when it fires
-                const signal = opts?.signal;
-                if (signal) {
-                    signal.addEventListener("abort", () => {
-                        const err = new DOMException("The operation was aborted.", "AbortError");
-                        reject(err);
-                    });
-                }
-            });
-        });
-        const ee = createEEClient({ fetchImpl: mockFetch, timeoutMs: 50 });
-        // Advance timers to trigger AbortSignal.timeout
-        const resultPromise = ee.intercept(mockReq);
-        await vi.advanceTimersByTimeAsync(200);
-        const result = await resultPromise;
-        expect(result.decision).toBe("allow");
-        expect(result.reason).toBe("ee-unreachable");
-    });
-});
-describe("EEClient - posttool", () => {
-    it("Test 7: posttool is awaitable — returns Promise<void> and fetch is called", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        // posttool is now async (awaitable by PostToolUse handler)
-        const returnValue = ee.posttool(mockPayload);
-        expect(returnValue).toBeInstanceOf(Promise);
-        await returnValue;
-        expect(mockFetch).toHaveBeenCalledOnce();
-    });
-    it("Test 8: posttool swallows errors silently", async () => {
-        const mockFetch = vi.fn().mockRejectedValue(new Error("network error"));
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        // Must not throw even when awaited
-        await expect(ee.posttool(mockPayload)).resolves.toBeUndefined();
-    });
-    it("Test 9: posttool does not hang on a wedged server — bounded by an abort signal", async () => {
-        // PostToolUse hook (src/hooks/index.ts) AWAITS posttool on the hot path.
-        // A reachable-but-wedged EE server (accepts TCP, never responds) must NOT
-        // hang the hook — posttool must carry a timeout abort signal like every
-        // other client method, honouring the "never block orchestrator" intent.
-        vi.useFakeTimers();
-        try {
-            const mockFetch = vi.fn().mockImplementation((_url, opts) => {
-                return new Promise((_resolve, reject) => {
-                    const signal = opts?.signal;
-                    // Wedged server: only ever settles if the client aborts it.
-                    signal?.addEventListener("abort", () => {
-                        reject(new DOMException("The operation was aborted.", "AbortError"));
-                    });
-                });
-            });
-            const ee = createEEClient({ fetchImpl: mockFetch });
-            const p = ee.posttool(mockPayload);
-            // Structural: the call must be bounded by an AbortSignal (deterministic).
-            const opts = mockFetch.mock.calls[0][1];
-            expect(opts.signal).toBeInstanceOf(AbortSignal);
-            // Behavioral: once the timeout fires, the wedged call is aborted and the
-            // fire-and-forget catch resolves posttool to undefined (never throws).
-            await vi.advanceTimersByTimeAsync(15_000);
-            await expect(p).resolves.toBeUndefined();
-        }
-        finally {
-            vi.useRealTimers();
-        }
-    });
-});
-describe("EEClient - auth", () => {
-    beforeEach(() => {
-        resetEEClientState();
-    });
-    it("Test 9: auth header included when authToken provided", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ decision: "allow" }),
-        });
-        const ee = createEEClient({ authToken: "my-token", fetchImpl: mockFetch });
-        await ee.intercept(mockReq);
-        const [, opts] = mockFetch.mock.calls[0];
-        const headers = opts.headers;
-        expect(headers.Authorization).toBe("Bearer my-token");
-    });
-    it("Test 10: intercept body does NOT contain BYOK provider keys (sk- prefix)", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ decision: "allow" }),
-        });
-        const ee = createEEClient({ fetchImpl: mockFetch });
-        // Even if toolInput somehow contains key-like values, the intercept payload
-        // schema is toolName + toolInput + cwd only — no auth tokens from the CLI config
-        const reqWithNoKeys = {
-            toolName: "bash",
-            toolInput: { command: "echo hello" },
-            cwd: "/home/user",
-            tenantId: "local",
-            scope: { kind: "global" },
-        };
-        await ee.intercept(reqWithNoKeys);
-        const [, opts] = mockFetch.mock.calls[0];
-        const body = opts.body;
-        // The request body must not contain any "sk-" substring
-        expect(body).not.toMatch(/sk-/);
-        // Must not contain "Bearer sk-" form
-        expect(body).not.toMatch(/Bearer sk-/);
-    });
-});
-//# sourceMappingURL=client.test.js.map

package/dist/src/ee/extract-session.test.d.ts

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