thebird 1.2.78 → 1.2.80

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-http-stream.js

@@ -0,0 +1,24 @@
+export async function* streamKiloHTTP({ url, model, messages }) {
+  yield { type: 'start-step' };
+  const base = (url || 'http://localhost:4780').replace(/\/$/, '');
+  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: kilo serve --port ' + (new URL(base).port || 4780) + ' --cors ' + 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, lastStatus: null } });
+
+  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', agent: 'hermes-llm' };
+  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) throw new Error('kilo message ' + msgRes.status + ': ' + await msgRes.text());
+  const result = await msgRes.json();
+  window.__debug.kilo.lastResult = result;
+  const textParts = (result.parts || []).filter(p => p.type === 'text');
+  for (const tp of textParts) yield { type: 'text-delta', textDelta: tp.text };
+  yield { type: 'finish-step', finishReason: result.info?.finish || 'stop' };
+}

package/docs/node-builtins.js

@@ -0,0 +1,194 @@
+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();
+    },
+    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,
+  };
+}
+
+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)); }
+    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);
+    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;
+  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;
+}