bun-workspaces 1.0.1-alpha → 1.0.2

package/src/cli/commands/runScript/output/renderGroupedOutput.mjs

@@ -0,0 +1,331 @@
+import { runOnExit } from "../../../../internal/core/index.mjs";
+import {
+  TypedEventTarget,
+  createTypedEventFactory,
+} from "../../../../internal/core/language/events/typedEventTarget.mjs";
+import {
+  calculateVisibleLength,
+  truncateTerminalString,
+} from "../../../../internal/core/language/string/utf/visibleLength.mjs";
+import { logger } from "../../../../internal/logger/index.mjs";
+import { generatePlainOutputLines } from "./renderPlainOutput.mjs"; // CONCATENATED MODULE: external "../../../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../../../internal/core/language/events/typedEventTarget.mjs"
+// CONCATENATED MODULE: external "../../../../internal/core/language/string/utf/visibleLength.mjs"
+// CONCATENATED MODULE: external "../../../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./renderPlainOutput.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/runScript/output/renderGroupedOutput.ts
+
+class ScriptEventTarget extends TypedEventTarget {}
+const createScriptEventTarget = () => new ScriptEventTarget();
+const createScriptEvent = {
+  start: createTypedEventFactory("start"),
+  skip: createTypedEventFactory("skip"),
+  exit: createTypedEventFactory("exit"),
+};
+const cursorOps = {
+  up: (n) => `\x1b[${n}A`,
+  down: (n) => `\x1b[${n}B`,
+  toColumn: (n) => `\x1b[${n}G`,
+  hide: () => `\x1b[?25l`,
+  show: () => `\x1b[?25h`,
+};
+const lineOps = {
+  clearToEnd: () => `\x1b[0K`,
+  clearToStart: () => `\x1b[1K`,
+  clearFull: () => `\x1b[2K`,
+};
+const textOps = {
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  blue: (s) => `\x1b[34m${s}\x1b[0m`,
+  magenta: (s) => `\x1b[35m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  white: (s) => `\x1b[37m${s}\x1b[0m`,
+  gray: (s) => `\x1b[90m${s}\x1b[0m`,
+  intenseBlack: (s) => `\x1b[0;90m${s}\x1b[0m`,
+  intenseRed: (s) => `\x1b[0;91m${s}\x1b[0m`,
+  intenseGreen: (s) => `\x1b[0;92m${s}\x1b[0m`,
+  intenseYellow: (s) => `\x1b[0;93m${s}\x1b[0m`,
+  intenseBlue: (s) => `\x1b[0;94m${s}\x1b[0m`,
+  intenseMagenta: (s) => `\x1b[0;95m${s}\x1b[0m`,
+  intenseCyan: (s) => `\x1b[0;96m${s}\x1b[0m`,
+  intenseWhite: (s) => `\x1b[0;97m${s}\x1b[0m`,
+};
+const STATUS_COLORS = {
+  pending: "gray",
+  running: "intenseCyan",
+  skipped: "gray",
+  success: "intenseGreen",
+  failure: "intenseRed",
+  interrupted: "intenseYellow",
+  cancelled: "gray",
+  killed: "intenseRed",
+};
+const BORDER_COLOR = "blue";
+const renderGroupedOutput = async (
+  workspaces,
+  output,
+  summary,
+  scriptEventTarget,
+  activeScriptLines,
+  outputWriters,
+  terminalWidth,
+) => {
+  const workspaceState = workspaces.reduce((acc, workspace) => {
+    acc[workspace.name] = {
+      lines: [],
+      status: "pending",
+      exitCode: null,
+      signal: null,
+    };
+    return acc;
+  }, {});
+  let isInitialized = false;
+  const initializeTuiTerminal = () => {
+    if (isInitialized) {
+      return;
+    }
+    isInitialized = true;
+    logger.debug("Initializing TUI state");
+    outputWriters.stdout(cursorOps.hide());
+    process.stdin.setRawMode?.(true);
+  };
+  let isReset = false;
+  const resetTuiTerminal = () => {
+    if (isReset) {
+      return;
+    }
+    isReset = true;
+    logger.debug("Resetting TUI state");
+    outputWriters.stdout(cursorOps.show());
+    process.stdin.unref?.();
+    process.stdin.setRawMode?.(false);
+  };
+  let previousHeight = 0;
+  let didFinalRender = false;
+  const render = (isFinal = false) => {
+    if (didFinalRender) {
+      return;
+    }
+    if (isFinal) {
+      didFinalRender = true;
+    }
+    const width = Math.max(2, terminalWidth || process.stdout.columns);
+    const linesToWrite = [];
+    const workspaceBoxContents = {};
+    workspaces.forEach((workspace) => {
+      const state = workspaceState[workspace.name];
+      let statusText = state.status;
+      const hasExitCode = state.exitCode && state.exitCode !== -1;
+      const exitState =
+        hasExitCode && state.signal
+          ? "exitAndSignal"
+          : hasExitCode
+            ? "exit"
+            : state.signal
+              ? "signal"
+              : null;
+      if (exitState === "exitAndSignal") {
+        statusText += ` (exit code: ${state.exitCode}, signal: ${state.signal})`;
+      } else if (exitState === "exit") {
+        statusText += ` (exit code: ${state.exitCode})`;
+      } else if (exitState === "signal") {
+        statusText += ` (signal: ${state.signal})`;
+      }
+      const workspaceLine = "Workspace: " + textOps.bold(workspace.name);
+      const statusLine =
+        "   Status: " + textOps[STATUS_COLORS[state.status]](statusText);
+      workspaceBoxContents[workspace.name] = {
+        name: workspaceLine,
+        status: statusLine,
+      };
+    });
+    const padding = 4; // left border, spaces, right border
+    const workspaceBoxWidth = Math.min(
+      width,
+      Math.max(
+        ...Object.values(workspaceBoxContents).map((content) =>
+          Math.max(
+            calculateVisibleLength(content.name),
+            calculateVisibleLength(content.status),
+          ),
+        ),
+      ) + padding,
+    );
+    workspaces.forEach((workspace) => {
+      const state = workspaceState[workspace.name];
+      const { name: workspaceNameContent, status: statusTextContent } =
+        workspaceBoxContents[workspace.name];
+      linesToWrite.push({
+        text: textOps[BORDER_COLOR](
+          "┌" + "─".repeat(workspaceBoxWidth - 2) + "┐",
+        ),
+        type: "border",
+      });
+      const borderText = (text) => {
+        const visibleLength = calculateVisibleLength(text);
+        const truncated =
+          visibleLength > width - padding
+            ? truncateTerminalString(text, width - padding - 1) + "\x1b[0m…"
+            : text;
+        return (
+          textOps[BORDER_COLOR]("│ ") +
+          truncated +
+          " ".repeat(Math.max(0, workspaceBoxWidth - visibleLength - padding)) +
+          textOps[BORDER_COLOR](" │")
+        );
+      };
+      linesToWrite.push({
+        text: borderText(workspaceNameContent),
+        type: "borderedContent",
+      });
+      linesToWrite.push({
+        text: borderText(statusTextContent),
+        type: "borderedContent",
+      });
+      linesToWrite.push({
+        text: textOps[BORDER_COLOR](
+          "└" + "─".repeat(workspaceBoxWidth - 2) + "┘",
+        ),
+        type: "border",
+      });
+      if (
+        activeScriptLines !== "all" &&
+        state.lines.length > activeScriptLines &&
+        !isFinal
+      ) {
+        const hiddenLines = state.lines.length - activeScriptLines;
+        linesToWrite.push({
+          text: textOps.gray(
+            `(${hiddenLines} line${hiddenLines === 1 ? "" : "s"} hidden until exit)`,
+          ),
+          type: "scriptOutput",
+        });
+      }
+      linesToWrite.push(
+        ...state.lines
+          .slice(isFinal ? undefined : -activeScriptLines)
+          .map((line) => ({
+            text: line.text,
+            type: "scriptOutput",
+          })),
+      );
+      return linesToWrite;
+    });
+    if (previousHeight > 0) {
+      // clear previous frame
+      outputWriters.stdout(cursorOps.up(previousHeight));
+      for (let i = 0; i < previousHeight; i++) {
+        outputWriters.stdout(cursorOps.toColumn(1));
+        outputWriters.stdout(lineOps.clearFull());
+        outputWriters.stdout("\n");
+      }
+      outputWriters.stdout(cursorOps.up(previousHeight));
+    }
+    for (const line of linesToWrite) {
+      if (isFinal && line.type === "scriptOutput") {
+        outputWriters.stdout(line.text.replace(/\n?$/, "\n"));
+      } else {
+        const visibleLength = calculateVisibleLength(line.text);
+        const truncated =
+          visibleLength > width
+            ? truncateTerminalString(line.text, width - 2) + "\x1b[0m…"
+            : line.text;
+        outputWriters.stdout(truncated.replace(/\n?$/, "\n"));
+      }
+    }
+    previousHeight = linesToWrite.length;
+    if (isFinal) {
+      resetTuiTerminal();
+    }
+  };
+  const handleExitResult = (result) => {
+    const state = workspaceState[result.metadata.workspace.name];
+    if (result.signal) {
+      if (state.status === "running") {
+        if (result.signal === "SIGINT") {
+          state.status = "interrupted";
+        } else {
+          state.status = "killed";
+          state.signal = result.signal ?? null;
+        }
+      } else if (state.status === "pending") {
+        state.status = "cancelled";
+      }
+    } else {
+      state.status = result.skipped
+        ? "skipped"
+        : result.success
+          ? "success"
+          : "failure";
+    }
+    state.exitCode = result.exitCode ?? process.exitCode ?? null;
+  };
+  scriptEventTarget.addEventListener("start", (event) => {
+    const { workspace } = event;
+    workspaceState[workspace.name].status = "running";
+    render();
+  });
+  scriptEventTarget.addEventListener("skip", (event) => {
+    const { workspace } = event;
+    workspaceState[workspace.name].status = "skipped";
+    render();
+  });
+  scriptEventTarget.addEventListener("exit", (event) => {
+    if (event.exitResult) handleExitResult(event.exitResult);
+    render();
+  });
+  process.on("SIGWINCH", render);
+  process.stdin.on("data", (data) => {
+    if (data[0] === 0x03) process.kill(process.pid, "SIGINT");
+    if (data[0] === 0x1c) process.kill(process.pid, "SIGQUIT");
+  });
+  runOnExit((reason) => {
+    try {
+      if (typeof reason === "string" && reason.startsWith("SIG")) {
+        outputWriters.stdout("\r" + lineOps.clearFull());
+      }
+      Object.keys(workspaceState).forEach((workspaceName) => {
+        handleExitResult({
+          metadata: {
+            workspace: {
+              name: workspaceName,
+            },
+          },
+          skipped: false,
+          success: false,
+          exitCode:
+            typeof process.exitCode === "number" ? process.exitCode : -1,
+          signal: typeof reason === "string" ? reason : null,
+        });
+      });
+      render(true);
+    } finally {
+      resetTuiTerminal();
+    }
+  });
+  initializeTuiTerminal();
+  render();
+  for await (const { metadata, line } of generatePlainOutputLines(output, {
+    stripDisruptiveControls: true,
+    prefix: false,
+  })) {
+    const workspaceName = metadata.workspace.name;
+    workspaceState[workspaceName].lines.push({
+      text: line.replace(/\n$/, ""),
+      type: "scriptOutput",
+    });
+    render();
+  }
+  await summary.then((summary) => {
+    // fallback logic to resolve race conditions with script events
+    summary.scriptResults.forEach((result) => {
+      handleExitResult(result);
+    });
+    render(true);
+  });
+};
+
+export { createScriptEvent, createScriptEventTarget, renderGroupedOutput };

package/src/cli/commands/runScript/output/renderPlainOutput.d.ts

@@ -0,0 +1,24 @@
+import type { RunScriptAcrossWorkspacesOutput } from "../../../../project";
+import type { WriteOutputOptions } from "../../../createCli";
+export type RenderPlainOutputOptions = {
+  stripDisruptiveControls?: boolean;
+  prefix?: boolean;
+};
+export declare function generatePlainOutputLines(
+  output: RunScriptAcrossWorkspacesOutput,
+  { stripDisruptiveControls, prefix }: RenderPlainOutputOptions,
+): AsyncGenerator<
+  {
+    line: string;
+    metadata: import("../../../..").RunWorkspaceScriptMetadata & {
+      streamName: import("../../../..").OutputStreamName;
+    };
+  },
+  void,
+  unknown
+>;
+export declare const renderPlainOutput: (
+  output: RunScriptAcrossWorkspacesOutput,
+  outputWriters: Required<WriteOutputOptions>,
+  { stripDisruptiveControls, prefix }: RenderPlainOutputOptions,
+) => Promise<void>;

package/src/cli/commands/runScript/output/renderPlainOutput.mjs

@@ -0,0 +1,44 @@
+import { sanitizeChunk } from "./sanitizeChunk.mjs"; // CONCATENATED MODULE: external "./sanitizeChunk.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/runScript/output/renderPlainOutput.ts
+
+async function* generatePlainOutputLines(
+  output,
+  { stripDisruptiveControls = true, prefix = false },
+) {
+  const workspaceLineBuffers = {};
+  const formatLine = (line, workspaceName) => {
+    const prefixedLine = prefix ? `[${workspaceName}] ${line}` : line;
+    return `\x1b[0m${prefixedLine}`;
+  };
+  for await (const { metadata, chunk } of output.text()) {
+    const workspaceName = metadata.workspace.name;
+    const sanitizedChunk = sanitizeChunk(chunk, stripDisruptiveControls);
+    const prior = workspaceLineBuffers[workspaceName] ?? "";
+    const content = prior + sanitizedChunk;
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line)
+        yield {
+          line: formatLine(line, workspaceName),
+          metadata,
+        };
+    }
+    workspaceLineBuffers[workspaceName] = content.endsWith("\n")
+      ? ""
+      : (lines[lines.length - 1] ?? "");
+  }
+}
+const renderPlainOutput = async (
+  output,
+  outputWriters,
+  { stripDisruptiveControls = true, prefix = false },
+) => {
+  for await (const { line, metadata } of generatePlainOutputLines(output, {
+    stripDisruptiveControls,
+    prefix,
+  })) {
+    outputWriters[metadata.streamName](line + "\n");
+  }
+};
+
+export { generatePlainOutputLines, renderPlainOutput };

package/src/cli/commands/runScript/output/sanitizeChunk.d.ts

@@ -0,0 +1,4 @@
+export declare const sanitizeChunk: (
+  input: string,
+  stripDisruptiveControls?: boolean,
+) => string;

package/src/cli/commands/runScript/output/sanitizeChunk.mjs

@@ -0,0 +1,101 @@
+// CONCATENATED MODULE: ./src/cli/commands/runScript/output/sanitizeChunk.ts
+const sanitizeChunk = (input, stripDisruptiveControls = false) => {
+  if (!stripDisruptiveControls) {
+    return input.replace(/\r\n/g, "\n");
+  }
+  // 1) Normalize newline-ish controls
+  let normalizedText = input
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .replace(/\f/g, "\n")
+    .replace(/\v/g, "\n");
+  // 2) Remove disruptive single-byte controls (except \n, \t)
+  //    - backspace, bell, and C1 controls
+  // eslint-disable-next-line no-control-regex
+  normalizedText = normalizedText.replace(/[\b\x07\x80-\x9F]/g, "");
+  // 3) Strip ANSI sequences, keeping only SGR (CSI ... m)
+  //
+  // We'll scan rather than rely on one giant regex so we can:
+  // - keep SGR exactly
+  // - drop any other ESC sequence
+  // - handle incomplete ESC sequences conservatively (drop the ESC byte itself)
+  //
+  // ESC = \x1B
+  const ESC = "\x1B";
+  let result = "";
+  for (let index = 0; index < normalizedText.length; index++) {
+    const currentChar = normalizedText[index];
+    if (currentChar !== ESC) {
+      result += currentChar;
+      continue;
+    }
+    // If ESC is last char, drop it
+    if (index + 1 >= normalizedText.length) break;
+    const nextChar = normalizedText[index + 1];
+    // Keep only CSI ... m  (ESC [ ... m)
+    if (nextChar === "[") {
+      // Find final byte of CSI sequence (per spec: 0x40-0x7E).
+      // We only keep it if the final byte is 'm'.
+      let scanIndex = index + 2;
+      while (scanIndex < normalizedText.length) {
+        const code = normalizedText.charCodeAt(scanIndex);
+        if (code >= 0x40 && code <= 0x7e) break; // final byte
+        scanIndex++;
+      }
+      // If we didn't find a final byte, drop the ESC and stop (incomplete)
+      if (scanIndex >= normalizedText.length) break;
+      const finalByte = normalizedText[scanIndex];
+      if (finalByte === "m") {
+        // Keep full SGR sequence
+        result += normalizedText.slice(index, scanIndex + 1);
+      }
+      // else: drop the entire CSI sequence
+      index = scanIndex; // advance past sequence
+      continue;
+    }
+    // All other ESC sequences: drop them.
+    //
+    // For 2-byte sequences (like ESC c), we can just drop ESC+next.
+    // For string-terminated families (OSC/DCS/APC/PM/SOS), we should skip until terminator.
+    //
+    // OSC: ESC ] ... (BEL or ESC \)
+    // DCS: ESC P ... (ST = ESC \)
+    // APC: ESC _ ... (ST)
+    // PM : ESC ^ ... (ST)
+    // SOS: ESC X ... (ST)
+    if (
+      nextChar === "]" ||
+      nextChar === "P" ||
+      nextChar === "_" ||
+      nextChar === "^" ||
+      nextChar === "X"
+    ) {
+      let scanIndex = index + 2;
+      while (scanIndex < normalizedText.length) {
+        const currentByte = normalizedText[scanIndex];
+        // BEL terminator (OSC can end with BEL)
+        if (currentByte === "\x07") {
+          scanIndex++;
+          break;
+        }
+        // ST terminator: ESC \
+        if (
+          currentByte === ESC &&
+          scanIndex + 1 < normalizedText.length &&
+          normalizedText[scanIndex + 1] === "\\"
+        ) {
+          scanIndex += 2;
+          break;
+        }
+        scanIndex++;
+      }
+      index = scanIndex - 1; // -1 because loop will index++
+      continue;
+    }
+    // Fallback: treat as a 2-byte escape and drop ESC + next.
+    index += 1;
+  }
+  return result;
+};
+
+export { sanitizeChunk };

package/src/cli/createCli.d.ts

@@ -0,0 +1,25 @@
+import { type CliMiddlewareOptions } from "./middleware";
+export interface WriteOutputOptions {
+  stdout?: (...args: Parameters<typeof process.stdout.write>) => void;
+  stderr?: (...args: Parameters<typeof process.stderr.write>) => void;
+}
+export interface RunCliOptions {
+  argv?: string[];
+  /** Should be `true` if args do not include the binary name (e.g. `bunx bun-workspaces`) */
+  programmatic?: true;
+  middleware?: CliMiddlewareOptions;
+  writeOutput?: WriteOutputOptions;
+  terminalWidth?: number;
+}
+export interface CLI {
+  run: (options?: RunCliOptions) => Promise<void>;
+}
+export interface CreateCliOptions {
+  defaultCwd?: string;
+  /** Always handled when the result `.run()` is called */
+  defaultMiddleware?: CliMiddlewareOptions;
+}
+export declare const createCli: ({
+  defaultCwd,
+  defaultMiddleware,
+}?: CreateCliOptions) => CLI;

package/src/cli/createCli.mjs

@@ -0,0 +1,157 @@
+import { createCommand } from "commander";
+import package_0 from "../../package.json";
+import { validateCurrentBunVersion } from "../internal/bun/index.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import {
+  defineGlobalCommands,
+  defineProjectCommands,
+} from "./commands/index.mjs";
+import { commandOutputLogger } from "./commands/commandHandlerUtils.mjs";
+import { fatalErrorLogger } from "./fatalErrorLogger.mjs";
+import { initializeWithGlobalOptions } from "./globalOptions/index.mjs";
+import { resolveMiddleware } from "./middleware.mjs"; // CONCATENATED MODULE: external "commander"
+// CONCATENATED MODULE: external "../../package.json"
+// CONCATENATED MODULE: external "../internal/bun/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./commands/index.mjs"
+// CONCATENATED MODULE: external "./commands/commandHandlerUtils.mjs"
+// CONCATENATED MODULE: external "./fatalErrorLogger.mjs"
+// CONCATENATED MODULE: external "./globalOptions/index.mjs"
+// CONCATENATED MODULE: external "./middleware.mjs"
+// CONCATENATED MODULE: ./src/cli/createCli.ts
+
+const createCli = ({ defaultCwd = process.cwd(), defaultMiddleware } = {}) => {
+  logger.debug(`Creating CLI with default cwd: ${defaultCwd}`);
+  const run = async ({
+    argv = process.argv,
+    programmatic,
+    middleware: _runMiddleware,
+    writeOutput,
+    terminalWidth = process.stdout.columns,
+  } = {}) => {
+    const middleware = resolveMiddleware(
+      defaultMiddleware ?? {},
+      _runMiddleware ?? {},
+    );
+    const outputWriters = {
+      stdout: (...args) => process.stdout.write(...args),
+      stderr: (...args) => process.stderr.write(...args),
+      ...writeOutput,
+    };
+    logger.setPrintStdout(outputWriters.stdout);
+    logger.setPrintStderr(outputWriters.stderr);
+    commandOutputLogger.setPrintStdout(outputWriters.stdout);
+    commandOutputLogger.setPrintStderr(outputWriters.stderr);
+    const errorListener = (error) => {
+      middleware.catchError(error);
+      fatalErrorLogger.error(error);
+      process.exit(1);
+    };
+    process.on("unhandledRejection", errorListener);
+    try {
+      const program = createCommand("bun-workspaces")
+        .description("A CLI on top of native Bun workspaces")
+        .version(package_0.version)
+        .showHelpAfterError(true)
+        .configureOutput({
+          writeOut: outputWriters.stdout,
+          writeErr: outputWriters.stderr,
+          ...(terminalWidth
+            ? {
+                getOutHelpWidth: () => terminalWidth,
+                getErrHelpWidth: () => terminalWidth,
+              }
+            : {}),
+        });
+      const defaultContext = {
+        commanderProgram: program,
+      };
+      middleware.initProgram({
+        ...defaultContext,
+        argv,
+      });
+      const { args, postTerminatorArgs } = (() => {
+        const terminatorIndex = argv.findIndex((arg) => arg === "--");
+        return {
+          args: terminatorIndex !== -1 ? argv.slice(0, terminatorIndex) : argv,
+          postTerminatorArgs:
+            terminatorIndex !== -1 ? argv.slice(terminatorIndex + 1) : [],
+        };
+      })();
+      middleware.processArgv({
+        ...defaultContext,
+        args,
+        postTerminatorArgs,
+      });
+      const bunVersionError = validateCurrentBunVersion();
+      if (bunVersionError) {
+        fatalErrorLogger.error(bunVersionError.message);
+        process.exit(1);
+      }
+      const { project, projectError } = initializeWithGlobalOptions(
+        program,
+        args,
+        defaultCwd,
+        middleware,
+      );
+      middleware.findProject({
+        ...defaultContext,
+        project,
+        projectError,
+      });
+      if (postTerminatorArgs.length) {
+        logger.debug("Has post-terminator args");
+      }
+      logger.debug(`Bun version: ${Bun.version}`);
+      defineProjectCommands({
+        program,
+        project,
+        projectError,
+        postTerminatorArgs,
+        middleware,
+        outputWriters,
+        terminalWidth,
+      });
+      defineGlobalCommands({
+        program,
+        postTerminatorArgs,
+        middleware,
+        outputWriters,
+        terminalWidth,
+      });
+      logger.debug(`Commands initialized. Parsing args...`);
+      middleware.preParse({
+        ...defaultContext,
+        args,
+        project,
+        projectError,
+      });
+      await program.parseAsync(args, {
+        from: programmatic ? "user" : "node",
+      });
+      middleware.postParse({
+        ...defaultContext,
+        args,
+        project,
+        projectError,
+      });
+    } catch (error) {
+      if (error instanceof BunWorkspacesError) {
+        logger.debug(error);
+        fatalErrorLogger.error(error.message);
+        process.exit(1);
+      } else {
+        errorListener(error);
+      }
+    } finally {
+      process.off("unhandledRejection", errorListener);
+    }
+  };
+  return {
+    run,
+  };
+};
+
+export { createCli };

package/src/cli/fatalErrorLogger.d.ts

@@ -0,0 +1 @@
+export declare const fatalErrorLogger: import("../internal/logger").Logger;