sailfork / t3code-github / apps/ server/ scripts/ record-pi-rpc-replay-fixture.ts
import { pipe } from "effect/Function";
import * as NodeServices from "@effect/platform-node/NodeServices";
import type { ProviderReplayEntry, ProviderReplayTranscript } from "@t3tools/contracts";
import * as Console from "effect/Console";
import * as DateTime from "effect/DateTime";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import { TestClock } from "effect/testing";
import { ChildProcess, ChildProcessSpawner } from "effect/process";
import {
makePiRecordingSpawner,
PI_REPLAY_ANY,
PI_RPC_REPLAY_PROTOCOL,
PiOrchestratorReplayHarness,
} from "../src/orchestration-v2/Adapters/PiAdapterV2.testkit.ts";
import * as PiAdapterV2Testkit from "../src/orchestration-v2/Adapters/PiAdapterV2.testkit.ts";
import { PI_PROVIDER } from "@t3tools/provider-pi/server";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import { provideDeterministicTestRuntime } from "../src/orchestration-v2/testkit/DeterministicRuntime.ts";
import { ORCHESTRATOR_REPLAY_FIXTURES } from "../src/orchestration-v2/testkit/fixtures/index.ts";
import { materializeFixtureInput } from "../src/orchestration-v2/testkit/fixtures/shared.ts";
import { runOrchestratorV2ProviderReplayScenario } from "../src/orchestration-v2/testkit/ProviderReplayHarness.ts";
import {
checkpointWorkspace,
makeCheckpointWorkspace,
} from "@t3tools/provider-testing/replayWorkspace";
// Exclude user context; --approve lets the throwaway workspace's `.pi/settings.json` load.
const HERMETIC_LAUNCH_ARGS =
"--no-extensions --no-skills --no-prompt-templates --no-context-files --approve";
// Pi excludes ~20k recent tokens from compaction; lower the budget for this short fixture.
const WORKSPACE_PI_SETTINGS = { compaction: { keepRecentTokens: 50 } };
const CLOCK_TICK = Duration.millis(20);
function readArgValue(name: string): string | undefined {
const index = process.argv.indexOf(name);
return index === -1 ? undefined : process.argv[index + 1];
}
const scenario = readArgValue("--scenario");
const fixture = ORCHESTRATOR_REPLAY_FIXTURES.find((entry) => entry.name === scenario);
const variant = fixture?.providers.find((provider) => provider.driver === PI_PROVIDER);
if (fixture === undefined || variant === undefined) {
const names = ORCHESTRATOR_REPLAY_FIXTURES.filter((entry) =>
entry.providers.some((provider) => provider.driver === PI_PROVIDER),
).map((entry) => entry.name);
throw new Error(`Pass --scenario with a fixture that registers Pi: ${names.join(", ")}`);
}
const piBinary = process.env.T3_PI_BIN ?? "pi";
const [modelProvider, ...modelId] = variant.modelSelection.model.split("/");
const launchArgs = `--provider ${modelProvider} --model ${modelId.join("/")} ${HERMETIC_LAUNCH_ARGS}`;
const home = process.env.HOME ?? "";
const UUID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/giu;
const ISO_TIMESTAMP_PATTERN = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/gu;
const NORMALIZED_EPOCH_MS = DateTime.toEpochMillis(DateTime.makeUnsafe("2026-01-01T00:00:00.000Z"));
function escapeRegExp(value: string): string {
return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\Loading Sailfork
amp;");
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
// Normalize both directions consistently so echoed paths, UUIDs and times still match on replay.
function normalizeEntries(input: {
readonly entries: ReadonlyArray<ProviderReplayEntry>;
readonly workspace: string;
readonly sessionDir: string;
readonly modelSlug: string;
}): ReadonlyArray<ProviderReplayEntry> {
const sessionFiles = new Map<string, string>();
const uuids = new Map<string, string>();
let timeAnchorMs: number | undefined;
const shiftTime = (ms: number): number => {
timeAnchorMs ??= ms;
return NORMALIZED_EPOCH_MS + (ms - timeAnchorMs);
};
const sessionFilePattern = new RegExp(
`${escapeRegExp(input.sessionDir)}/[^\\s"']+?\\.jsonl`,
"gu",
);
const normalizeString = (value: string): string =>
value
.replace(sessionFilePattern, (file) => {
const existing = sessionFiles.get(file);
if (existing !== undefined) return existing;
const next = `/pi-sessions/session-${sessionFiles.size + 1}.jsonl`;
sessionFiles.set(file, next);
return next;
})
.replaceAll(input.sessionDir, "/pi-sessions")
.replaceAll(input.workspace, "<workspace>")
.replaceAll(home.length > 1 ? home : "\0", "~")
.replace(ISO_TIMESTAMP_PATTERN, (iso) =>
pipe(
DateTime.makeUnsafe(iso),
DateTime.toEpochMillis,
shiftTime,
DateTime.makeUnsafe,
DateTime.formatIso,
),
)
.replace(UUID_PATTERN, (uuid) => {
const existing = uuids.get(uuid.toLowerCase());
if (existing !== undefined) return existing;
const next = `00000000-0000-4000-8000-${String(uuids.size + 1).padStart(12, "0")}`;
uuids.set(uuid.toLowerCase(), next);
return next;
});
const normalizeValue = (value: unknown): unknown => {
if (typeof value === "string") return normalizeString(value);
if (Array.isArray(value)) return value.map(normalizeValue);
if (!isRecord(value)) return value;
// Pi's unread system messages contain machine-specific context; retain only their shape.
if (value.role === "system" && isRecord(value.sections)) {
return {
...value,
sections: Object.fromEntries(
Object.keys(value.sections).map((key) => [key, "<system-prompt-section>"]),
),
};
}
return Object.fromEntries(
Object.entries(value).map(([key, entry]) => [
key,
key === "thinkingSignature" || key === "textSignature"
? "<signature>"
: key === "timestamp" && typeof entry === "number"
? shiftTime(entry)
: normalizeValue(entry),
]),
);
};
const normalizeFrame = (frame: unknown): unknown => {
if (!isRecord(frame)) return normalizeValue(frame);
const args = frame.args;
if (frame.type === "process_start" && Array.isArray(args)) {
return normalizeValue({
...frame,
args: args.map((arg, index) => (args[index - 1] === "--extension" ? PI_REPLAY_ANY : arg)),
});
}
const data = frame.data;
if (frame.command === "get_available_models" && isRecord(data) && Array.isArray(data.models)) {
return normalizeValue({
...frame,
data: {
...data,
models: data.models.filter(
(model) => isRecord(model) && `${model.provider}/${model.id}` === input.modelSlug,
),
},
});
}
return normalizeValue(frame);
};
return input.entries.map((entry) =>
entry.type === "runtime_exit" ? entry : { ...entry, frame: normalizeFrame(entry.frame) },
);
}
const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
function encodeTranscriptNdjson(transcript: ProviderReplayTranscript): string {
const { entries, ...metadata } = transcript;
return [
encodeJson({ type: "transcript_start", ...metadata }),
...entries.map((entry) => encodeJson(entry)),
"",
].join("\n");
}
// Follow wall time for live Pi timers while retaining replay's TestClock steps.
const followWallClock = Effect.gen(function* () {
while (true) {
yield* TestClock.withLive(Effect.sleep(CLOCK_TICK));
yield* TestClock.adjust(CLOCK_TICK);
}
});
const readPiVersion = Effect.gen(function* () {
const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
return (yield* spawner.string(ChildProcess.make(piBinary, ["--version"]))).trim();
});
const record = Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const piVersion = yield* readPiVersion;
const outputPath = readArgValue("--out") ?? (yield* path.fromFileUrl(variant.transcriptFile));
const fixtureInput = fixture.buildInput();
const workspace = yield* Effect.promise(() =>
makeCheckpointWorkspace(`pi-rpc-record-${fixture.name}`, fixtureInput.workspaceFiles),
);
yield* fs.makeDirectory(path.join(workspace, ".pi"));
yield* fs.writeFileString(
path.join(workspace, ".pi", "settings.json"),
encodeJson(WORKSPACE_PI_SETTINGS),
);
const sessionDir = yield* fs.makeTempDirectory({ prefix: `t3-pi-record-sessions-` });
yield* Effect.addFinalizer(() =>
Effect.all([
fs.remove(workspace, { recursive: true, force: true }),
fs.remove(sessionDir, { recursive: true, force: true }),
]).pipe(Effect.ignore),
);
const entries: Array<ProviderReplayEntry> = [];
const placeholder: ProviderReplayTranscript = {
provider: PI_PROVIDER,
protocol: PI_RPC_REPLAY_PROTOCOL,
version: piVersion,
scenario: fixture.name,
entries: [],
};
const layerRecordingSpawner = Layer.effect(
ChildProcessSpawner.ChildProcessSpawner,
Effect.map(Effect.service(ChildProcessSpawner.ChildProcessSpawner), (live) =>
makePiRecordingSpawner(live, entries),
),
).pipe(Layer.provide(NodeServices.layer));
const materializeInput = materializeFixtureInput({
scenario: fixture.name,
fixtureInput,
driver: variant.driver,
modelSelection: variant.modelSelection,
}).pipe(Effect.provide(IdAllocator.layer));
const continuationOptions =
variant.runContinuationWorker === true ? { runContinuationWorker: true } : {};
yield* Effect.gen(function* () {
yield* followWallClock.pipe(Effect.forkScoped);
const materialized = yield* materializeInput;
yield* runOrchestratorV2ProviderReplayScenario(
{
name: `${fixture.name}/pi:record`,
transcript: placeholder,
commands: materialized.commands,
steps: materialized.steps,
projectionThreadIds: materialized.projectionThreadIds,
runtimePolicyOverride: { ...variant.runtimePolicyOverride, cwd: workspace },
},
{
driver: PI_PROVIDER,
decodeTranscript: Effect.succeed,
makeProviderAdapterRegistryLayer: () =>
PiAdapterV2Testkit.layer({
scenario: fixture.name,
binaryPath: piBinary,
launchArgs,
environment: [
{ name: "PI_CODING_AGENT_SESSION_DIR", value: sessionDir, sensitive: false },
{ name: "PI_SKIP_VERSION_CHECK", value: "1", sensitive: false },
],
spawner: layerRecordingSpawner,
}),
},
continuationOptions,
);
}).pipe(Effect.scoped, provideDeterministicTestRuntime);
const transcript = {
...placeholder,
metadata: {
generatedBy: "live-pi-recorder",
piVersion,
model: variant.modelSelection.model,
launchArgs,
},
entries: normalizeEntries({
entries,
workspace,
sessionDir,
modelSlug: variant.modelSelection.model,
}),
} satisfies ProviderReplayTranscript;
// Assert on normalized replay; the live projection has raw paths. Failed assertions preserve the fixture.
yield* Effect.gen(function* () {
const replayWorkspace = yield* checkpointWorkspace(fixture.name, fixtureInput.workspaceFiles);
const materialized = yield* materializeInput;
const replayResult = yield* runOrchestratorV2ProviderReplayScenario(
{
name: `${fixture.name}/pi:verify`,
transcript: yield* PiOrchestratorReplayHarness.decodeTranscript(transcript),
commands: materialized.commands,
steps: materialized.steps,
projectionThreadIds: materialized.projectionThreadIds,
runtimePolicyOverride: { ...variant.runtimePolicyOverride, cwd: replayWorkspace },
},
PiOrchestratorReplayHarness,
continuationOptions,
);
variant.assertOutput(replayResult, transcript);
}).pipe(Effect.scoped, provideDeterministicTestRuntime);
yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
yield* fs.writeFileString(outputPath, encodeTranscriptNdjson(transcript));
yield* Console.log(`Wrote ${transcript.entries.length} Pi RPC replay entries to ${outputPath}`);
});
await Effect.runPromise(record.pipe(Effect.scoped, Effect.provide(NodeServices.layer)));