From fc6ba9a94969184b3c7859e9ed38fff573a82402 Mon Sep 17 00:00:00 2001 From: Yordis Prieto Date: Thu, 19 Nov 2026 23:46:44 -0500 Subject: [PATCH] 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* (