@volter/tabnode 0.5.4 → 0.5.6

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

@@ -40,7 +40,7 @@ import { errname } from './uv';
  * the same shape here rather than widened there.
  */
 function createNodeError(code: string, syscall: string, path: string): Error {
-  const known = ['EEXIST', 'EINVAL', 'EISDIR', 'ENOENT', 'ENOTDIR', 'ENOTEMPTY', 'ELOOP'];
+  const known = ['EEXIST', 'EINVAL', 'EISDIR', 'ENOENT', 'ENOTDIR', 'ENOTEMPTY', 'ELOOP', 'EROFS'];
   if (known.includes(code)) return vfsError(code as 'ENOENT', syscall, path);
   return Object.assign(new Error(`${code}: ${syscall} '${path}'`), { code, syscall, path, errno: -9 });
 }

package/src/process-registry.ts

@@ -2,6 +2,22 @@
 export interface ProcessIdentity {
   readonly pid: number;
   readonly ppid: number;
+  /** What the process was started as, where its starter said: `/proc/<pid>/cmdline`. */
+  readonly argv?: readonly string[];
+  /** The directory it was started in: `/proc/<pid>/cwd`. */
+  readonly cwd?: string;
+  /** When it started, in milliseconds since the epoch. */
+  readonly startedAt?: number;
+}
+
+/** The parts of an identity a starter may add, checked before they are kept. */
+function describedIdentity(identity: ProcessIdentity): ProcessIdentity {
+  const { pid, ppid, argv, cwd, startedAt } = identity;
+  const described: { pid: number; ppid: number; argv?: readonly string[]; cwd?: string; startedAt?: number } = { pid, ppid };
+  if (Array.isArray(argv) && argv.length <= 4096 && argv.every(arg => typeof arg === 'string')) described.argv = Object.freeze([...argv]);
+  if (typeof cwd === 'string' && cwd.startsWith('/')) described.cwd = cwd;
+  if (typeof startedAt === 'number' && Number.isFinite(startedAt)) described.startedAt = startedAt;
+  return Object.freeze(described);
 }
 
 /** A run already admitted by the container owner into this realm's scope. */
