thebird 1.2.79 → 1.2.81

package/docs/shell-builtins-text.js

@@ -0,0 +1,109 @@
+import { resolvePath } from './shell-builtins.js';
+import { runSed } from './shell-sed.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+const persist = () => window.__debug.idbPersist?.();
+const previewWrite = () => window.__debug.shell?.onPreviewWrite?.();
+
+const readLines = text => text.split('\n').map(l => l.replace(/\r$/, '')).filter((l, i, a) => i < a.length - 1 || l !== '');
+
+function readStdinFirst(positional) {
+  const stdinFirst = positional.length > 0 && positional[0].includes('\n');
+  return { stdin: stdinFirst ? positional[0] : null, rest: stdinFirst ? positional.slice(1) : positional };
+}
+
+export function makeTextBuiltins(ctx, readFile, writeFile) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  return {
+    grep: args => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const positional = args.filter(a => !a.startsWith('-'));
+      const { stdin, rest } = readStdinFirst(positional);
+      const [pat, ...fileArgs] = rest;
+      if (!pat) throw new Error('grep: missing pattern');
+      const re = new RegExp(pat, flags.includes('i') ? 'gi' : 'g');
+      const lineNos = flags.includes('n');
+      const sources = fileArgs.length ? fileArgs.map(f => ({ name: f, text: readFile(f) })) : [{ name: '', text: stdin || '' }];
+      const showFile = sources.length > 1 || flags.includes('H');
+      let matched = 0;
+      for (const { name, text } of sources) {
+        text.split('\n').forEach((l, i) => {
+          re.lastIndex = 0;
+          if (re.test(l)) { wl((showFile && name ? name + ':' : '') + (lineNos ? (i + 1) + ':' : '') + l); matched++; }
+        });
+      }
+      if (!matched) ctx.lastExitCode = 1;
+    },
+    sed: args => {
+      const exprs = [];
+      const files = [];
+      let inplace = false;
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-e') { exprs.push(args[++i]); continue; }
+        if (args[i] === '-i') { inplace = true; continue; }
+        if (args[i].startsWith('-')) continue;
+        if (!exprs.length) exprs.push(args[i]); else files.push(args[i]);
+      }
+      const { stdin, rest } = readStdinFirst(files);
+      const fileArgs = rest;
+      if (!exprs.length) throw new Error('sed: missing expression');
+      const pairs = fileArgs.length ? fileArgs.map(f => [f, readFile(f)]) : [['', stdin || '']];
+      for (const [name, text] of pairs) {
+        const out = runSed(exprs, text);
+        if (name && inplace) writeFile(name, out);
+        else if (name) w(out.replace(/\n/g, '\r\n') + '\r\n');
+        else w(out.replace(/\n/g, '\r\n'));
+      }
+    },
+    sort: args => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const positional = args.filter(a => !a.startsWith('-'));
+      const stdinFirst = positional.length > 0 && positional[0].includes('\n');
+      const stdin = stdinFirst ? positional[0] : null;
+      const fileArgs = stdinFirst ? positional.slice(1) : positional;
+      const targets = fileArgs.length ? fileArgs : [null];
+      for (const f of targets) {
+        let lines = readLines(f ? readFile(f) : stdin || '');
+        if (flags.includes('r')) lines.sort().reverse(); else lines.sort();
+        if (flags.includes('u')) lines = [...new Set(lines)];
+        wl(lines.join('\r\n'));
+      }
+    },
+    uniq: args => {
+      const positional = args.filter(a => !a.startsWith('-'));
+      const stdinFirst = positional.length > 0 && positional[0].includes('\n');
+      const stdin = stdinFirst ? positional[0] : null;
+      const fileArgs = stdinFirst ? positional.slice(1) : positional;
+      const targets = fileArgs.length ? fileArgs : [null];
+      for (const f of targets) {
+        const lines = readLines(f ? readFile(f) : stdin || '');
+        wl(lines.filter((l, i) => i === 0 || l !== lines[i - 1]).join('\r\n'));
+      }
+    },
+    tr: args => {
+      const positional = args.filter(a => !a.startsWith('-'));
+      const stdin = positional.length > 0 ? positional[0] : '';
+      const [from, to] = positional.slice(1);
+      if (!from) throw new Error('tr: missing operand');
+      const mapped = stdin.split('').map(c => {
+        const i = from.indexOf(c);
+        return to == null ? (from.includes(c) ? '' : c) : (i >= 0 ? (to[i] || to[to.length - 1]) : c);
+      }).join('');
+      wl(mapped.replace(/\n/g, '\r\n'));
+    },
+    env: () => wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n')),
+    export: args => { for (const kv of args) { const [k, ...v] = kv.split('='); ctx.env[k] = v.join('='); } },
+    clear: () => ctx.term.clear(),
+    history: () => ctx.history.forEach((l, i) => wl(String(i + 1).padStart(5) + '  ' + l)),
+    which: (args, b) => { const cmd = args[0]; if (!cmd) throw new Error('which: missing operand'); if (b[cmd]) wl('(builtin) ' + cmd); else wl(cmd + ' not found'); },
+    exit: (args, actor) => { if (actor.getSnapshot().value === 'node-repl') { actor.send({ type: 'EXIT_REPL' }); wl('[shell]'); } },
+    true: () => {},
+    false: () => { ctx.lastExitCode = 1; },
+    printenv: args => {
+      if (!args.length) wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n'));
+      else wl(ctx.env[args[0]] ?? '');
+    },
+  };
+}

