@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 568 lines 21.3 KB
Raw
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 import * as Console from "effect/Console";
3 import * as Effect from "effect/Effect";
4 import * as FileSystem from "effect/FileSystem";
5 import * as Path from "effect/Path";
6 import * as Schema from "effect/Schema";
7
8 import {
9 recordClaudeAgentSdkReplayTranscript,
10 CLAUDE_AGENT_SDK_REPLAY_PROTOCOL,
11 } from "../src/orchestration-v2/Adapters/ClaudeAdapterV2.testkit.ts";
12 import { claudeRuntimeQueryPolicyForRuntimePolicy } from "../src/orchestration-v2/Adapters/ClaudeAdapterV2.ts";
13 import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
14 import type { RuntimePolicyV2Override } from "../src/orchestration-v2/RuntimePolicy.ts";
15 import { makeCheckpointWorkspace } from "@t3tools/provider-testing/replayWorkspace";
16 import { CLAUDE_MODEL_SELECTION } from "../src/orchestration-v2/testkit/fixtures/shared.ts";
17 import {
18 MESSAGE_STEERING_INITIAL_PROMPT,
19 MULTI_TURN_FIRST_PROMPT,
20 MESSAGE_STEERING_STEER_PROMPT,
21 READ_ONLY_NEVER_POLICY,
22 READ_ONLY_ON_REQUEST_POLICY,
23 RESTRICTED_GRANULAR_POLICY,
24 MULTI_TURN_SECOND_PROMPT,
25 SIMPLE_PROMPT,
26 SUBAGENT_PROMPT,
27 THREAD_FORK_NATIVE_PRIOR_TURN_ALPHA_PROMPT,
28 THREAD_FORK_NATIVE_PRIOR_TURN_BETA_PROMPT,
29 THREAD_FORK_NATIVE_PRIOR_TURN_REPEAT_PROMPT,
30 THREAD_FORK_NATIVE_SOURCE_PROMPT,
31 THREAD_FORK_NATIVE_TARGET_PROMPT,
32 THREAD_MERGE_BACK_SIBLINGS_FIRST_FORK_PROMPT,
33 THREAD_MERGE_BACK_SIBLINGS_FIRST_HANDOFF_PROMPT,
34 THREAD_MERGE_BACK_SIBLINGS_RECALL_PROMPT,
35 THREAD_MERGE_BACK_SIBLINGS_SECOND_FORK_PROMPT,
36 THREAD_MERGE_BACK_SIBLINGS_SECOND_HANDOFF_PROMPT,
37 THREAD_MERGE_BACK_SIBLINGS_SOURCE_PROMPT,
38 THREAD_ROLLBACK_AFTER_PROMPT,
39 THREAD_ROLLBACK_FIRST_PROMPT,
40 THREAD_ROLLBACK_SECOND_PROMPT,
41 TOOL_CALL_READ_ONLY_PROMPT,
42 TOOL_CALL_READ_ONLY_WORKSPACE_ROOT,
43 TOOL_CALL_WRITE_PROMPT,
44 TURN_INTERRUPT_MID_TOOL_PROMPT,
45 COMMAND_OUTPUT_STREAMING_PROMPT,
46 TURN_INTERRUPT_PROMPT,
47 TURN_INTERRUPT_RECOVERY_PROMPT,
48 WORKSPACE_NEVER_POLICY,
49 WEB_SEARCH_PROMPT,
50 } from "../src/orchestration-v2/testkit/fixtures/shared.ts";
51 import { CLAUDE_BACKGROUND_SUBAGENT_AFTER_ROOT_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_background_subagent_after_root/input.ts";
52 import {
53 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_FINAL_PROMPT,
54 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_LAUNCH_PROMPT,
55 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_RESUME_PROMPT,
56 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_STOP_PROMPT,
57 } from "../src/orchestration-v2/testkit/fixtures/claude_background_subagent_lifecycle/input.ts";
58 import { CLAUDE_BACKGROUND_MONITOR_WAKE_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_background_monitor_wake/input.ts";
59 import { CLAUDE_NESTED_BACKGROUND_SUBAGENT_WAKE_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_nested_background_subagent_wake/input.ts";
60 import { CLAUDE_NESTED_SUBAGENT_MODEL_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_nested_subagent_model/input.ts";
61 import { CLAUDE_MCP_TOOL_PRESENTATION_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_mcp_tool_presentation/input.ts";
62 import { CLAUDE_BACKGROUND_TASK_INTERRUPT_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_background_task_interrupt/input.ts";
63 import { CLAUDE_BACKGROUND_WAKE_BEFORE_QUEUED_PROMPT_LAUNCH_PROMPT } from "../src/orchestration-v2/testkit/fixtures/claude_background_wake_before_queued_prompt/input.ts";
64 import {
65 CLAUDE_BACKGROUND_TASK_WAKE_FOLLOW_UP_PROMPT,
66 CLAUDE_BACKGROUND_TASK_WAKE_PROMPT,
67 } from "../src/orchestration-v2/testkit/fixtures/claude_background_task_wake/input.ts";
68 import {
69 DENIED_WRITE_POLICY,
70 TOOL_CALL_DENIED_WRITE_PROMPT,
71 TOOL_CALL_DENIED_WRITE_TARGET,
72 } from "../src/orchestration-v2/testkit/fixtures/tool_call_denied_write/input.ts";
73 import {
74 validateClaudeReplayRecordingSelection,
75 type ClaudeRecordingQueryMode,
76 } from "./claudeReplayRecordingConfig.ts";
77
78 const CLAUDE_RECORDINGS = {
79 simple: {
80 prompts: [SIMPLE_PROMPT],
81 defaultTranscriptFile: "fixtures/simple/claude_transcript.ndjson",
82 queryMode: "streaming",
83 enableTools: true,
84 },
85 // Record with ANTHROPIC_BASE_URL at a CLIProxyAPI hub whose upstream accounts answer 429.
86 usage_limit: {
87 prompts: [SIMPLE_PROMPT],
88 defaultTranscriptFile: "fixtures/usage_limit/claude_transcript.ndjson",
89 queryMode: "streaming",
90 enableTools: true,
91 },
92 multi_turn: {
93 prompts: [MULTI_TURN_FIRST_PROMPT, MULTI_TURN_SECOND_PROMPT],
94 defaultTranscriptFile: "fixtures/multi_turn/claude_transcript.ndjson",
95 queryMode: "streaming",
96 enableTools: true,
97 },
98 multi_turn_restart: {
99 prompts: [MULTI_TURN_FIRST_PROMPT, MULTI_TURN_SECOND_PROMPT],
100 defaultTranscriptFile: "fixtures/multi_turn_restart/claude_transcript.ndjson",
101 queryMode: "restart",
102 enableTools: true,
103 },
104 queued_turn: {
105 prompts: [MULTI_TURN_FIRST_PROMPT, MULTI_TURN_SECOND_PROMPT],
106 defaultTranscriptFile: "fixtures/queued_turn/claude_transcript.ndjson",
107 queryMode: "streaming",
108 enableTools: true,
109 },
110 message_steering: {
111 prompts: [MESSAGE_STEERING_INITIAL_PROMPT, MESSAGE_STEERING_STEER_PROMPT],
112 defaultTranscriptFile: "fixtures/message_steering/claude_transcript.ndjson",
113 queryMode: "active_steering",
114 enableTools: true,
115 },
116 command_output_streaming: {
117 prompts: [COMMAND_OUTPUT_STREAMING_PROMPT],
118 defaultTranscriptFile: "fixtures/command_output_streaming/claude_transcript.ndjson",
119 queryMode: "streaming",
120 enableTools: true,
121 },
122 turn_interrupt_mid_tool: {
123 prompts: [TURN_INTERRUPT_MID_TOOL_PROMPT],
124 defaultTranscriptFile: "fixtures/turn_interrupt_mid_tool/claude_transcript.ndjson",
125 queryMode: "interrupt",
126 enableTools: true,
127 interruptAfter: "tool_use",
128 },
129 turn_interrupt: {
130 prompts: [TURN_INTERRUPT_PROMPT],
131 defaultTranscriptFile: "fixtures/turn_interrupt/claude_transcript.ndjson",
132 queryMode: "interrupt",
133 enableTools: true,
134 },
135 turn_interrupt_restart: {
136 prompts: [TURN_INTERRUPT_MID_TOOL_PROMPT, TURN_INTERRUPT_RECOVERY_PROMPT],
137 defaultTranscriptFile: "fixtures/turn_interrupt_restart/claude_transcript.ndjson",
138 queryMode: "interrupt_restart",
139 enableTools: true,
140 interruptAfter: "tool_use",
141 },
142 tool_call_read_only: {
143 prompts: [TOOL_CALL_READ_ONLY_PROMPT],
144 defaultTranscriptFile: "fixtures/tool_call_read_only/claude_transcript.ndjson",
145 queryMode: "streaming",
146 enableTools: true,
147 runtimePolicyOverride: READ_ONLY_NEVER_POLICY,
148 },
149 tool_call_read_only_on_request: {
150 prompts: [TOOL_CALL_WRITE_PROMPT],
151 defaultTranscriptFile: "fixtures/tool_call_read_only_on_request/claude_transcript.ndjson",
152 queryMode: "streaming",
153 enableTools: true,
154 runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY,
155 },
156 tool_call_workspace_never: {
157 prompts: [TOOL_CALL_WRITE_PROMPT],
158 defaultTranscriptFile: "fixtures/tool_call_workspace_never/claude_transcript.ndjson",
159 queryMode: "streaming",
160 enableTools: true,
161 runtimePolicyOverride: WORKSPACE_NEVER_POLICY,
162 },
163 tool_call_denied_write: {
164 prompts: [TOOL_CALL_DENIED_WRITE_PROMPT],
165 defaultTranscriptFile: "fixtures/tool_call_denied_write/claude_transcript.ndjson",
166 queryMode: "streaming",
167 enableTools: true,
168 runtimePolicyOverride: DENIED_WRITE_POLICY,
169 permissionDecision: "decline",
170 expectedAbsentWorkspacePaths: [TOOL_CALL_DENIED_WRITE_TARGET],
171 },
172 tool_call_restricted_granular: {
173 prompts: [TOOL_CALL_WRITE_PROMPT],
174 defaultTranscriptFile: "fixtures/tool_call_restricted_granular/claude_transcript.ndjson",
175 queryMode: "streaming",
176 enableTools: true,
177 runtimePolicyOverride: RESTRICTED_GRANULAR_POLICY,
178 },
179 web_search: {
180 prompts: [WEB_SEARCH_PROMPT],
181 defaultTranscriptFile: "fixtures/web_search/claude_transcript.ndjson",
182 queryMode: "streaming",
183 enableTools: true,
184 },
185 claude_background_subagent_after_root: {
186 prompts: [CLAUDE_BACKGROUND_SUBAGENT_AFTER_ROOT_PROMPT],
187 defaultTranscriptFile:
188 "fixtures/claude_background_subagent_after_root/claude_transcript.ndjson",
189 queryMode: "streaming",
190 enableTools: true,
191 backgroundWakeCounts: [1],
192 },
193 claude_background_task_wake: {
194 prompts: [CLAUDE_BACKGROUND_TASK_WAKE_PROMPT, CLAUDE_BACKGROUND_TASK_WAKE_FOLLOW_UP_PROMPT],
195 defaultTranscriptFile: "fixtures/claude_background_task_wake/claude_transcript.ndjson",
196 queryMode: "streaming",
197 enableTools: true,
198 backgroundWakeCounts: [1, 0],
199 },
200 claude_background_monitor_wake: {
201 prompts: [CLAUDE_BACKGROUND_MONITOR_WAKE_PROMPT],
202 defaultTranscriptFile: "fixtures/claude_background_monitor_wake/claude_transcript.ndjson",
203 queryMode: "streaming",
204 enableTools: true,
205 backgroundWakeCounts: [1],
206 },
207 claude_background_subagent_lifecycle: {
208 prompts: [
209 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_LAUNCH_PROMPT,
210 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_STOP_PROMPT,
211 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_RESUME_PROMPT,
212 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_FINAL_PROMPT,
213 ],
214 defaultTranscriptFile: "fixtures/claude_background_subagent_lifecycle/claude_transcript.ndjson",
215 queryMode: "streaming",
216 enableTools: true,
217 backgroundWakeCounts: [1, 0, 1, 0],
218 },
219 claude_background_wake_before_queued_prompt: {
220 prompts: [
221 CLAUDE_BACKGROUND_WAKE_BEFORE_QUEUED_PROMPT_LAUNCH_PROMPT,
222 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_STOP_PROMPT,
223 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_RESUME_PROMPT,
224 CLAUDE_BACKGROUND_SUBAGENT_LIFECYCLE_FINAL_PROMPT,
225 ],
226 defaultTranscriptFile:
227 "fixtures/claude_background_wake_before_queued_prompt/claude_transcript.ndjson",
228 queryMode: "streaming",
229 enableTools: true,
230 backgroundWakeCounts: [1, 0, 1, 0],
231 offerNextPromptImmediately: true,
232 },
233 claude_background_task_interrupt: {
234 prompts: [CLAUDE_BACKGROUND_TASK_INTERRUPT_PROMPT],
235 defaultTranscriptFile: "fixtures/claude_background_task_interrupt/claude_transcript.ndjson",
236 queryMode: "interrupt",
237 enableTools: true,
238 interruptAfter: "tool_use",
239 interruptAfterToolUses: 2,
240 },
241 claude_nested_background_subagent_wake: {
242 prompts: [CLAUDE_NESTED_BACKGROUND_SUBAGENT_WAKE_PROMPT],
243 defaultTranscriptFile:
244 "fixtures/claude_nested_background_subagent_wake/claude_transcript.ndjson",
245 queryMode: "streaming",
246 enableTools: true,
247 backgroundWakeCounts: [1],
248 },
249 claude_nested_subagent_model: {
250 prompts: [CLAUDE_NESTED_SUBAGENT_MODEL_PROMPT],
251 defaultTranscriptFile: "fixtures/claude_nested_subagent_model/claude_transcript.ndjson",
252 queryMode: "streaming",
253 enableTools: true,
254 },
255 // Requires the recording account's claude.ai Firecrawl connector; MCP metadata uses undeclared `tool_use_meta`.
256 claude_mcp_tool_presentation: {
257 prompts: [CLAUDE_MCP_TOOL_PRESENTATION_PROMPT],
258 defaultTranscriptFile: "fixtures/claude_mcp_tool_presentation/claude_transcript.ndjson",
259 queryMode: "streaming",
260 enableTools: true,
261 },
262 subagent: {
263 prompts: [SUBAGENT_PROMPT],
264 defaultTranscriptFile: "fixtures/subagent/claude_transcript.ndjson",
265 queryMode: "streaming",
266 enableTools: true,
267 },
268 thread_rollback: {
269 prompts: [
270 THREAD_ROLLBACK_FIRST_PROMPT,
271 THREAD_ROLLBACK_SECOND_PROMPT,
272 THREAD_ROLLBACK_AFTER_PROMPT,
273 ],
274 defaultTranscriptFile: "fixtures/thread_rollback/claude_transcript.ndjson",
275 queryMode: "resume_at_cursor",
276 enableTools: true,
277 },
278 thread_fork_native: {
279 prompts: [THREAD_FORK_NATIVE_SOURCE_PROMPT, THREAD_FORK_NATIVE_TARGET_PROMPT],
280 defaultTranscriptFile: "fixtures/thread_fork_native/claude_transcript.ndjson",
281 queryMode: "fork_session",
282 enableTools: true,
283 },
284 thread_fork_native_prior_turn: {
285 prompts: [
286 THREAD_FORK_NATIVE_PRIOR_TURN_ALPHA_PROMPT,
287 THREAD_FORK_NATIVE_PRIOR_TURN_BETA_PROMPT,
288 THREAD_FORK_NATIVE_PRIOR_TURN_REPEAT_PROMPT,
289 ],
290 defaultTranscriptFile: "fixtures/thread_fork_native_prior_turn/claude_transcript.ndjson",
291 queryMode: "fork_session_prior_turn",
292 enableTools: true,
293 },
294 thread_merge_back_siblings: {
295 prompts: [
296 THREAD_MERGE_BACK_SIBLINGS_SOURCE_PROMPT,
297 THREAD_MERGE_BACK_SIBLINGS_FIRST_FORK_PROMPT,
298 THREAD_MERGE_BACK_SIBLINGS_SECOND_FORK_PROMPT,
299 THREAD_MERGE_BACK_SIBLINGS_FIRST_HANDOFF_PROMPT,
300 THREAD_MERGE_BACK_SIBLINGS_SECOND_HANDOFF_PROMPT,
301 THREAD_MERGE_BACK_SIBLINGS_RECALL_PROMPT,
302 ],
303 defaultTranscriptFile: "fixtures/thread_merge_back_siblings/claude_transcript.ndjson",
304 queryMode: "fork_session_merge_back_siblings",
305 enableTools: true,
306 },
307 } as const;
308
309 function readArgValue(name: string): string | undefined {
310 const args = process.argv.slice(2);
311 const index = args.indexOf(name);
312 return index >= 0 ? args[index + 1] : undefined;
313 }
314
315 function selectedQueryMode(defaultMode: ClaudeRecordingQueryMode): ClaudeRecordingQueryMode {
316 const raw = readArgValue("--query-mode") ?? process.env.T3_CLAUDE_REPLAY_QUERY_MODE;
317 if (raw === undefined) {
318 return defaultMode;
319 }
320 if (
321 raw === "streaming" ||
322 raw === "restart" ||
323 raw === "resume_at_cursor" ||
324 raw === "fork_session" ||
325 raw === "fork_session_prior_turn" ||
326 raw === "fork_session_merge_back_siblings" ||
327 raw === "active_steering" ||
328 raw === "interrupt" ||
329 raw === "interrupt_restart"
330 ) {
331 return raw;
332 }
333 throw new Error(
334 `Unsupported Claude replay query mode '${raw}'. Use 'streaming', 'restart', 'resume_at_cursor', 'fork_session', 'fork_session_prior_turn', 'fork_session_merge_back_siblings', 'active_steering', 'interrupt', or 'interrupt_restart'.`,
335 );
336 }
337
338 const scenario = readArgValue("--scenario") ?? process.env.T3_CLAUDE_REPLAY_SCENARIO ?? "simple";
339 const recording = CLAUDE_RECORDINGS[scenario as keyof typeof CLAUDE_RECORDINGS];
340 const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
341
342 if (recording === undefined) {
343 throw new Error(`Claude replay fixture '${scenario}' is not configured.`);
344 }
345
346 const positionalOutputPath = process.argv[2]?.startsWith("--") ? undefined : process.argv[2];
347 const path = await Effect.runPromise(
348 Effect.service(Path.Path).pipe(Effect.provide(NodeServices.layer)),
349 );
350 const outputPath =
351 readArgValue("--out") ??
352 positionalOutputPath ??
353 (await Effect.runPromise(
354 path.fromFileUrl(
355 new URL(
356 `../src/orchestration-v2/testkit/${recording.defaultTranscriptFile}`,
357 import.meta.url,
358 ),
359 ),
360 ));
361
362 function encodeTranscriptNdjson(
363 transcript: Awaited<ReturnType<typeof recordClaudeAgentSdkReplayTranscript>>,
364 ): string {
365 const { entries, ...metadata } = transcript;
366 return [
367 JSON.stringify({ type: "transcript_start", ...metadata }),
368 ...entries.map((entry) => JSON.stringify(entry)),
369 "",
370 ].join("\n");
371 }
372
373 function joinPath(directory: string, fileName: string): string {
374 return `${directory.replace(/\/+$/u, "")}/${fileName.replace(/^\/+/u, "")}`;
375 }
376
377 function runFileSystem<A, E>(effect: Effect.Effect<A, E, FileSystem.FileSystem>): Promise<A> {
378 return Effect.runPromise(effect.pipe(Effect.provide(NodeServices.layer)));
379 }
380
381 function selectedPrompts(): ReadonlyArray<string> {
382 if (process.env.T3_CLAUDE_REPLAY_PROMPTS !== undefined) {
383 return process.env.T3_CLAUDE_REPLAY_PROMPTS.split("\n---\n").filter(
384 (prompt) => prompt.length > 0,
385 );
386 }
387 if (process.env.T3_CLAUDE_REPLAY_PROMPT !== undefined) {
388 return [process.env.T3_CLAUDE_REPLAY_PROMPT];
389 }
390 return recording.prompts;
391 }
392
393 const prompts = selectedPrompts();
394 const queryMode = selectedQueryMode(recording.queryMode);
395 validateClaudeReplayRecordingSelection({
396 scenario,
397 configuredQueryMode: recording.queryMode,
398 selectedQueryMode: queryMode,
399 configuredPromptCount: recording.prompts.length,
400 selectedPromptCount: prompts.length,
401 });
402
403 function runtimePolicyForRecording(input: {
404 readonly cwd: string;
405 readonly override?: RuntimePolicyV2Override;
406 }): ProviderAdapter.ProviderAdapterV2RuntimePolicy {
407 return ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
408 runtimeMode: "full-access",
409 interactionMode: "default",
410 cwd: input.override?.cwd ?? input.cwd,
411 ...(input.override?.approvalPolicy === undefined
412 ? {}
413 : { approvalPolicy: input.override.approvalPolicy }),
414 ...(input.override?.sandboxPolicy === undefined
415 ? {}
416 : { sandboxPolicy: input.override.sandboxPolicy }),
417 ...(input.override?.reasoningEffort === undefined
418 ? {}
419 : { reasoningEffort: input.override.reasoningEffort }),
420 });
421 }
422
423 async function makeToolCallReadOnlyRecordingWorkspace(): Promise<string> {
424 await runFileSystem(
425 Effect.gen(function* () {
426 const fs = yield* FileSystem.FileSystem;
427 yield* fs.remove(TOOL_CALL_READ_ONLY_WORKSPACE_ROOT, { recursive: true, force: true });
428 yield* fs.makeDirectory(TOOL_CALL_READ_ONLY_WORKSPACE_ROOT, { recursive: true });
429 }),
430 );
431 return TOOL_CALL_READ_ONLY_WORKSPACE_ROOT;
432 }
433
434 const cwd =
435 process.env.T3_CLAUDE_REPLAY_CWD ??
436 (scenario === "tool_call_read_only"
437 ? await makeToolCallReadOnlyRecordingWorkspace()
438 : await makeCheckpointWorkspace(`claude-agent-sdk-record-${scenario}`));
439 const shouldRemoveCwd = process.env.T3_CLAUDE_REPLAY_CWD === undefined;
440
441 const expectedAbsentWorkspacePaths =
442 "expectedAbsentWorkspacePaths" in recording ? recording.expectedAbsentWorkspacePaths : [];
443
444 async function assertWorkspacePathsAbsent(phase: "before" | "after"): Promise<void> {
445 const presentPaths = await runFileSystem(
446 Effect.gen(function* () {
447 const fs = yield* FileSystem.FileSystem;
448 const present: Array<string> = [];
449 for (const relativePath of expectedAbsentWorkspacePaths) {
450 if (yield* fs.exists(joinPath(cwd, relativePath))) {
451 present.push(relativePath);
452 }
453 }
454 return present;
455 }),
456 );
457 if (presentPaths.length > 0) {
458 throw new Error(
459 `Claude replay fixture '${scenario}' expected ${presentPaths
460 .map((relativePath) => `'${relativePath}'`)
461 .join(
462 ", ",
463 )} to be absent ${phase} the recorded turn, but found in the recording workspace.`,
464 );
465 }
466 }
467
468 if (shouldRemoveCwd && (scenario === "tool_call_read_only" || scenario === "subagent")) {
469 await runFileSystem(
470 Effect.gen(function* () {
471 const fs = yield* FileSystem.FileSystem;
472 yield* fs.writeFileString(
473 joinPath(cwd, "package.json"),
474 encodeUnknownJsonString({
475 name: "claude-read-only-fixture",
476 private: true,
477 scripts: { typecheck: "tsc --noEmit" },
478 }),
479 );
480 yield* fs.writeFileString(
481 joinPath(cwd, "tsconfig.json"),
482 encodeUnknownJsonString({
483 compilerOptions: {
484 module: "ESNext",
485 strict: true,
486 target: "ES2022",
487 },
488 }),
489 );
490 }),
491 );
492 }
493
494 try {
495 const runtimePolicy = runtimePolicyForRecording({
496 cwd,
497 ...("runtimePolicyOverride" in recording ? { override: recording.runtimePolicyOverride } : {}),
498 });
499 const queryPolicy = claudeRuntimeQueryPolicyForRuntimePolicy(runtimePolicy);
500
501 await assertWorkspacePathsAbsent("before");
502 const transcript = await recordClaudeAgentSdkReplayTranscript({
503 scenario,
504 prompts,
505 modelSelection: {
506 ...CLAUDE_MODEL_SELECTION,
507 model: process.env.T3_CLAUDE_REPLAY_MODEL ?? CLAUDE_MODEL_SELECTION.model,
508 },
509 cwd,
510 ...(process.env.T3_CLAUDE_REPLAY_SESSION_ID === undefined
511 ? {}
512 : { sessionId: process.env.T3_CLAUDE_REPLAY_SESSION_ID }),
513 queryMode,
514 ...("enableTools" in recording && recording.enableTools === true ? { enableTools: true } : {}),
515 ...(queryPolicy.tools === undefined ? {} : { tools: queryPolicy.tools }),
516 permissionMode: queryPolicy.permissionMode,
517 ...(queryPolicy.allowedTools === undefined ? {} : { allowedTools: queryPolicy.allowedTools }),
518 ...(queryPolicy.allowDangerouslySkipPermissions === undefined
519 ? {}
520 : { allowDangerouslySkipPermissions: queryPolicy.allowDangerouslySkipPermissions }),
521 ...(queryPolicy.installPermissionCallback ? { enablePermissionCallback: true } : {}),
522 ...("permissionDecision" in recording
523 ? { permissionDecision: recording.permissionDecision }
524 : {}),
525 ...("interruptAfter" in recording ? { interruptAfter: recording.interruptAfter } : {}),
526 ...("interruptAfterToolUses" in recording
527 ? { interruptAfterToolUses: recording.interruptAfterToolUses }
528 : {}),
529 ...("backgroundWakeCounts" in recording
530 ? { backgroundWakeCounts: recording.backgroundWakeCounts }
531 : {}),
532 ...("offerNextPromptImmediately" in recording
533 ? { offerNextPromptImmediately: recording.offerNextPromptImmediately }
534 : {}),
535 });
536 await assertWorkspacePathsAbsent("after");
537 const transcriptWithEvidence =
538 expectedAbsentWorkspacePaths.length === 0
539 ? transcript
540 : {
541 ...transcript,
542 metadata: {
543 ...transcript.metadata,
544 verifiedAbsentWorkspacePaths: [...expectedAbsentWorkspacePaths],
545 },
546 };
547 await runFileSystem(
548 Effect.gen(function* () {
549 const fs = yield* FileSystem.FileSystem;
550 yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
551 yield* fs.writeFileString(outputPath, encodeTranscriptNdjson(transcriptWithEvidence));
552 }),
553 );
554 await Effect.runPromise(
555 Console.log(
556 `Wrote ${transcript.entries.length} ${CLAUDE_AGENT_SDK_REPLAY_PROTOCOL} replay entries to ${outputPath}`,
557 ),
558 );
559 } finally {
560 if (shouldRemoveCwd) {
561 await runFileSystem(
562 Effect.gen(function* () {
563 const fs = yield* FileSystem.FileSystem;
564 yield* fs.remove(cwd, { recursive: true, force: true });
565 }),
566 );
567 }
568 }