thebird 1.2.77 → 1.2.79

package/.github/workflows/auto-declaudeify.yml

@@ -4,41 +4,45 @@ on:
   push:
     branches: ['**']
 
+permissions:
+  contents: write
+
 jobs:
   declaudeify:
-    if: contains(github.event.head_commit.author.name, 'Claude') || contains(github.event.head_commit.author.email, 'claude')
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Check for Claude commits
         id: check
         run: |
           CLAUDE_COMMITS=$(git log --all --author="Claude" --oneline | wc -l)
           echo "count=$CLAUDE_COMMITS" >> $GITHUB_OUTPUT
-          if [ $CLAUDE_COMMITS -gt 0 ]; then
+          if [ "$CLAUDE_COMMITS" -gt 0 ]; then
             echo "Found $CLAUDE_COMMITS Claude commits, will filter"
+          else
+            echo "No Claude commits found"
           fi
 
       - name: Filter Claude from history
-        if: steps.check.outputs.count > 0
+        if: steps.check.outputs.count != '0'
         run: |
-          git filter-branch --force --env-filter \
-            'if [ "$GIT_AUTHOR_NAME" = "Claude" ]; then \
-              export GIT_AUTHOR_NAME="lanmower"; \
-              export GIT_AUTHOR_EMAIL="lanmower@lanmower.com"; \
-            fi; \
-            if [ "$GIT_COMMITTER_NAME" = "Claude" ]; then \
-              export GIT_COMMITTER_NAME="lanmower"; \
-              export GIT_COMMITTER_EMAIL="lanmower@lanmower.com"; \
-            fi' \
-            --tag-name-filter cat -- --all
+          git config user.name "lanmower"
+          git config user.email "lanmower@lanmower.com"
+          git filter-branch --force --env-filter '
+            if [ "$GIT_AUTHOR_NAME" = "Claude" ]; then
+              export GIT_AUTHOR_NAME="lanmower"
+              export GIT_AUTHOR_EMAIL="lanmower@lanmower.com"
+            fi
+            if [ "$GIT_COMMITTER_NAME" = "Claude" ]; then
+              export GIT_COMMITTER_NAME="lanmower"
+              export GIT_COMMITTER_EMAIL="lanmower@lanmower.com"
+            fi' --tag-name-filter cat -- --all
 
       - name: Force push filtered history
-        if: steps.check.outputs.count > 0
+        if: steps.check.outputs.count != '0'
         run: git push --all --force
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+### Added
+- `docs/node-builtins.js`: Full Node.js module polyfills — path, fs (IDB-backed), events (EventEmitter), url, querystring, Buffer class with encoding support
+- `docs/shell-node.js`: Enhanced Node env — relative require, JSON require, per-file __dirname, process.stdout/stderr/nextTick/argv/hrtime, console.dir/table/time/assert/count, express with route params/middleware/static/json, os/util/crypto/stream modules
+- `docs/shell.js`: Added node -e/-v flags, touch/head/tail/wc/grep/which commands, npm i alias
+
+### Changed
+- `docs/shell-node.js`: Rewritten to import from node-builtins.js; require() resolves relative paths, .json, directory/index.js
+- `docs/shell.js`: Trimmed from 206L to 189L; ls shows directory entries properly
+
 ### Added
 - `lib/errors.js`: Typed error hierarchy — BridgeError, AuthError, RateLimitError, TimeoutError, ContextWindowError, ContentPolicyError, ProviderError with classifyError factory. GeminiError kept as alias.
 - `lib/errors.js`: `redactKeys()` — auto-redacts API keys (AIza, sk-, key- patterns) in error messages to `...XXXX`

package/docs/node-builtins.js

