@effected/github-actions 0.20.0 → 0.20.1

package/PackageManagerInstaller.js

@@ -4,6 +4,7 @@ import { digestFileHex } from "./internal/digest.js";
 import { isWindowsRunner } from "./internal/runner.js";
 import { typeAt } from "./internal/fsProbe.js";
 import { PNPM_EXE_PREFIX, detectMusl, isNodeScript, pnpmExeTarget, strongestSri } from "./internal/pnpmExe.js";
+import { cmdShim, gitBashShim, posixShim } from "./internal/shim.js";
 import { ToolInstaller } from "./ToolInstaller.js";
 import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
@@ -100,8 +101,10 @@ var AmbientPackageManager = class extends Schema.Class("AmbientPackageManager")(
 * `binDir` is the directory a consumer hands to `ActionOutputs.addPath` to
 * make the manager invokable by name in subsequent workflow steps. For the
 * npm-registry managers it is the entry's `.bin` directory of executable
-* shims this installer writes (`#!/bin/sh` exec wrappers, or `.cmd` wrappers
-* on Windows); for bun it is the entry directory itself, because the cached
+* shims this installer writes (`#!/bin/sh` exec wrappers; on Windows a
+* `.cmd` wrapper plus an extensionless Git Bash sibling per bin, because
+* Git Bash does not apply `PATHEXT` and never resolves the `.cmd` by the
+* bare name); for bun it is the entry directory itself, because the cached
 * `bun` binary is directly executable and a shim would add nothing but a
 * fork. `bins` still maps each published bin name to the underlying entry —
 * a Node script to run with `node` for npm, yarn and pnpm 11 and earlier; an
@@ -150,17 +153,6 @@ var CachedPackageManager = class extends Schema.Class("CachedPackageManager")({
 const InstalledPackageManager = Schema.Union([AmbientPackageManager, CachedPackageManager]);
 /** The shim directory name inside a cached npm-registry-manager entry. */
 const SHIM_DIR = ".bin";
-/**
-* The POSIX shim body: an `exec` wrapper so the shim's process *becomes* the
-* target, and `"$@"` so arguments survive quoting intact. A Node script
-* (`.js`/`.mjs`/`.cjs`) runs under `node`; anything else — pnpm 12's native
-* binary, its `#!/bin/sh` alias scripts — is exec'd directly, because handing
-* a shell script or a Mach-O to node is exactly the "Invalid or unexpected
-* token" failure this rule exists to prevent.
-*/
-const posixShim = (target) => isNodeScript(target) ? `#!/bin/sh\nexec node "${target}" "$@"\n` : `#!/bin/sh\nexec "${target}" "$@"\n`;
-/** The Windows shim body, CRLF-terminated as cmd expects; same node-vs-direct rule. */
-const cmdShim = (target) => isNodeScript(target) ? `@echo off\r\nnode "${target}" %*\r\n` : `@echo off\r\n"${target}" %*\r\n`;
 /** The bin names pnpm's wrapper publishes, every one of which becomes the native binary on Windows. */
 const PNPM_NATIVE_BIN_NAMES = [
 	"pnpm",
@@ -229,8 +221,16 @@ const make = Effect.gen(function* () {
 	const windows = yield* isWindowsRunner(env);
 	const musl = detectMusl();
 	const bunBinaryName = windows ? "bun.exe" : "bun";
-	const shimFileName = (name) => windows ? `${name}.cmd` : name;
-	const shimBody = windows ? cmdShim : posixShim;
+	/**
+	* The shim files one bin gets, as file-name/body pairs: the extensionless
+	* `#!/bin/sh` exec wrapper on POSIX; on Windows the `.cmd` wrapper for
+	* `cmd.exe` and PowerShell PLUS the extensionless Git Bash sibling — Git
+	* Bash does not apply `PATHEXT`, so a bare name never resolves to the
+	* `.cmd`. Both flavours derive from the same target, so every distinction
+	* the `.cmd` applies (pnpm 12's native binary vs its aliases, node-vs-
+	* direct dispatch) the sibling applies identically.
+	*/
+	const shimFiles = (name, target) => windows ? [[`${name}.cmd`, cmdShim(target)], [name, gitBashShim(target)]] : [[name, posixShim(target)]];
 	const errorFor = (pin) => (fields) => new PackageManagerInstallerError({
 		name: pin.name,
 		version: pin.version.toString(),
@@ -363,8 +363,9 @@ const make = Effect.gen(function* () {
 	})), Effect.orElseSucceed(() => false));
 	const rootBins = (bins, directory) => Object.fromEntries(Object.entries(bins).map(([name, relative]) => [name, path.join(directory, relative)]));
 	/**
-	* Write one executable shim per bin into `<into>/.bin`, each invoking
-	* `node <finalDirectory>/<relative>`.
+	* Write the shim files of every bin into `<into>/.bin`, each naming
+	* `<finalDirectory>/<relative>` — the POSIX exec wrapper, or on Windows
+	* BOTH the `.cmd` wrapper and its extensionless Git Bash sibling.
 	*
 	* @remarks
 	* `into` and `finalDirectory` are DIFFERENT on the install path on purpose:
@@ -372,8 +373,9 @@ const make = Effect.gen(function* () {
 	* ToolInstaller renames into place (the cache only ever contains complete
 	* entries), while their contents must name the *final* cache path the entry
 	* is about to land at. On the cache-hit regeneration path the two coincide.
-	* When `skipExisting` is set, a shim already present is left untouched — the
-	* regeneration path must not rewrite a shared cache entry another writer owns.
+	* When `skipExisting` is set, a shim file already present is left untouched,
+	* file by file — the regeneration path must not rewrite what another writer
+	* owns, but it does add a sibling a previous version never wrote.
 	*/
 	const writeShims = (pin, into, finalDirectory, bins, options) => Effect.gen(function* () {
 		const shimDir = path.join(into, SHIM_DIR);
@@ -383,12 +385,12 @@ const make = Effect.gen(function* () {
 			cause
 		});
 		yield* fs.makeDirectory(shimDir, { recursive: true }).pipe(Effect.mapError(cacheError(shimDir)));
-		for (const [name, relative] of Object.entries(bins)) {
-			const shim = path.join(shimDir, shimFileName(name));
+		for (const [name, relative] of Object.entries(bins)) for (const [file, body] of shimFiles(name, path.join(finalDirectory, relative))) {
+			const shim = path.join(shimDir, file);
 			if (options.skipExisting) {
 				if ((yield* typeAt(fs, shim)) === "File") continue;
 			}
-			yield* fs.writeFileString(shim, shimBody(path.join(finalDirectory, relative))).pipe(Effect.mapError(cacheError(shim)));
+			yield* fs.writeFileString(shim, body).pipe(Effect.mapError(cacheError(shim)));
 			if (!windows) yield* fs.chmod(shim, 493).pipe(Effect.mapError(cacheError(shim)));
 		}
 	});

package/index.d.ts

@@ -4838,8 +4838,10 @@ declare const CachedPackageManager_base: Schema.Class<CachedPackageManager, Sche
  * `binDir` is the directory a consumer hands to `ActionOutputs.addPath` to
  * make the manager invokable by name in subsequent workflow steps. For the
  * npm-registry managers it is the entry's `.bin` directory of executable
- * shims this installer writes (`#!/bin/sh` exec wrappers, or `.cmd` wrappers
- * on Windows); for bun it is the entry directory itself, because the cached
+ * shims this installer writes (`#!/bin/sh` exec wrappers; on Windows a
+ * `.cmd` wrapper plus an extensionless Git Bash sibling per bin, because
+ * Git Bash does not apply `PATHEXT` and never resolves the `.cmd` by the
+ * bare name); for bun it is the entry directory itself, because the cached
  * `bun` binary is directly executable and a shim would add nothing but a
  * fork. `bins` still maps each published bin name to the underlying entry —
  * a Node script to run with `node` for npm, yarn and pnpm 11 and earlier; an

package/internal/shim.js

@@ -0,0 +1,30 @@
+import { isNodeScript } from "./pnpmExe.js";
+
+//#region src/internal/shim.ts
+/**
+* The POSIX shim body: an `exec` wrapper so the shim's process *becomes* the
+* target, and `"$@"` so arguments survive quoting intact. A Node script
+* (`.js`/`.mjs`/`.cjs`) runs under `node`; anything else — pnpm 12's native
+* binary, its `#!/bin/sh` alias scripts — is exec'd directly, because handing
+* a shell script or a Mach-O to node is exactly the "Invalid or unexpected
+* token" failure this rule exists to prevent.
+*/
+const posixShim = (target) => isNodeScript(target) ? `#!/bin/sh\nexec node "${target}" "$@"\n` : `#!/bin/sh\nexec "${target}" "$@"\n`;
+/** The Windows shim body, CRLF-terminated as cmd expects; same node-vs-direct rule. */
+const cmdShim = (target) => isNodeScript(target) ? `@echo off\r\nnode "${target}" %*\r\n` : `@echo off\r\n"${target}" %*\r\n`;
+/**
+* The Git Bash shim body written beside every Windows `.cmd` shim: the POSIX
+* wrapper's own shape — same shebang, same `exec`, same `"$@"`, same
+* node-vs-direct rule — with the target rendered in forward slashes. Inside
+* double quotes `/bin/sh` consumes a backslash only before `$`, a backtick,
+* `"`, another `\` or a newline, and a trailing backslash would escape the
+* closing quote — enough to mangle a verbatim Windows path (a doubled UNC
+* lead, a segment before `$`), while Git Bash resolves `C:/…` paths as-is.
+* Git Bash does not apply `PATHEXT`, so a bare name never finds the `.cmd`
+* twin on its own; npm's global installs write the same extensionless sibling
+* for the same reason.
+*/
+const gitBashShim = (target) => posixShim(target.replaceAll("\\", "/"));
+
+//#endregion
+export { cmdShim, gitBashShim, posixShim };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/github-actions",
-	"version": "0.20.0",
+	"version": "0.20.1",
 	"private": false,
 	"description": "The GitHub Actions runtime: env, inputs, outputs, state, logging, cache, artifacts, blob storage, OIDC and the token bridge.",
 	"keywords": [
@@ -39,12 +39,12 @@
 	},
 	"dependencies": {
 		"@azure/storage-blob": "^12.33.0",
-		"@effected/github": "^0.15.0",
-		"@effected/github-commands": "^0.1.0",
+		"@effected/github": "^0.15.1",
+		"@effected/github-commands": "^0.2.0",
 		"@effected/glob": "^0.10.0",
-		"@effected/markdown": "^0.15.0",
+		"@effected/markdown": "^0.15.1",
 		"@effected/npm": "^0.20.0",
-		"@effected/sbom": "^0.10.0",
+		"@effected/sbom": "^0.10.1",
 		"@effected/semver": "^0.11.0",
 		"@effected/templates": "^0.10.0",
 		"@effected/walker": "^0.15.0"