From fc6ba9a94969184b3c7859e9ed38fff573a82402 Mon Sep 17 00:00:00 2001 From: Yordis Prieto Date: Thu, 19 Nov 2026 23:46:44 -0500 Subject: [PATCH 1/3] fix(server): surface unreadable provider environment secrets Usage polling, the session scanner and installation removal built a provider environment from literal variables only, so a secret-backed variable whose read failed was dropped without a trace and the work ran against the host default instead. Read those secrets through a shared helper, which the terminal launch now uses too. The usage and scanner paths skip the instance with a warning naming the variable and its reference, and removal fails rather than leave another instance's binary unprotected. Secret values are never reported. Signed-off-by: Yordis Prieto --- .../src/project/AgentSessionImporter.test.ts | 2 + .../src/project/AgentSessionScanner.test.ts | 83 +++++++++++++++++++ .../server/src/project/AgentSessionScanner.ts | 24 +++++- .../src/provider/providerInstallation.test.ts | 45 ++++++++++ .../src/provider/providerInstallation.ts | 24 ++++-- .../src/secrets/SecretResolver.testkit.ts | 19 +++++ .../src/secrets/providerEnvironmentSecrets.ts | 68 +++++++++++++++ apps/server/src/server.ts | 1 + apps/server/src/terminal/Manager.ts | 35 ++------ apps/server/src/usage/UsageService.test.ts | 69 +++++++++++++++ apps/server/src/usage/UsageService.ts | 32 +++++-- 11 files changed, 359 insertions(+), 43 deletions(-) create mode 100644 apps/server/src/secrets/SecretResolver.testkit.ts create mode 100644 apps/server/src/secrets/providerEnvironmentSecrets.ts diff --git a/apps/server/src/project/AgentSessionImporter.test.ts b/apps/server/src/project/AgentSessionImporter.test.ts index 18c0946144d4a..ac1629648e30c 100644 --- a/apps/server/src/project/AgentSessionImporter.test.ts +++ b/apps/server/src/project/AgentSessionImporter.test.ts @@ -45,6 +45,7 @@ import { } from "../orchestration-v2/testkit/fixtures/shared.ts"; import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.ts"; import * as SqlitePersistence from "../persistence/Sqlite.ts"; +import * as SecretResolverTestkit from "../secrets/SecretResolver.testkit.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as AgentSessionImporter from "./AgentSessionImporter.ts"; import * as AgentSessionScanner from "./AgentSessionScanner.ts"; @@ -1027,6 +1028,7 @@ it.effect("repeated imports reach linked-worktree sessions behind the scan budge }, }, }), + SecretResolverTestkit.layerTest(), Layer.mock(ProjectStore.ProjectStoreV2)({ listShells: () => Effect.succeed([]) }), Layer.succeed( ProviderSessionRuntime.ProviderSessionRuntimeRepository, diff --git a/apps/server/src/project/AgentSessionScanner.test.ts b/apps/server/src/project/AgentSessionScanner.test.ts index 9c62ddb1a2b84..f6b45b56c80ef 100644 --- a/apps/server/src/project/AgentSessionScanner.test.ts +++ b/apps/server/src/project/AgentSessionScanner.test.ts @@ -13,6 +13,7 @@ import { ProjectId, ProviderDriverKind, ProviderInstanceId, + SecretProviderId, type ServerSettings as ContractServerSettings, ThreadId, } from "@t3tools/contracts"; @@ -34,6 +35,7 @@ import * as ServerConfig from "../config.ts"; import * as ProcessRunner from "../processRunner.ts"; import * as ProjectStore from "../orchestration-v2/ProjectStore.ts"; import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.ts"; +import * as SecretResolverTestkit from "../secrets/SecretResolver.testkit.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as AgentSessionScanner from "./AgentSessionScanner.ts"; @@ -67,6 +69,7 @@ interface ScannerTestInput { readonly sources: ReadonlyArray; }; readonly processRunner?: Layer.Layer; + readonly readSecrets?: Parameters[0]; } const layerRuntimeRepository = (imported: ScannerTestInput["importedTranscripts"]) => @@ -131,6 +134,7 @@ const layerScannerTest = (input: ScannerTestInput) => ), layerProjectStore(input.importedWorkspaceRoots ?? []), layerRuntimeRepository(input.importedTranscripts), + SecretResolverTestkit.layerTest(input.readSecrets), ), ), ); @@ -817,6 +821,85 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { }), ); + describe("secret-backed history directory", () => { + const secretHome = { provider: SecretProviderId.make("vault"), reference: "kv/codex#home" }; + const unrelated = { provider: SecretProviderId.make("vault"), reference: "kv/codex#key" }; + const scanCodexSecretHome = ( + readSecrets: (home: string) => Parameters[0], + extraEnvironment: ReadonlyArray<{ name: string; value: typeof unrelated; sensitive: true }>, + ) => + Effect.gen(function* () { + const path = yield* Path.Path; + const claudeHomePath = yield* makeTempDir("t3code-claude-legacy-"); + const codexHomePath = yield* makeTempDir("t3code-codex-legacy-"); + const secretCodexHome = yield* makeTempDir("t3code-codex-secret-"); + const codexWorkspace = yield* makeTempDir("t3code-workspace-codex-secret-"); + yield* writeTranscript({ + filePath: path.join( + secretCodexHome, + "sessions", + "2026", + "01", + "01", + "rollout-session.jsonl", + ), + contents: codexRolloutLine(codexWorkspace), + mtimeMs: Date.parse("2026-01-02T00:00:00.000Z"), + }); + const result = yield* runScan({ + claudeHomePath, + codexHomePath, + readSecrets: readSecrets(secretCodexHome), + providerInstances: { + [ProviderInstanceId.make("codex")]: { + driver: ProviderDriverKind.make("codex"), + environment: [ + { name: "CODEX_HOME", value: secretHome, sensitive: true }, + ...extraEnvironment, + ], + config: {}, + }, + }, + }); + return { result, codexWorkspace }; + }); + + it.effect("scans the directory a secret names", () => + Effect.gen(function* () { + const { result, codexWorkspace } = yield* scanCodexSecretHome( + (home) => (references) => references.map(() => home), + [], + ); + expect(result.candidates.map((candidate) => candidate.path)).toEqual([codexWorkspace]); + }), + ); + + it.effect( + "skips the instance instead of scanning the default home when it is unreadable", + () => + Effect.gen(function* () { + const { result } = yield* scanCodexSecretHome( + () => (references) => references.map(() => undefined), + [], + ); + expect(result.candidates).toEqual([]); + }), + ); + + it.effect("does not skip an instance over a secret unrelated to its history directory", () => + Effect.gen(function* () { + const { result, codexWorkspace } = yield* scanCodexSecretHome( + (home) => (references) => + references.map((reference) => + reference.reference === secretHome.reference ? home : undefined, + ), + [{ name: "OPENAI_API_KEY", value: unrelated, sensitive: true }], + ); + expect(result.candidates.map((candidate) => candidate.path)).toEqual([codexWorkspace]); + }), + ); + }); + it.effect("honors provider instance home directory environment variables", () => Effect.gen(function* () { const path = yield* Path.Path; diff --git a/apps/server/src/project/AgentSessionScanner.ts b/apps/server/src/project/AgentSessionScanner.ts index 1e300d1fe0410..3c16ceabd0557 100644 --- a/apps/server/src/project/AgentSessionScanner.ts +++ b/apps/server/src/project/AgentSessionScanner.ts @@ -39,6 +39,11 @@ import * as ProcessRunner from "../processRunner.ts"; import * as ProjectStore from "../orchestration-v2/ProjectStore.ts"; import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.ts"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; +import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import { + PROVIDER_HOME_ENVIRONMENT_NAMES, + resolveProviderEnvironmentSecrets, +} from "../secrets/providerEnvironmentSecrets.ts"; import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; import { piHome, resolvePiSessionsDir } from "@t3tools/provider-pi/server/usage"; @@ -852,6 +857,7 @@ export const make = Effect.gen(function* () { const platform = yield* HostProcess.Platform; const isWindows = platform === "win32"; const foldWorktreeCase = isWindows; + const secrets = yield* SecretResolver.SecretResolver; const hostEnvironment = yield* HostProcess.Environment; const homeDir = yield* HostProcess.HomeDirectory; // `/private/tmp` is what macOS reports for sessions started in `/tmp`. @@ -1757,8 +1763,22 @@ export const make = Effect.gen(function* () { const homes: Array<{ homePath: string; providerInstanceId: ProviderInstanceId }> = []; const seenHomes = new Set(); for (const { instanceId, config: instance } of instances) { + const providerSecrets = yield* resolveProviderEnvironmentSecrets( + secrets, + instance.environment, + PROVIDER_HOME_ENVIRONMENT_NAMES, + ); + // A history directory held in an unreadable secret would fall back to the host default, + // so the scan would show or import another account's sessions as this instance's. + if (providerSecrets.unreadable.length > 0) { + yield* Effect.logWarning( + "skipping a provider instance whose history directory secret could not be read", + { instanceId, unreadable: providerSecrets.unreadable }, + ); + continue; + } const environmentHome = (name: "CLAUDE_CONFIG_DIR" | "CODEX_HOME") => { - const configured = instance.environment?.findLast( + const configured = providerSecrets.environment.findLast( (variable) => variable.name === name, )?.value; return typeof configured === "string" ? configured : hostEnvironment[name]; @@ -1767,7 +1787,7 @@ export const make = Effect.gen(function* () { let homePath: string; if (source === "pi") { const environment = yield* mergeProviderInstanceEnvironment( - instance.environment, + providerSecrets.environment, hostEnvironment, ).pipe(Effect.provideService(HostProcess.HomeDirectory, homeDir)); homePath = resolvePiSessionsDir( diff --git a/apps/server/src/provider/providerInstallation.test.ts b/apps/server/src/provider/providerInstallation.test.ts index d4c7467c62d0d..a7f45a9deb530 100644 --- a/apps/server/src/provider/providerInstallation.test.ts +++ b/apps/server/src/provider/providerInstallation.test.ts @@ -3,6 +3,7 @@ import { assert, describe, it } from "@effect/vitest"; import { ProviderDriverKind, ProviderInstanceId, + SecretProviderId, type ProviderInstallState, } from "@t3tools/contracts"; import * as HostProcess from "@t3tools/shared/HostProcess"; @@ -14,6 +15,7 @@ import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; import * as Stream from "effect/Stream"; +import * as SecretResolverTestkit from "../secrets/SecretResolver.testkit.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as CodexInstallation from "./CodexInstallation.ts"; import * as AntigravityInstallation from "./AntigravityInstallation.ts"; @@ -60,6 +62,7 @@ const makeHarness = Effect.fn("providerInstallation.test.makeHarness")(function* input: { instance?: ProviderInstance; settings?: Parameters[0]; + readSecrets?: Parameters[0]; } = {}, ) { const calls: string[] = []; @@ -71,6 +74,7 @@ const makeHarness = Effect.fn("providerInstallation.test.makeHarness")(function* const configured = input.instance ?? instance(); const dependencies = Layer.mergeAll( ServerSettings.layerTest(input.settings), + SecretResolverTestkit.layerTest(input.readSecrets), Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({ getInstance: (id) => Effect.succeed(id === configured.instanceId ? configured : undefined), listInstances: Effect.succeed([configured]), @@ -226,6 +230,47 @@ describe("provider installation routing", () => { }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), ); + describe("secret-backed PATH", () => { + const pathSecret = { provider: SecretProviderId.make("vault"), reference: "kv/path#dirs" }; + const withSecretPath = (readSecrets: Parameters[0]) => + makeHarness({ + readSecrets, + settings: { + providerInstances: { + [ProviderInstanceId.make("antigravity-work")]: { + driver, + config: { binaryPath: "agy-test" }, + environment: [{ name: "PATH", value: pathSecret, sensitive: true }], + }, + }, + }, + }); + + it.effect("protects a binary found through a PATH read from a secret", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const platform = yield* HostProcess.Platform; + const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-provider-secret-path-" }); + const executable = path.join(directory, platform === "win32" ? "agy-test.exe" : "agy-test"); + yield* fs.writeFileString(executable, "test"); + yield* fs.chmod(executable, 0o755); + const harness = yield* withSecretPath(() => [directory]); + yield* harness.router.remove({ instanceId }); + assert.include(harness.protectedPaths(), executable); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); + + it.effect("fails the removal naming the variable and reference when it cannot be read", () => + Effect.gen(function* () { + const harness = yield* withSecretPath(() => [undefined]); + const failed = yield* Effect.flip(harness.router.remove({ instanceId })); + assert.include(failed.detail, "PATH (vault:kv/path#dirs)"); + assert.deepEqual(harness.calls, []); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); + }); + it.effect("protects another instance's binary found through its own PATH", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; diff --git a/apps/server/src/provider/providerInstallation.ts b/apps/server/src/provider/providerInstallation.ts index 2e4efc720177f..4fb99984ae3fb 100644 --- a/apps/server/src/provider/providerInstallation.ts +++ b/apps/server/src/provider/providerInstallation.ts @@ -20,14 +20,13 @@ import * as Stream from "effect/Stream"; import * as CodexInstallation from "./CodexInstallation.ts"; import * as ServerSettings from "../serverSettings.ts"; +import * as SecretResolverCore from "@t3tools/secret-provider-core/server/SecretResolver"; +import { resolveProviderEnvironmentSecrets } from "../secrets/providerEnvironmentSecrets.ts"; import * as AntigravityInstallation from "./AntigravityInstallation.ts"; import { deriveProviderInstanceConfigMap } from "./ProviderInstanceRegistryHydration.ts"; import * as ProviderInstanceRegistry from "./ProviderInstanceRegistry.ts"; import * as ProviderRegistry from "./ProviderRegistry.ts"; -import { - literalProviderInstanceEnvironment, - mergeProviderInstanceEnvironment, -} from "@t3tools/provider-core/server/instanceEnvironment"; +import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; const ANTIGRAVITY = ProviderDriverKind.make("antigravity"); const hasBinaryPath = Schema.is(Schema.Struct({ binaryPath: Schema.String })); @@ -58,6 +57,7 @@ const make = Effect.fn("makeProviderInstallation")(function* () { const instances = yield* ProviderInstanceRegistry.ProviderInstanceRegistry; const providers = yield* ProviderRegistry.ProviderRegistry; const settings = yield* ServerSettings.ServerSettingsService; + const secrets = yield* SecretResolverCore.SecretResolver; const fileSystem = yield* FileSystem.FileSystem; const path = yield* Path.Path; const scope = yield* Effect.scope; @@ -222,10 +222,20 @@ const make = Effect.fn("makeProviderInstallation")(function* () { return []; } const binaryPath = entry.config.binaryPath.trim(); + // A PATH that cannot be read would resolve the binary against the server's own PATH, + // and removal would then leave a path another instance still runs unprotected. + const pathSecrets = yield* resolveProviderEnvironmentSecrets(secrets, entry.environment, [ + "PATH", + ]); + if (pathSecrets.unreadable.length > 0) { + return yield* new ProviderSetupError({ + instanceId: input.instanceId, + operation: "remove-install", + detail: `Could not read ${pathSecrets.unreadable.join(", ")} from its secret provider. Unlock it, then try again.`, + }); + } const resolved = yield* resolveCommandPath(binaryPath, { - env: yield* mergeProviderInstanceEnvironment( - literalProviderInstanceEnvironment(entry.environment), - ), + env: yield* mergeProviderInstanceEnvironment(pathSecrets.environment), }).pipe( Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path), diff --git a/apps/server/src/secrets/SecretResolver.testkit.ts b/apps/server/src/secrets/SecretResolver.testkit.ts new file mode 100644 index 0000000000000..a2686376ee89a --- /dev/null +++ b/apps/server/src/secrets/SecretResolver.testkit.ts @@ -0,0 +1,19 @@ +import type { SecretReference } from "@t3tools/contracts"; +import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +/** A resolver answering every read with `read`; by default no secret is readable. */ +export const layerTest = ( + read: (references: ReadonlyArray) => ReadonlyArray = ( + references, + ) => references.map(() => undefined), +) => + Layer.succeed( + SecretResolver.SecretResolver, + SecretResolver.SecretResolver.of({ + read: (references) => Effect.succeed(read(references)), + invalidate: () => Effect.void, + label: (provider) => Effect.succeed(provider), + }), + ); diff --git a/apps/server/src/secrets/providerEnvironmentSecrets.ts b/apps/server/src/secrets/providerEnvironmentSecrets.ts new file mode 100644 index 0000000000000..dac652b103bc8 --- /dev/null +++ b/apps/server/src/secrets/providerEnvironmentSecrets.ts @@ -0,0 +1,68 @@ +import type { ProviderInstanceEnvironment } from "@t3tools/contracts"; +import { literalProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; +import type * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import * as Effect from "effect/Effect"; + +/** + * Variables that place a provider's session history on disk. Readers that only look for a + * transcript directory need these resolved, and nothing else. + */ +export const PROVIDER_HOME_ENVIRONMENT_NAMES: ReadonlyArray = [ + "CLAUDE_CONFIG_DIR", + "CODEX_HOME", + "ANTIGRAVITY_DATA_DIR", + "PI_CODING_AGENT_DIR", + "PI_CODING_AGENT_SESSION_DIR", +]; + +export interface ProviderEnvironmentSecrets { + /** Literal variables plus every secret that was read, ready to overlay on a process environment. */ + readonly environment: ReadonlyArray<{ + readonly name: string; + readonly value: string; + readonly sensitive?: boolean | undefined; + }>; + /** `NAME (provider:reference)` for each secret that could not be read or read empty. */ + readonly unreadable: ReadonlyArray; +} + +/** + * Reads the secret-backed variables of a provider instance, so a caller never launches or probes + * with a credential silently missing. `only` limits the read to the named variables, for callers + * that need a few of them and should not fail on an unrelated secret. Values are never part of + * `unreadable`. + */ +export const resolveProviderEnvironmentSecrets = Effect.fn("ProviderEnvironmentSecrets.resolve")( + function* ( + secrets: SecretResolver.SecretResolver["Service"] | undefined, + environment: ProviderInstanceEnvironment | undefined, + only?: ReadonlyArray, + ) { + const secretVariables = (environment ?? []).flatMap((variable) => + typeof variable.value === "string" || (only !== undefined && !only.includes(variable.name)) + ? [] + : [{ name: variable.name, reference: variable.value }], + ); + const values = + secretVariables.length === 0 + ? [] + : secrets === undefined + ? secretVariables.map(() => undefined) + : yield* secrets.read(secretVariables.map(({ reference }) => reference)); + const unreadable = secretVariables.filter((_, index) => (values[index] ?? "").trim() === ""); + return { + environment: [ + ...literalProviderInstanceEnvironment(environment), + ...secretVariables.flatMap(({ name }, index) => { + const value = values[index]; + return value === undefined || value.trim() === "" + ? [] + : [{ name, value, sensitive: true }]; + }), + ], + unreadable: unreadable.map( + ({ name, reference }) => `${name} (${reference.provider}:${reference.reference})`, + ), + } satisfies ProviderEnvironmentSecrets; + }, +); diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index 7d444dcc6b54a..6a61e0ef24a5b 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -317,6 +317,7 @@ const layerUsage = UsageService.layer.pipe( ).pipe(Layer.provide(ProviderHostLive.layer.pipe(Layer.provide(ServerSecretStore.layer)))), ), Layer.provide(layerServerSettings), + Layer.provide(SecretResolver.layer), ); const layerResourceDiagnostics = Layer.mergeAll( diff --git a/apps/server/src/terminal/Manager.ts b/apps/server/src/terminal/Manager.ts index 2d5c84b3e83ee..85462bdde48e8 100644 --- a/apps/server/src/terminal/Manager.ts +++ b/apps/server/src/terminal/Manager.ts @@ -68,14 +68,12 @@ import * as SynchronizedRef from "effect/SynchronizedRef"; import packageJson from "../../package.json" with { type: "json" }; import * as ServerConfig from "../config.ts"; -import { - literalProviderInstanceEnvironment, - overlayProviderInstanceEnvironment, -} from "@t3tools/provider-core/server/instanceEnvironment"; +import { overlayProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; import { makeClaudeEnvironment } from "../provider/Drivers/ClaudeHome.ts"; import type { deriveProviderInstanceConfigMap } from "../provider/ProviderInstanceRegistryHydration.ts"; import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import { resolveProviderEnvironmentSecrets } from "../secrets/providerEnvironmentSecrets.ts"; import * as ServerSettings from "../serverSettings.ts"; import { increment, terminalSessionsTotal } from "../observability/Metrics.ts"; import { expandHomeVariable } from "@t3tools/provider-core/server/pathExpansion"; @@ -1721,38 +1719,21 @@ export const resolveProviderInstanceTerminalEnvironment = Effect.fn( // A shell missing a configured credential would fall back to whatever the server inherited, // so an unreadable secret fails the launch instead of dropping the variable. - const secretVariables = (instance.environment ?? []).flatMap((variable) => - typeof variable.value === "string" ? [] : [{ name: variable.name, reference: variable.value }], - ); - const secretValues = - secretVariables.length === 0 - ? [] - : input.secrets === undefined - ? secretVariables.map(() => undefined) - : yield* input.secrets.read(secretVariables.map(({ reference }) => reference)); - const unreadable = secretVariables.filter( - (_, index) => (secretValues[index] ?? "").trim() === "", + const providerSecrets = yield* resolveProviderEnvironmentSecrets( + input.secrets, + instance.environment, ); - if (unreadable.length > 0) { + if (providerSecrets.unreadable.length > 0) { return yield* new TerminalProviderEnvironmentError({ providerInstanceId, cause: new Error( - `Could not read ${unreadable - .map(({ name, reference }) => `${name} (${reference.provider}:${reference.reference})`) - .join(", ")} from its secret provider. Unlock it, then try again.`, + `Could not read ${providerSecrets.unreadable.join(", ")} from its secret provider. Unlock it, then try again.`, ), }); } let resolved = yield* overlayProviderInstanceEnvironment( - [ - ...literalProviderInstanceEnvironment(instance.environment), - ...secretVariables.map(({ name }, index) => ({ - name, - value: secretValues[index] ?? "", - sensitive: true, - })), - ], + providerSecrets.environment, input.env ?? {}, ); if (instance.driver === "codex") { diff --git a/apps/server/src/usage/UsageService.test.ts b/apps/server/src/usage/UsageService.test.ts index 9a7f7ab82c8f1..3a335ce992dc0 100644 --- a/apps/server/src/usage/UsageService.test.ts +++ b/apps/server/src/usage/UsageService.test.ts @@ -18,6 +18,7 @@ import { EnvironmentId, ProviderDriverKind, ProviderInstanceId, + SecretProviderId, UsageDay, type UsageSource, type UsageSummary, @@ -51,6 +52,7 @@ 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 SecretResolverTestkit from "../secrets/SecretResolver.testkit.ts"; import * as UsageService from "./UsageService.ts"; import { DESKTOP_HOST_SCOPE_ENV, physicalSourceIdOf } from "./usageTranscriptReader.ts"; import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts"; @@ -196,6 +198,7 @@ const layerService = (input: { readonly platform?: NodeJS.Platform; readonly hostname?: string; readonly secretStore?: Partial; + readonly readSecrets?: Parameters[0]; }) => layerCursorUsageAccounts(CursorAccountReader.layer).pipe( Layer.provideMerge(AntigravityUsage.layer), @@ -217,6 +220,7 @@ const layerService = (input: { Layer.provideMerge(Layer.succeed(HostProcess.Hostname, input.hostname ?? "usage-test-host")), Layer.provideMerge(Layer.succeed(HostProcess.HomeDirectory, input.home)), Layer.provideMerge(ServerSettings.layerTest(input.settings)), + Layer.provideMerge(SecretResolverTestkit.layerTest(input.readSecrets)), Layer.provideMerge( Layer.succeed( HttpClient.HttpClient, @@ -1787,6 +1791,71 @@ describe("UsageService", () => { }), ); + describe("secret-backed history directory", () => { + const secretHome = { provider: SecretProviderId.make("vault"), reference: "kv/codex#home" }; + const summaryWith = ( + readSecrets: (home: string) => Parameters[0], + ) => + Effect.gen(function* () { + const { home, settings } = yield* setup; + const sessions = NodePath.join(home, "secret-codex", "sessions"); + yield* Effect.promise(async () => { + await NodeFSP.mkdir(sessions, { recursive: true }); + await NodeFSP.writeFile( + NodePath.join(sessions, "rollout.jsonl"), + [ + { type: "session_meta", payload: { id: "secret" } }, + { 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: 31 } }, + }, + }, + ] + .map((line) => encodeUnknownJsonString(line)) + .join("\n") + "\n", + ); + }); + const service = yield* UsageService.make.pipe( + Effect.provide( + layerService({ + prefix: "usage-secret-home", + home, + readSecrets: readSecrets(home), + settings: { + ...settings, + providerInstances: { + [ProviderInstanceId.make("codex-secret")]: { + driver: ProviderDriverKind.make("codex"), + config: {}, + environment: [{ name: "CODEX_HOME", value: secretHome, sensitive: true }], + }, + }, + }, + }), + ), + ); + return yield* service.readSummary(WINDOW); + }).pipe(Effect.scoped); + + it.effect("counts the history of a directory read from a secret", () => + Effect.gen(function* () { + const summary = yield* summaryWith((home) => () => [NodePath.join(home, "secret-codex")]); + assert.strictEqual(totalOutputTokens(summary), 31); + }), + ); + + it.effect("skips the instance and logs the variable when its secret cannot be read", () => + Effect.gen(function* () { + const summary = yield* summaryWith(() => () => [undefined]); + assert.strictEqual(totalOutputTokens(summary), 0); + }), + ); + }); + it.effect("reads shared managed default and disabled extra account history once", () => Effect.gen(function* () { const { home, settings } = yield* setup; diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts index 9d35546fb685b..3c1fc260ef6f1 100644 --- a/apps/server/src/usage/UsageService.ts +++ b/apps/server/src/usage/UsageService.ts @@ -30,13 +30,15 @@ import { HttpClient, HttpClientResponse } from "effect/http"; import { writeFileStringAtomically } from "@t3tools/shared/atomicWrite"; import { formatMalformedUsageWarning } from "@t3tools/shared/usageFormat"; import * as ServerConfig from "../config.ts"; +import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import { + PROVIDER_HOME_ENVIRONMENT_NAMES, + resolveProviderEnvironmentSecrets, +} from "../secrets/providerEnvironmentSecrets.ts"; import * as ServerSettings from "../serverSettings.ts"; import { BUILT_IN_USAGE_DRIVERS, type BuiltInUsageReadersEnv } from "../provider/builtInDrivers.ts"; import type { ProviderDriver } from "@t3tools/provider-core/server/driver"; -import { - literalProviderInstanceEnvironment, - mergeProviderInstanceEnvironment, -} from "@t3tools/provider-core/server/instanceEnvironment"; +import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import type { ProviderUsageInstance, TranscriptUsageFormat, @@ -173,6 +175,7 @@ export const make = Effect.gen(function* () { const config = yield* ServerConfig.ServerConfig; const settingsService = yield* ServerSettings.ServerSettingsService; const httpClient = yield* HttpClient.HttpClient; + const secrets = yield* SecretResolver.SecretResolver; const hostEnvironment = yield* HostProcess.Environment; const hostPlatform = yield* HostProcess.Platform; const hostScope = hostEnvironment[DESKTOP_HOST_SCOPE_ENV]?.trim(); @@ -371,21 +374,36 @@ export const make = Effect.gen(function* () { // History in the driver's default home stays counted after every instance moves elsewhere; readers dedupe shared directories. entries.push([ProviderInstanceId.make(driver.driverKind), {}, false]); const decodeConfig = Schema.decodeUnknownOption(driver.configSchema); - return yield* Effect.forEach( + const resolved = yield* Effect.forEach( entries, Effect.fnUntraced(function* ([instanceId, instance, configured]) { + const providerSecrets = yield* resolveProviderEnvironmentSecrets( + secrets, + instance.environment, + PROVIDER_HOME_ENVIRONMENT_NAMES, + ); + // Counting the default home for an instance whose own home cannot be read would + // report the wrong history as if it were complete, so the instance is skipped. + if (providerSecrets.unreadable.length > 0) { + yield* Effect.logWarning( + "skipping usage for a provider instance whose environment secret could not be read", + { instanceId, unreadable: providerSecrets.unreadable }, + ); + return []; + } const instanceConfig: ProviderUsageInstance = { instanceId, config: Option.getOrUndefined(decodeConfig(instance.config ?? {})), environment: yield* mergeProviderInstanceEnvironment( - literalProviderInstanceEnvironment(instance.environment), + providerSecrets.environment, hostEnvironment, ), configured, }; - return instanceConfig; + return [instanceConfig]; }), ); + return resolved.flat(); }); const resolveTranscriptDirs = Effect.fn("UsageService.resolveTranscriptDirs")(function* ( From a05904ab4cfde2a32e4c9710eb6b14e7c9a082fe Mon Sep 17 00:00:00 2001 From: Yordis Prieto Date: Sat, 21 Nov 2026 17:37:10 -0500 Subject: [PATCH 2/3] fix(server): only require the history secrets a reader actually uses - Home variables are selected per driver, so an unreadable secret for another driver no longer skips history. - The scanner skips the home secret when a configured home path takes precedence. - Resolved environment keeps configured order, so a later row still wins. Signed-off-by: Yordis Prieto --- .../src/project/AgentSessionScanner.test.ts | 38 +++++++++++-- .../server/src/project/AgentSessionScanner.ts | 56 +++++++++++-------- .../src/secrets/providerEnvironmentSecrets.ts | 37 ++++++------ apps/server/src/usage/UsageService.ts | 4 +- 4 files changed, 85 insertions(+), 50 deletions(-) diff --git a/apps/server/src/project/AgentSessionScanner.test.ts b/apps/server/src/project/AgentSessionScanner.test.ts index f6b45b56c80ef..8292e2c9dfb83 100644 --- a/apps/server/src/project/AgentSessionScanner.test.ts +++ b/apps/server/src/project/AgentSessionScanner.test.ts @@ -12,6 +12,7 @@ import { type OrchestrationProjectShell, ProjectId, ProviderDriverKind, + type ProviderInstanceConfig, ProviderInstanceId, SecretProviderId, type ServerSettings as ContractServerSettings, @@ -826,7 +827,8 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { const unrelated = { provider: SecretProviderId.make("vault"), reference: "kv/codex#key" }; const scanCodexSecretHome = ( readSecrets: (home: string) => Parameters[0], - extraEnvironment: ReadonlyArray<{ name: string; value: typeof unrelated; sensitive: true }>, + extraEnvironment: (home: string) => NonNullable, + config: (home: string) => Record = () => ({}), ) => Effect.gen(function* () { const path = yield* Path.Path; @@ -855,9 +857,9 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { driver: ProviderDriverKind.make("codex"), environment: [ { name: "CODEX_HOME", value: secretHome, sensitive: true }, - ...extraEnvironment, + ...extraEnvironment(secretCodexHome), ], - config: {}, + config: config(secretCodexHome), }, }, }); @@ -868,7 +870,7 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { Effect.gen(function* () { const { result, codexWorkspace } = yield* scanCodexSecretHome( (home) => (references) => references.map(() => home), - [], + () => [], ); expect(result.candidates.map((candidate) => candidate.path)).toEqual([codexWorkspace]); }), @@ -880,12 +882,33 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { Effect.gen(function* () { const { result } = yield* scanCodexSecretHome( () => (references) => references.map(() => undefined), - [], + () => [], ); expect(result.candidates).toEqual([]); }), ); + it.effect("scans a configured home path when the environment home secret is unreadable", () => + Effect.gen(function* () { + const { result, codexWorkspace } = yield* scanCodexSecretHome( + () => (references) => references.map(() => undefined), + () => [], + (home) => ({ homePath: home }), + ); + expect(result.candidates.map((candidate) => candidate.path)).toEqual([codexWorkspace]); + }), + ); + + it.effect("lets a later configured home row win over an earlier secret one", () => + Effect.gen(function* () { + const { result, codexWorkspace } = yield* scanCodexSecretHome( + () => (references) => references.map(() => "/nonexistent-codex-home"), + (home) => [{ name: "CODEX_HOME", value: home, sensitive: false }], + ); + expect(result.candidates.map((candidate) => candidate.path)).toEqual([codexWorkspace]); + }), + ); + it.effect("does not skip an instance over a secret unrelated to its history directory", () => Effect.gen(function* () { const { result, codexWorkspace } = yield* scanCodexSecretHome( @@ -893,7 +916,10 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { references.map((reference) => reference.reference === secretHome.reference ? home : undefined, ), - [{ name: "OPENAI_API_KEY", value: unrelated, sensitive: true }], + () => [ + { name: "OPENAI_API_KEY", value: unrelated, sensitive: true }, + { name: "CLAUDE_CONFIG_DIR", value: unrelated, sensitive: true }, + ], ); expect(result.candidates.map((candidate) => candidate.path)).toEqual([codexWorkspace]); }), diff --git a/apps/server/src/project/AgentSessionScanner.ts b/apps/server/src/project/AgentSessionScanner.ts index 3c16ceabd0557..42e809765b148 100644 --- a/apps/server/src/project/AgentSessionScanner.ts +++ b/apps/server/src/project/AgentSessionScanner.ts @@ -41,7 +41,7 @@ import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.t import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; import { - PROVIDER_HOME_ENVIRONMENT_NAMES, + providerHomeEnvironmentNames, resolveProviderEnvironmentSecrets, } from "../secrets/providerEnvironmentSecrets.ts"; import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; @@ -1763,10 +1763,24 @@ export const make = Effect.gen(function* () { const homes: Array<{ homePath: string; providerInstanceId: ProviderInstanceId }> = []; const seenHomes = new Set(); for (const { instanceId, config: instance } of instances) { + const claudeConfig = + source === "claudeAgent" ? decodeClaudeSettings(instance.config ?? {}) : Option.none(); + const codexConfig = + source === "codex" ? decodeCodexSettings(instance.config ?? {}) : Option.none(); + if (source === "claudeAgent" && Option.isNone(claudeConfig)) continue; + if (source === "codex" && Option.isNone(codexConfig)) continue; + // A configured home path wins over the environment, so its secret is not needed then. + const configuredHome = + Option.exists(claudeConfig, (config) => config.homePath.trim().length > 0) || + Option.exists( + codexConfig, + (config) => + config.homePath.trim().length > 0 || config.shadowHomePath.trim().length > 0, + ); const providerSecrets = yield* resolveProviderEnvironmentSecrets( secrets, instance.environment, - PROVIDER_HOME_ENVIRONMENT_NAMES, + configuredHome ? [] : providerHomeEnvironmentNames(source), ); // A history directory held in an unreadable secret would fall back to the host default, // so the scan would show or import another account's sessions as this instance's. @@ -1785,37 +1799,31 @@ export const make = Effect.gen(function* () { }; let homePath: string; - if (source === "pi") { - const environment = yield* mergeProviderInstanceEnvironment( - providerSecrets.environment, - hostEnvironment, - ).pipe(Effect.provideService(HostProcess.HomeDirectory, homeDir)); - homePath = resolvePiSessionsDir( - environment, - piHome(environment, homeDir, platform), - path, - ); - } else if (source === "claudeAgent") { - const config = decodeClaudeSettings(instance.config ?? {}); - if (Option.isNone(config)) continue; + if (Option.isSome(claudeConfig)) { homePath = resolveClaudeConfigDir( - config.value.homePath, + claudeConfig.value.homePath, environmentHome("CLAUDE_CONFIG_DIR"), ); - } else { - const config = decodeCodexSettings(instance.config ?? {}); - if (Option.isNone(config)) continue; + } else if (Option.isSome(codexConfig)) { const codexHome = environmentHome("CODEX_HOME"); const codexSettings = - config.value.homePath.trim().length === 0 && - config.value.shadowHomePath.trim().length === 0 && - codexHome?.trim() - ? { ...config.value, homePath: codexHome } - : config.value; + !configuredHome && codexHome?.trim() + ? { ...codexConfig.value, homePath: codexHome } + : codexConfig.value; const layout = yield* resolveCodexHomeLayout(codexSettings).pipe( Effect.provideService(Path.Path, path), ); homePath = layout.sharedHomePath; + } else { + const environment = yield* mergeProviderInstanceEnvironment( + providerSecrets.environment, + hostEnvironment, + ).pipe(Effect.provideService(HostProcess.HomeDirectory, homeDir)); + homePath = resolvePiSessionsDir( + environment, + piHome(environment, homeDir, platform), + path, + ); } const homeKey = `${source}\0${yield* directoryIdentity(homePath)}`; diff --git a/apps/server/src/secrets/providerEnvironmentSecrets.ts b/apps/server/src/secrets/providerEnvironmentSecrets.ts index dac652b103bc8..5f65ef3aafd83 100644 --- a/apps/server/src/secrets/providerEnvironmentSecrets.ts +++ b/apps/server/src/secrets/providerEnvironmentSecrets.ts @@ -1,19 +1,20 @@ import type { ProviderInstanceEnvironment } from "@t3tools/contracts"; -import { literalProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import type * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; import * as Effect from "effect/Effect"; +const PROVIDER_HOME_ENVIRONMENT_NAMES = new Map>([ + ["claudeAgent", ["CLAUDE_CONFIG_DIR"]], + ["codex", ["CODEX_HOME"]], + ["antigravity", ["ANTIGRAVITY_DATA_DIR"]], + ["pi", ["PI_CODING_AGENT_DIR", "PI_CODING_AGENT_SESSION_DIR"]], +]); + /** - * Variables that place a provider's session history on disk. Readers that only look for a + * Variables that place a driver's session history on disk. Readers that only look for a * transcript directory need these resolved, and nothing else. */ -export const PROVIDER_HOME_ENVIRONMENT_NAMES: ReadonlyArray = [ - "CLAUDE_CONFIG_DIR", - "CODEX_HOME", - "ANTIGRAVITY_DATA_DIR", - "PI_CODING_AGENT_DIR", - "PI_CODING_AGENT_SESSION_DIR", -]; +export const providerHomeEnvironmentNames = (driver: string): ReadonlyArray => + PROVIDER_HOME_ENVIRONMENT_NAMES.get(driver) ?? []; export interface ProviderEnvironmentSecrets { /** Literal variables plus every secret that was read, ready to overlay on a process environment. */ @@ -50,16 +51,16 @@ export const resolveProviderEnvironmentSecrets = Effect.fn("ProviderEnvironmentS ? secretVariables.map(() => undefined) : yield* secrets.read(secretVariables.map(({ reference }) => reference)); const unreadable = secretVariables.filter((_, index) => (values[index] ?? "").trim() === ""); + let secretIndex = 0; return { - environment: [ - ...literalProviderInstanceEnvironment(environment), - ...secretVariables.flatMap(({ name }, index) => { - const value = values[index]; - return value === undefined || value.trim() === "" - ? [] - : [{ name, value, sensitive: true }]; - }), - ], + environment: (environment ?? []).flatMap(({ name, value, sensitive }) => { + if (typeof value === "string") return [{ name, value, sensitive }]; + if (only !== undefined && !only.includes(name)) return []; + const read = values[secretIndex++]; + return read === undefined || read.trim() === "" + ? [] + : [{ name, value: read, sensitive: true }]; + }), unreadable: unreadable.map( ({ name, reference }) => `${name} (${reference.provider}:${reference.reference})`, ), diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts index 3c1fc260ef6f1..b16503a8f88d2 100644 --- a/apps/server/src/usage/UsageService.ts +++ b/apps/server/src/usage/UsageService.ts @@ -32,7 +32,7 @@ import { formatMalformedUsageWarning } from "@t3tools/shared/usageFormat"; import * as ServerConfig from "../config.ts"; import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; import { - PROVIDER_HOME_ENVIRONMENT_NAMES, + providerHomeEnvironmentNames, resolveProviderEnvironmentSecrets, } from "../secrets/providerEnvironmentSecrets.ts"; import * as ServerSettings from "../serverSettings.ts"; @@ -380,7 +380,7 @@ export const make = Effect.gen(function* () { const providerSecrets = yield* resolveProviderEnvironmentSecrets( secrets, instance.environment, - PROVIDER_HOME_ENVIRONMENT_NAMES, + providerHomeEnvironmentNames(driver.driverKind), ); // Counting the default home for an instance whose own home cannot be read would // report the wrong history as if it were complete, so the instance is skipped. From 09a9b2b0953f18a9cfb7c5d0010fbb7485d07901 Mon Sep 17 00:00:00 2001 From: Yordis Prieto Date: Sat, 21 Nov 2026 17:43:06 -0500 Subject: [PATCH 3/3] refactor(server): usage readers declare the variables that locate their history The server no longer keeps a per-driver list. Each reader returns the variables that move its history for a given config, so a new provider states its own, and a provider without one reads none. Signed-off-by: Yordis Prieto --- .../server/src/project/AgentSessionScanner.ts | 28 +++++++++---------- .../src/provider/Drivers/AntigravityUsage.ts | 1 + .../src/provider/Drivers/claudeUsage.ts | 2 ++ .../server/src/provider/Drivers/codexUsage.ts | 4 +++ .../src/secrets/providerEnvironmentSecrets.ts | 14 ---------- apps/server/src/usage/UsageService.ts | 10 +++---- packages/provider-core/src/server/usage.ts | 11 ++++++-- packages/provider-grok/src/server/usage.ts | 1 + .../provider-opencode/src/server/usage.ts | 1 + packages/provider-pi/src/server/usage.ts | 6 ++++ 10 files changed, 40 insertions(+), 38 deletions(-) diff --git a/apps/server/src/project/AgentSessionScanner.ts b/apps/server/src/project/AgentSessionScanner.ts index 42e809765b148..d7087f3ff1877 100644 --- a/apps/server/src/project/AgentSessionScanner.ts +++ b/apps/server/src/project/AgentSessionScanner.ts @@ -38,15 +38,14 @@ import * as ServerConfig from "../config.ts"; import * as ProcessRunner from "../processRunner.ts"; import * as ProjectStore from "../orchestration-v2/ProjectStore.ts"; import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.ts"; +import { claudeUsageReader } from "../provider/Drivers/claudeUsage.ts"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; +import { codexUsageReader } from "../provider/Drivers/codexUsage.ts"; import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; -import { - providerHomeEnvironmentNames, - resolveProviderEnvironmentSecrets, -} from "../secrets/providerEnvironmentSecrets.ts"; +import { resolveProviderEnvironmentSecrets } from "../secrets/providerEnvironmentSecrets.ts"; import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; -import { piHome, resolvePiSessionsDir } from "@t3tools/provider-pi/server/usage"; +import { piHome, piUsageReader, resolvePiSessionsDir } from "@t3tools/provider-pi/server/usage"; import * as ServerSettings from "../serverSettings.ts"; import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts"; import { @@ -1769,18 +1768,15 @@ export const make = Effect.gen(function* () { source === "codex" ? decodeCodexSettings(instance.config ?? {}) : Option.none(); if (source === "claudeAgent" && Option.isNone(claudeConfig)) continue; if (source === "codex" && Option.isNone(codexConfig)) continue; - // A configured home path wins over the environment, so its secret is not needed then. - const configuredHome = - Option.exists(claudeConfig, (config) => config.homePath.trim().length > 0) || - Option.exists( - codexConfig, - (config) => - config.homePath.trim().length > 0 || config.shadowHomePath.trim().length > 0, - ); + const historyEnvironment = Option.isSome(claudeConfig) + ? claudeUsageReader.historyEnvironment?.(claudeConfig.value) + : Option.isSome(codexConfig) + ? codexUsageReader.historyEnvironment?.(codexConfig.value) + : piUsageReader.historyEnvironment?.(undefined); const providerSecrets = yield* resolveProviderEnvironmentSecrets( secrets, instance.environment, - configuredHome ? [] : providerHomeEnvironmentNames(source), + historyEnvironment ?? [], ); // A history directory held in an unreadable secret would fall back to the host default, // so the scan would show or import another account's sessions as this instance's. @@ -1807,7 +1803,9 @@ export const make = Effect.gen(function* () { } else if (Option.isSome(codexConfig)) { const codexHome = environmentHome("CODEX_HOME"); const codexSettings = - !configuredHome && codexHome?.trim() + codexConfig.value.homePath.trim().length === 0 && + codexConfig.value.shadowHomePath.trim().length === 0 && + codexHome?.trim() ? { ...codexConfig.value, homePath: codexHome } : codexConfig.value; const layout = yield* resolveCodexHomeLayout(codexSettings).pipe( diff --git a/apps/server/src/provider/Drivers/AntigravityUsage.ts b/apps/server/src/provider/Drivers/AntigravityUsage.ts index 2eb9744a3e42a..2788fc67b6d02 100644 --- a/apps/server/src/provider/Drivers/AntigravityUsage.ts +++ b/apps/server/src/provider/Drivers/AntigravityUsage.ts @@ -128,6 +128,7 @@ export const antigravityUsageReader: ProviderUsageReader ["ANTIGRAVITY_DATA_DIR"], scan: ({ instances, windowStartMs }) => AntigravityUsage.pipe(Effect.flatMap((usage) => usage.scan({ instances, windowStartMs }))), }; diff --git a/apps/server/src/provider/Drivers/claudeUsage.ts b/apps/server/src/provider/Drivers/claudeUsage.ts index 713b35884292b..1e3465f8033c0 100644 --- a/apps/server/src/provider/Drivers/claudeUsage.ts +++ b/apps/server/src/provider/Drivers/claudeUsage.ts @@ -136,6 +136,8 @@ export const claudeUsageReader: ProviderUsageReader = kind: "transcripts", provider: "claude", format: claudeUsageFormat, + historyEnvironment: (config) => + config === undefined || config.homePath.trim() ? [] : ["CLAUDE_CONFIG_DIR"], directories: Effect.fn("claudeUsageReader.directories")(function* ({ config, environment }) { if (config === undefined) return []; const path = yield* Path.Path; diff --git a/apps/server/src/provider/Drivers/codexUsage.ts b/apps/server/src/provider/Drivers/codexUsage.ts index a2977d3080fee..cb2696204f708 100644 --- a/apps/server/src/provider/Drivers/codexUsage.ts +++ b/apps/server/src/provider/Drivers/codexUsage.ts @@ -548,6 +548,10 @@ export const codexUsageReader: ProviderUsageReader< } return speeds; }), + historyEnvironment: (config) => + config === undefined || config.setupMode === "managed" || config.homePath.trim() + ? [] + : ["CODEX_HOME"], directories: Effect.fn("codexUsageReader.directories")(function* ({ config, environment }) { if (config === undefined) return []; const path = yield* Path.Path; diff --git a/apps/server/src/secrets/providerEnvironmentSecrets.ts b/apps/server/src/secrets/providerEnvironmentSecrets.ts index 5f65ef3aafd83..5d8cf0ebfc444 100644 --- a/apps/server/src/secrets/providerEnvironmentSecrets.ts +++ b/apps/server/src/secrets/providerEnvironmentSecrets.ts @@ -2,20 +2,6 @@ import type { ProviderInstanceEnvironment } from "@t3tools/contracts"; import type * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; import * as Effect from "effect/Effect"; -const PROVIDER_HOME_ENVIRONMENT_NAMES = new Map>([ - ["claudeAgent", ["CLAUDE_CONFIG_DIR"]], - ["codex", ["CODEX_HOME"]], - ["antigravity", ["ANTIGRAVITY_DATA_DIR"]], - ["pi", ["PI_CODING_AGENT_DIR", "PI_CODING_AGENT_SESSION_DIR"]], -]); - -/** - * Variables that place a driver's session history on disk. Readers that only look for a - * transcript directory need these resolved, and nothing else. - */ -export const providerHomeEnvironmentNames = (driver: string): ReadonlyArray => - PROVIDER_HOME_ENVIRONMENT_NAMES.get(driver) ?? []; - export interface ProviderEnvironmentSecrets { /** Literal variables plus every secret that was read, ready to overlay on a process environment. */ readonly environment: ReadonlyArray<{ diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts index b16503a8f88d2..fa196ee7f1127 100644 --- a/apps/server/src/usage/UsageService.ts +++ b/apps/server/src/usage/UsageService.ts @@ -31,10 +31,7 @@ import { writeFileStringAtomically } from "@t3tools/shared/atomicWrite"; import { formatMalformedUsageWarning } from "@t3tools/shared/usageFormat"; import * as ServerConfig from "../config.ts"; import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; -import { - providerHomeEnvironmentNames, - resolveProviderEnvironmentSecrets, -} from "../secrets/providerEnvironmentSecrets.ts"; +import { resolveProviderEnvironmentSecrets } from "../secrets/providerEnvironmentSecrets.ts"; import * as ServerSettings from "../serverSettings.ts"; import { BUILT_IN_USAGE_DRIVERS, type BuiltInUsageReadersEnv } from "../provider/builtInDrivers.ts"; import type { ProviderDriver } from "@t3tools/provider-core/server/driver"; @@ -377,10 +374,11 @@ export const make = Effect.gen(function* () { const resolved = yield* Effect.forEach( entries, Effect.fnUntraced(function* ([instanceId, instance, configured]) { + const config = Option.getOrUndefined(decodeConfig(instance.config ?? {})); const providerSecrets = yield* resolveProviderEnvironmentSecrets( secrets, instance.environment, - providerHomeEnvironmentNames(driver.driverKind), + driver.usage?.historyEnvironment?.(config) ?? [], ); // Counting the default home for an instance whose own home cannot be read would // report the wrong history as if it were complete, so the instance is skipped. @@ -393,7 +391,7 @@ export const make = Effect.gen(function* () { } const instanceConfig: ProviderUsageInstance = { instanceId, - config: Option.getOrUndefined(decodeConfig(instance.config ?? {})), + config, environment: yield* mergeProviderInstanceEnvironment( providerSecrets.environment, hostEnvironment, diff --git a/packages/provider-core/src/server/usage.ts b/packages/provider-core/src/server/usage.ts index ff4c14dfefe00..9818b898746bd 100644 --- a/packages/provider-core/src/server/usage.ts +++ b/packages/provider-core/src/server/usage.ts @@ -105,16 +105,21 @@ export interface ProviderUsageScanInput { readonly awaitRefresh: boolean; } -interface ProviderUsageRateModel { +interface ProviderUsageReaderBase { /** * The rate-table name for a model ID this provider records with a separate `rateModel`, so * usage mapped onto that ID prices like the provider's own records of it. */ readonly rateModel?: (model: string) => string; + /** + * Variables that move where an instance's history lives. Their secrets must be readable before + * the instance is counted, or the default location would report another account's history. + */ + readonly historyEnvironment?: (config: Config | undefined) => ReadonlyArray; } export type ProviderUsageReader = - | (ProviderUsageRateModel & { + | (ProviderUsageReaderBase & { readonly kind: "transcripts"; readonly provider: UsageProviderKind; readonly format: TranscriptUsageFormat; @@ -135,7 +140,7 @@ export type ProviderUsageReader = R >; }) - | (ProviderUsageRateModel & { + | (ProviderUsageReaderBase & { readonly kind: "scan"; readonly provider: UsageProviderKind; /** Fails only when the whole usage read cannot go on; an unreadable source is a status. */ diff --git a/packages/provider-grok/src/server/usage.ts b/packages/provider-grok/src/server/usage.ts index 1e0b75cc796b1..d4cfda4f69212 100644 --- a/packages/provider-grok/src/server/usage.ts +++ b/packages/provider-grok/src/server/usage.ts @@ -200,6 +200,7 @@ export const grokUsageReader: ProviderUsageReader = { kind: "transcripts", provider: "grok", format: grokUsageFormat, + historyEnvironment: () => ["GROK_HOME"], directories: Effect.fn("grokUsageReader.directories")(function* ({ environment }) { const path = yield* Path.Path; const homeDirectory = yield* HostProcess.HomeDirectory; diff --git a/packages/provider-opencode/src/server/usage.ts b/packages/provider-opencode/src/server/usage.ts index 9878742ce882e..7491241cc8249 100644 --- a/packages/provider-opencode/src/server/usage.ts +++ b/packages/provider-opencode/src/server/usage.ts @@ -492,6 +492,7 @@ export type OpenCodeUsageReaderEnv = FileSystem.FileSystem | Path.Path; export const openCodeUsageReader: ProviderUsageReader = { kind: "scan", provider: "opencode", + historyEnvironment: () => ["OPENCODE_DATA_DIR", "XDG_DATA_HOME"], scan: Effect.fn("openCodeUsageReader.scan")(function* ({ instances, windowStartMs, diff --git a/packages/provider-pi/src/server/usage.ts b/packages/provider-pi/src/server/usage.ts index 2e274b464864a..b20eef54de342 100644 --- a/packages/provider-pi/src/server/usage.ts +++ b/packages/provider-pi/src/server/usage.ts @@ -131,6 +131,12 @@ export const piUsageReader: ProviderUsageReader = { format: piUsageFormat, // Pi model IDs are `/`. rateModel: (model) => model.slice(model.indexOf("/") + 1), + historyEnvironment: () => [ + "PI_CODING_AGENT_DIR", + "PI_CODING_AGENT_SESSION_DIR", + "HOME", + "USERPROFILE", + ], directories: Effect.fn("piUsageReader.directories")(function* ({ config, environment }) { const path = yield* Path.Path; const home = yield* HostProcess.HomeDirectory;