import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import * as HostProcess from "@t3tools/shared/HostProcess";
import {
OrchestratorMcpRequestSecretInput,
ProjectId,
type OrchestrationV2ServerCommand,
SecretProviderId,
SecretProviderKind,
SecretRef,
ThreadId,
TurnItemId,
} from "@t3tools/contracts";
import { defineSecretProviderDriver } from "@t3tools/secret-provider-core/server/driver";
import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
import { defineSecretProvider } from "@t3tools/secret-provider-core/shared/definition";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Metric from "effect/Metric";
import * as Tracer from "effect/Tracer";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as PlatformError from "effect/PlatformError";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
import * as SecretRequests from "./SecretRequests.ts";
const threadId = ThreadId.make("thread-orchestrator");
const turnItemId = TurnItemId.make("turn-item:secret-request:1");
const projectId = ProjectId.make("project-1");
const decodeSecretInput = Schema.decodeUnknownEffect(OrchestratorMcpRequestSecretInput);
const decodeSecretInputExit = Schema.decodeUnknownExit(OrchestratorMcpRequestSecretInput);
const FAKE_KIND = SecretProviderKind.make("fake");
const vault = SecretProviderId.make("vault");
/** Reads `fake://` references from `values` while unlocked, as a password manager would. */
const fakeVault = () => {
const state = { unlocked: true, values: new Map([["fake://github/token", "ghp_from_vault"]]) };
const driver = defineSecretProviderDriver({
kind: FAKE_KIND,
definition: defineSecretProvider({
kind: FAKE_KIND,
label: "Fake",
configSchema: Schema.Struct({}),
isReference: (reference) => reference.startsWith("fake://"),
referencePlaceholder: "fake://item",
invalidReferenceMessage: "Use fake://item.",
}),
read: (_config, references) =>
Effect.sync(() =>
references.map((reference) => (state.unlocked ? state.values.get(reference) : undefined)),
),
});
return {
state,
layer: SecretResolver.layer({
drivers: [driver],
secretProviders: Effect.succeed({ [vault]: { kind: FAKE_KIND, label: "Vault", config: {} } }),
}).pipe(Layer.provide(Layer.merge(NodeServices.layer, NodeCrypto.layer))),
};
};
const withService = <A, E>(
body: (input: {
readonly service: SecretRequests.SecretRequests["Service"];
readonly stored: Map<string, Uint8Array>;
readonly dispatched: Array<OrchestrationV2ServerCommand>;
}) => Effect.Effect<A, E>,
options: {
readonly threadId?: ThreadId;
readonly delivery?: "file";
readonly directory?: string;
readonly runStatus?: string;
readonly removeFails?: boolean;
readonly closedFirst?: boolean;
readonly failedRecords?: number;
readonly resolver?: Layer.Layer<SecretResolver.SecretResolver>;
} = {},
) =>
Effect.gen(function* () {
const stored = new Map<string, Uint8Array>();
const dispatched: Array<OrchestrationV2ServerCommand> = [];
let secretStatus = "pending";
let failedRecords = options.failedRecords ?? 0;
const requestThreadId = options.threadId ?? threadId;
const layerDependencies = Layer.mergeAll(
NodeCrypto.layer,
NodeServices.layer,
options.resolver ?? fakeVault().layer,
Layer.succeed(
ServerSecretStore.ServerSecretStore,
ServerSecretStore.ServerSecretStore.of({
...(options.directory === undefined ? {} : { directory: options.directory }),
get: (name) => Effect.yieldNow.pipe(Effect.as(Option.fromNullishOr(stored.get(name)))),
set: (name, value) => Effect.sync(() => void stored.set(name, value)),
create: (name, value) =>
stored.has(name)
? Effect.fail(
new ServerSecretStore.SecretStorePersistError({
resource: name,
cause: new PlatformError.PlatformError(
new PlatformError.SystemError({
_tag: "AlreadyExists",
module: "FileSystem",
method: "open",
}),
),
} as never),
)
: Effect.sync(() => void stored.set(name, value)),
getOrCreateRandom: (name, bytes) =>
Effect.sync(() => {
const existing = stored.get(name);
if (existing) return existing;
const value = new Uint8Array(bytes).fill(7);
stored.set(name, value);
return value;
}),
remove: (name) =>
options.removeFails
? Effect.fail(
new ServerSecretStore.SecretStorePersistError({
resource: name,
cause: new Error("read-only"),
}),
)
: Effect.sync(() => void stored.delete(name)),
}),
),
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: () =>
Effect.succeed({
thread: { projectId },
runs: [{ id: "run-1", status: options.runStatus ?? "running" }],
turnItems: [
{
id: turnItemId,
threadId: requestThreadId,
runId: "run-1",
nodeId: "node-root",
type: "secret_request",
label: "GitHub token",
reason: "Used as GH_TOKEN.",
...(options.delivery === undefined ? {} : { delivery: options.delivery }),
secretStatus,
},
],
} as never),
dispatch: (command) => {
if (command.type === "secret_request.record" && failedRecords > 0) {
failedRecords -= 1;
return Effect.fail(new Error("orchestrator unavailable") as never);
}
return Effect.sync(() => {
dispatched.push(command);
if (options.closedFirst && command.type === "secret_request.record") {
secretStatus = "cancelled";
} else if (command.type === "secret_request.record" && secretStatus === "pending") {
secretStatus = command.secretStatus;
}
return {} as never;
});
},
}),
);
return yield* Effect.gen(function* () {
const service = yield* SecretRequests.SecretRequests;
return yield* body({ service, stored, dispatched });
}).pipe(Effect.provide(SecretRequests.layer.pipe(Layer.provide(layerDependencies))));
});
const valuesOf = (stored: Map<string, Uint8Array>) =>
Array.from(stored.entries())
.filter(([name]) => name !== "secret-request-salt")
.map(([, bytes]) => new TextDecoder().decode(bytes));
it.effect("a saved answer becomes a one-use ref, and the thread only learns it was saved", () =>
withService(({ service, stored, dispatched }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
assert.equal(dispatched.length, 1);
assert.include(dispatched[0] as object, {
type: "secret_request.record",
secretStatus: "saved",
});
assert.notInclude(Object.values(dispatched[0] as object).map(String), "ghp_secret");
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
assert.isFalse(valuesOf(stored).some((value) => value.includes("ghp_secret")));
const again = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
assert.include(again.message, "already used");
}),
),
);
it.effect("a secret provider reference is read once and saved like a typed value", () =>
withService(({ service, dispatched }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: {
type: "reference",
reference: { provider: vault, reference: "fake://github/token" },
},
});
assert.include(dispatched[0] as object, { secretStatus: "saved" });
assert.notInclude(JSON.stringify(dispatched), "fake://");
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
assert.equal(yield* service.consume({ ref, projectId }), "ghp_from_vault");
}),
),
);
it.effect(
"an unreadable reference leaves the request pending, and a retry after unlocking works",
() => {
const { state, layer } = fakeVault();
state.unlocked = false;
return withService(
({ service, stored, dispatched }) =>
Effect.gen(function* () {
const reference = { provider: vault, reference: "fake://github/token" };
const locked = yield* service
.answer({ threadId, turnItemId, answer: { type: "reference", reference } })
.pipe(Effect.flip);
assert.equal(locked.reason, "reference_unreadable");
assert.include(locked.message, '"Vault"');
assert.deepEqual(dispatched, []);
assert.deepEqual(valuesOf(stored), []);
state.unlocked = true;
yield* service.answer({ threadId, turnItemId, answer: { type: "reference", reference } });
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
assert.equal(yield* service.consume({ ref, projectId }), "ghp_from_vault");
}),
{ resolver: layer },
);
},
);
it.effect("a reference to a secret provider that is not configured fails", () =>
withService(({ service, dispatched }) =>
Effect.gen(function* () {
const error = yield* service
.answer({
threadId,
turnItemId,
answer: {
type: "reference",
reference: {
// Also an Object.prototype key, which must not pass for a configured provider.
provider: SecretProviderId.make("constructor"),
reference: "fake://github/token",
},
},
})
.pipe(Effect.flip);
assert.equal(error.reason, "reference_unreadable");
assert.include(error.message, '"constructor"');
assert.deepEqual(dispatched, []);
}),
),
);
it.effect("two concurrent uses of one ref hand the value out once", () =>
withService(({ service }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
const results = yield* Effect.forEach(
[service.consume({ ref, projectId }), service.consume({ ref, projectId })],
Effect.result,
{ concurrency: "unbounded" },
);
assert.deepEqual(results.map((result) => result._tag).toSorted(), ["Failure", "Success"]);
}),
),
);
it.effect("a save that loses to the card closing deletes the value and says so", () =>
withService(
({ service, stored }) =>
Effect.gen(function* () {
const error = yield* service
.answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
.pipe(Effect.flip);
assert.equal(error.reason, "agent_stopped");
assert.isFalse(valuesOf(stored).some((value) => value.includes("ghp_secret")));
}),
{ closedFirst: true },
),
);
it.effect("a save whose record failed can be saved again", () =>
withService(
({ service }) =>
Effect.gen(function* () {
const failed = yield* service
.answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
.pipe(Effect.flip);
assert.equal(failed.reason, "record_failed");
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
}),
{ failedRecords: 1 },
),
);
it.effect("a ref only works in the project it was entered for", () =>
withService(({ service }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
const elsewhere = yield* service
.consume({ ref, projectId: ProjectId.make("project-other") })
.pipe(Effect.flip);
assert.include(elsewhere.message, "does not exist");
assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
}),
),
);
it.effect("declining stores nothing, and a request is answered once", () =>
withService(({ service, stored, dispatched }) =>
Effect.gen(function* () {
yield* service.answer({ threadId, turnItemId, answer: { type: "decline" } });
assert.deepEqual(valuesOf(stored), []);
assert.isTrue(Option.isNone(yield* service.savedRef({ threadId, turnItemId })));
const late = yield* service
.answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
.pipe(Effect.flip);
assert.include(late.message, "already answered");
assert.equal(dispatched.length, 1);
assert.deepEqual(valuesOf(stored), []);
}),
),
);
it.effect("traces and counts a saved answer without ever recording the value", () =>
Effect.gen(function* () {
const spans: Array<Tracer.NativeSpan> = [];
const tracer = Tracer.make({
span: (options) => {
const span = new Tracer.NativeSpan(options);
spans.push(span);
return span;
},
});
const counted = Metric.snapshot.pipe(
Effect.map((snapshots) => {
const found = snapshots.find(
(snapshot) =>
snapshot.id === "t3_secret_refs_consumed_total" &&
snapshot.attributes?.result === "used",
);
return found?.type === "Counter" ? Number(found.state.count) : 0;
}),
);
const before = yield* counted;
yield* withService(({ service }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
yield* service.consume({ ref, projectId });
}),
).pipe(Effect.withTracer(tracer));
assert.equal((yield* counted) - before, 1);
const recorded = spans.flatMap((span) => [
span.name,
...Array.from(span.attributes.values(), String),
]);
assert.include(recorded, "SecretRequests.answer");
assert.include(recorded, "SecretRequests.consume");
assert.isFalse(recorded.some((value) => value.includes("ghp_secret")));
}),
);
it.effect("works in threads with long ids, such as a delegated subagent's", () => {
const delegatedThreadId = ThreadId.make(
`thread:delegated-task:command%3Amcp%3A${"a".repeat(36)}%3Adelegate-task%3Arelease-notes-v0.2.0-${"b".repeat(40)}`,
);
return withService(
({ service, stored }) =>
Effect.gen(function* () {
yield* service.answer({
threadId: delegatedThreadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
assert.isTrue(Array.from(stored.keys()).every((name) => name.length < 100));
const ref = Option.getOrThrow(
yield* service.savedRef({ threadId: delegatedThreadId, turnItemId }),
);
assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
}),
{ threadId: delegatedThreadId },
);
});
it.effect("refuses an answer once the agent that asked has stopped", () =>
withService(
({ service, stored, dispatched }) =>
Effect.gen(function* () {
const late = yield* service
.answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
.pipe(Effect.flip);
assert.include(late.message, "has stopped");
assert.deepEqual(valuesOf(stored), []);
assert.equal(dispatched.length, 0);
}),
{ runStatus: "completed" },
),
);
it.effect("a used value that cannot be deleted is not handed out", () =>
withService(
({ service }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
const failed = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
assert.include(failed.message, "Could not use");
}),
{ removeFails: true },
),
);
const SECRET_FILE_TTL_MS = 24 * 60 * 60 * 1000;
it.effect("a file request moves its value to an owner-only file, once", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
const file = yield* withService(
({ service, stored, dispatched }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "cf_token'$(id)" },
});
assert.include(dispatched[0] as object, { secretStatus: "saved", delivery: "file" });
const file = yield* service.saveToFile({ threadId, turnItemId });
assert.equal(yield* fs.readFileString(file), "cf_token'$(id)");
assert.deepEqual(valuesOf(stored), []);
if ((yield* HostProcess.Platform) !== "win32") {
assert.equal((yield* fs.stat(file)).mode & 0o777, 0o600);
assert.equal((yield* fs.stat(path.dirname(file))).mode & 0o777, 0o700);
}
// A retried request_secret gets the same file; the value is never a ref again.
assert.equal(yield* service.saveToFile({ threadId, turnItemId }), file);
const ref = SecretRef.make(`secret-ref:${path.basename(file)}`);
const reused = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
assert.equal(reused.reason, "ref_unavailable");
return file;
}),
{ delivery: "file", directory },
);
const { mtime } = yield* fs.stat(file);
yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS);
yield* withService(() => Effect.void, { directory });
assert.isTrue(yield* fs.exists(file));
yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS + 1);
yield* withService(() => Effect.void, { directory });
assert.isFalse(yield* fs.exists(file));
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect("a failed file write keeps the value, so the request can retry", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
yield* withService(
({ service }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "cf_token" },
});
const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
const name = ref.slice("secret-ref:".length);
// A non-empty directory where the partial file goes makes the write fail.
const partial = path.join(directory, "files", `${name}.partial`);
yield* fs.makeDirectory(path.join(partial, "block"), { recursive: true });
const failed = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
assert.equal(failed.reason, "store_failed");
yield* fs.remove(partial, { recursive: true });
const file = yield* service.saveToFile({ threadId, turnItemId });
assert.equal(yield* fs.readFileString(file), "cf_token");
}),
{ delivery: "file", directory },
);
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect("a file is not delivered while its stored copy cannot be removed", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
yield* withService(
({ service }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "cf_token" },
});
const first = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
assert.equal(first.reason, "consume_failed");
// A retry finds the file but still will not hand it out until the removal works.
const retried = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
assert.equal(retried.reason, "consume_failed");
}),
{ delivery: "file", directory, removeFails: true },
);
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect("a secret the card promised to keep from the agent is never written to a file", () =>
withService(({ service, stored }) =>
Effect.gen(function* () {
yield* service.answer({
threadId,
turnItemId,
answer: { type: "save", secret: "ghp_secret" },
});
const refused = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
assert.equal(refused.reason, "not_a_file_request");
assert.isTrue(valuesOf(stored).some((value) => value.includes("ghp_secret")));
}),
),
);
it.effect("a pasted secret goes straight to an owner-only file, with no card", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
const spans: Array<Tracer.NativeSpan> = [];
const tracer = Tracer.make({
span: (options) => {
const span = new Tracer.NativeSpan(options);
spans.push(span);
return span;
},
});
const pasted = "4829'$(id) 16";
const file = yield* withService(
({ service, stored, dispatched }) =>
Effect.gen(function* () {
const file = yield* service.savePasted({
threadId,
requestNamespace: "session-a",
requestKey: "key-1",
value: pasted,
});
assert.equal(path.dirname(file), path.join(directory, "files"));
assert.match(path.basename(file), /^[0-9a-f]{32}$/);
assert.equal(yield* fs.readFileString(file), pasted);
if ((yield* HostProcess.Platform) !== "win32") {
assert.equal((yield* fs.stat(file)).mode & 0o777, 0o600);
assert.equal((yield* fs.stat(path.dirname(file))).mode & 0o777, 0o700);
}
// No card and no stored copy: the thread never hears of it.
assert.deepEqual(dispatched, []);
assert.deepEqual(valuesOf(stored), []);
// A retry with the same key gets the same file, unchanged even if the value differs.
assert.equal(
yield* service.savePasted({
threadId,
requestNamespace: "session-a",
requestKey: "key-1",
value: "other",
}),
file,
);
assert.equal(yield* fs.readFileString(file), pasted);
// Another key, or the same key from another provider session, gets its own file.
const other = yield* service.savePasted({
threadId,
requestNamespace: "session-a",
requestKey: "key-2",
value: "x",
});
assert.notEqual(other, file);
const otherSession = yield* service.savePasted({
threadId,
requestNamespace: "session-b",
requestKey: "key-1",
value: "y",
});
assert.notEqual(otherSession, file);
assert.equal(yield* fs.readFileString(file), pasted);
// Its name is not a ref to the value.
const ref = SecretRef.make(`secret-ref:${path.basename(file)}`);
const reused = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
assert.equal(reused.reason, "ref_unavailable");
return file;
}).pipe(Effect.withTracer(tracer)),
{ directory },
);
const recorded = spans.flatMap((span) => [
span.name,
...Array.from(span.attributes.values(), String),
]);
assert.include(recorded, "SecretRequests.savePasted");
assert.isFalse(recorded.some((value) => value.includes("4829")));
const { mtime } = yield* fs.stat(file);
yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS);
yield* withService(() => Effect.void, { directory });
assert.isTrue(yield* fs.exists(file));
yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS + 1);
yield* withService(() => Effect.void, { directory });
assert.isFalse(yield* fs.exists(file));
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect("a pasted secret keeps its exact bytes from the tool input to the file", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
const pasted = " pa ss\tword\t ";
const input = yield* decodeSecretInput({
label: "Staging password",
reason: "Signs in the QA account.",
value: pasted,
});
assert.equal(input.value, pasted);
const empty = decodeSecretInputExit({
label: "Staging password",
reason: "Signs in the QA account.",
value: "",
});
assert.isTrue(Exit.isFailure(empty));
const file = yield* withService(
({ service }) =>
service.savePasted({
threadId,
requestNamespace: "session-a",
requestKey: "key-1",
value: input.value!,
}),
{ directory },
);
assert.equal(yield* fs.readFileString(file), pasted);
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect("a pasted secret is refused without a secrets directory", () =>
withService(({ service }) =>
Effect.gen(function* () {
const failed = yield* service
.savePasted({ threadId, requestNamespace: "session-a", requestKey: "key-1", value: "4829" })
.pipe(Effect.flip);
assert.equal(failed.reason, "store_failed");
}),
),
);