numux 2.9.0 → 2.10.1

package/README.md

@@ -130,7 +130,7 @@ numux -w dev -n redis="redis-server" --colors
 # Unnamed (name derived from command)
 numux "bun dev:api" "bun dev:web"
 
-# Named
+# Named process
 numux -n api="bun dev:api" -n web="bun dev:web"
 ```
 
@@ -256,6 +256,7 @@ Each process accepts:
 | `readyTimeout` | `number` | — | Milliseconds to wait for `readyPattern` before failing |
 | `maxRestarts` | `number` | `0` | Max auto-restart attempts on non-zero exit (0 = no restarts) |
 | `delay` | `number` | — | Milliseconds to wait before starting the process |
+| `optional` | `boolean` | `false` | Process is visible as a tab but not started automatically. Use Alt+S to start manually |
 | `condition` | `string` | — | Env var name; process skipped if falsy. Prefix with `!` to negate |
 | `platform` | `string \| string[]` | — | OS(es) this process runs on (e.g. `'darwin'`, `'linux'`). Non-matching processes are removed; dependents still start |
 | `stopSignal` | `string` | `SIGTERM` | Signal for graceful stop (`SIGTERM`, `SIGINT`, or `SIGHUP`) |
@@ -360,6 +361,24 @@ export default defineConfig({
 
 Falsy values: unset, empty string, `"0"`, `"false"`, `"no"`, `"off"` (case-insensitive). If a conditional process is skipped, its dependents are also skipped.
 
+### Optional processes
+
+Use `optional` for tools you want visible in tabs but not auto-started (e.g. Prisma Studio, debug servers):
+
+```ts
+export default defineConfig({
+  processes: {
+    app: { command: 'bun run dev' },
+    studio: {
+      command: 'bunx prisma studio',
+      optional: true,  // shows as stopped tab, start with Alt+S
+    },
+  },
+})
+```
+
+Unlike `condition`, optional processes don't cascade — their dependents still start normally.
+
 ### Dependency orchestration
 
 Each process starts as soon as its declared `dependsOn` dependencies are ready — it does not wait for unrelated processes. If a process fails, its dependents are skipped.

package/dist/config.js

@@ -1,3 +1,4 @@
+// @bun
 // src/config.ts
 function defineConfig(config) {
   return config;

package/dist/numux.js

@@ -37,7 +37,7 @@ var __require = import.meta.require;
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "numux",
-    version: "2.9.0",
+    version: "2.10.1",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -67,7 +67,7 @@ var require_package = __commonJS((exports, module) => {
       }
     },
     scripts: {
-      build: "bun build src/index.ts --outfile dist/numux.js --target bun --packages external && bun build src/config.ts --outfile dist/config.js --packages external && bunx tsc src/config.ts src/types.ts --emitDeclarationOnly --declaration --outDir dist --target ESNext --module ESNext --moduleResolution bundler && cp src/bin-wrapper.js dist/bin.js",
+      build: "bun run build.ts",
       prepublishOnly: "bun run build",
       dev: "cd example && bun run dev --debug",
       test: "bun test",
@@ -1237,6 +1237,7 @@ function validateConfig(raw, _warnings) {
     const processWatch = validateStringOrStringArray(p.watch);
     validated[name] = {
       command: p.command,
+      ...p.optional === true ? { optional: true } : {},
       cwd: processCwd ?? globalCwd,
       env: globalEnv || processEnv ? { ...globalEnv, ...processEnv } : undefined,
       envFile: processEnvFile ?? globalEnvFile,
@@ -1967,6 +1968,12 @@ class ProcessManager {
     const launches = this.tiers.flat().map(async (name) => {
       const proc = this.config.processes[name];
       const resolve8 = readyResolvers.get(name);
+      if (proc.optional) {
+        this.updateStatus(name, "stopped");
+        this.createRunner(name);
+        resolve8();
+        return;
+      }
       const deps = proc.dependsOn ?? [];
       if (deps.length > 0) {
         await Promise.all(deps.map((d) => readyPromises.get(d)));
@@ -2313,7 +2320,407 @@ import {
   LineNumberRenderable,
   ScrollBoxRenderable
 } from "@opentui/core";
-import { GhosttyTerminalRenderable } from "ghostty-opentui/terminal-buffer";
+
+// node_modules/ghostty-opentui/src/terminal-buffer.ts
+import {
+  TextBufferRenderable,
+  StyledText,
+  RGBA
+} from "@opentui/core";
+import { ptyToJson, PersistentTerminal, hasPersistentTerminalSupport, StyleFlags } from "ghostty-opentui";
+var DEFAULT_FG = RGBA.fromHex("#d4d4d4");
+var DEFAULT_BG = RGBA.fromHex("#1e1e1e");
+var TextAttributes = {
+  BOLD: 1 << 0,
+  DIM: 1 << 1,
+  ITALIC: 1 << 2,
+  UNDERLINE: 1 << 3,
+  BLINK: 1 << 4,
+  REVERSE: 1 << 5,
+  HIDDEN: 1 << 6,
+  STRIKETHROUGH: 1 << 7
+};
+function convertSpanToChunk(span) {
+  const { text, fg, bg, flags } = span;
+  let fgColor = fg ? RGBA.fromHex(fg) : DEFAULT_FG;
+  let bgColor = bg ? RGBA.fromHex(bg) : undefined;
+  if (flags & StyleFlags.INVERSE) {
+    const temp = fgColor;
+    fgColor = bgColor || DEFAULT_BG;
+    bgColor = temp;
+  }
+  let attributes = 0;
+  if (flags & StyleFlags.BOLD)
+    attributes |= TextAttributes.BOLD;
+  if (flags & StyleFlags.ITALIC)
+    attributes |= TextAttributes.ITALIC;
+  if (flags & StyleFlags.UNDERLINE)
+    attributes |= TextAttributes.UNDERLINE;
+  if (flags & StyleFlags.STRIKETHROUGH)
+    attributes |= TextAttributes.STRIKETHROUGH;
+  if (flags & StyleFlags.FAINT)
+    attributes |= TextAttributes.DIM;
+  return { __isChunk: true, text, fg: fgColor, bg: bgColor, attributes };
+}
+function applyHighlightsToLine(chunks, highlights) {
+  if (highlights.length === 0)
+    return chunks;
+  const result = [];
+  let col = 0;
+  for (const chunk of chunks) {
+    const chunkStart = col;
+    const chunkEnd = col + chunk.text.length;
+    const overlappingHighlights = highlights.filter((hl) => hl.start < chunkEnd && hl.end > chunkStart);
+    if (overlappingHighlights.length === 0) {
+      result.push(chunk);
+      col = chunkEnd;
+      continue;
+    }
+    let pos = 0;
+    const text = chunk.text;
+    const sortedHighlights = [...overlappingHighlights].sort((a, b) => a.start - b.start);
+    for (const hl of sortedHighlights) {
+      const hlStartInChunk = Math.max(0, hl.start - chunkStart);
+      const hlEndInChunk = Math.min(text.length, hl.end - chunkStart);
+      if (pos < hlStartInChunk) {
+        result.push({
+          __isChunk: true,
+          text: text.slice(pos, hlStartInChunk),
+          fg: chunk.fg,
+          bg: chunk.bg,
+          attributes: chunk.attributes
+        });
+      }
+      if (hlStartInChunk < hlEndInChunk) {
+        const highlightedText = text.slice(hlStartInChunk, hlEndInChunk);
+        const displayText = hl.replaceWithX ? "x".repeat(highlightedText.length) : highlightedText;
+        result.push({
+          __isChunk: true,
+          text: displayText,
+          fg: chunk.fg,
+          bg: RGBA.fromHex(hl.backgroundColor),
+          attributes: chunk.attributes
+        });
+      }
+      pos = hlEndInChunk;
+    }
+    if (pos < text.length) {
+      result.push({
+        __isChunk: true,
+        text: text.slice(pos),
+        fg: chunk.fg,
+        bg: chunk.bg,
+        attributes: chunk.attributes
+      });
+    }
+    col = chunkEnd;
+  }
+  return result;
+}
+function makeCursorChunk(char, style, original) {
+  if (style === "block") {
+    return {
+      __isChunk: true,
+      text: char,
+      fg: original?.bg || RGBA.fromHex("#1e1e1e"),
+      bg: original?.fg || DEFAULT_FG,
+      attributes: original?.attributes ?? 0
+    };
+  }
+  return {
+    __isChunk: true,
+    text: char,
+    fg: original?.fg || DEFAULT_FG,
+    bg: original?.bg,
+    attributes: (original?.attributes ?? 0) | TextAttributes.UNDERLINE
+  };
+}
+function applyCursorToLine(chunks, cursorX, cursorStyle) {
+  const totalLen = chunks.reduce((sum, c) => sum + c.text.length, 0);
+  if (cursorX >= totalLen) {
+    const gap = cursorX - totalLen;
+    if (gap > 0) {
+      return [...chunks, { __isChunk: true, text: " ".repeat(gap), attributes: 0 }, makeCursorChunk(" ", cursorStyle)];
+    }
+    return [...chunks, makeCursorChunk(" ", cursorStyle)];
+  }
+  const result = [];
+  let col = 0;
+  for (const chunk of chunks) {
+    const chunkEnd = col + chunk.text.length;
+    if (cursorX >= col && cursorX < chunkEnd) {
+      const pos = cursorX - col;
+      if (pos > 0) {
+        result.push({ ...chunk, text: chunk.text.slice(0, pos) });
+      }
+      result.push(makeCursorChunk(chunk.text[pos], cursorStyle, chunk));
+      if (pos + 1 < chunk.text.length) {
+        result.push({ ...chunk, text: chunk.text.slice(pos + 1) });
+      }
+    } else {
+      result.push(chunk);
+    }
+    col = chunkEnd;
+  }
+  return result;
+}
+function terminalDataToStyledText(data, highlights, cursor) {
+  const chunks = [];
+  const highlightsByLine = new Map;
+  if (highlights) {
+    for (const hl of highlights) {
+      const lineHighlights = highlightsByLine.get(hl.line) ?? [];
+      lineHighlights.push(hl);
+      highlightsByLine.set(hl.line, lineHighlights);
+    }
+  }
+  for (let i = 0;i < data.lines.length; i++) {
+    const line = data.lines[i];
+    let lineChunks = [];
+    if (line.spans.length === 0) {
+      lineChunks.push({ __isChunk: true, text: " ", attributes: 0 });
+    } else {
+      for (const span of line.spans) {
+        lineChunks.push(convertSpanToChunk(span));
+      }
+    }
+    const lineHighlights = highlightsByLine.get(i);
+    if (lineHighlights) {
+      lineChunks = applyHighlightsToLine(lineChunks, lineHighlights);
+    }
+    if (cursor && i === cursor.y) {
+      lineChunks = applyCursorToLine(lineChunks, cursor.x, cursor.style);
+    }
+    chunks.push(...lineChunks);
+    if (i < data.lines.length - 1) {
+      chunks.push({ __isChunk: true, text: `
+`, attributes: 0 });
+    }
+  }
+  return new StyledText(chunks);
+}
+
+class GhosttyTerminalRenderable extends TextBufferRenderable {
+  _ansi;
+  _cols;
+  _rows;
+  _limit;
+  _trimEnd;
+  _highlights;
+  _ansiDirty = false;
+  _lineCount = 0;
+  _showCursor = false;
+  _cursorStyle = "block";
+  _persistent = false;
+  _persistentTerminal = null;
+  constructor(ctx, options) {
+    super(ctx, {
+      ...options,
+      fg: DEFAULT_FG,
+      wrapMode: "none"
+    });
+    this._ansi = options.ansi ?? "";
+    this._cols = options.cols ?? 120;
+    this._rows = options.rows ?? 40;
+    this._limit = options.limit;
+    this._trimEnd = options.trimEnd;
+    this._highlights = options.highlights;
+    this._persistent = options.persistent ?? false;
+    this._showCursor = options.showCursor ?? false;
+    this._cursorStyle = options.cursorStyle ?? "block";
+    if (this._persistent && hasPersistentTerminalSupport()) {
+      this._persistentTerminal = new PersistentTerminal({
+        cols: this._cols,
+        rows: this._rows
+      });
+      if (this._ansi && (typeof this._ansi === "string" ? this._ansi.length > 0 : this._ansi.length > 0)) {
+        this._persistentTerminal.feed(this._ansi);
+      }
+    }
+    this._ansiDirty = true;
+  }
+  get lineCount() {
+    return this._lineCount;
+  }
+  get limit() {
+    return this._limit;
+  }
+  set limit(value) {
+    if (this._limit !== value) {
+      this._limit = value;
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get trimEnd() {
+    return this._trimEnd;
+  }
+  set trimEnd(value) {
+    if (this._trimEnd !== value) {
+      this._trimEnd = value;
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get highlights() {
+    return this._highlights;
+  }
+  set highlights(value) {
+    this._highlights = value;
+    this._ansiDirty = true;
+    this.requestRender();
+  }
+  get showCursor() {
+    return this._showCursor;
+  }
+  set showCursor(value) {
+    if (this._showCursor !== value) {
+      this._showCursor = value;
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get cursorStyle() {
+    return this._cursorStyle;
+  }
+  set cursorStyle(value) {
+    if (this._cursorStyle !== value) {
+      this._cursorStyle = value;
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get ansi() {
+    return this._ansi;
+  }
+  set ansi(value) {
+    if (this._ansi !== value) {
+      this._ansi = value;
+      if (this._persistentTerminal) {
+        this._persistentTerminal.reset();
+        if (value && (typeof value === "string" ? value.length > 0 : value.length > 0)) {
+          this._persistentTerminal.feed(value);
+        }
+      }
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get cols() {
+    return this._cols;
+  }
+  set cols(value) {
+    if (this._cols !== value) {
+      this._cols = value;
+      if (this._persistentTerminal) {
+        this._persistentTerminal.resize(value, this._rows);
+      }
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get rows() {
+    return this._rows;
+  }
+  set rows(value) {
+    if (this._rows !== value) {
+      this._rows = value;
+      if (this._persistentTerminal) {
+        this._persistentTerminal.resize(this._cols, value);
+      }
+      this._ansiDirty = true;
+      this.requestRender();
+    }
+  }
+  get persistent() {
+    return this._persistent;
+  }
+  set persistent(_value) {}
+  feed(data) {
+    if (!this._persistentTerminal) {
+      throw new Error("feed() is only available in persistent mode. Set persistent=true in options.");
+    }
+    this._persistentTerminal.feed(data);
+    this._ansiDirty = true;
+    this.requestRender();
+  }
+  reset() {
+    if (!this._persistentTerminal) {
+      throw new Error("reset() is only available in persistent mode. Set persistent=true in options.");
+    }
+    this._persistentTerminal.reset();
+    this._ansiDirty = true;
+    this.requestRender();
+  }
+  getCursor() {
+    if (!this._persistentTerminal) {
+      throw new Error("getCursor() is only available in persistent mode. Set persistent=true in options.");
+    }
+    return this._persistentTerminal.getCursor();
+  }
+  getText() {
+    if (this._persistentTerminal) {
+      return this._persistentTerminal.getText();
+    }
+    throw new Error("getText() in stateless mode is not implemented. Use persistent=true.");
+  }
+  destroy() {
+    if (this._persistentTerminal) {
+      this._persistentTerminal.destroy();
+      this._persistentTerminal = null;
+    }
+    super.destroy();
+  }
+  renderSelf(buffer) {
+    if (this._ansiDirty) {
+      let data;
+      if (this._persistentTerminal) {
+        data = this._persistentTerminal.getJson({
+          limit: this._limit
+        });
+      } else {
+        data = ptyToJson(this._ansi, {
+          cols: this._cols,
+          rows: this._rows,
+          limit: this._limit
+        });
+      }
+      if (this._trimEnd) {
+        while (data.lines.length > 0) {
+          const lastLine = data.lines[data.lines.length - 1];
+          const hasText = lastLine.spans.some((span) => span.text.trim().length > 0);
+          if (hasText)
+            break;
+          data.lines.pop();
+        }
+      }
+      const cursor = this._showCursor ? {
+        x: data.cursor[0],
+        y: Math.max(0, data.totalLines - data.rows + data.cursor[1] - data.offset),
+        style: this._cursorStyle
+      } : undefined;
+      const styledText = terminalDataToStyledText(data, this._highlights, cursor);
+      this.textBuffer.setStyledText(styledText);
+      this.updateTextInfo();
+      const lineInfo = this.textBufferView.logicalLineInfo;
+      if (lineInfo) {
+        this._lineCount = lineInfo.lineStarts.length;
+      }
+      this._ansiDirty = false;
+    }
+    super.renderSelf(buffer);
+  }
+  getScrollPositionForLine(lineNumber) {
+    const clampedLine = Math.max(0, Math.min(lineNumber, this._lineCount - 1));
+    const lineInfo = this.textBufferView.logicalLineInfo;
+    const lineStarts = lineInfo?.lineStarts;
+    let lineYOffset = clampedLine;
+    if (lineStarts && lineStarts.length > clampedLine) {
+      lineYOffset = lineStarts[clampedLine];
+    }
+    return this.y + lineYOffset;
+  }
+}
 
 // src/utils/timestamp.ts
 var DEFAULT_TIMESTAMP_FORMAT = "HH:mm:ss";
@@ -2789,7 +3196,7 @@ class SearchController {
 }
 
 // src/ui/status-bar.ts
-import { cyan, red, reverse, StyledText, TextRenderable, yellow } from "@opentui/core";
+import { cyan, red, reverse, StyledText as StyledText2, TextRenderable, yellow } from "@opentui/core";
 function plain(text) {
   return { __isChunk: true, text };
 }
@@ -2835,12 +3242,12 @@ class StatusBar {
   }
   buildContent() {
     if (this._tempMessage) {
-      return new StyledText([cyan(this._tempMessage)]);
+      return new StyledText2([cyan(this._tempMessage)]);
     }
     if (this._searchMode) {
       return this.buildSearchContent();
     }
-    return new StyledText([plain(STATUS_BAR_TEXT)]);
+    return new StyledText2([plain(STATUS_BAR_TEXT)]);
   }
   buildSearchContent() {
     const chunks = [];
@@ -2866,7 +3273,7 @@ class StatusBar {
       chunks.push(plain("  Enter: next"));
     }
     chunks.push(plain(`  Tab: ${isAllMode ? "single" : "all"}  Esc: close`));
-    return new StyledText(chunks);
+    return new StyledText2(chunks);
   }
 }
 
@@ -3529,8 +3936,8 @@ class PrefixDisplay {
       this.shutdown();
     });
     process.on("unhandledRejection", (reason) => {
-      const message = reason instanceof Error ? reason.message : String(reason);
-      process.stderr.write(`numux: unhandled rejection: ${message}
+      const stack = reason instanceof Error ? reason.stack : String(reason);
+      process.stderr.write(`numux: unhandled rejection: ${stack}
 `);
       this.shutdown();
     });
