cursedops 0.10.6 → 0.10.7

package/README.md

@@ -8,7 +8,7 @@ bun add cursedops
 
 | subpath | what it is |
 |---|---|
-| `cursedops/roots` | finding a generation's roots, and a checkout's package root, without knowing a path — and the `cd` prefix of a printed command that RUNS when pasted (`repoCd`, 0.5.0) |
+| `cursedops/roots` | finding a generation's roots, and a checkout's package root, without knowing a path — and the `cd` prefix of a printed command that RUNS when pasted (`repoCd`, 0.5.0); a worktree is followed to its primary from its `.git` file, once per directory, never a `git` per call (0.10.7) |
 | `cursedops/paths` | the generation's whole-tree laws (`check-paths`, `check-doc-citations`, plus any `--also`) run over ONE repo, from a checkout or a worktree — and its `forge-paths` bin (0.5.0) |
 | `cursedops/launchd` | installing, replacing and removing a macOS launchd user agent, and the port a LIVE job serves on (`livePort`, 0.5.0) |
 | `cursedops/smoke` | the scaffolding of a deployed smoke — the ledger, the fetch, the DNS hint, the exit code — the one check no app owns (every address of a deployment serving the same built client), and since 0.5.0 its VERDICTS: the origin asked on loopback, the smoke's own environment, a network that lies about DNS, and a version that has settled |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedops",
