feat(runtime): two-tier subprocess API

cli/diagnostics.rs

@@ -68,6 +68,9 @@ const UNSTABLE_DENO_PROPS: &[&str] = &[
   "umask",
   "utime",
   "utimeSync",
+  "CommandOptions",
+  "Command",
+  "Child",
 ];
 
 lazy_static::lazy_static! {

cli/dts/lib.deno.unstable.d.ts

@@ -1094,6 +1094,52 @@ declare namespace Deno {
       write?: "inherit" | boolean | Array<string | URL>;
     };
   }
+
+  interface CommandOptions {
+    args?: string[];
+    cwd?: string | URL;
+    clearEnv?: boolean;
+    env?: Record<string, string>;
+  }
+
+  interface ProcessIOOptions {
+    stdin?: "piped" | "inherit" | "null";
+    stdout?: "piped" | "inherit" | "null";
+    stderr?: "piped" | "inherit" | "null";
+  }
+
+  class Command {
+    constructor(command: string | URL, options?: CommandOptions);
+
+    spawn<T extends ProcessIOOptions = ProcessIOOptions>(options?: T): Child<T>;
+    status(options?: {
+      stdout?: "inherit" | "null";
+      stderr?: "inherit" | "null";
+    }): Promise<ProcessStatus>;
+    output(): Promise<CommandOutput<{ stdin: "piped"; stderr: "piped" }>>;
+  }
+
+  class Child<T extends ProcessIOOptions = ProcessIOOptions> {
+    readonly stdin: T["stdin"] extends "piped" ? WritableStream<Uint8Array>
+      : null;
+    readonly stdout: T["stdout"] extends "piped" ? ReadableStream<Uint8Array>
+      : null;
+    readonly stderr: T["stderr"] extends "piped" ? ReadableStream<Uint8Array>
+      : null;
+
+    readonly pid: number;
+    readonly status: ProcessStatus | null;
+
+    wait(): Promise<ProcessStatus>;
+    output(): Promise<CommandOutput>;
+    kill(signo: number): void;
+  }
+
+  interface CommandOutput<T extends ProcessIOOptions = ProcessIOOptions> {
+    status: ProcessStatus;
+    stdout: T["stdin"] extends "piped" ? Uint8Array : null;
+    stderr: T["stderr"] extends "piped" ? Uint8Array : null;
+  }
 }
 
 declare function fetch(

runtime/js/40_command.js

@@ -0,0 +1,168 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+"use strict";
+
+((window) => {
+  const core = window.Deno.core;
+  const { assert, pathFromURL } = window.__bootstrap.util;
+  const { read } = window.__bootstrap.io;
+  const { writeAll } = window.__bootstrap.buffer;
+  const { illegalConstructorKey } = window.__bootstrap.webUtil;
+  const { ArrayPrototypeMap, ObjectEntries, String } =
+    window.__bootstrap.primordials;
+
+  class Command {
+    #args;
+
+    constructor(command, {
+      args = [],
+      cwd = undefined,
+      clearEnv = false,
+      env = {},
+    } = {}) {
+      this.#args = {
+        cmd: pathFromURL(command),
+        args: ArrayPrototypeMap(args, String),
+        cwd: pathFromURL(cwd),
+        clearEnv,
+        env: ObjectEntries(env),
+      };
+    }
+
+    spawn(options = {}) {
+      const child = core.opSync("op_command_spawn", {
+        ...this.#args,
+        ...options,
+      });
+
+      return new Child(illegalConstructorKey, child);
+    }
+
+    async status(options = {}) {
+      return await core.opAsync("op_command_status", {
+        ...this.#args,
+        ...options,
+      });
+    }
+
+    async output() {
+      return await core.opAsync("op_command_output", this.#args);
+    }
+  }
+
+  class Child {
+    #rid;
+
+    #pid;
+    get pid() {
+      return this.#pid;
+    }
+
+    #stdin;
+    get stdin() {
+      return this.#stdin;
+    }
+
+    #stdoutRid;
+    #stdout;
+    get stdout() {
+      return this.#stdout;
+    }
+
+    #stderrRid;
+    #stderr;
+    get stderr() {
+      return this.#stderr;
+    }
+
+    constructor(key = null, {
+      rid,
+      pid,
+      stdinRid,
+      stdoutRid,
+      stderrRid,
+    } = null) {
+      if (key !== illegalConstructorKey) {
+        throw new TypeError("Illegal constructor.");
+      }
+
+      this.#rid = rid;
+      this.#pid = pid;
+
+      if (stdinRid !== undefined) {
+        this.#stdin = new WritableStream({
+          async write(chunk) {
+            await writeAll(stdinRid, chunk);
+          },
+          abort() {
+            core.close(stdinRid);
+          },
+        });
+      }
+
+      if (stdoutRid !== undefined) {
+        this.#stdoutRid = stdoutRid;
+        // TODO(crowlkats): BYOB Stream
+        this.#stdout = new ReadableStream({
+          async pull(controller) {
+            const buf = new Uint8Array(1024); // TODO(crowlkats): different number? wouldnt bee needed with byob stream
+            const res = await read(stdoutRid, buf);
+            if (res === null) {
+              core.close(stdoutRid);
+              controller.close();
+            } else {
+              controller.enqueue(buf);
+            }
+          },
+          cancel() {
+            core.close(stdoutRid);
+          },
+        });
+      }
+
+      if (stderrRid !== undefined) {
+        this.#stderrRid = stderrRid;
+        // TODO(crowlkats): BYOB Stream
+        this.#stderr = new ReadableStream({
+          async pull(controller) {
+            const buf = new Uint8Array(1024); // TODO(crowlkats): different number? wouldnt bee needed with byob stream
+            const res = await read(stderrRid, buf);
+            if (res === null) {
+              core.close(stderrRid);
+              controller.close();
+            } else {
+              controller.enqueue(buf);
+            }
+          },
+          cancel() {
+            core.close(stderrRid);
+          },
+        });
+      }
+    }
+
+    get status() {
+      return core.opSync("op_command_child_status", this.#rid);
+    }
+
+    async wait() {
+      return await core.opAsync("op_command_child_wait", this.#rid);
+    }
+
+    async output() {
+      return await core.opAsync("op_command_child_output", {
+        rid: this.#rid,
+        stdoutRid: this.#stdoutRid,
+        stderrRid: this.#stderrRid,
+      });
+    }
+
+    kill(signal) {
+      core.opSync("op_kill", this.#pid, signal);
+    }
+  }
+
+  window.__bootstrap.command = {
+    Command,
+    Child,
+  };
+})(this);

runtime/js/40_process.js

@@ -15,7 +15,7 @@
   } = window.__bootstrap.primordials;
 
   function opKill(pid, signo) {
-    core.opSync("op_kill", { pid, signo });
+    core.opSync("op_kill", pid, signo);
   }
 
   function opRunStatus(rid) {

runtime/js/90_deno_ns.js

@@ -140,5 +140,7 @@
     flockSync: __bootstrap.fs.flockSync,
     funlock: __bootstrap.fs.funlock,
     funlockSync: __bootstrap.fs.funlockSync,
+    Command: __bootstrap.command.Command,
+    Child: __bootstrap.command.Child,
   };
 })(this);