@@ -0,0 +1,170 @@
+const snap = () => window.__debug?.idbSnapshot || {};
+const toKey = p => p.replace(/^\//, '');
+const persist = () => window.__debug?.idbPersist?.();
+const previewWrite = () => window.__debug?.shell?.onPreviewWrite?.();
+
+export function createPath() {
+  const sep = '/';
+  const normalize = p => {
+    const parts = [];
+    for (const s of p.split('/')) {
+      if (s === '..') parts.pop();
+      else if (s && s !== '.') parts.push(s);
+    }
+    return (p.startsWith('/') ? '/' : '') + parts.join('/');
+  };
+  return {
+    sep,
+    normalize,
+    join: (...a) => normalize(a.join('/')),
+    resolve: (...a) => {
+      let r = '';
+      for (const p of a) r = p.startsWith('/') ? p : r + '/' + p;
+      return normalize(r);
+    },
+    dirname: p => { const i = p.lastIndexOf('/'); return i <= 0 ? '/' : p.slice(0, i); },
+    basename: (p, ext) => { const b = p.split('/').pop() || ''; return ext && b.endsWith(ext) ? b.slice(0, -ext.length) : b; },
+    extname: p => { const b = p.split('/').pop() || ''; const i = b.lastIndexOf('.'); return i > 0 ? b.slice(i) : ''; },
+    isAbsolute: p => p.startsWith('/'),
+    relative: (from, to) => to.replace(from.replace(/\/$/, '') + '/', ''),
+    parse: p => {
+      const dir = p.slice(0, p.lastIndexOf('/')) || '/';
+      const base = p.split('/').pop() || '';
+      const ext = base.lastIndexOf('.') > 0 ? base.slice(base.lastIndexOf('.')) : '';
+      return { root: '/', dir, base, ext, name: ext ? base.slice(0, -ext.length) : base };
+    },
+  };
+}
+
+export function createFs() {
+  const resolveP = p => typeof p === 'string' ? p : p.toString();
+  return {
+    readFileSync: (p, enc) => {
+      const key = toKey(resolveP(p));
+      const data = snap()[key];
+      if (data == null) throw Object.assign(new Error('ENOENT: ' + p), { code: 'ENOENT' });
+      return enc ? data : data;
+    },
+    writeFileSync: (p, data) => {
+      const s = snap();
+      s[toKey(resolveP(p))] = typeof data === 'string' ? data : String(data);
+      persist();
+      previewWrite();
+    },
+    appendFileSync: (p, data) => {
+      const key = toKey(resolveP(p));
+      const s = snap();
+      s[key] = (s[key] || '') + (typeof data === 'string' ? data : String(data));
+      persist();
+    },
+    existsSync: p => toKey(resolveP(p)) in snap(),
+    unlinkSync: p => {
+      const key = toKey(resolveP(p));
+      if (!(key in snap())) throw Object.assign(new Error('ENOENT: ' + p), { code: 'ENOENT' });
+      delete snap()[key];
+      persist();
+    },
+    mkdirSync: (p, opts) => {
+      const key = toKey(resolveP(p));
+      if (!snap()[key + '/.keep']) { snap()[key + '/.keep'] = ''; persist(); }
+    },
+    readdirSync: p => {
+      const prefix = toKey(resolveP(p));
+      const pLen = prefix ? prefix.length + 1 : 0;
+      const seen = new Set();
+      for (const k of Object.keys(snap())) {
+        if (prefix && !k.startsWith(prefix + '/') && k !== prefix) continue;
+        if (!prefix && !k.includes('/')) { seen.add(k); continue; }
+        const rest = k.slice(pLen);
+        const first = rest.split('/')[0];
+        if (first && first !== '.keep') seen.add(first);
+      }
+      return [...seen];
+    },
+    statSync: p => {
+      const key = toKey(resolveP(p));
+      const s = snap();
+      const isFile = key in s;
+      const isDir = !isFile && Object.keys(s).some(k => k.startsWith(key + '/'));
+      if (!isFile && !isDir) throw Object.assign(new Error('ENOENT: ' + p), { code: 'ENOENT' });
+      return { isFile: () => isFile, isDirectory: () => isDir, size: isFile ? (s[key]?.length || 0) : 0 };
+    },
+    renameSync: (o, n) => {
+      const s = snap();
+      const ok = toKey(resolveP(o)), nk = toKey(resolveP(n));
+      if (!(ok in s)) throw Object.assign(new Error('ENOENT: ' + o), { code: 'ENOENT' });
+      s[nk] = s[ok];
+      delete s[ok];
+      persist();
+    },
+    copyFileSync: (s, d) => {
+      const src = snap()[toKey(resolveP(s))];
+      if (src == null) throw Object.assign(new Error('ENOENT: ' + s), { code: 'ENOENT' });
+      snap()[toKey(resolveP(d))] = src;
+      persist();
+    },
+  };
+}
+
+export function createEvents() {
+  return class EventEmitter {
+    constructor() { this._e = {}; }
+    on(ev, fn) { (this._e[ev] = this._e[ev] || []).push(fn); return this; }
+    once(ev, fn) { const w = (...a) => { this.off(ev, w); fn(...a); }; return this.on(ev, w); }
+    off(ev, fn) { this._e[ev] = (this._e[ev] || []).filter(f => f !== fn); return this; }
+    removeListener(ev, fn) { return this.off(ev, fn); }
+    removeAllListeners(ev) { if (ev) delete this._e[ev]; else this._e = {}; return this; }
+    emit(ev, ...a) { for (const fn of (this._e[ev] || [])) fn(...a); return (this._e[ev] || []).length > 0; }
+    listeners(ev) { return (this._e[ev] || []).slice(); }
+    listenerCount(ev) { return (this._e[ev] || []).length; }
+  };
+}
+
+export function createUrl() {
+  return {
+    parse: s => {
+      const u = new URL(s);
+      return { protocol: u.protocol, host: u.host, hostname: u.hostname, port: u.port, pathname: u.pathname, search: u.search, query: u.search.slice(1), hash: u.hash, href: u.href };
+    },
+    format: o => {
+      const u = new URL('http://x');
+      for (const [k, v] of Object.entries(o)) { try { u[k] = v; } catch {} }
+      return u.href;
+    },
+    resolve: (from, to) => new URL(to, from).href,
+  };
+}
+
+export function createQuerystring() {
+  return {
+    parse: s => Object.fromEntries(new URLSearchParams(s)),
+    stringify: o => new URLSearchParams(o).toString(),
+    escape: s => encodeURIComponent(s),
+    unescape: s => decodeURIComponent(s),
+  };
+}
+
+export function createBuffer() {
+  class Buf extends Uint8Array {
+    toString(enc) {
+      if (enc === 'base64') return btoa(String.fromCharCode(...this));
+      if (enc === 'hex') return [...this].map(b => b.toString(16).padStart(2, '0')).join('');
+      return new TextDecoder().decode(this);
+    }
+    toJSON() { return { type: 'Buffer', data: [...this] }; }
+    slice(s, e) { return Buf.from(super.slice(s, e)); }
+  }
+  Buf.from = (d, enc) => {
+    if (d instanceof Uint8Array) return new Buf(d);
+    if (Array.isArray(d)) return new Buf(d);
+    if (typeof d !== 'string') return new Buf(0);
+    if (enc === 'base64') return new Buf(Uint8Array.from(atob(d), c => c.charCodeAt(0)));
+    if (enc === 'hex') return new Buf(d.match(/.{2}/g).map(h => parseInt(h, 16)));
+    return new Buf(new TextEncoder().encode(d));
+  };
+  Buf.alloc = (n, fill) => { const b = new Buf(n); if (fill) b.fill(typeof fill === 'number' ? fill : fill.charCodeAt(0)); return b; };
+  Buf.concat = list => { const t = list.reduce((s, b) => s + b.length, 0); const r = new Buf(t); let o = 0; for (const b of list) { r.set(b, o); o += b.length; } return r; };
+  Buf.isBuffer = o => o instanceof Buf;
+  Buf.byteLength = (s, enc) => Buf.from(s, enc).length;
+  return Buf;
+}

package/docs/shell-node.js

@@ -1,106 +1,191 @@
+import { createPath, createFs, createEvents, createUrl, createQuerystring, createBuffer } from './node-builtins.js';
+
 function serializeRoutes(routes) {
   const out = {};
-  for (const [method, arr] of Object.entries(routes)) {
-    out[method] = arr.map(r => ({ path: r.path }));
-  }
+  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?.();
-      },
+function matchRoute(pattern, path) {
+  if (pattern === '*') return {};
+  const pp = pattern.split('/'), rp = path.split('/');
+  if (pp.length !== rp.length) return null;
+  const params = {};
+  for (let i = 0; i < pp.length; i++) {
+    if (pp[i].startsWith(':')) params[pp[i].slice(1)] = rp[i];
+    else if (pp[i] !== rp[i]) return null;
+  }
+  return params;
+}
+
+function createExpress(term, fsmod) {
+  return () => {
+    const routes = { GET: [], POST: [], PUT: [], DELETE: [], USE: [] };
+    const middlewares = [];
+    const app = fn => middlewares.push(fn);
+    app.get = (p, ...fns) => routes.GET.push({ path: p, fns });
+    app.post = (p, ...fns) => routes.POST.push({ path: p, fns });
+    app.put = (p, ...fns) => routes.PUT.push({ path: p, fns });
+    app.delete = (p, ...fns) => routes.DELETE.push({ path: p, fns });
+    app.use = (...args) => {
+      if (typeof args[0] === 'function') middlewares.push(args[0]);
+      else routes.USE.push({ path: args[0], fn: args[1] });
+    };
+    app.listen = (port, cb) => {
+      window.__debug.shell.httpHandlers[port] = { routes, middlewares };
+      navigator.serviceWorker?.controller?.postMessage({ type: 'REGISTER_ROUTES', port, routes: serializeRoutes(routes) });
+      term.write('Express listening on :' + port + '\r\n');
+      cb?.();
+    };
+    app.json = () => (req, res, next) => {
+      if (typeof req.body === 'string') try { req.body = JSON.parse(req.body); } catch {}
+      next?.();
+    };
+    app.static = dir => (req, res) => {
+      const fp = dir.replace(/\/$/, '') + req.path;
+      try { res.send(fsmod.readFileSync(fp)); } catch { res.status(404).send('Not Found'); }
     };
     return app;
-  },
-  'better-sqlite3': () => class Database {
+  };
+}
+
+function createSqlite() {
+  return class Database {
     constructor(name) {
       this._name = name;
-      if (!window.__sqlJs) throw new Error('sql.js not loaded — call await loadSql() first');
+      if (!window.__sqlJs) throw new Error('sql.js not loaded');
       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]]))); },
