@volter/tabnode 0.5.11 → 0.5.12

package/dist/index.d.ts

@@ -44,6 +44,7 @@ import { Runtime, RuntimeOptions } from './runtime';
 import { PackageManager } from './npm';
 import { ServerBridge } from './server-bridge';
 import { type Socket as NetSocket } from './node-lib/net-module';
+import { type NativeStreamHandleView } from './native-stream-owner';
 import { runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
 export { createProcessRegistryScope, installProcessRegistry, ownerProcessRegistryScope, ownerProcessTable } from './process-tokens';
@@ -52,7 +53,7 @@ export type { NodeProcessLaunch, NodeProcessHost } from './node-process-host';
 export type { ProcessIdentity, ProcessRegistry, ProcessRegistryScope, InitialProcessRegistration } from './process-registry';
 export { NativeStreamScope } from './native-stream-owner';
 export { installNativeStreamTransport, nativeStreamDescriptor } from './native-stream-binding';
-export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport } from './native-stream-owner';
+export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport, NativeStreamHandleView } from './native-stream-owner';
 export interface RunResult {
     stdout: string;
     stderr: string;
@@ -116,6 +117,8 @@ export declare function createContainer(options?: ContainerOptions): {
     processPorts: (token: string) => number[];
     /** The pid of the process listening on a port of this engine, where a guest process is: `/proc`'s socket owner. */
     portPid: (port: number) => number | undefined;
+    /** The stream handles the processes of other workers hold through this engine: `/proc/<pid>/fd`. */
+    streamHandles: () => NativeStreamHandleView[];
     /** Deliver a signal to the named run as another process's `kill(pid)` does; false when the run is gone. */
     signalProcess: (token: string, signal: string) => boolean;
     stopProcess: (token: string) => boolean;

package/dist/index.mjs

@@ -38098,6 +38098,7 @@ function resetServerBridge() {
   globalBridge = null;
 }
 const scopes = /* @__PURE__ */ new WeakMap();
+const liveScopes = /* @__PURE__ */ new Set();
 class NativeStreamScope {
   /**
    * `ownerPid` names the process whose worker this scope serves: a listener
@@ -38116,6 +38117,19 @@ class NativeStreamScope {
     this.ownerPid = ownerPid;
     if ([limits.maxHandles, limits.maxReadChunkBytes, limits.maxQueuedBytes, limits.maxQueuedHandles, limits.maxPendingWriteBytes].some((value) => !Number.isSafeInteger(value) || value < 1) || limits.maxReadChunkBytes > 2147483647 || limits.maxReadChunkBytes > limits.maxQueuedBytes || limits.maxReadChunkBytes > limits.maxPendingWriteBytes) throw new Error("Invalid native stream resource limits.");
     this.limits = Object.freeze({ ...limits });
+    liveScopes.add(this);
+  }
+  /** This scope's open handles, with the process it serves. */
+  handles() {
+    var _a2;
+    if (this.disposed) return [];
+    const pid = (_a2 = this.ownerPid) == null ? void 0 : _a2.call(this);
+    return [...this.entries.values()].map(({ handle, descriptor }) => ({
+      ...pid !== void 0 ? { pid } : {},
+      id: descriptor.id,
+      kind: descriptor.kind,
+      listening: !!handle.listening
+    }));
   }
   entry(id) {
     return this.disposed ? void 0 : this.entries.get(id);
@@ -38387,6 +38401,7 @@ class NativeStreamScope {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    liveScopes.delete(this);
     const failures = [];
     for (const id of [...this.entries.keys()]) {
       try {
@@ -38402,6 +38417,9 @@ function nativeStreamOwnerPid(handle) {
   var _a2, _b2;
   return (_b2 = (_a2 = scopes.get(handle)) == null ? void 0 : _a2.ownerPid) == null ? void 0 : _b2.call(_a2);
 }
+function nativeStreamHandles() {
+  return [...liveScopes].flatMap((scope) => scope.handles());
+}
 let __nextRunName = 1;
 function createContainer(options) {
   const vfs2 = options && options.vfs || new VirtualFS();
@@ -38464,6 +38482,7 @@ function createContainer(options) {
       if (!listener) return void 0;
       return ((_a2 = runPid(ownerOf(listener))) == null ? void 0 : _a2.pid) ?? nativeStreamOwnerPid(listener);
     },
+    streamHandles: () => nativeStreamHandles(),
     /**
      * Deliver a signal to the named run as another process's `kill(pid)` does:
      * the guest's listeners for it run, else its default action ends the run.

package/dist/native-stream-owner.d.ts

@@ -88,6 +88,13 @@ export interface NativeStreamTransport {
     write(id: number, bytes: Uint8Array, handle?: number): Promise<number>;
     onEvent(listener: (event: NativeStreamEvent) => void): () => void;
 }
+/** One open stream handle, as a process's descriptor table shows it. */
+export interface NativeStreamHandleView {
+    pid?: number;
+    id: number;
+    kind: 'tcp' | 'pipe';
+    listening: boolean;
+}
 /**
  * One capability namespace per worker. Only the trusted host can inherit a
  * descriptor from another scope; wire operations can name this scope's IDs only.
@@ -108,6 +115,8 @@ export declare class NativeStreamScope {
      * it opens is that process's socket, as the container's /proc shows it.
      */
     constructor(limits: NativeStreamLimits, emit: (event: NativeStreamEvent) => void, ownerPid?: (() => number | undefined) | undefined);
+    /** This scope's open handles, with the process it serves. */
+    handles(): NativeStreamHandleView[];
     private entry;
     private publish;
     private claim;
@@ -126,3 +135,5 @@ export declare class NativeStreamScope {
 }
 /** The process a handle opened for another worker's process belongs to, where a scope holds it. */
 export declare function nativeStreamOwnerPid(handle: object): number | undefined;
+/** Every open native stream handle in this worker, by the process each scope serves. */
+export declare function nativeStreamHandles(): NativeStreamHandleView[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.11",
+  "version": "0.5.12",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -56,7 +56,7 @@ import { runCommand, registerRunStreams, releaseRunStreams, sendStdin } from './
 import { Server as NetServer, __releaseOwnedHandles, type Socket as NetSocket } from './node-lib/net-module';
 import { __adoptHandle, ownerOf, type OwnedHandle } from './node-lib/binding/handles';
 import { listenerOnPort } from './node-lib/binding/tcp_wrap';
-import { nativeStreamOwnerPid } from './native-stream-owner';
+import { nativeStreamHandles, nativeStreamOwnerPid, type NativeStreamHandleView } from './native-stream-owner';
 
 import { __currentProcessToken, __runFor, __signalOwnedProcess, __takeTermination, __stopOwnedProcess, runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
@@ -66,7 +66,7 @@ export type { NodeProcessLaunch, NodeProcessHost } from './node-process-host';
 export type { ProcessIdentity, ProcessRegistry, ProcessRegistryScope, InitialProcessRegistration } from './process-registry';
 export { NativeStreamScope } from './native-stream-owner';
 export { installNativeStreamTransport, nativeStreamDescriptor } from './native-stream-binding';
-export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport } from './native-stream-owner';
+export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport, NativeStreamHandleView } from './native-stream-owner';
 
 export interface RunResult {
   stdout: string;
@@ -129,6 +129,8 @@ export function createContainer(options?: ContainerOptions): {
   processPorts: (token: string) => number[];
   /** The pid of the process listening on a port of this engine, where a guest process is: `/proc`'s socket owner. */
   portPid: (port: number) => number | undefined;
+  /** The stream handles the processes of other workers hold through this engine: `/proc/<pid>/fd`. */
+  streamHandles: () => NativeStreamHandleView[];
   /** Deliver a signal to the named run as another process's `kill(pid)` does; false when the run is gone. */
   signalProcess: (token: string, signal: string) => boolean;
   stopProcess: (token: string) => boolean;
@@ -224,6 +226,7 @@ export function createContainer(options?: ContainerOptions): {
       // a guest's own listener, or one this engine holds for another worker's process
       return runPid(ownerOf(listener as unknown as OwnedHandle))?.pid ?? nativeStreamOwnerPid(listener);
     },
+    streamHandles: (): NativeStreamHandleView[] => nativeStreamHandles(),
     /**
      * Deliver a signal to the named run as another process's `kill(pid)` does:
      * the guest's listeners for it run, else its default action ends the run.

package/src/native-stream-owner.ts

@@ -41,6 +41,12 @@ export interface NativeStreamTransport {
 type NativeHandle = TCP | Pipe;
 interface Entry { handle: NativeHandle; descriptor: NativeStreamDescriptor; buffer?: Uint8Array }
 const scopes = new WeakMap<LibuvStreamWrap, NativeStreamScope>();
+// Every scope not yet disposed: what the container's /proc lists as each
+// process's descriptors.
+const liveScopes = new Set<NativeStreamScope>();
+
+/** One open stream handle, as a process's descriptor table shows it. */
+export interface NativeStreamHandleView { pid?: number; id: number; kind: 'tcp' | 'pipe'; listening: boolean }
 
 /**
  * One capability namespace per worker. Only the trusted host can inherit a
@@ -66,6 +72,16 @@ export class NativeStreamScope {
       || limits.maxReadChunkBytes > limits.maxQueuedBytes
       || limits.maxReadChunkBytes > limits.maxPendingWriteBytes) throw new Error('Invalid native stream resource limits.');
     this.limits = Object.freeze({ ...limits });
+    liveScopes.add(this);
+  }
+
+  /** This scope's open handles, with the process it serves. */
+  handles(): NativeStreamHandleView[] {
+    if (this.disposed) return [];
+    const pid = this.ownerPid?.();
+    return [...this.entries.values()].map(({ handle, descriptor }) => ({
+      ...(pid !== undefined ? { pid } : {}), id: descriptor.id, kind: descriptor.kind, listening: !!handle.listening,
+    }));
   }
 
   private entry(id: number): Entry | undefined {
@@ -318,6 +334,7 @@ export class NativeStreamScope {
   dispose(): void {
     if (this.disposed) return;
     this.disposed = true;
+    liveScopes.delete(this);
     const failures: unknown[] = [];
     for (const id of [...this.entries.keys()]) {
       try { this.close(id); } catch (cause) { failures.push(cause); }
@@ -330,3 +347,8 @@ export class NativeStreamScope {
 export function nativeStreamOwnerPid(handle: object): number | undefined {
   return scopes.get(handle as NativeHandle)?.ownerPid?.();
 }
+
+/** Every open native stream handle in this worker, by the process each scope serves. */
+export function nativeStreamHandles(): NativeStreamHandleView[] {
+  return [...liveScopes].flatMap(scope => scope.handles());
+}