@@ -3941,10 +4348,10 @@ function setupShutdownHandlers(app, logWriter) {
     });
   });
   process.on("unhandledRejection", (reason) => {
-    const message = reason instanceof Error ? reason.message : String(reason);
-    log("Unhandled rejection:", message);
+    const stack = reason instanceof Error ? reason.stack : String(reason);
+    log("Unhandled rejection:", stack);
     app.shutdown().finally(() => {
-      process.stderr.write(`numux: unhandled rejection: ${message}
+      process.stderr.write(`numux: unhandled rejection: ${stack}
 `);
       logWriter?.cleanup();
       process.exit(1);

package/dist/types.d.ts

@@ -43,6 +43,8 @@ export interface NumuxProcessConfig<K extends string = string> {
      * @default false
      */
     interactive?: boolean;
+    /** Process is visible but not started automatically. Use Alt+S to start manually */
+    optional?: boolean;
     /** `true` = detect ANSI red output, string = regex pattern */
     errorMatcher?: boolean | string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numux",
-  "version": "2.9.0",
+  "version": "2.10.1",
   "description": "Terminal multiplexer with dependency orchestration",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outfile dist/numux.js --target bun --packages external && bun build src/config.ts --outfile dist/config.js --packages external && bunx tsc src/config.ts src/types.ts --emitDeclarationOnly --declaration --outDir dist --target ESNext --module ESNext --moduleResolution bundler && cp src/bin-wrapper.js dist/bin.js",
+    "build": "bun run build.ts",
     "prepublishOnly": "bun run build",
     "dev": "cd example && bun run dev --debug",
     "test": "bun test",