+        run: (...p) => { db.run(sql, p); return { changes: 1 }; },
+        get: (...p) => { const r = db.exec(sql, p); return r[0]?.values[0] ? Object.fromEntries(r[0].columns.map((c, i) => [c, r[0].values[0][i]])) : undefined; },
+        all: (...p) => { const r = db.exec(sql, p); if (!r[0]) return []; return r[0].values.map(row => Object.fromEntries(r[0].columns.map((c, i) => [c, row[i]]))); },
       };
     }
-  },
-});
+    close() {}
+  };
+}
 
-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 mod = { exports: {} };
-      new Function('module', 'exports', 'require', src)(mod, mod.exports, scope.require);
-      return mod.exports;
+function createConsole(term) {
+  const w = s => term.write(s + '\r\n');
+  const timers = {};
+  return {
+    log: (...a) => w(a.map(v => typeof v === 'object' ? JSON.stringify(v, null, 2) : String(v)).join(' ')),
+    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'),
+    info: (...a) => w(a.map(String).join(' ')),
+    dir: (o, opts) => w(JSON.stringify(o, null, 2)),
+    table: data => {
+      if (!Array.isArray(data)) { w(JSON.stringify(data, null, 2)); return; }
+      if (!data.length) { w('(empty)'); return; }
+      const cols = Object.keys(data[0]);
+      w(cols.join('\t'));
+      for (const row of data) w(cols.map(c => String(row[c] ?? '')).join('\t'));
     },
-    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?.();
-        },
-      }),
+    time: label => { timers[label || 'default'] = performance.now(); },
+    timeEnd: label => {
+      const k = label || 'default';
+      const ms = timers[k] ? (performance.now() - timers[k]).toFixed(3) : 0;
+      delete timers[k];
+      w(k + ': ' + ms + 'ms');
     },
