thebird 1.2.79 → 1.2.81

package/docs/shell-sw-jobs.js

@@ -0,0 +1,76 @@
+export function createSwJobs() {
+  const registry = new Map();
+
+  async function postSw(msg) {
+    if (!navigator.serviceWorker?.controller) return null;
+    const chan = new MessageChannel();
+    const p = new Promise(res => { chan.port1.onmessage = e => res(e.data); setTimeout(() => res(null), 2000); });
+    navigator.serviceWorker.controller.postMessage(msg, [chan.port2]);
+    return p;
+  }
+
+  return {
+    async register(id, cmd) {
+      registry.set(id, { cmd, startedAt: Date.now() });
+      await postSw({ type: 'JOB_REGISTER', id, cmd, tabId: getTabId() });
+    },
+    async unregister(id) {
+      registry.delete(id);
+      await postSw({ type: 'JOB_UNREGISTER', id, tabId: getTabId() });
+    },
+    async list() {
+      const r = await postSw({ type: 'JOB_LIST' });
+      return r?.jobs || [...registry.entries()].map(([id, j]) => ({ id, ...j, tabId: getTabId() }));
+    },
+    local: () => [...registry.entries()].map(([id, j]) => ({ id, ...j })),
+  };
+}
+
+let _tabId = null;
+function getTabId() {
+  if (_tabId) return _tabId;
+  try { _tabId = sessionStorage.getItem('thebird_tab') || String(Date.now()) + Math.random().toString(36).slice(2, 6); sessionStorage.setItem('thebird_tab', _tabId); } catch { _tabId = 'main'; }
+  return _tabId;
+}
+
+export function makeNohupBuiltin(ctx) {
+  return async args => {
+    if (!args.length) return;
+    ctx.term.write('nohup: ignoring HUP\r\n');
+    const cmd = args.join(' ');
+    if (ctx.jobRegistry) ctx.jobRegistry.spawnJob(cmd, ctx.runPipeline);
+  };
+}
+
+export function makeNetcatStub(ctx) {
+  return async (args, _a, stdin) => {
+    const host = args.find(a => !a.startsWith('-'));
+    const portArg = args[args.indexOf(host) + 1];
+    if (!host || !portArg) throw new Error('nc: usage: nc HOST PORT');
+    const url = 'http://' + host + ':' + portArg;
+    try {
+      const r = await fetch(url, { method: stdin ? 'POST' : 'GET', body: stdin || undefined });
+      const text = await r.text();
+      ctx.term.write(text.replace(/\n/g, '\r\n') + '\r\n');
+    } catch (e) {
+      ctx.term.write('\x1b[31mnc: ' + e.message + '\x1b[0m\r\n');
+      ctx.lastExitCode = 1;
+    }
+  };
+}
+
+export function makeCurlBuiltin(ctx) {
+  return async (args, _a, stdin) => {
+    const url = args.find(a => !a.startsWith('-') && (a.includes('://') || a.startsWith('/dev/tcp/')));
+    if (!url) throw new Error('curl: missing url');
+    let fetchUrl = url;
+    const tcpM = url.match(/^\/dev\/tcp\/([^/]+)\/(\d+)(\/.*)?$/);
+    if (tcpM) fetchUrl = 'http://' + tcpM[1] + ':' + tcpM[2] + (tcpM[3] || '/');
+    const method = args.includes('-X') ? args[args.indexOf('-X') + 1] : (args.includes('-d') || stdin ? 'POST' : 'GET');
+    const body = args.includes('-d') ? args[args.indexOf('-d') + 1] : stdin;
+    try {
+      const r = await fetch(fetchUrl, { method, body });
+      ctx.term.write((await r.text()).replace(/\n/g, '\r\n'));
+    } catch (e) { ctx.term.write('\x1b[31mcurl: ' + e.message + '\x1b[0m\r\n'); ctx.lastExitCode = 1; }
+  };
+}

package/docs/shell-ts.js

