fix: address PR review feedback

Julius Marminge committed 8 months ago

Commit 41734df1 parent 8f42d345 files · +108 −25Browse files

Showing the changes to apps/server/src/git (2 of 5 files). Show all

Unified · Split

2 files

apps/server/src/git/Layers/CodexTextGeneration.test.ts +57 −0
apps/server/src/git/Layers/CodexTextGeneration.ts +28 −11

apps/server/src/git/Layers/CodexTextGeneration.test.ts+57−0

@@ -349,6 +349,15 @@ it.layer(CodexTextGenerationTestLayer)("CodexTextGenerationLive", (it) => { · 348 unmodified lines
349	},	349	},
350	],	350	],
351	})	351	})
		352	.pipe(
		353	Effect.tap(() =>
		354	fs.stat(imagePath).pipe(
		355	Effect.map((fileInfo) => {
		356	expect(fileInfo.type).toBe("File");
		357	}),
		358	),
		359	),
		360	)
352	.pipe(	361	.pipe(
353	Effect.ensuring(	362	Effect.ensuring(
354	fs.remove(imagePath).pipe(Effect.catch(() => Effect.void)),	363	fs.remove(imagePath).pipe(Effect.catch(() => Effect.void)),
@@ -360,6 +369,54 @@ it.layer(CodexTextGenerationTestLayer)("CodexTextGenerationLive", (it) => { · 5 unmodified lines
360	),	369	),
361	);	370	);
362		371
		372	it.effect("ignores absolute non-route attachment paths for codex image inputs", () =>
		373	withFakeCodexEnv(
		374	{
		375	output: JSON.stringify({
		376	branch: "fix/ui-regression",
		377	}),
		378	requireImage: true,
		379	},
		380	Effect.gen(function* () {
		381	const fs = yield* FileSystem.FileSystem;
		382	const path = yield* Path.Path;
		383	const tempDir = yield* fs.makeTempDirectoryScoped({
		384	prefix: "t3code-codex-attachment-bypass-",
		385	});
		386	const absoluteImagePath = path.join(tempDir, "outside.png");
		387	yield* fs.writeFile(absoluteImagePath, Buffer.from("hello"));
		388
		389	const textGeneration = yield* TextGeneration;
		390	const result = yield* textGeneration
		391	.generateBranchName({
		392	cwd: process.cwd(),
		393	message: "Fix layout bug from screenshot.",
		394	attachments: [
		395	{
		396	type: "image",
		397	name: "outside.png",
		398	mimeType: "image/png",
		399	sizeBytes: 5,
		400	dataUrl: absoluteImagePath,
		401	},
		402	],
		403	})
		404	.pipe(
		405	Effect.match({
		406	onFailure: (error) => ({ _tag: "Left" as const, left: error }),
		407	onSuccess: (value) => ({ _tag: "Right" as const, right: value }),
		408	}),
		409	);
		410
		411	expect(result._tag).toBe("Left");
		412	if (result._tag === "Left") {
		413	expect(result.left).toBeInstanceOf(TextGenerationError);
		414	expect(result.left.message).toContain("missing --image input");
		415	}
		416	}),
		417	),
		418	);
		419
363	it.effect(	420	it.effect(
364	"fails with typed TextGenerationError when codex returns wrong branch payload shape",	421	"fails with typed TextGenerationError when codex returns wrong branch payload shape",
365	() =>	422	() =>

apps/server/src/git/Layers/CodexTextGeneration.ts+28−11

   const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const serverConfig = yield* Effect.service(ServerConfig);
+  type MaterializedImageAttachments = {
+    readonly imagePaths: ReadonlyArray<string>;
+    readonly tempImagePaths: ReadonlyArray<string>;
+  };
   const readStreamAsString = <E>(
     operation: string,
     stream: Stream.Stream<Uint8Array, E>,
   const materializeImageAttachments = (
     operation: "generateCommitMessage" | "generatePrContent" | "generateBranchName",
     attachments: BranchNameGenerationInput["attachments"],
-  ): Effect.Effect<ReadonlyArray<string>, TextGenerationError> =>
+  ): Effect.Effect<MaterializedImageAttachments, TextGenerationError> => {
-    Effect.gen(function* () {
+    const tempImagePaths: string[] = [];
+    return Effect.gen(function* () {
       if (!attachments || attachments.length === 0) {
-        return [];
+        return { imagePaths: [], tempImagePaths };
       }
       const imagePaths: string[] = [];
             extension,
           );
           imagePaths.push(imagePath);
+          tempImagePaths.push(imagePath);
           continue;
         }
           stateDir: serverConfig.stateDir,
           dataUrl: attachment.dataUrl,
         });
-        const localPath = persistedPath ?? attachment.dataUrl;
+        if (!persistedPath || !path.isAbsolute(persistedPath)) {
-        if (!path.isAbsolute(localPath)) {
           continue;
         }
         const fileInfo = yield* fileSystem
-          .stat(localPath)
+          .stat(persistedPath)
           .pipe(Effect.catch(() => Effect.succeed(null)));
         if (!fileInfo || fileInfo.type !== "File") {
           continue;
         }
-        imagePaths.push(localPath);
+        imagePaths.push(persistedPath);
       }
-      return imagePaths;
+      return { imagePaths, tempImagePaths };
-    });
+    }).pipe(
+      Effect.tapError(() =>
+        Effect.all(tempImagePaths.map((filePath) => safeUnlink(filePath)), {
+          concurrency: "unbounded",
+        }).pipe(Effect.asVoid),
+      ),
+    );
+  };
   const runCodexJson = <S extends Schema.Top>({
     operation,
     prompt,
     outputSchemaJson,
     imagePaths = [],
+    cleanupPaths = [],
   }: {
     operation: "generateCommitMessage" | "generatePrContent" | "generateBranchName";
     cwd: string;
     prompt: string;
     outputSchemaJson: S;
     imagePaths?: ReadonlyArray<string>;
+    cleanupPaths?: ReadonlyArray<string>;
   }): Effect.Effect<S["Type"], TextGenerationError, S["DecodingServices"]> =>
     Effect.gen(function* () {
       const schemaPath = yield* writeTempFile(
       });
       const cleanup = Effect.all(
-        [schemaPath, outputPath, ...imagePaths].map((filePath) => safeUnlink(filePath)),
+        [schemaPath, outputPath, ...cleanupPaths].map((filePath) => safeUnlink(filePath)),
         {
           concurrency: "unbounded",
         },
   const generateBranchName: TextGenerationShape["generateBranchName"] = (input) => {
     return Effect.gen(function* () {
-      const imagePaths = yield* materializeImageAttachments(
+      const { imagePaths, tempImagePaths } = yield* materializeImageAttachments(
         "generateBranchName",
         input.attachments,
       );
           branch: Schema.String,
         }),
         imagePaths,
+        cleanupPaths: tempImagePaths,
       });
       return {