procband 0.2.0 → 0.2.2

package/README.md

@@ -20,7 +20,6 @@ import process from 'node:process'
 import { supervise } from 'procband'
 
 const proc = supervise({
-  name: 'api',
   command: process.execPath,
   args: ['-e', 'console.log("ready")'],
 })
@@ -30,6 +29,9 @@ const result = await proc
 console.log(result)
 ```
 
+`stdin` is disabled by default. Set `stdin: true` to write to `proc.stdin`, or
+pass a readable stream to `stdin` to pipe input automatically.
+
 ## Documentation Map
 
 - Concepts and lifecycle: [docs/context.md](docs/context.md)

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { ChildProcess } from "node:child_process";
-import { Writable } from "node:stream";
+import { Readable, Writable } from "node:stream";
 
 //#region src/types.d.ts
 /**
@@ -27,8 +27,10 @@ type MatchStream = 'stdout' | 'stderr' | 'both';
 interface ProcessConfig {
   /**
    * Stable identifier used in prefixed output and emitted match events.
+   *
+   * Defaults to the trailing `/[-\w]+$/` match from `command`.
    */
-  name: string;
+  name?: string;
   /**
    * Executable or shell-free command name passed to `spawn()`.
    */
@@ -65,6 +67,14 @@ interface ProcessConfig {
    * `process.stderr`.
    */
   stderr?: Writable;
+  /**
+   * Child stdin behavior.
+   *
+   * Defaults to `false`, which connects the child stdin to the null device.
+   * Use `true` to expose a writable `proc.stdin`, or pass a readable stream to
+   * pipe bytes into the child automatically.
+   */
+  stdin?: boolean | Readable;
   /**
    * Automatic restart behavior for terminal child exits.
    *
@@ -271,8 +281,8 @@ interface ProcbandProcess extends ChildProcess, PromiseLike<ProcessResult> {
  *
  * @param config The subprocess configuration to supervise.
  * @returns A `ChildProcess`-compatible wrapper with procband-specific helpers.
- * @throws When `config` is invalid, such as a missing `name`, missing
- * `command`, or an invalid reserved color.
+ * @throws When `config` is invalid, such as a missing `command`, a `command`
+ * that does not produce a fallback `name`, or an invalid reserved color.
  * @example
  * ```ts
  * import process from 'node:process'

package/dist/index.mjs

