@volter/tabnode 0.2.14-volter.88

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

@@ -0,0 +1,252 @@
+/**
+ * The four small bindings Node's `internal/errors.js`, `internal/validators.js`
+ * and `internal/net.js` reach for on their way to `net`.
+ *
+ * Each is the whole of what those files read from it and nothing more.
+ */
+import { constantsBinding as buildConstantsBinding } from '../../shims/constants';
+import { UV_ENOSYS } from './uv';
+import * as osShim from '../../shims/os';
+import { nodeLibInternalRequire } from '../load';
+
+/**
+ * `internalBinding('constants')`: the engine's own constants module, which
+ * already answers Node's `os.signals`, `os.errno` and the rest.
+ * `internal/validators.js` reads `constants.os.signals` to validate a signal
+ * name.
+ *
+ * Built on the first property read, not when this file is evaluated. The
+ * function that builds the table reads `crypto.constants` through a getter;
+ * calling it at module scope is a use of that binding while `crypto.ts` is
+ * still in its body (the constants file and the crypto shim import each
+ * other through this table), which is `Cannot access 'constants$N' before
+ * initialization` in a consumer's Node.
+ */
+// eslint-disable-next-line no-var, vars-on-top
+var __constants: Record<string, unknown> | undefined;
+// eslint-disable-next-line no-var, vars-on-top
+var __zlibModesApplied = false;
+
+/**
+ * Node's `zlib` constant group carries the FLUSH and error values a program
+ * reads AND the mode enum its own `zlib.js` switches on -- `DEFLATE` through
+ * `ZSTD_DECOMPRESS`, which is how `new Gzip()` tells the binding what it is.
+ * The engine's table had the first half only, so `zlib.js` asserted on its
+ * own mode before it made a handle. The modes are added here, beside the
+ * group they belong to, in the order Node's own enum has them.
+ */
+const __zlibModes = {
+  DEFLATE: 1, INFLATE: 2, GZIP: 3, GUNZIP: 4, DEFLATERAW: 5, INFLATERAW: 6, UNZIP: 7,
+  BROTLI_DECODE: 8, BROTLI_ENCODE: 9, ZSTD_COMPRESS: 10, ZSTD_DECOMPRESS: 11,
+};
+
+function constantsOf(): Record<string, unknown> {
+  return __constants ??= buildConstantsBinding() as unknown as Record<string, unknown>;
+}
+
+function applyZlibModes(): void {
+  if (__zlibModesApplied) return;
+  __zlibModesApplied = true;
+  const table = constantsOf();
+  const zlib = table.zlib as Record<string, unknown> | undefined;
+  if (zlib) Object.assign(zlib, __zlibModes);
+  else table.zlib = { ...__zlibModes };
+}
+
+export const constantsBinding = new Proxy({} as Record<string, unknown>, {
+  get: (_t, key, receiver) => {
+    if (key === 'zlib') applyZlibModes();
+    return Reflect.get(constantsOf(), key, receiver);
+  },
+  set: (_t, key, value, receiver) => Reflect.set(constantsOf(), key, value, receiver),
+  has: (_t, key) => Reflect.has(constantsOf(), key),
+  ownKeys: () => Reflect.ownKeys(constantsOf()),
+  getOwnPropertyDescriptor: (_t, key) => {
+    if (key === 'zlib') applyZlibModes();
+    const descriptor = Reflect.getOwnPropertyDescriptor(constantsOf(), key);
+    return descriptor === undefined ? undefined : { ...descriptor, configurable: true };
+  },
+  defineProperty: (_t, key, descriptor) => Reflect.defineProperty(constantsOf(), key, descriptor),
+});
+
+/**
+ * `internalBinding('os')`: `internal/errors.js` names the host in the banner
+ * it prints for an uncaught exception under a report flag the engine never
+ * sets, which is the only call.
+ */
+// eslint-disable-next-line no-var, vars-on-top
+var __priorities = new Map<number, number>();
+
+export const osBinding = {
+  /** Node's `os.type()`, `release()` and `version()`, in that order. */
+  getOSInformation: (): string[] => [osShim.type(), osShim.release(), osShim.version()],
+  getHostname: (): string => osShim.hostname(),
+  getHomeDirectory: (): string => osShim.homedir(),
+  getUptime: (): number => osShim.uptime(),
+  getTotalMem: (): number => osShim.totalmem(),
+  getFreeMem: (): number => osShim.freemem(),
+  getLoadAvg: (array: Float64Array): void => {
+    const [one, five, fifteen] = osShim.loadavg();
+    array[0] = one; array[1] = five; array[2] = fifteen;
+  },
+  getAvailableParallelism: (): number => (osShim as { availableParallelism?: () => number }).availableParallelism?.() ?? osShim.cpus().length,
+  isBigEndian: osShim.endianness() === 'BE',
+  /**
+   * Node reads its CPU list as a flat array: a model and a speed, then the
+   * five time counters, for each core.
+   */
+  getCPUs: (): Array<string | number> => {
+    const flat: Array<string | number> = [];
+    for (const cpu of osShim.cpus()) {
+      flat.push(cpu.model, cpu.speed, cpu.times.user, cpu.times.nice, cpu.times.sys, cpu.times.idle, cpu.times.irq);
+    }
+    return flat;
+  },
+  /**
+   * The same shape for interfaces: name, address, netmask, family, mac,
+   * scope id, then the CIDR, per address.
+   */
+  getInterfaceAddresses: (): Array<string | number | boolean> => {
+    const flat: Array<string | number | boolean> = [];
+    for (const [name, addresses] of Object.entries(osShim.networkInterfaces())) {
+      for (const address of addresses ?? []) {
+        flat.push(name, address.address, address.netmask, address.family === 'IPv6' ? 6 : 4,
+          address.mac, address.internal, (address as { scopeid?: number }).scopeid ?? 0);
+      }
+    }
+    return flat;
+  },
+  getUserInfo: (): Record<string, unknown> => osShim.userInfo() as unknown as Record<string, unknown>,
+  /**
+   * A process's niceness. A tab has no scheduler to hand it to, but the pair
+   * still has to agree: a program that sets a priority and reads it back must
+   * see what it set, which is what `test-os.js` checks. The value is this
+   * engine's, per pid, and changes nothing about how anything runs.
+   */
+  getPriority: (pid: number): number => __priorities.get(pid || 0) ?? osShim.getPriority(pid),
+  setPriority: (pid: number, priority: number): number => {
+    __priorities.set(pid || 0, priority);
+    osShim.setPriority(pid, priority);
+    return 0;
+  },
+};
+
+/**
+ * `internalBinding('credentials')`: the one name `os.js` takes from it. A tab
+ * has no environment of its own to read `TMPDIR` from, so the answer is the
+ * directory the engine's `os` calls its temporary one.
+ */
+export const credentialsBinding = {
+  /**
+   * Where a temporary file goes. Node reads `TMPDIR`, then `TMP`, then
+   * `TEMP` from the environment and falls back to the platform's directory,
+   * dropping a trailing slash; a program that sets `TMPDIR` expects to be
+   * obeyed, which is what `test-os.js` checks.
+   */
+  getTempDir: (): string => {
+    const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env ?? {};
+    const named = env.TMPDIR || env.TMP || env.TEMP;
+    const chosen = named && named.length > 0 ? named : osShim.tmpdir();
+    return chosen.length > 1 && chosen.endsWith('/') ? chosen.slice(0, -1) : chosen;
+  },
+};
+
+/**
+ * `internalBinding('encoding_binding')`: the punycode conversion `url.js`
+ * makes for a host name, out of the engine's own `punycode`.
+ */
+export const encodingBinding = {
+  toASCII: (value: string): string => (nodeLibInternalRequire('punycode') as { toASCII(value: string): string }).toASCII(value),
+  toUnicode: (value: string): string => (nodeLibInternalRequire('punycode') as { toUnicode(value: string): string }).toUnicode(value),
+};
+
+/**
+ * `internalBinding('config')`: the build switches Node's own files read. The
+ * engine has no ICU, so `buffer.transcode` is not defined -- which is what
+ * Node without ICU does, and is the one thing `buffer.js` loses here.
+ */
+export const configBinding = {
+  hasIntl: false,
+  hasSmallICU: false,
+  hasNodeOptions: true,
+  hasInspector: false,
+  noBrowserGlobals: false,
+  bits: 64,
+  hasOpenSSL: false,
+  fipsMode: false,
+  hasDtrace: false,
+};
+
+/**
+ * `internalBinding('fs')`: `internal/net.js`'s `makeSyncWrite` writes a
+ * descriptor synchronously, which Node does only for Windows' stdout and
+ * stderr. The engine's platform is `linux` and nothing reaches it.
+ */
+export const fsBinding = {
+  writeBuffer: (_fd: number, _buffer: Uint8Array, _offset: number, _length: number,
+    _position: unknown, _req: unknown, ctx: { errno?: number; syscall?: string }): number => {
+    ctx.errno = UV_ENOSYS;
+    ctx.syscall = 'write';
+    return 0;
+  },
+};
+
+
+/**
+ * `internalBinding('types')`: V8's own type tests. The engine answers them
+ * out of the realm's built-ins, and `internal/util/types` is the same object
+ * -- Node's own `util.types` is that binding with a doc comment on it.
+ */
+export { internalUtilTypes as typesBinding } from '../internals/util';
+
+/**
+ * `internalBinding('string_decoder')`: `internal/util.js` reads the table of
+ * encoding names out of it to normalize one.
+ */
+export const stringDecoderBinding = {
+  encodings: ['ascii', 'utf8', 'base64', 'ucs2', 'binary', 'hex', 'utf16le', 'base64url'],
+};
+
+/**
+ * `internalBinding('trace_events')`: the tracing category buffer
+ * `internal/util/debuglog.js` reads to decide whether a section is traced.
+ * Nothing in a tab is traced, so every category reads 0 -- which is what
+ * `debuglog` checks before it formats anything.
+ */
+export const traceEventsBinding = {
+  getCategoryEnabledBuffer: (): Uint8Array => new Uint8Array(1),
+  trace: (): void => {},
+};
+
+/**
+ * `internalBinding('messaging')`: `internal/util.js` reaches for
+ * `DOMException` through it, which the realm already has.
+ */
+export const messagingBinding = {
+  get DOMException() { return (globalThis as { DOMException?: unknown }).DOMException; },
+};
+
+
+/**
+ * `internalBinding('errors')`: the one call `diagnostics_channel.js` makes
+ * into it. A subscriber that throws must not be swallowed and must not take
+ * the publisher with it, so Node hands the error to the process as an
+ * uncaught exception. The engine has that door already -- it is how a run
+ * reports a throw nobody caught -- and this reaches it through the realm's
+ * own process, which is the run's.
+ */
+export const errorsBinding = {
+  triggerUncaughtException: (error: unknown, fromPromise = false): void => {
+    const realm = (globalThis as {
+      process?: { emit?: (event: string, ...args: unknown[]) => boolean; listenerCount?: (event: string) => number };
+    }).process;
+    const event = fromPromise ? 'unhandledRejection' : 'uncaughtException';
+    if (realm && typeof realm.listenerCount === 'function' && realm.listenerCount(event) > 0) {
+      realm.emit?.(event, error, event);
+      return;
+    }
+    // Nobody is listening: the throw becomes this realm's, on the next turn,
+    // rather than the publisher's to catch.
+    setTimeout(() => { throw error; }, 0);
+  },
+};

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