@@ -0,0 +1,30 @@
+let stripPromise=null;
+async function getStripper(){
+  if(!stripPromise)stripPromise=import('https://esm.sh/sucrase@3.35.0/es2022/sucrase.mjs').then(m=>m.default||m).catch(()=>null);
+  return stripPromise;
+}
+
+const typeDeclRE=/(^|\n)\s*(type|interface)\s+\w+[^\n]*(?:\n\s+[^\n]+)*\n?/g;
+const asAnyRE=/\s+as\s+[\w.<>|&[\]]+/g;
+const genericRE=/<[A-Z]\w*(?:\s*(?:extends|,)[^>]*)?>/g;
+const varAnnotRE=/(\b(?:const|let|var)\s+\w+)\s*:\s*[^=,;)\n]+/g;
+const paramAnnotRE=/(\b\w+)\s*:\s*[\w.<>|&[\]{} ]+?(?=\s*[,)=])/g;
+const retTypeRE=/\)\s*:\s*[\w.<>|&[\]{} ]+?(?=\s*[{=]|$)/gm;
+
+export function stripTypesSync(src){
+  let out=src.replace(typeDeclRE,'\n').replace(asAnyRE,'').replace(genericRE,'');
+  out=out.replace(varAnnotRE,'$1').replace(retTypeRE,')');
+  return out;
+}
+
+export async function stripTypes(src,opts={}){
+  try{const s=await getStripper();if(s?.transform){const r=s.transform(src,{transforms:['typescript',...(opts.jsx?['jsx']:[])],jsxRuntime:'automatic'});return r.code;}}catch{}
+  return stripTypesSync(src);
+}
+
+export function isTsFile(filename){return/\.(ts|tsx|mts|cts)$/i.test(filename);}
+
+export function preprocessSource(filename,src){
+  if(!isTsFile(filename))return Promise.resolve(src);
+  return stripTypes(src,{jsx:/\.tsx$/.test(filename)});
+}

package/docs/shell.js

@@ -1,94 +1,19 @@
 import { createMachine, createActor } from './vendor/xstate.js';
 import { createNodeEnv } from './shell-node.js';
 import { createReadline } from './shell-readline.js';
-
-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('/');
-}
-
-function makeBuiltins(ctx) {
-  const snap = () => window.__debug.idbSnapshot || {};
-  const toKey = p => p.replace(/^\//, '');
-  const w = s => ctx.term.write(s);
-  const wl = s => w(s + '\r\n');
-  return {
-    ls: ([p]) => {
-      const prefix = toKey(resolvePath(ctx.cwd, p || ''));
-      const pLen = prefix ? prefix.length + 1 : 0;
-      const seen = new Set();
-      for (const k of Object.keys(snap())) {
-        if (prefix && !k.startsWith(prefix + '/') && k !== prefix) continue;
-        if (!prefix && !k.includes('/')) { seen.add(k); continue; }
-        const rest = k.slice(pLen);
-        const first = rest.split('/')[0];
-        if (first && first !== '.keep') seen.add(first);
-      }
-      wl([...seen].join('\r\n') || '(empty)');
-    },
-    cat: ([f]) => {
-      const c = snap()[toKey(resolvePath(ctx.cwd, f))];
-      if (c == null) throw new Error('no such file: ' + f);
-      wl(c);
-    },
-    echo: args => wl(args.join(' ')),
-    pwd: () => wl(ctx.cwd),
-    cd: ([p]) => { ctx.cwd = resolvePath(ctx.cwd, p || '~'); },
-    mkdir: ([p]) => { snap()[toKey(resolvePath(ctx.cwd, p)) + '/.keep'] = ''; window.__debug.idbPersist?.(); },
-    rm: ([f]) => { delete snap()[toKey(resolvePath(ctx.cwd, f))]; window.__debug.idbPersist?.(); },
-    cp: ([s, d]) => { snap()[toKey(resolvePath(ctx.cwd, d))] = snap()[toKey(resolvePath(ctx.cwd, s))]; window.__debug.idbPersist?.(); },
-    mv: ([s, d]) => {
-      const src = toKey(resolvePath(ctx.cwd, s)), dst = toKey(resolvePath(ctx.cwd, d));
-      snap()[dst] = snap()[src]; delete snap()[src]; window.__debug.idbPersist?.();
-    },
-    touch: ([f]) => { const k = toKey(resolvePath(ctx.cwd, f)); if (!(k in snap())) { snap()[k] = ''; window.__debug.idbPersist?.(); } },
-    head: ([f]) => { const c = snap()[toKey(resolvePath(ctx.cwd, f))]; if (!c) throw new Error('no such file: ' + f); wl(c.split('\n').slice(0, 10).join('\r\n')); },
-    tail: ([f]) => { const c = snap()[toKey(resolvePath(ctx.cwd, f))]; if (!c) throw new Error('no such file: ' + f); wl(c.split('\n').slice(-10).join('\r\n')); },
-    wc: ([f]) => { const c = snap()[toKey(resolvePath(ctx.cwd, f))]; if (!c) throw new Error('no such file: ' + f); const lines = c.split('\n').length; wl(lines + ' ' + c.length + ' ' + f); },
-    grep: ([pat, f]) => {
-      const c = snap()[toKey(resolvePath(ctx.cwd, f))];
-      if (!c) throw new Error('no such file: ' + f);
-      const re = new RegExp(pat, 'g');
-      wl(c.split('\n').filter(l => re.test(l)).join('\r\n') || '(no matches)');
-    },
-    env: () => wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n')),
-    export: ([kv]) => { const [k, ...v] = (kv || '').split('='); ctx.env[k] = v.join('='); },
-    clear: () => ctx.term.clear(),
-    help: () => wl(Object.keys(makeBuiltins(ctx)).join('  ')),
-    which: ([cmd]) => wl(makeBuiltins(ctx)[cmd] ? '(builtin) ' + cmd : 'not found: ' + cmd),
-    exit: (_, actor) => {
-      if (actor.getSnapshot().value === 'node-repl') { actor.send({ type: 'EXIT_REPL' }); wl('[shell]'); }
-    },
-    node: async (args, actor) => {
-      if (!args.length) { actor.send({ type: 'ENTER_REPL' }); wl('[node repl — type exit to return]'); return; }
-      if (args[0] === '-v' || args[0] === '--version') { wl('v20.0.0'); return; }
-      if (args[0] === '-e' || args[0] === '--eval') { await ctx.nodeEval(args.slice(1).join(' ')); return; }
-      const path = resolvePath(ctx.cwd, args[0]);
-      const code = snap()[toKey(path)];
-      if (code == null) throw new Error('no such file: ' + path);
-      actor.send({ type: 'NODE_START' });
-      await ctx.nodeEval(code, path, args.slice(1));
-    },
-    npm: async (args) => {
-      if (args[0] !== 'install' && args[0] !== 'i') throw new Error('only npm install supported');
-      const pkg = args[1];
-      if (!pkg) throw new Error('npm install <pkg>');
-      w('fetching ' + pkg + '...\r\n');
-      const r = await fetch('https://esm.sh/' + pkg);
-      if (!r.ok) throw new Error('fetch failed: ' + r.status);
-      snap()['node_modules/' + pkg + '/index.js'] = await r.text();
-      window.__debug.idbPersist?.();
-      wl('installed ' + pkg);
-    },
-  };
-}
+import { makeBuiltins, resolvePath } from './shell-builtins.js';
+import { makeNpm, makeNpx } from './shell-npm.js';
+import { makePmDispatcher, makeCorepackStub, detectPm } from './shell-pm.js';
+import { makeDlx } from './shell-pm-layout.js';
+import { tokenize, splitTopLevel, parsePipes } from './shell-parser.js';
+import { fullExpand } from './shell-expand.js';
+import { isControlStart, isBlockOpen, runControl, runScript } from './shell-control.js';
+import { createSignals, makeKillBuiltin, makeTrapBuiltin } from './shell-signals.js';
+import { createJobRegistry, makeJobsBuiltin, makeFgBuiltin, makeBgBuiltin, makeDisownBuiltin } from './shell-jobs.js';
+import { createFdTable, makeExecBuiltin } from './shell-fd.js';
+import { readStream } from './shell-procsub.js';
+import { makeExpander, makeCaptureRun, makeNodeRunner, makeNpmResultRunner } from './shell-exec.js';
+import { createSwJobs, makeNohupBuiltin, makeNetcatStub, makeCurlBuiltin } from './shell-sw-jobs.js';
 
 const machine = createMachine({ id: 'shell', initial: 'idle', states: {
   idle: { on: { RUN: 'executing', ENTER_REPL: 'node-repl', NODE_START: 'node-running' } },
@@ -98,91 +23,175 @@ const machine = createMachine({ id: 'shell', initial: 'idle', states: {
 }});
 
 export function createShell({ term, onPreviewWrite }) {
-  const ctx = { term, cwd: '/', env: {}, history: [] };
-  const BUILTINS = makeBuiltins(ctx);
-  ctx.nodeEval = createNodeEnv({ ctx, term });
-
+  const ctx = { term, cwd: '/', prevCwd: '/', env: {}, history: [], lastExitCode: 0, argv: [], functions: {}, opts: {}, localStack: [], loopFlag: null, arrays: {}, bgJobs: {}, traps: {} };
   const actor = createActor(machine);
   actor.start();
+  const httpHandlers = {};
+  window.__debug = window.__debug || {};
 
   let inputQueue = [];
   function drainQueue(onData) { const items = inputQueue.slice(); inputQueue = []; for (const d of items) onData(d); }
 
-  window.__debug = window.__debug || {};
-  window.__debug.shell = {
-    get state() { return actor.getSnapshot().value; },
-    get cwd() { return ctx.cwd; },
-    get env() { return ctx.env; },
-    get history() { return ctx.history; },
-    httpHandlers: {},
-    get inputQueue() { return inputQueue.slice(); },
-  };
+  const toKey = p => p.replace(/^\//, '');
+  const snap = () => window.__debug.idbSnapshot || {};
 
-  async function runCmd(line, capture) {
-    if (!line.trim()) return '';
-    const [cmd, ...args] = line.trim().split(/\s+/);
-    const fn = BUILTINS[cmd];
-    if (!capture) {
-      if (fn) await fn(args, actor); else term.write('command not found: ' + cmd + '\r\n');
-      return '';
-    }
-    let out = '';
-    const orig = term.write.bind(term);
-    term.write = s => { out += s; };
-    try { if (fn) await fn(args, actor); else out += 'command not found: ' + cmd; }
-    finally { term.write = orig; }
+  const BUILTINS = makeBuiltins(ctx, actor, invokeBuiltin);
+  ctx.builtinsRef = BUILTINS;
+  const _exp = makeExpander(ctx, l => captureRun(l), t => parseRedirect(t));
+  expandTokens = _exp.expandTokens;
+  captureRun = makeCaptureRun(ctx, BUILTINS, actor, t => parseRedirect(t), t => expandTokens(t));
+  ctx.signals = createSignals(ctx);
+  ctx.fdTable = createFdTable(ctx);
+  ctx.swJobs = createSwJobs();
+  const jobRegistry = createJobRegistry(ctx);
+  ctx.jobRegistry = jobRegistry;
+  ctx.runPipeline = line => runPipeline(line);
+  Object.assign(BUILTINS, { kill: makeKillBuiltin(ctx), trap: makeTrapBuiltin(ctx), jobs: makeJobsBuiltin(ctx, jobRegistry), fg: makeFgBuiltin(ctx, jobRegistry), bg: makeBgBuiltin(ctx, jobRegistry), disown: makeDisownBuiltin(ctx), exec: makeExecBuiltin(ctx, ctx.fdTable), nohup: makeNohupBuiltin(ctx), nc: makeNetcatStub(ctx), curl: makeCurlBuiltin(ctx) });
+  ctx.runScript = text => runScript(text, run, ctx);
+  ctx.expand = token => fullExpand(token, ctx.env, ctx.lastExitCode, ctx.argv, captureRun, ctx.arrays);
+  const npmCmd = makeNpm(ctx); const npxCmd = makeNpx(npmCmd); ctx.exec = line => run(line);
+  const pmDispatch = makePmDispatcher(term, null, () => window.__debug.idbPersist?.(), ctx); const corepackCmd = makeCorepackStub(term); const dlxCmd = makeDlx(term, null, ctx, run);
+  ctx.nodeEval = createNodeEnv({ ctx, term });
+  const runNode = makeNodeRunner(ctx, actor);
+  const runNpmResult = makeNpmResultRunner(ctx, line => run(line));
+
+  let expandTokens, captureRun;
+
+  async function captureFn(fn) {
+    let out = ''; const orig = term.write.bind(term); term.write = s => { out += s; };
+    try { await fn(); } finally { term.write = orig; }
     return out;
   }
 
-  async function run(line, onData) {
-    if (!line.trim()) return;
-    const st = actor.getSnapshot().value;
-    if (st === 'node-repl' && line.trim() !== 'exit') { await ctx.nodeEval(line); return; }
-    if (line.trim() === 'exit') { BUILTINS.exit([], actor); return; }
-    const [cmd] = line.trim().split(/\s+/);
-    if (cmd !== 'npm' && cmd !== 'node') actor.send({ type: 'RUN' });
+  async function runFunction(name, args) {
+    const savedArgv = ctx.argv; ctx.argv = [name, ...args]; ctx.localStack.push({});
+    try { await runScript(ctx.functions[name], run, ctx); }
+    finally {
+      const locals = ctx.localStack.pop();
+      for (const k of Object.keys(locals)) { if (locals[k] === undefined) delete ctx.env[k]; else ctx.env[k] = locals[k]; }
+      ctx.argv = savedArgv;
+    }
+  }
+
+  async function invokeBuiltin(name, args, withCaptureInto, stdinBuf) {
+    if (ctx.functions[name]) {
+      if (!withCaptureInto) { await runFunction(name, args); return ''; }
+      return captureFn(() => runFunction(name, args));
+    }
+    const fn = BUILTINS[name];
+    if (!fn) throw new Error('command not found: ' + name);
+    if (!withCaptureInto) { await fn(args, actor, stdinBuf, invokeBuiltin, run); return ''; }
+    return captureFn(() => fn(args, actor, stdinBuf, invokeBuiltin, run));
+  }
+
+  function evalKV(kv) { const eq = kv.indexOf('='); return [kv.slice(0, eq), fullExpand(kv.slice(eq + 1), ctx.env, ctx.lastExitCode, ctx.argv, captureRun)]; }
+
+  async function runSingleCommand(line) {
+    const arrM = line.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)=\((.*)\)\s*$/);
+    if (arrM) { (ctx.arrays = ctx.arrays || {})[arrM[1]] = tokenize(arrM[2]).map(t => fullExpand(t, ctx.env, ctx.lastExitCode, ctx.argv, captureRun, ctx.arrays)); return; }
+    const idxM = line.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)\[([^\]]+)\]=(.*)$/);
+    if (idxM) { ctx.arrays = ctx.arrays || {}; if (!ctx.arrays[idxM[1]]) ctx.arrays[idxM[1]] = {}; const a = ctx.arrays[idxM[1]], ex = t => fullExpand(t, ctx.env, ctx.lastExitCode, ctx.argv, captureRun, ctx.arrays), k = ex(idxM[2]), v = ex(idxM[3]); if (Array.isArray(a)) a[parseInt(k, 10)] = v; else a[k] = v; return; }
+    const raw = tokenize(line); if (!raw.length) return;
+    let i = 0; const varAssigns = [];
+    while (i < raw.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(raw[i])) varAssigns.push(raw[i++]);
+    const rest = raw.slice(i);
+    if (!rest.length) { for (const kv of varAssigns) { const [k, v] = evalKV(kv); ctx.env[k] = v; } return; }
+    const { args: [cmd, ...args], stdout: rout, append } = parseRedirect(expandTokens(rest));
+    const writeOut = rout ? buf => { const k = toKey(resolvePath(ctx.cwd, rout)); snap()[k] = append ? (snap()[k] || '') + buf : buf; window.__debug.idbPersist?.(); } : null;
+    const prevEnv = {}; for (const kv of varAssigns) { const [k, v] = evalKV(kv); prevEnv[k] = ctx.env[k]; ctx.env[k] = v; }
     try {
-      const parts = line.split(' | ');
-      if (parts.length > 1) {
-        let buf = await runCmd(parts[0], true);
-        for (const p of parts.slice(1)) {
-          const [c, ...a] = p.trim().split(/\s+/);
-          const fn = BUILTINS[c];
-          if (fn) await fn([buf, ...a], actor); else term.write('command not found: ' + c + '\r\n');
-          buf = '';
-        }
-      } else {
-        await runCmd(line, false);
+      if (cmd === 'npm') { if (writeOut) { writeOut(await captureFn(async () => { await runNpmResult(await npmCmd(args)); })); return; } await runNpmResult(await npmCmd(args)); return; }
+      if (cmd === 'npx') { await runNpmResult(await npxCmd(args)); return; }
+      if (cmd === 'pnpm' || cmd === 'yarn' || cmd === 'bun') { ctx.lastExitCode = args[0] === 'dlx' || args[0] === 'x' ? await dlxCmd(args.slice(1)) : await pmDispatch(cmd, args[0] || 'install', args.slice(1)); return; }
+      if (cmd === 'deno') { if (args[0] === 'run') { await runNode(args.slice(1)); return; } ctx.lastExitCode = await pmDispatch('deno', args[0] || 'task', args.slice(1)); return; }
+      if (cmd === 'corepack') { ctx.lastExitCode = await corepackCmd(args); return; }
+      if (cmd === 'node') { await runNode(args); return; }
+      if (cmd === 'exit') { BUILTINS.exit([], actor); return; }
+      if (writeOut) { writeOut(await invokeBuiltin(cmd, args, true)); return; }
+      await invokeBuiltin(cmd, args, false);
+    } finally { for (const k of Object.keys(prevEnv)) { if (prevEnv[k] === undefined) delete ctx.env[k]; else ctx.env[k] = prevEnv[k]; } }
+  }
+
+  function parseRedirect(tokens) {
+    const out = { args: [], stdout: null, append: false };
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t === '>' || t === '>>') { out.stdout = tokens[++i]; out.append = t === '>>'; } else out.args.push(t);
+    }
+    return out;
+  }
+
+  async function runPipeline(line) {
+    const pipes = parsePipes(line);
+    if (pipes.length === 1) { await runSingleCommand(pipes[0]); return; }
+    let buf = '';
+    for (let i = 0; i < pipes.length; i++) {
+      const isLast = i === pipes.length - 1;
+      const { args: [cmd, ...args], stdout: rout, append } = parseRedirect(expandTokens(tokenize(pipes[i])));
+      const sArgs = i === 0 ? args : (buf && cmd !== 'node' ? [buf, ...args] : args);
+      const stdinForStage = cmd === 'node' ? buf : buf;
+      if (isLast && !rout) {
+        if (cmd === 'node') { await runNode(args, stdinForStage); buf = ''; continue; }
+        await invokeBuiltin(cmd, sArgs, false, stdinForStage); buf = ''; continue;
       }
-      actor.send({ type: 'DONE' });
-      drainQueue(onData);
-    } catch (e) {
-      term.write('\x1b[31m' + e.message + '\x1b[0m\r\n');
-      actor.send({ type: 'ERROR' });
-      drainQueue(onData);
+      const out = cmd === 'node' ? await captureFn(() => runNode(args, stdinForStage)) : await invokeBuiltin(cmd, sArgs, true, stdinForStage);
+      if (rout) { const k = toKey(resolvePath(ctx.cwd, rout)); snap()[k] = append ? (snap()[k] || '') + out : out; window.__debug.idbPersist?.(); buf = ''; } else { buf = out; }
     }
   }
 
-  function getCompletions(line, word) {
-    const files = Object.keys(window.__debug.idbSnapshot || {});
-    const tokens = line.trim().split(/\s+/);
-    if (tokens.length <= 1 && !line.includes(' ')) return Object.keys(BUILTINS).filter(c => c.startsWith(word));
-    return files.filter(f => f.startsWith(word));
+  let blockLines = [];
+
+  async function run(line, onData) {
+    if (!line.trim()) return;
+    ctx.history.push(line);
+    const st = actor.getSnapshot().value;
+    if (st === 'node-repl') {
+      const t = line.trim();
+      if (t === 'exit' || t === '.exit' || t === '.quit') { actor.send({ type: 'EXIT_REPL' }); return; }
+      if (t === '.help') { term.write('.exit    Exit the REPL\r\n.help    Show this list\r\n.clear   Break out of current expression\r\n'); return; }
+      if (t === '.clear') return;
+      const exprCode = 'try { const __r = (' + line + '); if (__r !== undefined) console.log(require("util").inspect(__r)); } catch (__e1) { try {\n' + line + '\n} catch (__e2) { console.error(__e2.message); } }';
+      await ctx.nodeEval(exprCode); return;
+    }
+    if (ctx.opts.xtrace) term.write('\x1b[90m+ ' + line + '\x1b[0m\r\n');
+    const chain = splitTopLevel(line, ['&&', '||', ';', '&']);
+    let lastOk = true;
+    for (const { cmd, sep } of chain) {
+      if (ctx.loopFlag) break;
+      if (sep === '&&' && !lastOk) continue;
+      if (sep === '||' && lastOk) { lastOk = true; continue; }
+      if (sep === '&') { const id = jobRegistry.spawnJob(cmd, runPipeline); ctx.env['!'] = id; term.write('[' + id + '] spawned\r\n'); continue; }
+      actor.send({ type: 'RUN' });
+      try { ctx.lastExitCode = 0; await runPipeline(cmd); lastOk = ctx.lastExitCode === 0; actor.send({ type: 'DONE' }); }
+      catch (e) { term.write('\x1b[31m' + e.message + '\x1b[0m\r\n'); ctx.lastExitCode = 1; lastOk = false; actor.send({ type: 'ERROR' }); }
+      if (ctx.opts.errexit && !lastOk) break;
+      if (ctx.signals) await ctx.signals.check(l => run(l));
+    }
+    if (onData) drainQueue(onData);
   }
 
-  const rl = createReadline({ term, getCompletions, getPrompt: () => ctx.cwd, onLine: line => run(line, onData).then(() => rl.showPrompt()) });
+  const getCompletions = (line, word) => (line.trim().split(/\s+/).length <= 1 && !line.includes(' ')) ? Object.keys(BUILTINS).concat(['npm', 'node', 'pnpm', 'yarn', 'bun', 'deno', 'npx', 'corepack']).filter(c => c.startsWith(word)) : Object.keys(snap()).filter(f => f.startsWith(word));
 
+  const handleLine = line => {
+    if (blockLines.length > 0 || isControlStart(line)) {
+      blockLines.push(line); if (isBlockOpen(blockLines)) { rl.showContinuation(); return; }
+      const block = blockLines.slice(); blockLines = [];
+      runControl(block, run, ctx).then(() => rl.showPrompt()).catch(e => { term.write('\x1b[31m' + e.message + '\x1b[0m\r\n'); rl.showPrompt(); });
+      return;
+    }
+    run(line, onData).then(() => rl.showPrompt());
+  };
+  const rl = createReadline({ term, getCompletions, getPrompt: () => actor.getSnapshot().value === 'node-repl' ? '> ' : ctx.cwd, isBlockOpen: () => blockLines.length > 0, onLine: handleLine });
   function onData(data) {
-    if (data === '\x03') { actor.send({ type: 'ERROR' }); inputQueue = []; term.write('^C'); rl.showPrompt(); return; }
+    if (data === '\x03') { actor.send({ type: 'ERROR' }); inputQueue = []; blockLines = []; term.write('^C'); rl.showPrompt(); return; }
     const st = actor.getSnapshot().value;
-    if (st !== 'idle' && st !== 'node-repl') { inputQueue.push(data); return; }
-    rl.onData(data);
+    if (st !== 'idle' && st !== 'node-repl') inputQueue.push(data); else rl.onData(data);
   }
-
   term.onData(onData);
-  onPreviewWrite && (window.__debug.shell.onPreviewWrite = onPreviewWrite);
-  const runPublic = line => run(line, onData);
-  window.__debug.shell.run = runPublic;
   rl.showPrompt();
-  return { run: runPublic };
+  return {
+    run: line => run(line, onData), onPreviewWrite, httpHandlers, procsubRead: id => readStream(id), fdRead: fd => ctx.fdTable.readFd(fd),
+    get state() { return actor.getSnapshot().value; }, get cwd() { return ctx.cwd; }, get env() { return ctx.env; }, get history() { return ctx.history; },
+    get lastExitCode() { return ctx.lastExitCode; }, get inputQueue() { return inputQueue.slice(); },
+  };
 }

package/docs/terminal.js

@@ -3,7 +3,7 @@ import { createMachine, createActor } from './vendor/xstate.js';
 import { createShell } from './shell.js';
 import { registerPreviewSW } from './preview-sw-client.js';
 
-const IDB_KEY = 'thebird_fs_v2';
+const IDB_KEY = 'thebird_fs_v4';
 
 async function idbLoad() {
   return new Promise((res, rej) => {
@@ -44,7 +44,7 @@ function scheduleReload() {
   clearTimeout(reloadTimer);
   reloadTimer = setTimeout(() => {
     if (typeof window.refreshPreview === 'function') window.refreshPreview();
-  }, 5000);
+  }, 1000);
 }
 
 async function boot() {
@@ -57,7 +57,7 @@ async function boot() {
   window.__debug = window.__debug || {};
   window.__debug.terminal = { get state() { return bootActor.getSnapshot().value; } };
 
-  const term = new Terminal({ theme: { background: '#000000' }, convertEol: true });
+  const term = new Terminal({ theme: { background: '#000000', foreground: '#33ff33' }, convertEol: true });
   const fit = new FitAddon();
   term.loadAddon(fit);
   term.open(el);
@@ -78,19 +78,17 @@ async function boot() {
   window.__debug.term = term;
   bootActor.send({ type: 'IDB_READY' });
 
-  try {
-    const swPromise = registerPreviewSW();
-    const swTimeout = new Promise((_, rej) => setTimeout(() => rej(new Error('SW registration timeout')), 3000));
-    await Promise.race([swPromise, swTimeout]);
+  const shell = createShell({ term, onPreviewWrite: scheduleReload });
+  window.__debug.shell = shell;
+
+  registerPreviewSW().then(() => {
     bootActor.send({ type: 'SW_READY' });
-  } catch (e) {
+  }).catch(e => {
     console.log('[terminal] SW error:', e.message);
     window.__debug.sw = window.__debug.sw || {};
     window.__debug.sw.bootError = e.message;
     bootActor.send({ type: 'SW_ERROR' });
-  }
-
-  const shell = createShell({ term, onPreviewWrite: scheduleReload });
+  });
   window.__debug.shellWriter = { write: line => shell.run(line.replace(/\n$/, '')) };
 }