bun-workspaces 1.8.1 → 1.9.0

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

@@ -0,0 +1,45 @@
+import { logger } from "../../../../internal/logger/index.mjs";
+
+const SHOW_CURSOR_SEQUENCE = "\x1b[?25h";
+const HIDE_CURSOR_SEQUENCE = "\x1b[?25l";
+/**
+ * Resets the controlling tty after the grouped-output TUI has owned it.
+ *
+ * Each step runs independently: when SIGINT is delivered to the whole
+ * process group via the raw-mode ^C handler, `setRawMode(false)` can
+ * race with child-process tty teardown and return EIO. A throw must
+ * not strand the cursor in a hidden state nor leave the tty in raw
+ * mode for any subsequent step.
+ *
+ * `setRawMode` runs before `unref` so the underlying tty handle is in
+ * a known, ref'd state for tcsetattr.
+ */ const resetTuiTerminalState = ({ stdout, stdin }) => {
+  try {
+    stdout(SHOW_CURSOR_SEQUENCE);
+  } catch (error) {
+    logger.debug("Failed to show cursor during TUI reset", {
+      error,
+    });
+  }
+  try {
+    stdin.setRawMode?.(false);
+  } catch (error) {
+    logger.debug("Failed to reset raw mode during TUI reset", {
+      error,
+    });
+  }
+  try {
+    stdin.pause();
+    stdin.unref?.();
+  } catch (error) {
+    logger.debug("Failed to detach stdin during TUI reset", {
+      error,
+    });
+  }
+};
+const initializeTuiTerminalState = ({ stdout, stdin }) => {
+  stdout(HIDE_CURSOR_SEQUENCE);
+  stdin.setRawMode?.(true);
+};
+
+export { initializeTuiTerminalState, resetTuiTerminalState };

package/src/cli/commands/runScript/scriptRunFlow.mjs