@@ -352,8 +352,8 @@ function isMissingProcessError(error) {
 *
 * @param config The subprocess configuration to supervise.
 * @returns A `ChildProcess`-compatible wrapper with procband-specific helpers.
-* @throws When `config` is invalid, such as a missing `name`, missing
-* `command`, or an invalid reserved color.
+* @throws When `config` is invalid, such as a missing `command`, a `command`
+* that does not produce a fallback `name`, or an invalid reserved color.
 * @example
 * ```ts
 * import process from 'node:process'
@@ -395,10 +395,10 @@ var ProcbandProcessImpl = class extends EventEmitter {
 	terminalResultObserved = false;
 	constructor(config) {
 		super();
-		validateProcessConfig(config);
+		const name = validateProcessConfig(config);
 		this.config = config;
-		this.name = config.name;
-		this.label = config.label ?? config.name;
+		this.name = name;
+		this.label = config.label ?? name;
 		this.color = resolveProcessColor(config.color);
 		this.matches = new MatchRegistry(this.name);
 		this.restart = new RestartController(config.restart);
@@ -516,7 +516,7 @@ var ProcbandProcessImpl = class extends EventEmitter {
 			cwd: this.config.cwd,
 			env: this.config.env,
 			stdio: [
-				"pipe",
+				this.config.stdin ? "pipe" : "ignore",
 				"pipe",
 				"pipe"
 			]
@@ -537,13 +537,15 @@ var ProcbandProcessImpl = class extends EventEmitter {
 				text: "",
 				flushed: false
 			},
-			closed: false
+			closed: false,
+			stdinCleanup: null
 		};
 		this.attempt = attempt;
 		this.attachAttempt(attempt);
 	}
 	attachAttempt(attempt) {
 		const { child } = attempt;
+		attempt.stdinCleanup = this.bindAttemptStdin(attempt);
 		child.on("spawn", () => {
 			if (this.attempt === attempt) this.emit("spawn");
 		});
@@ -556,6 +558,8 @@ var ProcbandProcessImpl = class extends EventEmitter {
 		child.on("close", (code, signal) => {
 			if (this.attempt !== attempt) return;
 			attempt.closed = true;
+			attempt.stdinCleanup?.();
+			attempt.stdinCleanup = null;
 			this.flushLineBuffer(attempt, "stdout");
 			this.flushLineBuffer(attempt, "stderr");
 			attempt.settleClose({
@@ -682,13 +686,27 @@ var ProcbandProcessImpl = class extends EventEmitter {
 		buffer.text = "";
 		this.handleLine(stream, line, false);
 	}
+	bindAttemptStdin(attempt) {
+		const source = this.config.stdin;
+		const destination = attempt.child.stdin;
+		if (!destination || typeof source !== "object") return null;
+		source.pipe(destination);
+		return () => {
+			source.unpipe(destination);
+		};
+	}
 };
 const liveProcesses = /* @__PURE__ */ new Set();
 let propagatedFailure = false;
 function validateProcessConfig(config) {
-	if (!config.name) throw new Error("ProcessConfig.name is required");
 	if (!config.command) throw new Error("ProcessConfig.command is required");
 	validateProcessColor(config.color);
+	const name = config.name || inferProcessName(config.command);
+	if (!name) throw new Error("ProcessConfig.name is required when command does not match /[-\\w]+$/");
+	return name;
+}
+function inferProcessName(command) {
+	return command.match(/[-\w]+$/)?.[0];
 }
 function getResultExitCode(code, signal) {
 	if (code != null) return code;

package/docs/context.md

@@ -35,8 +35,8 @@ Supervision adds four behaviors on top of raw `spawn()`:
 # Core Abstractions
 
 - `ProcessConfig`
-  Declares one supervised subprocess plus its label, color, restart policy, and
-  optional raw `stderr` tee.
+  Declares one supervised subprocess plus its label, color, restart policy,
+  optional stdin behavior, and optional raw `stderr` tee.
 - `ProcbandProcess`
   The live wrapper returned by `supervise()`. It is a `ChildProcess`-compatible
   handle, a matching surface, a shutdown surface, and a thenable final result.
@@ -52,14 +52,17 @@ Supervision adds four behaviors on top of raw `spawn()`:
 3. Each line is prefixed and written to the parent `process.stdout` or
    `process.stderr`.
 4. `stderr` can also be tee'd as raw bytes to `ProcessConfig.stderr`.
-5. Future matching lines are delivered through `match()` callbacks or
+5. `stdin` is disconnected by default. Set `ProcessConfig.stdin` to `true` for
+   a writable child stdin, or pass a readable stream to pipe input into the
+   child automatically.
+6. Future matching lines are delivered through `match()` callbacks or
    `waitFor()`.
-6. When a child exits, `procband` either finalizes or starts a new attempt,
+7. When a child exits, `procband` either finalizes or starts a new attempt,
    depending on the restart policy.
-7. A terminal failed exit that nobody observed through `await proc` or
+8. A terminal failed exit that nobody observed through `await proc` or
    `proc.wait()` sets `process.exitCode` and begins
    stopping any other live `procband` processes in the same parent script.
-8. `await proc` or `await proc.wait()` resolves only after the process is
+9. `await proc` or `await proc.wait()` resolves only after the process is
    terminal and no further restart will happen.
 
 # Common Tasks -> Recommended APIs
@@ -78,6 +81,10 @@ Supervision adds four behaviors on top of raw `spawn()`:
   Do not call `wait()` or await the thenable result
 - Capture raw child `stderr` in a file or custom stream:
   `ProcessConfig.stderr`
+- Write to child stdin manually:
+  `stdin: true`, then `proc.stdin?.write(...)`
+- Pipe a custom input stream into the child:
+  `stdin: readable`
 - Retry failed exits with sane defaults:
   `restart: true`
 - Use explicit retry rules:
@@ -102,18 +109,21 @@ Supervision adds four behaviors on top of raw `spawn()`:
   processes in the same parent script.
 - The wrapper survives restarts, but inherited `pid`, `stdin`, `stdout`,
   `stderr`, and related `ChildProcess` fields always refer to the current active
-  child attempt.
+  child attempt. `stdin` is `null` unless `ProcessConfig.stdin` is enabled.
 - `kill()` only signals the current direct child. `stop()` disables restart and
   kills the full process tree.
 - Parent cleanup installs both `SIGINT` and `SIGTERM` handlers while any live
   supervised process exists.
 - `stderr` prefixes always use the reserved red, even when a custom process
   color is configured.
+- `ProcessConfig.name` is optional. When omitted, it falls back to the
+  trailing `/[-\w]+$/` match from `command`.
 
 # Error Model
 
-- `supervise()` throws synchronously for invalid config such as missing `name`,
-  missing `command`, or an invalid reserved color.
+- `supervise()` throws synchronously for invalid config such as missing
+  `command`, a `command` that does not produce a fallback `name`, or an
+  invalid reserved color.
 - `waitFor()` rejects on timeout or terminal exit before a future match.
 - A thrown `match()` callback only unsubscribes that callback.
 - Errors from `ProcessConfig.stderr` stop teeing to that sink but do not stop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "procband",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Supervise subprocesses from TypeScript: prefix logs, wait for output patterns, and manage lifecycle/restarts.",
   "license": "MIT",
   "author": "Alec Larson",