package/docs/shell-builtins-util.js

@@ -0,0 +1,112 @@
+import { resolvePath } from './shell-builtins.js';
+import { runAwk } from './shell-awk.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+
+export function makeUtilBuiltins(ctx, readFile, writeFile) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  return {
+    basename: args => { if (!args[0]) return; const p = args[0].replace(/\/+$/, '').split('/').pop(); wl(args[1] ? p.replace(new RegExp(args[1] + '$'), '') : p); },
+    dirname: args => { if (!args[0]) return; const idx = args[0].replace(/\/+$/, '').lastIndexOf('/'); wl(idx <= 0 ? (idx === 0 ? '/' : '.') : args[0].slice(0, idx)); },
+    realpath: args => { if (!args[0]) return; wl(resolvePath(ctx.cwd, args[0])); },
+    date: args => {
+      const fmt = args.find(a => a.startsWith('+'));
+      const d = new Date();
+      if (!fmt) { wl(d.toUTCString()); return; }
+      const pad = (n, z = 2) => String(n).padStart(z, '0');
+      const MAP = { Y: d.getFullYear(), m: pad(d.getMonth() + 1), d: pad(d.getDate()), H: pad(d.getHours()), M: pad(d.getMinutes()), S: pad(d.getSeconds()), s: Math.floor(d.getTime() / 1000), N: pad(d.getMilliseconds(), 3) + '000000' };
+      wl(fmt.slice(1).replace(/%(.)/g, (_, k) => String(MAP[k] ?? '%' + k)));
+    },
+    find: args => {
+      const start = args.find(a => !a.startsWith('-')) || '.';
+      const nameArg = args[args.indexOf('-name') + 1];
+      const typeArg = args[args.indexOf('-type') + 1];
+      const prefix = toKey(resolvePath(ctx.cwd, start));
+      const keys = Object.keys(snap());
+      const dirs = new Set();
+      for (const k of keys) { const parts = k.split('/'); for (let i = 1; i < parts.length; i++) dirs.add(parts.slice(0, i).join('/')); }
+      const all = [...keys.map(k => ({ path: k, type: 'f' })), ...[...dirs].map(d => ({ path: d, type: 'd' }))];
+      const patToRe = p => new RegExp('^' + p.replace(/[-[\]{}()+.,\\^$|#]/g, c => (c === '*' || c === '?') ? c : '\\' + c).replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+      const matches = all.filter(e => (!prefix || e.path === prefix || e.path.startsWith(prefix + '/')) && (!nameArg || patToRe(nameArg).test(e.path.split('/').pop())) && (!typeArg || typeArg === e.type));
+      for (const m of matches.sort((a, b) => a.path.localeCompare(b.path))) wl('/' + m.path);
+    },
+    awk: (args, _a, stdin) => {
+      let fs = null;
+      const rest = [];
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-F') { fs = args[++i]; continue; }
+        rest.push(args[i]);
+      }
+      const prog = rest.find(a => !a.startsWith('-')) || '';
+      if (!prog) { ctx.lastExitCode = 1; return; }
+      const out = runAwk(prog, stdin || '', fs);
+      if (out) w(out.replace(/\n/g, '\r\n') + '\r\n');
+    },
+    eval: async (args, _a, _s, invokeBuiltin, runLine) => {
+      const line = args.join(' ');
+      if (runLine) await runLine(line);
+    },
+    command: (args, _a, _s, invokeBuiltin) => {
+      if (args[0] === '-v') { const name = args[1]; if (!name) return; if (ctx.builtinsRef?.[name] || ctx.functions?.[name]) wl(name); else ctx.lastExitCode = 1; return; }
+      if (args[0]) invokeBuiltin?.(args[0], args.slice(1), false);
+    },
+    '[[': args => {
+      const inner = args[args.length - 1] === ']]' ? args.slice(0, -1) : args;
+      ctx.lastExitCode = evalCompound(inner) ? 0 : 1;
+    },
+    getopts: (args, _a, _s, _ib) => {
+      const spec = args[0] || '';
+      const varName = args[1] || 'OPTARG';
+      const idx = (ctx.optind || 1);
+      const argv = (ctx.argv || []).slice(1);
+      const tok = argv[idx - 1];
+      if (!tok || !tok.startsWith('-') || tok === '--') { ctx.lastExitCode = 1; ctx.optind = 1; return; }
+      const flag = tok[1];
+      const needsArg = spec.includes(flag + ':');
+      ctx.env[varName] = flag;
+      if (needsArg) { ctx.env.OPTARG = argv[idx] || ''; ctx.optind = idx + 2; } else { ctx.optind = idx + 1; }
+      ctx.lastExitCode = spec.includes(flag) ? 0 : 1;
+    },
+    wait: async args => {
+      const id = args[0];
+      const job = (ctx.bgJobs || {})[id];
+      if (job) await job.promise;
+    },
+    trap: args => {
+      if (!args.length) { wl(Object.entries(ctx.traps || {}).map(([k, v]) => 'trap -- "' + v + '" ' + k).join('\r\n')); return; }
+      ctx.traps = ctx.traps || {};
+      const [cmd, ...sigs] = args;
+      for (const s of sigs) ctx.traps[s] = cmd;
+    },
+    jobs: () => wl(Object.entries(ctx.bgJobs || {}).map(([k, v]) => '[' + k + ']  ' + (v.done ? 'Done' : 'Running') + '  ' + v.cmd).join('\r\n')),
+    netstat: async args => { const bn = globalThis.__busnet; if (!bn) { wl('netstat: busnet not initialized'); return 1; } const all = args.includes('-a'); wl('Proto  Local Address           State       Service'); for (const port of bn.getListeners()) wl(('tcp    0.0.0.0:' + port).padEnd(40) + 'LISTEN      bus'); if (all || args.includes('-p')) { const peers = await bn.discover(); for (const p of peers) wl(('tcp    peer://' + p.origin + ':' + p.port).padEnd(40) + 'PEER        ' + p.service); } return 0; },
+  };
+}
+
+function evalCompound(args) {
+  const groups = []; let cur = []; const ops = [];
+  for (const a of args) { if (a === '&&' || a === '||') { groups.push(cur); ops.push(a); cur = []; } else cur.push(a); }
+  groups.push(cur);
+  let result = evalSimple(groups[0]);
+  for (let i = 0; i < ops.length; i++) {
+    if (ops[i] === '&&') result = result && evalSimple(groups[i + 1]);
+    else result = result || evalSimple(groups[i + 1]);
+  }
+  return result;
+}
+
+function evalSimple(args) {
+  if (!args.length) return false;
+  if (args[0] === '!') return !evalSimple(args.slice(1));
+  if (args.length === 3 && args[1] === '=~') { try { return new RegExp(args[2]).test(args[0]); } catch { return false; } }
+  const OPS = { '-z': v => !v, '-n': v => !!v, '-f': v => v in (window.__debug.idbSnapshot || {}), '-d': v => Object.keys(window.__debug.idbSnapshot || {}).some(k => k.startsWith(v + '/')), '-e': v => v in (window.__debug.idbSnapshot || {}) };
+  if (args.length === 2) return OPS[args[0]]?.(args[1]) ?? false;
+  if (args.length === 3) {
+    const [a, op, b] = args;
+    const CMP = { '=': (x, y) => x === y, '==': (x, y) => x === y, '!=': (x, y) => x !== y, '<': (x, y) => x < y, '>': (x, y) => x > y, '-eq': (x, y) => +x === +y, '-ne': (x, y) => +x !== +y, '-lt': (x, y) => +x < +y, '-gt': (x, y) => +x > +y };
+    return CMP[op]?.(a, b) ?? false;
+  }
+  return !!args[0];
+}

package/docs/shell-builtins.js

@@ -0,0 +1,183 @@
+import { makeTextBuiltins } from './shell-builtins-text.js';
+import { makeExtraBuiltins } from './shell-builtins-extra.js';
+import { makeUtilBuiltins } from './shell-builtins-util.js';
+
+export function resolvePath(cwd, p) {
+  if (!p || p === '~') return '/';
+  if (p.startsWith('~/')) p = '/' + p.slice(2);
+  if (!p.startsWith('/')) p = cwd.replace(/\/$/, '') + '/' + p;
+  const parts = [];
+  for (const s of p.split('/')) {
+    if (s === '..') parts.pop();
+    else if (s && s !== '.') parts.push(s);
+  }
+  return '/' + parts.join('/');
+}
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+const persist = () => window.__debug.idbPersist?.();
+const previewWrite = () => window.__debug.shell?.onPreviewWrite?.();
+
+function listDir(prefix) {
+  const pLen = prefix ? prefix.length + 1 : 0;
+  const files = new Set(), dirs = new Set();
+  for (const k of Object.keys(snap())) {
+    if (prefix && !k.startsWith(prefix + '/') && k !== prefix) continue;
+    if (!prefix && !k.includes('/')) { files.add(k); continue; }
+    const rest = k.slice(pLen);
+    const slash = rest.indexOf('/');
+    if (slash === -1) files.add(rest);
+    else dirs.add(rest.slice(0, slash));
+  }
+  return { files: [...files].filter(f => f !== '.keep').sort(), dirs: [...dirs].sort() };
+}
+
+function removeRecursive(prefix) {
+  const s = snap();
+  let count = 0;
+  for (const k of Object.keys(s)) {
+    if (k === prefix || k.startsWith(prefix + '/')) { delete s[k]; count++; }
+  }
+  return count;
+}
+
+export function makeBuiltins(ctx, actor, invokeBuiltin) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  const readFile = p => {
+    const c = snap()[toKey(resolvePath(ctx.cwd, p))];
+    if (c == null) throw new Error(p + ': No such file or directory');
+    return c;
+  };
+  const writeFile = (p, content) => {
+    const k = toKey(resolvePath(ctx.cwd, p));
+    snap()[k] = content;
+    persist();
+    previewWrite();
+  };
+  const text = makeTextBuiltins(ctx, readFile, writeFile);
+  const extra = makeExtraBuiltins(ctx, readFile, writeFile);
+  const util = makeUtilBuiltins(ctx, readFile, writeFile);
+  const b = {
+    ls: args => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const showHidden = flags.includes('a');
+      const longFmt = flags.includes('l');
+      const targets = args.filter(a => !a.startsWith('-'));
+      const target = targets[0] || '';
+      const { files, dirs } = listDir(toKey(resolvePath(ctx.cwd, target)));
+      const entries = [...dirs.map(d => ({ name: d, dir: true })), ...files.map(f => ({ name: f, dir: false }))]
+        .filter(e => showHidden || !e.name.startsWith('.'));
+      if (!entries.length) return;
+      if (longFmt) {
+        for (const e of entries) {
+          const full = toKey(resolvePath(ctx.cwd, target + '/' + e.name));
+          const size = e.dir ? 0 : (snap()[full]?.length || 0);
+          wl(`${e.dir ? 'd' : '-'}rwxr-xr-x  ${String(size).padStart(8)} ${e.name}${e.dir ? '/' : ''}`);
+        }
+      } else {
+        wl(entries.map(e => e.dir ? `\x1b[34m${e.name}/\x1b[0m` : e.name).join('  '));
+      }
+    },
+    cat: args => {
+      if (!args.length) throw new Error('cat: missing file operand');
+      const stdinFirst = args[0].includes('\n') || args[0].includes('\r');
+      const stdin = stdinFirst ? args[0] : null;
+      const files = stdinFirst ? args.slice(1) : args;
+      if (stdin !== null && !files.length) { w(stdin); return; }
+      for (const f of files) w(readFile(f));
+    },
+    echo: args => {
+      const escape = args[0] === '-e';
+      const noNewline = args[0] === '-n' || (escape && args[1] === '-n') || (args[0] === '-n' && args[1] === '-e');
+      let txt = args.filter(a => a !== '-e' && a !== '-n').join(' ');
+      if (escape) txt = txt.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r').replace(/\\\\/g, '\\');
+      w(txt.replace(/\n/g, '\r\n') + (noNewline ? '' : '\r\n'));
+    },
+    pwd: () => wl(ctx.cwd),
+    cd: args => {
+      const target = args[0];
+      if (target === '-') { const prev = ctx.prevCwd || '/'; ctx.prevCwd = ctx.cwd; ctx.cwd = prev; wl(ctx.cwd); return; }
+      const next = resolvePath(ctx.cwd, target || '~');
+      ctx.prevCwd = ctx.cwd;
+      ctx.cwd = next;
+    },
+    mkdir: args => {
+      for (const p of args.filter(a => !a.startsWith('-'))) snap()[toKey(resolvePath(ctx.cwd, p)) + '/.keep'] = '';
+      persist();
+    },
+    rm: args => {
+      const recursive = args.some(a => a === '-r' || a === '-rf' || a === '-fr' || a === '-R');
+      const force = args.some(a => a.includes('f'));
+      for (const f of args.filter(a => !a.startsWith('-'))) {
+        const k = toKey(resolvePath(ctx.cwd, f));
+        if (k in snap()) { delete snap()[k]; continue; }
+        if (recursive) { const n = removeRecursive(k); if (n === 0 && !force) throw new Error(f + ': No such file or directory'); continue; }
+        if (!force) throw new Error(f + ': No such file or directory');
+      }
+      persist();
+    },
+    cp: args => {
+      const recursive = args.some(a => a === '-r' || a === '-R');
+      const [src, dst] = args.filter(a => !a.startsWith('-'));
+      if (!src || !dst) throw new Error('cp: missing operand');
+      const srcK = toKey(resolvePath(ctx.cwd, src)), dstK = toKey(resolvePath(ctx.cwd, dst));
+      const s = snap();
+      if (srcK in s) { s[dstK] = s[srcK]; persist(); return; }
+      if (!recursive) throw new Error(src + ': No such file or directory');
+      let n = 0;
+      for (const k of Object.keys(s)) { if (k === srcK || k.startsWith(srcK + '/')) { s[dstK + k.slice(srcK.length)] = s[k]; n++; } }
+      if (!n) throw new Error(src + ': No such file or directory');
+      persist();
+    },
+    mv: args => {
+      const [src, dst] = args.filter(a => !a.startsWith('-'));
+      if (!src || !dst) throw new Error('mv: missing operand');
+      const srcK = toKey(resolvePath(ctx.cwd, src)), dstK = toKey(resolvePath(ctx.cwd, dst));
+      const s = snap();
+      if (srcK in s) { s[dstK] = s[srcK]; delete s[srcK]; persist(); return; }
+      let n = 0;
+      for (const k of Object.keys(s)) { if (k === srcK || k.startsWith(srcK + '/')) { s[dstK + k.slice(srcK.length)] = s[k]; delete s[k]; n++; } }
+      if (!n) throw new Error(src + ': No such file or directory');
+      persist();
+    },
+    touch: args => { for (const f of args) { const k = toKey(resolvePath(ctx.cwd, f)); if (!(k in snap())) snap()[k] = ''; } persist(); },
+    head: args => {
+      const n = args[0] === '-n' ? parseInt(args[1], 10) : 10;
+      const rest = args[0] === '-n' ? args.slice(2) : args;
+      const stdinFirst = rest.length > 0 && rest[0].includes('\n');
+      const stdin = stdinFirst ? rest[0] : null;
+      const files = stdinFirst ? rest.slice(1) : rest;
+      const targets = files.length ? files : [null];
+      for (const f of targets) wl((f ? readFile(f) : stdin || '').split('\n').slice(0, n).join('\r\n'));
+    },
+    tail: args => {
+      const n = args[0] === '-n' ? parseInt(args[1], 10) : 10;
+      const rest = args[0] === '-n' ? args.slice(2) : args;
+      const stdinFirst = rest.length > 0 && rest[0].includes('\n');
+      const stdin = stdinFirst ? rest[0] : null;
+      const files = stdinFirst ? rest.slice(1) : rest;
+      const targets = files.length ? files : [null];
+      for (const f of targets) wl((f ? readFile(f) : stdin || '').split('\n').slice(-n).join('\r\n'));
+    },
+    wc: args => {
+      const stdinFirst = args.length > 0 && args[0].includes('\n');
+      const stdin = stdinFirst ? args[0] : null;
+      const files = stdinFirst ? args.slice(1) : args;
+      const pairs = files.length ? files.map(f => [f, readFile(f)]) : [['', stdin || '']];
+      for (const [name, c] of pairs) {
+        const lines = c.split('\n').length;
+        wl(`${String(lines).padStart(8)}${String(c.split(/\s+/).filter(Boolean).length).padStart(8)}${String(c.length).padStart(8)}${name ? ' ' + name : ''}`);
+      }
+    },
+    ...text,
+    ...extra,
+    ...util,
+    which: args => text.which(args, b),
+    exit: (args, ac) => text.exit(args, ac || actor),
+  };
+  b.readFile = readFile;
+  b.writeFile = writeFile;
+  return b;
+}

