@volter/tabnode 0.5.15 → 0.5.17

package/src/shims/child_process.ts

@@ -936,8 +936,10 @@ export function initChildProcess(vfs: VirtualFS): void {
         // engine's own registries. A run that still holds a handle or a timer
         // is not that -- Node's loop runs while one is open, for as long as it
         // is open -- and cutting it at a minute ended a forked child that was
-        // a server, which is every extension host and every pty host.
-        if (!isLongRunning && !stillWorking() && Date.now() - startTime >= MAX_TOTAL_MS) break;
+        // a server, which is every extension host and every pty host. Work the
+        // host holds for it (a build, a pre-bundle) is seen work too: a dev
+        // server whose start passed a minute mid pre-bundle was cut with exit 0.
+        if (!isLongRunning && !stillWorking() && heldWork().count === 0 && Date.now() - startTime >= MAX_TOTAL_MS) break;
       }
 
       return { stdout, stderr, exitCode: exitCalled ? exitCode : (typeof proc !== 'undefined' && typeof proc.exitCode === 'number' ? proc.exitCode : 0) };
@@ -1011,6 +1013,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 +1295,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
  */
@@ -1711,6 +1757,15 @@ function startChildRun(request: RunRequest): StartedRun {
   const admittedNode = nodeProcessHostInstalled() && engineProgramFor(request.file, request.cwd) === 'node';
   const hostTerminal = request.terminal !== undefined && hostExecutor() !== null && !admittedNode;
   let wakeInput: (() => void) | undefined;
+  /**
+   * A piped fd 0 that stays open for a program the host runs (a program pack,
+   * not a builtin of the engine's shell): what the parent writes reaches it
+   * as it is written, through the same live stream a terminal gets. A
+   * builtin reads its input once, before it runs; a server that speaks
+   * JSON-RPC over stdio (`supercode harness serve`) read that one string,
+   * saw EOF and exited before its client's first request.
+   */
+  let liveInput = false;
   const hostInput: AsyncIterable<Uint8Array> = {
     async *[Symbol.asyncIterator]() {
       while (!finished && !controller.signal.aborted) {
@@ -1810,6 +1865,12 @@ function startChildRun(request: RunRequest): StartedRun {
   const begin = (): void => {
     if (started || finished) return;
     started = true;
+    const engineFirst = !hostTerminal && programExists(request.file, request.cwd, request.env);
+    liveInput = !hostTerminal && !admittedNode && request.stdinIsPipe && !engineFirst;
+    if (liveInput) {
+      pendingStdin.unshift(...initialStdin);
+      initialStdin.length = 0;
+    }
     const stdin = initialStdin.length > 0 ? Buffer.concat(initialStdin).toString('utf8') : undefined;
     void (async () => {
       let outcome: CommandOutcome;
@@ -1823,11 +1884,11 @@ function startChildRun(request: RunRequest): StartedRun {
           filesystem: currentVfs!, env, streams, ...(stdin !== undefined ? { stdin } : {}),
         }) : await enterRun(token, () => routeCommand({
           command: __substrateLineFor(request.file, request.args, request.cwd),
-          engineFirst: !hostTerminal && programExists(request.file, request.cwd, request.env),
+          engineFirst,
           cwd: request.cwd,
           env: { ...request.env, [PROCESS_TOKEN_ENV]: token },
           stdin,
-          ...(hostTerminal ? { stdinStream: hostInput, terminal: request.terminal } : {}),
+          ...(hostTerminal ? { stdinStream: hostInput, terminal: request.terminal } : liveInput ? { stdinStream: hostInput } : {}),
           signal: controller.signal,
           onStdout: streams.onStdout,
           onStderr: streams.onStderr,
@@ -1868,18 +1929,20 @@ function startChildRun(request: RunRequest): StartedRun {
       return 0;
     },
     writeStdin(bytes: Uint8Array): void | Promise<void> {
-      if (hostTerminal) { pendingStdin.push(bytes); wakeInput?.(); wakeInput = undefined; return; }
+      if (hostTerminal || liveInput) { pendingStdin.push(bytes); wakeInput?.(); wakeInput = undefined; return; }
       if (!started) { initialStdin.push(bytes); return; }
       pendingStdin.push(bytes);
       return flushStdin();
     },
     endStdin(): void {
-      if (hostTerminal) { pendingStdin.push(null); wakeInput?.(); wakeInput = undefined; return; }
+      if (hostTerminal || liveInput) { pendingStdin.push(null); wakeInput?.(); wakeInput = undefined; return; }
       if (!started) {
         // The writer closed before the command began: the run's fd 0 is the
         // string already collected and nothing more, so it is not held open.
         streams.stdinOpen = false;
         begin();
+        // A live pipe closed before it began still ends where it was closed.
+        if (liveInput) { pendingStdin.push(null); wakeInput?.(); wakeInput = undefined; }
         return;
       }
       pendingStdin.push(null);
@@ -1907,3 +1970,4 @@ export default {
   runCommand,
   sendStdin,
 };
+

package/src/shims/esbuild.ts

@@ -398,6 +398,16 @@ export interface EsbuildHost {
 }
 let currentHost: EsbuildHost | null = null;
 
+/**
+ * esbuild-wasm starts its compiler on a Worker unless told not to. A realm
+ * that runs guests may withhold `Worker` (the execution worker confines its
+ * guests that way), and there the compiler runs on the calling thread, which
+ * is esbuild's own `worker: false`.
+ */
+function realmCanStartWorker(): boolean {
+  return typeof (globalThis as { Worker?: unknown }).Worker === 'function';
+}
+
 let inlineEsbuild: Promise<typeof import('esbuild-wasm')> | null = null;
 function ownEsbuild(): Promise<typeof import('esbuild-wasm')> {
   // A build that brings plugins of its own, a bundler such as tsup does,
@@ -408,7 +418,7 @@ function ownEsbuild(): Promise<typeof import('esbuild-wasm')> {
     /* @vite-ignore */
     esbuildModuleURL
   ).then(async (esbuild) => {
-    await esbuild.initialize({ wasmURL });
+    await esbuild.initialize({ wasmURL, worker: realmCanStartWorker() });
     return esbuild;
   }).catch((cause) => {
     // A load that failed, a page whose server was away for a moment, is not kept: the next build tries again.
@@ -527,6 +537,7 @@ export async function initialize(options?: { wasmURL?: string }): Promise<void>
 
       await esbuild.initialize({
         wasmURL: options?.wasmURL || wasmURL,
+        worker: realmCanStartWorker(),
       });
 
       esbuildInstance = esbuild;

package/src/shims/perf_hooks.ts

@@ -2,6 +2,7 @@
  * perf_hooks shim - Performance measurement APIs
  * Wraps browser Performance API
  */
+import { forGuestRealm } from '../host-globals';
 
 export const performance = globalThis.performance || {
   now: () => Date.now(),
@@ -16,6 +17,23 @@ export const performance = globalThis.performance || {
   clearResourceTimings: () => {},
 };
 
+/**
+ * Node's `performance.markResourceTiming`, which a browser's `performance`
+ * does not have. undici's fetch reads it off the global `performance` at load
+ * and calls it after every response, so each fetch through an undici a
+ * program installed (Pi's does) threw once the body was read. Node records a
+ * PerformanceResourceTiming entry there; this engine keeps no resource
+ * timeline for a guest's own HTTP, so the call records nothing.
+ */
+forGuestRealm(() => {
+  const own = globalThis.performance as (Performance & { markResourceTiming?: unknown }) | undefined;
+  if (own && typeof own.markResourceTiming !== 'function') {
+    try {
+      Object.defineProperty(own, 'markResourceTiming', { value: () => undefined, writable: true, configurable: true, enumerable: false });
+    } catch { /* a performance object that refuses the name keeps its own shape */ }
+  }
+});
+
 export class PerformanceObserver {
   private callback: (list: PerformanceObserverEntryList) => void;
   private entryTypes: string[] = [];

package/src/shims/string_decoder.ts

@@ -308,6 +308,7 @@ function base64End(this: StringDecoder, buf?: unknown): string {
 // ---------------------------------------------------------------------------
 
 function simpleWrite(this: StringDecoder, buf: unknown): string {
+  if (typeof buf === 'string') return buf;
   return decoderInput(this, buf).toString(this.encoding as BufferEncoding);
 }
 
@@ -353,6 +354,10 @@ const decoderPrototype = StringDecoderImpl.prototype as unknown as StringDecoder
 
 decoderPrototype.write = function write(this: unknown, buffer: unknown): string {
   const self = assertDecoder(this);
+  // Node returns a string as it is given: readline decodes every chunk of its
+  // input, and an input stream with an encoding (`createReadStream(path,
+  // 'utf8')`) hands it strings.
+  if (typeof buffer === 'string') return buffer;
   const buf = decoderInput(self, buffer);
   if (buf.length === 0) return '';
   let r: string | undefined;

package/src/shims/tls.ts

@@ -102,6 +102,17 @@ const DEFAULT_MIN_VERSION = 'TLSv1.2';
 
 const rootCertificates: string[] = [];
 
+// Node's certificate-store door, read by callers that build their own agents
+// (VS Code's proxy agent, on every fetch it patches). The engine holds no
+// store: certificates are the browser's, so every kind answers the same empty
+// set `rootCertificates` does.
+const getCACertificates = (type: string = 'default'): string[] => {
+  if (!['default', 'system', 'bundled', 'extra'].includes(type)) {
+    throw Object.assign(new TypeError(`The argument 'type' must be one of: 'default', 'system', 'bundled', 'extra'. Received '${String(type)}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+  }
+  return [];
+};
+
 return {
   TLSSocket,
   Server,
@@ -109,6 +120,7 @@ return {
   connect,
   createSecureContext,
   getCiphers,
+  getCACertificates,
   DEFAULT_ECDH_CURVE,
   DEFAULT_MAX_VERSION,
   DEFAULT_MIN_VERSION,
@@ -117,7 +129,7 @@ return {
 
 }
 const tls = createTlsModule();
-export const { TLSSocket, Server, createServer, connect, createSecureContext, getCiphers,
+export const { TLSSocket, Server, createServer, connect, createSecureContext, getCiphers, getCACertificates,
   DEFAULT_ECDH_CURVE, DEFAULT_MAX_VERSION, DEFAULT_MIN_VERSION, rootCertificates } = tls;
 export type TLSSocket = InstanceType<typeof TLSSocket>;
 export type Server = InstanceType<typeof Server>;

package/src/shims/worker_threads.ts

@@ -88,6 +88,23 @@ export function markAsUntransferable(object: unknown): void {
   // No-op
 }
 
+/**
+ * Node 22's `markAsUncloneable` and its query: an object so marked is refused
+ * by `structuredClone` and `postMessage`. undici's WebIDL layer marks every
+ * `CacheStorage`, `Request` and `Response` it makes, at construction, so a
+ * program that loads undici 7.x+ or 8.x died on `markAsUncloneable is not a
+ * function` before its first line. The mark is kept; this engine's message
+ * channels do not yet read it, so a marked object that is posted is copied
+ * rather than refused.
+ */
+const uncloneable = new WeakSet<object>();
+export function markAsUncloneable(object: unknown): void {
+  if (object !== null && (typeof object === 'object' || typeof object === 'function')) uncloneable.add(object as object);
+}
+export function isMarkedAsUncloneable(object: unknown): boolean {
+  return object !== null && (typeof object === 'object' || typeof object === 'function') && uncloneable.has(object as object);
+}
+
 export function getEnvironmentData(key: unknown): unknown {
   return undefined;
 }
@@ -109,6 +126,8 @@ export default {
   receiveMessageOnPort,
   SHARE_ENV,
   markAsUntransferable,
+  markAsUncloneable,
+  isMarkedAsUncloneable,
   getEnvironmentData,
   setEnvironmentData,
 };