omkit 0.1.4 → 0.1.5

package/dist/actions/command.d.ts

@@ -1,5 +1,10 @@
 /** Tunes an action built with {@link command}. */
 export interface CommandOptions {
+    /**
+     * Launch `cmdOrFile` directly with these arguments instead of executing it
+     * through a shell. Omit to run the command as a shell command.
+     */
+    args?: readonly string[];
     /** Directory to run in; relative paths resolve against `process.cwd()`. Default ".". */
     cwd?: string;
     /** Full environment for the child (handed as-is, not merged). Omit to inherit. */
@@ -8,9 +13,11 @@ export interface CommandOptions {
     inheritDebugger?: boolean;
 }
 /**
- * Runs an executable directly (without a shell) as an action instance.
+ * Runs a command as an action instance.
  *
- * Output streams into the run's log under `name`; a non-zero exit fails the
- * action; teardown force-kills the process tree.
+ * By default the command is executed through the shell.
+ *
+ * If `options.args` is provided, `cmdOrFile` is treated as an executable and
+ * launched directly without a shell.
  */
-export declare function command(name: string, file: string, args?: readonly string[], options?: CommandOptions): import("../index.ts").ActionInstance<void, import("../core/types.ts").NoEvents, void>;
+export declare function command(name: string, cmdOrFile: string, options?: CommandOptions): import("../index.ts").ActionInstance<import("zx").ProcessOutput, import("../core/types.ts").NoEvents, void> | import("../index.ts").ActionInstance<void, import("../core/types.ts").NoEvents, void>;

package/dist/actions/command.js

@@ -1,43 +1,72 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { action } from "../core/action.js";
-import { killTree, streamLines } from "../system/proc.js";
+import { debuggerFreeEnv, killTree, streamLines } from "../system/proc.js";
 /**
- * Runs an executable directly (without a shell) as an action instance.
+ * Build a zx tagged template that runs `cmd` verbatim.
+ */
+const verbatim = (cmd) => Object.assign([cmd], { raw: [cmd] });
+/**
+ * Runs a command as an action instance.
  *
- * Output streams into the run's log under `name`; a non-zero exit fails the
- * action; teardown force-kills the process tree.
+ * By default the command is executed through the shell.
+ *
+ * If `options.args` is provided, `cmdOrFile` is treated as an executable and
+ * launched directly without a shell.
  */
-export function command(name, file, args = [], options = {}) {
+export function command(name, cmdOrFile, options = {}) {
+    const cwd = path.resolve(options.cwd ?? ".");
+    // Shell command.
+    if (options.args === undefined) {
+        return action(name).run((ctx) => ctx.proc(name, {
+            cwd,
+            ...(options.env && { env: options.env }),
+            ...(options.inheritDebugger && {
+                inheritDebugger: true,
+            }),
+        })(verbatim(cmdOrFile)))();
+    }
+    // Direct executable.
     return action(name).run(async (ctx) => {
-        const cwd = path.resolve(options.cwd ?? ".");
-        const child = spawn(file, args, {
+        const inherit = options.inheritDebugger ?? Boolean(process.env.OMKIT_INHERIT_DEBUGGER);
+        const env = inherit
+            ? (options.env ?? process.env)
+            : debuggerFreeEnv(options.env ?? process.env);
+        const args = options.args ?? [];
+        const child = spawn(cmdOrFile, args, {
             cwd,
-            env: options.env,
+            env,
             detached: process.platform !== "win32",
             windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
         });
-        console.log(`start · '${file}' ${args.join(" ")} · in ${cwd}`);
-        void streamLines(child.stdout, (line) => console.info(line));
-        void streamLines(child.stderr, (line) => console.error(line));
+        console.log(`${name} · start · '${cmdOrFile}' ${args.join(" ")} · in ${cwd}`);
+        void streamLines(child.stdout, console.info);
+        void streamLines(child.stderr, console.error);
         let finished = false;
         const onAbort = () => {
             if (!finished && child.pid !== undefined) {
                 killTree(child.pid);
             }
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        if (ctx.signal.aborted) {
+            onAbort();
+        }
+        else {
+            ctx.signal.addEventListener("abort", onAbort, { once: true });
+        }
         try {
             await new Promise((resolve, reject) => {
-                child.once("error", reject);
+                child.once("error", (err) => {
+                    reject(new Error(`${name}: ${err.message}`, { cause: err }));
+                });
                 child.once("exit", (code, signal) => {
                     finished = true;
-                    if (code === 0) {
+                    if (ctx.signal.aborted || code === 0) {
                         resolve();
                     }
                     else {
-                        reject(new Error(signal ? `${name} terminated by ${signal}` : `${name} exited with code ${code}`));
+                        reject(Object.assign(new Error(signal ? `${name} terminated by ${signal}` : `${name} exited with code ${code}`), { exitCode: code ?? undefined }));
                     }
                 });
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A tiny runtime for developer workflows: typed actions that pass runtime capabilities and emit typed events, under one run and one shared log. The operational/runtime layer to tskb's knowledge layer.",
   "type": "module",
   "main": "./dist/index.js",