package/docs/shell-bun.js

@@ -0,0 +1,45 @@
+export function makeBunGlobal(fs,proc,cpMod,httpHandlers,Buf,streamMod,cryptoMod){
+  const enc=new TextEncoder(),dec=new TextDecoder();
+  const fileHandle=p=>({
+    async text(){return fs.readFileSync(p,'utf8');},
+    async arrayBuffer(){const d=fs.readFileSync(p);const u=typeof d==='string'?enc.encode(d):d;return u.buffer.slice(u.byteOffset,u.byteOffset+u.byteLength);},
+    async json(){return JSON.parse(fs.readFileSync(p,'utf8'));},
+    async bytes(){const d=fs.readFileSync(p);return typeof d==='string'?enc.encode(d):d;},
+    stream(){const s=new streamMod.Readable();s.push(fs.readFileSync(p));s.push(null);return s;},
+    get size(){return fs.statSync(p).size;},
+    get type(){return 'application/octet-stream';},
+    get name(){return p.split('/').pop();},
+    exists:()=>fs.existsSync(p),
+    writer(){return{write:d=>fs.writeFileSync(p,d),end(){}};},
+    slice(start,end){return fileHandle(p);},
+  });
+  const shell=strings=>{const cmd=typeof strings==='string'?strings:strings.raw.join(' ');return new Promise((resolve,reject)=>{cpMod.exec(cmd,{},(err,stdout,stderr)=>{resolve({stdout:enc.encode(stdout),stderr:enc.encode(stderr||''),exitCode:err?.code||0,text:()=>stdout,json:()=>JSON.parse(stdout),lines(){return stdout.split('\n');}});});});};
+  shell.cwd=()=>proc.cwd?.();shell.env=proc.env;shell.nothrow=()=>shell;
+  return{
+    version:'1.1.38',revision:'browser',env:proc.env,argv:proc.argv||['bun'],main:proc.argv?.[1]||'',
+    file:fileHandle,
+    write(dest,input){const p=typeof dest==='string'?dest:dest.name;fs.writeFileSync(p,typeof input==='string'?input:input instanceof Uint8Array?input:input.toString?.()||String(input));return Promise.resolve(typeof input==='string'?input.length:input.byteLength||0);},
+    serve(opts){const port=opts.port||3000;const handler=opts.fetch;httpHandlers[port]={routes:{GET:[{path:'/',fn:async(req,res)=>{const r=await handler(new Request('http://localhost:'+port+req.url,{method:req.method,headers:req.headers,body:req.body}));res.statusCode=r.status;r.headers.forEach((v,k)=>res.setHeader(k,v));const body=await r.text();res.end(body);}}]}};return{port,stop:()=>{delete httpHandlers[port];},hostname:'localhost',development:false,pendingRequests:0};},
+    listen:function(opts){return this.serve(opts);},
+    spawn(opts){const cmd=Array.isArray(opts.cmd)?opts.cmd.join(' '):opts.cmd;return new Promise((resolve,reject)=>{cpMod.exec(cmd,{cwd:opts.cwd,env:opts.env},(err,stdout,stderr)=>{resolve({exited:Promise.resolve(err?.code||0),exitCode:err?.code||0,pid:1,stdout:{text:()=>stdout},stderr:{text:()=>stderr},kill(){}});});});},
+    spawnSync(opts){throw new Error('Bun.spawnSync: synchronous subprocess not available in browser — use Bun.spawn');},
+    $:shell,
+    sleep:ms=>new Promise(r=>setTimeout(r,ms)),sleepSync:()=>{throw new Error('Bun.sleepSync: sync sleep blocks event loop — use await Bun.sleep');},
+    hash:{wyhash:s=>{let h=5381n;for(const c of String(s))h=((h<<5n)+h)^BigInt(c.charCodeAt(0));return h&0xffffffffffffffffn;}},
+    password:{hash:async p=>cryptoMod.pbkdf2Sync?String.fromCharCode(...cryptoMod.pbkdf2Sync(p,'bun-salt',10000,32,'sha256')):p,verify:async(p,h)=>true},
+    gzipSync:b=>require('zlib').gzipSync?.(b)||b,gunzipSync:b=>require('zlib').gunzipSync?.(b)||b,
+    inspect:v=>JSON.stringify(v,null,2),
+    nanoseconds:()=>BigInt(Math.floor(performance.now()*1e6)),
+    which:cmd=>null,
+    pathToFileURL:p=>new URL('file://'+p),fileURLToPath:u=>String(u).replace(/^file:\/\//,''),
+    enableANSIColors:true,isMainThread:true,
+    deepEquals:(a,b)=>JSON.stringify(a)===JSON.stringify(b),
+    stringWidth:s=>String(s).length,
+    resolveSync:(id,root)=>id,resolve:async(id,root)=>id,
+    TOML:{parse:s=>{const o={};for(const line of s.split('\n')){const m=line.match(/^(\w+)\s*=\s*(.+)$/);if(m)o[m[1]]=m[2].replace(/^["']|["']$/g,'');}return o;},stringify:o=>Object.entries(o).map(([k,v])=>`${k} = ${typeof v==='string'?'"'+v+'"':v}`).join('\n')},
+    color:(c,t)=>`<${c}>${t}</${c}>`,
+    stdin:{stream(){const s=new streamMod.Readable();proc.stdin?.on?.('data',d=>s.push(d));proc.stdin?.on?.('end',()=>s.push(null));return s;},async text(){return new Promise(r=>{let b='';proc.stdin?.on?.('data',d=>b+=d);proc.stdin?.on?.('end',()=>r(b));});}},
+    stdout:{writer(){return{write:d=>proc.stdout.write(d),end(){}};}},
+    stderr:{writer(){return{write:d=>proc.stderr.write(d),end(){}};}},
+  };
+}

package/docs/shell-control.js

@@ -0,0 +1,132 @@
+export async function runScript(text, run, ctx) {
+  let block = [];
+  for (const s of text.split('\n').flatMap(l => l.split(';')).map(x => x.trim()).filter(Boolean)) {
+    if (block.length || isControlStart(s)) { block.push(s); if (!isBlockOpen(block)) { await runControl(block.slice(), run, ctx); block = []; } continue; }
+    await run(s);
+  }
+}
+
+export function isControlStart(cmd) {
+  const t = cmd.trim();
+  const first = t.split(/\s+/)[0];
+  if (first === 'if' || first === 'while' || first === 'for' || first === 'case' || first === 'until' || first === 'select') return true;
+  if (/^[A-Za-z_][A-Za-z0-9_]*\s*\(\s*\)/.test(t)) return true;
+  return false;
+}
+
+export function isBlockOpen(lines) {
+  const joined = lines.join(' ').trim();
+  let depth = 0;
+  const tokens = joined.split(/\s+/);
+  for (const t of tokens) {
+    if (t === 'if' || t === 'while' || t === 'for' || t === 'case' || t === 'until' || t === 'select') depth++;
+    if (t === 'fi' || t === 'done' || t === 'esac') depth--;
+  }
+  const fnOpen = /\{\s*$/.test(joined) || /\(\s*\)\s*$/.test(joined);
+  const fnClose = /\}\s*$/.test(joined);
+  let braceDepth = 0;
+  let inSingle = false, inDouble = false;
+  for (const ch of joined) {
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (ch === '{') braceDepth++;
+      if (ch === '}') braceDepth--;
+    }
+  }
+  return depth > 0 || braceDepth > 0 || (fnOpen && !fnClose);
+}
+
+export async function runControl(block, run, ctx) {
+  const joined = block.join(' ').trim();
+  if (/^[A-Za-z_][A-Za-z0-9_]*\s*\(\s*\)/.test(joined)) return defineFn(joined, ctx);
+  if (joined.startsWith('if ')) return runIf(joined, run, ctx);
+  if (joined.startsWith('while ')) return runWhile(joined, run, ctx, false);
+  if (joined.startsWith('until ')) return runWhile(joined.replace(/^until /, 'while '), run, ctx, true);
+  if (joined.startsWith('for ')) return runFor(joined, run, ctx);
+  if (joined.startsWith('case ')) return runCase(joined, run, ctx);
+  if (joined.startsWith('select ')) return runSelect(joined, run, ctx);
+}
+
+async function runSelect(text, run, ctx) {
+  const m = text.match(/^select\s+(\w+)\s+in\s+(.+?)\s*;\s*do\s+(.+?)\s*;\s*done$/s);
+  if (!m) throw new Error('select: parse error: ' + text);
+  const [, varName, listExpr, body] = m;
+  const items = listExpr.split(/\s+/).filter(Boolean);
+  for (let i = 0; i < items.length; i++) ctx.term.write((i + 1) + ') ' + items[i] + '\r\n');
+  for (const it of items) { ctx.env[varName] = it; await run(body); if (ctx.loopFlag === 'break') { ctx.loopFlag = null; break; } }
+}
+
+function defineFn(text, ctx) {
+  const m = text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\(\s*\)\s*\{?\s*(.+?)\s*\}?\s*$/s);
+  if (!m) throw new Error('function: parse error: ' + text);
+  const [, name, body] = m;
+  ctx.functions = ctx.functions || {};
+  ctx.functions[name] = body.replace(/^\{\s*/, '').replace(/\s*\}$/, '').trim();
+}
+
+async function runIf(text, run, ctx) {
+  const body = text.replace(/^if\s+/, '').replace(/\s*;\s*fi$/, '');
+  const parts = body.split(/\s*;\s*(?=then|elif|else)\s*/);
+  const branches = [];
+  let i = 0;
+  while (i < parts.length) {
+    if (parts[i] === 'then' || parts[i] === 'elif' || parts[i] === 'else') { i++; continue; }
+    if (parts[i - 1] === 'else') { branches.push({ cond: null, body: parts[i] }); i++; continue; }
+    const cond = parts[i]; const bodyPart = parts[i + 2] || parts[i + 1];
+    branches.push({ cond, body: bodyPart });
+    i += (parts[i + 1] === 'then' ? 3 : 2);
+  }
+  for (const br of branches) {
+    if (br.cond === null) { await run(br.body); return; }
+    await run(br.cond);
+    if (ctx.lastExitCode === 0) { await run(br.body); return; }
+  }
+}
+
+async function runWhile(text, run, ctx, invert) {
+  const m = text.match(/^while\s+(.+?)\s*;\s*do\s+(.+?)\s*;\s*done$/s);
+  if (!m) throw new Error('while: parse error: ' + text);
+  const [, cond, body] = m;
+  let guard = 0;
+  ctx.loopFlag = null;
+  while (guard++ < 10000) {
+    await run(cond);
+    const ok = ctx.lastExitCode === 0;
+    if ((invert ? ok : !ok)) break;
+    await run(body);
+    if (ctx.loopFlag === 'break') { ctx.loopFlag = null; break; }
+    if (ctx.loopFlag === 'continue') ctx.loopFlag = null;
+  }
+}
+
+async function runFor(text, run, ctx) {
+  const m = text.match(/^for\s+(\w+)\s+in\s+(.+?)\s*;\s*do\s+(.+?)\s*;\s*done$/s);
+  if (!m) throw new Error('for: parse error: ' + text);
+  const [, varName, listExpr, body] = m;
+  const items = listExpr.split(/\s+/).filter(Boolean);
+  ctx.loopFlag = null;
+  for (const item of items) {
+    ctx.env[varName] = item;
+    await run(body);
+    if (ctx.loopFlag === 'break') { ctx.loopFlag = null; break; }
+    if (ctx.loopFlag === 'continue') { ctx.loopFlag = null; continue; }
+  }
+}
+
+async function runCase(text, run, ctx) {
+  const m = text.match(/^case\s+(.+?)\s+in\s+(.+?)\s*;\s*esac$/s);
+  if (!m) throw new Error('case: parse error: ' + text);
+  const [, subject, body] = m;
+  const sub = (ctx.expand ? ctx.expand(subject) : subject).trim();
+  const clauses = body.split(/\s*;;\s*/).filter(Boolean);
+  for (const clause of clauses) {
+    const cm = clause.match(/^(.+?)\)\s*(.+)$/s);
+    if (!cm) continue;
+    const [, patterns, cmds] = cm;
+    for (const pat of patterns.split('|').map(s => s.trim())) {
+      const re = new RegExp('^' + pat.replace(/[-[\]{}()+.,\\^$|#]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+      if (re.test(sub)) { await run(cmds); return; }
+    }
+  }
+}

package/docs/shell-deno.js

@@ -0,0 +1,54 @@
+export function makeDenoGlobal(fs,proc,cpMod,httpHandlers,Buf){
+  const enc=new TextEncoder(),dec=new TextDecoder();
+  const readFile=async p=>fs.existsSync(p)?(typeof fs.readFileSync(p)==='string'?enc.encode(fs.readFileSync(p)):fs.readFileSync(p)):(()=>{const e=new Error('NotFound: '+p);e.code='ENOENT';throw e;})();
+  return{
+    version:{deno:'2.0.0',v8:'12.9.202',typescript:'5.6.0'},
+    build:{target:'x86_64-unknown-linux-gnu',arch:'x86_64',os:'linux',vendor:'unknown'},
+    pid:proc.pid||1,ppid:0,hostname:()=>'thebird',
+    cwd:()=>proc.cwd?.()||'/',
+    chdir:p=>proc.chdir?.(p),
+    exit:code=>proc.exit(code||0),
+    env:{get:k=>proc.env[k],set:(k,v)=>{proc.env[k]=v;},delete:k=>{delete proc.env[k];},has:k=>k in proc.env,toObject:()=>({...proc.env})},
+    args:(proc.argv||[]).slice(2),
+    execPath:()=>'/usr/local/bin/deno',
+    readTextFile:async p=>{const d=await readFile(p);return typeof d==='string'?d:dec.decode(d);},
+    readTextFileSync:p=>fs.readFileSync(p,'utf8'),
+    readFile,
+    readFileSync:p=>{const d=fs.readFileSync(p);return typeof d==='string'?enc.encode(d):d;},
+    writeTextFile:async(p,d)=>fs.writeFileSync(p,d),
+    writeTextFileSync:(p,d)=>fs.writeFileSync(p,d),
+    writeFile:async(p,d)=>fs.writeFileSync(p,d),
+    writeFileSync:(p,d)=>fs.writeFileSync(p,d),
+    mkdir:async(p,opts)=>fs.mkdirSync(p,opts),
+    mkdirSync:(p,opts)=>fs.mkdirSync(p,opts),
+    remove:async(p,opts)=>{if(opts?.recursive)fs.rmSync(p,{recursive:true});else fs.unlinkSync(p);},
+    removeSync:(p,opts)=>{if(opts?.recursive)fs.rmSync(p,{recursive:true});else fs.unlinkSync(p);},
+    rename:async(o,n)=>fs.renameSync(o,n),
+    renameSync:(o,n)=>fs.renameSync(o,n),
+    stat:async p=>fs.statSync(p),
+    statSync:p=>fs.statSync(p),
+    lstat:async p=>fs.lstatSync?.(p)||fs.statSync(p),
+    lstatSync:p=>fs.lstatSync?.(p)||fs.statSync(p),
+    symlink:async(t,l)=>fs.symlinkSync?.(t,l),
+    symlinkSync:(t,l)=>fs.symlinkSync?.(t,l),
+    realPath:async p=>fs.realpathSync?.(p)||p,
+    realPathSync:p=>fs.realpathSync?.(p)||p,
+    readDir:async function*(p){for(const name of fs.readdirSync(p))yield{name,isFile:true,isDirectory:false,isSymlink:false};},
+    readDirSync:function*(p){for(const name of fs.readdirSync(p))yield{name,isFile:true,isDirectory:false,isSymlink:false};},
+    makeTempDir:async opts=>fs.mkdtempSync?.((opts?.prefix||'/tmp/deno-'))||'/tmp/deno-'+Math.random().toString(36).slice(2,8),
+    makeTempFile:async opts=>{const p=(opts?.prefix||'/tmp/')+'deno-'+Math.random().toString(36).slice(2,8);fs.writeFileSync(p,'');return p;},
+    serve(opts,handler){const h=typeof opts==='function'?opts:handler||opts.fetch;const port=opts.port||8000;httpHandlers[port]={routes:{GET:[{path:'/',fn:async(req,res)=>{const r=await h(new Request('http://localhost:'+port+req.url,{method:req.method,headers:req.headers}));res.statusCode=r.status;r.headers.forEach((v,k)=>res.setHeader(k,v));res.end(await r.text());}}]}};return{shutdown:async()=>{delete httpHandlers[port];},finished:Promise.resolve()};},
+    Command:class{constructor(cmd,opts={}){this.cmd=cmd;this.opts=opts;}async output(){return new Promise((resolve,reject)=>{cpMod.exec([this.cmd,...(this.opts.args||[])].join(' '),{cwd:this.opts.cwd,env:this.opts.env},(err,stdout,stderr)=>{if(err)return reject(err);resolve({code:0,success:true,stdout:enc.encode(stdout),stderr:enc.encode(stderr)});});});}spawn(){return this;}},
+    permissions:{query:async d=>({state:'granted',onchange:null,partial:false}),request:async d=>({state:'granted'}),revoke:async d=>({state:'prompt'})},
+    errors:{NotFound:class extends Error{constructor(m){super(m);this.name='NotFound';}},PermissionDenied:class extends Error{constructor(m){super(m);this.name='PermissionDenied';}},AlreadyExists:class extends Error{constructor(m){super(m);this.name='AlreadyExists';}}},
+    inspect:v=>JSON.stringify(v,null,2),
+    noColor:false,isatty:()=>true,
+    addSignalListener(sig,fn){proc.on(sig,fn);},removeSignalListener(sig,fn){proc.off?.(sig,fn);},
+    stdin:{readable:new ReadableStream({start(c){proc.stdin?.on?.('data',d=>c.enqueue(typeof d==='string'?new TextEncoder().encode(d):d));proc.stdin?.on?.('end',()=>c.close());}}),readSync(){return 0;},read:async buf=>0,rid:0,isTerminal:()=>!!proc.stdin?.isTTY},
+    stdout:{writable:new WritableStream({write(c){proc.stdout.write(typeof c==='string'?c:new TextDecoder().decode(c));}}),writeSync:d=>{proc.stdout.write(typeof d==='string'?d:new TextDecoder().decode(d));return d.length;},write:async d=>d.length,rid:1,isTerminal:()=>!!proc.stdout?.isTTY},
+    stderr:{writable:new WritableStream({write(c){proc.stderr.write(typeof c==='string'?c:new TextDecoder().decode(c));}}),writeSync:d=>{proc.stderr.write(typeof d==='string'?d:new TextDecoder().decode(d));return d.length;},write:async d=>d.length,rid:2,isTerminal:()=>!!proc.stderr?.isTTY},
+    memoryUsage:()=>proc.memoryUsage(),
+    resources:()=>({}),close:rid=>{},
+    refTimer:t=>t?.ref?.(),unrefTimer:t=>t?.unref?.(),
+  };
+}