thebird 1.2.79 → 1.2.81

package/docs/index.html

@@ -5,8 +5,6 @@
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <meta name="version" content="1.2.23">
 <title>thebird — TUI</title>
-<script>window.coi = { coepDegrade: () => false };</script>
-<script src="coi-serviceworker.js"></script>
 <link rel="stylesheet" href="vendor/xterm.css" />
 <link rel="stylesheet" href="tui.css" />
 </head>
@@ -42,24 +40,43 @@ function callExpressRoute(path, method) {
   const match = routes.find(r => r.path === '*' || r.path === path || path.startsWith(r.path));
   if (!match) return null;
   return new Promise(resolve => {
+    let done = false;
+    const finish = (status, body, ct) => { if (done) return; done = true; resolve({ status, body, ct }); };
     const res = {
       _body: '', _status: 200, _ct: 'text/html',
-      send(b) { this._body = b; resolve({ status: this._status, body: this._body, ct: this._ct }); },
+      writeHead(code, headers) { this._status = code; if (headers?.['Content-Type']) this._ct = headers['Content-Type']; return this; },
+      setHeader(k, v) { if (k.toLowerCase() === 'content-type') this._ct = v; return this; },
+      write(chunk) { this._body += String(chunk); return true; },
+      end(chunk) { if (chunk != null) this._body += String(chunk); finish(this._status, this._body, this._ct); },
+      send(b) { this._body = typeof b === 'string' ? b : JSON.stringify(b); finish(this._status, this._body, this._ct); },
       json(o) { this._ct = 'application/json'; this.send(JSON.stringify(o)); },
       status(n) { this._status = n; return this; },
     };
-    try { match.fn({ method: method || 'GET', path, query: {}, headers: {} }, res); }
-    catch(e) { resolve({ status: 500, body: e.message, ct: 'text/plain' }); }
+    const req = { method: method || 'GET', url: path, path, query: {}, headers: {}, [Symbol.asyncIterator]: async function* () {} };
+    try {
+      const r = match.fn(req, res);
+      if (r && typeof r.then === 'function') r.catch(e => finish(500, e.message, 'text/plain'));
+    } catch(e) { finish(500, e.message, 'text/plain'); }
+    setTimeout(() => finish(res._status, res._body, res._ct), 5000);
   });
 }
 async function refreshPreview() {
   const iframe = document.getElementById('preview-frame');
   if (!iframe) return;
+  const swReady = window.__debug?.sw?.registered;
+  const handlers = window.__debug?.shell?.httpHandlers || {};
+  const hasServer = Object.keys(handlers).length > 0;
+  if (swReady && hasServer) {
+    const target = './preview/';
+    if (!iframe.src || !iframe.src.includes('/preview/')) iframe.src = target;
+    else iframe.contentWindow?.location.reload();
+    return;
+  }
   const result = await callExpressRoute('/');
   if (result) { iframe.srcdoc = result.body; return; }
   const snap = window.__debug?.idbSnapshot || {};
   if (snap['index.html']) { iframe.srcdoc = snap['index.html']; return; }
-  iframe.srcdoc = '<pre style="color:#33ff33;padding:1ch;font-family:monospace">No express app running.\nRun node app.js in terminal.</pre>';
+  iframe.srcdoc = '<pre style="color:#33ff33;padding:1ch;font-family:monospace">No express app running.\nRun: node server.js</pre>';
 }
 function switchTab(t) {
   ['chat', 'term', 'preview'].forEach(id => {

package/docs/kilo-fs-mirror.js

@@ -0,0 +1,15 @@
+export async function mirrorFromSandbox(fsBase, _touchedPaths) {
+  const listRes = await fetch(fsBase + '/__list');
+  if (!listRes.ok) return [];
+  const relFiles = await listRes.json();
+  const snap = window.__debug.idbSnapshot || (window.__debug.idbSnapshot = {});
+  const mirrored = [];
+  for (const rel of relFiles) {
+    const r = await fetch(fsBase + '/' + rel);
+    if (!r.ok) continue;
+    const content = await r.text();
+    if (snap[rel] !== content) { snap[rel] = content; mirrored.push(rel); }
+  }
+  if (mirrored.length) { window.__debug.idbPersist?.(); window.__debug.shell?.onPreviewWrite?.(); }
+  return mirrored;
+}

package/docs/kilo-http-stream.js

@@ -0,0 +1,47 @@
+import { mirrorFromSandbox } from './kilo-fs-mirror.js';
+
+export async function* streamKiloHTTP({ url, model, messages }) {
+  yield { type: 'start-step' };
+  const base = (url || 'http://localhost:4780').replace(/\/$/, '');
+  const fsBase = base.replace(/:\d+$/, ':4781');
+  let sessRes;
+  try { sessRes = await fetch(base + '/session', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' }); }
+  catch (e) { throw new Error('kilo serve not reachable at ' + base + ' — start it with: node start-kilo.js --origin ' + location.origin); }
+  if (!sessRes.ok) throw new Error('kilo /session ' + sessRes.status + ': ' + await sessRes.text());
+  const { id: sessionId } = await sessRes.json();
+  Object.assign(window.__debug = window.__debug || {}, { kilo: { sessionId, url: base, fsBase, writes: [], lastStatus: null } });
+
+  const es = new EventSource(base + '/event');
+  const pendingWrites = new Set();
+  es.onmessage = (ev) => {
+    try {
+      const msg = JSON.parse(ev.data);
+      if (msg.type === 'message.part.updated') {
+        const part = msg.properties?.part;
+        if (part?.type === 'tool' && part.state?.status === 'completed' && (part.tool === 'write' || part.tool === 'edit')) {
+          const abs = part.state.input?.filePath;
+          if (abs) pendingWrites.add(abs);
+        }
+      }
+    } catch (_) {}
+  };
+
+  const userText = messages.filter(m => m.role === 'user').map(m =>
+    typeof m.content === 'string' ? m.content : (m.content || []).filter(b => b.type === 'text').map(b => b.text).join('')
+  ).join('\n');
+
+  const body = { parts: [{ type: 'text', text: userText }], providerID: 'kilo', modelID: model || 'x-ai/grok-code-fast-1:optimized:free' };
+  const msgRes = await fetch(base + '/session/' + sessionId + '/message', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  window.__debug.kilo.lastStatus = msgRes.status;
+  if (!msgRes.ok) { es.close(); throw new Error('kilo message ' + msgRes.status + ': ' + await msgRes.text()); }
+  const result = await msgRes.json();
+  window.__debug.kilo.lastResult = result;
+  es.close();
+  const mirrored = await mirrorFromSandbox(fsBase, [...pendingWrites]);
+  window.__debug.kilo.writes = mirrored;
+  if (mirrored.length) window.refreshPreview?.();
+  const textParts = (result.parts || []).filter(p => p.type === 'text');
+  for (const tp of textParts) yield { type: 'text-delta', textDelta: tp.text };
+  if (mirrored.length) yield { type: 'text-delta', textDelta: '\n\n[mirrored to preview: ' + mirrored.join(', ') + ']' };
+  yield { type: 'finish-step', finishReason: result.info?.finish || 'stop' };
+}

package/docs/node-builtins.js

@@ -103,6 +103,16 @@ export function createFs() {
       snap()[toKey(resolveP(d))] = src;
       persist();
     },
+    rmSync: (p, opts = {}) => {
+      const key = toKey(resolveP(p)); const s = snap();
+      if (key in s) { delete s[key]; persist(); return; }
+      if (opts.recursive) { for (const k of Object.keys(s)) if (k === key || k.startsWith(key + '/')) delete s[k]; persist(); return; }
+      if (!opts.force) throw Object.assign(new Error('ENOENT: ' + p), { code: 'ENOENT' });
+    },
+    rmdirSync: (p, opts = {}) => { const key = toKey(resolveP(p)); for (const k of Object.keys(snap())) if (k.startsWith(key + '/')) delete snap()[k]; persist(); },
+    accessSync: p => { if (!(toKey(resolveP(p)) in snap())) throw Object.assign(new Error('ENOENT: ' + p), { code: 'ENOENT' }); },
+    realpathSync: p => resolveP(p),
+    promises: null,
   };
 }
 
@@ -153,6 +163,17 @@ export function createBuffer() {
     }
     toJSON() { return { type: 'Buffer', data: [...this] }; }
     slice(s, e) { return Buf.from(super.slice(s, e)); }
+    subarray(s, e) { return Buf.from(super.subarray(s, e)); }
+    equals(o) { if (!(o instanceof Uint8Array) || o.length !== this.length) return false; for (let i = 0; i < this.length; i++) if (this[i] !== o[i]) return false; return true; }
+    compare(o) { const l = Math.min(this.length, o.length); for (let i = 0; i < l; i++) { if (this[i] < o[i]) return -1; if (this[i] > o[i]) return 1; } return this.length === o.length ? 0 : this.length < o.length ? -1 : 1; }
+    indexOf(v, fromIdx = 0) { const bytes = typeof v === 'string' ? new TextEncoder().encode(v) : v instanceof Uint8Array ? v : new Uint8Array([v]); outer: for (let i = fromIdx; i <= this.length - bytes.length; i++) { for (let j = 0; j < bytes.length; j++) if (this[i + j] !== bytes[j]) continue outer; return i; } return -1; }
+    includes(v) { return this.indexOf(v) !== -1; }
+    write(str, offset = 0, length, encoding) { if (typeof offset === 'string') { encoding = offset; offset = 0; } const bytes = new TextEncoder().encode(str); const n = Math.min(bytes.length, this.length - offset, length ?? bytes.length); this.set(bytes.subarray(0, n), offset); return n; }
+    readUInt8(o = 0) { return this[o]; }
+    readUInt16BE(o = 0) { return (this[o] << 8) | this[o + 1]; }
+    readUInt16LE(o = 0) { return this[o] | (this[o + 1] << 8); }
+    readUInt32BE(o = 0) { return ((this[o] * 0x1000000) + (this[o + 1] << 16) | (this[o + 2] << 8) | this[o + 3]) >>> 0; }
+    writeUInt8(v, o = 0) { this[o] = v & 0xff; return o + 1; }
   }
   Buf.from = (d, enc) => {
     if (d instanceof Uint8Array) return new Buf(d);
@@ -166,5 +187,8 @@ export function createBuffer() {
   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;
+  Buf.compare = (a, b) => a.compare(b);
+  Buf.allocUnsafe = n => new Buf(n);
+  Buf.poolSize = 8192;
   return Buf;
 }

package/docs/preview/index.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html><head><meta charset="UTF-8"><title>preview — bootstrap</title>
+<style>body{font-family:monospace;background:#000;color:#33ff33;padding:2ch;margin:0}</style></head>
+<body>
+<p id="msg">bootstrapping preview...</p>
+<script>
+(async () => {
+  const msg = document.getElementById('msg');
+  if (navigator.serviceWorker.controller) {
+    msg.textContent = 'SW already controls — reloading to fetch content...';
+    location.reload();
+    return;
+  }
+  msg.textContent = 'waiting for SW to activate...';
+  try {
+    await navigator.serviceWorker.ready;
+    let tries = 0;
+    while (!navigator.serviceWorker.controller && tries++ < 20) {
+      await new Promise(r => setTimeout(r, 100));
+    }
+    if (navigator.serviceWorker.controller) {
+      msg.textContent = 'SW ready — fetching real content...';
+      location.reload();
+    } else {
+      msg.textContent = 'SW registered but not controlling. Ensure preview-sw.js is at /thebird/preview-sw.js.';
+    }
+  } catch (e) {
+    msg.textContent = 'SW error: ' + e.message;
+  }
+})();
+</script>
+</body></html>

package/docs/preview-sw-client.js

@@ -22,21 +22,52 @@ export async function registerPreviewSW() {
 }
 
 navigator.serviceWorker?.addEventListener('message', e => {
+  if (e.data?.type === 'SW_STREAM_READ') {
+    const path = e.data.path;
+    const procsub = path.match(/^\/procsub\/(\d+)$/);
+    if (procsub && window.__debug?.shell?.procsubRead) {
+      const data = window.__debug.shell.procsubRead(procsub[1]);
+      e.ports[0]?.postMessage({ data: data || '', found: data != null });
+      return;
+    }
+    const fdM = path.match(/^\/dev\/fd\/(\d+)$/);
+    if (fdM && window.__debug?.shell?.fdRead) {
+      try { const data = window.__debug.shell.fdRead(fdM[1]); e.ports[0]?.postMessage({ data: data || '', found: true }); }
+      catch { e.ports[0]?.postMessage({ data: '', found: false }); }
+      return;
+    }
+    e.ports[0]?.postMessage({ found: false });
+    return;
+  }
   if (e.data?.type !== 'EXPRESS_REQUEST') return;
-  const { path, method } = e.data;
+  const { path, method, body: reqBody, headers: reqHeaders } = e.data;
   const replyPort = e.ports[0];
   const handlers = window.__debug?.shell?.httpHandlers || {};
   const app = Object.values(handlers)[0];
-  if (!app?.routes) { replyPort.postMessage({ status: 404, body: 'no express app' }); return; }
+  if (!app?.routes) { replyPort.postMessage({ status: 503, body: '<h1>503</h1><p>no server running — run <code>node server.js</code> in terminal</p>', contentType: 'text/html' }); return; }
   const routes = app.routes[method] || [];
   const match = routes.find(r => r.path === '*' || r.path === path || path.startsWith(r.path));
-  if (!match) { replyPort.postMessage({ status: 404, body: 'no route for ' + path }); return; }
+  if (!match) { replyPort.postMessage({ status: 404, body: 'no route for ' + method + ' ' + path, contentType: 'text/plain' }); return; }
+  let done = false;
+  const finish = (status, body, ct) => { if (done) return; done = true; replyPort.postMessage({ status, body, contentType: ct }); };
   const res = {
     _body: '', _status: 200, _ct: 'text/html',
-    send(b) { this._body = b; replyPort.postMessage({ status: this._status, body: this._body, contentType: this._ct }); },
+    writeHead(code, headers) { this._status = code; if (headers?.['Content-Type']) this._ct = headers['Content-Type']; return this; },
+    setHeader(k, v) { if (k.toLowerCase() === 'content-type') this._ct = v; return this; },
+    write(chunk) { this._body += String(chunk); return true; },
+    end(chunk) { if (chunk != null) this._body += String(chunk); finish(this._status, this._body, this._ct); },
+    send(b) { this._body = typeof b === 'string' ? b : JSON.stringify(b); finish(this._status, this._body, this._ct); },
     json(o) { this._ct = 'application/json'; this.send(JSON.stringify(o)); },
     status(n) { this._status = n; return this; },
   };
-  const req = { method, path, query: {}, headers: {} };
-  try { match.fn(req, res); } catch (err) { replyPort.postMessage({ status: 500, body: err.message }); }
+  let bodyConsumed = false;
+  const req = {
+    method, url: path, path, query: {}, headers: reqHeaders || {},
+    [Symbol.asyncIterator]: async function* () { if (!bodyConsumed && reqBody) { bodyConsumed = true; yield reqBody; } },
+  };
+  try {
+    const r = match.fn(req, res);
+    if (r && typeof r.then === 'function') r.catch(err => finish(500, '<h1>500</h1><pre>' + String(err.message).replace(/</g, '&lt;') + '</pre>', 'text/html'));
+  } catch (err) { finish(500, '<h1>500</h1><pre>' + String(err.message).replace(/</g, '&lt;') + '</pre>', 'text/html'); }
+  setTimeout(() => finish(res._status, res._body, res._ct), 10000);
 });

package/docs/preview-sw.js

@@ -1,61 +1,65 @@
-const MIME = {
-  '.html': 'text/html',
-  '.js': 'application/javascript',
-  '.css': 'text/css',
-  '.json': 'application/json',
-  '.txt': 'text/plain',
-};
+const swJobs = new Map();
+const swFds = new Map();
+const swProcsubs = new Map();
 
-function getMime(key) {
-  const ext = key.slice(key.lastIndexOf('.'));
-  return MIME[ext] || 'application/octet-stream';
-}
-
-function openIDB() {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open('thebird', 1);
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-
-function getFS(db) {
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction('fs', 'readonly');
-    const store = tx.objectStore('fs');
-    const req = store.get('thebird_fs_v2');
-    req.onsuccess = () => resolve(req.result ? JSON.parse(req.result) : {});
-    req.onerror = () => reject(req.error);
-  });
-}
+self.addEventListener('install', e => self.skipWaiting());
+self.addEventListener('activate', e => e.waitUntil(clients.claim()));
 
-self.addEventListener('install', () => self.skipWaiting());
-self.addEventListener('activate', e => e.waitUntil(self.clients.claim()));
+self.addEventListener('message', e => {
+  const d = e.data;
+  if (!d) return;
+  if (d.type === 'JOB_REGISTER') swJobs.set(d.id + '@' + d.tabId, { id: d.id, cmd: d.cmd, tabId: d.tabId, startedAt: Date.now() });
+  else if (d.type === 'JOB_UNREGISTER') swJobs.delete(d.id + '@' + d.tabId);
+  else if (d.type === 'JOB_LIST') e.ports?.[0]?.postMessage({ jobs: [...swJobs.values()] });
+  else if (d.type === 'PROCSUB_PUT') swProcsubs.set(d.id, d.data);
+  else if (d.type === 'FD_PUT') swFds.set(d.id, d.data);
+});
 
 self.addEventListener('fetch', e => {
   const url = new URL(e.request.url);
-  const idx = url.pathname.indexOf('/preview/');
-  if (idx === -1) return;
-  const key = url.pathname.slice(idx + '/preview/'.length) || 'index.html';
-  e.respondWith(handlePreview(key, e.request));
+  const swScope = new URL(self.registration.scope);
+  if (!url.pathname.startsWith(swScope.pathname)) return;
+  const path = '/' + url.pathname.slice(swScope.pathname.length).replace(/^\//, '') || '/';
+
+  const procsubM = path.match(/^\/procsub\/(\d+)$/);
+  if (procsubM) { e.respondWith(serveFromClient(path, e.request)); return; }
+  if (path.startsWith('/dev/fd/')) { e.respondWith(serveFromClient(path, e.request)); return; }
+  const tcpM = path.match(/^\/dev\/tcp\/([^/]+)\/(\d+)(\/.*)?$/);
+  if (tcpM) { e.respondWith(fetch('http://' + tcpM[1] + ':' + tcpM[2] + (tcpM[3] || '/'), { method: e.request.method, body: e.request.method !== 'GET' ? e.request.body : undefined })); return; }
+
+  e.respondWith(forwardExpress(e.request, path));
 });
 
-const CORS_HEADERS = {
-  'Cross-Origin-Resource-Policy': 'cross-origin',
-};
+async function serveFromClient(path, request) {
+  const clients_ = await clients.matchAll({ includeUncontrolled: true });
+  const target = clients_.find(c => c.frameType !== 'nested') || clients_[0];
+  if (!target) return new Response('no client', { status: 503 });
+  const chan = new MessageChannel();
+  target.postMessage({ type: 'SW_STREAM_READ', path }, [chan.port2]);
+  return new Promise(res => {
+    const timeout = setTimeout(() => res(new Response('timeout', { status: 504 })), 5000);
+    chan.port1.onmessage = msg => {
+      clearTimeout(timeout);
+      if (!msg.data?.found) res(new Response('not found', { status: 404 }));
+      else res(new Response(msg.data.data, { status: 200, headers: { 'Content-Type': 'text/plain' } }));
+    };
+  });
+}
 
-async function handlePreview(key, request) {
-  const db = await openIDB();
-  const fs = await getFS(db);
-  if (key in fs) return new Response(fs[key], { status: 200, headers: { ...CORS_HEADERS, 'Content-Type': getMime(key) } });
-  const clients = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
-  if (!clients.length) return new Response('not found: ' + key, { status: 404, headers: CORS_HEADERS });
-  const { port1, port2 } = new MessageChannel();
-  const result = await new Promise((res, rej) => {
-    const t = setTimeout(() => rej(new Error('express timeout')), 5000);
-    port1.onmessage = e => { clearTimeout(t); res(e.data); };
-    clients[0].postMessage({ type: 'EXPRESS_REQUEST', path: '/' + key, method: request.method }, [port2]);
+async function forwardExpress(request, path) {
+  const body = ['POST', 'PUT', 'PATCH'].includes(request.method) ? await request.text() : null;
+  const headers = {};
+  request.headers.forEach((v, k) => { headers[k] = v; });
+  const chan = new MessageChannel();
+  const clients_ = await clients.matchAll({ includeUncontrolled: true });
+  const target = clients_.find(c => c.frameType !== 'nested') || clients_[0];
+  if (!target) return new Response('no client', { status: 503 });
+  target.postMessage({ type: 'EXPRESS_REQUEST', path, method: request.method, body, headers }, [chan.port2]);
+  return new Promise(res => {
+    const timeout = setTimeout(() => res(new Response('timeout', { status: 504 })), 10000);
+    chan.port1.onmessage = msg => {
+      clearTimeout(timeout);
+      res(new Response(msg.data.body, { status: msg.data.status || 200, headers: { 'Content-Type': msg.data.contentType || 'text/html' } }));
+    };
   });
-  if (!result || result.status === 404) return new Response('not found: ' + key, { status: 404, headers: CORS_HEADERS });
-  return new Response(result.body, { status: result.status || 200, headers: { ...CORS_HEADERS, 'Content-Type': result.contentType || 'text/html' } });
 }

package/docs/shell-awk.js

@@ -0,0 +1,113 @@
+export function runAwk(program, stdin, fs_sep) {
+  const fs = fs_sep || /\s+/;
+  const blocks = parseAwk(program);
+  const out = [];
+  const ctx = { NR: 0, vars: {} };
+  const emit = s => out.push(s);
+  for (const b of blocks.filter(b => b.when === 'BEGIN')) execAction(b.action, { $: [], NR: 0, NF: 0 }, emit, ctx);
+  const lines = (stdin || '').split('\n');
+  const effective = lines.length > 0 && lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines;
+  for (const line of effective) {
+    ctx.NR++;
+    const fields = line.split(fs).filter((_, i, a) => i > 0 || a.length === 1 || _ !== '');
+    const rec = { $: [line, ...fields], NR: ctx.NR, NF: fields.length };
+    for (const b of blocks.filter(b => b.when !== 'BEGIN' && b.when !== 'END')) {
+      if (!b.when || matchCond(b.when, rec, ctx)) execAction(b.action, rec, emit, ctx);
+    }
+  }
+  for (const b of blocks.filter(b => b.when === 'END')) execAction(b.action, { $: [], NR: ctx.NR, NF: 0 }, emit, ctx);
+  return out.join('\n');
+}
+
+function parseAwk(prog) {
+  const blocks = [];
+  let i = 0;
+  while (i < prog.length) {
+    while (i < prog.length && /\s/.test(prog[i])) i++;
+    if (i >= prog.length) break;
+    let when = '';
+    while (i < prog.length && prog[i] !== '{') { when += prog[i++]; }
+    when = when.trim();
+    if (prog[i] !== '{') { if (when) blocks.push({ when, action: 'print' }); break; }
+    let depth = 1; i++;
+    let action = '';
+    while (i < prog.length && depth > 0) {
+      if (prog[i] === '{') depth++;
+      else if (prog[i] === '}') { depth--; if (!depth) break; }
+      action += prog[i++];
+    }
+    i++;
+    blocks.push({ when: when || null, action: action.trim() || 'print' });
+  }
+  return blocks;
+}
+
+function matchCond(cond, rec, ctx) {
+  const re = cond.match(/^\/(.+)\/$/);
+  if (re) return new RegExp(re[1]).test(rec.$[0]);
+  const cmp = cond.match(/^\$(\d+)\s*(==|!=|<|>|~)\s*"(.*)"$/);
+  if (cmp) { const v = rec.$[+cmp[1]] || ''; const OPS = { '==': v === cmp[3], '!=': v !== cmp[3], '<': v < cmp[3], '>': v > cmp[3], '~': new RegExp(cmp[3]).test(v) }; return OPS[cmp[2]]; }
+  if (cond === 'NR==1') return rec.NR === 1;
+  try { return !!Function('$', 'NR', 'NF', 'return (' + cond.replace(/\$(\d+)/g, (_, n) => '$[' + n + ']') + ')')(rec.$, rec.NR, rec.NF); } catch { return false; }
+}
+
+function execAction(action, rec, emit, ctx) {
+  for (const stmt of action.split(';').map(s => s.trim()).filter(Boolean)) {
+    const pr = stmt.match(/^print\s*(.*)$/);
+    if (pr) { emit(evalPrint(pr[1] || '$0', rec, ctx)); continue; }
+    const printf = stmt.match(/^printf\s+(.+)$/);
+    if (printf) { const parts = splitTop(printf[1], ','); const vals = parts.map(p => evalExpr(p.trim(), rec, ctx)); emit(AWK_FNS.sprintf(vals[0], ...vals.slice(1))); continue; }
+    const assign = stmt.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
+    if (assign) { ctx.vars[assign[1]] = evalExpr(assign[2], rec, ctx); continue; }
+    if (stmt === 'next') { ctx.skipRest = true; continue; }
+    try { evalExpr(stmt, rec, ctx); } catch {}
+  }
+}
+
+function evalPrint(args, rec, ctx) {
+  if (!args) return rec.$[0] || '';
+  const parts = splitTop(args, ',');
+  return parts.map(p => String(evalExpr(p.trim(), rec, ctx))).join(' ');
+}
+
+const AWK_FNS = {
+  length: s => String(s ?? '').length,
+  substr: (s, i, n) => String(s).substr((i|0) - 1, n == null ? undefined : n|0),
+  tolower: s => String(s).toLowerCase(),
+  toupper: s => String(s).toUpperCase(),
+  index: (s, t) => String(s).indexOf(String(t)) + 1,
+  match: (s, re) => { const m = String(s).match(new RegExp(re)); return m ? m.index + 1 : 0; },
+  split: (s, arr, re) => { const parts = String(s).split(new RegExp(re || /\s+/)); for (let i = 0; i < parts.length; i++) arr[i + 1] = parts[i]; return parts.length; },
+  sub: (re, rep, s) => { const r = new RegExp(re); const v = String(s ?? ''); return v.replace(r, rep); },
+  gsub: (re, rep, s) => { const r = new RegExp(re, 'g'); const v = String(s ?? ''); return v.replace(r, rep); },
+  sprintf: (fmt, ...a) => { let i = 0; return String(fmt).replace(/%([sdfox])/g, (_, k) => { const v = a[i++]; if (k === 'd') return String(parseInt(v, 10) || 0); if (k === 's') return String(v ?? ''); if (k === 'f') return String(parseFloat(v) || 0); if (k === 'x') return (parseInt(v, 10) || 0).toString(16); if (k === 'o') return (parseInt(v, 10) || 0).toString(8); return ''; }); },
+};
+
+function evalExpr(expr, rec, ctx) {
+  const s = expr.trim();
+  const strM = s.match(/^"(.*)"$/);
+  if (strM) return strM[1];
+  const fldM = s.match(/^\$(\d+|NF)$/);
+  if (fldM) { const n = fldM[1] === 'NF' ? rec.NF : +fldM[1]; return rec.$[n] || ''; }
+  if (s === 'NR') return rec.NR;
+  if (s === 'NF') return rec.NF;
+  if (ctx.vars[s] !== undefined) return ctx.vars[s];
+  const num = +s;
+  if (!isNaN(num)) return num;
+  try {
+    const body = 'return (' + s.replace(/\$(\d+|NF)/g, (_, n) => n === 'NF' ? 'NF' : '$[' + n + ']').replace(/\b([A-Za-z_]\w*)\b/g, (_, n) => AWK_FNS[n] ? 'F.' + n : 'v.' + n) + ')';
+    return Function('$', 'NR', 'NF', 'v', 'F', body)(rec.$, rec.NR, rec.NF, ctx.vars, AWK_FNS) ?? '';
+  } catch { return s; }
+}
+
+function splitTop(s, sep) {
+  const out = []; let cur = ''; let depth = 0; let inStr = false;
+  for (const c of s) {
+    if (c === '"') inStr = !inStr;
+    else if (!inStr) { if (c === '(' || c === '[') depth++; else if (c === ')' || c === ']') depth--; }
+    if (c === sep && !inStr && !depth) { out.push(cur); cur = ''; continue; }
+    cur += c;
+  }
+  if (cur) out.push(cur);
+  return out;
+}

package/docs/shell-builtins-extra.js

@@ -0,0 +1,121 @@
+import { resolvePath } from './shell-builtins.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+
+export function makeExtraBuiltins(ctx, readFile, writeFile) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  return {
+    test: args => { ctx.lastExitCode = evalTest(args) ? 0 : 1; },
+    '[': args => { const inner = args[args.length - 1] === ']' ? args.slice(0, -1) : args; ctx.lastExitCode = evalTest(inner) ? 0 : 1; },
+    tee: (args, _a, stdin) => {
+      const files = args.filter(a => !a.startsWith('-'));
+      const append = args.some(a => a === '-a');
+      const buf = stdin || '';
+      for (const f of files) writeFile(f, append ? (snap()[toKey(resolvePath(ctx.cwd, f))] || '') + buf : buf);
+      w(buf.replace(/\n/g, '\r\n'));
+    },
+    xargs: async (args, _a, stdin, invokeBuiltin) => {
+      const parts = (stdin || '').trim().split(/\s+/).filter(Boolean);
+      if (!args.length || !parts.length) return;
+      await invokeBuiltin(args[0], [...args.slice(1), ...parts], false);
+    },
+    read: (args, _a, stdin) => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const names = args.filter(a => !a.startsWith('-'));
+      if (!names.length) names.push('REPLY');
+      let line = (stdin || '').split('\n')[0];
+      if (!flags.includes('r')) line = line.replace(/\\(.)/g, '$1');
+      line = line.replace(/\r$/, '');
+      const nIdx = flags.indexOf('n');
+      if (nIdx >= 0) { const n = parseInt(flags.slice(nIdx + 1), 10); if (!isNaN(n)) line = line.slice(0, n); }
+      const parts = line.split(/\s+/);
+      for (let i = 0; i < names.length; i++) ctx.env[names[i]] = i === names.length - 1 ? parts.slice(i).join(' ') : parts[i] || '';
+    },
+    printf: args => {
+      if (!args.length) return;
+      let dest = null;
+      if (args[0] === '-v') { dest = args[1]; args = args.slice(2); }
+      if (!args.length) return;
+      const fmt = args[0].replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r');
+      let idx = 1;
+      const out = fmt.replace(/%([sdxof])/g, (_, spec) => {
+        const v = args[idx++] ?? '';
+        if (spec === 'd') return String(parseInt(v, 10) || 0);
+        if (spec === 'x') return (parseInt(v, 10) || 0).toString(16);
+        if (spec === 'o') return (parseInt(v, 10) || 0).toString(8);
+        if (spec === 'f') return String(parseFloat(v) || 0);
+        return String(v);
+      });
+      if (dest) ctx.env[dest] = out; else w(out.replace(/\n/g, '\r\n'));
+    },
+    declare: args => {
+      const assoc = args.includes('-A');
+      const arr = args.includes('-a');
+      const names = args.filter(a => !a.startsWith('-'));
+      for (const n of names) { const eq = n.indexOf('='); const k = eq >= 0 ? n.slice(0, eq) : n; if (assoc) { ctx.arrays = ctx.arrays || {}; ctx.arrays[k] = {}; } else if (arr) { ctx.arrays = ctx.arrays || {}; ctx.arrays[k] = []; } else if (eq >= 0) ctx.env[k] = n.slice(eq + 1); }
+    },
+    shift: args => {
+      const n = parseInt(args[0], 10) || 1;
+      ctx.argv = (ctx.argv || []).slice(n);
+    },
+    local: args => {
+      for (const kv of args) {
+        const eq = kv.indexOf('=');
+        const k = eq >= 0 ? kv.slice(0, eq) : kv;
+        const v = eq >= 0 ? kv.slice(eq + 1) : '';
+        (ctx.localStack && ctx.localStack[ctx.localStack.length - 1] || {})[k] = ctx.env[k];
+        ctx.env[k] = v;
+      }
+    },
+    set: args => {
+      for (const a of args) {
+        if (a === '-e') ctx.opts = { ...ctx.opts, errexit: true };
+        else if (a === '+e') ctx.opts = { ...ctx.opts, errexit: false };
+        else if (a === '-x') ctx.opts = { ...ctx.opts, xtrace: true };
+        else if (a === '+x') ctx.opts = { ...ctx.opts, xtrace: false };
+        else if (a === '-u') ctx.opts = { ...ctx.opts, nounset: true };
+      }
+    },
+    break: args => { ctx.loopFlag = 'break'; ctx.loopDepth = parseInt(args[0], 10) || 1; },
+    continue: args => { ctx.loopFlag = 'continue'; ctx.loopDepth = parseInt(args[0], 10) || 1; },
+    source: async (args, _a, _s, invokeBuiltin, runLine) => {
+      if (!args[0]) throw new Error('source: missing file');
+      const content = snap()[toKey(resolvePath(ctx.cwd, args[0]))];
+      if (content == null) throw new Error('source: ' + args[0] + ': No such file');
+      const savedArgv = ctx.argv;
+      ctx.argv = [args[0], ...args.slice(1)];
+      try { if (ctx.runScript) await ctx.runScript(content); else for (const ln of content.split('\n')) if (ln.trim()) await runLine(ln); }
+      finally { ctx.argv = savedArgv; }
+    },
+    '.': async (args, actor, stdin, invokeBuiltin, runLine) => {
+      const src = (ctx.builtinsRef || {}).source;
+      if (src) await src(args, actor, stdin, invokeBuiltin, runLine);
+    },
+  };
+}
+
+function evalTest(args) {
+  if (args.length === 1) return !!args[0];
+  if (args.length === 2) {
+    const [flag, val] = args;
+    const s = () => window.__debug.idbSnapshot || {};
+    const OPS = {
+      '-z': v => v === '', '-n': v => v !== '',
+      '-f': v => v in s(),
+      '-d': v => Object.keys(s()).some(k => k.startsWith(v + '/')),
+      '-e': v => v in s() || Object.keys(s()).some(k => k.startsWith(v + '/')),
+      '!': v => !v,
+    };
+    return OPS[flag]?.(val) ?? false;
+  }
+  if (args.length === 3) {
+    const [a, op, b] = args;
+    const CMP = { '=':(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,'-le':(x,y)=>+x<=+y,'-ge':(x,y)=>+x>=+y };
+    return CMP[op]?.(a, b) ?? false;
+  }
+  return false;
+}