omkit 0.1.3 → 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. */
@@ -7,21 +12,12 @@ export interface CommandOptions {
     /** Let this command inherit the orchestrator's debugger (default false). */
     inheritDebugger?: boolean;
 }
-declare function build(name: string, cmdOrFile: string, argsOrOptions: readonly string[] | CommandOptions, maybeOptions: CommandOptions): import("../index.ts").ActionInstance<import("zx").ProcessOutput, import("../core/types.ts").NoEvents, void>;
 /**
- * Runs a shell command as an action instance. Two forms:
+ * Runs a command as an action instance.
  *
- * - `command(name, cmd, options?)` — a full command **string**, run verbatim through the
- *   shell, so pipes, globs and `&&` work (quote anything yourself).
- * - `command(name, file, args, options?)` — an executable **plus an args array**; each arg
- *   is quoted individually, so spaces and `=`/paths in args are safe without hand-quoting.
+ * By default the command is executed through the shell.
  *
- * Output streams into the run's log under `name`; a non-zero exit fails the action;
- * teardown kills the child tree. For interpolated events or a daemon loop, drop to
- * `action(...).run(...)`.
+ * If `options.args` is provided, `cmdOrFile` is treated as an executable and
+ * launched directly without a shell.
  */
-export declare const command: {
-    (name: string, cmd: string, options?: CommandOptions): ReturnType<typeof build>;
-    (name: string, file: string, args: readonly string[], options?: CommandOptions): ReturnType<typeof build>;
-};
-export {};
+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,38 +1,79 @@
+import { spawn } from "node:child_process";
 import path from "node:path";
 import { action } from "../core/action.js";
+import { debuggerFreeEnv, killTree, streamLines } from "../system/proc.js";
 /**
- * Build a zx tagged template that runs `cmd` verbatim — zx only quotes interpolated
- * args, not the template's `pieces`, so the whole (developer-supplied) command in
- * `pieces` runs exactly as written (pipes, globs, `&&`).
+ * Build a zx tagged template that runs `cmd` verbatim.
  */
 const verbatim = (cmd) => Object.assign([cmd], { raw: [cmd] });
-function build(name, cmdOrFile, argsOrOptions, maybeOptions) {
-    const hasArgs = Array.isArray(argsOrOptions);
-    const args = hasArgs ? argsOrOptions : undefined;
-    const options = (hasArgs ? maybeOptions : argsOrOptions) ?? {};
-    return action(name).run((ctx) => {
-        const cwd = path.resolve(options.cwd ?? ".");
-        const proc = ctx.proc(name, {
-            cwd,
-            ...(options.env ? { env: options.env } : {}),
-            ...(options.inheritDebugger ? { inheritDebugger: true } : {}),
-        });
-        // `file, args` form: zx quotes the file and every arg individually (arrays spread), so
-        // paths/values with spaces are safe and nothing is re-parsed by the shell. String form:
-        // run the whole command verbatim.
-        return args ? proc `${cmdOrFile} ${args}` : proc(verbatim(cmdOrFile));
-    })();
-}
 /**
- * Runs a shell command as an action instance. Two forms:
+ * Runs a command as an action instance.
  *
- * - `command(name, cmd, options?)` — a full command **string**, run verbatim through the
- *   shell, so pipes, globs and `&&` work (quote anything yourself).
- * - `command(name, file, args, options?)` — an executable **plus an args array**; each arg
- *   is quoted individually, so spaces and `=`/paths in args are safe without hand-quoting.
+ * By default the command is executed through the shell.
  *
- * Output streams into the run's log under `name`; a non-zero exit fails the action;
- * teardown kills the child tree. For interpolated events or a daemon loop, drop to
- * `action(...).run(...)`.
+ * If `options.args` is provided, `cmdOrFile` is treated as an executable and
+ * launched directly without a shell.
  */
-export const command = (name, cmdOrFile, argsOrOptions = {}, maybeOptions = {}) => build(name, cmdOrFile, argsOrOptions, maybeOptions);
+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 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,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        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);
+            }
+        };
+        if (ctx.signal.aborted) {
+            onAbort();
+        }
+        else {
+            ctx.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                child.once("error", (err) => {
+                    reject(new Error(`${name}: ${err.message}`, { cause: err }));
+                });
+                child.once("exit", (code, signal) => {
+                    finished = true;
+                    if (ctx.signal.aborted || code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(Object.assign(new Error(signal ? `${name} terminated by ${signal}` : `${name} exited with code ${code}`), { exitCode: code ?? undefined }));
+                    }
+                });
+            });
+        }
+        finally {
+            finished = true;
+            ctx.signal.removeEventListener("abort", onAbort);
+        }
+    })();
+}

package/dist/system/proc.d.ts

@@ -49,3 +49,5 @@ export declare const procRegistry: ProcRegistry;
  * actions just describe the command — output streams in, the child dies on teardown.
  */
 export declare const createProc: (sink: ProcSink, signal: AbortSignal) => Proc;
+/** Split a byte/string stream into lines, calling `onLine` for each non-empty one. */
+export declare function streamLines(stream: AsyncIterable<unknown>, onLine: (line: string) => void): Promise<void>;

package/dist/system/proc.js

@@ -130,7 +130,7 @@ export const createProc = (sink, signal) => (name, opts) => {
     };
 };
 /** Split a byte/string stream into lines, calling `onLine` for each non-empty one. */
-async function streamLines(stream, onLine) {
+export async function streamLines(stream, onLine) {
     let buffer = "";
     for await (const chunk of stream) {
         buffer += String(chunk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.1.3",
+  "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",