Open History to see the last commit
1import { describe, expect, it } from "@effect/vitest";
2
3import {
4 decodeScanCache,
5 makeScanCacheWriter,
6 type CachedFile,
7 type ScanCache,
8} from "./usageScanCache.ts";
9import type { UsageRecord } from "@t3tools/provider-core/server/usage";
10
11import { TEST_FORMAT_MAP } from "./usageTestFormats.ts";
12import { initialCodexScanState, parseCodexLine } from "../provider/Drivers/codexUsage.ts";
13
14const parse = (parts: Iterable<string>) => JSON.parse([...parts].join(""));
15
16function record(overrides: Partial<UsageRecord> = {}): UsageRecord {
17 return {
18 provider: "claude",
19 timestampMs: 1_786_000_000_000,
20 model: "claude-fable-5",
21 sessionId: "session-a",
22 totals: {
23 uncachedInputTokens: 2,
24 cachedInputTokens: 1000,
25 cacheCreationTokens: 10,
26 outputTokens: 50,
27 reasoningTokens: 0,
28 },
29 reportedCostUsd: null,
30 speed: "standard",
31 dedupeKey: "msg_1:",
32 ...overrides,
33 };
34}
35
36function position(overrides: Partial<CachedFile["position"]> = {}): CachedFile["position"] {
37 return {
38 resumeOffset: 120,
39 guardLength: 64,
40 guardHash: 0xdeadbeef,
41 state: null,
42 ...overrides,
43 };
44}
45
46function cacheWith(entries: readonly [string, number, readonly UsageRecord[]][]): ScanCache {
47 const cache: ScanCache = new Map();
48 for (const [path, mtimeMs, records] of entries) {
49 cache.set(path, {
50 size: records.length * 10,
51 mtimeMs,
52 provider: "claude",
53 records,
54 tailRecords: [],
55 malformedRecords: 0,
56 position: position(),
57 });
58 }
59 return cache;
60}
61
62describe("scan cache round trip", () => {
63 it("restores cached history unchanged except for Claude local placeholders", () => {
64 const original = cacheWith([
65 [
66 "/a.jsonl",
67 100,
68 [record(), record({ dedupeKey: "msg_2:", model: "claude-opus-5-5", speed: "fast" })],
69 ],
70 [
71 "/b.jsonl",
72 200,
73 [
74 record({
75 sessionId: "session-b",
76 reportedCostUsd: 1.5,
77 totals: {
78 uncachedInputTokens: 0,
79 cachedInputTokens: 0,
80 cacheCreationTokens: 0,
81 outputTokens: 0,
82 reasoningTokens: 0,
83 },
84 }),
85 ],
86 ],
87 ]);
88 original.set("/grok.jsonl", {
89 size: 40,
90 malformedRecords: 2,
91 mtimeMs: 300,
92 provider: "grok",
93 records: [
94 record({ provider: "grok", model: "grok-4.5-build", dedupeKey: "s:p:grok-4.5-build" }),
95 record({ provider: "grok", model: "<synthetic>", dedupeKey: "s:p:<synthetic>" }),
96 ],
97 tailRecords: [record({ provider: "grok", model: "<synthetic>", dedupeKey: null })],
98 position: position({ resumeOffset: 30, guardLength: 30, guardHash: 123 }),
99 });
100 const state = initialCodexScanState();
101 for (const line of [
102 { type: "session_meta", payload: { id: "session-c", model_provider: "openai" } },
103 { type: "turn_context", payload: { model: "gpt-6-astra", turn_id: "native-turn" } },
104 {
105 type: "event_msg",
106 timestamp: "2026-08-01T10:00:00Z",
107 payload: {
108 type: "token_count",
109 info: { last_token_usage: { input_tokens: 1, output_tokens: 2 } },
110 },
111 },
112 ])
113 parseCodexLine(JSON.stringify(line), state);
114 const pending = {
115 ...record({
116 provider: "codex",
117 model: "gpt-6-astra",
118 sessionId: "session-c",
119 dedupeKey: null,
120 }),
121 unresolvedServiceTierTurnId: "native-turn",
122 };
123 const pendingTail = { ...pending, unresolvedServiceTierTurnId: "native-tail" };
124 original.set("/codex.jsonl", {
125 size: 80,
126 malformedRecords: 3,
127 mtimeMs: 400,
128 provider: "codex",
129 records: [
130 record({
131 provider: "codex",
132 model: "gpt-6-astra",
133 rateModel: "gpt-6",
134 dedupeKey: null,
135 speed: "ultrafast",
136 }),
137 pending,
138 ],
139 tailRecords: [pendingTail],
140 position: position({ state }),
141 });
142
143 original.set("/a.jsonl", {
144 ...original.get("/a.jsonl")!,
145 tailRecords: [record({ dedupeKey: "msg_tail:" })],
146 });
147 const claude = original.get("/a.jsonl")!;
148 const cached = new Map(original);
149 cached.set("/a.jsonl", {
150 ...claude,
151 records: [...claude.records, record({ model: "<synthetic>" })],
152 tailRecords: [
153 ...claude.tailRecords,
154 record({ model: "<synthetic>", dedupeKey: "msg_tail:" }),
155 ],
156 });
157 const restored = decodeScanCache(parse(makeScanCacheWriter()(cached, {})), TEST_FORMAT_MAP);
158
159 expect(restored.size).toBe(4);
160 expect(restored).toEqual(original);
161 });
162
163 it.each([5, 6, 7, 8, 10])(
164 "retains v%s history and compatible positions but invalidates obsolete state",
165 (version) => {
166 const original = cacheWith([["/gone.jsonl", 100, [record({ speed: "fast" })]]]);
167 original.set("/gone-codex.jsonl", {
168 ...original.get("/gone.jsonl")!,
169 provider: "codex",
170 malformedRecords: 1,
171 records: [record({ provider: "codex", speed: "fast", dedupeKey: null })],
172 position: position({
173 state: {
174 ...(version >= 6 ? initialCodexScanState() : {}),
175 model: "gpt-6-astra",
176 speed: "fast",
177 sessionId: "session-a",
178 lastUsageSignature: null,
179 sawSessionMeta: true,
180 suppressingForkCopies: false,
181 forkCopyAnchorMs: 0,
182 },
183 }),
184 });
185 original.set("/gone-pi.jsonl", {
186 ...original.get("/gone.jsonl")!,
187 size: 256,
188 provider: "pi",
189 records: [record({ provider: "pi", model: "anthropic/claude-fable-5" })],
190 malformedRecords: 3,
191 position: position({ state: { sessionId: "session-a" } }),
192 });
193 const cleanCodex = {
194 ...original.get("/gone-codex.jsonl")!,
195 malformedRecords: 0,
196 };
197 original.set("/clean-codex.jsonl", cleanCodex);
198 const encoded = parse(makeScanCacheWriter()(original, {}));
199 const entry = encoded.files["/gone.jsonl"]!;
200 const legacy = {
201 ...encoded,
202 version,
203 files: {
204 ...encoded.files,
205 "/gone.jsonl": {
206 s: entry.s,
207 m: entry.m,
208 p: entry.p,
209 r: entry.r,
210 t: entry.t,
211 o: entry.o,
212 gl: entry.gl,
213 gh: entry.gh,
214 cs: entry.cs,
215 },
216 },
217 };
218
219 const restored = decodeScanCache(JSON.parse(JSON.stringify(legacy)), TEST_FORMAT_MAP);
220 expect(restored.get("/gone.jsonl")).toEqual({
221 ...original.get("/gone.jsonl"),
222 size: -1,
223 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
224 });
225 expect(restored.get("/gone-codex.jsonl")).toEqual({
226 ...original.get("/gone-codex.jsonl"),
227 size: -1,
228 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
229 });
230 expect(restored.get("/clean-codex.jsonl")).toEqual({
231 ...cleanCodex,
232 size: version >= 8 ? cleanCodex.size : -1,
233 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
234 });
235 expect(restored.get("/gone-pi.jsonl")).toEqual(
236 version >= 6
237 ? original.get("/gone-pi.jsonl")
238 : {
239 ...original.get("/gone-pi.jsonl"),
240 size: -1,
241 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
242 },
243 );
244 },
245 );
246
247 it("re-parses a Claude transcript cached before partial copies were merged", () => {
248 const original = cacheWith([["/claude.jsonl", 100, [record()]]]);
249 const v11 = { ...parse(makeScanCacheWriter()(original, {})), version: 11 };
250
251 const restored = decodeScanCache(JSON.parse(JSON.stringify(v11)), TEST_FORMAT_MAP);
252 expect(restored.get("/claude.jsonl")).toEqual({
253 ...original.get("/claude.jsonl"),
254 size: -1,
255 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
256 });
257 });
258
259 it("rewrites only changed entries and still restores the whole cache", () => {
260 const write = makeScanCacheWriter();
261 const cache = cacheWith([
262 ["/a.jsonl", 100, [record()]],
263 ["/b.jsonl", 200, [record({ sessionId: "session-b" })]],
264 ]);
265 cache.set("/b.jsonl", { ...cache.get("/b.jsonl")!, malformedRecords: 2 });
266 const sources = { "claude\u0000/projects": { dir: "/projects", volumeId: "1:2" } };
267 expect(decodeScanCache(parse(write(cache, { sources })), TEST_FORMAT_MAP)).toEqual(cache);
268
269 cache.set("/b.jsonl", {
270 ...cache.get("/b.jsonl")!,
271 size: 30,
272 malformedRecords: 4,
273 records: [record({ sessionId: "session-c", model: "claude-opus-5-5", dedupeKey: "msg_3:" })],
274 });
275 const document = parse(write(cache, { sources }));
276 expect(decodeScanCache(document, TEST_FORMAT_MAP)).toEqual(cache);
277 expect(document.sources).toEqual(sources);
278 });
279
280 it("treats a corrupt or foreign document as an empty cache", () => {
281 expect(decodeScanCache(null, TEST_FORMAT_MAP).size).toBe(0);
282 expect(decodeScanCache("nonsense", TEST_FORMAT_MAP).size).toBe(0);
283 expect(
284 decodeScanCache({ version: 999, models: [], sessions: [], files: {} }, TEST_FORMAT_MAP).size,
285 ).toBe(0);
286 });
287
288 it("skips malformed file entries but keeps good ones", () => {
289 const encoded = parse(makeScanCacheWriter()(cacheWith([["/good.jsonl", 100, [record()]]]), {}));
290 const withJunk = {
291 ...encoded,
292 files: { ...encoded.files, "/bad.jsonl": { s: "nope", m: 1, p: "claude", r: [] } },
293 };
294
295 const restored = decodeScanCache(JSON.parse(JSON.stringify(withJunk)), TEST_FORMAT_MAP);
296 expect([...restored.keys()]).toEqual(["/good.jsonl"]);
297 });
298
299 it("drops the whole entry when any row is corrupt, forcing a cold re-parse", () => {
300 const encoded = parse(
301 makeScanCacheWriter()(
302 cacheWith([["/a.jsonl", 100, [record(), record({ dedupeKey: "msg_2:" })]]]),
303 {},
304 ),
305 );
306 const rows = encoded.files["/a.jsonl"]!.r;
307 const poisoned = {
308 ...encoded,
309 files: {
310 "/a.jsonl": {
311 ...encoded.files["/a.jsonl"]!,
312 r: [rows[0]!, [...rows[1]!.slice(0, 3), "not-a-number", ...rows[1]!.slice(4)]],
313 },
314 },
315 };
316
317 const restored = decodeScanCache(JSON.parse(JSON.stringify(poisoned)), TEST_FORMAT_MAP);
318 expect(restored.has("/a.jsonl")).toBe(false);
319 });
320});