+    assert: (cond, ...a) => { if (!cond) term.write('\x1b[31mAssertion failed: ' + a.join(' ') + '\x1b[0m\r\n'); },
+    count: (() => { const c = {}; return label => { const k = label || 'default'; c[k] = (c[k] || 0) + 1; w(k + ': ' + c[k]); }; })(),
+    clear: () => term.clear(),
+    trace: (...a) => w('Trace: ' + a.map(String).join(' ')),
+    group: () => {},
+    groupEnd: () => {},
+  };
+}
+
+function createProcess(term, ctx) {
+  return {
+    argv: ['node'],
+    env: ctx.env,
+    cwd: () => ctx.cwd,
+    chdir: d => { ctx.cwd = d; },
+    exit: code => term.write('[exit ' + (code || 0) + ']\r\n'),
+    platform: 'browser',
+    version: 'v20.0.0',
+    versions: { node: '20.0.0' },
+    pid: 1,
+    nextTick: fn => Promise.resolve().then(fn),
+    stdout: { write: s => term.write(String(s)) },
+    stderr: { write: s => term.write('\x1b[31m' + String(s) + '\x1b[0m') },
+    stdin: { on: () => {} },
+    on: () => {},
+    off: () => {},
+    hrtime: { bigint: () => BigInt(Math.round(performance.now() * 1e6)) },
+  };
+}
+
+export function createNodeEnv({ ctx, term }) {
+  const pathmod = createPath();
+  const fsmod = createFs();
+  const Buf = createBuffer();
+  const MODULES = {
+    path: () => pathmod,
+    fs: () => fsmod,
+    events: () => createEvents(),
+    url: () => createUrl(),
+    querystring: () => createQuerystring(),
+    os: () => ({ platform: () => 'browser', homedir: () => '/', tmpdir: () => '/tmp', cpus: () => [{}], totalmem: () => 1073741824, freemem: () => 536870912, hostname: () => 'thebird', EOL: '\n' }),
+    util: () => ({ format: (...a) => a.join(' '), inspect: o => JSON.stringify(o, null, 2), promisify: fn => (...a) => new Promise((r, j) => fn(...a, (e, v) => e ? j(e) : r(v))), types: { isPromise: p => p instanceof Promise } }),
+    crypto: () => ({ randomBytes: n => Buf.from(Array.from({ length: n }, () => Math.random() * 256 | 0)), randomUUID: () => crypto.randomUUID(), createHash: () => ({ update: () => ({ digest: () => 'stub' }) }) }),
+    stream: () => ({ Readable: createEvents(), Writable: createEvents(), Transform: createEvents(), pipeline: (...a) => a.pop()(null) }),
+    express: createExpress(term, fsmod),
+    'better-sqlite3': createSqlite,
   };
 
-  return async function nodeEval(code, filename) {
+  const cons = createConsole(term);
+  const proc = createProcess(term, ctx);
+
+  function makeRequire(dir) {
+    return function require(id) {
+      if (MODULES[id]) return MODULES[id]();
+      const candidates = id.startsWith('.') ? [
+        pathmod.resolve(dir, id) + '.js',
+        pathmod.resolve(dir, id),
+        pathmod.resolve(dir, id) + '/index.js',
+        pathmod.resolve(dir, id, 'index.js'),
+      ] : ['node_modules/' + id + '/index.js'];
+      const s = snap();
+      for (const c of candidates) {
+        const key = c.replace(/^\//, '');
+        if (key in s) {
+          if (key.endsWith('.json')) return JSON.parse(s[key]);
+          const mod = { exports: {} };
+          const modDir = pathmod.dirname('/' + key);
+          new Function('module', 'exports', 'require', '__filename', '__dirname', 'process', 'console', 'Buffer', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'fetch', s[key])(mod, mod.exports, makeRequire(modDir), '/' + key, modDir, proc, cons, Buf, setTimeout, setInterval, clearTimeout, clearInterval, fetch);
+          return mod.exports;
+        }
+      }
+      throw new Error('Cannot find module: ' + id);
+    };
+  }
+
+  const snap = () => window.__debug?.idbSnapshot || {};
+
+  async function loadSql() {
+    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;
+  }
+
+  return async function nodeEval(code, filename, argv) {
+    const dir = filename ? pathmod.dirname(filename) : ctx.cwd;
+    const fpath = filename || ctx.cwd + '/repl';
+    proc.argv = ['node', fpath, ...(argv || [])];
+    const scope = { process: proc, console: cons, require: makeRequire(dir), Buffer: Buf, __filename: fpath, __dirname: dir, setTimeout, setInterval, clearTimeout, clearInterval, fetch, loadSql, module: { exports: {} }, exports: {} };
     try {
       const keys = Object.keys(scope);
       const vals = Object.values(scope);
       const fn = new Function(...keys, 'return (async () => {\n' + code + '\n})()');
-      await fn(...vals);
+      const result = await fn(...vals);
+      if (result !== undefined && !filename) cons.log(result);
     } catch (e) {
       term.write('\x1b[31m' + (filename ? filename + ': ' : '') + e.message + '\x1b[0m\r\n');
     }

package/docs/shell.js

@@ -21,9 +21,17 @@ function makeBuiltins(ctx) {
   const wl = s => w(s + '\r\n');
   return {
     ls: ([p]) => {
-      const prefix = toKey(resolvePath(ctx.cwd, p || '')) + '/';
-      const keys = prefix === '/' ? Object.keys(snap()) : Object.keys(snap()).filter(k => k.startsWith(prefix));
-      wl(keys.join('\r\n') || '(empty)');
+      const prefix = toKey(resolvePath(ctx.cwd, p || ''));
+      const pLen = prefix ? prefix.length + 1 : 0;
+      const seen = new Set();
+      for (const k of Object.keys(snap())) {
+        if (prefix && !k.startsWith(prefix + '/') && k !== prefix) continue;
+        if (!prefix && !k.includes('/')) { seen.add(k); continue; }
+        const rest = k.slice(pLen);
+        const first = rest.split('/')[0];
+        if (first && first !== '.keep') seen.add(first);
+      }
+      wl([...seen].join('\r\n') || '(empty)');
     },
     cat: ([f]) => {
       const c = snap()[toKey(resolvePath(ctx.cwd, f))];
@@ -33,50 +41,49 @@ function makeBuiltins(ctx) {
     echo: args => wl(args.join(' ')),
     pwd: () => wl(ctx.cwd),
     cd: ([p]) => { ctx.cwd = resolvePath(ctx.cwd, p || '~'); },
-    mkdir: ([p]) => {
-      window.__debug.idbSnapshot[toKey(resolvePath(ctx.cwd, p)) + '/.keep'] = '';
-      window.__debug.idbPersist?.();
-    },
-    rm: ([f]) => {
-      delete window.__debug.idbSnapshot[toKey(resolvePath(ctx.cwd, f))];
-      window.__debug.idbPersist?.();
-    },
-    cp: ([s, d]) => {
-      window.__debug.idbSnapshot[toKey(resolvePath(ctx.cwd, d))] = snap()[toKey(resolvePath(ctx.cwd, s))];
-      window.__debug.idbPersist?.();
-    },
+    mkdir: ([p]) => { snap()[toKey(resolvePath(ctx.cwd, p)) + '/.keep'] = ''; window.__debug.idbPersist?.(); },
+    rm: ([f]) => { delete snap()[toKey(resolvePath(ctx.cwd, f))]; window.__debug.idbPersist?.(); },
+    cp: ([s, d]) => { snap()[toKey(resolvePath(ctx.cwd, d))] = snap()[toKey(resolvePath(ctx.cwd, s))]; window.__debug.idbPersist?.(); },
     mv: ([s, d]) => {
       const src = toKey(resolvePath(ctx.cwd, s)), dst = toKey(resolvePath(ctx.cwd, d));
-      window.__debug.idbSnapshot[dst] = snap()[src];
-      delete window.__debug.idbSnapshot[src];
-      window.__debug.idbPersist?.();
+      snap()[dst] = snap()[src]; delete snap()[src]; window.__debug.idbPersist?.();
+    },
+    touch: ([f]) => { const k = toKey(resolvePath(ctx.cwd, f)); if (!(k in snap())) { snap()[k] = ''; window.__debug.idbPersist?.(); } },
+    head: ([f]) => { const c = snap()[toKey(resolvePath(ctx.cwd, f))]; if (!c) throw new Error('no such file: ' + f); wl(c.split('\n').slice(0, 10).join('\r\n')); },
+    tail: ([f]) => { const c = snap()[toKey(resolvePath(ctx.cwd, f))]; if (!c) throw new Error('no such file: ' + f); wl(c.split('\n').slice(-10).join('\r\n')); },
+    wc: ([f]) => { const c = snap()[toKey(resolvePath(ctx.cwd, f))]; if (!c) throw new Error('no such file: ' + f); const lines = c.split('\n').length; wl(lines + ' ' + c.length + ' ' + f); },
+    grep: ([pat, f]) => {
+      const c = snap()[toKey(resolvePath(ctx.cwd, f))];
+      if (!c) throw new Error('no such file: ' + f);
+      const re = new RegExp(pat, 'g');
+      wl(c.split('\n').filter(l => re.test(l)).join('\r\n') || '(no matches)');
     },
     env: () => wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n')),
     export: ([kv]) => { const [k, ...v] = (kv || '').split('='); ctx.env[k] = v.join('='); },
     clear: () => ctx.term.clear(),
     help: () => wl(Object.keys(makeBuiltins(ctx)).join('  ')),
-    exit: (actor) => {
-      const st = actor.getSnapshot().value;
-      if (st === 'node-repl') { actor.send({ type: 'EXIT_REPL' }); wl('[shell]'); }
+    which: ([cmd]) => wl(makeBuiltins(ctx)[cmd] ? '(builtin) ' + cmd : 'not found: ' + cmd),
+    exit: (_, actor) => {
+      if (actor.getSnapshot().value === 'node-repl') { actor.send({ type: 'EXIT_REPL' }); wl('[shell]'); }
     },
-    node: async ([file], actor) => {
-      if (!file) { actor.send({ type: 'ENTER_REPL' }); wl('[node repl — type exit to return]'); return; }
-      const path = resolvePath(ctx.cwd, file);
+    node: async (args, actor) => {
+      if (!args.length) { actor.send({ type: 'ENTER_REPL' }); wl('[node repl — type exit to return]'); return; }
+      if (args[0] === '-v' || args[0] === '--version') { wl('v20.0.0'); return; }
+      if (args[0] === '-e' || args[0] === '--eval') { await ctx.nodeEval(args.slice(1).join(' ')); return; }
+      const path = resolvePath(ctx.cwd, args[0]);
       const code = snap()[toKey(path)];
       if (code == null) throw new Error('no such file: ' + path);
       actor.send({ type: 'NODE_START' });
-      await ctx.nodeEval(code, path);
+      await ctx.nodeEval(code, path, args.slice(1));
     },
-    npm: async (args, actor) => {
-      if (args[0] !== 'install') throw new Error('only npm install supported');
+    npm: async (args) => {
+      if (args[0] !== 'install' && args[0] !== 'i') throw new Error('only npm install supported');
       const pkg = args[1];
       if (!pkg) throw new Error('npm install <pkg>');
-      actor.send({ type: 'NPM_START' });
       w('fetching ' + pkg + '...\r\n');
       const r = await fetch('https://esm.sh/' + pkg);
       if (!r.ok) throw new Error('fetch failed: ' + r.status);
-      const key = 'node_modules/' + pkg + '/index.js';
-      window.__debug.idbSnapshot[key] = await r.text();
+      snap()['node_modules/' + pkg + '/index.js'] = await r.text();
       window.__debug.idbPersist?.();
       wl('installed ' + pkg);
     },
@@ -84,15 +91,14 @@ function makeBuiltins(ctx) {
 }
 
 const machine = createMachine({ id: 'shell', initial: 'idle', states: {
-  idle: { on: { RUN: 'executing', ENTER_REPL: 'node-repl', NPM_START: 'npm-installing', NODE_START: 'node-running' } },
+  idle: { on: { RUN: 'executing', ENTER_REPL: 'node-repl', NODE_START: 'node-running' } },
   executing: { on: { DONE: 'idle', ERROR: 'idle' } },
-  'npm-installing': { on: { DONE: 'idle', ERROR: 'idle' } },
   'node-running': { on: { DONE: 'idle', ERROR: 'idle' } },
   'node-repl': { on: { EXIT_REPL: 'idle', RUN: 'node-repl' } },
 }});
 
 export function createShell({ term, onPreviewWrite }) {
-  const ctx = { term, cwd: '/', env: {}, history: [], httpHandlers: {} };
+  const ctx = { term, cwd: '/', env: {}, history: [] };
   const BUILTINS = makeBuiltins(ctx);
   ctx.nodeEval = createNodeEnv({ ctx, term });
 
@@ -100,12 +106,7 @@ export function createShell({ term, onPreviewWrite }) {
   actor.start();
 
   let inputQueue = [];
-
-  function drainQueue(onData) {
-    const items = inputQueue.slice();
-    inputQueue = [];
-    for (const d of items) onData(d);
-  }
+  function drainQueue(onData) { const items = inputQueue.slice(); inputQueue = []; for (const d of items) onData(d); }
 
   window.__debug = window.__debug || {};
   window.__debug.shell = {
@@ -113,11 +114,11 @@ export function createShell({ term, onPreviewWrite }) {
     get cwd() { return ctx.cwd; },
     get env() { return ctx.env; },
     get history() { return ctx.history; },
-    httpHandlers: ctx.httpHandlers,
+    httpHandlers: {},
     get inputQueue() { return inputQueue.slice(); },
   };
 
-  async function runCmd(line, capture, actor) {
+  async function runCmd(line, capture) {
     if (!line.trim()) return '';
     const [cmd, ...args] = line.trim().split(/\s+/);
     const fn = BUILTINS[cmd];
@@ -128,7 +129,7 @@ export function createShell({ term, onPreviewWrite }) {
     let out = '';
     const orig = term.write.bind(term);
     term.write = s => { out += s; };
-    try { if (fn) await fn(args, actor); else out += 'command not found: ' + cmd + '\r\n'; }
+    try { if (fn) await fn(args, actor); else out += 'command not found: ' + cmd; }
     finally { term.write = orig; }
     return out;
   }
@@ -137,13 +138,13 @@ export function createShell({ term, onPreviewWrite }) {
     if (!line.trim()) return;
     const st = actor.getSnapshot().value;
     if (st === 'node-repl' && line.trim() !== 'exit') { await ctx.nodeEval(line); return; }
-    if (line.trim() === 'exit') { BUILTINS.exit(actor); return; }
+    if (line.trim() === 'exit') { BUILTINS.exit([], actor); return; }
     const [cmd] = line.trim().split(/\s+/);
     if (cmd !== 'npm' && cmd !== 'node') actor.send({ type: 'RUN' });
     try {
       const parts = line.split(' | ');
       if (parts.length > 1) {
-        let buf = await runCmd(parts[0], true, actor);
+        let buf = await runCmd(parts[0], true);
         for (const p of parts.slice(1)) {
           const [c, ...a] = p.trim().split(/\s+/);
           const fn = BUILTINS[c];
@@ -151,7 +152,7 @@ export function createShell({ term, onPreviewWrite }) {
           buf = '';
         }
       } else {
-        await runCmd(line, false, actor);
+        await runCmd(line, false);
       }
       actor.send({ type: 'DONE' });
       drainQueue(onData);
@@ -163,36 +164,18 @@ export function createShell({ term, onPreviewWrite }) {
   }
 
   function getCompletions(line, word) {
-    const snap = window.__debug.idbSnapshot || {};
-    const files = Object.keys(snap);
+    const files = Object.keys(window.__debug.idbSnapshot || {});
     const tokens = line.trim().split(/\s+/);
-    if (tokens.length <= 1 && !line.includes(' ')) {
-      const cmds = Object.keys(BUILTINS);
-      return cmds.filter(c => c.startsWith(word));
-    }
+    if (tokens.length <= 1 && !line.includes(' ')) return Object.keys(BUILTINS).filter(c => c.startsWith(word));
     return files.filter(f => f.startsWith(word));
   }
 
-  const rl = createReadline({
-    term,
-    getCompletions,
-    getPrompt: () => ctx.cwd,
-    onLine: line => run(line, onData).then(() => rl.showPrompt()),
-  });
+  const rl = createReadline({ term, getCompletions, getPrompt: () => ctx.cwd, onLine: line => run(line, onData).then(() => rl.showPrompt()) });
 
   function onData(data) {
-    if (data === '\x03') {
-      actor.send({ type: 'ERROR' });
-      inputQueue = [];
-      term.write('^C');
-      rl.showPrompt();
-      return;
-    }
+    if (data === '\x03') { actor.send({ type: 'ERROR' }); inputQueue = []; term.write('^C'); rl.showPrompt(); return; }
     const st = actor.getSnapshot().value;
-    if (st !== 'idle' && st !== 'node-repl') {
-      inputQueue.push(data);
-      return;
-    }
+    if (st !== 'idle' && st !== 'node-repl') { inputQueue.push(data); return; }
     rl.onData(data);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thebird",
-  "version": "1.2.77",
+  "version": "1.2.79",
   "description": "Anthropic SDK to Gemini streaming bridge — drop-in proxy that translates Anthropic message format and tool calls to Google Gemini",
   "scripts": {
     "start": "node serve.js"