@lowlighter/run 3.0.0 → 3.4.0

package/README.md

@@ -16,12 +16,12 @@
 ```ts
 import { command } from "./command.ts"
 
-// Commands are run asynchronously, and support Deno.command options alongside additional options
-// For example, stdio can also be set to a Logger level too or you can automatically append an extension when running on Windows
-await command("deno", ["version"], { stdout: "debug", stderr: "piped", winext: ".exe" })
+// Commands are run asynchronously, and support Deno.Command options alongside additional options
+// Piped channels are captured into the result and mirrored to a LogTape sub-logger; you can also automatically append an extension when running on Windows
+await command("deno", ["--version"], { stdout: "piped", stderr: "piped", winext: ".exe" })
 
 // Commands can be run synchronously too, and can also throw an error automatically when the process exits with a non-zero code
-command("deno", ["version"], { sync: true, throw: true })
+command("deno", ["--version"], { sync: true, throw: true })
 ```
 
 ### Writing to stdin
@@ -31,15 +31,16 @@ import { command } from "./command.ts"
 
 const { stdout } = await command("deno", ["repl"], {
   env: { NO_COLOR: "true" },
-  // Passing a callback will automatically set `stdin` to `"piped"`
-  // You can then write to the process using utility functions
-  callback: async ({ i, stdio, write, close, wait }) => {
-    if ((!stdio.stdout.includes("exit using")) || i) {
+  // Passing a callback automatically pipes stdin.
+  // The callback is an async generator: `for await` over `stdio` to react to output,
+  // `yield` to write to stdin (verbatim — add your own newlines), and `return` to close it.
+  callback: async function* ({ stdio }) {
+    for await (const { stdout } of stdio) {
+      if (!stdout.includes("exit using"))
+        continue
+      yield "console.log('hello')\n"
       return
     }
-    await write("console.log('hello')")
-    await wait(1000)
-    close()
   },
 })
 console.assert(stdout.includes("hello"))
@@ -47,12 +48,28 @@ console.assert(stdout.includes("hello"))
 
 ## ✨ Features
 
-- Supports `stdin` interactivity through callbacks.
-  - Make it possible to monitor `stdout` and `stderr` content and react accordingly.
+- Supports `stdin` interactivity through an async generator callback.
+  - `for await` over process output, `yield` to write to stdin, `return` to close it.
 - Auto-detects os and can automatically append an extension when running on Windows.
 - Supports both `sync` and `async` modes in a single function.
   - Optionally decide to throw an error when the process exits with a non-zero code.
+- Background processes support `await using` for automatic cleanup (killed and awaited on scope exit).
 - Generates a `stdio` history that contains timestamped entries with configurable buffering
+- Integrates with [`LogTape`](https://logtape.org): each piped channel is mirrored to a sub-logger (`stdin`/`stdout`/`stderr`).
+  - Logging defaults to the `["run"]` category, leaving output configuration to the host application.
+
+## 🕊️ Migrating from `3.x.x` to `4.x.x`
+
+Version `4.x.x` replaces the [`@libs/logger`](https://jsr.io/@libs/logger) dependency with [`LogTape`](https://logtape.org) and reworks the stdin callback:
+
+- The `logger` option is now a category (`string[]`) forwarded to `getLogger()`, defaulting to `["run"]`.
+  - As recommended for libraries, `command()` never calls `configure()` — the host application is in charge of setting up sinks and levels.
+  - Each channel is mirrored to a sub-logger: `stdin` at `debug`, `stdout` at `info`, `stderr` at `error`.
+- The `stdin`, `stdout` and `stderr` options now only accept `"piped"`, `"inherit"` or `null` (log levels are no longer set per-channel).
+- The `callback` option is now an **async generator** instead of a function:
+  - `for await (const { stdout } of stdio)` to react to output, `yield "text"` to write to stdin (verbatim, no automatic newline), and `return` to close it.
+  - The `write()`, `close()` and `wait()` helpers are gone — use `yield`, `return` and `await` respectively.
+  - If the generator throws, stdin is closed, the process is killed, and the result rejects with the error.
 
 ## 🕊️ Migrating from `2.x.x` to `3.x.x`
 

package/command.d.ts

@@ -0,0 +1,138 @@
+import type { Nullable, Promisable } from "@lowlighter/typing";
+import { type Logger } from "@logtape/logtape";
+export type { Logger, Promisable };
+/**
+ * Handling of a stdio channel.
+ * - `"piped"`: the channel is captured into the {@link Result} and mirrored to a {@link https://logtape.org | LogTape} sub-logger.
+ * - `"inherit"`: the channel is forwarded to the parent process.
+ * - `null`: the channel is discarded.
+ */ export type Channel = Nullable<"piped" | "inherit">;
+/** Run options. */ export type Options = {
+  /**
+   * Logger categories forwarded to {@link https://logtape.org | LogTape}'s `getLogger()`.
+   * Each channel is mirrored through a sub-category (`stdin`, `stdout`, `stderr`) so the host application can route or filter them.
+   * Defaults to `["run"]`.
+   */ logger?: string[];
+  /** Environment variables. */ env?: Deno.CommandOptions["env"];
+  /** Current working directory. */ cwd?: Deno.CommandOptions["cwd"];
+  /** Raw arguments (Windows only). */ raw?: boolean;
+  /** Handling of stdin. */ stdin?: Channel;
+  /** Handling of stdout. */ stdout?: Channel;
+  /** Handling of stderr. */ stderr?: Channel;
+  /**
+   * Stdin interaction callback.
+   * Passing this option automatically pipes stdin.
+   * See {@link Callback} for the interaction protocol.
+   */ callback?: Callback;
+  /**
+   * Stdio buffering.
+   * This is used to merge messages that are received relatively closely.
+   * Buffering is skipped when a different channel is used in-between.
+   */ buffering?: number;
+  /** Abort signal. */ signal?: Deno.CommandOptions["signal"];
+  /**
+   * Execute process synchronously.
+   * Note that stdin is not usable in sync mode.
+   */ sync?: boolean;
+  /**
+   * Run process in background.
+   * This implies `sync: false`.
+   */ background?: boolean;
+  /** Process extension on Windows. */ winext?: string;
+  /** Operating system. */ os?: typeof Deno.build.os;
+  /** Throw an error if exit code is non-zero rather than returning a result. */ throw?: boolean;
+  /**
+   * Do not actually execute the command.
+   * In this case you will instead receive an empty successful result object.
+   */ dryrun?: boolean;
+};
+/** Run result. */ export type Result = {
+  /** Whether the process exited with a zero-code. */ success: Deno.CommandStatus["success"];
+  /** Process exit code. */ code: Deno.CommandStatus["code"];
+  /**
+   * Process stdio content.
+   * First element is the delta timestamp since process start, second element is the channel (0:stdin, 1:stdout, 2:stderr), third element is the content.
+   */ stdio: Array<[number, 0 | 1 | 2, string]>;
+  /** Process stdin content. */ stdin: string;
+  /** Process stdout content. */ stdout: string;
+  /** Process stderr content. */ stderr: string;
+};
+/** Handle to a process running in background. */ export type Background = {
+  /** Send a signal to the process (defaults to `"SIGTERM"`). */ kill: (signal?: Deno.Signal) => Promise<void>;
+  /** Prevent the process from keeping the parent process alive. */ unref: () => void;
+  /** Process identifier. */ pid: number;
+  /** Process result (resolves once the process exits). */ result: Promise<Result>;
+  /** Kill the process and wait for it to fully terminate. */ [Symbol.asyncDispose]: () => Promise<void>;
+};
+/** Snapshot of the accumulated process stdio content. */ export type Snapshot = Pick<Result, "stdin" | "stdout" | "stderr">;
+/**
+ * Stdin interaction callback.
+ *
+ * It is an async generator that lets you drive an interactive process with plain language constructs:
+ * ```ts ignore
+ * // Iterate over process output to react to new data.
+ * // (one iteration per buffered event)
+ * for await (const { stdout } of stdio) {
+ *   // Use await to pause or poll for a condition
+ *   await delay(1000)
+ *   // Use yield to write to stdin (verbatim)
+ *   yield "content\n"
+ *   // Use return to close stdin and end the interaction
+ *   return
+ * }
+ * ```
+ *
+ * If the generator throws, stdin is closed, the process is killed and the returned {@link Result} rejects with the thrown error.
+ * When the process exits on its own, the `stdio` iterator ends, so a generator parked on `for await` completes naturally.
+ */ export type Callback = (options: {
+  stdio: AsyncIterable<Snapshot>;
+}) => AsyncGenerator<string, void, unknown>;
+/**
+ * Asynchronous version of {@link command} running in background.
+ *
+ * ```ts
+ * import { command } from "./command.ts"
+ * const process = command("deno", ["eval", "Deno.exit(0)"], { background: true })
+ * await process.kill()
+ * ```
+ */ export declare function command(bin: string, args: string[], options?: Options & {
+  sync?: false;
+  background: true;
+}): Background;
+/**
+ * Asynchronous version of {@link command}.
+ *
+ * ```ts
+ * import { command } from "./command.ts"
+ * try {
+ *   await command("deno", ["eval", "Deno.exit(1)"], { throw: true })
+ * }
+ * catch (error) {
+ *   console.log(error)
+ * }
+ * ```
+ */ export declare function command(bin: string, args: string[], options?: Options & {
+  sync?: false;
+  background?: false;
+}): Promise<Result>;
+/**
+ * Synchronous version of {@link command}.
+ *
+ * Note that stdin is not usable in sync mode and will always be empty.
+ *
+ * ```ts
+ * import { command } from "./command.ts"
+ * command("deno", ["--version"], { sync: true })
+ * ```
+ * ```ts
+ * import { command } from "./command.ts"
+ * try {
+ *   command("deno", ["eval", "Deno.exit(1)"], { sync: true, throw: true })
+ * }
+ * catch (error) {
+ *   console.log(error)
+ * }
+ * ```
+ */ export declare function command(bin: string, args: string[], options?: Options & {
+  sync: true;
+}): Result;

package/command.js

@@ -0,0 +1,332 @@
+// Imports
+import { getLogger } from "@logtape/logtape";
+import { TextLineStream } from "@std/streams";
+import { debounce } from "@std/async/debounce";
+/** Text encoder */ const encoder = new TextEncoder();
+/** Text decoder */ const decoder = new TextDecoder();
+/** Default interaction: an empty generator that closes stdin immediately. */ const noop = async function*() {};
+/**
+ * Run a command.
+ *
+ * This is a wrapper around {@link https://docs.deno.com/api/deno/~/Deno.Command | Deno.Command} that provides a better handling of stdio for interactive processes.
+ *
+ * Like `Deno.Command`, the `env`, `cwd`, and `raw` (alias for `windowsRawArguments`) options are supported.
+ *
+ * The `stdin`, `stdout` and `stderr` options accept `"piped"` (captured into the result and mirrored to a {@link https://logtape.org | LogTape} sub-logger), `"inherit"` (forwarded to the parent process) or `null` (discarded).
+ *
+ * Logging is performed through {@link https://logtape.org | LogTape}.
+ * The `logger` option is a category forwarded to `getLogger()` (defaulting to `["run"]`), and each channel is mirrored through its own sub-category — `stdin` at `debug`, `stdout` at `info`, `stderr` at `error`.
+ * As recommended for libraries, `command()` never configures LogTape itself: the host application is in charge of the actual output (through {@link https://logtape.org/manual/config | LogTape configuration}).
+ *
+ * Set `winext` option to automatically append an extension to the binary path on Windows (like `.cmd` or `.exe`).
+ * This is useful when the binary path isn't automatically resolved on Windows.
+ *
+ * Pass a `callback` option (an async generator) to interact with the process stdin.
+ * See {@link Callback} for the interaction protocol: `for await` over `stdio` to read output, `yield` to write to stdin, `return` to close it.
+ *
+ * The `buffering` option is used to merge messages that are received relatively closely.
+ * Setting this option to a low value will also increase the rate at which the interaction generator is resumed.
+ *
+ * Resulting object contains the same properties as {@link https://docs.deno.com/api/deno/~/Deno.CommandStatus | Deno.CommandStatus}
+ * with an additional `stdio` property that contains an array of ordered tuples with the delta timestamp since process start, the channel idenfitier (0:stdin, 1:stdout, 2:stderr) and the content.
+ * This offers a proper history of exchanged content.
+ *
+ * ```ts
+ * import { command } from "./command.ts"
+ * await command("deno", ["--version"], { env: { NO_COLOR: "true" }, cwd: "/tmp", raw: true })
+ * await command("deno", ["--version"], { stdout: "piped" })
+ * await command("deno", ["--version"], { logger: ["my-app", "run"], stdout: "piped" })
+ * await command("deno", ["--version"], { winext: ".exe" })
+ * ```
+ *
+ * ```ts
+ * import { command } from "./command.ts"
+ *
+ * const { stdout } = await command("deno", ["repl"], {
+ *   env: { NO_COLOR: "true" },
+ *   // Passing a callback automatically pipes stdin.
+ *   // Iterate `stdio` to react to output, `yield` to write to stdin (verbatim), `return` to close it.
+ *   callback: async function* ({ stdio }) {
+ *     for await (const { stdout } of stdio) {
+ *       if (!stdout.includes("exit using")) {
+ *         continue
+ *       }
+ *       yield "console.log('hello')\n"
+ *       return
+ *     }
+ *   },
+ * })
+ * console.assert(stdout.includes("hello"))
+ * ```
+ *
+ * @author Simon Lecoq (lowlighter)
+ * @license MIT
+ * @module
+ */ export function command(bin, args, { logger: category = [
+  "run"
+], stdin = null, stdout = "piped", stderr = "piped", env, cwd, raw, callback, buffering, signal, sync, background, throw: _throw, dryrun, winext = "", os = Deno.build.os } = {}) {
+  if (os === "windows") bin = `${bin}${winext}`;
+  const log = getLogger(category).with({
+    bin
+  });
+  if (callback && handle(stdin) !== "piped") stdin = "piped";
+  const command1 = new Deno.Command(bin, {
+    args,
+    stdin: !sync ? handle(stdin) : "null",
+    stdout: handle(stdout),
+    stderr: handle(stderr),
+    clearEnv: true,
+    env,
+    cwd,
+    windowsRawArguments: raw,
+    signal,
+    detached: background
+  });
+  if (dryrun) {
+    log.warn("dryrun: {bin} not executed", {
+      bin
+    });
+    const result = {
+      success: true,
+      code: 0,
+      stdio: [],
+      stdin: "",
+      stdout: "",
+      stderr: ""
+    };
+    return sync ? result : Promise.resolve(result);
+  }
+  if (sync) return exec(command1, {
+    bin,
+    log,
+    throw: _throw,
+    stdout,
+    stderr
+  });
+  return spawn(command1, {
+    bin,
+    log,
+    callback,
+    buffering,
+    throw: _throw,
+    background,
+    stdin,
+    stdout,
+    stderr
+  });
+}
+/** Returns the handle type for a given mode. */ function handle(mode) {
+  return [
+    "inherit",
+    "null"
+  ].includes(`${mode}`) ? `${mode}` : "piped";
+}
+/** Execute a command synchronously. */ function exec(command, { bin, log, throw: _throw, stdout, stderr }) {
+  const start = Date.now();
+  const output = command.outputSync();
+  const { success, code } = output // Do not access stdout or stderr before "piped" status check
+  ;
+  const t = Date.now() - start;
+  const stdio = {
+    get stdio () {
+      return [
+        [
+          t,
+          1,
+          this.stdout
+        ],
+        [
+          t,
+          2,
+          this.stderr
+        ]
+      ];
+    },
+    stdin: "",
+    stdout: handle(stdout) === "piped" ? decoder.decode(output.stdout) : "",
+    stderr: handle(stderr) === "piped" ? decoder.decode(output.stderr) : ""
+  };
+  for (const { channel, mode } of [
+    {
+      channel: "stdout",
+      mode: stdout
+    },
+    {
+      channel: "stderr",
+      mode: stderr
+    }
+  ]){
+    if (handle(mode) === "piped" && stdio[channel]) logged(log, channel, t, stdio[channel]);
+  }
+  if (!success && _throw) throw new EvalError(`${bin} exited with non-zero code ${code}:\n${stdio.stdout}\n${stdio.stderr}`);
+  return {
+    success,
+    code,
+    ...stdio
+  };
+}
+/** Spawn a command. */ function spawn(command, { bin, log, callback = noop, buffering = 250, throw: _throw, background, ...channels }) {
+  const process = command.spawn();
+  const start = Date.now();
+  const stdio = {
+    stdio: [],
+    get stdin () {
+      return this.stdio.filter(([_, i])=>i === 0).map(([_, __, content])=>content).join("");
+    },
+    get stdout () {
+      return this.stdio.filter(([_, i])=>i === 1).map(([_, __, content])=>content).join("\n");
+    },
+    get stderr () {
+      return this.stdio.filter(([_, i])=>i === 2).map(([_, __, content])=>content).join("\n");
+    }
+  };
+  let last = "";
+  // Drive the interaction generator when stdin is piped
+  let release = ()=>{};
+  let notify = null;
+  let pending = true;
+  let ended = false;
+  let interaction = Promise.resolve();
+  if (handle(channels.stdin) === "piped") {
+    const writer = process.stdin.getWriter();
+    const close = async ()=>{
+      try {
+        await writer.close();
+        log.with({
+          t: Date.now() - start
+        }).trace("closed stdin");
+      } catch  {
+      // Ignore (stdin may already be closed if the process exited)
+      }
+    };
+    release = ()=>{
+      ended = true;
+      notify?.();
+      notify = null;
+    };
+    const input = {
+      async *[Symbol.asyncIterator] () {
+        while(true){
+          if (pending) {
+            pending = false;
+            yield stdio;
+            continue;
+          }
+          if (ended) return;
+          await new Promise((resolve)=>notify = resolve);
+        }
+      }
+    };
+    interaction = (async ()=>{
+      const generator = callback({
+        stdio: input
+      });
+      try {
+        for await (const content of generator){
+          const t = Date.now() - start;
+          logged(log, "stdin", t, `${content}`);
+          stdio.stdio.push([
+            t,
+            0,
+            `${content}`
+          ]);
+          await writer.write(encoder.encode(`${content}`));
+          last = "stdin";
+        }
+        await close();
+      } catch (error) {
+        await close();
+        abort(process);
+        await process.status;
+        throw error;
+      }
+    })();
+  }
+  // Buffer output and resume the interaction generator
+  const debounced = debounce(()=>{
+    last = "";
+    pending = true;
+    notify?.();
+    notify = null;
+  }, buffering);
+  const outputs = Promise.all([
+    "stdout",
+    "stderr"
+  ].filter((channel)=>handle(channels[channel]) === "piped").map(async (channel)=>{
+    for await (const line of process[channel].pipeThrough(new TextDecoderStream()).pipeThrough(new TextLineStream())){
+      const t = Date.now() - start;
+      const stdi = {
+        stdout: 1,
+        stderr: 2
+      }[channel];
+      logged(log, channel, t, line);
+      if (stdio.stdio.length && last === channel) {
+        const previous = stdio.stdio.at(-1);
+        if (previous[1] === stdi) previous[2] += `\n${line}`;
+      } else {
+        stdio.stdio.push([
+          t,
+          stdi,
+          line
+        ]);
+      }
+      last = channel;
+      debounced();
+    }
+  }));
+  void outputs.then(release, release);
+  // Compute result
+  const result = (async ()=>{
+    const [output, interacted] = await Promise.allSettled([
+      outputs,
+      interaction
+    ]);
+    debounced.clear();
+    const { success, code } = await process.status;
+    if (output.status === "rejected" || interacted.status === "rejected") throw output.reason ?? interacted.reason;
+    if (!success && _throw) throw new EvalError(`${bin} exited with non-zero code ${code}:\n${stdio.stdout}\n${stdio.stderr}`);
+    return {
+      success,
+      code,
+      ...stdio
+    };
+  })();
+  const terminate = async (signal = "SIGTERM")=>{
+    abort(process, signal);
+    await result.catch(()=>{});
+  };
+  return background ? {
+    kill: terminate,
+    unref: ()=>process.unref(),
+    pid: process.pid,
+    result,
+    [Symbol.asyncDispose]: ()=>terminate()
+  } : result;
+}
+/** Send a signal to a process, ignoring the error raised when it has already terminated. */ function abort(process, signal = "SIGTERM") {
+  try {
+    process.kill(signal);
+  } catch  {
+  // Already terminated
+  }
+}
+/** Mirror a stdio line through the channel's sub-logger. */ function logged(log, channel, t, content) {
+  const logger = log.getChild(channel).with({
+    t
+  });
+  switch(channel){
+    case "stdin":
+      return void logger.debug("{content}", {
+        content
+      });
+    case "stdout":
+      return void logger.info("{content}", {
+        content
+      });
+    case "stderr":
+      return void logger.error("{content}", {
+        content
+      });
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/run/command.ts"],"sourcesContent":["// Imports\nimport type { Nullable, Promisable } from \"@libs/typing\"\nimport { getLogger, type Logger } from \"@logtape/logtape\"\nimport { TextLineStream } from \"@std/streams\"\nimport { debounce } from \"@std/async/debounce\"\nexport type { Logger, Promisable }\n\n/**\n * Handling of a stdio channel.\n * - `\"piped\"`: the channel is captured into the {@link Result} and mirrored to a {@link https://logtape.org | LogTape} sub-logger.\n * - `\"inherit\"`: the channel is forwarded to the parent process.\n * - `null`: the channel is discarded.\n */\nexport type Channel = Nullable<\"piped\" | \"inherit\">\n\n/** Run options. */\nexport type Options = {\n  /**\n   * Logger categories forwarded to {@link https://logtape.org | LogTape}'s `getLogger()`.\n   * Each channel is mirrored through a sub-category (`stdin`, `stdout`, `stderr`) so the host application can route or filter them.\n   * Defaults to `[\"run\"]`.\n   */\n  logger?: string[]\n  /** Environment variables. */\n  env?: Deno.CommandOptions[\"env\"]\n  /** Current working directory. */\n  cwd?: Deno.CommandOptions[\"cwd\"]\n  /** Raw arguments (Windows only). */\n  raw?: boolean\n  /** Handling of stdin. */\n  stdin?: Channel\n  /** Handling of stdout. */\n  stdout?: Channel\n  /** Handling of stderr. */\n  stderr?: Channel\n  /**\n   * Stdin interaction callback.\n   * Passing this option automatically pipes stdin.\n   * See {@link Callback} for the interaction protocol.\n   */\n  callback?: Callback\n  /**\n   * Stdio buffering.\n   * This is used to merge messages that are received relatively closely.\n   * Buffering is skipped when a different channel is used in-between.\n   */\n  buffering?: number\n  /** Abort signal. */\n  signal?: Deno.CommandOptions[\"signal\"]\n  /**\n   * Execute process synchronously.\n   * Note that stdin is not usable in sync mode.\n   */\n  sync?: boolean\n  /**\n   * Run process in background.\n   * This implies `sync: false`.\n   */\n  background?: boolean\n  /** Process extension on Windows. */\n  winext?: string\n  /** Operating system. */\n  os?: typeof Deno.build.os\n  /** Throw an error if exit code is non-zero rather than returning a result. */\n  throw?: boolean\n  /**\n   * Do not actually execute the command.\n   * In this case you will instead receive an empty successful result object.\n   */\n  dryrun?: boolean\n}\n\n/** Run result. */\nexport type Result = {\n  /** Whether the process exited with a zero-code. */\n  success: Deno.CommandStatus[\"success\"]\n  /** Process exit code. */\n  code: Deno.CommandStatus[\"code\"]\n  /**\n   * Process stdio content.\n   * First element is the delta timestamp since process start, second element is the channel (0:stdin, 1:stdout, 2:stderr), third element is the content.\n   */\n  stdio: Array<[number, 0 | 1 | 2, string]>\n  /** Process stdin content. */\n  stdin: string\n  /** Process stdout content. */\n  stdout: string\n  /** Process stderr content. */\n  stderr: string\n}\n\n/** Handle to a process running in background. */\nexport type Background = {\n  /** Send a signal to the process (defaults to `\"SIGTERM\"`). */\n  kill: (signal?: Deno.Signal) => Promise<void>\n  /** Prevent the process from keeping the parent process alive. */\n  unref: () => void\n  /** Process identifier. */\n  pid: number\n  /** Process result (resolves once the process exits). */\n  result: Promise<Result>\n  /** Kill the process and wait for it to fully terminate. */\n  [Symbol.asyncDispose]: () => Promise<void>\n}\n\n/** Snapshot of the accumulated process stdio content. */\nexport type Snapshot = Pick<Result, \"stdin\" | \"stdout\" | \"stderr\">\n\n/**\n * Stdin interaction callback.\n *\n * It is an async generator that lets you drive an interactive process with plain language constructs:\n * ```ts ignore\n * // Iterate over process output to react to new data.\n * // (one iteration per buffered event)\n * for await (const { stdout } of stdio) {\n *   // Use await to pause or poll for a condition\n *   await delay(1000)\n *   // Use yield to write to stdin (verbatim)\n *   yield \"content\\n\"\n *   // Use return to close stdin and end the interaction\n *   return\n * }\n * ```\n *\n * If the generator throws, stdin is closed, the process is killed and the returned {@link Result} rejects with the thrown error.\n * When the process exits on its own, the `stdio` iterator ends, so a generator parked on `for await` completes naturally.\n */\nexport type Callback = (options: { stdio: AsyncIterable<Snapshot> }) => AsyncGenerator<string, void, unknown>\n\n/** Text encoder */\nconst encoder = new TextEncoder()\n\n/** Text decoder */\nconst decoder = new TextDecoder()\n\n/** Default interaction: an empty generator that closes stdin immediately. */\nconst noop: Callback = async function* () {}\n\n/**\n * Asynchronous version of {@link command} running in background.\n *\n * ```ts\n * import { command } from \"./command.ts\"\n * const process = command(\"deno\", [\"eval\", \"Deno.exit(0)\"], { background: true })\n * await process.kill()\n * ```\n */\nexport function command(bin: string, args: string[], options?: Options & { sync?: false; background: true }): Background\n/**\n * Asynchronous version of {@link command}.\n *\n * ```ts\n * import { command } from \"./command.ts\"\n * try {\n *   await command(\"deno\", [\"eval\", \"Deno.exit(1)\"], { throw: true })\n * }\n * catch (error) {\n *   console.log(error)\n * }\n * ```\n */\nexport function command(bin: string, args: string[], options?: Options & { sync?: false; background?: false }): Promise<Result>\n/**\n * Synchronous version of {@link command}.\n *\n * Note that stdin is not usable in sync mode and will always be empty.\n *\n * ```ts\n * import { command } from \"./command.ts\"\n * command(\"deno\", [\"--version\"], { sync: true })\n * ```\n * ```ts\n * import { command } from \"./command.ts\"\n * try {\n *   command(\"deno\", [\"eval\", \"Deno.exit(1)\"], { sync: true, throw: true })\n * }\n * catch (error) {\n *   console.log(error)\n * }\n * ```\n */\nexport function command(bin: string, args: string[], options?: Options & { sync: true }): Result\n/**\n * Run a command.\n *\n * This is a wrapper around {@link https://docs.deno.com/api/deno/~/Deno.Command | Deno.Command} that provides a better handling of stdio for interactive processes.\n *\n * Like `Deno.Command`, the `env`, `cwd`, and `raw` (alias for `windowsRawArguments`) options are supported.\n *\n * The `stdin`, `stdout` and `stderr` options accept `\"piped\"` (captured into the result and mirrored to a {@link https://logtape.org | LogTape} sub-logger), `\"inherit\"` (forwarded to the parent process) or `null` (discarded).\n *\n * Logging is performed through {@link https://logtape.org | LogTape}.\n * The `logger` option is a category forwarded to `getLogger()` (defaulting to `[\"run\"]`), and each channel is mirrored through its own sub-category — `stdin` at `debug`, `stdout` at `info`, `stderr` at `error`.\n * As recommended for libraries, `command()` never configures LogTape itself: the host application is in charge of the actual output (through {@link https://logtape.org/manual/config | LogTape configuration}).\n *\n * Set `winext` option to automatically append an extension to the binary path on Windows (like `.cmd` or `.exe`).\n * This is useful when the binary path isn't automatically resolved on Windows.\n *\n * Pass a `callback` option (an async generator) to interact with the process stdin.\n * See {@link Callback} for the interaction protocol: `for await` over `stdio` to read output, `yield` to write to stdin, `return` to close it.\n *\n * The `buffering` option is used to merge messages that are received relatively closely.\n * Setting this option to a low value will also increase the rate at which the interaction generator is resumed.\n *\n * Resulting object contains the same properties as {@link https://docs.deno.com/api/deno/~/Deno.CommandStatus | Deno.CommandStatus}\n * with an additional `stdio` property that contains an array of ordered tuples with the delta timestamp since process start, the channel idenfitier (0:stdin, 1:stdout, 2:stderr) and the content.\n * This offers a proper history of exchanged content.\n *\n * ```ts\n * import { command } from \"./command.ts\"\n * await command(\"deno\", [\"--version\"], { env: { NO_COLOR: \"true\" }, cwd: \"/tmp\", raw: true })\n * await command(\"deno\", [\"--version\"], { stdout: \"piped\" })\n * await command(\"deno\", [\"--version\"], { logger: [\"my-app\", \"run\"], stdout: \"piped\" })\n * await command(\"deno\", [\"--version\"], { winext: \".exe\" })\n * ```\n *\n * ```ts\n * import { command } from \"./command.ts\"\n *\n * const { stdout } = await command(\"deno\", [\"repl\"], {\n *   env: { NO_COLOR: \"true\" },\n *   // Passing a callback automatically pipes stdin.\n *   // Iterate `stdio` to react to output, `yield` to write to stdin (verbatim), `return` to close it.\n *   callback: async function* ({ stdio }) {\n *     for await (const { stdout } of stdio) {\n *       if (!stdout.includes(\"exit using\")) {\n *         continue\n *       }\n *       yield \"console.log('hello')\\n\"\n *       return\n *     }\n *   },\n * })\n * console.assert(stdout.includes(\"hello\"))\n * ```\n *\n * @author Simon Lecoq (lowlighter)\n * @license MIT\n * @module\n */\nexport function command(\n  bin: string,\n  args: string[],\n  { logger: category = [\"run\"], stdin = null, stdout = \"piped\", stderr = \"piped\", env, cwd, raw, callback, buffering, signal, sync, background, throw: _throw, dryrun, winext = \"\", os = Deno.build.os } = {} as Options,\n): Promisable<Result> | Background {\n  if (os === \"windows\")\n    bin = `${bin}${winext}`\n  const log = getLogger(category).with({ bin })\n  if (callback && (handle(stdin) !== \"piped\"))\n    stdin = \"piped\"\n  const command = new Deno.Command(bin, { args, stdin: !sync ? handle(stdin) : \"null\", stdout: handle(stdout), stderr: handle(stderr), clearEnv: true, env, cwd, windowsRawArguments: raw, signal, detached: background })\n  if (dryrun) {\n    log.warn(\"dryrun: {bin} not executed\", { bin })\n    const result = { success: true, code: 0, stdio: [], stdin: \"\", stdout: \"\", stderr: \"\" }\n    return sync ? result : Promise.resolve(result)\n  }\n  if (sync)\n    return exec(command, { bin, log, throw: _throw, stdout, stderr })\n  return spawn(command, { bin, log, callback, buffering, throw: _throw, background, stdin, stdout, stderr })\n}\n\n/** Returns the handle type for a given mode. */\nfunction handle(mode: Channel) {\n  return [\"inherit\", \"null\"].includes(`${mode}`) ? `${mode}` as \"inherit\" | \"null\" : \"piped\"\n}\n\n/** Execute a command synchronously. */\nfunction exec(command: Deno.Command, { bin, log, throw: _throw, stdout, stderr }: { bin: string; log: Logger; throw?: boolean; stdout: Channel; stderr: Channel }) {\n  const start = Date.now()\n  const output = command.outputSync()\n  const { success, code } = output // Do not access stdout or stderr before \"piped\" status check\n  const t = Date.now() - start\n  const stdio = {\n    get stdio() {\n      return [[t, 1, this.stdout], [t, 2, this.stderr]]\n    },\n    stdin: \"\",\n    stdout: handle(stdout) === \"piped\" ? decoder.decode(output.stdout) : \"\",\n    stderr: handle(stderr) === \"piped\" ? decoder.decode(output.stderr) : \"\",\n  } as Snapshot & Pick<Result, \"stdio\">\n  for (const { channel, mode } of [{ channel: \"stdout\", mode: stdout }, { channel: \"stderr\", mode: stderr }] as const) {\n    if ((handle(mode) === \"piped\") && (stdio[channel]))\n      logged(log, channel, t, stdio[channel])\n  }\n  if ((!success) && _throw)\n    throw new EvalError(`${bin} exited with non-zero code ${code}:\\n${stdio.stdout}\\n${stdio.stderr}`)\n  return { success, code, ...stdio }\n}\n\n/** Spawn a command asynchronously in background. */\nfunction spawn(\n  command: Deno.Command,\n  options: { bin: string; log: Logger; callback?: Callback; buffering?: number; throw?: boolean; background: true; stdin: Channel; stdout: Channel; stderr: Channel },\n): Background\n/** Spawn a command asynchronously. */\nfunction spawn(command: Deno.Command, options: { bin: string; log: Logger; callback?: Callback; buffering?: number; throw?: boolean; background?: boolean; stdin: Channel; stdout: Channel; stderr: Channel }): Promise<Result>\n/** Spawn a command. */\nfunction spawn(\n  command: Deno.Command,\n  { bin, log, callback = noop, buffering = 250, throw: _throw, background, ...channels }: {\n    bin: string\n    log: Logger\n    callback?: Callback\n    buffering?: number\n    throw?: boolean\n    background?: boolean\n    stdin: Channel\n    stdout: Channel\n    stderr: Channel\n  },\n) {\n  const process = command.spawn()\n  const start = Date.now()\n  const stdio = {\n    stdio: [],\n    get stdin() {\n      return this.stdio.filter(([_, i]) => i === 0).map(([_, __, content]) => content).join(\"\")\n    },\n    get stdout() {\n      return this.stdio.filter(([_, i]) => i === 1).map(([_, __, content]) => content).join(\"\\n\")\n    },\n    get stderr() {\n      return this.stdio.filter(([_, i]) => i === 2).map(([_, __, content]) => content).join(\"\\n\")\n    },\n  } as Snapshot & Pick<Result, \"stdio\">\n  let last = \"\"\n\n  // Drive the interaction generator when stdin is piped\n  let release = () => {}\n  let notify = null as Nullable<() => void>\n  let pending = true\n  let ended = false\n  let interaction = Promise.resolve()\n  if (handle(channels.stdin) === \"piped\") {\n    const writer = process.stdin.getWriter()\n    const close = async () => {\n      try {\n        await writer.close()\n        log.with({ t: Date.now() - start }).trace(\"closed stdin\")\n      } catch {\n        // Ignore (stdin may already be closed if the process exited)\n      }\n    }\n    release = () => {\n      ended = true\n      notify?.()\n      notify = null\n    }\n    const input = {\n      async *[Symbol.asyncIterator]() {\n        while (true) {\n          if (pending) {\n            pending = false\n            yield stdio as Snapshot\n            continue\n          }\n          if (ended)\n            return\n          await new Promise<void>((resolve) => notify = resolve)\n        }\n      },\n    }\n    interaction = (async () => {\n      const generator = callback({ stdio: input })\n      try {\n        for await (const content of generator) {\n          const t = Date.now() - start\n          logged(log, \"stdin\", t, `${content}`)\n          stdio.stdio.push([t, 0, `${content}`])\n          await writer.write(encoder.encode(`${content}`))\n          last = \"stdin\"\n        }\n        await close()\n      } catch (error) {\n        await close()\n        abort(process)\n        await process.status\n        throw error\n      }\n    })()\n  }\n\n  // Buffer output and resume the interaction generator\n  const debounced = debounce(() => {\n    last = \"\"\n    pending = true\n    notify?.()\n    notify = null\n  }, buffering)\n  const outputs = Promise.all(\n    ([\"stdout\", \"stderr\"] as const).filter((channel) => handle(channels[channel]) === \"piped\").map(async (channel) => {\n      for await (const line of process[channel].pipeThrough(new TextDecoderStream()).pipeThrough(new TextLineStream())) {\n        const t = Date.now() - start\n        const stdi = { stdout: 1, stderr: 2 }[channel] as 1 | 2\n        logged(log, channel, t, line)\n        if ((stdio.stdio.length) && (last === channel)) {\n          const previous = stdio.stdio.at(-1)!\n          if (previous[1] === stdi)\n            previous[2] += `\\n${line}`\n        } else {\n          stdio.stdio.push([t, stdi, line])\n        }\n        last = channel\n        debounced()\n      }\n    }),\n  )\n  void outputs.then(release, release)\n\n  // Compute result\n  const result = (async () => {\n    const [output, interacted] = await Promise.allSettled([outputs, interaction])\n    debounced.clear()\n    const { success, code } = await process.status\n    if ((output.status === \"rejected\") || (interacted.status === \"rejected\"))\n      throw ((output as { reason?: unknown }).reason ?? (interacted as { reason?: unknown }).reason)\n    if ((!success) && _throw)\n      throw new EvalError(`${bin} exited with non-zero code ${code}:\\n${stdio.stdout}\\n${stdio.stderr}`)\n    return { success, code, ...stdio }\n  })()\n  const terminate = async (signal: Deno.Signal = \"SIGTERM\") => {\n    abort(process, signal)\n    await result.catch(() => {})\n  }\n  return background\n    ? {\n      kill: terminate,\n      unref: () => process.unref(),\n      pid: process.pid,\n      result,\n      [Symbol.asyncDispose]: () => terminate(),\n    }\n    : result\n}\n\n/** Send a signal to a process, ignoring the error raised when it has already terminated. */\nfunction abort(process: Deno.ChildProcess, signal: Deno.Signal = \"SIGTERM\") {\n  try {\n    process.kill(signal)\n  } catch {\n    // Already terminated\n  }\n}\n\n/** Mirror a stdio line through the channel's sub-logger. */\nfunction logged(log: Logger, channel: \"stdin\" | \"stdout\" | \"stderr\", t: number, content: string) {\n  const logger = log.getChild(channel).with({ t })\n  switch (channel) {\n    case \"stdin\":\n      return void logger.debug(\"{content}\", { content })\n    case \"stdout\":\n      return void logger.info(\"{content}\", { content })\n    case \"stderr\":\n      return void logger.error(\"{content}\", { content })\n  }\n}\n"],"names":[],"mappings":"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"}

package/mod.d.ts

@@ -0,0 +1 @@
+export * from "./command.js";

package/mod.js

@@ -0,0 +1,2 @@
+export * from "./command.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvcnVuL21vZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb21tYW5kLmpzXCJcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWMifQ==

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@lowlighter/run",
-  "version": "3.0.0",
+  "version": "3.4.0",
   "type": "module",
-  "scripts": {},
-  "dependencies": {},
-  "devDependencies": {},
-  "description": "Utilities to run subprocess.",
-  "keywords": [
-    "subprocess",
-    "esm"
-  ],
-  "license": "MIT",
-  "author": "lowlighter (Simon Lecoq)",
-  "homepage": "https://github.com/lowlighter/libs",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lowlighter/libs.git"
-  },
-  "funding": "https://github.com/sponsors/lowlighter",
+  "main": "./mod.js",
+  "types": "./mod.d.ts",
   "exports": {
-    ".": "./mod.mjs",
-    "./command": "./command.mjs"
+    ".": {
+      "types": "./mod.d.ts",
+      "import": "./mod.js",
+      "default": "./mod.js"
+    },
+    "./command": {
+      "types": "./command.d.ts",
+      "import": "./command.js",
+      "default": "./command.js"
+    }
+  },
+  "dependencies": {
+    "@jsr/logtape__logtape": "^2.2.0",
+    "@jsr/std__async": "^1.2.0",
+    "@jsr/std__streams": "^1.0.17",
+    "@lowlighter/typing": "^4.1.0"
   }
-}
+}