// @effect-diagnostics nodeBuiltinImport:off - the suite seeds and grows real
// transcript trees on disk, outside the service's Effect FileSystem.
import * as NodeChildProcess from "node:child_process";
import * as NodeFSP from "node:fs/promises";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeSqlite from "node:sqlite";
import * as NodeZlib from "node:zlib";
import { assert, describe, it } from "@effect/vitest";
import { vi } from "vite-plus/test";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { mergeUsage } from "@t3tools/shared/usageMerge";
import {
EnvironmentId,
ProviderDriverKind,
ProviderInstanceId,
UsageDay,
type UsageSource,
type UsageSummary,
type UsageSummaryInput,
} from "@t3tools/contracts";
import * as Duration from "effect/Duration";
import * as Clock from "effect/Clock";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Context from "effect/Context";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Scheduler from "effect/Scheduler";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import * as SqlClient from "effect/sql/SqlClient";
import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
import * as ServerConfig from "../config.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as Sqlite from "../persistence/Sqlite.ts";
import * as CodexUsageHistory from "./CodexUsageHistory.ts";
import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
import * as UsageService from "./UsageService.ts";
import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts";
import { MuseUsageHome } from "@t3tools/provider-muse/server";
import { makeScanCacheWriter, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";
vi.mock("node:fs/promises", { spy: true });
vi.mock("../../../../packages/provider-muse/src/server/sdk.ts", async (importOriginal) => {
const original = await importOriginal<typeof MuseSdk>();
return {
...original,
createMuseSdkHostEffect: vi.fn(() =>
Effect.fail(
new original.MuseSdkError({
operation: "start",
cause: new Error("Muse is not installed in this test"),
}),
),
),
};
});
const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
const decodeUnknownJsonString = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
function claudeLine(
id: number,
outputTokens: number,
model = "claude-fable-5",
sessionId = "session-1",
): string {
return `${JSON.stringify({
type: "assistant",
timestamp: "2026-08-01T10:00:00Z",
requestId: `req_${id}`,
sessionId,
message: {
id: `msg_${id}`,
model,
usage: { input_tokens: 10, output_tokens: outputTokens },
},
})}\n`;
}
const WINDOW: UsageSummaryInput = {
timeZone: "UTC",
sinceDay: UsageDay.make("2026-07-31"),
untilDay: UsageDay.make("2026-08-02"),
};
const setup = Effect.gen(function* () {
const home = yield* Effect.promise(() =>
NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "usage-service-test-")),
);
yield* Effect.addFinalizer(() =>
Effect.promise(() => NodeFSP.rm(home, { recursive: true, force: true })),
);
const transcriptDir = NodePath.join(home, "claude", "projects", "proj");
yield* Effect.promise(() => NodeFSP.mkdir(transcriptDir, { recursive: true }));
return {
home,
transcript: NodePath.join(transcriptDir, "session.jsonl"),
settings: {
providerInstances: {
[ProviderInstanceId.make("claudeAgent")]: {
driver: ProviderDriverKind.make("claudeAgent"),
config: { homePath: NodePath.join(home, "claude") },
},
[ProviderInstanceId.make("codex")]: {
driver: ProviderDriverKind.make("codex"),
config: { homePath: NodePath.join(home, "codex") },
},
},
},
};
});
const layerCursorUsageAccounts = <E, R>(
reader: Layer.Layer<CursorAccountReader.CursorAccountReader, E, R>,
) => Layer.fresh(CursorUsageAccounts.layer).pipe(Layer.provide(reader));
const makeWithCursor = (read: CursorAccountReader.CursorAccountReader["Service"]["read"]) =>
Effect.gen(function* () {
const context = yield* Layer.build(
layerCursorUsageAccounts(Layer.succeed(CursorAccountReader.CursorAccountReader, { read })),
);
const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
const service = yield* UsageService.make.pipe(Effect.provideContext(context));
return {
...service,
awaitPersisted: Effect.andThen(service.awaitPersisted, accounts.awaitPersisted),
};
});
const layerService = (input: {
readonly prefix: string;
readonly home: string;
readonly settings: Parameters<typeof ServerSettings.layerTest>[0];
readonly onRatesFetch?: (request: HttpClientRequest.HttpClientRequest) => void;
readonly ratesDocument?: unknown;
readonly ratesStatus?: () => number;
readonly ratesResponse?: (
request: HttpClientRequest.HttpClientRequest,
) => Effect.Effect<Response, HttpClientError.HttpClientError>;
readonly environment?: NodeJS.ProcessEnv;
readonly platform?: NodeJS.Platform;
readonly hostname?: string;
readonly secretStore?: Partial<ServerSecretStore.ServerSecretStore["Service"]>;
}) =>
layerCursorUsageAccounts(
CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer)),
).pipe(
Layer.provideMerge(AntigravityUsage.layer),
Layer.provideMerge(MuseUsageHome.layer),
Layer.provideMerge(ProviderHostLive.layer),
Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
Layer.provideMerge(
Layer.mock(ServerSecretStore.ServerSecretStore)({
get: () => Effect.succeedNone,
...input.secretStore,
}),
),
Layer.provideMerge(
ServerConfig.layerTest(process.cwd(), NodePath.join(input.home, input.prefix)),
),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
Layer.provideMerge(Layer.succeed(HostProcess.Platform, input.platform ?? "linux")),
Layer.provideMerge(Layer.succeed(HostProcess.Hostname, input.hostname ?? "usage-test-host")),
Layer.provideMerge(ServerSettings.layerTest(input.settings)),
Layer.provideMerge(
Layer.succeed(
HttpClient.HttpClient,
HttpClient.make((request) =>
Effect.suspend(() => {
input.onRatesFetch?.(request);
const response = input.ratesResponse
? input.ratesResponse(request)
: Effect.succeed(
Response.json(input.ratesDocument ?? {}, {
status: input.ratesStatus?.() ?? 200,
}),
);
return response.pipe(
Effect.map((response) => HttpClientResponse.fromWeb(request, response)),
);
}),
),
),
),
Layer.provideMerge(
Layer.succeed(HostProcess.Environment, {
HOME: input.home,
GROK_HOME: NodePath.join(input.home, "grok"),
PI_CODING_AGENT_DIR: NodePath.join(input.home, "pi"),
OPENCODE_DATA_DIR: NodePath.join(input.home, "opencode"),
ANTIGRAVITY_DATA_DIR: NodePath.join(input.home, "antigravity"),
XDG_CONFIG_HOME: NodePath.join(input.home, "config"),
APPDATA: NodePath.join(input.home, "config"),
...input.environment,
}),
),
);
const BEFORE_NARROW_WINDOW = Date.parse("2026-08-01T10:00:00Z") / 1000;
const NARROW_WINDOW: UsageSummaryInput = {
timeZone: "UTC",
sinceDay: UsageDay.make("2026-09-01"),
untilDay: UsageDay.make("2026-09-02"),
};
// Each waiting gate holds a libuv thread; allow at most three.
const makeGate = (path: string, lastWriteSeconds?: number) =>
Effect.promise(async () => {
NodeChildProcess.execFileSync("mkfifo", [path]);
if (lastWriteSeconds !== undefined) {
await NodeFSP.utimes(path, lastWriteSeconds, lastWriteSeconds);
}
});
const openGate = (path: string) =>
Effect.promise(async () => (await NodeFSP.open(path, "w")).close());
const replaceFile = (path: string, content: string) =>
Effect.promise(async () => {
await NodeFSP.writeFile(path + ".next", content);
await NodeFSP.rename(path + ".next", path);
});
function totalOutputTokens(summary: { buckets: readonly { totals: { outputTokens: number } }[] }) {
return summary.buckets.reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0);
}
const CURSOR_NOW = Date.parse("2026-08-02T12:00:00Z");
const HOUR_MS = 60 * 60 * 1000;
function makeFakeCursor() {
const state = {
accountKey: "account-a",
events: [] as { readonly timestampMs: number; readonly outputTokens: number }[],
error: null as string | null,
gate: undefined as Deferred.Deferred<void> | undefined,
calls: [] as { readonly sinceMs: number; readonly untilMs: number }[],
credentials: [] as unknown[],
};
const read = (credential: unknown, sinceMs: number, untilMs: number) =>
Effect.gen(function* () {
state.calls.push({ sinceMs, untilMs });
state.credentials.push(credential);
if (state.gate !== undefined) yield* Deferred.await(state.gate);
const { accountKey, error } = state;
if (error !== null) return { accountKey, records: [], missing: false, error };
const occurrences = new Map<string, number>();
const records = state.events
.filter(({ timestampMs }) => timestampMs >= sinceMs && timestampMs <= untilMs)
.map(({ timestampMs, outputTokens }): UsageRecord => {
const key = `${timestampMs}:${outputTokens}`;
const occurrence = occurrences.get(key) ?? 0;
occurrences.set(key, occurrence + 1);
return {
provider: "cursor",
timestampMs,
model: "claude-fable-5",
sessionId: "conversation-1",
totals: {
uncachedInputTokens: 0,
cachedInputTokens: 0,
cacheCreationTokens: 0,
outputTokens,
reasoningTokens: 0,
},
reportedCostUsd: null,
speed: "standard",
dedupeKey: `cursor-account:${accountKey}:${key}:${occurrence}`,
};
});
return { accountKey, records, missing: false, error: null };
});
return { state, read };
}
const writeCursorLogin = (home: string) =>
Effect.promise(async () => {
const authPath = NodePath.join(home, "config", "cursor", "auth.json");
await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
await NodeFSP.writeFile(authPath, "{}");
});
function cursorSource(summary: { readonly sources: readonly UsageSource[] }) {
return summary.sources.find((source) => source.fingerprint.provider === "cursor");
}
function cursorSources(summary: { readonly sources: readonly UsageSource[] }) {
return summary.sources.filter((source) => source.fingerprint.provider === "cursor");
}
const seedCodexHistory = (input: {
id: string;
nativeTurnId?: string;
sessionId?: string;
model?: string;
options?: readonly { id: string; value: string | boolean }[];
}) =>
Effect.gen(function* () {
const sql = yield* SqlClient.SqlClient;
const { id } = input;
const selection = {
instanceId: "codex",
model: input.model ?? "gpt-6-astra",
options: input.options ?? [{ id: "serviceTier", value: "priority" }],
};
const run = {
id: `run-${id}`,
activeAttemptId: `attempt-${id}`,
status: "running",
modelSelection: selection,
};
yield* sql`INSERT INTO orchestration_v2_projection_run_attempts ${sql.insert({
attempt_id: run.activeAttemptId,
thread_id: `thread-${id}`,
run_id: run.id,
attempt_ordinal: 1,
root_node_id: `node-${id}`,
provider: "codex",
provider_thread_id: `provider-thread-${id}`,
provider_turn_id: `turn-${id}`,
status: "completed",
payload_json: encodeUnknownJsonString({ nativeThreadId: input.sessionId ?? "session" }),
})}`;
yield* sql`INSERT INTO orchestration_v2_projection_provider_turns ${sql.insert({
provider_turn_id: `turn-${id}`,
thread_id: `thread-${id}`,
provider_thread_id: `provider-thread-${id}`,
node_id: `node-${id}`,
run_attempt_id: run.activeAttemptId,
ordinal: 1,
status: "completed",
payload_json: encodeUnknownJsonString({
nativeTurnRef: { driver: "codex", nativeId: input.nativeTurnId ?? id, strength: "strong" },
}),
})}`;
const changedSelection = {
...selection,
options: [{ id: "serviceTier", value: "ultrafast" }],
};
// These selections disagree so reading the current projection or the wrong event is visible.
yield* sql`INSERT INTO orchestration_v2_projection_runs ${sql.insert({
run_id: run.id,
thread_id: `thread-${id}`,
ordinal: 1,
provider: "codex",
provider_thread_id: `provider-thread-${id}`,
status: "completed",
requested_at: "2026-08-01T10:00:00Z",
payload_json: encodeUnknownJsonString({
...run,
status: "completed",
modelSelection: { ...selection, options: [] },
}),
})}`;
for (const [index, payload] of [
{ ...run, activeAttemptId: "earlier-attempt", modelSelection: changedSelection },
{ ...run, status: "queued", modelSelection: changedSelection },
run,
{ ...run, modelSelection: changedSelection },
].entries()) {
yield* sql`INSERT INTO orchestration_events ${sql.insert({
event_id: `event-${id}-${index}`,
aggregate_kind: "thread",
stream_id: `thread-${id}`,
stream_version: index + 1,
event_type: "run.updated",
occurred_at: "2026-08-01T10:00:00Z",
actor_kind: "system",
metadata_json: "{}",
application_event_version: 2,
payload_json: encodeUnknownJsonString(payload),
})}`;
}
});
describe("Codex usage history", () => {
const historyLayer = CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory));
const request = (nativeTurnId: string) => ({
sessionId: "session",
nativeTurnId,
model: "gpt-6-astra",
});
it.effect("resolves a batch from each attempt's first running selection", () =>
Effect.gen(function* () {
yield* seedCodexHistory({ id: "fast" });
yield* seedCodexHistory({
id: "ultrafast",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
yield* seedCodexHistory({ id: "legacy-option", options: [{ id: "fastMode", value: true }] });
yield* seedCodexHistory({ id: "standard", options: [] });
const requests = ["fast", "ultrafast", "legacy-option", "standard", "fast"].map(request);
const history = yield* CodexUsageHistory.CodexUsageHistory;
const resolved = yield* history.resolve(requests);
assert.strictEqual(resolved.size, requests.length);
assert.deepStrictEqual(
requests.map((item) => resolved.get(item)),
["fast", "ultrafast", "fast", "standard", "fast"],
);
}).pipe(Effect.provide(historyLayer)),
);
it.effect("leaves ambiguous, mismatched, and missing V2 evidence unresolved", () =>
Effect.gen(function* () {
for (const id of [
"valid",
"duplicate-model",
"duplicate-session",
"imported",
"v1-event",
"queued",
"missing-selection",
]) {
yield* seedCodexHistory({ id });
}
yield* seedCodexHistory({
id: "second-model",
nativeTurnId: "duplicate-model",
model: "other-model",
});
yield* seedCodexHistory({
id: "second-session",
nativeTurnId: "duplicate-session",
sessionId: "other-session",
});
yield* seedCodexHistory({ id: "wrong-model", model: "other-model" });
yield* seedCodexHistory({ id: "wrong-session", sessionId: "other-session" });
const sql = yield* SqlClient.SqlClient;
yield* sql`UPDATE orchestration_v2_projection_provider_turns
SET run_attempt_id = NULL WHERE provider_turn_id = 'turn-imported'`;
yield* sql`DELETE FROM orchestration_v2_projection_run_attempts WHERE attempt_id = 'attempt-imported'`;
yield* sql`UPDATE orchestration_events SET application_event_version = 1
WHERE stream_id = 'thread-v1-event'`;
yield* sql`UPDATE orchestration_events
SET payload_json = json_set(payload_json, '$.status', 'queued')
WHERE stream_id = 'thread-queued'`;
yield* sql`UPDATE orchestration_events
SET payload_json = json_remove(payload_json, '$.modelSelection')
WHERE event_id = 'event-missing-selection-2'`;
const requests = [
"valid",
"duplicate-model",
"duplicate-session",
"wrong-model",
"wrong-session",
"missing-turn",
"imported",
"v1-event",
"queued",
"missing-selection",
].map(request);
const history = yield* CodexUsageHistory.CodexUsageHistory;
const resolved = yield* history.resolve(requests);
assert.deepStrictEqual([...resolved], [[requests[0], "fast"]]);
}).pipe(Effect.provide(historyLayer)),
);
it.effect(
"reports SQL failures through the typed channel and can resolve again after repair",
() =>
Effect.gen(function* () {
yield* seedCodexHistory({ id: "retry" });
const history = yield* CodexUsageHistory.CodexUsageHistory;
const sql = yield* SqlClient.SqlClient;
const input = request("retry");
yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
const error = yield* Effect.flip(history.resolve([input]));
assert.instanceOf(error, CodexUsageHistory.CodexUsageHistoryReadError);
assert.strictEqual(error.requestedTurnCount, 1);
yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
assert.strictEqual((yield* history.resolve([input])).get(input), "fast");
}).pipe(Effect.provide(historyLayer)),
);
});
describe("UsageService", () => {
it.live("counts compressed Codex rollouts across refresh, rewrites, and cache restarts", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const sessions = NodePath.join(home, "codex", "sessions");
const compressedPath = NodePath.join(sessions, "compressed.jsonl.zst");
const usage = (output_tokens: number, timestamp = "2026-08-01T10:00:00Z") =>
encodeUnknownJsonString({
type: "event_msg",
timestamp,
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 10, output_tokens } },
},
}) + "\n";
const rollout = (id: string, output: number) =>
[
{ type: "session_meta", payload: { id } },
{ type: "turn_context", payload: { model: "gpt-6-astra" } },
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") +
"\n" +
usage(output);
const compressed = rollout("compressed-session", 23);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(sessions, "plain.jsonl"),
rollout("plain-session", 17),
);
await NodeFSP.writeFile(compressedPath, NodeZlib.zstdCompressSync(compressed));
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(first), 40);
assert.strictEqual(
first.sources.find((source) => source.fingerprint.provider === "codex")?.distinctSessions,
2,
);
assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, first.buckets);
yield* service.awaitPersisted;
// The same rollout may remain in a plain file while compression finishes.
yield* Effect.promise(() =>
NodeFSP.writeFile(NodePath.join(sessions, "copy.jsonl"), compressed),
);
assert.strictEqual(totalOutputTokens(yield* service.readSummary(WINDOW)), 40);
yield* Effect.promise(() =>
NodeFSP.writeFile(
compressedPath,
NodeZlib.zstdCompressSync(compressed + usage(31, "2026-08-01T10:00:05Z")),
),
);
const rewritten = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(rewritten), 71);
assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, rewritten.buckets);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, rewritten.buckets);
yield* restarted.awaitPersisted;
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix: "usage-compressed-codex", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live("keeps the first host identity across recreation and explicit override removal", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
for (const [hostname, override, expected] of [
["container-a", undefined, "container-a"],
["container-b", undefined, "container-a"],
["container-c", "physical-host", "physical-host"],
["container-d", undefined, "container-a"],
] as const) {
const summary = yield* Effect.gen(function* () {
const service = yield* UsageService.make;
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-host-id",
home,
settings,
hostname,
environment: override === undefined ? {} : { T3CODE_HOST_ID: override },
}),
),
);
const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
assert.strictEqual(source?.fingerprint.hostId, expected);
}
}).pipe(Effect.scoped),
);
it.live("concurrent initialization keeps one host identity across service recreation", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
const prefix = "usage-host-id-race";
const hostIdPath = NodePath.join(home, prefix, "usage-host-id");
const bothRead = yield* Deferred.make<void>();
let reads = 0;
const summaries = yield* Effect.forEach(
["container-a", "container-b"],
(hostname) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
let firstRead = true;
const service = yield* UsageService.make.pipe(
Effect.provideService(FileSystem.FileSystem, {
...fileSystem,
readFileString: (path, encoding) =>
Effect.gen(function* () {
if (path !== hostIdPath || !firstRead) {
return yield* fileSystem.readFileString(path, encoding);
}
firstRead = false;
// Both instances observe the missing file before either can create it.
const result = yield* Effect.exit(fileSystem.readFileString(path, encoding));
reads += 1;
if (reads === 2) yield* Deferred.succeed(bothRead, undefined);
yield* Deferred.await(bothRead);
return yield* result;
}),
}),
);
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix, home, settings, hostname })),
),
{ concurrency: "unbounded" },
);
const persisted = yield* Effect.promise(() => NodeFSP.readFile(hostIdPath, "utf8"));
const hostId = persisted.trim();
assert.include(["container-a", "container-b"], hostId);
const restarted = yield* Effect.gen(function* () {
const service = yield* UsageService.make;
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix, home, settings, hostname: "container-c" })),
);
for (const summary of [...summaries, restarted]) {
const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
assert.strictEqual(source?.fingerprint.hostId, hostId);
}
}).pipe(Effect.scoped),
);
it.live(
"repairs initial Codex prices after unchanged-file retries, persists evidence and corrections, and honors later native tiers",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const sessions = NodePath.join(home, "codex", "sessions");
const fastPath = NodePath.join(sessions, "fast.jsonl");
const ultraPath = NodePath.join(sessions, "ultra.jsonl");
const meta = (id: string) => ({
type: "session_meta",
payload: { id, model_provider: "openai" },
});
const context = (turn_id?: string) => ({
type: "turn_context",
payload: { model: "gpt-6-astra", turn_id },
});
const usage = (output_tokens: number) => ({
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 0, output_tokens } },
},
});
const tier = (service_tier?: string) => ({
type: "event_msg",
payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
});
const lines = (records: readonly unknown[]) =>
records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
const verify = (summary: UsageSummary, output: number, cost: number) => {
assert.strictEqual(totalOutputTokens(summary), output);
assert.strictEqual(
summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
cost,
);
};
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
fastPath,
lines([meta("fast-session"), context("fast-turn"), usage(1)]) +
encodeUnknownJsonString(usage(2)),
);
await NodeFSP.writeFile(
ultraPath,
lines([meta("ultra-session"), context("ultra-turn"), usage(4)]),
);
});
yield* Effect.gen(function* () {
const first = yield* UsageService.make;
verify(yield* first.readSummary(WINDOW), 7, 7);
yield* first.awaitPersisted;
const pending = yield* UsageService.make;
verify(yield* pending.readSummary(WINDOW), 7, 7);
yield* seedCodexHistory({ id: "fast-turn", sessionId: "fast-session" });
yield* seedCodexHistory({
id: "ultra-turn",
sessionId: "ultra-session",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
const sql = yield* SqlClient.SqlClient;
yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
verify(yield* pending.readSummary(WINDOW), 7, 7);
yield* pending.awaitPersisted;
const retry = yield* UsageService.make;
verify(yield* retry.readSummary(WINDOW), 7, 7);
yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
// History repair must touch both the committed record and tentative tail.
verify(yield* retry.readSummary(WINDOW), 7, 30);
yield* retry.awaitPersisted;
yield* sql`ALTER TABLE orchestration_events RENAME TO resolved_events`;
verify(yield* retry.readSummary(WINDOW), 7, 30);
const resolved = yield* UsageService.make;
verify(yield* resolved.readSummary(WINDOW), 7, 30);
yield* sql`ALTER TABLE resolved_events RENAME TO orchestration_events`;
// Completing the tail reparses it; neither an absent turn ID nor a new
// turn with no retained attempt may inherit the inferred Fast speed.
yield* Effect.promise(() =>
NodeFSP.appendFile(
fastPath,
"\n" + lines([context(), usage(3), context("unretained-turn"), usage(4)]),
),
);
verify(yield* resolved.readSummary(WINDOW), 14, 37);
yield* seedCodexHistory({
id: "native-turn",
sessionId: "fast-session",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
yield* seedCodexHistory({ id: "later-native-turn", sessionId: "fast-session" });
yield* Effect.promise(() =>
NodeFSP.appendFile(
fastPath,
lines([
context("native-turn"),
tier(),
usage(5),
context("later-native-turn"),
usage(6),
tier("priority"),
]) + encodeUnknownJsonString(usage(7)),
),
);
verify(yield* resolved.readSummary(WINDOW), 32, 62);
yield* resolved.awaitPersisted;
const native = yield* UsageService.make;
verify(yield* native.readSummary(WINDOW), 32, 62);
yield* seedCodexHistory({
id: "after-restart-native",
sessionId: "fast-session",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
yield* Effect.promise(() =>
NodeFSP.appendFile(
fastPath,
"\n" +
lines([context("after-restart-native"), usage(8), tier("ultrafast"), usage(9)]),
),
);
verify(yield* native.readSummary(WINDOW), 49, 132);
yield* native.awaitPersisted;
yield* Effect.promise(async () => {
await NodeFSP.rm(fastPath);
await NodeFSP.rm(ultraPath);
});
yield* sql`DELETE FROM orchestration_events`;
const deleted = yield* UsageService.make;
verify(yield* deleted.readSummary(WINDOW), 49, 132);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-initial-tier",
home,
settings,
ratesDocument: {
"gpt-6-astra": {
input_cost_per_token: 0,
output_cost_per_token: 1,
input_cost_per_token_priority: 0,
output_cost_per_token_priority: 2,
input_cost_per_token_ultrafast: 0,
output_cost_per_token_ultrafast: 6,
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live(
"reads Pi per-model usage and auxiliary costs once across forks and repeated entries",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const dir = NodePath.join(home, "pi", "sessions", "project");
const usage = {
input: 10,
output: 5,
cacheRead: 20,
cacheWrite: 3,
reasoning: 2,
totalTokens: 38,
cost: { input: 0.1, output: 0.2, cacheRead: 0.3, cacheWrite: 0.4, total: 1 },
};
const parent = {
type: "message",
id: "a123abcd",
parentId: null,
timestamp: "2026-08-01T10:00:00Z",
message: {
role: "assistant",
provider: "anthropic",
model: "requested-model",
responseModel: "actual-model",
usage,
},
};
const auxiliary = [
{
type: "message",
id: "tool",
message: { role: "toolResult", toolName: "classify", usage },
},
{
type: "message",
id: "image",
message: {
role: "toolResult",
toolName: "image",
usage: { ...usage, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
},
{ type: "compaction", id: "compact", usage },
{ type: "branch_summary", id: "summary", usage },
].map((entry) => ({ ...entry, timestamp: "2026-08-01T11:00:00Z" }));
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "parent.jsonl"),
[
{ type: "session", id: "parent" },
parent,
...auxiliary,
{
type: "usage",
id: "warm",
timestamp: "2026-08-01T12:00:00Z",
kind: "cache_warm",
provider: "openai",
model: "actual-model",
usage: { ...usage, cost: { ...usage.cost, total: 0 } },
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
await NodeFSP.writeFile(
NodePath.join(dir, "fork.jsonl"),
[
{ type: "session", id: "fork", parentSession: NodePath.join(dir, "parent.jsonl") },
{ ...parent, parentId: "relinked" },
parent,
...auxiliary,
{
...parent,
timestamp: "2026-08-01T13:00:00Z",
message: { ...parent.message, provider: "openai", responseModel: "another-model" },
},
{ type: "get_session_stats", usage: { ...usage, cost: { total: 1000 } } },
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
const pi = first.buckets.filter((bucket) => bucket.provider === "pi");
assert.strictEqual(
pi.reduce((total, bucket) => total + bucket.costUsd, 0),
44,
);
assert.strictEqual(
pi.reduce((total, bucket) => total + totalTokens(bucket.totals), 0),
228,
);
assert.deepStrictEqual(pi.map((bucket) => bucket.model).sort(), [
"Tools/summaries",
"anthropic/actual-model",
"openai/actual-model",
"openai/another-model",
]);
const assistant = pi.find((bucket) => bucket.model === "anthropic/actual-model");
assert.deepStrictEqual(assistant?.totals, {
uncachedInputTokens: 10,
outputTokens: 5,
cachedInputTokens: 20,
cacheCreationTokens: 3,
reasoningTokens: 2,
});
assert.strictEqual(assistant?.costSource, "providerReported");
assert.approximately(assistant?.categoryCostUsd?.input ?? NaN, 10 / 38, 1e-6);
assert.approximately(assistant?.categoryCostUsd?.cacheRead ?? NaN, 2 / 38, 1e-6);
assert.approximately(assistant?.categoryCostUsd?.cacheWrite ?? NaN, 6 / 38, 1e-6);
assert.approximately(assistant?.categoryCostUsd?.output ?? NaN, 20 / 38, 1e-6);
assert.strictEqual(assistant?.cacheSavingsUsd, 18);
const warm = pi.find((bucket) => bucket.model === "openai/actual-model");
assert.strictEqual(warm?.costSource, "modelPriced");
assert.strictEqual(warm?.costUsd, 38);
assert.deepStrictEqual(warm?.categoryCostUsd, {
input: 10,
cacheRead: 2,
cacheWrite: 6,
output: 20,
});
assert.strictEqual(warm?.cacheSavingsUsd, 18);
assert.strictEqual(
first.sources.filter((source) => source.fingerprint.provider === "pi").length,
1,
);
yield* Effect.promise(() =>
NodeFSP.appendFile(
NodePath.join(dir, "fork.jsonl"),
encodeUnknownJsonString({
...parent,
id: "new",
timestamp: "2026-08-01T14:00:00Z",
message: { ...parent.message, responseModel: "latest-model" },
}) + "\n",
),
);
const grown = yield* service.readSummary(WINDOW);
assert.strictEqual(
grown.buckets
.filter((bucket) => bucket.provider === "pi")
.reduce((total, bucket) => total + bucket.costUsd, 0),
45,
);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, grown.buckets);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-pi-fork",
home,
ratesDocument: {
"actual-model": {
input_cost_per_token: 1,
output_cost_per_token: 4,
cache_read_input_token_cost: 0.1,
cache_creation_input_token_cost: 2,
},
},
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("pi-extra")]: {
driver: ProviderDriverKind.make("pi"),
enabled: false,
environment: [
{
name: "PI_CODING_AGENT_DIR",
value: NodePath.join(home, "pi"),
sensitive: false,
},
],
},
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live(
"reads Muse inference history once, persists appended usage, and reprices unknown models",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const museHome = NodePath.join(home, "configured-data", "muse");
const dir = NodePath.join(museHome, "sessions", "2026", "08", "01", "parent");
const child = NodePath.join(dir, "subagent", "child");
const entry = (
id: string,
sessionId = "parent",
timestamp = "2026-08-01T00:00:00Z",
model = "muse-unknown",
) => ({
schema_version: 1,
record_type: "event",
payload_type: "runtime.session",
payload_schema_version: 1,
id,
recorded_at: Date.parse(timestamp) * 1000 + 999,
stream: { kind: "session", id: sessionId },
payload: {
source_run_record_id: id,
event: {
kind: "model_completed",
model,
usage: {
input_tokens: 100,
cached_tokens: 60,
cache_read_tokens: 60,
cache_write_tokens: 10,
output_tokens: 20,
reasoning_tokens: 8,
},
},
},
});
const parent = entry("inference-1");
const review = {
...entry("review", "child"),
payload_schema_version: 3,
payload: {
event: {
...parent.payload.event,
kind: "automated_review_completed",
model: { model_id: "priced-model" },
usage: {
input_tokens: 100,
cached_input_tokens: 60,
output_tokens: 20,
reasoning_tokens: 8,
},
},
},
};
yield* Effect.promise(async () => {
await NodeFSP.mkdir(child, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "session.jsonl"),
[
parent,
parent,
{
...parent,
payload: { event: { ...parent.payload.event, kind: "workflow_completed" } },
},
{ ...parent, payload_type: "goal_usage_attribution" },
entry("before", "parent", "2026-07-31T23:59:59.999Z"),
entry("after", "parent", "2026-08-02T00:00:00Z"),
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n{broken}\n",
);
await NodeFSP.writeFile(
NodePath.join(child, "session.jsonl"),
[
{ ...parent, id: "copied-envelope", stream: { kind: "session", id: "child" } },
entry("child-inference", "child"),
review,
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
await NodeFSP.writeFile(
NodePath.join(child, "telemetry.jsonl"),
encodeUnknownJsonString(entry("not-a-session")) + "\n",
);
});
using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
Effect.succeed({
initializeResult: {
grantedCapabilities: [],
museHome: NodePath.join(options.environment?.XDG_DATA_HOME ?? home, "muse"),
},
close: async () => {},
} as unknown as MuseSdk.MuseSdkHost),
);
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const window = {
timeZone: "UTC",
sinceDay: UsageDay.make("2026-08-01"),
untilDay: UsageDay.make("2026-08-01"),
};
const muse = (summary: UsageSummary) =>
summary.buckets.filter((bucket) => bucket.provider === "muse");
const first = yield* service.readSummary(window);
const buckets = muse(first);
assert.strictEqual(
buckets.reduce((sum, b) => sum + b.records, 0),
3,
);
assert.strictEqual(
buckets.reduce((sum, b) => sum + totalTokens(b.totals), 0),
360,
);
const unknown = buckets.find((b) => b.model === "muse-unknown");
assert.strictEqual(unknown?.costSource, "unpriced");
assert.strictEqual(unknown?.unpricedRecords, 2);
assert.deepStrictEqual(unknown?.totals, {
uncachedInputTokens: 60,
cachedInputTokens: 120,
cacheCreationTokens: 20,
outputTokens: 40,
reasoningTokens: 16,
});
const priced = buckets.find((b) => b.model === "priced-model");
assert.strictEqual(priced?.costSource, "modelPriced");
assert.closeTo(priced?.costUsd ?? NaN, 0.000172, 1e-12);
assert.closeTo(priced?.cacheSavingsUsd ?? NaN, 0.000108, 1e-12);
const sources = first.sources.filter((source) => source.fingerprint.provider === "muse");
assert.strictEqual(sources.length, 1);
assert.strictEqual(sources[0]?.scannedFiles, 2);
assert.strictEqual(sources[0]?.distinctSessions, 2);
const local = muse(
yield* service.readSummary({ ...window, timeZone: "America/Los_Angeles" }),
);
assert.strictEqual(
local.reduce((sum, b) => sum + b.records, 0),
1,
);
assert.strictEqual(local[0]?.day, "2026-08-01");
const hourly = muse(
yield* service.readSummary({
...window,
resolution: "hour",
sinceTime: "2026-08-01T00:00:00.000Z",
untilTime: "2026-08-02T00:00:00.000Z",
}),
);
assert.strictEqual(
hourly.reduce((sum, b) => sum + b.records, 0),
3,
);
const appended = encodeUnknownJsonString(entry("appended", "child"));
const file = NodePath.join(child, "session.jsonl");
yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(0, -10)));
assert.deepStrictEqual(muse(yield* service.readSummary(window)), buckets);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(-10) + "\n"));
const grown = muse(yield* restarted.readSummary(window));
assert.strictEqual(
grown.reduce((sum, b) => sum + b.records, 0),
4,
);
assert.strictEqual(
grown.reduce((sum, b) => sum + totalTokens(b.totals), 0),
480,
);
const settingsService = yield* ServerSettings.ServerSettingsService;
yield* settingsService.updateSettings({
usagePriceOverrides: {
"muse-unknown": {
inputCostPerMillionTokens: 2,
outputCostPerMillionTokens: 4,
cacheReadCostPerMillionTokens: 0.2,
cacheWriteCostPerMillionTokens: 1,
},
},
});
const repriced = muse(yield* restarted.readSummary(window)).find(
(b) => b.model === "muse-unknown",
);
assert.strictEqual(repriced?.unpricedRecords, 0);
assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-muse",
home,
environment: { XDG_DATA_HOME: NodePath.dirname(museHome) },
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("muse")]: {
driver: ProviderDriverKind.make("muse"),
enabled: false,
},
[ProviderInstanceId.make("muse-alias")]: {
driver: ProviderDriverKind.make("muse"),
enabled: false,
},
},
},
ratesDocument: {
"priced-model": {
input_cost_per_token: 0.000002,
output_cost_per_token: 0.000004,
cache_read_input_token_cost: 0.0000002,
cache_creation_input_token_cost: 0.0000002,
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const missing = yield* service.readSummary(WINDOW);
assert.strictEqual(
missing.sources.find((source) => source.fingerprint.provider === "pi")?.status,
"missing",
);
const dir = NodePath.join(home, "pi", "sessions");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "session.jsonl"),
[
"{broken",
"null",
encodeUnknownJsonString({ type: "session", id: "valid" }),
encodeUnknownJsonString({
type: "message",
id: "bad",
timestamp: "invalid",
message: {
role: "assistant",
provider: "openai",
model: "model",
usage: { input: 100 },
},
}),
encodeUnknownJsonString({
type: "message",
id: "valid",
timestamp: "2026-08-01T10:00:00Z",
message: {
role: "assistant",
provider: "openai",
model: "model",
usage: {
input: -1,
cacheRead: "100",
output: 7,
reasoning: 50,
cost: { total: -1 },
},
},
}),
].join("\n") + "\n",
);
});
const summary = yield* service.readSummary(WINDOW);
const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
assert.strictEqual(pi.length, 1);
assert.strictEqual(pi[0] && totalTokens(pi[0].totals), 7);
assert.strictEqual(pi[0]?.totals.reasoningTokens, 7);
assert.strictEqual(pi[0]?.costSource, "unpriced");
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix: "usage-pi-malformed", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live("discovers Pi history in its default home and directory overrides", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
for (const [agentDir, sessionDir, relativeDir, launchArgs, instanceHome, platform] of [
[undefined, undefined, ".pi/agent/sessions", undefined],
["~/custom-pi", undefined, "custom-pi/sessions", undefined],
["~/ignored-pi", "~/custom-sessions", "custom-sessions", undefined],
["~/ignored-pi", NodePath.join(home, "absolute-sessions"), "absolute-sessions", undefined],
["~/ignored-pi", undefined, "launch-sessions", "--session-dir ~/launch-sessions"],
[
"~/ignored-pi",
undefined,
"instance-home /launch-sessions",
"--session-dir ~/launch-sessions",
"instance-home ",
],
[
"~/ignored-pi",
undefined,
"windows-profile/launch-sessions",
"--session-dir ~/launch-sessions",
"windows-profile",
"win32",
],
] as const) {
const dir = NodePath.join(home, relativeDir);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "session.jsonl"),
[
{ type: "session", id: relativeDir },
{
type: "usage",
id: "warm",
timestamp: "2026-08-01T10:00:00Z",
provider: "openai",
model: "model",
usage: { input: 7 },
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const summary = yield* service.readSummary(WINDOW);
const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
assert.strictEqual(pi.length, 1);
assert.strictEqual(pi[0]?.totals.uncachedInputTokens, 7);
assert.strictEqual(
summary.sources.find((source) => source.fingerprint.provider === "pi")?.fingerprint
.resolvedHomePath,
dir,
);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-pi-" + relativeDir.replaceAll("/", "-"),
home,
settings:
launchArgs === undefined
? settings
: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("pi")]: {
driver: ProviderDriverKind.make("pi"),
config: { launchArgs },
environment:
instanceHome === undefined
? []
: [
{
name: platform === "win32" ? "USERPROFILE" : "HOME",
value: NodePath.join(home, instanceHome),
sensitive: false,
},
],
},
},
},
environment: {
PI_CODING_AGENT_DIR: agentDir,
PI_CODING_AGENT_SESSION_DIR: sessionDir,
},
platform: platform ?? "linux",
}),
),
Effect.provideService(HostProcess.HomeDirectory, home),
);
}
}).pipe(Effect.scoped),
);
it.live("reads shared managed default and disabled extra account history once", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const summary = yield* Effect.gen(function* () {
for (const [id, output] of [
["codex", 17],
["codex-personal", 23],
] as const) {
const sessions = NodePath.join(home, "shared-codex", "sessions");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(sessions, `${id}-rollout.jsonl`),
[
{ type: "session_meta", payload: { id } },
{ type: "turn_context", payload: { model: "gpt-5.6-sol" } },
{
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 10, output_tokens: output } },
},
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
});
}
const service = yield* UsageService.make;
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-managed-accounts",
home,
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("codex")]: {
driver: ProviderDriverKind.make("codex"),
config: {
setupMode: "managed",
homePath: NodePath.join(home, "shared-codex"),
},
},
[ProviderInstanceId.make("codex-personal")]: {
driver: ProviderDriverKind.make("codex"),
enabled: false,
config: {
setupMode: "managed",
homePath: NodePath.join(home, "shared-codex"),
shadowHomePath: NodePath.join(home, "personal-shadow"),
},
environment: [
{
name: "CODEX_HOME",
value: NodePath.join(home, "ignored-environment"),
sensitive: false,
},
],
},
},
},
}),
),
);
assert.strictEqual(totalOutputTokens(summary), 40);
assert.strictEqual(
summary.sources.filter(
(source) => source.fingerprint.provider === "codex" && source.status === "ok",
).length,
1,
);
}).pipe(Effect.scoped),
);
it.live("keeps Cursor credential errors visible when a saved login cannot be read", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const authPath = NodePath.join(home, "config", "cursor", "auth.json");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
await NodeFSP.writeFile(authPath, "invalid json");
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({ prefix: "usage-service-cursor-invalid-login", home, settings }),
),
);
const summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
assert.strictEqual(cursor?.message, "Cursor credentials could not be read.");
}).pipe(Effect.scoped),
);
it.live("restores the Cursor account cache after a restart", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
yield* writeCursorLogin(home);
yield* TestClock.setTime(CURSOR_NOW);
const before = makeFakeCursor();
before.state.events = [
{ timestampMs: CURSOR_NOW - 30 * HOUR_MS, outputTokens: 5 },
{ timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 },
];
yield* Effect.gen(function* () {
const first = yield* makeWithCursor(before.read);
const original = yield* first.readSummary({ ...WINDOW, awaitRefresh: true });
yield* first.awaitPersisted;
const after = makeFakeCursor();
after.state.events = before.state.events;
const restarted = yield* makeWithCursor(after.read);
const restored = yield* restarted.readSummary(WINDOW);
assert.isUndefined(cursorSource(restored)?.refreshing);
assert.deepStrictEqual(restored.buckets, original.buckets);
assert.deepStrictEqual(cursorSource(restored), cursorSource(original));
assert.strictEqual(after.state.calls.length, 0);
yield* TestClock.adjust(Duration.minutes(2));
const refreshed = yield* restarted.readSummary({ ...WINDOW, awaitRefresh: true });
assert.deepStrictEqual(refreshed.buckets, original.buckets);
assert.deepStrictEqual(after.state.calls, [
{ sinceMs: CURSOR_NOW - HOUR_MS, untilMs: CURSOR_NOW + 2 * 60 * 1000 },
]);
}).pipe(
Effect.provide(layerService({ prefix: "usage-service-cursor-restart", home, settings })),
);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.live("does not read the macOS Cursor Keychain before account usage is enabled", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-keychain-disabled",
home,
settings,
platform: "darwin",
environment: {},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
assert.strictEqual(cursor?.status, "missing");
assert.strictEqual(cursor?.action, "enableCursorKeychain");
}).pipe(Effect.scoped),
);
it.effect("ignores a stale macOS Keychain login when Cursor is not installed", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const cursor = makeFakeCursor();
cursor.state.error = "Sign in to Cursor again to read account usage.";
const readCursorSource = Effect.gen(function* () {
const service = yield* makeWithCursor(cursor.read);
const summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
return cursorSource(summary);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-keychain-uninstalled",
home,
settings: { ...settings, cursorKeychainUsageEnabled: true },
platform: "darwin",
environment: {},
}),
),
);
assert.isUndefined(yield* readCursorSource);
assert.lengthOf(cursor.state.calls, 0);
yield* Effect.promise(() => NodeFSP.mkdir(NodePath.join(home, ".cursor")));
const installed = yield* readCursorSource;
assert.strictEqual(installed?.message, "Sign in to Cursor again to read account usage.");
assert.lengthOf(cursor.state.calls, 1);
}).pipe(Effect.scoped),
);
it.live("ignores stale Cursor file logins when the active credential store differs", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
for (const [index, testCase] of [
{
platform: "darwin" as const,
environment: { AGENT_CLI_CREDENTIAL_STORE: "memory" },
authPath: [".cursor", "auth.json"],
},
{
platform: "linux" as const,
environment: { AGENT_CLI_CREDENTIAL_STORE: "memory" },
authPath: ["config", "cursor", "auth.json"],
},
].entries()) {
const authPath = NodePath.join(home, ...testCase.authPath);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
await NodeFSP.writeFile(
authPath,
encodeUnknownJsonString({ accessToken: "stale-token" }),
);
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: `usage-service-cursor-store-${index}`,
home,
settings,
platform: testCase.platform,
environment: testCase.environment,
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
assert.strictEqual(cursor?.status, "missing");
assert.include(cursor?.message ?? "", "Cursor CLI login");
assert.isFalse(summary.buckets.some((bucket) => bucket.provider === "cursor"));
}
}).pipe(Effect.scoped),
);
it.live("reads the Cursor account of an API key or T3 sign-in instead of a CLI login", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const signIn = new TextEncoder().encode(
encodeUnknownJsonString({
version: 1,
backendUrl: "https://api2.cursor.sh",
apiKey: "signed-in-key",
createdAtMs: 0,
}),
);
for (const [index, testCase] of [
{ environment: { CURSOR_API_KEY: "environment-key" }, stored: Option.none() },
{ environment: {}, stored: Option.some(signIn) },
].entries()) {
const cursor = makeFakeCursor();
const summary = yield* Effect.gen(function* () {
const service = yield* makeWithCursor(cursor.read);
return yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
}).pipe(
Effect.provide(
layerService({
prefix: `usage-service-cursor-api-key-${index}`,
home,
settings,
platform: "darwin",
environment: testCase.environment,
secretStore: { get: () => Effect.succeed(testCase.stored) },
}),
),
);
assert.deepStrictEqual(cursor.state.credentials, [
{ kind: "apiKey", apiKey: index === 0 ? "environment-key" : "signed-in-key" },
]);
assert.strictEqual(cursorSource(summary)?.status, "ok");
}
}).pipe(Effect.scoped),
);
it.live("does not show a previous Cursor account's history after the API key changes", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
yield* TestClock.setTime(CURSOR_NOW);
let apiKey = "first-account-key";
const signIn = () =>
Option.some(
new TextEncoder().encode(