@@ -38,7 +54,7 @@ export interface ProcessRegistryScope extends ProcessRegistry {
  * so identical local run tokens cannot overwrite or release another realm's
  * process. Allocation alone does not announce a live process.
  */
-export function createProcessRegistryOwner(): { createScope(): ProcessRegistryScope } {
+export function createProcessRegistryOwner(): { createScope(): ProcessRegistryScope; table(): ProcessIdentity[] } {
   let nextPid = 1000 + Math.floor(Math.random() * 30000);
   const live = new Map<number, ProcessIdentity>();
   // Which realm's scope answers for each live pid, including after handoff.
@@ -104,7 +120,7 @@ export function createProcessRegistryOwner(): { createScope(): ProcessRegistrySc
           if (identity.ppid !== 0 && !Array.from(runs.values()).some(parent => parent.pid === identity.ppid)) {
             throw new Error('Parent process is not owned by this realm.');
           }
-          const entry = Object.freeze({ pid: identity.pid, ppid: identity.ppid });
+          const entry = describedIdentity(identity);
           runs.set(token, entry);
           live.set(entry.pid, entry);
           receivers.set(entry.pid, receiver);
@@ -140,5 +156,9 @@ export function createProcessRegistryOwner(): { createScope(): ProcessRegistrySc
       scopes.set(scope, { allocated, runs, active });
       return scope;
     },
+    /** Every live process of the container, in pid order: what `/proc` lists. */
+    table() {
+      return [...live.values()].sort((a, b) => a.pid - b.pid);
+    },
   };
 }

package/src/process-tokens.ts

@@ -17,7 +17,7 @@
 
 import type { Process } from './shims/process';
 import { AsyncLocalStorage } from './shims/async_hooks';
-import { createProcessRegistryOwner, type ProcessRegistry, type ProcessRegistryScope, type InitialProcessRegistration } from './process-registry';
+import { createProcessRegistryOwner, type ProcessIdentity, type ProcessRegistry, type ProcessRegistryScope, type InitialProcessRegistration } from './process-registry';
 
 /** Whatever the embedding runtime uses to name one guest process. */
 export type ProcessToken = string;
@@ -113,6 +113,27 @@ export function __stopOwnedProcess(token: ProcessToken): void {
   runs.get(token)?.stopTimers();
 }
 
+/**
+ * Another process's `kill(pid, signal)`, delivered to a named run's guest.
+ * On a machine the target's handlers run, or its default action ends it; the
+ * guest's own `process.kill(process.pid, signal)` is exactly that, so the
+ * signal is raised through it, as the run. False when the run is gone or the
+ * signal is not one Node names.
+ */
+export function __signalOwnedProcess(token: ProcessToken, signal: string): boolean {
+  const run = runs.get(token);
+  if (!run) return false;
+  const guest = run.process as unknown as { pid: number; kill(pid: number, signal: string): unknown };
+  try { enterRun(token, () => guest.kill(guest.pid, signal)); }
+  catch (error) {
+    // A default action ends the process by `exit`, which a synchronous guest
+    // frame reports by throwing; that is the signal delivered.
+    if (error instanceof Error && error.message.startsWith("Process exited with code")) return true;
+    return false;
+  }
+  return true;
+}
+
 /**
  * A process's own number.
  *
@@ -147,6 +168,12 @@ export function createProcessRegistryScope(): ProcessRegistryScope {
   return processRegistryOwner.createScope();
 }
 
+/** Trusted container owner only: every live process of the container, from every realm. */
+export function ownerProcessTable(): ProcessIdentity[] {
+  if (registryInstalled) throw new Error('This realm is a process registry client, not the container owner.');
+  return processRegistryOwner.table();
+}
+
 /** Trusted container owner only; worker clients cannot expose their authority. */
 export function ownerProcessRegistryScope(): ProcessRegistryScope {
   if (registryInstalled) throw new Error('This realm is a process registry client, not the container owner.');
@@ -177,9 +204,9 @@ export function mintPid(): number {
 }
 
 /** Record the numbers a named run was started with, for the run to read back. */
-export function setRunPid(token: ProcessToken, pid: number, ppid: number): void {
+export function setRunPid(token: ProcessToken, pid: number, ppid: number, started?: { argv?: readonly string[]; cwd?: string }): void {
   registryUsed = true;
-  processRegistry.publish(token, { pid, ppid });
+  processRegistry.publish(token, { pid, ppid, ...started, startedAt: Date.now() });
   pidsOfRuns.set(token, { pid, ppid });
 }
 

package/src/runtime.ts

@@ -343,23 +343,49 @@ function transformDynamicImportsRegex(code: string): string {
  * saw no import at all.
  */
 function __substrateRewriteDynamicImportsInScript(code: string): string {
-  if (!/(?<![.$\w#])import\s*\(/.test(code)) return code;
+  if (!/(?<![.$\w#])(?:import|eval)\s*\(/.test(code)) return code;
   let ast;
   try {
     ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "script", allowReturnOutsideFunction: true, allowHashBang: true, allowAwaitOutsideFunction: true });
   } catch {
     return code;
   }
-  const replacements: Array<[number, number]> = [];
+  const replacements: Array<[number, number, string]> = [];
   walkAst(ast, (node: any) => {
-    if (node.type === "ImportExpression") replacements.push([node.start, node.start + 6]);
+    if (node.type === "ImportExpression") replacements.push([node.start, node.start + 6, "__dynamicImport"]);
+    collectDirectEval(node, replacements);
   });
   if (replacements.length === 0) return code;
-  replacements.sort((a, b) => b[0] - a[0]);
+  return applyReplacements(code, replacements);
+}
+
+/**
+ * A direct `eval` runs source the module builds at run time, and Node runs an
+ * `import()` in it through the module's loader: Playwright loads an ES config
+ * with ``eval(`import(${url})`)``. The call stays a direct eval, so the
+ * source keeps the module's scope, `__dynamicImport` included; only the
+ * source it is given is rewritten the way the module's own was.
+ */
+function collectDirectEval(node: any, replacements: Array<[number, number, string]>): void {
+  if (node.type !== "CallExpression" || node.optional || node.callee?.type !== "Identifier" || node.callee.name !== "eval") return;
+  const source = node.arguments?.[0];
+  if (!source || source.type === "SpreadElement") return;
+  replacements.push([source.start, source.start, "__substrateEvalSource("]);
+  replacements.push([source.end, source.end, ")"]);
+}
+
+/** Applies insertions and replacements from the end, so earlier offsets hold. */
+function applyReplacements(code: string, replacements: Array<[number, number, string]>): string {
+  replacements.sort((a, b) => b[0] - a[0] || b[1] - a[1]);
   let out = code;
-  for (const [start, end] of replacements) out = out.slice(0, start) + "__dynamicImport" + out.slice(end);
+  for (const [start, end, text] of replacements) out = out.slice(0, start) + text + out.slice(end);
   return out;
 }
+
+Object.defineProperty(globalThis, "__substrateEvalSource", {
+  configurable: true,
+  value: (source: unknown): unknown => typeof source === "string" ? __substrateRewriteDynamicImportsInScript(source) : source,
+});
 function transformEsmToCjs(code: string, filename: string): string {
   // Quick check: does the code have any ESM-like patterns?
   const maybeEsm = __substrateHasEsmSyntax(code);
@@ -401,6 +427,7 @@ function transformEsmToCjsAst(code: string, filename: string): string {
       // Replace just the 'import' keyword, preserving the (...) part
       deepReplacements.push([node.start, node.start + 6, '__dynamicImport']);
     }
+    collectDirectEval(node, deepReplacements);
   });
 
   // Check for actual import/export declarations
@@ -408,11 +435,7 @@ function transformEsmToCjsAst(code: string, filename: string): string {
   const hasExportDecl = ast.body.some((n: any) => n.type?.startsWith('Export'));
 
   // Apply deep replacements from end to start (preserves earlier positions)
-  let transformed = code;
-  deepReplacements.sort((a, b) => b[0] - a[0]);
-  for (const [start, end, replacement] of deepReplacements) {
-    transformed = transformed.slice(0, start) + replacement + transformed.slice(end);
-  }
+  let transformed = applyReplacements(code, deepReplacements);
 
   // Transform import/export declarations (re-parses the modified code)
   if (hasImportDecl || hasExportDecl) {

package/src/shims/child_process.ts

@@ -199,7 +199,7 @@ const _runStreams = new Map<ProcessToken, RunStreams>();
 /** Submit before returning to a spawning parent; completion remains async. */
 async function runHostedNode(host: NodeProcessHost, launch: Omit<NodeProcessLaunch, 'identity' | 'inherited' | 'stdinStream'>): Promise<CommandOutcome> {
   const { token, streams } = launch;
-  if (!runPid(token)) setRunPid(token, mintPid(), 0);
+  if (!runPid(token)) setRunPid(token, mintPid(), 0, { argv: ['node', ...launch.argv], cwd: launch.cwd });
   let input: ReturnType<typeof nodeProcessInput> | undefined;
   try {
     streams?.signal?.throwIfAborted();
@@ -578,7 +578,7 @@ export function initChildProcess(vfs: VirtualFS): void {
     // This run's numbers, recorded under its name: a child it spawns reads
     // them for its own `ppid`, and `process.kill(pid, 0)` asks this registry
     // whether a pid is a live process.
-    if (runToken !== null) setRunPid(runToken, proc.pid, proc.ppid);
+    if (runToken !== null) setRunPid(runToken, proc.pid, proc.ppid, { argv: ['node', ...args], cwd: ctx.cwd });
     const releaseRun = runToken === null ? null : __recordRun(runToken, {
       process: proc,
       stdout: appendStdout,
@@ -1680,7 +1680,8 @@ function startChildRun(request: RunRequest): StartedRun {
   const pid = mintPid();
   // In a process realm the admitted guest is always the spawning parent.
   // Async bookkeeping for a routed child must not make that child its parent.
-  setRunPid(token, pid, runPid(nodeProcessRealmToken() ?? __currentProcessToken() ?? __lastLaunchedToken)?.pid ?? 0);
+  setRunPid(token, pid, runPid(nodeProcessRealmToken() ?? __currentProcessToken() ?? __lastLaunchedToken)?.pid ?? 0,
+    { argv: request.args.length ? request.args : [request.file], ...(request.cwd ? { cwd: request.cwd } : {}) });
   const controller = new AbortController();
   const pendingStdin: Array<Uint8Array | null> = [];
   // A host terminal consumes input incrementally. The old string-only

package/src/virtual-fs.ts

@@ -44,6 +44,23 @@ export interface FSNode {
    * apart). Absent until something sets it, which is the write time.
    */
   atime?: number;
+  /**
+   * A tree mounted here: the paths below this node are the tree's, answered
+   * when they are read, and never this filesystem's to write. Linux's
+   * `/proc` is one.
+   */
+  mount?: MountedTree;
+}
+
+/**
+ * A read-only tree another party answers, mounted at a directory: `node`
+ * returns what is at a path relative to the mount point (`/` is the mount
+ * point itself), computed when it is asked, or undefined where nothing is.
+ * A directory's `children` names what a listing shows; a link's `target` is
+ * followed as any link is.
+ */
+export interface MountedTree {
+  node(path: string): FSNode | undefined;
 }
 
 // Identity belongs to the node, so writes and renames preserve it while an
@@ -116,7 +133,7 @@ export interface NodeError extends Error {
 }
 
 export function createNodeError(
-  code: 'ENOENT' | 'ENOTDIR' | 'EISDIR' | 'EEXIST' | 'ENOTEMPTY' | 'ELOOP' | 'EINVAL',
+  code: 'ENOENT' | 'ENOTDIR' | 'EISDIR' | 'EEXIST' | 'ENOTEMPTY' | 'ELOOP' | 'EINVAL' | 'EROFS',
   syscall: string,
   path: string,
   message?: string
@@ -127,6 +144,7 @@ export function createNodeError(
     EISDIR: -21,
     EEXIST: -17,
     ENOTEMPTY: -39,
+    EROFS: -30,
   };
 
   const messages: Record<string, string> = {
@@ -135,6 +153,7 @@ export function createNodeError(
     EISDIR: 'is a directory',
     EEXIST: 'file already exists',
     ENOTEMPTY: 'directory not empty',
+    EROFS: 'read-only file system',
   };
 
   const err = new Error(
@@ -216,6 +235,7 @@ export class VirtualFS {
   }
 
   private serializeNode(path: string, node: FSNode, files: VFSFileEntry[]): void {
+    if (node.mount) return; // a mounted tree is its answerer's, never the filesystem's contents
     if (node.type === 'file') {
       // Encode binary content as base64
       let content = '';
@@ -284,6 +304,7 @@ export class VirtualFS {
    */
   private writeFileSyncInternal(path: string, data: string | Uint8Array, emitEvent: boolean): void {
     const normalized = this.normalizePath(path);
+    this.assertWritable(normalized, 'open');
     const parentPath = this.getParentPath(normalized);
     const basename = this.getBasename(normalized);
 
@@ -377,11 +398,14 @@ export class VirtualFS {
     if (depth > 40) throw createNodeError('ELOOP', 'stat', path);
     const segments = this.getPathSegments(path);
     let current = this.root;
+    let mounted: { tree: MountedTree; at: number } | undefined;
     for (let index = 0; index < segments.length; index += 1) {
-      if (current.type !== 'directory' || !current.children) {
+      if (current.type !== 'directory' || (!mounted && !current.children)) {
         return undefined;
       }
-      const child = current.children.get(segments[index]);
+      const child = mounted
+        ? mounted.tree.node('/' + segments.slice(mounted.at + 1, index + 1).join('/'))
+        : current.children!.get(segments[index]);
       if (!child) {
         return undefined;
       }
@@ -391,16 +415,51 @@ export class VirtualFS {
         const target = this.__substrateLinkTarget(linkPath, child.target!);
         return this.__substrateNode(rest ? target + '/' + rest : target, follow, depth + 1);
       }
-      current = child;
+      if (!mounted && child.mount) {
+        mounted = { tree: child.mount, at: index };
+        current = child.mount.node('/') ?? child;
+      } else {
+        current = child;
+      }
     }
     return current;
   }
+
+  /**
+   * Mount a read-only tree at a directory, as Linux mounts `/proc`: reads
+   * below it are the tree's answers, writes fail with `EROFS`, and a snapshot
+   * leaves it out. Answers the unmount.
+   */
+  mount(path: string, tree: MountedTree): () => void {
+    const normalized = this.normalizePath(path);
+    const basename = this.getBasename(normalized);
+    if (!basename) throw createNodeError('EINVAL', 'mount', path);
+    const parent = this.ensureDirectory(this.getParentPath(normalized));
+    const existing = parent.children!.get(basename);
+    if (existing && (existing.type !== 'directory' || existing.mount || existing.children?.size)) {
+      throw createNodeError('EEXIST', 'mount', path);
+    }
+    const node: FSNode = { type: 'directory', children: new Map(), mtime: Date.now(), mode: 0o555, mount: tree };
+    parent.children!.set(basename, node);
+    return () => { if (parent.children!.get(basename) === node) parent.children!.delete(basename); };
+  }
+
+  /** A write at or below a mount point is refused, as a read-only filesystem refuses it. */
+  private assertWritable(path: string, syscall: string): void {
+    let current: FSNode | undefined = this.root;
+    for (const segment of this.getPathSegments(path)) {
+      current = current?.children?.get(segment);
+      if (!current) return;
+      if (current.mount) throw createNodeError('EROFS', syscall, path);
+    }
+  }
   /** A link's target as an absolute path: absolute as written, or relative to the link's directory. */
   __substrateLinkTarget(linkPath: string, target: string): string {
     return this.normalizePath(target.startsWith('/') ? target : this.getParentPath(linkPath) + '/' + target);
   }
   symlinkSync(target: string, path: string): void {
     const normalized = this.normalizePath(path);
+    this.assertWritable(normalized, 'symlink');
     const parentPath = this.getParentPath(normalized);
     const basename = this.getBasename(normalized);
     const parent = this.getNode(parentPath);
@@ -472,12 +531,14 @@ export class VirtualFS {
    * Get stats for path
    */
   chmodSync(path: string, mode: number): void {
+    this.assertWritable(path, 'chmod');
     const node = this.getNode(path);
     if (!node) throw createNodeError('ENOENT', 'chmod', path);
     node.mode = mode & 0o7777;
   }
 
   utimesSync(path: string, atime: number | Date, mtime: number | Date): void {
+    this.assertWritable(path, 'utime');
     const node = this.getNode(path);
     if (!node) throw createNodeError('ENOENT', 'utimes', path);
     node.atime = atime instanceof Date ? atime.getTime() : atime * 1000;
@@ -600,6 +661,9 @@ export class VirtualFS {
    */
   mkdirSync(path: string, options?: { recursive?: boolean }): void {
     const normalized = this.normalizePath(path);
+    // `mkdir -p` of a directory that is there, a mount point among them, is done
+    if (options?.recursive && this.getNode(normalized)?.type === 'directory') return;
+    this.assertWritable(normalized, 'mkdir');
 
     if (options?.recursive) {
       this.ensureDirectory(normalized);
@@ -657,6 +721,7 @@ export class VirtualFS {
    */
   unlinkSync(path: string): void {
     const normalized = this.normalizePath(path);
+    this.assertWritable(normalized, 'unlink');
     const parentPath = this.getParentPath(normalized);
     const basename = this.getBasename(normalized);
 
@@ -689,6 +754,7 @@ export class VirtualFS {
    */
   rmdirSync(path: string): void {
     const normalized = this.normalizePath(path);
+    this.assertWritable(normalized, 'rmdir');
     const parentPath = this.getParentPath(normalized);
     const basename = this.getBasename(normalized);
 
@@ -727,6 +793,8 @@ export class VirtualFS {
   renameSync(oldPath: string, newPath: string): void {
     const normalizedOld = this.normalizePath(oldPath);
     const normalizedNew = this.normalizePath(newPath);
+    this.assertWritable(normalizedOld, 'rename');
+    this.assertWritable(normalizedNew, 'rename');
 
     const oldParentPath = this.getParentPath(normalizedOld);
     const oldBasename = this.getBasename(normalizedOld);
@@ -846,10 +914,14 @@ export class VirtualFS {
     for (let hops = 0; hops <= 40; hops += 1) {
       const segments = resolved.split('/').filter(Boolean);
       let current: FSNode | undefined = this.root;
+      let mounted: { tree: MountedTree; at: number } | undefined;
       let linked = false;
       for (let index = 0; index < segments.length; index += 1) {
-        const child: FSNode | undefined = current && current.children ? current.children.get(segments[index]) : void 0;
+        const child: FSNode | undefined = mounted
+          ? mounted.tree.node('/' + segments.slice(mounted.at + 1, index + 1).join('/'))
+          : current && current.children ? current.children.get(segments[index]) : void 0;
         if (!child) throw createNodeError('ENOENT', 'realpath', path);
+        if (!mounted && child.mount) mounted = { tree: child.mount, at: index };
         if (child.type === 'symlink') {
           const linkPath = '/' + segments.slice(0, index + 1).join('/');
           const rest = segments.slice(index + 1).join('/');