@volter/tabnode 0.4.0 → 0.5.0

package/src/node-lib/binding/pipe_wrap.ts

@@ -15,6 +15,7 @@ import { LibuvStreamWrap, type WriteWrap } from './stream_wrap';
 import { UV_EADDRINUSE, UV_ENOENT, UV_EBADF } from './uv';
 import { handleForFd, registerFd, releaseFd } from './fds';
 import { __adoptHandle, ownerOf } from './handles';
+import { nativeStreamFor, registerNativeStreamConstructor } from '../../native-stream-binding';
 
 /** libuv's `uv_pipe_t` flavours, and the two chmod bits `listen` reads. */
 export const constants = {
@@ -51,9 +52,12 @@ export class Pipe extends LibuvStreamWrap {
   constructor(type: number = constants.SOCKET) {
     super();
     this.type = type;
+    this.attachNative('pipe', type);
   }
 
   bind(path: string): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.call({ operation: 'bind', id: native.descriptor.id, address: path }).status;
     const held = boundPaths.get(path);
     if (held && held !== this) return UV_EADDRINUSE;
     this.path = path;
@@ -62,12 +66,20 @@ export class Pipe extends LibuvStreamWrap {
   }
 
   listen(_backlog: number): number {
+    const native = nativeStreamFor(this);
+    if (native) {
+      const status = native.call({ operation: 'listen', id: native.descriptor.id, backlog: _backlog }).status;
+      if (status === 0) this.listening = true;
+      return status;
+    }
     if (this.path === null) return UV_EBADF;
     this.listening = true;
     return 0;
   }
 
   connect(req: PipeConnectWrap, path: string): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.connect(path, undefined, false, status => req.oncomplete?.(status, this, req, true, true));
     // libuv answers a connect through the request, never from the call.
     queueMicrotask(() => {
       if (this.closed) return;
@@ -76,7 +88,7 @@ export class Pipe extends LibuvStreamWrap {
         req.oncomplete?.(UV_ENOENT, this, req, true, true);
         return;
       }
-      const accepted = new Pipe(server.type === constants.IPC ? constants.IPC : constants.SOCKET);
+      const accepted = new (server.constructor as typeof Pipe)(server.type === constants.IPC ? constants.IPC : constants.SOCKET);
       accepted.path = path;
       // The serving run owns what it accepted, not the connecting one.
       __adoptHandle(accepted, ownerOf(server));
@@ -95,6 +107,12 @@ export class Pipe extends LibuvStreamWrap {
    * opened it, because a child's channel is written to before the child runs.
    */
   open(fd: number): number {
+    const native = nativeStreamFor(this);
+    if (native) {
+      const status = native.call({ operation: 'open', id: native.descriptor.id, fd }).status;
+      if (status === 0) this.fd = fd;
+      return status;
+    }
     const held = handleForFd(fd) as LibuvStreamWrap | undefined;
     if (!held) return UV_EBADF;
     this.takeOverFrom(held);
@@ -111,8 +129,9 @@ export class Pipe extends LibuvStreamWrap {
 
   /** libuv's `dup()`: the same pairing, under the same flavour. */
   override duplicate(): Pipe {
-    const copy = new Pipe(this.type);
-    copy.takeOverFrom(this);
+    const native = nativeStreamFor(this);
+    const copy = native ? native.duplicate() as Pipe : new (this.constructor as typeof Pipe)(this.type);
+    if (!native) copy.shareConnectionFrom(this);
     return copy;
   }
 
@@ -133,14 +152,16 @@ export class Pipe extends LibuvStreamWrap {
    *
    * The handle becomes the receiving run's. Node's `send(message, socket)`
    * duplicates the sender's descriptor into the other process, and from then
-   * on the socket is an active handle of that process's loop; here parent and
-   * child are one realm and there is nothing to duplicate, so the move is the
-   * run ownership the engine counts. Without it, openvscode-server's extension
+   * on the socket is an active handle of that process's loop. The binding
+   * duplicates the wrapper and assigns that reference to the receiver.
+   * Without that ownership, openvscode-server's extension
    * host -- a program whose only handle is the socket its parent sent it --
    * read as idle and was settled with exit 0.
    */
-  override writeUtf8String(req: WriteWrap, text: string, handle?: unknown): number {
-    if (handle === undefined || handle === null) return super.writeUtf8String(req, text);
+  protected override dispatchWrite(req: WriteWrap, bytes: Uint8Array, handle?: unknown): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.write(req, [bytes], handle);
+    if (handle === undefined || handle === null) return super.dispatchWrite(req, bytes);
     // A descriptor crosses as a duplicate, as `SCM_RIGHTS` hands one over: the
     // receiver gets its own handle on the same connection, so the sender's
     // close on `NODE_HANDLE_ACK` -- which Node's `child_process.js` does the
@@ -148,11 +169,12 @@ export class Pipe extends LibuvStreamWrap {
     // a listening server's, has nothing to duplicate and crosses as it is.
     const sent = handle as LibuvStreamWrap;
     const given = sent.peer !== null ? sent.duplicate() : sent;
-    // The receiving run owns it from here: parent and child are one realm and
-    // there is no descriptor table to move it in, so the move is the count the
-    // engine keeps of what holds a run open.
+    // The receiving run owns this reference; the sender retains its own until
+    // Node closes it on acknowledgement, or continues using it with keepOpen.
     __adoptHandle(given, ownerOf(this.peer ?? this));
-    return super.writeUtf8String(req, text, given);
+    const status = super.dispatchWrite(req, bytes, given);
+    if (status !== 0 && given !== sent) given.close();
+    return status;
   }
 
   protected override onCloseHandle(): void {
@@ -163,4 +185,5 @@ export class Pipe extends LibuvStreamWrap {
   }
 }
 
+registerNativeStreamConstructor('pipe', Pipe);
 export default { Pipe, PipeConnectWrap, constants };

package/src/node-lib/binding/process_wrap.ts

@@ -25,9 +25,11 @@ import { Pipe, constants as pipeConstants } from './pipe_wrap';
 import { UV_ENOENT, UV_ESRCH } from './uv';
 import {
   registerHandle, refHandle, unrefHandle, handleHasRef, releaseHandle, __adoptHandle,
-  type OwnedHandle,
+  ownerOf, type OwnedHandle,
 } from './handles';
-import type { ProcessToken } from '../../process-tokens';
+import { __runFor, mintPid, type ProcessToken } from '../../process-tokens';
+import { handleForFd } from './fds';
+import { TTY, type TerminalState } from './tty_wrap';
 
 /** One entry of Node's `options.stdio`, as `getValidStdio` builds it. */
 export interface StdioEntry {
@@ -85,8 +87,14 @@ export interface RunRequest {
   stderrIsPipe: boolean;
   /** True when the child's fd 0 is a pipe whose writer has not closed. */
   stdinIsPipe: boolean;
+  terminal?: TerminalState;
   /** The IPC channel the child is started with, where it has one. */
   channel?: RunChannel;
+  /**
+   * The child's pipes past fd 2 (`stdio: [..., 'pipe', 'pipe']`), each at the
+   * number the child reads or writes it by, with the child's end of it.
+   */
+  descriptors: { fd: number; pipe: Pipe }[];
   /** Called once, when the run has ended. */
   exit(code: number, signal: string | null): void;
 }
@@ -100,7 +108,7 @@ export interface StartedRun {
   /** libuv's `uv_process_kill`: 0, or `UV_ESRCH` for a run already over. */
   kill(signal: string): number;
   /** Bytes the parent wrote to the child's fd 0. */
-  writeStdin(bytes: Uint8Array): void;
+  writeStdin(bytes: Uint8Array): void | Promise<void>;
   /** The parent closed the child's fd 0. */
   endStdin(): void;
 }
@@ -123,7 +131,6 @@ export function setProcessRunner(next: ProcessRunner): void {
   runner = next;
 }
 
-let nextPid = 1001 + Math.floor(Math.random() * 30000);
 let nextAsyncId = 1;
 
 /** `envPairs` is `KEY=value` strings; the engine's shell takes a record. */
@@ -154,18 +161,31 @@ function signalNameOf(signal: number | string): string {
  * `/work` means `/work/child.js`, and resolved against the engine's shell's
  * own root it meant `/child.js` and a child that exited 1.
  */
-function spawningDirectory(): string | undefined {
-  const realm = (globalThis as unknown as { process?: { cwd?: () => string } }).process;
+// A shared realm's process global is whichever guest ran last. The spawning
+// handle belongs to the parent: inherited stdio and cwd must come from that
+// parent's process, even while a sibling starts or exits. A failed fork was
+// replaying stderr into its own closed IPC-backed stream (write EBADF).
+function parentProcess(token: ProcessToken | null) {
+  return token !== null ? __runFor(token)?.process
+    : (globalThis as unknown as { process?: { cwd?: () => string; stdout?: { write(text: string): unknown }; stderr?: { write(text: string): unknown } } }).process;
+}
+
+function spawningDirectory(token: ProcessToken | null): string | undefined {
+  const realm = parentProcess(token);
   if (typeof realm?.cwd !== 'function') return undefined;
   try { return realm.cwd(); } catch { return undefined; }
 }
 
 /** Where an `inherit` entry's bytes go: the spawning program's own stream. */
-function inheritedWriter(fd: number): ((text: string) => void) | null {
+function inheritedWriter(fd: number, token: ProcessToken | null): ((text: string) => void) | null {
   if (fd !== 1 && fd !== 2) return null;
-  const realm = (globalThis as unknown as {
-    process?: { stdout?: { write(text: string): unknown }; stderr?: { write(text: string): unknown } };
-  }).process;
+  // Inherit the descriptor's original sink, not a guest replacement of
+  // process.stderr.write (a child commonly redirects its console over IPC).
+  if (token !== null) {
+    const parent = __runFor(token);
+    return (fd === 1 ? parent?.stdout : parent?.stderr) ?? null;
+  }
+  const realm = parentProcess(token);
   const stream = fd === 1 ? realm?.stdout : realm?.stderr;
   if (!stream || typeof stream.write !== 'function') return null;
   return (text: string) => {
@@ -195,6 +215,7 @@ export class Process implements OwnedHandle {
   private closed = false;
   /** The stdio entries this run was started with, and their far ends. */
   private stdio: StdioEntry[] = [];
+  private terminalEnds = new Map<number, TTY>();
   private readonly asyncId = nextAsyncId++;
 
   constructor() {
@@ -230,20 +251,37 @@ export class Process implements OwnedHandle {
     const request: RunRequest = {
       file: options.file,
       args: options.args ?? [options.file],
-      cwd: options.cwd ?? spawningDirectory(),
+      cwd: options.cwd ?? spawningDirectory(ownerOf(this)),
       env,
       detached: options.detached === true,
       stdout: null,
       stderr: null,
       stderrIsPipe: false,
       stdinIsPipe: false,
+      descriptors: [],
       exit: (code, signal) => { this.reportExit(code, signal); },
     };
 
-    let stdinFar: Pipe | null = null;
+    let stdinFar: LibuvStreamWrap | null = null;
     for (let index = 0; index < this.stdio.length; index += 1) {
       const entry = this.stdio[index];
       if (!entry) continue;
+      if (index < 3 && !entry.ipc) {
+        const descriptor = entry.type === 'fd' || entry.type === 'inherit'
+          ? handleForFd(entry.fd ?? index) : entry.handle;
+        if (descriptor instanceof TTY && descriptor.slave) {
+          // Inherit an independent descriptor reference, never the parent's
+          // wrapper. Failed spawn and child exit release only this copy.
+          const inherited = descriptor.duplicate();
+          __adoptHandle(inherited, null);
+          this.terminalEnds.set(index, inherited);
+          request.terminal = inherited.terminal;
+          if (index === 0) { stdinFar = inherited; request.stdinIsPipe = true; }
+          else if (index === 1) request.stdout = text => this.toPipe(index, text);
+          else request.stderr = text => this.toPipe(index, text);
+          continue;
+        }
+      }
       const far = this.pairFarEnd(entry);
       if (entry.ipc) {
         if (far) {
@@ -260,7 +298,12 @@ export class Process implements OwnedHandle {
         request.stdinIsPipe = far !== null;
         continue;
       }
-      if (index !== 1 && index !== 2) continue;
+      if (index > 2) {
+        // A pipe past fd 2 is the child's too, at its own number: libuv
+        // hands a child every `UV_CREATE_PIPE` entry, not only stdio's three.
+        if (far) request.descriptors.push({ fd: index, pipe: far });
+        continue;
+      }
       if (far) {
         const to = index;
         const write = (text: string): void => { this.toPipe(to, text); };
@@ -270,7 +313,7 @@ export class Process implements OwnedHandle {
           request.stderrIsPipe = true;
         }
       } else if (entry.type === 'inherit' || entry.type === 'fd') {
-        const inherited = inheritedWriter(entry.fd ?? index);
+        const inherited = inheritedWriter(entry.fd ?? index, ownerOf(this));
         if (index === 1) request.stdout = inherited;
         else request.stderr = inherited;
       }
@@ -284,7 +327,7 @@ export class Process implements OwnedHandle {
     this.run = runner.start(request);
     // The number the parent reads off the handle is the child's own
     // `process.pid`, as it is in Node; a runner that names none is given one.
-    this.pid = this.run.pid ?? nextPid++;
+    this.pid = this.run.pid ?? mintPid();
     if (stdinFar) this.readStdinFrom(stdinFar);
     return 0;
   }
@@ -324,7 +367,7 @@ export class Process implements OwnedHandle {
 
   /** The far end of fd `index`, whoever holds it now. */
   private farEndAt(index: number): LibuvStreamWrap | null {
-    return this.stdio[index]?.handle?.peer ?? null;
+    return this.terminalEnds.get(index) ?? this.stdio[index]?.handle?.peer ?? null;
   }
 
   private closeFarEnds(): void {
@@ -343,11 +386,22 @@ export class Process implements OwnedHandle {
   }
 
   /** Bytes the parent writes reach the child's fd 0; the parent's EOF ends it. */
-  private readStdinFrom(far: Pipe): void {
+  private readStdinFrom(far: LibuvStreamWrap): void {
     far.onread = (arrayBuffer: ArrayBuffer | null): void => {
       const length = streamBaseState[kReadBytesOrError];
       if (length <= 0 || arrayBuffer === null) { this.run?.endStdin(); return; }
-      this.run?.writeStdin(new Uint8Array(arrayBuffer, streamBaseState[kArrayBufferOffset], length).slice());
+      const run = this.run;
+      const consumed = run?.writeStdin(new Uint8Array(arrayBuffer, streamBaseState[kArrayBufferOffset], length).slice());
+      if (consumed) {
+        far.readStop();
+        void consumed.then(() => {
+          if (this.run === run && !this.ended && !far.closed) far.readStart();
+        }, () => {
+          // A stopped receiver closes its input pipe. Do not resume a reader
+          // or deliver its queued bytes to a later run.
+          if (this.run === run && !this.ended) { far.close(); run?.endStdin(); }
+        });
+      }
     };
     far.readStart();
   }