@lablup/ui-common-cli 0.2.0-alpha.15

package/cli/diff.mjs

@@ -0,0 +1,125 @@
+/**
+ * A line diff, enough for a dry-run summary (+/- counts) and a unified
+ * preview. Plain LCS over the lines that differ after trimming the common
+ * head and tail, which is all a codemod's edits ever are.
+ */
+
+const MAX_CELLS = 25_000_000;
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {Array<{op: ' ' | '-' | '+', line: string}>}
+ */
+export function diffLines(a, b) {
+  const x = a.split("\n");
+  const y = b.split("\n");
+  let head = 0;
+  while (head < x.length && head < y.length && x[head] === y[head]) head++;
+  let tail = 0;
+  while (
+    tail < x.length - head &&
+    tail < y.length - head &&
+    x[x.length - 1 - tail] === y[y.length - 1 - tail]
+  ) {
+    tail++;
+  }
+  const xs = x.slice(head, x.length - tail);
+  const ys = y.slice(head, y.length - tail);
+  /** @type {Array<{op: ' ' | '-' | '+', line: string}>} */
+  const middle = [];
+  if ((xs.length + 1) * (ys.length + 1) > MAX_CELLS) {
+    for (const line of xs) middle.push({ op: "-", line });
+    for (const line of ys) middle.push({ op: "+", line });
+  } else {
+    const n = xs.length;
+    const m = ys.length;
+    const table = new Uint32Array((n + 1) * (m + 1));
+    for (let i = n - 1; i >= 0; i--) {
+      for (let k = m - 1; k >= 0; k--) {
+        table[i * (m + 1) + k] =
+          xs[i] === ys[k]
+            ? table[(i + 1) * (m + 1) + k + 1] + 1
+            : Math.max(table[(i + 1) * (m + 1) + k], table[i * (m + 1) + k + 1]);
+      }
+    }
+    let i = 0;
+    let k = 0;
+    while (i < n && k < m) {
+      if (xs[i] === ys[k]) {
+        middle.push({ op: " ", line: xs[i] });
+        i++;
+        k++;
+      } else if (table[(i + 1) * (m + 1) + k] >= table[i * (m + 1) + k + 1]) {
+        middle.push({ op: "-", line: xs[i++] });
+      } else {
+        middle.push({ op: "+", line: ys[k++] });
+      }
+    }
+    while (i < n) middle.push({ op: "-", line: xs[i++] });
+    while (k < m) middle.push({ op: "+", line: ys[k++] });
+  }
+  return [
+    ...x.slice(0, head).map((line) => ({ op: /** @type {' '} */ (" "), line })),
+    ...middle,
+    ...x.slice(x.length - tail).map((line) => ({ op: /** @type {' '} */ (" "), line })),
+  ];
+}
+
+/** @param {string} a @param {string} b */
+export function diffStat(a, b) {
+  let added = 0;
+  let removed = 0;
+  for (const { op } of diffLines(a, b)) {
+    if (op === "+") added++;
+    else if (op === "-") removed++;
+  }
+  return { added, removed };
+}
+
+/**
+ * A unified diff with three lines of context.
+ *
+ * @param {string} file
+ * @param {string} a before ('' for a new file)
+ * @param {string} b after
+ */
+export function unifiedDiff(file, a, b, context = 3) {
+  const lines = diffLines(a, b);
+  const out = [`--- a/${file}`, `+++ b/${file}`];
+  let i = 0;
+  let oldLine = 1;
+  let newLine = 1;
+  while (i < lines.length) {
+    if (lines[i].op === " ") {
+      i++;
+      oldLine++;
+      newLine++;
+      continue;
+    }
+    const start = Math.max(0, i - context);
+    let end = i;
+    // Extend while changes are within 2*context of each other.
+    for (;;) {
+      while (end < lines.length && lines[end].op !== " ") end++;
+      let next = end;
+      while (next < lines.length && lines[next].op === " " && next - end < context * 2)
+        next++;
+      if (next < lines.length && lines[next].op !== " ") end = next;
+      else break;
+    }
+    const stop = Math.min(lines.length, end + context);
+    const lead = i - start;
+    const hunk = lines.slice(start, stop);
+    const oldCount = hunk.filter((l) => l.op !== "+").length;
+    const newCount = hunk.filter((l) => l.op !== "-").length;
+    out.push(`@@ -${oldLine - lead},${oldCount} +${newLine - lead},${newCount} @@`);
+    for (const l of hunk) out.push(`${l.op}${l.line}`);
+    for (let k = i; k < stop; k++) {
+      if (lines[k].op !== "+") oldLine++;
+      if (lines[k].op !== "-") newLine++;
+    }
+    i = stop;
+  }
+  return out.join("\n");
+}

