fix(scripts): run lex codegen via a Node runner, not a shell pipe

`set -o pipefail` is NOT portable: GitHub's Ubuntu `sh` (dash) rejects it
(`set: Illegal option -o pipefail`), which broke CI. And no `xargs` option
replaces it — `-r` only skips empty input, it does not propagate a producer's
non-zero exit, so a crashed list-generator still yields a "successful" pipeline.

Replace the pipe entirely with scripts/run-lex-codegen.js: a single Node
process that builds the permission-set-excluded file list and spawns
`lex <subcommand> <args> <files…>` with the list as argv, forwarding lex's exit
code. One authoritative exit code, no shell builtins, no ARG_MAX (argv, not a
command line), no pipefail. Empty list or spawn failure → non-zero exit.

(Renamed from codegen-lexicon-files.js, which only printed the list.)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: aspiers

package.json

@@ -42,12 +42,12 @@
     "check": "npm run gen-api && npm run lint && npm run typecheck && npm run build && npm run test",
     "build": "rollup -c && npm run build:types",
     "build:types": "tsc --project tsconfig.build.json",
-    "//permissions": "permission-set lexicons are published as-is but have no TS shape; lex gen-* cannot codegen them. scripts/codegen-lexicon-files.js emits the NUL-delimited lexicon list to codegen, excluding permission-sets by content (single source of truth shared with generate-exports.js). Piped into `xargs -0 -r` under `set -o pipefail`: pipefail propagates a producer failure (xargs alone cannot — it would run lex on partial/empty input and report success); -r skips lex if the list is somehow empty; xargs avoids ARG_MAX.",
-    "gen-api": "set -o pipefail; node ./scripts/codegen-lexicon-files.js | xargs -0 -r lex gen-api --yes ./generated && npm run gen-index",
-    "gen-md": "set -o pipefail; node ./scripts/codegen-lexicon-files.js | xargs -0 -r lex gen-md --yes ./lexicons.md",
+    "//permissions": "permission-set lexicons are published as-is but have no TS shape; lex gen-* cannot codegen them. scripts/run-lex-codegen.js runs a lex subcommand over all lexicons EXCEPT permission-sets (excluded by content — the same check generate-exports.js uses). It is a single Node process that spawns lex with the file list as argv and forwards lex's exit code, so a producer failure propagates without `set -o pipefail` (not portable across npm's sh) and there is no ARG_MAX limit.",
+    "gen-api": "node ./scripts/run-lex-codegen.js gen-api --yes ./generated && npm run gen-index",
+    "gen-md": "node ./scripts/run-lex-codegen.js gen-md --yes ./lexicons.md",
     "gen-schemas-md": "node ./scripts/generate-schemas.js",
     "//gen-ts": "UNUSED - use gen-api instead",
-    "gen-ts": "set -o pipefail; node ./scripts/codegen-lexicon-files.js | xargs -0 -r lex gen-ts-obj > generated/DO-NOT-USE-lexicons.ts",
+    "gen-ts": "node ./scripts/run-lex-codegen.js gen-ts-obj > generated/DO-NOT-USE-lexicons.ts",
     "gen-index": "node ./scripts/generate-exports.js",
     "lex": "lex",
     "test": "vitest run",

scripts/codegen-lexicon-files.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+/**
+ * Run a `lex` codegen subcommand over every lexicon under `lexicons/` EXCEPT
+ * permission-set lexicons.
+ *
+ * `lex gen-api` / `gen-md` / `gen-ts` cannot codegen a `type: "permission-set"`
+ * def — it has no TypeScript shape and the CLI throws on it. Permission sets are
+ * published as-is, so they are excluded from codegen. The exclusion is by
+ * **content** (`defs.main.type === "permission-set"`), the same check
+ * `scripts/generate-exports.js` uses — so the two cannot drift as files move.
+ *
+ * Why a Node runner rather than a shell pipeline:
+ *  - `lex … $(node …)` swallows a producer failure (command substitution discards
+ *    its exit code) and can hit ARG_MAX.
+ *  - `node … | xargs -0 lex …` needs `set -o pipefail` to propagate a producer
+ *    failure, and `pipefail` is NOT portable across the `sh` npm runs scripts
+ *    with (rejected by the dash on GitHub's Ubuntu runners).
+ *  This runner is a single process with one authoritative exit code, passes the
+ *  file list to `lex` as argv (no shell, no ARG_MAX), and forwards lex's exit
+ *  code. No shell builtins involved.
+ *
+ * Usage (in package.json):
+ *   node ./scripts/run-lex-codegen.js gen-api --yes ./generated
+ *   node ./scripts/run-lex-codegen.js gen-ts-obj > generated/DO-NOT-USE-lexicons.ts
+ */
+
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const lexiconsDir = fileURLToPath(new URL("../lexicons", import.meta.url));
+
+function findJsonFiles(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...findJsonFiles(full));
+    else if (entry.isFile() && entry.name.endsWith(".json")) out.push(full);
+  }
+  return out;
+}
+
+function isPermissionSet(file) {
+  try {
+    return (
+      JSON.parse(readFileSync(file, "utf-8"))?.defs?.main?.type ===
+      "permission-set"
+    );
+  } catch {
+    return false; // let lex surface a parse error rather than silently skip
+  }
+}
+
+const lexArgs = process.argv.slice(2);
+if (lexArgs.length === 0) {
+  process.stderr.write(
+    "run-lex-codegen: expected a lex subcommand, e.g. `gen-api --yes ./generated`\n",
+  );
+  process.exit(2);
+}
+
+const files = findJsonFiles(lexiconsDir)
+  .filter((f) => !isPermissionSet(f))
+  .sort();
+
+// Fail loudly rather than run lex on an empty list (which could "succeed"
+// producing nothing).
+if (files.length === 0) {
+  process.stderr.write("run-lex-codegen: no lexicons found\n");
+  process.exit(1);
+}
+
+// `shell: false` (the default) — args are passed as argv, so there is no shell
+// word-splitting, no ARG_MAX limit from a command line, and lex's exit code is
+// ours. stdio inherited so `> file` redirection in the npm script still works.
+const result = spawnSync("lex", [...lexArgs, ...files], { stdio: "inherit" });
+if (result.error) {
+  process.stderr.write(
+    `run-lex-codegen: failed to spawn lex: ${result.error.message}\n`,
+  );
+  process.exit(1);
+}
+process.exit(result.status ?? 1);