thebird 1.2.78 → 1.2.80

package/docs/shell-node.js

@@ -1,108 +1,199 @@
-function serializeRoutes(routes) {
-  const out = {};
-  for (const [method, arr] of Object.entries(routes)) {
-    out[method] = arr.map(r => ({ path: r.path }));
-  }
-  return out;
-}
-
-const makeBuiltinModules = term => ({
-  express: () => () => {
-    const routes = { GET: [], POST: [], USE: [] };
-    const app = {
-      get: (path, fn) => routes.GET.push({ path, fn }),
-      post: (path, fn) => routes.POST.push({ path, fn }),
-      use: (fn) => routes.USE.push({ path: '*', fn }),
-      listen: (port, cb) => {
-        window.__debug.shell.httpHandlers[port] = { routes };
-        navigator.serviceWorker?.controller?.postMessage({ type: 'REGISTER_ROUTES', port, routes: serializeRoutes(routes) });
-        term.write('Express listening on :' + port + '\r\n');
-        cb?.();
-      },
-    };
-    return app;
-  },
-  'better-sqlite3': () => class Database {
-    constructor(name) {
-      this._name = name;
-      if (!window.__sqlJs) throw new Error('sql.js not loaded — call await loadSql() first');
-      this._db = new window.__sqlJs.Database();
-    }
-    prepare(sql) {
-      const db = this._db;
-      return {
-        run: (...params) => { db.run(sql, params); return { changes: 1 }; },
-        get: (...params) => { const r = db.exec(sql, params); return r[0]?.values[0] ? Object.fromEntries(r[0].columns.map((c, i) => [c, r[0].values[0][i]])) : undefined; },
-        all: (...params) => { const r = db.exec(sql, params); if (!r[0]) return []; return r[0].values.map(row => Object.fromEntries(r[0].columns.map((c, i) => [c, row[i]]))); },
-      };
-    }
-  },
-});
+import { createPath, createFs, createEvents, createUrl, createQuerystring, createBuffer } from './node-builtins.js';
+import { createExpress, createHttp, createSqlite, createConsole, createProcess, NODE_VERSION, NODE_VERSIONS, NodeExit } from './shell-node-modules.js';
+import { inspect, format, createZlib, preloadFflate } from './shell-node-stdlib.js';
+import { createHash, createHmac, pbkdf2Sync, randomBytes } from './shell-node-crypto.js';
+import { createChildProcess, createHttpClient, extendProcess, rewriteStack, isEsmCode, runEsm, parseDotEnv } from './shell-node-io.js';
+import { resolveExports, resolveImports, walkUpNodeModules, resolvePackageEntry, makeModuleModule, makeModuleNotFoundError, makeFsPromises, makeFsWatch, makeNetStub, makeDgramStub, makeWorkerThreadsStub } from './shell-node-resolve.js';
+import { extendBuffer, extendPath, createUrlExt, makeStringDecoder, makeReadline, makeTimersMod, makePerfHooks, makeV8Mod, makeAsyncHooks, makeStubs, makeErrorCodes, extendProcessExtras, makeStreamConsumers } from './shell-node-extras.js';
+import { makeStream, extendFsStreams } from './shell-node-streams.js';
+import { extendCrypto } from './shell-node-cipher.js';
+import { extendKeys } from './shell-node-keyobject.js';
+import { makeStreamingZlib, makeVmModule, makeModuleRegister, makeHttp2, makeWasi } from './shell-node-advanced.js';
+import { makeDebugRegistry, makeDiagnosticsChannel, makeTraceEvents, makeBufferPool, makeProcessBindings, makePerfMemory, makeFetchPool, makeFsWatchReal, installPrepareStackTraceHook, installCaptureStackTrace } from './shell-node-observe.js';
+import { makeWorkerThreads, makeChildProcessReal, makeRepl } from './shell-node-runtime.js';
+import { detectBrowser, registerPolyfill, makeCompressionStreamZlib, makeWebCodecs, makeWebPush, makeStorageHelpers } from './shell-node-firefox.js';
+import { makeOpfsBackend, wireOpfsIntoFs } from './shell-node-opfs.js';
+import { preloadBrotli, makeBrotli } from './shell-node-brotli.js';
+import { preloadSourceMap, installSourceMapStacks } from './shell-node-srcmap.js';
+import { makeNet, makeTls, makeDgram } from './shell-node-net.js';
+import { makeInspector } from './shell-node-inspector.js';
+import { makeV8Profiler, makeHeapSnapshot } from './shell-node-profiler.js';
+import { makeCluster } from './shell-node-cluster.js';
+import { preloadX509 } from './shell-node-keyobject.js';
+import { detectRuntime, registerRuntime, switchRuntime, logRuntimeSwitch } from './shell-runtime.js';
+import { makeDenoGlobal } from './shell-deno.js'; import { makeBunGlobal } from './shell-bun.js';
+import { makePmDispatcher, detectPm, makeCorepackStub } from './shell-pm.js';
+import { isTsFile, preprocessSource } from './shell-ts.js'; import { installPosixFs, installFds, installTmpAndMisc } from './shell-posix.js';
+import { makeTestRunner, makeTapReporter } from './shell-node-testrunner.js'; import { makeForkIpc } from './shell-node-ipc.js';
+import { styleText, stripVTControlCharacters, getCallSites, MIMEType, MIMEParams, makeConsoleExtras } from './shell-node-util-extras.js';
+import { makeProcFs, wireProcFs } from './shell-node-procfs.js'; import { makeGit } from './shell-node-git.js'; import { makeTar } from './shell-node-tar.js'; import { makeDns } from './shell-node-dns.js'; import { makeNativeLoader } from './shell-node-native.js'; import { makeRegistry } from './shell-node-registry.js';
+import { makeBusnet, makeBusHttp } from './shell-node-busnet.js';
 
 export function createNodeEnv({ ctx, term }) {
-  const BUILTIN_MODULES = makeBuiltinModules(term);
-  const scope = {
-    process: {
-      argv: [],
-      env: ctx.env,
-      cwd: () => ctx.cwd,
-      exit: code => term.write('[exit ' + code + ']\r\n'),
-    },
-    console: {
-      log: (...a) => term.write(a.map(String).join(' ') + '\r\n'),
-      error: (...a) => term.write('\x1b[31m' + a.map(String).join(' ') + '\x1b[0m\r\n'),
-      warn: (...a) => term.write('\x1b[33m' + a.map(String).join(' ') + '\x1b[0m\r\n'),
-    },
-    require: id => {
-      if (BUILTIN_MODULES[id]) return BUILTIN_MODULES[id]();
-      const key = 'node_modules/' + id + '/index.js';
-      const src = (window.__debug.idbSnapshot || {})[key];
-      if (src == null) throw new Error('module not found: ' + id);
+  const pathmod = extendPath(createPath()); const Buf = makeBufferPool(extendBuffer(createBuffer())); const debugReg = makeDebugRegistry();
+  const browserInfo = detectBrowser(); debugReg.browser = browserInfo; const snapFn = () => window.__debug?.idbSnapshot || {};
+  const fsmod = installTmpAndMisc(installFds(installPosixFs(extendFsStreams(createFs(), Buf), Buf, ctx), Buf), Buf, ctx);
+  const opfs = makeOpfsBackend(Buf); if (opfs) wireOpfsIntoFs(fsmod, opfs, debugReg);
+  const runtime = detectRuntime(); registerRuntime(debugReg, runtime); fsmod.promises = makeFsPromises(fsmod); fsmod.watch = makeFsWatchReal(snapFn);
+  fsmod.glob = (pat, opts, cb) => { if (typeof opts === 'function') { cb = opts; opts = {}; } const matches = Object.keys(window.__debug?.idbSnapshot || {}).filter(k => new RegExp('^' + pat.replace(/\*\*/g, '.+').replace(/\*/g, '[^/]*') + '$').test(k)); queueMicrotask(() => cb?.(null, matches)); };
+  fsmod.globSync = pat => Object.keys(window.__debug?.idbSnapshot || {}).filter(k => new RegExp('^' + pat.replace(/\*\*/g, '.+').replace(/\*/g, '[^/]*') + '$').test(k));
+  const zlibMod = createZlib(Buf); const httpClient = createHttpClient(Buf); const cpMod = createChildProcess(ctx); const streamMod = makeStream();
+  const cpReal = makeChildProcessReal(Buf, streamMod); Object.assign(cpMod, { exec: cpReal.exec.bind(cpReal), spawn: cpReal.spawn.bind(cpReal), execFile: cpReal.execFile.bind(cpReal), execSync: cpReal.execSync, spawnSync: cpReal.spawnSync, fork: cpReal.fork });
+  let cryptoMod = { createHash, createHmac, pbkdf2Sync, pbkdf2: (pw, salt, iter, len, dig, cb) => queueMicrotask(() => { try { cb(null, Buf.from(pbkdf2Sync(pw, salt, iter, len, dig))); } catch (e) { cb(e); } }), randomBytes: n => Buf.from(randomBytes(n)), randomUUID: () => crypto.randomUUID(), randomInt: (a, b) => Math.floor(Math.random() * (b - a) + a), webcrypto: globalThis.crypto, constants: {} };
+  cryptoMod = extendKeys(extendCrypto(cryptoMod, Buf)); cryptoMod._ops = () => ++debugReg.cryptoOps; cryptoMod.secureHeapUsed = () => ({ total: 0, min: 0, used: 0, utilization: 0 });
+  const errorCodes = makeErrorCodes(); const stubs = makeStubs(ctx); const diagCh = makeDiagnosticsChannel(); const traceEv = makeTraceEvents(debugReg);
+  const vmMod = makeVmModule(); const http2Mod = makeHttp2(); const wasiMod = makeWasi(); const moduleRegister = makeModuleRegister(); const workerThreads = makeWorkerThreads(snapFn, Buf);
+  const getMem = makePerfMemory(performance); const FetchAgent = makeFetchPool(); const netMod = makeNet(Buf); const tlsMod = makeTls(netMod, Buf); const dgramMod = makeDgram(Buf);
+  const v8Real = makeV8Profiler(debugReg); const heapSnap = makeHeapSnapshot(); const clusterReal = makeCluster(); const inspector = makeInspector(debugReg);
+  const nativeCS = makeCompressionStreamZlib(streamMod, Buf); const webCodecs = makeWebCodecs(); const webPush = makeWebPush(); const storage = makeStorageHelpers();
+  const gitMod = makeGit(fsmod); const tarMod = makeTar(fsmod, null, Buf); const dnsMod = makeDns(); const nativeLoader = makeNativeLoader(); const registryMod = makeRegistry(); const busnet = makeBusnet(); globalThis.__busnet = busnet; const busHttp = makeBusHttp(busnet); debugReg.busnet = busnet;
+  if (nativeCS) registerPolyfill(debugReg, 'compressionStream', 'native', 'CompressionStream available'); if (browserInfo.capabilities.webCodecs) registerPolyfill(debugReg, 'webCodecs', 'native', 'WebCodecs available');
+  const proc = extendProcessExtras(extendProcess(createProcess(term, ctx), ctx), ctx);
+  proc.stdin.setRawMode = () => proc.stdin; proc.stdin.isRaw = false; proc.binding = makeProcessBindings(); proc.memoryUsage = getMem; proc.storage = storage; proc.storageBuckets = storage.buckets; proc.cwd = () => ctx.cwd; proc.chdir = p => { ctx.cwd = p.startsWith('/') ? p : pathmod.resolve(ctx.cwd, p); }; proc.umask = m => { const prev = ctx.umask || 0o022; if (m != null) ctx.umask = m; return prev; }; makeForkIpc(proc); proc.dlopen = (t, p) => nativeLoader.dlopen(t, p); proc.resourceUsage = () => { const m = performance.memory || {}; return { userCPUTime: performance.now() * 1000 | 0, systemCPUTime: 0, maxRSS: (m.totalJSHeapSize || 0) / 1024 | 0, sharedMemorySize: 0, unsharedDataSize: 0, unsharedStackSize: 0, minorPageFault: 0, majorPageFault: 0, swappedOut: 0, fsRead: 0, fsWrite: 0, ipcSent: 0, ipcReceived: 0, signalsCount: 0, voluntaryContextSwitches: 0, involuntaryContextSwitches: 0 }; };
+  wireProcFs(fsmod, makeProcFs(proc)); const denoGlobal = makeDenoGlobal(fsmod, proc, cpMod, ctx.httpHandlers || {}, Buf); const bunGlobal = makeBunGlobal(fsmod, proc, cpMod, ctx.httpHandlers || {}, Buf, streamMod, cryptoMod);
+  const MODULES = {
+    path: () => pathmod, fs: () => fsmod, events: () => createEvents(), url: () => createUrlExt(), querystring: () => createQuerystring(),
+    os: () => { const n=navigator?.hardwareConcurrency||1; const mem=performance.memory||{}; return { platform: () => 'linux', arch: () => 'x64', homedir: () => ctx.env.HOME || '/root', tmpdir: () => '/tmp', cpus: () => Array.from({length:n},(_,i)=>({model:'Browser CPU',speed:3000,times:{user:0,nice:0,sys:0,idle:0,irq:0}})), totalmem: () => mem.jsHeapSizeLimit || 1073741824, freemem: () => (mem.jsHeapSizeLimit || 1073741824) - (mem.usedJSHeapSize || 0), hostname: () => ctx.env.HOSTNAME || 'thebird', EOL: '\n', release: () => '6.0.0-browser', type: () => 'Linux', uptime: () => performance.now() / 1000, networkInterfaces: () => ({ lo: [{ address: '127.0.0.1', netmask: '255.0.0.0', family: 'IPv4', mac: '00:00:00:00:00:00', internal: true, cidr: '127.0.0.1/8' }] }), loadavg: () => [0, 0, 0], userInfo: () => ({ username: ctx.env.USER || 'root', uid: 0, gid: 0, shell: ctx.env.SHELL || '/bin/sh', homedir: ctx.env.HOME || '/root' }), endianness: () => 'LE', version: () => '#1 SMP', machine: () => 'x86_64', devNull: '/dev/null', availableParallelism: () => n, constants: { signals: { SIGINT: 2, SIGTERM: 15, SIGKILL: 9, SIGHUP: 1 }, errno: { EACCES: 13, EEXIST: 17, ENOENT: 2, EISDIR: 21, ENOTDIR: 20 } } }; },
+    util: () => ({ inspect, format, promisify: fn => (...a) => new Promise((r, j) => fn(...a, (e, v) => e ? j(e) : r(v))), callbackify: fn => (...a) => { const cb = a.pop(); fn(...a).then(v => cb(null, v), e => cb(e)); }, types: { isPromise: p => p instanceof Promise, isDate: v => v instanceof Date, isRegExp: v => v instanceof RegExp, isBuffer: v => v instanceof Uint8Array, isTypedArray: v => ArrayBuffer.isView(v) && !(v instanceof DataView), isAsyncFunction: f => f?.constructor?.name === 'AsyncFunction', isNativeError: e => e instanceof Error }, deprecate: fn => fn, inherits: (a, b) => { Object.setPrototypeOf(a.prototype, b.prototype); }, debuglog: () => () => {}, isDeepStrictEqual: (a, b) => JSON.stringify(a) === JSON.stringify(b), styleText, stripVTControlCharacters, getCallSites, MIMEType, MIMEParams, parseArgs: ({ args = [], options = {} }) => { const values = {}, positionals = []; for (let i = 0; i < args.length; i++) { const a = args[i]; if (a.startsWith('--')) { const [k, v] = a.slice(2).split('='); if (v !== undefined) values[k] = v; else if (options[k]?.type === 'string') values[k] = args[++i]; else values[k] = true; } else positionals.push(a); } return { values, positionals }; } }),
+    crypto: () => cryptoMod,
+    stream: () => streamMod, 'stream/promises': () => streamMod.promises, 'stream/consumers': () => makeStreamConsumers(), 'stream/web': () => ({ ReadableStream, WritableStream, TransformStream }),
+    http: () => ({ ...httpClient, Agent: FetchAgent, globalAgent: new FetchAgent() }), https: () => ({ ...httpClient, Agent: FetchAgent, globalAgent: new FetchAgent() }),
+    http2: () => http2Mod, 'node:http2': () => http2Mod,
+    vm: () => vmMod, 'node:vm': () => vmMod,
+    buffer: () => ({ Buffer: Buf, constants: { MAX_LENGTH: 4294967295, MAX_STRING_LENGTH: 536870888 }, kMaxLength: 4294967295, Blob, File }),
+    child_process: () => cpMod,
+    net: () => netMod, dgram: () => dgramMod, tls: () => tlsMod, worker_threads: () => workerThreads,
+    zlib: () => ({ ...zlibMod, ...makeStreamingZlib(streamMod, Buf, globalThis.__fflate || {}), ...(nativeCS || {}), ...makeBrotli(streamMod, Buf) }),
+    assert: () => { const a = (v, m) => { if (!v) throw new Error(m || 'assertion failed'); }; a.ok = a; a.equal = (x, y, m) => a(x === y, m); a.deepEqual = (x, y, m) => a(JSON.stringify(x) === JSON.stringify(y), m); a.deepStrictEqual = a.deepEqual; a.strictEqual = a.equal; a.notEqual = (x, y, m) => a(x !== y, m); a.notDeepEqual = (x, y, m) => a(JSON.stringify(x) !== JSON.stringify(y), m); a.notStrictEqual = a.notEqual; a.throws = (fn, m) => { try { fn(); throw new Error('did not throw'); } catch (e) {} }; a.doesNotThrow = fn => fn(); a.rejects = async fn => { try { await (typeof fn === 'function' ? fn() : fn); throw new Error('did not reject'); } catch {} }; a.fail = m => { throw new Error(m || 'failed'); }; a.match = (s, re) => a(re.test(s)); return a; },
+    string_decoder: () => stubs.string_decoder, readline: () => makeReadline(term, proc), 'readline/promises': () => stubs.readline_promises,
+    timers: () => makeTimersMod(), 'timers/promises': () => makeTimersMod().promises, perf_hooks: () => makePerfHooks(),
+    v8: () => ({ ...makeV8Mod(), ...v8Real, ...heapSnap }), async_hooks: () => makeAsyncHooks(),
+    inspector: () => inspector, cluster: () => clusterReal || stubs.cluster,
+    codecs: () => { if (!webCodecs) throw makeModuleNotFoundError('codecs', []); return webCodecs; }, 'web-push': () => webPush,
+    sea: () => stubs.sea, 'node:sea': () => stubs.sea, test: () => makeTestRunner(term), 'node:test': () => makeTestRunner(term),
+    'node:test/reporters': () => ({ tap: makeTapReporter(term), spec: class {}, dot: class {} }), tty: () => stubs.tty, domain: () => stubs.domain,
+    diagnostics_channel: () => diagCh, punycode: () => stubs.punycode, errors: () => errorCodes, trace_events: () => traceEv,
+    wasi: () => wasiMod, module: () => ({ ...makeModuleModule(() => {}, MODULES), register: moduleRegister.register, _registerHooks: moduleRegister._hooks }), express: () => createExpress(term, fsmod),
+    'better-sqlite3': createSqlite, sqlite: () => ({ DatabaseSync: createSqlite, StatementSync: class {} }), 'node:sqlite': () => ({ DatabaseSync: createSqlite, StatementSync: class {} }),
+    dns: () => dnsMod, 'dns/promises': () => dnsMod.promises, 'node:dns': () => dnsMod, 'isomorphic-git': () => gitMod, git: () => gitMod, tar: () => tarMod, 'npm-registry-fetch': () => registryMod,
+    busnet: () => busnet, 'bus-http': () => busHttp,
+  };
+  for (const k of Object.keys(MODULES)) if (!k.startsWith('node:')) MODULES['node:' + k] = MODULES[k];
+  const cons = createConsole(term);
+  cons.log = (...a) => term.write(format(...a) + '\r\n'); cons.info = cons.log; cons.error = (...a) => term.write('\x1b[31m' + format(...a) + '\x1b[0m\r\n'); cons.warn = (...a) => term.write('\x1b[33m' + format(...a) + '\x1b[0m\r\n'); cons.debug = cons.log; Object.assign(cons, makeConsoleExtras(cons, term));
+  const pkgCache = {}; const reqCache = {}; let requireStack = [];
+  function loadDotEnv() { const envFile = snapFn()[ctx.cwd.replace(/^\//, '').replace(/\/$/, '') + '/.env'] || snapFn()['.env']; if (!envFile) return; for (const [k, v] of Object.entries(parseDotEnv(envFile))) if (!(k in ctx.env)) ctx.env[k] = v; }
+
+  const resolveCandidates = (dir, id) => [pathmod.resolve(dir, id) + '.js', pathmod.resolve(dir, id), pathmod.resolve(dir, id) + '/index.js', pathmod.resolve(dir, id, 'index.js')];
+  function findPkgJsonDir(s, dir) { let d = dir.replace(/^\//, '').replace(/\/$/, ''); while (true) { const k = (d ? d + '/' : '') + 'package.json'; if (k in s) return d; if (!d) return null; const up = d.slice(0, d.lastIndexOf('/')); if (up === d) return null; d = up; } }
+  function isEsmPkg(s, filePath) { const pjDir = findPkgJsonDir(s, pathmod.dirname(filePath)); try { const pj = JSON.parse(s[(pjDir || '') + (pjDir ? '/' : '') + 'package.json']); return pj.type === 'module'; } catch { return false; } }
+
+  function makeRequire(dir) {
+    const req = function require(id) {
+      if (id === 'module') return makeModuleModule(req, MODULES);
+      if (MODULES[id]) return MODULES[id]();
+      const s = snapFn();
+      if (id.startsWith('#')) {
+        const pjRoot = findPkgJsonDir(s, dir);
+        if (pjRoot) { const pj = JSON.parse(s[pjRoot + '/package.json']); const target = resolveImports(pj, id); if (target) { const resolved = pathmod.resolve('/' + pjRoot, target); return loadFile(resolved.replace(/^\//, ''), s); } }
+        throw makeModuleNotFoundError(id, requireStack);
+      }
+      if (!id.startsWith('.')) {
+        if (pkgCache[id]) return pkgCache[id];
+        const pkgDir = walkUpNodeModules(s, dir, id);
+        if (pkgDir) { const entry = resolvePackageEntry(s, pkgDir); if (entry) { const m = loadFile(entry.replace(/^\//, ''), s); if (m) return m; } }
+        throw makeModuleNotFoundError(id, requireStack);
+      }
+      for (const c of resolveCandidates(dir, id)) {
+        const key = c.replace(/^\//, '');
+        if (key in s) { const loaded = loadFile(key, s); if (loaded !== undefined) return loaded; }
+      }
+      throw makeModuleNotFoundError(id, requireStack);
+    };
+    function loadFile(key, s) {
+      if (key.endsWith('.json')) return JSON.parse(s[key]);
+      if (reqCache[key]) return reqCache[key].exports;
       const mod = { exports: {} };
-      new Function('module', 'exports', 'require', src)(mod, mod.exports, scope.require);
+      reqCache[key] = mod;
+      const modDir = pathmod.dirname('/' + key);
+      requireStack.push('/' + key);
+      try {
+        const src = s[key]; const esm = key.endsWith('.mjs') || (key.endsWith('.js') && isEsmPkg(s, '/' + key)) || isEsmCode(src);
+        if (esm) throw new Error("ESM module '" + key + "' requested via require() — use dynamic import() or run entry as ESM");
+        new Function('module', 'exports', 'require', '__filename', '__dirname', 'process', 'console', 'Buffer', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'fetch', src)(mod, mod.exports, makeRequire(modDir), '/' + key, modDir, proc, cons, Buf, setTimeout, setInterval, clearTimeout, clearInterval, fetch);
+      }
+      finally { requireStack.pop(); }
+      mod.loaded = true;
       return mod.exports;
-    },
-    loadSql: async () => {
-      if (window.__sqlJs) return window.__sqlJs;
-      await new Promise((res, rej) => {
-        const s = document.createElement('script');
-        s.src = './vendor/sql-wasm.js';
-        s.onload = res; s.onerror = rej;
-        document.head.appendChild(s);
-      });
-      window.__sqlJs = await initSqlJs({ locateFile: f => './vendor/' + f });
-      return window.__sqlJs;
-    },
-    setTimeout, setInterval, clearTimeout, clearInterval, fetch,
-    Buffer: {
-      from: (s, enc) => enc === 'base64'
-        ? new Uint8Array(atob(s).split('').map(c => c.charCodeAt(0)))
-        : new TextEncoder().encode(s),
-      toString: (buf, enc) => enc === 'base64'
-        ? btoa(String.fromCharCode(...buf))
-        : new TextDecoder().decode(buf),
-    },
-    get __filename() { return ctx.cwd + '/repl'; },
-    get __dirname() { return ctx.cwd; },
-    http: {
-      createServer: handler => ({
-        listen: (port, cb) => {
-          window.__debug.shell.httpHandlers[port] = handler;
-          term.write('listening on :' + port + '\r\n');
-          cb?.();
-        },
-      }),
-    },
-  };
+    }
+    req.resolve = id => {
+      if (MODULES[id] || id === 'module') return id;
+      const s = snapFn();
+      if (!id.startsWith('.')) { const pkgDir = walkUpNodeModules(s, dir, id); if (pkgDir) return resolvePackageEntry(s, pkgDir) || pkgDir; throw makeModuleNotFoundError(id, requireStack); }
+      for (const c of resolveCandidates(dir, id)) { const key = c.replace(/^\//, ''); if (key in s) return '/' + key; }
+      throw makeModuleNotFoundError(id, requireStack);
+    };
+    req.cache = reqCache;
+    return req;
+  }
+
+  async function preloadAsyncPkgs(entryCode, entryDir) {
+    const s = snapFn();
+    const visited = new Set(); const queue = [{ code: entryCode, dir: entryDir }]; const pkgIds = new Set();
+    const re = /require\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while (queue.length) {
+      const { code, dir } = queue.shift(); let m; re.lastIndex = 0;
+      while ((m = re.exec(code))) { const id = m[1]; if (MODULES[id]) continue; if (!id.startsWith('.')) { pkgIds.add(id); continue; } for (const c of resolveCandidates(dir, id)) { const key = c.replace(/^\//, ''); if (visited.has(key) || !(key in s)) continue; visited.add(key); queue.push({ code: s[key], dir: pathmod.dirname('/' + key) }); break; } }
+    }
+    for (const id of pkgIds) {
+      if (pkgCache[id]) continue;
+      const key = 'node_modules/' + id + '/index.js'; if (!(key in s)) continue;
+      const urlMatch = s[key].match(/import\((".+?")\)/); if (!urlMatch) continue;
+      const url = JSON.parse(urlMatch[1]);
+      try { const mod = await import(url); const exp = { ...mod }; if (mod.default && typeof mod.default === 'object') Object.assign(exp, mod.default); pkgCache[id] = mod.default && Object.keys(mod).length === 1 ? mod.default : exp; }
+      catch (e) { term.write('\x1b[31mfailed to load ' + id + ': ' + e.message + '\x1b[0m\r\n'); }
+    }
+  }
 
-  return async function nodeEval(code, filename) {
+  return async function nodeEval(code, filename, argv, stdinBuf) {
+    const dir = filename ? pathmod.dirname(filename) : ctx.cwd;
+    const fpath = filename || '[eval]';
+    proc.argv = filename ? ['node', fpath, ...(argv || [])] : ['node'];
+    proc.exitCode = 0;
+    loadDotEnv();
+    globalThis.__fflate = await preloadFflate().catch(() => ({}));
+    if (proc.sourceMapsEnabled) { await preloadSourceMap().catch(() => {}); installSourceMapStacks(snapFn); }
+    const rtName = switchRuntime(code.startsWith('#!') ? code.slice(0, code.indexOf('\n')) : ''); logRuntimeSwitch(debugReg, debugReg.runtime.active, rtName, fpath);
+    if (isTsFile(fpath)) code = await preprocessSource(fpath, code);
+    await preloadAsyncPkgs(code, dir);
+    const reqFn = makeRequire(dir);
+    const scope = { process: proc, console: cons, require: reqFn, Buffer: Buf, __filename: fpath, __dirname: dir, setTimeout, setInterval, clearTimeout, clearInterval, fetch, module: { exports: {} }, exports: {}, global: globalThis, URL, URLSearchParams, TextEncoder, TextDecoder };
+    const prevGlobals = { process: globalThis.process, Buffer: globalThis.Buffer, Deno: globalThis.Deno, Bun: globalThis.Bun };
+    globalThis.process = proc; globalThis.Buffer = Buf;
+    if (rtName === 'deno') globalThis.Deno = denoGlobal; else delete globalThis.Deno;
+    if (rtName === 'bun') globalThis.Bun = bunGlobal; else delete globalThis.Bun;
+    installCaptureStackTrace(); installPrepareStackTraceHook();
+    const unhandledH = e => { e.preventDefault?.(); const err = e.reason || e; term.write('\x1b[31m' + rewriteStack(err, fpath) + '\x1b[0m\r\n'); ctx.lastExitCode = 1; };
+    window.addEventListener('unhandledrejection', unhandledH);
     try {
-      const keys = Object.keys(scope);
-      const vals = Object.values(scope);
+      if (isEsmCode(code)) { const preamble = '\nconst __filename = ' + JSON.stringify(fpath) + ';\nconst __dirname = ' + JSON.stringify(dir) + ';\n'; const mod = await runEsm(preamble + code, scope); if (mod && !filename) { for (const [k, v] of Object.entries(mod)) if (k !== 'default') cons.log(k + ':', v); } ctx.lastExitCode = proc.exitCode | 0; return; }
+      const keys = Object.keys(scope), vals = Object.values(scope);
       const fn = new Function(...keys, 'return (async () => {\n' + code + '\n})()');
-      await fn(...vals);
+      const pending = fn(...vals);
+      if (stdinBuf) queueMicrotask(() => proc.stdin._feed(stdinBuf));
+      const result = await pending;
+      if (result !== undefined && !filename) cons.log(result);
+      ctx.lastExitCode = proc.exitCode | 0;
     } catch (e) {
-      term.write('\x1b[31m' + (filename ? filename + ': ' : '') + e.message + '\x1b[0m\r\n');
+      if (e && e.__nodeExit) { ctx.lastExitCode = e.code | 0; return; }
+      term.write('\x1b[31m' + rewriteStack(e, fpath) + '\x1b[0m\r\n');
+      ctx.lastExitCode = 1;
+    } finally {
+      window.removeEventListener('unhandledrejection', unhandledH);
+      if (prevGlobals.process !== undefined) globalThis.process = prevGlobals.process; else delete globalThis.process;
+      if (prevGlobals.Buffer !== undefined) globalThis.Buffer = prevGlobals.Buffer; else delete globalThis.Buffer;
+      if (prevGlobals.Deno !== undefined) globalThis.Deno = prevGlobals.Deno; else delete globalThis.Deno;
+      if (prevGlobals.Bun !== undefined) globalThis.Bun = prevGlobals.Bun; else delete globalThis.Bun;
     }
   };
 }

package/docs/shell-npm.js

@@ -0,0 +1,173 @@
+import { NPM_VERSION } from './shell-node-modules.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+const persist = () => window.__debug.idbPersist?.();
+
+function resolvePkgJson(cwd, ctx) {
+  const path = cwd.replace(/\/$/, '') + '/package.json';
+  const raw = snap()[toKey(path)];
+  if (!raw) throw new Error('npm: no package.json in ' + cwd);
+  try { return { path, data: JSON.parse(raw) }; } catch (e) { throw new Error('npm: invalid package.json: ' + e.message); }
+}
+
+async function installOne(pkg, version, term) {
+  const spec = version && version !== 'latest' ? pkg + '@' + version.replace(/^[\^~]/, '') : pkg;
+  const url = 'https://esm.sh/' + spec + '?bundle&target=es2022';
+  term.write('  → ' + spec + '\r\n');
+  await import(url);
+  const stubPath = 'node_modules/' + pkg + '/index.js';
+  snap()[stubPath] = '// esm.sh async stub\nawait import(' + JSON.stringify(url) + ');';
+  const meta = { name: pkg, version: version || 'latest', _resolved: url, _from: 'esm.sh' };
+  snap()['node_modules/' + pkg + '/package.json'] = JSON.stringify(meta, null, 2);
+  persist();
+}
+
+function writePkgJson(pkgPath, data) {
+  snap()[toKey(pkgPath)] = JSON.stringify(data, null, 2);
+  persist();
+}
+
+function injectNpmEnv(ctx, data, scriptName) {
+  const prev = {};
+  const set = (k, v) => { prev[k] = ctx.env[k]; ctx.env[k] = v; };
+  set('npm_lifecycle_event', scriptName);
+  set('npm_package_name', data.name || '');
+  set('npm_package_version', data.version || '');
+  set('npm_config_user_agent', 'npm/' + NPM_VERSION + ' node/v23.10.0');
+  set('NODE_ENV', ctx.env.NODE_ENV || 'development');
+  for (const [k, v] of Object.entries(data.scripts || {})) set('npm_package_scripts_' + k.replace(/[^a-z0-9_]/gi, '_'), v);
+  return () => { for (const k of Object.keys(prev)) { if (prev[k] === undefined) delete ctx.env[k]; else ctx.env[k] = prev[k]; } };
+}
+
+export function makeNpm(ctx) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+
+  async function cmdInstall(args) {
+    const saveDev = args.includes('--save-dev') || args.includes('-D');
+    const noSave = args.includes('--no-save');
+    const pkgs = args.filter(a => !a.startsWith('-'));
+    if (!pkgs.length) {
+      const { data } = resolvePkgJson(ctx.cwd, ctx);
+      const all = { ...(data.dependencies || {}), ...(data.devDependencies || {}), ...(data.peerDependencies || {}) };
+      const entries = Object.entries(all);
+      if (!entries.length) { wl('up to date, 0 packages'); return; }
+      wl('installing ' + entries.length + ' packages from package.json');
+      for (const [name, ver] of entries) await installOne(name, ver, ctx.term);
+      wl('added ' + entries.length + ' package' + (entries.length === 1 ? '' : 's'));
+      return;
+    }
+    for (const spec of pkgs) {
+      const m = spec.match(/^(@?[^@]+?)(?:@(.+))?$/);
+      const [, name, version] = m;
+      await installOne(name, version, ctx.term);
+    }
+    if (!noSave) {
+      const { path: pkgPath, data } = resolvePkgJson(ctx.cwd, ctx);
+      const target = saveDev ? 'devDependencies' : 'dependencies';
+      data[target] = data[target] || {};
+      for (const spec of pkgs) {
+        const m = spec.match(/^(@?[^@]+?)(?:@(.+))?$/);
+        data[target][m[1]] = m[2] || 'latest';
+      }
+      writePkgJson(pkgPath, data);
+    }
+    wl('added ' + pkgs.length + ' package' + (pkgs.length === 1 ? '' : 's'));
+  }
+
+  function cmdUninstall(args) {
+    const pkgs = args.filter(a => !a.startsWith('-'));
+    if (!pkgs.length) throw new Error('npm uninstall <pkg>');
+    for (const pkg of pkgs) {
+      const s = snap();
+      let n = 0;
+      for (const k of Object.keys(s)) {
+        if (k === 'node_modules/' + pkg + '/index.js' || k.startsWith('node_modules/' + pkg + '/')) { delete s[k]; n++; }
+      }
+      wl(n ? 'removed ' + pkg : pkg + ' not installed');
+    }
+    const { path: pkgPath, data } = resolvePkgJson(ctx.cwd, ctx);
+    for (const pkg of pkgs) { delete data.dependencies?.[pkg]; delete data.devDependencies?.[pkg]; }
+    writePkgJson(pkgPath, data);
+    persist();
+  }
+
+  function cmdList(args) {
+    const filter = args.find(a => !a.startsWith('-'));
+    const s = snap();
+    const installed = Object.keys(s).filter(k => k.match(/^node_modules\/[^/]+\/package\.json$/) || k.match(/^node_modules\/@[^/]+\/[^/]+\/package\.json$/));
+    try {
+      const { data } = resolvePkgJson(ctx.cwd, ctx);
+      wl(data.name + '@' + (data.version || '1.0.0') + ' ' + ctx.cwd);
+    } catch { wl('(no package.json)'); }
+    for (const k of installed) {
+      const name = k.replace(/^node_modules\//, '').replace(/\/package\.json$/, '');
+      if (filter && !name.includes(filter)) continue;
+      const pj = JSON.parse(s[k]);
+      wl('├── ' + name + '@' + (pj.version || 'latest'));
+    }
+  }
+
+  async function cmdRun(args) {
+    const [scriptName, ...rest] = args;
+    const { data } = resolvePkgJson(ctx.cwd, ctx);
+    if (!scriptName) {
+      wl('Lifecycle scripts included in ' + (data.name || 'package') + '@' + (data.version || '') + ':');
+      for (const [n, s] of Object.entries(data.scripts || {})) wl('  ' + n + '\r\n    ' + s);
+      return null;
+    }
+    const cmd = data.scripts?.[scriptName];
+    if (!cmd) throw new Error('npm: Missing script: "' + scriptName + '"');
+    const pre = data.scripts?.['pre' + scriptName];
+    const post = data.scripts?.['post' + scriptName];
+    const restore = injectNpmEnv(ctx, data, scriptName);
+    try {
+      const chain = [];
+      if (pre) chain.push({ name: 'pre' + scriptName, cmd: pre });
+      chain.push({ name: scriptName, cmd: cmd + (rest.length ? ' ' + rest.join(' ') : '') });
+      if (post) chain.push({ name: 'post' + scriptName, cmd: post });
+      return { runInShell: null, npmChain: chain, pkgName: data.name || 'package', pkgVersion: data.version || '' };
+    } finally { queueMicrotask(restore); }
+  }
+
+  function cmdInit(args) {
+    const yes = args.includes('-y') || args.includes('--yes');
+    if (!yes) { wl('npm init -y — use -y for non-interactive'); return; }
+    const pj = { name: ctx.cwd.split('/').filter(Boolean).pop() || 'project', version: '1.0.0', main: 'index.js', scripts: { start: 'node index.js', test: 'echo "Error: no test specified" && exit 1' }, dependencies: {} };
+    writePkgJson(ctx.cwd.replace(/\/$/, '') + '/package.json', pj);
+    wl('Wrote to ' + ctx.cwd.replace(/\/$/, '') + '/package.json');
+  }
+
+  async function cmdExec(args) {
+    const pkg = args[0];
+    if (!pkg) throw new Error('npx: package required');
+    const s = snap();
+    if (!s['node_modules/' + pkg + '/index.js']) await installOne(pkg, null, ctx.term);
+    const binPath = 'node_modules/.bin/' + pkg;
+    if (s[binPath]) return { runInShell: 'node /' + binPath + (args.length > 1 ? ' ' + args.slice(1).join(' ') : '') };
+    return { runInShell: 'node -e "require(\'' + pkg + '\')"' };
+  }
+
+  return async function npm(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    if (sub === 'install' || sub === 'i' || sub === 'add') return cmdInstall(rest);
+    if (sub === 'uninstall' || sub === 'remove' || sub === 'rm') return cmdUninstall(rest);
+    if (sub === 'ls' || sub === 'list') return cmdList(rest);
+    if (sub === 'run' || sub === 'run-script') return cmdRun(rest);
+    if (sub === 'start') return cmdRun(['start', ...rest]);
+    if (sub === 'test' || sub === 't') return cmdRun(['test', ...rest]);
+    if (sub === 'init' || sub === 'create') return cmdInit(rest);
+    if (sub === 'exec' || sub === 'x') return cmdExec(rest);
+    if (sub === '--version' || sub === '-v') { wl(NPM_VERSION); return; }
+    if (sub === 'prefix') { wl(ctx.cwd); return; }
+    if (sub === 'root') { wl(ctx.cwd.replace(/\/$/, '') + '/node_modules'); return; }
+    if (sub === 'view' || sub === 'info' || sub === 'show') { const p = rest[0]; wl(p + ' — use esm.sh to inspect'); return; }
+    throw new Error('npm: unknown command "' + sub + '"');
+  };
+}
+
+export function makeNpx(npmCmd) {
+  return args => npmCmd(['exec', ...args]);
+}

package/docs/shell-parser.js

@@ -0,0 +1,122 @@
+export function tokenize(line) {
+  const tokens = [];
+  let cur = '';
+  let quote = null;
+  let escape = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (escape) {
+      if (quote === '"' && !'"\\`$'.includes(c)) cur += '\\';
+      cur += c; escape = false; continue;
+    }
+    if (c === '\\' && quote !== "'") { escape = true; continue; }
+    if (quote) {
+      if (c === quote) { quote = null; continue; }
+      cur += c;
+      continue;
+    }
+    if (c === '"' || c === "'") { quote = c; continue; }
+    if (/\s/.test(c)) {
+      if (cur) { tokens.push(cur); cur = ''; }
+      continue;
+    }
+    cur += c;
+  }
+  if (cur) tokens.push(cur);
+  return tokens;
+}
+
+export function expand(token, env, lastExitCode, argv) {
+  return token.replace(/\$\(([^)]+)\)|\$\{?(\?|#|@|[0-9]|[A-Za-z_][A-Za-z0-9_]*)\}?/g, (match, sub, name) => {
+    if (sub) return match;
+    if (name === '?') return String(lastExitCode ?? 0);
+    if (name === '#') return String((argv || []).length);
+    if (name === '@') return (argv || []).join(' ');
+    if (name === '0') return (argv || [])[0] || '';
+    if (/^[1-9]$/.test(name)) return (argv || [])[parseInt(name)] || '';
+    return env[name] ?? '';
+  });
+}
+
+export function expandCmdSub(token, env, lastExitCode, runCapture, argv) {
+  if (!token.includes('$(')) return expand(token, env, lastExitCode, argv);
+  return token.replace(/\$\(([^)]+)\)/g, (_, cmd) => runCapture ? runCapture(cmd) : '');
+}
+
+export function parsePipeline(line) {
+  const chunks = splitTopLevel(line, ['&&', '||', ';']);
+  return chunks;
+}
+
+export function splitTopLevel(line, seps) {
+  const cmds = [];
+  const separators = [];
+  let cur = '';
+  let quote = null;
+  let escape = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (escape) { cur += c; escape = false; continue; }
+    if (c === '\\' && quote !== "'") { cur += c; escape = true; continue; }
+    if (quote) {
+      if (c === quote) quote = null;
+      cur += c;
+      continue;
+    }
+    if (c === '"' || c === "'") { quote = c; cur += c; continue; }
+    let matched = null;
+    for (const sep of seps) if (line.startsWith(sep, i)) { matched = sep; break; }
+    if (matched) {
+      cmds.push(cur.trim());
+      separators.push(matched);
+      cur = '';
+      i += matched.length - 1;
+      continue;
+    }
+    cur += c;
+  }
+  if (cur.trim()) cmds.push(cur.trim());
+  return cmds.map((cmd, i) => ({ cmd, sep: separators[i - 1] || null }));
+}
+
+export function parseRedirects(tokens) {
+  const out = { args: [], stdout: null, stdoutAppend: false, stdin: null };
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === '>' || t === '>>') { out.stdout = tokens[++i]; out.stdoutAppend = t === '>>'; continue; }
+    if (t === '<') { out.stdin = tokens[++i]; continue; }
+    out.args.push(t);
+  }
+  return out;
+}
+
+export function parsePipes(line) {
+  return splitTopLevel(line, ['|']).map(p => p.cmd);
+}
+
+export function globToRe(pattern) {
+  let re = '';
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '[') {
+      const close = pattern.indexOf(']', i + 1);
+      if (close < 0) { re += '\\['; i++; continue; }
+      let cls = pattern.slice(i + 1, close);
+      if (cls[0] === '!') cls = '^' + cls.slice(1);
+      re += '[' + cls + ']';
+      i = close + 1; continue;
+    }
+    if (c === '*') { re += pattern[i + 1] === '*' ? ((i += 2), '.*') : ((i++), '[^/]*'); continue; }
+    if (c === '?') { re += '[^/]'; i++; continue; }
+    if ('-{}()+.,\\^$|#'.includes(c)) { re += '\\' + c; i++; continue; }
+    re += c; i++;
+  }
+  return new RegExp('^' + re + '$');
+}
+
+export function parseCommand(line, env) {
+  const raw = tokenize(line);
+  const expanded = raw.map(t => expand(t, env));
+  return parseRedirects(expanded);
+}