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 fc76fc150a1d2..38b33a25ca2f1 100644 --- a/apps/server/src/project/AgentSessionScanner.test.ts +++ b/apps/server/src/project/AgentSessionScanner.test.ts @@ -12,7 +12,9 @@ import { type OrchestrationProjectShell, ProjectId, ProviderDriverKind, + type ProviderInstanceConfig, ProviderInstanceId, + SecretProviderId, type ServerSettings as ContractServerSettings, ThreadId, } from "@t3tools/contracts"; @@ -34,6 +36,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 +70,7 @@ interface ScannerTestInput { readonly sources: ReadonlyArray; }; readonly processRunner?: Layer.Layer; + readonly readSecrets?: Parameters[0]; } const layerRuntimeRepository = (imported: ScannerTestInput["importedTranscripts"]) => @@ -131,6 +135,7 @@ const layerScannerTest = (input: ScannerTestInput) => ), layerProjectStore(input.importedWorkspaceRoots ?? []), layerRuntimeRepository(input.importedTranscripts), + SecretResolverTestkit.layerTest(input.readSecrets), ), ), ); @@ -817,6 +822,110 @@ 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: (home: string) => NonNullable, + config: (home: string) => Record = () => ({}), + ) => + 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(secretCodexHome), + ], + config: config(secretCodexHome), + }, + }, + }); + 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("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( + (home) => (references) => + references.map((reference) => + reference.reference === secretHome.reference ? home : undefined, + ), + () => [ + { 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]); + }), + ); + }); + 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 9bd4b5cebd276..b9fe8140bb659 100644 --- a/apps/server/src/project/AgentSessionScanner.ts +++ b/apps/server/src/project/AgentSessionScanner.ts @@ -39,10 +39,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 { 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 { @@ -921,6 +925,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`. @@ -1826,45 +1831,66 @@ 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; + 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, + 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. + 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]; }; let homePath: string; - if (source === "pi") { - const environment = yield* mergeProviderInstanceEnvironment( - instance.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 && + codexConfig.value.homePath.trim().length === 0 && + codexConfig.value.shadowHomePath.trim().length === 0 && codexHome?.trim() - ? { ...config.value, homePath: codexHome } - : config.value; + ? { ...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/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/provider/providerInstallation.test.ts b/apps/server/src/provider/providerInstallation.test.ts index 76cb5904193da..1be49e6efc541 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"; @@ -15,6 +16,7 @@ import * as Path from "effect/Path"; import * as Queue from "effect/Queue"; 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"; @@ -62,6 +64,7 @@ const makeHarness = Effect.fn("providerInstallation.test.makeHarness")(function* instance?: ProviderInstance; others?: ReadonlyArray; settings?: Parameters[0]; + readSecrets?: Parameters[0]; } = {}, ) { const calls: string[] = []; @@ -77,6 +80,7 @@ const makeHarness = Effect.fn("providerInstallation.test.makeHarness")(function* let watches = 0; const dependencies = Layer.mergeAll( ServerSettings.layerTest(input.settings), + SecretResolverTestkit.layerTest(input.readSecrets), Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({ getInstance: (id) => Effect.succeed(all.find((entry) => entry.instanceId === id)), listInstances: Effect.succeed(all), @@ -301,6 +305,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 0e423a832d00a..956fd9d32a0b7 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; @@ -231,10 +231,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.map(({ name, reference }) => `${name} (${reference.provider}:${reference.reference})`).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..3c0078ae2449f --- /dev/null +++ b/apps/server/src/secrets/providerEnvironmentSecrets.ts @@ -0,0 +1,55 @@ +import type { ProviderInstanceEnvironment, SecretReference } from "@t3tools/contracts"; +import type * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import * as Effect from "effect/Effect"; + +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; + }>; + /** Each secret that could not be read or read empty. Values are never part of it. */ + readonly unreadable: ReadonlyArray<{ + readonly name: string; + readonly reference: SecretReference; + }>; +} + +/** + * 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. + */ +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() === ""); + let secretIndex = 0; + return { + 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, + } satisfies ProviderEnvironmentSecrets; + }, +); diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index 66848e6815d7d..58a6acabc3a79 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -327,6 +327,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 5165753fbe645..d36fbf35e162d 100644 --- a/apps/server/src/terminal/Manager.ts +++ b/apps/server/src/terminal/Manager.ts @@ -73,6 +73,7 @@ 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"; @@ -1747,37 +1748,24 @@ 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 providerSecrets = yield* resolveProviderEnvironmentSecrets( + input.secrets, + instance.environment, ); - 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() === "", - ); - if (unreadable.length > 0) { + if (providerSecrets.unreadable.length > 0) { // The resolver caches failed reads too, so a retry after unlocking must ask the provider again. if (input.secrets !== undefined) { - yield* input.secrets.invalidate(unreadable.map(({ reference }) => reference)); + yield* input.secrets.invalidate(providerSecrets.unreadable.map(({ reference }) => reference)); } return yield* new TerminalProviderEnvironmentError({ providerInstanceId, - unreadableSecrets: unreadable, + unreadableSecrets: providerSecrets.unreadable, cause: new Error("A configured secret could not be read from its secret provider."), }); } - let secretIndex = 0; let resolved = yield* overlayProviderInstanceEnvironment( - (instance.environment ?? []).map((variable) => - typeof variable.value === "string" - ? { ...variable, value: variable.value } - : { ...variable, value: secretValues[secretIndex++] ?? "", 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 0a9b9611eea06..3db7ff36f8d1f 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..fa196ee7f1127 100644 --- a/apps/server/src/usage/UsageService.ts +++ b/apps/server/src/usage/UsageService.ts @@ -30,13 +30,12 @@ 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 { 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 +172,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 +371,37 @@ 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 config = Option.getOrUndefined(decodeConfig(instance.config ?? {})); + const providerSecrets = yield* resolveProviderEnvironmentSecrets( + secrets, + instance.environment, + 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. + 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 ?? {})), + 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* ( 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;