omkit 0.1.2 → 0.1.4

package/dist/actions/command.d.ts

@@ -7,21 +7,10 @@ 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 an executable directly (without a shell) 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.
- *
- * 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(...)`.
+ * Output streams into the run's log under `name`; a non-zero exit fails the
+ * action; teardown force-kills the process tree.
  */
-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, file: string, args?: readonly string[], options?: CommandOptions): import("../index.ts").ActionInstance<void, import("../core/types.ts").NoEvents, void>;

package/dist/actions/command.js

@@ -1,38 +1,50 @@
+import { spawn } from "node:child_process";
 import path from "node:path";
 import { action } from "../core/action.js";
+import { 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, `&&`).
+ * Runs an executable directly (without a shell) 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.
  */
-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) => {
+export function command(name, file, args = [], options = {}) {
+    return action(name).run(async (ctx) => {
         const cwd = path.resolve(options.cwd ?? ".");
-        const proc = ctx.proc(name, {
+        const child = spawn(file, args, {
             cwd,
-            ...(options.env ? { env: options.env } : {}),
-            ...(options.inheritDebugger ? { inheritDebugger: true } : {}),
+            env: options.env,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
         });
-        // `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));
+        console.log(`start · '${file}' ${args.join(" ")} · in ${cwd}`);
+        void streamLines(child.stdout, (line) => console.info(line));
+        void streamLines(child.stderr, (line) => console.error(line));
+        let finished = false;
+        const onAbort = () => {
+            if (!finished && child.pid !== undefined) {
+                killTree(child.pid);
+            }
+        };
+        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        try {
+            await new Promise((resolve, reject) => {
+                child.once("error", reject);
+                child.once("exit", (code, signal) => {
+                    finished = true;
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(signal ? `${name} terminated by ${signal}` : `${name} exited with code ${code}`));
+                    }
+                });
+            });
+        }
+        finally {
+            finished = true;
+            ctx.signal.removeEventListener("abort", onAbort);
+        }
     })();
 }
-/**
- * Runs a shell command as an action instance. Two forms:
- *
- * - `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.
- *
- * 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(...)`.
- */
-export const command = (name, cmdOrFile, argsOrOptions = {}, maybeOptions = {}) => build(name, cmdOrFile, argsOrOptions, maybeOptions);

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.2",
+  "version": "0.1.4",
   "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",