@effected/github-actions 0.2.0 → 0.4.0

package/ToolInstaller.js

@@ -53,6 +53,8 @@ var ToolInstallerError = class extends Schema.TaggedErrorClass()("ToolInstallerE
 };
 /** How many times a retryable download is retried before giving up. */
 const DOWNLOAD_RETRIES = 2;
+/** The default per-attempt download budget. See {@link ToolDownloadOptions.timeout}. */
+const DOWNLOAD_TIMEOUT = "5 minutes";
 const make = Effect.gen(function* () {
 	const env = yield* ActionEnvironment;
 	const fs = yield* FileSystem.FileSystem;
@@ -83,29 +85,37 @@ const make = Effect.gen(function* () {
 		})));
 	};
 	/**
-	* Run an extraction command, keeping its stderr.
+	* Run an extraction command ONCE, keeping its stderr.
 	*
 	* @remarks
 	* `tar`'s exit code says only that it failed; its stderr says why, and it is
 	* the difference between "this is not a gzip archive" and "tar is not
 	* installed". Discarding it is what makes an extraction failure unactionable.
+	*
+	* **One spawn, not two — load-bearing.** The spawner's convenience members
+	* each spawn independently: `string` collects output without inspecting the
+	* exit code, and `exitCode` runs the command AGAIN (core's
+	* `ChildProcessSpawner.make` derives both from `spawn`). Calling them
+	* back-to-back double-executed every extraction — harmless for idempotent
+	* `tar`/`unzip -o`, but .NET's `ZipFile.ExtractToDirectory` refuses to
+	* overwrite, so the second run failed 5/5 on real Windows runners while the
+	* captured "complaint" was the FIRST run's silent success. Output and exit
+	* code must come from the same `spawn` handle.
 	*/