package/cli/lab-peer.mjs

@@ -0,0 +1,226 @@
+/**
+ * `@astryxdesign/lab` is a canary with an exact peer on the core canary it was
+ * cut from, not on the stable core ui-common pins. Left alone, pnpm installs
+ * that canary core beside ui-common's and npm nests one under lab, so
+ * `@lablup/ui-common/lab` runs on a second copy of Astryx (two React
+ * contexts: lab components stop seeing the theme). One override per package
+ * manager points lab's core at ui-common's:
+ *
+ * - pnpm (`pnpm-workspace.yaml`): `"@astryxdesign/lab>@astryxdesign/core": "<pin>"`
+ * - npm (`package.json`): `"overrides": {"@astryxdesign/lab": {"@astryxdesign/core": "<pin>"}}`
+ *
+ * README carries both recipes at the core pin; `sync-astryx` moves them with
+ * the pin, a test fails when they go stale, and `ui-common upgrade` applies
+ * the one for the project's package manager when it adds lab.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { dependencyDir } from "./paths.mjs";
+
+export const LAB = "@astryxdesign/lab";
+export const CORE = "@astryxdesign/core";
+export const PNPM_OVERRIDE_KEY = `${LAB}>${CORE}`;
+
+/** The installed lab's declared core peer, or null when lab is not installed. */
+export function labCorePeer() {
+  const dir = dependencyDir(LAB);
+  if (!dir) return null;
+  const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+  return pkg.peerDependencies?.[CORE] ?? null;
+}
+
+/** @param {string} pin */
+export const pnpmOverrideLine = (pin) => `"${PNPM_OVERRIDE_KEY}": "${pin}"`;
+
+/** @param {string} pin */
+export const npmOverride = (pin) => ({ [LAB]: { [CORE]: pin } });
+
+const esc = (/** @type {string} */ s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+
+// The value slot is group 2 in both.
+const PNPM_LINE = new RegExp(
+  String.raw`^([ \t]*["']?${esc(PNPM_OVERRIDE_KEY)}["']?[ \t]*:[ \t]*)(["']?[^"'\s#]+["']?)`,
+  "m",
+);
+const NPM_ENTRY = new RegExp(
+  String.raw`("${esc(LAB)}"\s*:\s*\{\s*"${esc(CORE)}"\s*:\s*)("[^"]*")`,
+);
+
+const unquote = (/** @type {string} */ s) => s.replace(/^["']|["']$/g, "");
+
+/**
+ * What is wrong with the recipes in `text` (README) for core `pin`: each one
+ * missing or at another version. Empty when both are current.
+ *
+ * @param {string} text
+ * @param {string} pin
+ * @returns {string[]}
+ */
+export function labOverrideProblems(text, pin) {
+  const problems = [];
+  for (const [name, pattern] of /** @type {const} */ ([
+    ["pnpm", PNPM_LINE],
+    ["npm", NPM_ENTRY],
+  ])) {
+    const match = pattern.exec(text);
+    if (!match)
+      problems.push(`the ${name} override for ${LAB}'s ${CORE} peer is missing`);
+    else if (unquote(match[2]) !== pin)
+      problems.push(
+        `the ${name} override pins ${CORE} ${unquote(match[2])}, not ${pin}`,
+      );
+  }
+  return problems;
+}
+
+/**
+ * `text` with both recipes moved to `pin`. Everything else is left as it is.
+ *
+ * @param {string} text
+ * @param {string} pin
+ */
+export function syncLabOverrideDocs(text, pin) {
+  return text
+    .replace(PNPM_LINE, (_m, head) => `${head}"${pin}"`)
+    .replace(NPM_ENTRY, (_m, head) => `${head}"${pin}"`);
+}
+
+/**
+ * The package manager a project installs with, from `packageManager` and the
+ * nearest lockfile or pnpm workspace file at or above `projectDir`.
+ *
+ * @param {string} projectDir
+ * @param {any} pkg the project's package.json
+ * @returns {{manager: 'pnpm' | 'npm' | 'yarn' | 'bun' | null, root: string, workspaceYaml: string | null}}
+ */
+export function detectPackageManager(projectDir, pkg) {
+  const declared = /^(pnpm|npm|yarn|bun)@/.exec(pkg?.packageManager ?? "")?.[1] ?? null;
+  const markers = /** @type {const} */ ([
+    ["pnpm-workspace.yaml", "pnpm"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+  ]);
+  for (let dir = projectDir; ;) {
+    const hit = markers.find(([file]) => existsSync(join(dir, file)));
+    if (hit) {
+      const manager = declared ?? hit[1];
+      const workspaceYaml =
+        manager === "pnpm"
+          ? (nearestUp(dir, "pnpm-workspace.yaml") ?? join(dir, "pnpm-workspace.yaml"))
+          : null;
+      return { manager, root: dir, workspaceYaml };
+    }
+    const parent = dirname(dir);
+    if (parent === dir || existsSync(join(dir, ".git"))) break;
+    dir = parent;
+  }
+  return {
+    manager: declared,
+    root: projectDir,
+    workspaceYaml: declared === "pnpm" ? join(projectDir, "pnpm-workspace.yaml") : null,
+  };
+}
+
+/**
+ * @param {string} start
+ * @param {string} file
+ */
+function nearestUp(start, file) {
+  for (let dir = start; ;) {
+    if (existsSync(join(dir, file))) return join(dir, file);
+    const parent = dirname(dir);
+    if (parent === dir || existsSync(join(dir, ".git"))) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Both recipes, for a note where neither could be applied.
+ *
+ * @param {string} pin
+ */
+export function recipesNote(pin) {
+  return `pnpm: \`overrides: { ${pnpmOverrideLine(pin)} }\` in pnpm-workspace.yaml; npm: \`"overrides": ${JSON.stringify(npmOverride(pin))}\` in the root package.json`;
+}
+
+/**
+ * Point lab's core peer at `pin` for one package manager.
+ *
+ * - npm: sets `pkg.overrides` in place (`pkg` is the parsed package.json).
+ * - pnpm: returns the edited `workspaceYaml` text (`null` in: a new file), or
+ *   undefined when it already holds the pin or has a shape this cannot edit.
+ * - anything else: only a note, with both recipes.
+ *
+ * @param {{manager: string | null, pin: string, pkg?: any, workspaceYaml?: string | null}} options
+ * @returns {{note: string, workspaceYaml?: string}}
+ */
+export function applyLabOverride({ manager, pin, pkg, workspaceYaml }) {
+  const why = `${LAB} peers on a core canary, and without it the lab components run on a second copy of ${CORE}`;
+  if (manager === "npm" && pkg) {
+    const current = pkg.overrides?.[LAB];
+    if (current !== undefined) {
+      const core = typeof current === "object" ? current?.[CORE] : undefined;
+      if (typeof core === "string" && core !== pin && !core.startsWith("$")) {
+        current[CORE] = pin;
+        return { note: `overrides["${LAB}"]["${CORE}"]: "${core}" → "${pin}".` };
+      }
+      return {
+        note: `overrides["${LAB}"] was left as it is; it must resolve ${LAB}'s ${CORE} to ${pin} (${recipesNote(pin)}).`,
+      };
+    }
+    pkg.overrides = { ...pkg.overrides, ...npmOverride(pin) };
+    return { note: `added overrides["${LAB}"]["${CORE}"] = "${pin}": ${why}.` };
+  }
+  if (manager === "pnpm") {
+    const line = pnpmOverrideLine(pin);
+    if (workspaceYaml == null) {
+      return {
+        workspaceYaml: `overrides:\n  ${line}\n`,
+        note: `wrote pnpm-workspace.yaml with overrides ${line}: ${why}.`,
+      };
+    }
+    // Only the top-level `overrides:` block counts: the same key under
+    // `peerDependencyRules.allowedVersions` silences a warning, nothing more.
+    const block = /^overrides:[ \t]*(\r?\n)/m.exec(workspaceYaml);
+    if (block) {
+      const at = block.index + block[0].length;
+      const after = workspaceYaml.slice(at);
+      const end = /^\S/m.exec(after)?.index ?? after.length;
+      const body = after.slice(0, end);
+      const existing = PNPM_LINE.exec(body);
+      if (existing) {
+        if (unquote(existing[2]) === pin) return { note: "" };
+        return {
+          workspaceYaml: `${workspaceYaml.slice(0, at)}${body.replace(
+            PNPM_LINE,
+            (_m, head) => `${head}"${pin}"`,
+          )}${after.slice(end)}`,
+          note: `pnpm-workspace.yaml overrides: ${PNPM_OVERRIDE_KEY} ${unquote(existing[2])} → ${pin}.`,
+        };
+      }
+      const indent = /^([ \t]+)\S/.exec(after)?.[1] ?? "  ";
+      return {
+        workspaceYaml: `${workspaceYaml.slice(0, at)}${indent}${line}\n${after}`,
+        note: `added ${line} to the overrides in pnpm-workspace.yaml: ${why}.`,
+      };
+    }
+    if (/^overrides\s*:/m.test(workspaceYaml)) {
+      return {
+        note: `pnpm-workspace.yaml has an overrides entry this cannot edit; add ${line} to it: ${why}.`,
+      };
+    }
+    const base = workspaceYaml.replace(/\s*$/, "");
+    return {
+      workspaceYaml: `${base}${base ? "\n\n" : ""}overrides:\n  ${line}\n`,
+      note: `added overrides: ${line} to pnpm-workspace.yaml: ${why}.`,
+    };
+  }
+  return {
+    note: `${manager ? `${manager} projects are not edited for this` : "no package manager was detected"}, so point ${LAB}'s ${CORE} peer at ui-common's by hand (${recipesNote(pin)}) and check that \`why ${CORE}\` lists one version.`,
+  };
+}

package/cli/main.mjs

@@ -0,0 +1,97 @@
+/**
+ * The `ui-common` command line: a thin wrapper over the exact-pinned Astryx
+ * CLI plus ui-common's own commands.
+ */
+import { AGENTS_HELP, agentsCommand } from "./agents.mjs";
+import { passthrough } from "./passthrough.mjs";
+import {
+  cliDependencyVersion,
+  cliPackageJson,
+  uiCommonPackageJson,
+  uiCommonRoot,
+} from "./paths.mjs";
+import { ASTRYX_COMMANDS } from "./rewrite.mjs";
+import { SYNC_HELP, syncAstryxCommand } from "./sync-astryx.mjs";
+import { UPGRADE_HELP, upgradeCommand } from "./upgrade.mjs";
+
+export const HELP = `Usage: ui-common <command> [options]
+
+@lablup/ui-common's CLI (@lablup/ui-common-cli). Astryx commands run the
+Astryx CLI it pins, with its output rewritten to ui-common import paths.
+
+One-off, before ui-common is installed or bumped (\`@next\` until 0.2.0 is
+published; npm's \`latest\` for this package is its first alpha):
+  pnpm dlx @lablup/ui-common-cli@next upgrade --from 0.1   (npx: npx @lablup/ui-common-cli@next …)
+Installed as a devDependency next to @lablup/ui-common:
+  pnpm exec ui-common <command>
+
+ui-common commands:
+  agents [--write <file>] [--check]
+        Print, write or check the ui-common agent block (UI-COMMON markers).
+  upgrade [--from <v>] [--to <v>] [--dry-run] [--diff] [--report <path>] [paths…]
+        Run the codemods between two ui-common versions and write a report.
+  sync-astryx <version> [--lab <version>] [--as <version>] [--dry-run]
+        Maintainers, inside the ui-common repository: move to a new Astryx.
+
+Astryx commands (rewritten to @lablup/ui-common paths):
+  ${ASTRYX_COMMANDS.filter((c) => c !== "upgrade" && c !== "help").join(", ")}
+  e.g. ui-common component Button, ui-common search "date picker",
+       ui-common docs tokens, ui-common build "settings page"
+
+  astryx <args…>   Run the pinned Astryx CLI as is, with no rewriting
+                   (e.g. \`ui-common astryx upgrade --from 0.6.0\`).
+
+Options:
+  -h, --help       Show this help (\`ui-common <command> --help\` for one command)
+  -V, --version    Print the @lablup/ui-common-cli version (the same as the
+                   @lablup/ui-common it ships with); --verbose adds the
+                   project's ui-common and the Astryx CLI
+
+Exit codes: a passed-through command exits with the Astryx CLI's code. ui-common
+commands exit 0 on success, 1 on a failed check or run, 2 on bad arguments.
+`;
+
+/**
+ * @param {string[]} argv process.argv.slice(2)
+ * @returns {Promise<number>}
+ */
+export async function main(argv) {
+  const [command, ...rest] = argv;
+  switch (command) {
+    case undefined:
+    case "-h":
+    case "--help":
+    case "help":
+      if (command === "help" && rest[0]) return main([rest[0], "--help"]);
+      process.stdout.write(HELP);
+      return 0;
+    case "-V":
+    case "--version":
+      process.stdout.write(`${cliPackageJson().version}\n`);
+      if (rest.includes("--verbose")) {
+        let uiCommon = "not installed";
+        try {
+          const root = uiCommonRoot();
+          uiCommon = `${uiCommonPackageJson(root).version} (${root})`;
+        } catch {
+          // reported as not installed
+        }
+        process.stdout.write(
+          `@lablup/ui-common ${uiCommon}\nastryx ${cliDependencyVersion("@astryxdesign/cli") ?? "not installed"}\n`,
+        );
+      }
+      return 0;
+    case "agents":
+      return agentsCommand(rest);
+    case "upgrade":
+      return upgradeCommand(rest);
+    case "sync-astryx":
+      return syncAstryxCommand(rest);
+    case "astryx":
+      return passthrough(rest, { raw: true });
+    default:
+      return passthrough(argv);
+  }
+}
+
+export { AGENTS_HELP, SYNC_HELP, UPGRADE_HELP };

package/cli/passthrough.mjs

@@ -0,0 +1,153 @@
+/**
+ * `ui-common <astryx command> …`: run the pinned Astryx CLI and hand its
+ * output back in ui-common terms.
+ *
+ * The child's stdout and stderr are buffered, rewritten, then written; the
+ * exit code is the child's. `--json` output is rewritten inside its strings
+ * and re-checked, so it stays valid JSON. Notes about hidden names go to
+ * stderr in that mode, never into the JSON.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { astryxBin, binInvocation, findProjectDir } from "./paths.mjs";
+import { createShadow, needsShadow } from "./shadow.mjs";
+import { exclusionNotes, rewriteOutput } from "./rewrite.mjs";
+
+const UI_COMMON_MARKER = "<!-- UI-COMMON:START -->";
+const AGENT_DOC_FILES = ["AGENTS.md", "CLAUDE.md", ".claude/CLAUDE.md", ".cursorrules"];
+
+/** @param {string} dir */
+function hasUiCommonBlock(dir) {
+  return AGENT_DOC_FILES.some((f) => {
+    const file = join(dir, f);
+    return existsSync(file) && readFileSync(file, "utf8").includes(UI_COMMON_MARKER);
+  });
+}
+
+/**
+ * Astryx nudges every command toward `astryx init` until an ASTRYX block
+ * exists. A ui-common project keeps a UI-COMMON block instead, so point the
+ * nudge there, or drop it when that block is present.
+ *
+ * @param {string} stderr
+ * @param {string} cwd
+ * @param {string} invocation
+ */
+function rewriteSetupNudge(stderr, cwd, invocation) {
+  const nudge =
+    /\n?Next step: run `[^`]*init` to finish setup and install the Astryx agent prompt\.\n?/;
+  if (!nudge.test(stderr)) return stderr;
+  const project = findProjectDir(cwd);
+  if (project && hasUiCommonBlock(project)) return stderr.replace(nudge, "");
+  return stderr.replace(
+    nudge,
+    `\nNext step: run \`${invocation} agents --write AGENTS.md\` to install the ui-common agent block.\n`,
+  );
+}
+
+/**
+ * Run the pinned astryx bin with `args` and collect its output.
+ *
+ * @param {string[]} args
+ * @param {{cwd?: string, env?: NodeJS.ProcessEnv}} [options]
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+export function runAstryx(args, { cwd = process.cwd(), env = process.env } = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(process.execPath, [astryxBin(), ...args], {
+      cwd,
+      env,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+    /** @type {Buffer[]} */
+    const out = [];
+    /** @type {Buffer[]} */
+    const err = [];
+    child.stdout.on("data", (chunk) => out.push(chunk));
+    child.stderr.on("data", (chunk) => err.push(chunk));
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      resolvePromise({
+        code: code ?? (signal ? 128 + (signalNumber(signal) ?? 1) : 1),
+        stdout: Buffer.concat(out).toString("utf8"),
+        stderr: Buffer.concat(err).toString("utf8"),
+      });
+    });
+  });
+}
+
+/** @param {NodeJS.Signals} signal */
+function signalNumber(signal) {
+  return { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15 }[signal];
+}
+
+/**
+ * Rewrite one captured run. Exported for the tests.
+ *
+ * @param {{stdout: string, stderr: string}} result
+ * @param {{args: string[], cwd: string, invocation: string}} ctx
+ */
+export function rewriteRun({ stdout, stderr }, { args, cwd, invocation }) {
+  const json = args.includes("--json");
+  let newStdout = rewriteOutput(stdout, invocation);
+  if (json && stdout.trim()) {
+    // Belt and braces: the substitutions cannot break JSON, but if they ever
+    // did, hand back Astryx's own output rather than something unparseable.
+    try {
+      JSON.parse(stdout);
+      try {
+        JSON.parse(newStdout);
+      } catch {
+        newStdout = stdout;
+      }
+    } catch {
+      // Astryx did not print JSON either; nothing to protect.
+    }
+  }
+  let newStderr = rewriteSetupNudge(rewriteOutput(stderr, invocation), cwd, invocation);
+  const notes = exclusionNotes(newStdout, args);
+  if (notes.length > 0) {
+    if (json) {
+      newStderr += `${newStderr && !newStderr.endsWith("\n") ? "\n" : ""}${notes.join("\n")}\n`;
+    } else {
+      newStdout += `${newStdout && !newStdout.endsWith("\n") ? "\n" : ""}\n${notes.join("\n")}\n`;
+    }
+  }
+  return { stdout: newStdout, stderr: newStderr };
+}
+
+/**
+ * @param {string[]} args
+ * @param {{raw?: boolean}} [options] raw: no rewriting (`ui-common astryx …`)
+ * @returns {Promise<number>} exit code
+ */
+export async function passthrough(args, { raw = false } = {}) {
+  const cwd = process.cwd();
+  let result;
+  if (needsShadow(args, cwd)) {
+    const shadow = createShadow(cwd);
+    try {
+      result = await runAstryx(args, { cwd: shadow.dir });
+    } finally {
+      shadow.cleanup();
+    }
+    // Paths Astryx printed point into the shadow; show the project's.
+    for (const key of /** @type {const} */ (["stdout", "stderr"])) {
+      result[key] = result[key].split(shadow.dir).join(shadow.projectDir);
+    }
+  } else {
+    result = await runAstryx(args, { cwd });
+  }
+  if (raw) {
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    return result.code;
+  }
+  const invocation = binInvocation(findProjectDir(cwd) ?? cwd);
+  const { stdout, stderr } = rewriteRun(result, { args, cwd, invocation });
+  process.stdout.write(stdout);
+  process.stderr.write(stderr);
+  return result.code;
+}