The best way to control Claude Code, Codex and more from any computer or phone
| 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 | } |