-	const extractWith = (command, archive) => Effect.gen(function* () {
-		const output = yield* spawner.string(command, { includeStderr: true }).pipe(Effect.mapError((cause) => new ToolInstallerError({
-			reason: "extractFailed",
-			subject: archive,
-			cause
-		})));
-		if ((yield* spawner.exitCode(command).pipe(Effect.mapError((cause) => new ToolInstallerError({
+	const extractWith = (command, archive) => Effect.scoped(Effect.gen(function* () {
+		const extractError = (cause) => new ToolInstallerError({
 			reason: "extractFailed",
 			subject: archive,
 			cause
-		})))) !== 0) return yield* Effect.fail(new ToolInstallerError({
+		});
+		const handle = yield* spawner.spawn(command).pipe(Effect.mapError(extractError));
+		const output = yield* Stream.mkString(Stream.decodeText(handle.all)).pipe(Effect.mapError(extractError));
+		if ((yield* handle.exitCode.pipe(Effect.mapError(extractError))) !== 0) return yield* Effect.fail(new ToolInstallerError({
 			reason: "extractFailed",
 			subject: archive,
 			stderr: output.trim()
 		}));
-	});
+	}));
 	/**
 	* Install a staged directory into the tool cache by renaming it into place.
 	*
@@ -146,38 +156,55 @@ const make = Effect.gen(function* () {
 		recursive: true,
 		force: true
 	}))))));
-	return {
-		find: (tool, version) => Effect.map(Effect.result(fs.stat(cachePath(tool, version))), (result) => result._tag === "Success" && result.success.type === "Directory" ? Option.some(cachePath(tool, version)) : Option.none()),
-		download: Effect.fn("ToolInstaller.download")(function* (url) {
-			return yield* Effect.gen(function* () {
-				const response = yield* http.get(url).pipe(Effect.mapError((cause) => new ToolInstallerError({
-					reason: "downloadFailed",
-					subject: url,
-					cause
-				})));
-				if (response.status < 200 || response.status >= 300) return yield* Effect.fail(new ToolInstallerError({
-					reason: "downloadFailed",
-					subject: url,
-					status: response.status
-				}));
-				const directory = yield* fs.makeTempDirectory({ prefix: "effected-download-" }).pipe(Effect.mapError((cause) => new ToolInstallerError({
-					reason: "downloadFailed",
-					subject: url,
-					cause
-				})));
-				const file = path.join(directory, "download");
-				yield* Stream.run(response.stream, fs.sink(file)).pipe(Effect.mapError((cause) => new ToolInstallerError({
-					reason: "downloadFailed",
-					subject: url,
-					cause
-				})));
-				return file;
-			}).pipe(Effect.retry({
-				schedule: Schedule.exponential("1 second"),
-				times: DOWNLOAD_RETRIES,
-				while: (error) => error.retryable
+	const download = Effect.fn("ToolInstaller.download")(function* (url, options) {
+		return yield* Effect.gen(function* () {
+			const response = yield* http.get(url).pipe(Effect.mapError((cause) => new ToolInstallerError({
+				reason: "downloadFailed",
+				subject: url,
+				cause
+			})));
+			if (response.status < 200 || response.status >= 300) return yield* Effect.fail(new ToolInstallerError({
+				reason: "downloadFailed",
+				subject: url,
+				status: response.status
 			}));
-		}),
+			const directory = yield* fs.makeTempDirectory({ prefix: "effected-download-" }).pipe(Effect.mapError((cause) => new ToolInstallerError({
+				reason: "downloadFailed",
+				subject: url,
+				cause
+			})));
+			const file = path.join(directory, "download");
+			yield* Stream.run(response.stream, fs.sink(file)).pipe(Effect.mapError((cause) => new ToolInstallerError({
+				reason: "downloadFailed",
+				subject: url,
+				cause
+			})));
+			return file;
+		}).pipe(Effect.timeout(options?.timeout ?? DOWNLOAD_TIMEOUT), Effect.catchTag("TimeoutError", (cause) => Effect.fail(new ToolInstallerError({
+			reason: "downloadFailed",
+			subject: url,
+			cause
+		}))), Effect.retry({
+			schedule: Schedule.exponential("1 second"),
+			times: DOWNLOAD_RETRIES,
+			while: (error) => error.retryable
+		}));
+	});
+	const find = (tool, version) => Effect.map(Effect.result(fs.stat(cachePath(tool, version))), (result) => result._tag === "Success" && result.success.type === "Directory" ? Option.some(cachePath(tool, version)) : Option.none());
+	const cacheFile = Effect.fn("ToolInstaller.cacheFile")(function* (source, name, tool, version) {
+		yield* Effect.annotateCurrentSpan({
+			tool,
+			version
+		});
+		return yield* staged(tool, (staging) => fs.copyFile(source, path.join(staging, name)).pipe(Effect.mapError((cause) => new ToolInstallerError({
+			reason: "cacheFailed",
+			subject: tool,
+			cause
+		})), Effect.flatMap(() => swapIntoCache(staging, tool, version))));
+	});
+	return {
+		find,
+		download,
 		extractTar: Effect.fn("ToolInstaller.extractTar")(function* (archive, options) {
 			const destination = yield* destinationFor(options);
 			const flags = options?.flags === void 0 || options.flags.length === 0 ? ["xzf"] : [...options.flags];
@@ -195,7 +222,7 @@ const make = Effect.gen(function* () {
 				"-NoProfile",
 				"-NonInteractive",
 				"-Command",
-				`Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('${archive.replaceAll("'", "''")}', '${destination.replaceAll("'", "''")}')`
+				`$ErrorActionPreference = 'Stop'; try { Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('${archive.replaceAll("'", "''")}', '${destination.replaceAll("'", "''")}', $true) } catch { [Console]::Error.WriteLine($_.Exception.ToString()); exit 1 }`
 			]) : ChildProcess.make("unzip", [
 				"-oq",
 				archive,
@@ -216,16 +243,31 @@ const make = Effect.gen(function* () {
 				cause
 			})), Effect.flatMap(() => swapIntoCache(staging, tool, version))));
 		}),
-		cacheFile: Effect.fn("ToolInstaller.cacheFile")(function* (source, name, tool, version) {
+		cacheFile,
+		provisionFile: Effect.fn("ToolInstaller.provisionFile")(function* (options) {
 			yield* Effect.annotateCurrentSpan({
-				tool,
-				version
+				tool: options.tool,
+				version: options.version
 			});
-			return yield* staged(tool, (staging) => fs.copyFile(source, path.join(staging, name)).pipe(Effect.mapError((cause) => new ToolInstallerError({
+			const cached = yield* find(options.tool, options.version);
+			if (Option.isSome(cached)) {
+				const present = yield* Effect.result(fs.stat(path.join(cached.value, options.binary)));
+				if (present._tag === "Success" && present.success.type === "File") return {
+					directory: cached.value,
+					binDir: cached.value
+				};
+			}
+			const file = yield* download(options.url);
+			if (!windows) yield* fs.chmod(file, 493).pipe(Effect.mapError((cause) => new ToolInstallerError({
 				reason: "cacheFailed",
-				subject: tool,
+				subject: file,
 				cause
-			})), Effect.flatMap(() => swapIntoCache(staging, tool, version))));
+			})));
+			const directory = yield* cacheFile(file, options.binary, options.tool, options.version);
+			return {
+				directory,
+				binDir: directory
+			};
 		})
 	};
 });
@@ -236,10 +278,13 @@ const unimplemented = (member) => {
 * Download, extract and cache a toolchain in the runner's tool cache.
 *
 * @remarks
-* The primitives, not a workflow: a consumer composes `find` → `download` →
-* `extractTar` → `cacheDir` in whatever order its tool needs, because the
-* orders genuinely differ (a single binary skips extraction, a tarball with a
-* nested root directory needs a path fixup between extract and cache).
+* The primitives, plus exactly one packaged workflow: a consumer composes
+* `find` → `download` → `extractTar` → `cacheDir` in whatever order its tool
+* needs, because the orders genuinely differ (a tarball with a nested root
+* directory needs a path fixup between extract and cache). The one shape with
+* no per-tool variation — a single bare binary, which skips extraction and
+* needs only the executable bit — ships whole as
+* {@link ToolInstallerShape.provisionFile}.
 *
 * No `@actions/tool-cache` dependency — the cache is a directory layout, and
 * this reproduces the layout rather than importing a package to compute it.
@@ -283,6 +328,7 @@ var ToolInstaller = class ToolInstaller extends Context.Service()("@effected/git
 		extractZip: () => Effect.sync(() => unimplemented("extractZip")),
 		cacheDir: () => Effect.sync(() => unimplemented("cacheDir")),
 		cacheFile: () => Effect.sync(() => unimplemented("cacheFile")),
+		provisionFile: () => Effect.sync(() => unimplemented("provisionFile")),
 		...overrides
 	});
 	/** {@link ToolInstaller.makeTest} behind `Layer.succeed`. */