refactor(usage): Cursor account usage comes from provider-cursor

apps/server/src/provider/ProviderOrchestrationAdapterInfrastructure.ts

@@ -4,6 +4,7 @@ import * as ClaudeAdapterV2 from "../orchestration-v2/Adapters/ClaudeAdapterV2.t
 import * as CodexAdapterV2 from "../orchestration-v2/Adapters/CodexAdapterV2.ts";
 import * as CursorAgentSdk from "@t3tools/provider-cursor/server/CursorAgentSdk";
 import * as CursorSdk from "@t3tools/provider-cursor/server/CursorSdk";
+import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
 import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
 
@@ -12,6 +13,7 @@ export type ProviderOrchestrationAdapterInfrastructure =
   | CodexAdapterV2.CodexAppServerClientFactory
   | CursorAgentSdk.CursorAgentSdkRunner
   | CursorSdk.CursorSdk
+  | CursorKeychain.CursorKeychain
   | IdAllocator.IdAllocatorV2;
 
 /**
@@ -24,6 +26,7 @@ export const layer = Layer.mergeAll(
   ClaudeAdapterV2.layerQueryRunner,
   CodexAdapterV2.layerAppServerClientFactory,
   CursorAgentSdk.layer.pipe(Layer.provideMerge(CursorSdk.layer)),
+  CursorKeychain.layer,
   IdAllocator.layer,
   ProviderContinuationRequests.layer,
 );

apps/server/src/provider/builtInDrivers.ts

@@ -75,7 +75,8 @@ export type BuiltInUsageReadersEnv =
   | ProviderUsageReaderEnv<typeof ClaudeDriver>
   | ProviderUsageReaderEnv<typeof CodexDriver>
   | ProviderUsageReaderEnv<typeof GrokDriver>
-  | ProviderUsageReaderEnv<typeof OpenCodeDriver>;
+  | ProviderUsageReaderEnv<typeof OpenCodeDriver>
+  | ProviderUsageReaderEnv<typeof CursorDriver>;
 
 /**
  * The drivers that keep usage history, in the order the usage page reads
@@ -84,4 +85,4 @@ export type BuiltInUsageReadersEnv =
  */
 export const BUILT_IN_USAGE_DRIVERS: ReadonlyArray<
   AnyProviderDriver<BuiltInDriversEnv, BuiltInUsageReadersEnv>
-> = [ClaudeDriver, CodexDriver, GrokDriver, OpenCodeDriver];
+> = [ClaudeDriver, CodexDriver, GrokDriver, OpenCodeDriver, CursorDriver];

apps/server/src/server.ts

@@ -157,7 +157,9 @@ import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClien
 import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts";
 import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinary.ts";
 import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
-import * as CursorUsageReader from "./usage/cursorUsageReader.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 UsageService from "./usage/UsageService.ts";
 import * as RuntimeLayer from "./orchestration-v2/runtimeLayer.ts";
 import * as ProjectStore from "./orchestration-v2/ProjectStore.ts";
@@ -255,8 +257,13 @@ const layerBackground = BackgroundPolicy.layer.pipe(
 );
 
 const layerUsage = UsageService.layer.pipe(
+  Layer.provide(
+    CursorUsageAccounts.layer.pipe(
+      Layer.provide(CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer))),
+      Layer.provide(ProviderHostLive.layer.pipe(Layer.provide(ServerSecretStore.layer))),
+    ),
+  ),
   Layer.provide(layerServerSettings),
