authorgravatar for julius0216@outlook.comJulius Marminge <julius0216@outlook.com> 2026-06-20 11:57:48-07:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2026-06-20 11:57:48-07:00
log97487d9959554854698bf92e672b758e2c3fdeab
tree5b789ec44692ec5b3fdbb276fb79e1feb917bbcd
parentd2e38c53735718cee17c7aeb58f6c71be24bf435
signature Signed by PGP key B5690EEEBB952194

[codex] Structure reference repo sync failures (#3281)

Co-authored-by: codex <codex@users.noreply.github.com>

2 files changed, 241 insertions(+), 46 deletions(-)

scripts/sync-reference-repos.test.ts+131-9
...@@ -19,16 +19,22 @@ const encoder = new TextEncoder();...@@ -19,16 +19,22 @@ const encoder = new TextEncoder();
19const effectSmol = referenceRepos[0]!;19const effectSmol = referenceRepos[0]!;
20const alchemyEffect = referenceRepos[1]!;20const alchemyEffect = referenceRepos[1]!;
2121
22function mockHandle() {22function mockHandle(
23 options: {
24 readonly exitCode?: number;
25 readonly stdout?: string;
26 readonly stderr?: string;
27 } = {},
28) {
23 return ChildProcessSpawner.makeHandle({29 return ChildProcessSpawner.makeHandle({
24 pid: ChildProcessSpawner.ProcessId(1),30 pid: ChildProcessSpawner.ProcessId(1),
25 exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),31 exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(options.exitCode ?? 0)),
26 isRunning: Effect.succeed(false),32 isRunning: Effect.succeed(false),
27 kill: () => Effect.void,33 kill: () => Effect.void,
28 unref: Effect.succeed(Effect.void),34 unref: Effect.succeed(Effect.void),
29 stdin: Sink.drain,35 stdin: Sink.drain,
30 stdout: Stream.make(encoder.encode("done\n")),36 stdout: Stream.make(encoder.encode(options.stdout ?? "done\n")),
31 stderr: Stream.empty,37 stderr: Stream.make(encoder.encode(options.stderr ?? "")),
32 all: Stream.empty,38 all: Stream.empty,
33 getInputFd: () => Sink.drain,39 getInputFd: () => Sink.drain,
34 getOutputFd: () => Stream.empty,40 getOutputFd: () => Stream.empty,
...@@ -37,6 +43,7 @@ function mockHandle() {...@@ -37,6 +43,7 @@ function mockHandle() {
3743
38function mockSpawnerLayer(44function mockSpawnerLayer(
39 commands: Array<{ readonly command: string; readonly args: ReadonlyArray<string> }>,45 commands: Array<{ readonly command: string; readonly args: ReadonlyArray<string> }>,
46 handle = mockHandle(),
40) {47) {
41 return Layer.succeed(48 return Layer.succeed(
42 ChildProcessSpawner.ChildProcessSpawner,49 ChildProcessSpawner.ChildProcessSpawner,
...@@ -49,7 +56,7 @@ function mockSpawnerLayer(...@@ -49,7 +56,7 @@ function mockSpawnerLayer(
49 command: childProcess.command,56 command: childProcess.command,
50 args: childProcess.args,57 args: childProcess.args,
51 });58 });
52 return Effect.succeed(mockHandle());59 return Effect.succeed(handle);
53 }),60 }),
54 );61 );
55}62}
...@@ -85,6 +92,75 @@ it.layer(NodeServices.layer)("sync-reference-repos", (it) => {...@@ -85,6 +92,75 @@ it.layer(NodeServices.layer)("sync-reference-repos", (it) => {
85 }),92 }),
86 );93 );
8794
95 it.effect("preserves version source read context and the filesystem cause", () =>
96 Effect.gen(function* () {
97 const fs = yield* FileSystem.FileSystem;
98 const path = yield* Path.Path;
99 const rootDir = yield* fs.makeTempDirectoryScoped({
100 prefix: "sync-reference-repos-read-error-",
101 });
102 const sourcePath = path.join(rootDir, effectSmol.versionSourcePath);
103
104 const error = yield* resolveReferenceRepoRef(effectSmol, rootDir, false).pipe(Effect.flip);
105
106 if (error._tag !== "ReferenceRepoVersionSourceError") {
107 assert.fail(`Unexpected error: ${error._tag}`);
108 }
109 assert.equal(error.operation, "read");
110 assert.equal(error.repoId, effectSmol.id);
111 assert.equal(error.sourcePath, sourcePath);
112 assert.ok(error.cause !== undefined);
113 assert.ok(!error.message.includes(String((error.cause as Error).message)));
114 }),
115 );
116
117 it.effect("preserves version source parse context and the schema cause", () =>
118 Effect.gen(function* () {
119 const fs = yield* FileSystem.FileSystem;
120 const path = yield* Path.Path;
121 const rootDir = yield* fs.makeTempDirectoryScoped({
122 prefix: "sync-reference-repos-parse-error-",
123 });
124 const sourcePath = path.join(rootDir, alchemyEffect.versionSourcePath);
125 yield* fs.makeDirectory(path.dirname(sourcePath), { recursive: true });
126 yield* fs.writeFileString(sourcePath, "{");
127
128 const error = yield* resolveReferenceRepoRef(alchemyEffect, rootDir, false).pipe(Effect.flip);
129
130 if (error._tag !== "ReferenceRepoVersionSourceError") {
131 assert.fail(`Unexpected error: ${error._tag}`);
132 }
133 assert.equal(error.operation, "parse");
134 assert.equal(error.repoId, alchemyEffect.id);
135 assert.equal(error.sourcePath, sourcePath);
136 assert.ok(error.cause !== undefined);
137 assert.ok(!error.message.includes(String((error.cause as Error).message)));
138 }),
139 );
140
141 it.effect("reports the unresolved package path without inventing a cause", () =>
142 Effect.gen(function* () {
143 const fs = yield* FileSystem.FileSystem;
144 const path = yield* Path.Path;
145 const rootDir = yield* fs.makeTempDirectoryScoped({
146 prefix: "sync-reference-repos-resolution-error-",
147 });
148 const sourcePath = path.join(rootDir, alchemyEffect.versionSourcePath);
149 yield* fs.makeDirectory(path.dirname(sourcePath), { recursive: true });
150 yield* fs.writeFileString(sourcePath, '{"dependencies":{}}');
151
152 const error = yield* resolveReferenceRepoRef(alchemyEffect, rootDir, false).pipe(Effect.flip);
153
154 if (error._tag !== "ReferenceRepoVersionResolutionError") {
155 assert.fail(`Unexpected error: ${error._tag}`);
156 }
157 assert.equal(error.repoId, alchemyEffect.id);
158 assert.equal(error.sourcePath, sourcePath);
159 assert.deepStrictEqual(error.packageVersionPath, ["dependencies", "alchemy"]);
160 assert.ok(!("cause" in error));
161 }),
162 );
163
88 it.effect("resolves the alchemy-effect tag from the relay package", () =>164 it.effect("resolves the alchemy-effect tag from the relay package", () =>
89 Effect.gen(function* () {165 Effect.gen(function* () {
90 const fs = yield* FileSystem.FileSystem;166 const fs = yield* FileSystem.FileSystem;
...@@ -171,10 +247,56 @@ it.layer(NodeServices.layer)("sync-reference-repos", (it) => {...@@ -171,10 +247,56 @@ it.layer(NodeServices.layer)("sync-reference-repos", (it) => {
171 dryRun: true,247 dryRun: true,
172 }).pipe(Effect.flip);248 }).pipe(Effect.flip);
173249
174 assert.equal(250 if (error._tag !== "ReferenceRepoSelectionError") {
175 error.message,251 assert.fail(`Unexpected error: ${error._tag}`);
176 "Unknown reference repo 'missing'. Expected one of: effect-smol, alchemy-effect.",252 }
177 );253 assert.equal(error.repoId, "missing");
254 assert.deepStrictEqual(error.expectedRepoIds, ["effect-smol", "alchemy-effect"]);
255 assert.ok(!("cause" in error));
178 }),256 }),
179 );257 );
258
259 it.effect("reports non-zero git exits without retaining process output", () => {
260 const commands: Array<{ readonly command: string; readonly args: ReadonlyArray<string> }> = [];
261
262 return Effect.gen(function* () {
263 const fs = yield* FileSystem.FileSystem;
264 const path = yield* Path.Path;
265 const rootDir = yield* fs.makeTempDirectoryScoped({
266 prefix: "sync-reference-repos-exit-error-",
267 });
268 yield* fs.writeFileString(
269 path.join(rootDir, "pnpm-workspace.yaml"),
270 "catalog:\n effect: 4.0.0-beta.73\n",
271 );
272
273 const error = yield* syncReferenceRepos({ rootDir, repoId: "effect-smol" }).pipe(
274 Effect.provide(
275 mockSpawnerLayer(
276 commands,
277 mockHandle({ exitCode: 23, stderr: "subtree failed secret-token-value\n" }),
278 ),
279 ),
280 Effect.flip,
281 );
282
283 if (error._tag !== "ReferenceRepoGitSubtreeError") {
284 assert.fail(`Unexpected error: ${error._tag}`);
285 }
286 assert.equal(error.operation, "exit");
287 assert.equal(error.repoId, effectSmol.id);
288 assert.equal(error.action, "add");
289 assert.equal(error.repository, effectSmol.repository);
290 assert.equal(error.ref, "effect@4.0.0-beta.73");
291 assert.equal(error.rootDir, rootDir);
292 assert.equal(error.argumentCount, commands[0]?.args.length);
293 assert.equal(error.exitCode, 23);
294 assert.equal(error.stdoutLength, 5);
295 assert.equal(error.stderrLength, 34);
296 assert.notProperty(error, "args");
297 assert.notProperty(error, "stderr");
298 assert.notInclude(error.message, "secret-token-value");
299 assert.ok(!("cause" in error));
300 });
301 });
180});302});
scripts/sync-reference-repos.ts+110-37
...@@ -3,7 +3,6 @@...@@ -3,7 +3,6 @@
3import * as NodeRuntime from "@effect/platform-node/NodeRuntime";3import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
4import * as NodeServices from "@effect/platform-node/NodeServices";4import * as NodeServices from "@effect/platform-node/NodeServices";
5import * as Console from "effect/Console";5import * as Console from "effect/Console";
6import * as Data from "effect/Data";
7import * as Effect from "effect/Effect";6import * as Effect from "effect/Effect";
8import * as FileSystem from "effect/FileSystem";7import * as FileSystem from "effect/FileSystem";
9import * as Option from "effect/Option";8import * as Option from "effect/Option";
...@@ -32,10 +31,74 @@ export interface ReferenceRepoSyncPlan {...@@ -32,10 +31,74 @@ export interface ReferenceRepoSyncPlan {
32 readonly args: ReadonlyArray<string>;31 readonly args: ReadonlyArray<string>;
33}32}
3433
35export class ReferenceRepoSyncError extends Data.TaggedError("ReferenceRepoSyncError")<{34export class ReferenceRepoSelectionError extends Schema.TaggedErrorClass<ReferenceRepoSelectionError>()(
36 readonly message: string;35 "ReferenceRepoSelectionError",
37 readonly cause?: unknown;36 {
38}> {}37 repoId: Schema.String,
38 expectedRepoIds: Schema.Array(Schema.String),
39 },
40) {
41 override get message(): string {
42 return `Unknown reference repo "${this.repoId}". Expected one of: ${this.expectedRepoIds.join(", ")}.`;
43 }
44}
45
46export class ReferenceRepoVersionSourceError extends Schema.TaggedErrorClass<ReferenceRepoVersionSourceError>()(
47 "ReferenceRepoVersionSourceError",
48 {
49 operation: Schema.Literals(["read", "parse"]),
50 repoId: Schema.String,
51 sourcePath: Schema.String,
52 cause: Schema.Defect(),
53 },
54) {
55 override get message(): string {
56 return `Reference repo "${this.repoId}" version source operation "${this.operation}" failed for ${this.sourcePath}.`;
57 }
58}
59
60export class ReferenceRepoVersionResolutionError extends Schema.TaggedErrorClass<ReferenceRepoVersionResolutionError>()(
61 "ReferenceRepoVersionResolutionError",
62 {
63 repoId: Schema.String,
64 sourcePath: Schema.String,
65 packageVersionPath: Schema.Array(Schema.String),
66 },
67) {
68 override get message(): string {
69 return `No version was found for reference repo "${this.repoId}" at ${this.sourcePath}:${this.packageVersionPath.join(".")}.`;
70 }
71}
72
73export class ReferenceRepoGitSubtreeError extends Schema.TaggedErrorClass<ReferenceRepoGitSubtreeError>()(
74 "ReferenceRepoGitSubtreeError",
75 {
76 operation: Schema.Literals(["spawn", "communicate", "exit"]),
77 repoId: Schema.String,
78 action: Schema.Literals(["add", "pull"]),
79 repository: Schema.String,
80 ref: Schema.String,
81 rootDir: Schema.String,
82 argumentCount: Schema.Number,
83 exitCode: Schema.optional(Schema.Number),
84 stdoutLength: Schema.optional(Schema.Number),
85 stderrLength: Schema.optional(Schema.Number),
86 cause: Schema.optional(Schema.Defect()),
87 },
88) {
89 override get message(): string {
90 return `Git subtree ${this.action} for reference repo "${this.repoId}" failed during "${this.operation}".`;
91 }
92}
93
94export const ReferenceRepoSyncError = Schema.Union([
95 ReferenceRepoSelectionError,
96 ReferenceRepoVersionSourceError,
97 ReferenceRepoVersionResolutionError,
98 ReferenceRepoGitSubtreeError,
99]);
100export type ReferenceRepoSyncError = typeof ReferenceRepoSyncError.Type;
101export const isReferenceRepoSyncError = Schema.is(ReferenceRepoSyncError);
39102
40const decodeJsonSource = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString);103const decodeJsonSource = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString);
41const decodeYamlSource = Schema.decodeEffect(fromYaml(Schema.Unknown));104const decodeYamlSource = Schema.decodeEffect(fromYaml(Schema.Unknown));
...@@ -61,26 +124,21 @@ function readNestedString(input: unknown, keys: ReadonlyArray<string>): string |...@@ -61,26 +124,21 @@ function readNestedString(input: unknown, keys: ReadonlyArray<string>): string |
61}124}
62125
63function decodeVersionSource(126function decodeVersionSource(
127 repo: ReferenceRepo,
64 sourcePath: string,128 sourcePath: string,
65 content: string,129 content: string,
66): Effect.Effect<unknown, ReferenceRepoSyncError> {130): Effect.Effect<unknown, ReferenceRepoSyncError> {
67 if (sourcePath.endsWith(".yaml") || sourcePath.endsWith(".yml")) {131 const decode =
68 return decodeYamlSource(content).pipe(132 repo.versionSourcePath.endsWith(".yaml") || repo.versionSourcePath.endsWith(".yml")
69 Effect.mapError(133 ? decodeYamlSource
70 (cause) =>134 : decodeJsonSource;
71 new ReferenceRepoSyncError({135 return decode(content).pipe(
72 message: `Unable to parse version source ${sourcePath}.`,
73 cause,
74 }),
75 ),
76 );
77 }
78
79 return decodeJsonSource(content).pipe(
80 Effect.mapError(136 Effect.mapError(
81 (cause) =>137 (cause) =>
82 new ReferenceRepoSyncError({138 new ReferenceRepoVersionSourceError({
83 message: `Unable to parse version source ${sourcePath}.`,139 operation: "parse",
140 repoId: repo.id,
141 sourcePath,
84 cause,142 cause,
85 }),143 }),
86 ),144 ),
...@@ -98,10 +156,9 @@ function getSelectedRepos(...@@ -98,10 +156,9 @@ function getSelectedRepos(
98 return repo156 return repo
99 ? Effect.succeed([repo])157 ? Effect.succeed([repo])
100 : Effect.fail(158 : Effect.fail(
101 new ReferenceRepoSyncError({159 new ReferenceRepoSelectionError({
102 message: `Unknown reference repo '${repoId}'. Expected one of: ${referenceRepos160 repoId,
103 .map((candidate) => candidate.id)161 expectedRepoIds: referenceRepos.map((candidate) => candidate.id),
104 .join(", ")}.`,
105 }),162 }),
106 );163 );
107}164}
...@@ -121,20 +178,22 @@ export const resolveReferenceRepoRef = Effect.fn("resolveReferenceRepoRef")(func...@@ -121,20 +178,22 @@ export const resolveReferenceRepoRef = Effect.fn("resolveReferenceRepoRef")(func
121 const versionSourceContent = yield* fs.readFileString(versionSourcePath).pipe(178 const versionSourceContent = yield* fs.readFileString(versionSourcePath).pipe(
122 Effect.mapError(179 Effect.mapError(
123 (cause) =>180 (cause) =>
124 new ReferenceRepoSyncError({181 new ReferenceRepoVersionSourceError({
125 message: `Unable to read package version for '${repo.id}' from ${versionSourcePath}.`,182 operation: "read",
183 repoId: repo.id,
184 sourcePath: versionSourcePath,
126 cause,185 cause,
127 }),186 }),
128 ),187 ),
129 );188 );
130 const versionSource = yield* decodeVersionSource(repo.versionSourcePath, versionSourceContent);189 const versionSource = yield* decodeVersionSource(repo, versionSourcePath, versionSourceContent);
131 const version = readNestedString(versionSource, repo.packageVersionPath);190 const version = readNestedString(versionSource, repo.packageVersionPath);
132191
133 if (!version) {192 if (!version) {
134 return yield* new ReferenceRepoSyncError({193 return yield* new ReferenceRepoVersionResolutionError({
135 message: `Unable to resolve package version for '${repo.id}' at ${repo.versionSourcePath}:${repo.packageVersionPath.join(194 repoId: repo.id,
136 ".",195 sourcePath: versionSourcePath,
137 )}.`,196 packageVersionPath: repo.packageVersionPath,
138 });197 });
139 }198 }
140199
...@@ -163,11 +222,20 @@ export const planReferenceRepoSync = Effect.fn("planReferenceRepoSync")(function...@@ -163,11 +222,20 @@ export const planReferenceRepoSync = Effect.fn("planReferenceRepoSync")(function
163222
164const runGit = Effect.fn("runGit")(function* (rootDir: string, plan: ReferenceRepoSyncPlan) {223const runGit = Effect.fn("runGit")(function* (rootDir: string, plan: ReferenceRepoSyncPlan) {
165 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;224 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
225 const errorContext = {
226 repoId: plan.repo.id,
227 action: plan.action,
228 repository: plan.repo.repository,
229 ref: plan.ref,
230 rootDir,
231 argumentCount: plan.args.length,
232 } as const;
166 const child = yield* spawner.spawn(ChildProcess.make("git", plan.args, { cwd: rootDir })).pipe(233 const child = yield* spawner.spawn(ChildProcess.make("git", plan.args, { cwd: rootDir })).pipe(
167 Effect.mapError(234 Effect.mapError(
168 (cause) =>235 (cause) =>
169 new ReferenceRepoSyncError({236 new ReferenceRepoGitSubtreeError({
170 message: `Unable to start git subtree ${plan.action} for '${plan.repo.id}'.`,237 ...errorContext,
238 operation: "spawn",
171 cause,239 cause,
172 }),240 }),
173 ),241 ),
...@@ -182,16 +250,21 @@ const runGit = Effect.fn("runGit")(function* (rootDir: string, plan: ReferenceRe...@@ -182,16 +250,21 @@ const runGit = Effect.fn("runGit")(function* (rootDir: string, plan: ReferenceRe
182 ).pipe(250 ).pipe(
183 Effect.mapError(251 Effect.mapError(
184 (cause) =>252 (cause) =>
185 new ReferenceRepoSyncError({253 new ReferenceRepoGitSubtreeError({
186 message: `Unable to run git subtree ${plan.action} for '${plan.repo.id}'.`,254 ...errorContext,
255 operation: "communicate",
187 cause,256 cause,
188 }),257 }),
189 ),258 ),
190 );259 );
191260
192 if (exitCode !== 0) {261 if (exitCode !== 0) {
193 return yield* new ReferenceRepoSyncError({262 return yield* new ReferenceRepoGitSubtreeError({
194 message: `git subtree ${plan.action} failed for '${plan.repo.id}' with exit code ${exitCode}.\n${stderr.trim()}`,263 ...errorContext,
264 operation: "exit",
265 exitCode,
266 stdoutLength: stdout.length,
267 stderrLength: stderr.length,
195 });268 });
196 }269 }
197270