@@ -0,0 +1,213 @@
+import fs from "fs";
+import path from "path";
+import { expandHomePath } from "../../../internal/core/index.mjs";
+import { logger } from "../../../internal/logger/index.mjs";
+import {
+  getDefaultOutputStyle,
+  validateOutputStyle,
+} from "./output/outputStyle.mjs";
+import {
+  createScriptEvent,
+  createScriptEventTarget,
+  renderGroupedOutput,
+} from "./output/renderGroupedOutput.mjs";
+import { renderPlainOutput } from "./output/renderPlainOutput.mjs";
+
+const handleScriptRunFlow = async ({
+  project,
+  context,
+  script,
+  scriptArgs,
+  cliOptions,
+  runner,
+}) => {
+  const outputStyle = cliOptions.outputStyle
+    ? validateOutputStyle(cliOptions.outputStyle)
+    : getDefaultOutputStyle();
+  logger.debug(`Effective output style: ${outputStyle}`);
+  const scriptEventTarget = createScriptEventTarget();
+  const inline = cliOptions.inline
+    ? cliOptions.inlineName || cliOptions.shell
+      ? {
+          scriptName: cliOptions.inlineName,
+          shell: cliOptions.shell,
+        }
+      : true
+    : undefined;
+  const parallel =
+    typeof cliOptions.parallel === "boolean" ||
+    typeof cliOptions.parallel === "undefined"
+      ? undefined
+      : cliOptions.parallel === "true"
+        ? true
+        : cliOptions.parallel === "false"
+          ? false
+          : {
+              max: cliOptions.parallel,
+            };
+  const { output, summary, workspaces } = await runner({
+    script: script,
+    inline,
+    args: scriptArgs,
+    dependencyOrder: cliOptions.depOrder,
+    ignoreDependencyFailure: cliOptions.ignoreDepFailure,
+    ignoreOutput: outputStyle === "none",
+    onScriptEvent: (event, { workspace, exitResult }) => {
+      setTimeout(() =>
+        // place at end of call stack so listeners in render func receive event
+        scriptEventTarget.dispatchEvent(
+          createScriptEvent[event]({
+            workspace,
+            exitResult,
+          }),
+        ),
+      );
+    },
+    parallel,
+  });
+  const scriptName = cliOptions.inline
+    ? cliOptions.inlineName || "(inline)"
+    : script;
+  logger.debug(`Script name: ${scriptName}`);
+  const stripDisruptiveControls =
+    workspaces.length > 1 || !!cliOptions.parallel;
+  logger.debug(`Strip disruptive controls: ${stripDisruptiveControls}`);
+  let groupedLines = "auto";
+  if (cliOptions.groupedLines) {
+    if (cliOptions.groupedLines === "all") {
+      groupedLines = "all";
+    } else if (cliOptions.groupedLines === "auto") {
+      groupedLines = "auto";
+    } else {
+      const parsedGroupedLines = parseInt(cliOptions.groupedLines);
+      if (parsedGroupedLines <= 0 || isNaN(parsedGroupedLines)) {
+        logger.error(
+          `Invalid max grouped lines value: ${cliOptions.groupedLines}. Must be a positive number or "all".`,
+        );
+        process.exit(1);
+        return;
+      }
+      groupedLines = parsedGroupedLines;
+    }
+  }
+  logger.debug(`Effective grouped lines: ${JSON.stringify(groupedLines)}`);
+  if (!cliOptions.prefix) {
+    logger.warn(
+      "--no-prefix is deprecated and will be removed in a future version. Use --output-style=plain instead.",
+    );
+    if (!cliOptions.outputStyle) {
+      cliOptions.outputStyle = "plain";
+    }
+  }
+  const outputStyleHandlers = {
+    grouped: () =>
+      renderGroupedOutput(
+        workspaces,
+        output,
+        summary,
+        scriptEventTarget,
+        groupedLines,
+        context.outputWriters,
+        context.terminalWidth,
+        context.terminalHeight,
+      ),
+    prefixed: () =>
+      renderPlainOutput(output, context.outputWriters, {
+        prefix: true,
+        stripDisruptiveControls,
+      }),
+    plain: () =>
+      renderPlainOutput(output, context.outputWriters, {
+        prefix: false,
+        stripDisruptiveControls,
+      }),
+    none: async () => {
+      // no-op
+    },
+  };
+  await outputStyleHandlers[outputStyle]();
+  const exitResults = await summary;
+  exitResults.scriptResults.forEach(
+    ({ success, metadata: { workspace }, exitCode }) => {
+      const isSkipped = exitCode === -1;
+      if (isSkipped) {
+        logger.info(
+          `➖ ${workspace.name}: ${scriptName} (skipped due to dependency failure)`,
+        );
+      } else {
+        logger.info(
+          `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
+        );
+      }
+    },
+  );
+  const s = exitResults.scriptResults.length === 1 ? "" : "s";
+  const skippedCount = exitResults.scriptResults.filter(
+    ({ exitCode }) => exitCode === -1,
+  ).length;
+  const skippedMessage = skippedCount ? ` (${skippedCount} skipped)` : "";
+  if (exitResults.failureCount) {
+    const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed${skippedMessage}`;
+    logger.info(message);
+  } else {
+    logger.info(
+      `${exitResults.scriptResults.length} script${s} ran successfully${skippedMessage}`,
+    );
+  }
+  if (cliOptions.jsonOutfile) {
+    const fullOutputPath = path.resolve(
+      project.rootDirectory,
+      expandHomePath(cliOptions.jsonOutfile),
+    );
+    // Check if can make directory
+    const jsonOutputDir = path.dirname(fullOutputPath);
+    if (!fs.existsSync(jsonOutputDir)) {
+      try {
+        logger.debug(`Creating JSON output file directory "${jsonOutputDir}"`);
+        fs.mkdirSync(jsonOutputDir, {
+          recursive: true,
+        });
+      } catch (error) {
+        logger.error(
+          `Failed to create JSON output file directory "${jsonOutputDir}": ${error}`,
+        );
+        process.exit(1);
+        return;
+      }
+    } else if (fs.statSync(jsonOutputDir).isFile()) {
+      logger.error(
+        `Given JSON output file directory "${jsonOutputDir}" is an existing file`,
+      );
+      process.exit(1);
+      return;
+    }
+    // Check if can make file
+    if (
+      fs.existsSync(fullOutputPath) &&
+      fs.statSync(fullOutputPath).isDirectory()
+    ) {
+      logger.error(
+        `Given JSON output file path "${fullOutputPath}" is an existing directory`,
+      );
+      process.exit(1);
+      return;
+    }
+    try {
+      logger.debug(`Writing JSON output file "${fullOutputPath}"`);
+      fs.writeFileSync(fullOutputPath, JSON.stringify(exitResults, null, 2));
+    } catch (error) {
+      logger.error(
+        `Failed to write JSON output file "${fullOutputPath}": ${error}`,
+      );
+      process.exit(1);
+      return;
+    }
+    logger.info(`JSON output written to ${fullOutputPath}`);
+  }
+  if (exitResults.failureCount) {
+    process.exit(1);
+    return;
+  }
+};
+
+export { handleScriptRunFlow };