@@ -0,0 +1,166 @@
+/**
+ * `internalBinding('pipe_wrap')`: the same loopback, named by a path.
+ *
+ * VS Code's extension host is started by its parent and connects back to it
+ * over a unix-domain socket path: the parent runs `server.listen(path)` and
+ * the child `net.connect(path)`. A path is a name in one registry here, as a
+ * port is a number in the other; nothing on the path is `ENOENT`, which is
+ * what Node answers, and a path a live server already holds is `EADDRINUSE`.
+ *
+ * The IPC flavour is the same stream with one extra: a write may carry a
+ * handle, which is set on the peer before the peer's read, and that is how
+ * `setupChannel` in `internal/child_process.js` receives a sent socket.
+ */
+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';
+
+/** libuv's `uv_pipe_t` flavours, and the two chmod bits `listen` reads. */
+export const constants = {
+  SOCKET: 0,
+  SERVER: 1,
+  IPC: 1 << 1,
+  UV_READABLE: 1,
+  UV_WRITABLE: 2,
+};
+
+/** Node's `PipeConnectWrap`: the request a pipe connect is answered through. */
+export class PipeConnectWrap {
+  oncomplete: ((status: number, handle: unknown, req: unknown, readable: boolean, writable: boolean) => void) | null = null;
+  address = '';
+}
+
+/** Every path this engine holds, bound or listening. */
+const boundPaths = new Map<string, Pipe>();
+
+/** The listening pipe a connect to this path reaches, if any. */
+export function listenerOnPath(path: string): Pipe | undefined {
+  const bound = boundPaths.get(path);
+  return bound && bound.listening ? bound : undefined;
+}
+
+export class Pipe extends LibuvStreamWrap {
+  readonly type: number;
+  listening = false;
+  onconnection: ((status: number, clientHandle: Pipe) => void) | null = null;
+
+  private path: string | null = null;
+  private ownFd: number | null = null;
+
+  constructor(type: number = constants.SOCKET) {
+    super();
+    this.type = type;
+  }
+
+  bind(path: string): number {
+    const held = boundPaths.get(path);
+    if (held && held !== this) return UV_EADDRINUSE;
+    this.path = path;
+    boundPaths.set(path, this);
+    return 0;
+  }
+
+  listen(_backlog: number): number {
+    if (this.path === null) return UV_EBADF;
+    this.listening = true;
+    return 0;
+  }
+
+  connect(req: PipeConnectWrap, path: string): number {
+    // libuv answers a connect through the request, never from the call.
+    queueMicrotask(() => {
+      if (this.closed) return;
+      const server = listenerOnPath(path);
+      if (!server) {
+        req.oncomplete?.(UV_ENOENT, this, req, true, true);
+        return;
+      }
+      const accepted = new 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));
+      LibuvStreamWrap.pair(this, accepted);
+      server.onconnection?.(0, accepted);
+      req.oncomplete?.(0, this, req, true, true);
+    });
+    return 0;
+  }
+
+  /**
+   * The descriptor of a handle the engine itself opened — a forked child's IPC
+   * channel among them. There is nothing else to open: the engine has no
+   * descriptors of its own beyond the ones it hands out. Opening one takes
+   * over that end of its pairing, with whatever arrived on it before anyone
+   * opened it, because a child's channel is written to before the child runs.
+   */
+  open(fd: number): number {
+    const held = handleForFd(fd) as LibuvStreamWrap | undefined;
+    if (!held) return UV_EBADF;
+    this.takeOverFrom(held);
+    this.ownFd = fd;
+    this.fd = fd;
+    return 0;
+  }
+
+  /** The descriptor this handle can be reached at, for a child's stdio table. */
+  toFd(): number {
+    if (this.ownFd === null) { this.ownFd = registerFd('PIPE', this); this.fd = this.ownFd; }
+    return this.ownFd;
+  }
+
+  /** libuv's `dup()`: the same pairing, under the same flavour. */
+  override duplicate(): Pipe {
+    const copy = new Pipe(this.type);
+    copy.takeOverFrom(this);
+    return copy;
+  }
+
+  /** There is no filesystem entry behind an engine pipe to change the mode of. */
+  fchmod(_mode: number): number {
+    return 0;
+  }
+
+  /** Windows asks for more pipe instances; the engine has one realm and one. */
+  setPendingInstances(_count: number): number {
+    return 0;
+  }
+
+  /**
+   * An IPC write may carry a handle. The peer is given it before the bytes, so
+   * `setupChannel`'s reader sees `channel.pendingHandle` when the message it
+   * belongs to arrives, which is the order Node delivers them in.
+   *
+   * 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
+   * 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);
+    // 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
+    // moment the receiver confirms -- ends nothing. A handle with no pairing,
+    // 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.
+    __adoptHandle(given, ownerOf(this.peer ?? this));
+    return super.writeUtf8String(req, text, given);
+  }
+
+  protected override onCloseHandle(): void {
+    this.listening = false;
+    this.onconnection = null;
+    if (this.path !== null && boundPaths.get(this.path) === this) boundPaths.delete(this.path);
+    if (this.ownFd !== null) { releaseFd(this.ownFd); this.ownFd = null; }
+  }
+}
+
+export default { Pipe, PipeConnectWrap, constants };