@volter/tabnode 0.5.14 → 0.5.16

package/dist/node-lib/binding/fs.d.ts

@@ -3,6 +3,16 @@ import { Buffer as NodeBuffer } from '../buffer-module';
 /** The key the engine hangs a run's filesystem off its guest process. */
 export declare const kRunFilesystem: unique symbol;
 export declare function withFilesystem<T>(tree: VirtualFS, work: () => T): T;
+/**
+ * Where a child's output goes when its stdio names a descriptor of the
+ * parent's (`stdio: ['ignore', fd, fd]` with `fd` from `openSync`): the file
+ * that descriptor has open, as the child's own duplicate of it, so it keeps
+ * writing after the parent closes its copy. Appending descriptors append;
+ * others write on from the position the parent's copy had. A descriptor that
+ * is a stream (a socket, a pipe) is written as a stream. Anything else is
+ * not a sink, and the child's output there goes nowhere, as `ignore` does.
+ */
+export declare function descriptorWriter(fd: number): ((text: string) => void) | null;
 /** A request object `fs.js` hands an asynchronous call, answered on a tick. */
 interface FSReq {
     oncomplete?: (error: Error | null, ...rest: unknown[]) => void;

package/package.json

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

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

@@ -168,6 +168,40 @@ function fileFor(fd: number): OpenFile {
   return file;
 }
 
+/**
+ * Where a child's output goes when its stdio names a descriptor of the
+ * parent's (`stdio: ['ignore', fd, fd]` with `fd` from `openSync`): the file
+ * that descriptor has open, as the child's own duplicate of it, so it keeps
+ * writing after the parent closes its copy. Appending descriptors append;
+ * others write on from the position the parent's copy had. A descriptor that
+ * is a stream (a socket, a pipe) is written as a stream. Anything else is
+ * not a sink, and the child's output there goes nowhere, as `ignore` does.
+ */
+export function descriptorWriter(fd: number): ((text: string) => void) | null {
+  const stream = handleForFd(fd);
+  if (stream instanceof LibuvStreamWrap) {
+    return (text) => { try { stream.writeBuffer(new WriteWrap(), new TextEncoder().encode(text)); } catch { /* a closed stream drops the child's output, as a closed pipe does */ } };
+  }
+  const file = openFiles.get(fd);
+  if (!file || file.directory || (file.flags & 3) === 0) return null;
+  const { tree, path } = file;
+  const append = (file.flags & flagBits().append) !== 0;
+  let position = file.position;
+  return (text) => {
+    const bytes = new TextEncoder().encode(text);
+    // the parent's copy, while it is open, holds the file's bytes as it last wrote them
+    const shared = openFiles.get(fd) === file ? file : null;
+    const existing = shared?.cached ?? (tree.existsSync(path) ? tree.readFileSync(path) as Uint8Array : new Uint8Array(0));
+    const at = append ? existing.length : position;
+    const next = new Uint8Array(Math.max(existing.length, at + bytes.length));
+    next.set(existing, 0);
+    next.set(bytes, at);
+    tree.writeFileSync(path, next);
+    position = at + bytes.length;
+    if (shared) shared.cached = next;
+  };
+}
+
 /** Node's stat array: eighteen numbers, with each time a second and a nanosecond. */
 function statArray(stats: VfsStats, bigint: boolean, path?: string): Float64Array | BigInt64Array {
   const mtime = stats.mtime instanceof Date ? stats.mtime.getTime() : Number(stats.mtimeMs ?? 0);

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

@@ -29,6 +29,7 @@ import {
 } from './handles';
 import { __runFor, mintPid, type ProcessToken } from '../../process-tokens';
 import { handleForFd } from './fds';
+import { descriptorWriter } from './fs';
 import { TTY, type TerminalState } from './tty_wrap';
 
 /** One entry of Node's `options.stdio`, as `getValidStdio` builds it. */
@@ -178,7 +179,8 @@ function spawningDirectory(token: ProcessToken | null): string | undefined {
 
 /** Where an `inherit` entry's bytes go: the spawning program's own stream. */
 function inheritedWriter(fd: number, token: ProcessToken | null): ((text: string) => void) | null {
-  if (fd !== 1 && fd !== 2) return null;
+  // a descriptor of the parent's own (a log file it opened) is written as the file
+  if (fd !== 1 && fd !== 2) return descriptorWriter(fd);
   // 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) {

package/src/server-bridge.ts

@@ -774,7 +774,9 @@ export class ServerBridge extends EventEmitter {
     const virtualServer = this.servers.get(port);
     if (!virtualServer) return false;
     const bodyBuffer = body ? Buffer.from(new Uint8Array(body)) : undefined;
-    if (virtualServer.server === null) {
+    // A guest's listener (the old null sentinel, now a request adapter) is
+    // streamed off its connection; its adapter would answer whole.
+    if (virtualServer.server === null || this.guestServers.has(virtualServer.server)) {
       const named = Object.keys(headers).some((name) => name.toLowerCase() === 'host');
       const authority = `${virtualServer.hostname && virtualServer.hostname !== '0.0.0.0' && virtualServer.hostname !== '::' ? virtualServer.hostname : '127.0.0.1'}:${port}`;
       await __streamOverLoopback(
@@ -839,7 +841,7 @@ export class ServerBridge extends EventEmitter {
 
     // A guest's server is a port: its answer is streamed off the connection
     // as it arrives, which is what the page reads chunk by chunk.
-    if (virtualServer.server === null) {
+    if (virtualServer.server === null || this.guestServers.has(virtualServer.server)) {
       const bodyBuffer = body ? Buffer.from(new Uint8Array(body)) : undefined;
       const named = Object.keys(headers).some((name) => name.toLowerCase() === 'host');
       const authority = `${virtualServer.hostname && virtualServer.hostname !== '0.0.0.0' && virtualServer.hostname !== '::' ? virtualServer.hostname : '127.0.0.1'}:${port}`;

package/src/shims/child_process.ts

@@ -1011,6 +1011,10 @@ export function initChildProcess(vfs: VirtualFS): void {
       case 'ls':
       case 'list':
         return handleNpmList(ctx);
+      case 'init':
+      case 'create':
+      case 'innit':
+        return handleNpmInit(args.slice(1), ctx);
       default:
         return {
           stdout: '',
@@ -1289,6 +1293,46 @@ async function handleNpmInstall(args: string[], ctx: CommandContext): Promise<Ju
   }
 }
 
+/**
+ * `npm init -y`: npm's defaults written to package.json, the fields a
+ * package.json already has kept, and the file printed as npm prints it. The
+ * questionnaire without `-y` needs a person at npm's prompts; it is refused by
+ * name, as is an initializer (`npm init <pkg>`), which runs another package.
+ */
+async function handleNpmInit(args: string[], ctx: CommandContext): Promise<JustBashExecResult> {
+  const yes = args.includes('-y') || args.includes('--yes');
+  const initializer = args.find((a) => !a.startsWith('-'));
+  if (initializer) {
+    return { stdout: '', stderr: `npm ERR! npm init ${initializer} runs an initializer package, which this engine's npm does not; write package.json, or run \`npm init -y\`.\n`, exitCode: 1 };
+  }
+  if (!yes) {
+    return { stdout: '', stderr: 'npm ERR! npm init asks its questions at a prompt, which this engine\'s npm does not; `npm init -y` writes the defaults.\n', exitCode: 1 };
+  }
+  const vfs = currentVfs!;
+  const file = __resolvePath(ctx.cwd, 'package.json');
+  let existing: Record<string, unknown> = {};
+  if (vfs.existsSync(file)) {
+    try { existing = JSON.parse(String(vfs.readFileSync(file, 'utf8'))) as Record<string, unknown>; }
+    catch { return { stdout: '', stderr: `npm ERR! ${file} is not valid JSON\n`, exitCode: 1 }; }
+  }
+  const base = ctx.cwd.split('/').filter(Boolean).pop() ?? 'package';
+  const name = base.toLowerCase().replace(/^[._]+/, '').replace(/[^a-z0-9._~-]+/g, '-') || 'package';
+  const manifest = {
+    name,
+    version: '1.0.0',
+    description: '',
+    main: 'index.js',
+    scripts: { test: 'echo "Error: no test specified" && exit 1' },
+    keywords: [],
+    author: '',
+    license: 'ISC',
+    ...existing,
+  };
+  const text = `${JSON.stringify(manifest, null, 2)}\n`;
+  vfs.writeFileSync(file, text);
+  return { stdout: `Wrote to ${file}:\n\n${text}\n\n`, stderr: '', exitCode: 0 };
+}
+
 /**
  * Handle `npm ls` — list installed packages
  */