The best way to control Claude Code, Codex and more from any computer or phone

main
ts 831 lines 32.6 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { assert, it } from "@effect/vitest";
4 import * as HostProcess from "@t3tools/shared/HostProcess";
5 import {
6 OrchestratorMcpRequestSecretInput,
7 ProjectId,
8 type OrchestrationV2ServerCommand,
9 SecretProviderId,
10 SecretProviderKind,
11 SecretRef,
12 ThreadId,
13 TurnItemId,
14 } from "@t3tools/contracts";
15 import { defineSecretProviderDriver } from "@t3tools/secret-provider-core/server/driver";
16 import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
17 import { defineSecretProvider } from "@t3tools/secret-provider-core/shared/definition";
18 import * as Deferred from "effect/Deferred";
19 import * as Effect from "effect/Effect";
20 import * as Exit from "effect/Exit";
21 import * as Fiber from "effect/Fiber";
22 import * as FileSystem from "effect/FileSystem";
23 import * as Layer from "effect/Layer";
24 import * as Metric from "effect/Metric";
25 import * as Tracer from "effect/Tracer";
26 import * as Option from "effect/Option";
27 import * as Path from "effect/Path";
28 import * as PlatformError from "effect/PlatformError";
29 import * as Schema from "effect/Schema";
30 import * as TestClock from "effect/testing/TestClock";
31
32 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
33 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
34 import * as SecretRequests from "./SecretRequests.ts";
35
36 const threadId = ThreadId.make("thread-orchestrator");
37 const turnItemId = TurnItemId.make("turn-item:secret-request:1");
38 const projectId = ProjectId.make("project-1");
39 const decodeSecretInput = Schema.decodeUnknownEffect(OrchestratorMcpRequestSecretInput);
40 const decodeSecretInputExit = Schema.decodeUnknownExit(OrchestratorMcpRequestSecretInput);
41
42 const FAKE_KIND = SecretProviderKind.make("fake");
43 const vault = SecretProviderId.make("vault");
44 /** Reads `fake://` references from `values` while unlocked, as a password manager would. */
45 const fakeVault = () => {
46 const state = { unlocked: true, values: new Map([["fake://github/token", "ghp_from_vault"]]) };
47 const driver = defineSecretProviderDriver({
48 kind: FAKE_KIND,
49 definition: defineSecretProvider({
50 kind: FAKE_KIND,
51 label: "Fake",
52 configSchema: Schema.Struct({}),
53 isReference: (reference) => reference.startsWith("fake://"),
54 referencePlaceholder: "fake://item",
55 invalidReferenceMessage: "Use fake://item.",
56 }),
57 read: (_config, references) =>
58 Effect.sync(() =>
59 references.map((reference) => (state.unlocked ? state.values.get(reference) : undefined)),
60 ),
61 });
62 return {
63 state,
64 layer: SecretResolver.layer({
65 drivers: [driver],
66 secretProviders: Effect.succeed({ [vault]: { kind: FAKE_KIND, label: "Vault", config: {} } }),
67 }).pipe(Layer.provide(Layer.merge(NodeServices.layer, NodeCrypto.layer))),
68 };
69 };
70
71 const withService = <A, E>(
72 body: (input: {
73 readonly service: SecretRequests.SecretRequests["Service"];
74 readonly stored: Map<string, Uint8Array>;
75 readonly dispatched: Array<OrchestrationV2ServerCommand>;
76 }) => Effect.Effect<A, E>,
77 options: {
78 readonly threadId?: ThreadId;
79 readonly delivery?: "file";
80 readonly fields?: ReadonlyArray<{ readonly name: string; readonly label: string }>;
81 readonly directory?: string;
82 readonly runStatus?: string;
83 readonly removeFails?: boolean;
84 readonly closedFirst?: boolean;
85 readonly failedRecords?: number;
86 readonly resolver?: Layer.Layer<SecretResolver.SecretResolver>;
87 readonly afterCreate?: Effect.Effect<void>;
88 } = {},
89 ) =>
90 Effect.gen(function* () {
91 const stored = new Map<string, Uint8Array>();
92 const dispatched: Array<OrchestrationV2ServerCommand> = [];
93 let secretStatus = "pending";
94 let failedRecords = options.failedRecords ?? 0;
95 const requestThreadId = options.threadId ?? threadId;
96 const layerDependencies = Layer.mergeAll(
97 NodeCrypto.layer,
98 NodeServices.layer,
99 options.resolver ?? fakeVault().layer,
100 Layer.succeed(
101 ServerSecretStore.ServerSecretStore,
102 ServerSecretStore.ServerSecretStore.of({
103 ...(options.directory === undefined ? {} : { directory: options.directory }),
104 get: (name) => Effect.yieldNow.pipe(Effect.as(Option.fromNullishOr(stored.get(name)))),
105 set: (name, value) => Effect.sync(() => void stored.set(name, value)),
106 create: (name, value) =>
107 stored.has(name)
108 ? Effect.fail(
109 new ServerSecretStore.SecretStorePersistError({
110 resource: name,
111 cause: new PlatformError.PlatformError(
112 new PlatformError.SystemError({
113 _tag: "AlreadyExists",
114 module: "FileSystem",
115 method: "open",
116 }),
117 ),
118 } as never),
119 )
120 : Effect.sync(() => void stored.set(name, value)).pipe(
121 Effect.andThen(options.afterCreate ?? Effect.void),
122 ),
123 getOrCreateRandom: (name, bytes) =>
124 Effect.sync(() => {
125 const existing = stored.get(name);
126 if (existing) return existing;
127 const value = new Uint8Array(bytes).fill(7);
128 stored.set(name, value);
129 return value;
130 }),
131 remove: (name) =>
132 options.removeFails
133 ? Effect.fail(
134 new ServerSecretStore.SecretStorePersistError({
135 resource: name,
136 cause: new Error("read-only"),
137 }),
138 )
139 : Effect.sync(() => void stored.delete(name)),
140 }),
141 ),
142 Layer.mock(ThreadManagementService.ThreadManagementService)({
143 // Reads yield like a real store, so two answers can both see a pending card.
144 getThreadRecords: () =>
145 Effect.yieldNow.pipe(
146 Effect.as({
147 thread: { projectId },
148 runs: [{ id: "run-1", status: options.runStatus ?? "running" }],
149 turnItems: [
150 {
151 id: turnItemId,
152 threadId: requestThreadId,
153 runId: "run-1",
154 nodeId: "node-root",
155 type: "secret_request",
156 label: "GitHub token",
157 reason: "Used as GH_TOKEN.",
158 url: "https://github.com/settings/tokens",
159 ...(options.delivery === undefined ? {} : { delivery: options.delivery }),
160 ...(options.fields === undefined ? {} : { fields: options.fields }),
161 secretStatus,
162 },
163 ],
164 } as never),
165 ),
166 dispatch: (command) => {
167 if (command.type === "secret_request.record" && failedRecords > 0) {
168 failedRecords -= 1;
169 return Effect.fail(new Error("orchestrator unavailable") as never);
170 }
171 return Effect.sync(() => {
172 dispatched.push(command);
173 if (options.closedFirst && command.type === "secret_request.record") {
174 secretStatus = "cancelled";
175 } else if (command.type === "secret_request.record" && secretStatus === "pending") {
176 secretStatus = command.secretStatus;
177 }
178 return {} as never;
179 });
180 },
181 }),
182 );
183 return yield* Effect.gen(function* () {
184 const service = yield* SecretRequests.SecretRequests;
185 return yield* body({ service, stored, dispatched });
186 }).pipe(Effect.provide(SecretRequests.layer.pipe(Layer.provide(layerDependencies))));
187 });
188
189 const singleFile = (saved: { readonly file: string } | { readonly files: unknown }) =>
190 "file" in saved ? saved.file : assert.fail("expected a single file");
191
192 const valuesOf = (stored: Map<string, Uint8Array>) =>
193 Array.from(stored.entries())
194 .filter(([name]) => name !== "secret-request-salt")
195 .map(([, bytes]) => new TextDecoder().decode(bytes));
196
197 it.effect("a saved answer becomes a one-use ref, and the thread only learns it was saved", () =>
198 withService(({ service, stored, dispatched }) =>
199 Effect.gen(function* () {
200 yield* service.answer({
201 threadId,
202 turnItemId,
203 answer: { type: "save", secret: "ghp_secret" },
204 });
205 assert.equal(dispatched.length, 1);
206 assert.include(dispatched[0] as object, {
207 type: "secret_request.record",
208 secretStatus: "saved",
209 url: "https://github.com/settings/tokens",
210 });
211 assert.notInclude(Object.values(dispatched[0] as object).map(String), "ghp_secret");
212
213 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
214 assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
215 assert.isFalse(valuesOf(stored).some((value) => value.includes("ghp_secret")));
216 const again = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
217 assert.include(again.message, "already used");
218 }),
219 ),
220 );
221
222 it.effect("a secret provider reference is read once and saved like a typed value", () =>
223 withService(({ service, dispatched }) =>
224 Effect.gen(function* () {
225 yield* service.answer({
226 threadId,
227 turnItemId,
228 answer: {
229 type: "reference",
230 reference: { provider: vault, reference: "fake://github/token" },
231 },
232 });
233 assert.include(dispatched[0] as object, { secretStatus: "saved" });
234 assert.notInclude(JSON.stringify(dispatched), "fake://");
235 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
236 assert.equal(yield* service.consume({ ref, projectId }), "ghp_from_vault");
237 }),
238 ),
239 );
240
241 it.effect(
242 "an unreadable reference leaves the request pending, and a retry after unlocking works",
243 () => {
244 const { state, layer } = fakeVault();
245 state.unlocked = false;
246 return withService(
247 ({ service, stored, dispatched }) =>
248 Effect.gen(function* () {
249 const reference = { provider: vault, reference: "fake://github/token" };
250 const locked = yield* service
251 .answer({ threadId, turnItemId, answer: { type: "reference", reference } })
252 .pipe(Effect.flip);
253 assert.equal(locked.reason, "reference_unreadable");
254 assert.include(locked.message, '"Vault"');
255 assert.deepEqual(dispatched, []);
256 assert.deepEqual(valuesOf(stored), []);
257
258 state.unlocked = true;
259 yield* service.answer({ threadId, turnItemId, answer: { type: "reference", reference } });
260 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
261 assert.equal(yield* service.consume({ ref, projectId }), "ghp_from_vault");
262 }),
263 { resolver: layer },
264 );
265 },
266 );
267
268 it.effect("a reference to a secret provider that is not configured fails", () =>
269 withService(({ service, dispatched }) =>
270 Effect.gen(function* () {
271 const error = yield* service
272 .answer({
273 threadId,
274 turnItemId,
275 answer: {
276 type: "reference",
277 reference: {
278 // Also an Object.prototype key, which must not pass for a configured provider.
279 provider: SecretProviderId.make("constructor"),
280 reference: "fake://github/token",
281 },
282 },
283 })
284 .pipe(Effect.flip);
285 assert.equal(error.reason, "reference_unreadable");
286 assert.include(error.message, '"constructor"');
287 assert.deepEqual(dispatched, []);
288 }),
289 ),
290 );
291
292 it.effect("two concurrent uses of one ref hand the value out once", () =>
293 withService(({ service }) =>
294 Effect.gen(function* () {
295 yield* service.answer({
296 threadId,
297 turnItemId,
298 answer: { type: "save", secret: "ghp_secret" },
299 });
300 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
301 const results = yield* Effect.forEach(
302 [service.consume({ ref, projectId }), service.consume({ ref, projectId })],
303 Effect.result,
304 { concurrency: "unbounded" },
305 );
306 assert.deepEqual(results.map((result) => result._tag).toSorted(), ["Failure", "Success"]);
307 }),
308 ),
309 );
310
311 it.effect("a save that loses to the card closing deletes the value and says so", () =>
312 withService(
313 ({ service, stored }) =>
314 Effect.gen(function* () {
315 const error = yield* service
316 .answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
317 .pipe(Effect.flip);
318 assert.equal(error.reason, "agent_stopped");
319 assert.isFalse(valuesOf(stored).some((value) => value.includes("ghp_secret")));
320 }),
321 { closedFirst: true },
322 ),
323 );
324
325 it.effect("a save whose record failed can be saved again", () =>
326 withService(
327 ({ service }) =>
328 Effect.gen(function* () {
329 const failed = yield* service
330 .answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
331 .pipe(Effect.flip);
332 assert.equal(failed.reason, "record_failed");
333 yield* service.answer({
334 threadId,
335 turnItemId,
336 answer: { type: "save", secret: "ghp_secret" },
337 });
338 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
339 assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
340 }),
341 { failedRecords: 1 },
342 ),
343 );
344
345 it.effect("a ref only works in the project it was entered for", () =>
346 withService(({ service }) =>
347 Effect.gen(function* () {
348 yield* service.answer({
349 threadId,
350 turnItemId,
351 answer: { type: "save", secret: "ghp_secret" },
352 });
353 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
354 const elsewhere = yield* service
355 .consume({ ref, projectId: ProjectId.make("project-other") })
356 .pipe(Effect.flip);
357 assert.include(elsewhere.message, "does not exist");
358 assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
359 }),
360 ),
361 );
362
363 it.effect("declining stores nothing, and a request is answered once", () =>
364 withService(({ service, stored, dispatched }) =>
365 Effect.gen(function* () {
366 yield* service.answer({ threadId, turnItemId, answer: { type: "decline" } });
367 assert.deepEqual(valuesOf(stored), []);
368 assert.isTrue(Option.isNone(yield* service.savedRef({ threadId, turnItemId })));
369 const late = yield* service
370 .answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
371 .pipe(Effect.flip);
372 assert.include(late.message, "already answered");
373 assert.equal(dispatched.length, 1);
374 assert.deepEqual(valuesOf(stored), []);
375 }),
376 ),
377 );
378
379 it.effect("traces and counts a saved answer without ever recording the value", () =>
380 Effect.gen(function* () {
381 const spans: Array<Tracer.NativeSpan> = [];
382 const tracer = Tracer.make({
383 span: (options) => {
384 const span = new Tracer.NativeSpan(options);
385 spans.push(span);
386 return span;
387 },
388 });
389 const counted = Metric.snapshot.pipe(
390 Effect.map((snapshots) => {
391 const found = snapshots.find(
392 (snapshot) =>
393 snapshot.id === "t3_secret_refs_consumed_total" &&
394 snapshot.attributes?.result === "used",
395 );
396 return found?.type === "Counter" ? Number(found.state.count) : 0;
397 }),
398 );
399 const before = yield* counted;
400 yield* withService(({ service }) =>
401 Effect.gen(function* () {
402 yield* service.answer({
403 threadId,
404 turnItemId,
405 answer: { type: "save", secret: "ghp_secret" },
406 });
407 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
408 yield* service.consume({ ref, projectId });
409 }),
410 ).pipe(Effect.withTracer(tracer));
411 assert.equal((yield* counted) - before, 1);
412 const recorded = spans.flatMap((span) => [
413 span.name,
414 ...Array.from(span.attributes.values(), String),
415 ]);
416 assert.include(recorded, "SecretRequests.answer");
417 assert.include(recorded, "SecretRequests.consume");
418 assert.isFalse(recorded.some((value) => value.includes("ghp_secret")));
419 }),
420 );
421
422 it.effect("works in threads with long ids, such as a delegated subagent's", () => {
423 const delegatedThreadId = ThreadId.make(
424 `thread:delegated-task:command%3Amcp%3A${"a".repeat(36)}%3Adelegate-task%3Arelease-notes-v0.2.0-${"b".repeat(40)}`,
425 );
426 return withService(
427 ({ service, stored }) =>
428 Effect.gen(function* () {
429 yield* service.answer({
430 threadId: delegatedThreadId,
431 turnItemId,
432 answer: { type: "save", secret: "ghp_secret" },
433 });
434 assert.isTrue(Array.from(stored.keys()).every((name) => name.length < 100));
435 const ref = Option.getOrThrow(
436 yield* service.savedRef({ threadId: delegatedThreadId, turnItemId }),
437 );
438 assert.equal(yield* service.consume({ ref, projectId }), "ghp_secret");
439 }),
440 { threadId: delegatedThreadId },
441 );
442 });
443
444 it.effect("refuses an answer once the agent that asked has stopped", () =>
445 withService(
446 ({ service, stored, dispatched }) =>
447 Effect.gen(function* () {
448 const late = yield* service
449 .answer({ threadId, turnItemId, answer: { type: "save", secret: "ghp_secret" } })
450 .pipe(Effect.flip);
451 assert.include(late.message, "has stopped");
452 assert.deepEqual(valuesOf(stored), []);
453 assert.equal(dispatched.length, 0);
454 }),
455 { runStatus: "completed" },
456 ),
457 );
458
459 it.effect("a used value that cannot be deleted is not handed out", () =>
460 withService(
461 ({ service }) =>
462 Effect.gen(function* () {
463 yield* service.answer({
464 threadId,
465 turnItemId,
466 answer: { type: "save", secret: "ghp_secret" },
467 });
468 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
469 const failed = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
470 assert.include(failed.message, "Could not use");
471 }),
472 { removeFails: true },
473 ),
474 );
475
476 const SECRET_FILE_TTL_MS = 24 * 60 * 60 * 1000;
477
478 it.effect("a file request moves its value to an owner-only file, once", () =>
479 Effect.gen(function* () {
480 const fs = yield* FileSystem.FileSystem;
481 const path = yield* Path.Path;
482 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
483 const file = yield* withService(
484 ({ service, stored, dispatched }) =>
485 Effect.gen(function* () {
486 yield* service.answer({
487 threadId,
488 turnItemId,
489 answer: { type: "save", secret: "cf_token'$(id)" },
490 });
491 assert.include(dispatched[0] as object, { secretStatus: "saved", delivery: "file" });
492 const file = singleFile(yield* service.saveToFile({ threadId, turnItemId }));
493 assert.equal(yield* fs.readFileString(file), "cf_token'$(id)");
494 assert.deepEqual(valuesOf(stored), []);
495 if ((yield* HostProcess.Platform) !== "win32") {
496 assert.equal((yield* fs.stat(file)).mode & 0o777, 0o600);
497 assert.equal((yield* fs.stat(path.dirname(file))).mode & 0o777, 0o700);
498 }
499 // A retried request_secret gets the same file; the value is never a ref again.
500 assert.deepEqual(yield* service.saveToFile({ threadId, turnItemId }), { file });
501 const ref = SecretRef.make(`secret-ref:${path.basename(file)}`);
502 const reused = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
503 assert.equal(reused.reason, "ref_unavailable");
504 return file;
505 }),
506 { delivery: "file", directory },
507 );
508
509 const { mtime } = yield* fs.stat(file);
510 yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS);
511 yield* withService(() => Effect.void, { directory });
512 assert.isTrue(yield* fs.exists(file));
513 yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS + 1);
514 yield* withService(() => Effect.void, { directory });
515 assert.isFalse(yield* fs.exists(file));
516 }).pipe(Effect.provide(NodeServices.layer)),
517 );
518
519 it.effect("a fields request keeps each value apart and delivers one file per field", () =>
520 Effect.gen(function* () {
521 const fs = yield* FileSystem.FileSystem;
522 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
523 yield* withService(
524 ({ service, stored, dispatched }) =>
525 Effect.gen(function* () {
526 const answer = (values: Record<string, string>) =>
527 service.answer({ threadId, turnItemId, answer: { type: "save", values } });
528 // An older client answers with one secret; a partial answer is just as wrong.
529 for (const wrong of [
530 service.answer({ threadId, turnItemId, answer: { type: "save", secret: "pw" } }),
531 answer({ email: "qa@acme.dev" }),
532 answer({ email: "qa@acme.dev", password: "pw", extra: "x" }),
533 ]) {
534 assert.equal((yield* wrong.pipe(Effect.flip)).reason, "fields_mismatch");
535 }
536 assert.deepEqual(valuesOf(stored), []);
537 // A failed record removes every field's value, not just the first.
538 const failed = yield* answer({ email: "qa@acme.dev", password: "pw" }).pipe(Effect.flip);
539 assert.equal(failed.reason, "record_failed");
540 assert.deepEqual(valuesOf(stored), []);
541
542 yield* answer({ email: "qa@acme.dev", password: "hunter2" });
543 assert.include(dispatched[0] as object, { secretStatus: "saved", delivery: "file" });
544 assert.deepEqual((dispatched[0] as { fields?: unknown }).fields, [
545 { name: "email", label: "Email" },
546 { name: "password", label: "Password" },
547 ]);
548 assert.notInclude(JSON.stringify(dispatched), "hunter2");
549 const saved = yield* service.saveToFile({ threadId, turnItemId });
550 assert.isTrue("files" in saved);
551 const files = "files" in saved ? saved.files : {};
552 assert.deepEqual(Object.keys(files), ["email", "password"]);
553 assert.equal(yield* fs.readFileString(files.email ?? ""), "qa@acme.dev");
554 assert.equal(yield* fs.readFileString(files.password ?? ""), "hunter2");
555 assert.deepEqual(valuesOf(stored), []);
556 }),
557 {
558 delivery: "file",
559 directory,
560 failedRecords: 1,
561 fields: [
562 { name: "email", label: "Email" },
563 { name: "password", label: "Password" },
564 ],
565 },
566 );
567 }).pipe(Effect.provide(NodeServices.layer)),
568 );
569
570 it.effect("two racing answers to a fields card never mix their values", () =>
571 Effect.gen(function* () {
572 const fs = yield* FileSystem.FileSystem;
573 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
574 yield* withService(
575 ({ service }) =>
576 Effect.gen(function* () {
577 const answer = (who: string) =>
578 service.answer({
579 threadId,
580 turnItemId,
581 answer: { type: "save", values: { email: `${who}@acme.dev`, password: `${who}-pw` } },
582 });
583 const results = yield* Effect.forEach([answer("a"), answer("b")], Effect.result, {
584 concurrency: "unbounded",
585 });
586 assert.deepEqual(results.map((result) => result._tag).toSorted(), ["Failure", "Success"]);
587 const saved = yield* service.saveToFile({ threadId, turnItemId });
588 const files = "files" in saved ? saved.files : {};
589 const email = yield* fs.readFileString(files.email ?? "");
590 const password = yield* fs.readFileString(files.password ?? "");
591 assert.equal(password, `${email.split("@")[0]}-pw`);
592 }),
593 {
594 delivery: "file",
595 directory,
596 fields: [
597 { name: "email", label: "Email" },
598 { name: "password", label: "Password" },
599 ],
600 },
601 );
602 }).pipe(Effect.provide(NodeServices.layer)),
603 );
604
605 it.effect("a fields answer interrupted between two values keeps neither", () =>
606 Effect.gen(function* () {
607 const firstStored = yield* Deferred.make<void>();
608 yield* withService(
609 ({ service, stored }) =>
610 Effect.gen(function* () {
611 const fiber = yield* service
612 .answer({
613 threadId,
614 turnItemId,
615 answer: { type: "save", values: { email: "a@acme.dev", password: "a-pw" } },
616 })
617 .pipe(Effect.forkChild);
618 yield* Deferred.await(firstStored);
619 yield* Fiber.interrupt(fiber);
620 assert.deepEqual(valuesOf(stored), []);
621 }),
622 {
623 afterCreate: Deferred.succeed(firstStored, undefined).pipe(Effect.andThen(Effect.never)),
624 fields: [
625 { name: "email", label: "Email" },
626 { name: "password", label: "Password" },
627 ],
628 },
629 );
630 }),
631 );
632
633 it.effect("a failed file write keeps the value, so the request can retry", () =>
634 Effect.gen(function* () {
635 const fs = yield* FileSystem.FileSystem;
636 const path = yield* Path.Path;
637 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
638 yield* withService(
639 ({ service }) =>
640 Effect.gen(function* () {
641 yield* service.answer({
642 threadId,
643 turnItemId,
644 answer: { type: "save", secret: "cf_token" },
645 });
646 const ref = Option.getOrThrow(yield* service.savedRef({ threadId, turnItemId }));
647 const name = ref.slice("secret-ref:".length);
648 // A non-empty directory where the partial file goes makes the write fail.
649 const partial = path.join(directory, "files", `${name}.partial`);
650 yield* fs.makeDirectory(path.join(partial, "block"), { recursive: true });
651 const failed = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
652 assert.equal(failed.reason, "store_failed");
653 yield* fs.remove(partial, { recursive: true });
654 const file = singleFile(yield* service.saveToFile({ threadId, turnItemId }));
655 assert.equal(yield* fs.readFileString(file), "cf_token");
656 }),
657 { delivery: "file", directory },
658 );
659 }).pipe(Effect.provide(NodeServices.layer)),
660 );
661
662 it.effect("a file is not delivered while its stored copy cannot be removed", () =>
663 Effect.gen(function* () {
664 const fs = yield* FileSystem.FileSystem;
665 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
666 yield* withService(
667 ({ service }) =>
668 Effect.gen(function* () {
669 yield* service.answer({
670 threadId,
671 turnItemId,
672 answer: { type: "save", secret: "cf_token" },
673 });
674 const first = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
675 assert.equal(first.reason, "consume_failed");
676 // A retry finds the file but still will not hand it out until the removal works.
677 const retried = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
678 assert.equal(retried.reason, "consume_failed");
679 }),
680 { delivery: "file", directory, removeFails: true },
681 );
682 }).pipe(Effect.provide(NodeServices.layer)),
683 );
684
685 it.effect("a secret the card promised to keep from the agent is never written to a file", () =>
686 withService(({ service, stored }) =>
687 Effect.gen(function* () {
688 yield* service.answer({
689 threadId,
690 turnItemId,
691 answer: { type: "save", secret: "ghp_secret" },
692 });
693 const refused = yield* service.saveToFile({ threadId, turnItemId }).pipe(Effect.flip);
694 assert.equal(refused.reason, "not_a_file_request");
695 assert.isTrue(valuesOf(stored).some((value) => value.includes("ghp_secret")));
696 }),
697 ),
698 );
699
700 it.effect("a pasted secret goes straight to an owner-only file, with no card", () =>
701 Effect.gen(function* () {
702 const fs = yield* FileSystem.FileSystem;
703 const path = yield* Path.Path;
704 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
705 const spans: Array<Tracer.NativeSpan> = [];
706 const tracer = Tracer.make({
707 span: (options) => {
708 const span = new Tracer.NativeSpan(options);
709 spans.push(span);
710 return span;
711 },
712 });
713 const pasted = "4829'$(id) 16";
714 const file = yield* withService(
715 ({ service, stored, dispatched }) =>
716 Effect.gen(function* () {
717 const file = yield* service.savePasted({
718 threadId,
719 requestNamespace: "session-a",
720 requestKey: "key-1",
721 value: pasted,
722 });
723 assert.equal(path.dirname(file), path.join(directory, "files"));
724 assert.match(path.basename(file), /^[0-9a-f]{32}$/);
725 assert.equal(yield* fs.readFileString(file), pasted);
726 if ((yield* HostProcess.Platform) !== "win32") {
727 assert.equal((yield* fs.stat(file)).mode & 0o777, 0o600);
728 assert.equal((yield* fs.stat(path.dirname(file))).mode & 0o777, 0o700);
729 }
730 // No card and no stored copy: the thread never hears of it.
731 assert.deepEqual(dispatched, []);
732 assert.deepEqual(valuesOf(stored), []);
733 // A retry with the same key gets the same file, unchanged even if the value differs.
734 assert.equal(
735 yield* service.savePasted({
736 threadId,
737 requestNamespace: "session-a",
738 requestKey: "key-1",
739 value: "other",
740 }),
741 file,
742 );
743 assert.equal(yield* fs.readFileString(file), pasted);
744 // Another key, or the same key from another provider session, gets its own file.
745 const other = yield* service.savePasted({
746 threadId,
747 requestNamespace: "session-a",
748 requestKey: "key-2",
749 value: "x",
750 });
751 assert.notEqual(other, file);
752 const otherSession = yield* service.savePasted({
753 threadId,
754 requestNamespace: "session-b",
755 requestKey: "key-1",
756 value: "y",
757 });
758 assert.notEqual(otherSession, file);
759 assert.equal(yield* fs.readFileString(file), pasted);
760 // Its name is not a ref to the value.
761 const ref = SecretRef.make(`secret-ref:${path.basename(file)}`);
762 const reused = yield* service.consume({ ref, projectId }).pipe(Effect.flip);
763 assert.equal(reused.reason, "ref_unavailable");
764 return file;
765 }).pipe(Effect.withTracer(tracer)),
766 { directory },
767 );
768 const recorded = spans.flatMap((span) => [
769 span.name,
770 ...Array.from(span.attributes.values(), String),
771 ]);
772 assert.include(recorded, "SecretRequests.savePasted");
773 assert.isFalse(recorded.some((value) => value.includes("4829")));
774
775 const { mtime } = yield* fs.stat(file);
776 yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS);
777 yield* withService(() => Effect.void, { directory });
778 assert.isTrue(yield* fs.exists(file));
779 yield* TestClock.setTime(Option.getOrThrow(mtime).getTime() + SECRET_FILE_TTL_MS + 1);
780 yield* withService(() => Effect.void, { directory });
781 assert.isFalse(yield* fs.exists(file));
782 }).pipe(Effect.provide(NodeServices.layer)),
783 );
784
785 it.effect("a pasted secret keeps its exact bytes from the tool input to the file", () =>
786 Effect.gen(function* () {
787 const fs = yield* FileSystem.FileSystem;
788 const directory = yield* fs.makeTempDirectoryScoped({ prefix: "secret-files-test-" });
789 const pasted = " pa ss\tword\t ";
790 const input = yield* decodeSecretInput({
791 label: "Staging password",
792 reason: "Signs in the QA account.",
793 value: pasted,
794 });
795 assert.equal(input.value, pasted);
796 const empty = decodeSecretInputExit({
797 label: "Staging password",
798 reason: "Signs in the QA account.",
799 value: "",
800 });
801 assert.isTrue(Exit.isFailure(empty));
802 for (const url of ["https://?state=x", "javascript:alert(1)"]) {
803 assert.isTrue(
804 Exit.isFailure(decodeSecretInputExit({ label: "Code", reason: "Sign in.", url })),
805 url,
806 );
807 }
808 const file = yield* withService(
809 ({ service }) =>
810 service.savePasted({
811 threadId,
812 requestNamespace: "session-a",
813 requestKey: "key-1",
814 value: input.value!,
815 }),
816 { directory },
817 );
818 assert.equal(yield* fs.readFileString(file), pasted);
819 }).pipe(Effect.provide(NodeServices.layer)),
820 );
821
822 it.effect("a pasted secret is refused without a secrets directory", () =>
823 withService(({ service }) =>
824 Effect.gen(function* () {
825 const failed = yield* service
826 .savePasted({ threadId, requestNamespace: "session-a", requestKey: "key-1", value: "4829" })
827 .pipe(Effect.flip);
828 assert.equal(failed.reason, "store_failed");
829 }),
830 ),
831 );