-  Layer.provide(CursorUsageReader.layer),
 );
 
 const layerResourceDiagnostics = Layer.mergeAll(
@@ -677,9 +684,11 @@ const layerRuntimeCoreDependencies = layerRuntimeCoreDependenciesBase.pipe(
 
 const layerRuntimeDependencies = layerRuntimeCoreDependencies.pipe(
   // Misc.
+  // Usage reads provider history through the ProviderHost, which needs the
+  // background policy below it.
+  Layer.provideMerge(layerUsage),
   Layer.provideMerge(layerBackground),
   Layer.provideMerge(layerResourceDiagnostics),
-  Layer.provideMerge(layerUsage),
   Layer.provideMerge(TraceDiagnostics.layer),
   Layer.provideMerge(AnalyticsService.layer),
   Layer.provideMerge(ExternalLauncher.layer),

apps/server/src/usage/UsageService.test.ts

@@ -24,6 +24,7 @@ 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 Scheduler from "effect/Scheduler";
 import * as Schema from "effect/Schema";
@@ -32,7 +33,12 @@ import { HttpClient, HttpClientResponse } from "effect/http";
 
 import * as ServerConfig from "../config.ts";
 import * as ServerSettings from "../serverSettings.ts";
-import * as CursorUsageReader from "./cursorUsageReader.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 ProviderHostLive from "../provider/ProviderHostLive.ts";
 import type { UsageRecord } from "@t3tools/provider-core/server/usage";
 import * as UsageService from "./UsageService.ts";
 
@@ -87,6 +93,27 @@ const setup = Effect.gen(function* () {
   };
 });
 
+const layerCursorUsageAccounts = <E, R>(
+  reader: Layer.Layer<CursorAccountReader.CursorAccountReader, E, R>,
+) => Layer.fresh(CursorUsageAccounts.layer).pipe(Layer.provide(reader));
+
+/**
+ * A service with its own Cursor account caches over `read`, as a fresh server
+ * process has. `awaitPersisted` also waits for the account cache writes.
+ */
+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;
@@ -97,9 +124,14 @@ const layerService = (input: {
   readonly environment?: NodeJS.ProcessEnv;
   readonly platform?: NodeJS.Platform;
 }) =>
-  ServerConfig.layerTest(process.cwd(), { prefix: input.prefix }).pipe(
+  layerCursorUsageAccounts(
+    CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer)),
+  ).pipe(
+    Layer.provideMerge(ProviderHostLive.layer),
+    Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
+    Layer.provideMerge(Layer.mock(ServerSecretStore.ServerSecretStore)({})),
+    Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: input.prefix })),
     Layer.provideMerge(NodeServices.layer),
-    Layer.provideMerge(CursorUsageReader.layer),
     Layer.provideMerge(Layer.succeed(HostProcessPlatform, input.platform ?? "linux")),
     Layer.provideMerge(ServerSettings.layerTest(input.settings)),
     Layer.provideMerge(
@@ -364,9 +396,7 @@ describe("UsageService", () => {
       const gate = yield* Deferred.make<void>();
       cursor.state.gate = gate;
       yield* Effect.gen(function* () {
-        const service = yield* UsageService.make.pipe(
-          Effect.provideService(CursorUsageReader.CursorAccountReader, { read: cursor.read }),
-        );
+        const service = yield* makeWithCursor(cursor.read);
         // Cold: nothing cached yet, so Cursor answers empty while it refreshes.
         const cold = yield* service.readSummary(WINDOW);
         assert.strictEqual(cursorSource(cold)?.refreshing, true);
@@ -421,9 +451,7 @@ describe("UsageService", () => {
         { timestampMs: CURSOR_NOW - HOUR_MS / 2, outputTokens: 7 },
       ];
       yield* Effect.gen(function* () {
-        const service = yield* UsageService.make.pipe(
-          Effect.provideService(CursorUsageReader.CursorAccountReader, { read: cursor.read }),
-        );
+        const service = yield* makeWithCursor(cursor.read);
         const read = (input: UsageSummaryInput) =>
           service.readSummary({ ...input, awaitRefresh: true });
         assert.strictEqual(totalOutputTokens(yield* read(WINDOW)), 19);
@@ -470,9 +498,7 @@ describe("UsageService", () => {
       const cursor = makeFakeCursor();
       cursor.state.events = [{ timestampMs: CURSOR_NOW - HOUR_MS * 3, outputTokens: 5 }];
       yield* Effect.gen(function* () {
-        const service = yield* UsageService.make.pipe(
-          Effect.provideService(CursorUsageReader.CursorAccountReader, { read: cursor.read }),
-        );
+        const service = yield* makeWithCursor(cursor.read);
         yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
 
         yield* TestClock.adjust(Duration.minutes(2));
@@ -513,17 +539,13 @@ describe("UsageService", () => {
         { timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 },
       ];
       yield* Effect.gen(function* () {
-        const first = yield* UsageService.make.pipe(
-          Effect.provideService(CursorUsageReader.CursorAccountReader, { read: before.read }),
-        );
+        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* UsageService.make.pipe(
-          Effect.provideService(CursorUsageReader.CursorAccountReader, { read: after.read }),
-        );
+        const restarted = yield* makeWithCursor(after.read);
         const restored = yield* restarted.readSummary(WINDOW);
         assert.isUndefined(cursorSource(restored)?.refreshing);
         assert.deepStrictEqual(restored.buckets, original.buckets);