The best way to control Claude Code, Codex and more from any computer or phone

main
ts 426 lines 13.9 KB
Raw
1 import { describe, expect, it } from "@effect/vitest";
2
3 import {
4 decodeScanCache,
5 makeScanCacheWriter,
6 type CachedFile,
7 type ScanCache,
8 } from "./usageScanCache.ts";
9 import type { UsageRecord } from "@t3tools/provider-core/server/usage";
10
11 import { TEST_FORMAT_MAP } from "./usageTestFormats.ts";
12 import { initialCodexScanState, parseCodexLine } from "../provider/Drivers/codexUsage.ts";
13
14 const parse = (parts: Iterable<string>) => JSON.parse([...parts].join(""));
15
16 function 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
36 function 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
46 function 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
62 describe("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 [
69 record(),
70 record({
71 dedupeKey: "msg_2:",
72 model: "claude-opus-5-5",
73 speed: "fast",
74 cacheCreation1hTokens: 8,
75 }),
76 ],
77 ],
78 [
79 "/b.jsonl",
80 200,
81 [
82 record({
83 sessionId: "session-b",
84 reportedCostUsd: 1.5,
85 totals: {
86 uncachedInputTokens: 0,
87 cachedInputTokens: 0,
88 cacheCreationTokens: 0,
89 outputTokens: 0,
90 reasoningTokens: 0,
91 },
92 }),
93 ],
94 ],
95 ]);
96 original.set("/grok.jsonl", {
97 size: 40,
98 malformedRecords: 2,
99 mtimeMs: 300,
100 provider: "grok",
101 records: [
102 record({ provider: "grok", model: "grok-4.5-build", dedupeKey: "s:p:grok-4.5-build" }),
103 record({ provider: "grok", model: "<synthetic>", dedupeKey: "s:p:<synthetic>" }),
104 ],
105 tailRecords: [record({ provider: "grok", model: "<synthetic>", dedupeKey: null })],
106 position: position({ resumeOffset: 30, guardLength: 30, guardHash: 123 }),
107 });
108 const state = initialCodexScanState();
109 for (const line of [
110 { type: "session_meta", payload: { id: "session-c", model_provider: "openai" } },
111 { type: "turn_context", payload: { model: "gpt-6-astra", turn_id: "native-turn" } },
112 {
113 type: "event_msg",
114 timestamp: "2026-08-01T10:00:00Z",
115 payload: {
116 type: "token_count",
117 info: { last_token_usage: { input_tokens: 1, output_tokens: 2 } },
118 },
119 },
120 ])
121 parseCodexLine(JSON.stringify(line), state);
122 const pending = {
123 ...record({
124 provider: "codex",
125 model: "gpt-6-astra",
126 sessionId: "session-c",
127 dedupeKey: null,
128 }),
129 unresolvedServiceTierTurnId: "native-turn",
130 };
131 const pendingTail = { ...pending, unresolvedServiceTierTurnId: "native-tail" };
132 original.set("/codex.jsonl", {
133 size: 80,
134 malformedRecords: 3,
135 mtimeMs: 400,
136 provider: "codex",
137 records: [
138 record({
139 provider: "codex",
140 model: "gpt-6-astra",
141 rateModel: "gpt-6",
142 dedupeKey: null,
143 speed: "ultrafast",
144 }),
145 pending,
146 ],
147 tailRecords: [pendingTail],
148 position: position({ state }),
149 });
150
151 original.set("/a.jsonl", {
152 ...original.get("/a.jsonl")!,
153 tailRecords: [record({ dedupeKey: "msg_tail:" })],
154 });
155 const claude = original.get("/a.jsonl")!;
156 const cached = new Map(original);
157 cached.set("/a.jsonl", {
158 ...claude,
159 records: [...claude.records, record({ model: "<synthetic>" })],
160 tailRecords: [
161 ...claude.tailRecords,
162 record({ model: "<synthetic>", dedupeKey: "msg_tail:" }),
163 ],
164 });
165 const restored = decodeScanCache(parse(makeScanCacheWriter()(cached, {})), TEST_FORMAT_MAP);
166
167 expect(restored.size).toBe(4);
168 expect(restored).toEqual(original);
169 });
170
171 it.each([5, 6, 7, 8, 10, 11, 12, 13])(
172 "retains v%s history and compatible positions but invalidates obsolete state",
173 (version) => {
174 const original = cacheWith([["/gone.jsonl", 100, [record({ speed: "fast" })]]]);
175 original.set("/gone-codex.jsonl", {
176 ...original.get("/gone.jsonl")!,
177 provider: "codex",
178 malformedRecords: 1,
179 records: [record({ provider: "codex", speed: "fast", dedupeKey: null })],
180 position: position({
181 state: {
182 ...(version >= 6 ? initialCodexScanState() : {}),
183 model: "gpt-6-astra",
184 speed: "fast",
185 sessionId: "session-a",
186 lastUsageSignature: null,
187 sawSessionMeta: true,
188 suppressingForkCopies: false,
189 forkCopyAnchorMs: 0,
190 },
191 }),
192 });
193 original.set("/gone-pi.jsonl", {
194 ...original.get("/gone.jsonl")!,
195 size: 256,
196 provider: "pi",
197 records: [record({ provider: "pi", model: "anthropic/claude-fable-5" })],
198 malformedRecords: 3,
199 position: position({ state: { sessionId: "session-a" } }),
200 });
201 const cleanCodex = {
202 ...original.get("/gone-codex.jsonl")!,
203 malformedRecords: 0,
204 };
205 original.set("/clean-codex.jsonl", cleanCodex);
206 const encoded = parse(makeScanCacheWriter()(original, {}));
207 const entry = encoded.files["/gone.jsonl"]!;
208 const legacy = {
209 ...encoded,
210 version,
211 files: {
212 ...encoded.files,
213 "/gone.jsonl": {
214 s: entry.s,
215 m: entry.m,
216 p: entry.p,
217 r: entry.r,
218 t: entry.t,
219 o: entry.o,
220 gl: entry.gl,
221 gh: entry.gh,
222 cs: entry.cs,
223 },
224 },
225 };
226
227 const restored = decodeScanCache(JSON.parse(JSON.stringify(legacy)), TEST_FORMAT_MAP);
228 expect(restored.get("/gone.jsonl")).toEqual(
229 version >= 13
230 ? original.get("/gone.jsonl")
231 : {
232 ...original.get("/gone.jsonl"),
233 size: -1,
234 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
235 },
236 );
237 expect(restored.get("/gone-codex.jsonl")).toEqual({
238 ...original.get("/gone-codex.jsonl"),
239 size: -1,
240 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
241 });
242 expect(restored.get("/clean-codex.jsonl")).toEqual({
243 ...cleanCodex,
244 size: -1,
245 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
246 });
247 expect(restored.get("/gone-pi.jsonl")).toEqual(
248 version >= 6
249 ? original.get("/gone-pi.jsonl")
250 : {
251 ...original.get("/gone-pi.jsonl"),
252 size: -1,
253 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
254 },
255 );
256 },
257 );
258
259 it("re-parses a v14 Codex entry that skipped records and restarts a clean one when it grows", () => {
260 const codex = (malformedRecords: number): CachedFile => ({
261 size: 10,
262 mtimeMs: 100,
263 provider: "codex",
264 records: [record({ provider: "codex", model: "gpt-6-astra", dedupeKey: null })],
265 tailRecords: [],
266 malformedRecords,
267 position: position({
268 state: { ...initialCodexScanState(), model: "gpt-6-astra", sessionId: "session-a" },
269 }),
270 });
271 const original: ScanCache = new Map([
272 ["/skipped-codex.jsonl", codex(1)],
273 ["/clean-codex.jsonl", codex(0)],
274 ]);
275 const v14 = { ...parse(makeScanCacheWriter()(original, {})), version: 14 };
276
277 const restored = decodeScanCache(JSON.parse(JSON.stringify(v14)), TEST_FORMAT_MAP);
278 expect(restored.get("/skipped-codex.jsonl")).toEqual({
279 ...codex(1),
280 size: -1,
281 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
282 });
283 // Served while unchanged, but its state predates the latest snapshot time, so it cannot resume.
284 expect(restored.get("/clean-codex.jsonl")).toEqual({
285 ...codex(0),
286 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
287 });
288 // The migrated entries persist without a state and load again under the current version.
289 expect(decodeScanCache(parse(makeScanCacheWriter()(restored, {})), TEST_FORMAT_MAP)).toEqual(
290 restored,
291 );
292 });
293
294 it("restarts a grown v15 Codex entry, whose baseline time can be older than its totals", () => {
295 const request = {
296 input_tokens: 100,
297 cached_input_tokens: 0,
298 cache_write_input_tokens: 0,
299 output_tokens: 20,
300 reasoning_output_tokens: 0,
301 total_tokens: 120,
302 };
303 const entry: CachedFile = {
304 size: 10,
305 mtimeMs: 100,
306 provider: "codex",
307 records: [record({ provider: "codex", model: "gpt-6-astra", dedupeKey: null })],
308 tailRecords: [],
309 malformedRecords: 0,
310 position: position({
311 state: {
312 ...initialCodexScanState(),
313 model: "gpt-6-astra",
314 lastCumulativeUsage: request,
315 latestCumulativeAtMs: 1_786_000_000_000,
316 },
317 }),
318 };
319 const current = parse(makeScanCacheWriter()(new Map([["/codex.jsonl", entry]]), {}));
320
321 expect(
322 decodeScanCache({ ...current, version: 15 }, TEST_FORMAT_MAP).get("/codex.jsonl"),
323 ).toEqual({
324 ...entry,
325 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
326 });
327 expect(decodeScanCache(current, TEST_FORMAT_MAP).get("/codex.jsonl")).toEqual(entry);
328 });
329
330 it("re-parses a Claude transcript cached before 1-hour cache writes were counted", () => {
331 const original = cacheWith([["/claude.jsonl", 100, [record()]]]);
332 const v12 = { ...parse(makeScanCacheWriter()(original, {})), version: 12 };
333
334 const restored = decodeScanCache(JSON.parse(JSON.stringify(v12)), TEST_FORMAT_MAP);
335 expect(restored.get("/claude.jsonl")).toEqual({
336 ...original.get("/claude.jsonl"),
337 size: -1,
338 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
339 });
340 });
341
342 it.each(["s:p:grok-4.5", "s:p:1786000000000:grok-4.5"])(
343 "re-parses v16 Grok transcripts with key %s",
344 (dedupeKey) => {
345 const original = cacheWith([
346 ["/grok/updates.jsonl", 100, [record({ provider: "grok", model: "grok-4.5", dedupeKey })]],
347 ]);
348 original.set("/grok/updates.jsonl", {
349 ...original.get("/grok/updates.jsonl")!,
350 provider: "grok",
351 });
352 const encoded = parse(makeScanCacheWriter()(original, {}));
353 const restored = decodeScanCache({ ...encoded, version: 16 }, TEST_FORMAT_MAP);
354 expect(restored.get("/grok/updates.jsonl")).toEqual({
355 ...original.get("/grok/updates.jsonl"),
356 size: -1,
357 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
358 records: [
359 record({ provider: "grok", model: "grok-4.5", dedupeKey: "s:p:1786000000000:grok-4.5" }),
360 ],
361 });
362 },
363 );
364
365 it("rewrites only changed entries and still restores the whole cache", () => {
366 const write = makeScanCacheWriter();
367 const cache = cacheWith([
368 ["/a.jsonl", 100, [record()]],
369 ["/b.jsonl", 200, [record({ sessionId: "session-b" })]],
370 ]);
371 cache.set("/b.jsonl", { ...cache.get("/b.jsonl")!, malformedRecords: 2 });
372 const sources = { "claude\u0000/projects": { dir: "/projects", volumeId: "1:2" } };
373 expect(decodeScanCache(parse(write(cache, { sources })), TEST_FORMAT_MAP)).toEqual(cache);
374
375 cache.set("/b.jsonl", {
376 ...cache.get("/b.jsonl")!,
377 size: 30,
378 malformedRecords: 4,
379 records: [record({ sessionId: "session-c", model: "claude-opus-5-5", dedupeKey: "msg_3:" })],
380 });
381 const document = parse(write(cache, { sources }));
382 expect(decodeScanCache(document, TEST_FORMAT_MAP)).toEqual(cache);
383 expect(document.sources).toEqual(sources);
384 });
385
386 it("treats a corrupt or foreign document as an empty cache", () => {
387 expect(decodeScanCache(null, TEST_FORMAT_MAP).size).toBe(0);
388 expect(decodeScanCache("nonsense", TEST_FORMAT_MAP).size).toBe(0);
389 expect(
390 decodeScanCache({ version: 999, models: [], sessions: [], files: {} }, TEST_FORMAT_MAP).size,
391 ).toBe(0);
392 });
393
394 it("skips malformed file entries but keeps good ones", () => {
395 const encoded = parse(makeScanCacheWriter()(cacheWith([["/good.jsonl", 100, [record()]]]), {}));
396 const withJunk = {
397 ...encoded,
398 files: { ...encoded.files, "/bad.jsonl": { s: "nope", m: 1, p: "claude", r: [] } },
399 };
400
401 const restored = decodeScanCache(JSON.parse(JSON.stringify(withJunk)), TEST_FORMAT_MAP);
402 expect([...restored.keys()]).toEqual(["/good.jsonl"]);
403 });
404
405 it("drops the whole entry when any row is corrupt, forcing a cold re-parse", () => {
406 const encoded = parse(
407 makeScanCacheWriter()(
408 cacheWith([["/a.jsonl", 100, [record(), record({ dedupeKey: "msg_2:" })]]]),
409 {},
410 ),
411 );
412 const rows = encoded.files["/a.jsonl"]!.r;
413 const poisoned = {
414 ...encoded,
415 files: {
416 "/a.jsonl": {
417 ...encoded.files["/a.jsonl"]!,
418 r: [rows[0]!, [...rows[1]!.slice(0, 3), "not-a-number", ...rows[1]!.slice(4)]],
419 },
420 },
421 };
422
423 const restored = decodeScanCache(JSON.parse(JSON.stringify(poisoned)), TEST_FORMAT_MAP);
424 expect(restored.has("/a.jsonl")).toBe(false);
425 });
426 });