The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 2 | import { ProviderInstanceId } from "@t3tools/contracts"; |
| 3 | import { totalTokens } from "@t3tools/provider-core/server/usage"; |
| 4 | import * as HostProcess from "@t3tools/shared/HostProcess"; |
| 5 | import { SpawnExecutableResolution } from "@t3tools/shared/shell"; |
| 6 | import * as Effect from "effect/Effect"; |
| 7 | import * as Deferred from "effect/Deferred"; |
| 8 | import * as Fiber from "effect/Fiber"; |
| 9 | import * as TestClock from "effect/testing/TestClock"; |
| 10 | import * as Path from "effect/Path"; |
| 11 | import * as Schema from "effect/Schema"; |
| 12 | import { it } from "@effect/vitest"; |
| 13 | import { describe, expect, vi } from "vite-plus/test"; |
| 14 | import { MuseSettings } from "../settings.ts"; |
| 15 | import * as MuseSdk from "./sdk.ts"; |
| 16 | import * as MuseUsageHome from "./MuseUsageHome.ts"; |
| 17 | import { museUsageFormat, museUsageReader } from "./usage.ts"; |
| 18 | |
| 19 | vi.mock("./sdk.ts", { spy: true }); |
| 20 | |
| 21 | const entry = () => ({ |
| 22 | schema_version: 1, |
| 23 | record_type: "event", |
| 24 | payload_type: "runtime.session", |
| 25 | payload_schema_version: 1, |
| 26 | id: "envelope-1", |
| 27 | recorded_at: 1_785_578_400_123_456, |
| 28 | stream: { kind: "session", id: "session-1" }, |
| 29 | payload: { |
| 30 | source_run_record_id: "inference-1", |
| 31 | event: { |
| 32 | kind: "model_completed", |
| 33 | model: "muse-wonder-full-1.0", |
| 34 | usage: { |
| 35 | input_tokens: 100, |
| 36 | cached_tokens: 60, |
| 37 | cache_read_tokens: 60, |
| 38 | cache_write_tokens: 10, |
| 39 | output_tokens: 20, |
| 40 | reasoning_tokens: 8, |
| 41 | }, |
| 42 | }, |
| 43 | }, |
| 44 | }); |
| 45 | const decodeSettings = Schema.decodeSync(MuseSettings); |
| 46 | const parse = (value: unknown) => museUsageFormat.parseLine(JSON.stringify(value), undefined); |
| 47 | |
| 48 | it("normalizes inclusive cache and reasoning counters without doubling the subsets", () => { |
| 49 | const [record] = parse(entry()); |
| 50 | expect(record).toMatchObject({ |
| 51 | provider: "muse", |
| 52 | timestampMs: Date.parse("2026-08-01T10:00:00.123Z"), |
| 53 | sessionId: "session-1", |
| 54 | model: "muse-wonder-full-1.0", |
| 55 | reportedCostUsd: null, |
| 56 | totals: { |
| 57 | uncachedInputTokens: 30, |
| 58 | cachedInputTokens: 60, |
| 59 | cacheCreationTokens: 10, |
| 60 | outputTokens: 20, |
| 61 | reasoningTokens: 8, |
| 62 | }, |
| 63 | }); |
| 64 | expect(totalTokens(record!.totals)).toBe(120); |
| 65 | const value = entry(); |
| 66 | const { cache_read_tokens: _read, ...usage } = value.payload.event.usage; |
| 67 | expect( |
| 68 | parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, usage } } }), |
| 69 | ).toEqual([record]); |
| 70 | }); |
| 71 | |
| 72 | it("keeps individual inference identity across copied parent/child envelopes", () => { |
| 73 | const original = entry(); |
| 74 | const [first] = parse(original); |
| 75 | const [copy] = parse({ ...original, id: "copy", stream: { kind: "session", id: "child" } }); |
| 76 | expect(copy?.dedupeKey).toBe(first?.dedupeKey); |
| 77 | const next = entry(); |
| 78 | next.payload.source_run_record_id = "inference-2"; |
| 79 | expect(parse(next)[0]?.dedupeKey).not.toBe(first?.dedupeKey); |
| 80 | const { source_run_record_id: _source, ...payload } = original.payload; |
| 81 | const fallback = parse({ ...original, payload }); |
| 82 | expect(fallback[0]?.dedupeKey).toBe(JSON.stringify(["muse", original.id])); |
| 83 | }); |
| 84 | |
| 85 | it("includes automated review inference models and ignores workflow and telemetry rollups", () => { |
| 86 | const value = entry(); |
| 87 | expect( |
| 88 | parse({ |
| 89 | ...value, |
| 90 | payload: { |
| 91 | ...value.payload, |
| 92 | event: { |
| 93 | ...value.payload.event, |
| 94 | kind: "automated_review_completed", |
| 95 | model: { model_id: "review-model", provider_id: "meta" }, |
| 96 | }, |
| 97 | }, |
| 98 | })[0]?.model, |
| 99 | ).toBe("review-model"); |
| 100 | for (const kind of [ |
| 101 | "workflow_completed", |
| 102 | "goal_usage_attribution", |
| 103 | "turn_completed", |
| 104 | "usage_summary", |
| 105 | ]) { |
| 106 | expect( |
| 107 | parse({ ...value, payload: { ...value.payload, event: { ...value.payload.event, kind } } }), |
| 108 | ).toEqual([]); |
| 109 | } |
| 110 | expect(parse({ ...value, payload_type: "run.telemetry" })).toEqual([]); |
| 111 | expect(parse({ ...value, record_type: "snapshot" })).toEqual([]); |
| 112 | expect(parse({ ...value, stream: { kind: "run", id: "run-1" } })).toEqual([]); |
| 113 | }); |
| 114 | |
| 115 | it("includes native version 3 automated review inferences", () => { |
| 116 | const value = entry(); |
| 117 | const review = { |
| 118 | ...value, |
| 119 | payload_schema_version: 3, |
| 120 | payload: { |
| 121 | ...value.payload, |
| 122 | event: { |
| 123 | ...value.payload.event, |
| 124 | kind: "automated_review_completed", |
| 125 | model: { provider_id: "meta", model_id: "review-model", reasoning_effort: "high" }, |
| 126 | usage: { |
| 127 | input_tokens: 100, |
| 128 | cached_input_tokens: 60, |
| 129 | output_tokens: 20, |
| 130 | reasoning_tokens: 8, |
| 131 | }, |
| 132 | }, |
| 133 | }, |
| 134 | }; |
| 135 | expect(parse(review)).toEqual([ |
| 136 | { |
| 137 | ...parse(value)[0], |
| 138 | model: "review-model", |
| 139 | totals: { |
| 140 | uncachedInputTokens: 40, |
| 141 | cachedInputTokens: 60, |
| 142 | cacheCreationTokens: 0, |
| 143 | outputTokens: 20, |
| 144 | reasoningTokens: 8, |
| 145 | }, |
| 146 | }, |
| 147 | ]); |
| 148 | expect(museUsageFormat.parseProjected(review, undefined)).toEqual(parse(review)); |
| 149 | }); |
| 150 | |
| 151 | it("handles malformed and partial data and rejects unsupported timestamps or schemas", () => { |
| 152 | expect(museUsageFormat.parseLine("not json", undefined)).toEqual([]); |
| 153 | expect(museUsageFormat.parseLine(JSON.stringify(entry()).slice(0, -1), undefined)).toEqual([]); |
| 154 | for (const recorded_at of [NaN, Infinity, -1, "1785578400123456", Number.MAX_SAFE_INTEGER + 1]) { |
| 155 | expect(museUsageFormat.parseProjected({ ...entry(), recorded_at }, undefined)).toEqual([]); |
| 156 | } |
| 157 | expect(parse({ ...entry(), schema_version: 2 })).toEqual([]); |
| 158 | expect(parse({ ...entry(), payload_schema_version: 2 })).toEqual([]); |
| 159 | expect(parse({ ...entry(), id: "" })).toEqual([]); |
| 160 | expect(parse({ ...entry(), payload: { event: { kind: "model_completed" } } })).toEqual([]); |
| 161 | const value = entry(); |
| 162 | const result = parse({ |
| 163 | ...value, |
| 164 | payload: { |
| 165 | event: { |
| 166 | ...value.payload.event, |
| 167 | usage: { |
| 168 | input_tokens: 10, |
| 169 | cache_read_tokens: 20, |
| 170 | cache_write_tokens: 8, |
| 171 | output_tokens: 3, |
| 172 | reasoning_tokens: 9, |
| 173 | }, |
| 174 | }, |
| 175 | }, |
| 176 | }); |
| 177 | expect(result[0]?.totals).toEqual({ |
| 178 | uncachedInputTokens: 0, |
| 179 | cachedInputTokens: 10, |
| 180 | cacheCreationTokens: 0, |
| 181 | outputTokens: 3, |
| 182 | reasoningTokens: 3, |
| 183 | }); |
| 184 | expect( |
| 185 | parse({ |
| 186 | ...value, |
| 187 | payload: { |
| 188 | event: { ...value.payload.event, usage: { input_tokens: -5, output_tokens: "20" } }, |
| 189 | }, |
| 190 | }), |
| 191 | ).toEqual([]); |
| 192 | }); |
| 193 | |
| 194 | const AWAIT_REFRESH = { awaitRefresh: true }; |
| 195 | const onPath = Effect.provideService(SpawnExecutableResolution, (command: string) => command); |
| 196 | |
| 197 | describe("Muse history discovery", () => { |
| 198 | it.effect.each([undefined, "/custom/xdg-data"])( |
| 199 | "uses the initialized home with XDG_DATA_HOME=%s and closes without starting a session", |
| 200 | (xdg) => |
| 201 | Effect.gen(function* () { |
| 202 | const path = yield* Path.Path; |
| 203 | const close = vi.fn(async () => {}); |
| 204 | using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue( |
| 205 | Effect.succeed({ |
| 206 | initializeResult: { grantedCapabilities: [], museHome: "/native/configured-home" }, |
| 207 | close, |
| 208 | } as unknown as MuseSdk.MuseSdkHost), |
| 209 | ); |
| 210 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 211 | const directories = yield* museUsageReader.directories( |
| 212 | { |
| 213 | instanceId: ProviderInstanceId.make("muse-other"), |
| 214 | configured: true, |
| 215 | config: decodeSettings({ binaryPath: "~/bin/custom-muse" }), |
| 216 | environment: { XDG_DATA_HOME: xdg, MUSE_NO_AUTO_UPDATE: "0" }, |
| 217 | }, |
| 218 | AWAIT_REFRESH, |
| 219 | ); |
| 220 | expect(directories).toEqual([ |
| 221 | { dir: path.join("/native/configured-home", "sessions"), fileName: "session.jsonl" }, |
| 222 | ]); |
| 223 | expect(create).toHaveBeenCalledWith({ |
| 224 | binaryPath: path.join("/test-home", "bin/custom-muse"), |
| 225 | environment: { |
| 226 | PATH: "/host/bin", |
| 227 | XDG_DATA_HOME: xdg ?? "/host/data", |
| 228 | MUSE_NO_AUTO_UPDATE: "1", |
| 229 | MISE_OFFLINE: "1", |
| 230 | }, |
| 231 | readOnly: true, |
| 232 | startupTimeoutMs: 5_000, |
| 233 | }); |
| 234 | expect(close).toHaveBeenCalledOnce(); |
| 235 | }).pipe( |
| 236 | Effect.provide([NodeServices.layer, MuseUsageHome.layer]), |
| 237 | onPath, |
| 238 | Effect.provideService(HostProcess.HomeDirectory, "/test-home"), |
| 239 | Effect.provideService(HostProcess.Environment, { |
| 240 | PATH: "/host/bin", |
| 241 | XDG_DATA_HOME: "/host/data", |
| 242 | }), |
| 243 | ), |
| 244 | ); |
| 245 | |
| 246 | it.effect("reports no history without starting Muse when its CLI is not installed", () => |
| 247 | Effect.gen(function* () { |
| 248 | using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect"); |
| 249 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 250 | const directories = yield* museUsageReader.directories( |
| 251 | { |
| 252 | instanceId: ProviderInstanceId.make("muse"), |
| 253 | configured: false, |
| 254 | config: undefined, |
| 255 | environment: {}, |
| 256 | }, |
| 257 | { awaitRefresh: false }, |
| 258 | ); |
| 259 | expect(directories).toEqual([]); |
| 260 | expect(create).not.toHaveBeenCalled(); |
| 261 | }).pipe( |
| 262 | Effect.provide([NodeServices.layer, MuseUsageHome.layer]), |
| 263 | Effect.provideService(SpawnExecutableResolution, () => undefined), |
| 264 | ), |
| 265 | ); |
| 266 | |
| 267 | it.effect("does not guess a directory when initialization fails", () => |
| 268 | Effect.gen(function* () { |
| 269 | using _create = vi |
| 270 | .spyOn(MuseSdk, "createMuseSdkHostEffect") |
| 271 | .mockReturnValue( |
| 272 | Effect.fail( |
| 273 | new MuseSdk.MuseSdkError({ operation: "start", cause: new Error("not installed") }), |
| 274 | ), |
| 275 | ); |
| 276 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 277 | const directories = yield* museUsageReader.directories( |
| 278 | { |
| 279 | instanceId: ProviderInstanceId.make("muse"), |
| 280 | configured: false, |
| 281 | config: undefined, |
| 282 | environment: {}, |
| 283 | }, |
| 284 | AWAIT_REFRESH, |
| 285 | ); |
| 286 | expect(directories).toEqual([]); |
| 287 | }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath), |
| 288 | ); |
| 289 | |
| 290 | it.effect( |
| 291 | "reuses discovery across accounts, date scans, and equivalent effective environments", |
| 292 | () => |
| 293 | Effect.gen(function* () { |
| 294 | const path = yield* Path.Path; |
| 295 | const close = vi.fn(async () => {}); |
| 296 | using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockReturnValue( |
| 297 | Effect.succeed({ |
| 298 | initializeResult: { museHome: "/native/home" }, |
| 299 | close, |
| 300 | } as unknown as MuseSdk.MuseSdkHost), |
| 301 | ); |
| 302 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 303 | const instance = { |
| 304 | instanceId: ProviderInstanceId.make("disabled-muse"), |
| 305 | configured: true, |
| 306 | config: decodeSettings({ binaryPath: "~/bin/muse", enabled: false }), |
| 307 | environment: { PATH: "/bin", XDG_DATA_HOME: "/data" }, |
| 308 | }; |
| 309 | const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH); |
| 310 | const second = yield* museUsageReader.directories( |
| 311 | { |
| 312 | ...instance, |
| 313 | instanceId: ProviderInstanceId.make("another-account"), |
| 314 | config: decodeSettings({ |
| 315 | binaryPath: path.join("/test-home", "bin/muse"), |
| 316 | enabled: true, |
| 317 | }), |
| 318 | environment: { |
| 319 | XDG_DATA_HOME: "/data", |
| 320 | PATH: "/bin", |
| 321 | UNUSED: undefined, |
| 322 | META_API_KEY: "ignored", |
| 323 | }, |
| 324 | }, |
| 325 | AWAIT_REFRESH, |
| 326 | ); |
| 327 | expect(second).toEqual(first); |
| 328 | expect(first).toEqual([ |
| 329 | { dir: path.join("/native/home", "sessions"), fileName: "session.jsonl" }, |
| 330 | ]); |
| 331 | expect(create).toHaveBeenCalledOnce(); |
| 332 | expect(close).toHaveBeenCalledOnce(); |
| 333 | }).pipe( |
| 334 | Effect.provide([NodeServices.layer, MuseUsageHome.layer]), |
| 335 | onPath, |
| 336 | Effect.provideService(HostProcess.HomeDirectory, "/test-home"), |
| 337 | Effect.provideService(HostProcess.Environment, {}), |
| 338 | ), |
| 339 | ); |
| 340 | |
| 341 | it.effect( |
| 342 | "rediscovers when the binary, instance environment, or inherited environment changes", |
| 343 | () => |
| 344 | Effect.gen(function* () { |
| 345 | using create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) => |
| 346 | Effect.succeed({ |
| 347 | initializeResult: { museHome: options.environment?.XDG_DATA_HOME }, |
| 348 | close: async () => {}, |
| 349 | } as unknown as MuseSdk.MuseSdkHost), |
| 350 | ); |
| 351 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 352 | const instance = { |
| 353 | instanceId: ProviderInstanceId.make("muse"), |
| 354 | configured: true, |
| 355 | config: undefined, |
| 356 | environment: {}, |
| 357 | }; |
| 358 | const first = yield* museUsageReader.directories(instance, AWAIT_REFRESH); |
| 359 | expect( |
| 360 | yield* museUsageReader.directories( |
| 361 | { |
| 362 | ...instance, |
| 363 | config: decodeSettings({ binaryPath: "custom-muse" }), |
| 364 | }, |
| 365 | AWAIT_REFRESH, |
| 366 | ), |
| 367 | ).toEqual(first); |
| 368 | const changed = yield* museUsageReader.directories( |
| 369 | { |
| 370 | ...instance, |
| 371 | environment: { XDG_DATA_HOME: "/other-data" }, |
| 372 | }, |
| 373 | AWAIT_REFRESH, |
| 374 | ); |
| 375 | expect(changed).not.toEqual(first); |
| 376 | const inherited = yield* museUsageReader |
| 377 | .directories(instance, AWAIT_REFRESH) |
| 378 | .pipe( |
| 379 | Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/new-host-data" }), |
| 380 | ); |
| 381 | expect(inherited).not.toEqual(first); |
| 382 | expect(inherited).not.toEqual(changed); |
| 383 | expect(create).toHaveBeenCalledTimes(4); |
| 384 | }).pipe( |
| 385 | Effect.provide([NodeServices.layer, MuseUsageHome.layer]), |
| 386 | onPath, |
| 387 | Effect.provideService(HostProcess.Environment, { XDG_DATA_HOME: "/host-data" }), |
| 388 | ), |
| 389 | ); |
| 390 | |
| 391 | it.effect("reports pending discovery without waiting and shares it with awaiting reads", () => |
| 392 | Effect.gen(function* () { |
| 393 | const started = yield* Deferred.make<void>(); |
| 394 | const ready = yield* Deferred.make<MuseSdk.MuseSdkHost>(); |
| 395 | using create = vi |
| 396 | .spyOn(MuseSdk, "createMuseSdkHostEffect") |
| 397 | .mockImplementation(() => |
| 398 | Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(ready))), |
| 399 | ); |
| 400 | const close = vi.fn(async () => {}); |
| 401 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 402 | const instance = { |
| 403 | instanceId: ProviderInstanceId.make("muse"), |
| 404 | configured: true, |
| 405 | config: undefined, |
| 406 | environment: {}, |
| 407 | }; |
| 408 | const pending = [{ dir: "muse", refreshing: true }]; |
| 409 | expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual( |
| 410 | pending, |
| 411 | ); |
| 412 | yield* Deferred.await(started); |
| 413 | const reads = yield* Effect.all( |
| 414 | [ |
| 415 | museUsageReader.directories(instance, AWAIT_REFRESH), |
| 416 | museUsageReader.directories(instance, AWAIT_REFRESH), |
| 417 | ], |
| 418 | { concurrency: "unbounded" }, |
| 419 | ).pipe(Effect.forkChild); |
| 420 | expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual( |
| 421 | pending, |
| 422 | ); |
| 423 | yield* Deferred.succeed(ready, { |
| 424 | initializeResult: { museHome: "/native/home" }, |
| 425 | close, |
| 426 | } as unknown as MuseSdk.MuseSdkHost); |
| 427 | const [first, second] = yield* Fiber.join(reads); |
| 428 | expect(first).toEqual(second); |
| 429 | expect(first).toHaveLength(1); |
| 430 | expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual(first); |
| 431 | const uninstalled = Effect.provideService(SpawnExecutableResolution, () => undefined); |
| 432 | expect( |
| 433 | yield* museUsageReader.directories(instance, { awaitRefresh: false }).pipe(uninstalled), |
| 434 | ).toEqual(first); |
| 435 | expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH).pipe(uninstalled)).toEqual( |
| 436 | first, |
| 437 | ); |
| 438 | expect(create).toHaveBeenCalledOnce(); |
| 439 | expect(close).toHaveBeenCalledOnce(); |
| 440 | }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath), |
| 441 | ); |
| 442 | |
| 443 | it.effect("briefly caches failed discovery and retries after installation recovers", () => |
| 444 | Effect.gen(function* () { |
| 445 | using create = vi |
| 446 | .spyOn(MuseSdk, "createMuseSdkHostEffect") |
| 447 | .mockReturnValueOnce( |
| 448 | Effect.fail( |
| 449 | new MuseSdk.MuseSdkError({ operation: "start", cause: new Error("not installed") }), |
| 450 | ), |
| 451 | ) |
| 452 | .mockReturnValue( |
| 453 | Effect.succeed({ |
| 454 | initializeResult: { museHome: "/installed/home" }, |
| 455 | close: async () => {}, |
| 456 | } as unknown as MuseSdk.MuseSdkHost), |
| 457 | ); |
| 458 | if (museUsageReader.kind !== "transcripts") throw new Error("Expected a transcript reader"); |
| 459 | const instance = { |
| 460 | instanceId: ProviderInstanceId.make("muse"), |
| 461 | configured: false, |
| 462 | config: undefined, |
| 463 | environment: {}, |
| 464 | }; |
| 465 | expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toEqual([]); |
| 466 | expect(yield* museUsageReader.directories(instance, { awaitRefresh: false })).toEqual([]); |
| 467 | expect(create).toHaveBeenCalledOnce(); |
| 468 | yield* TestClock.adjust("30 seconds"); |
| 469 | expect(yield* museUsageReader.directories(instance, AWAIT_REFRESH)).toHaveLength(1); |
| 470 | expect(create).toHaveBeenCalledTimes(2); |
| 471 | }).pipe(Effect.provide([NodeServices.layer, MuseUsageHome.layer]), onPath), |
| 472 | ); |
| 473 | }); |