-	"version": "0.10.6",
+	"version": "0.10.7",
 	"description": "The build-and-ops answers this generation's apps wrote independently and identically: finding a generation's roots — and printing a command that runs when pasted — without knowing a path, the generation's whole-tree laws run over one repo from a checkout or a worktree, macOS launchd agent install/replace/remove and the live port a job serves, the scaffolding and verdicts of a deployed smoke (origin probe, the smoke's own environment, a network that lies about DNS, a settled version), the static-serving helpers eight apps copied — the path-traversal guard among them — the API floor that keeps an unmatched /api/... from ever being answered with the app shell, the commit and dirty flag a checkout-served process reports, the Cloudflare Worker deploy toolkit four apps copied (the deploy sequence, exact-set secrets over a pipe, origin-first rollback, the curl edge fetch, the row-for-row D1 import proof, the billed-CPU tail check around a deploy's walk and smoke, and each app's worker:secrets and worker:smoke main as one function of its data), the relay a Worker fronts a Mac-bound app with (the Durable Object, the frames, the Mac's dialer and key rotation — lifted from station for roms — and the signed-in stage walk's skeleton and the relay app's whole worker:deploy), the Worker import-graph and await-port checks every Worker app's suite runs over its own source, and the public-surface ratchet three published libraries each carried a forked copy of. Mechanism only — no app knows its name from here. Bun, zero runtime dependencies (typescript is an optional peer, for public-surface only), ships source.",
 	"type": "module",
 	"scripts": {

package/src/roots.ts

@@ -54,7 +54,7 @@
  */
 
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -86,30 +86,90 @@ function walkUp(from: string, marker: string): string | null {
 	return null;
 }
 
+/**
+ * The primary checkout's git directory for the repo `from` is in, read from DISK — or `undefined`
+ * when the files do not say, and only `git` can.
+ *
+ * A worktree's `.git` is a FILE, `gitdir: <primary>/.git/worktrees/<slug>`, and that directory's
+ * `commondir` names the primary's `.git` relative to it. A primary checkout or a clone has a `.git`
+ * DIRECTORY, which is its own common directory. Both are what `git rev-parse --git-common-dir`
+ * answers, without a process.
+ */
+function commonGitDirOnDisk(from: string): string | undefined {
+	let dir = resolve(from);
+	for (let hops = 0; hops < MAX_HOPS; hops++) {
+		const dotGit = join(dir, ".git");
+		if (existsSync(dotGit)) {
+			if (statSync(dotGit).isDirectory()) return realpathSync(dotGit);
+			const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, "utf8"))?.[1]?.trim();
+			if (!pointer) return undefined;
+			const gitDir = resolve(dir, pointer);
+			const commonFile = join(gitDir, "commondir");
+			// A submodule's `.git` points at `.git/modules/<name>`, which has no `commondir`: it IS its own.
+			const common = existsSync(commonFile) ? resolve(gitDir, readFileSync(commonFile, "utf8").trim()) : gitDir;
+			return existsSync(common) ? realpathSync(common) : undefined;
+		}
+		const up = dirname(dir);
+		if (up === dir) return undefined;
+		dir = up;
+	}
+	return undefined;
+}
+
+/**
+ * One answer per starting directory, for the life of the process. Which primary a worktree was cut
+ * from cannot change while a process runs, and every `forgeState(from)` in a worktree lands here.
+ */
+const viaWorktree = new Map<string, string | null>();
+
+/** For a test that must watch the lookup happen again. */
+export function __forgetWorktreeRoots(): void {
+	viaWorktree.clear();
+}
+
 /**
  * The generation above the checkout a git WORKTREE at `from` was cut from, or `null`.
  *
- * `git rev-parse --git-common-dir` names the primary checkout's git directory; the
- * ordinary walk runs from the directory holding it. For a primary checkout, a clone
- * or a plain repo that is its own `.git`, so the answer is exactly what the walk up
- * from `from` already said. `null` on anything unexpected — no git, not a repo, a
- * directory that is not there — because inventing a root is the failure this module
- * is against.
+ * The primary checkout's git directory names the checkout; the ordinary walk runs from the
+ * directory holding it. For a primary checkout, a clone or a plain repo that is its own `.git`,
+ * so the answer is exactly what the walk up from `from` already said. `null` on anything
+ * unexpected — no git, not a repo, a directory that is not there — because inventing a root is
+ * the failure this module is against.
+ *
+ * 🔴 Read from the files first, and remembered, because `git` here was a HANG. Until 0.10.7 this
+ * spawned `git rev-parse --git-common-dir` on EVERY call, and in a worktree every call reaches it:
+ * roms' suite made 593 of them per run (`forgeState` ← `assertTestSafeDbPath`, `requireState`, …).
+ * Measured 2026-09-24 in a roms worktree: under `bun test --parallel=6`, about one run in three
+ * left a test worker spinning at 99% CPU inside `Bun.spawnSync` beside a `<defunct>` git child —
+ * Bun had missed the exit, and the 5 s `timeout` never fired. One gate stood 23 minutes. The
+ * primary checkout never saw it, because its walk up finds `forge.env` and never asks git. The
+ * same run from files: zero spawns. `git` remains only for a layout the files do not settle.
  */
 export function findForgeRootViaWorktree(from: string): string | null {
+	const key = resolve(from);
+	const remembered = viaWorktree.get(key);
+	if (remembered !== undefined) return remembered;
+	let answer: string | null = null;
 	try {
-		const git = spawnSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
-			cwd: from,
-			encoding: "utf8",
-			timeout: 5_000,
-		});
-		if (git.status !== 0) return null;
-		const common = (git.stdout ?? "").trim();
-		if (!common.startsWith("/")) return null;
-		return walkUp(dirname(common), MARKER);
+		const common = commonGitDirOnDisk(key) ?? commonGitDirFromGit(key);
+		answer = common ? walkUp(dirname(common), MARKER) : null;
 	} catch {
-		return null;
+		answer = null;
 	}
+	viaWorktree.set(key, answer);
+	return answer;
+}
+
+/** `git rev-parse --git-common-dir` — the fallback for a layout {@link commonGitDirOnDisk} cannot read. */
+function commonGitDirFromGit(from: string): string | null {
+	const git = spawnSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+		cwd: from,
+		encoding: "utf8",
+		timeout: 5_000,
+	});
+	if (git.status !== 0) return null;
+	const common = (git.stdout ?? "").trim();
+	return common.startsWith("/") ? common : null;
 }
 
 /**