thebird 1.2.78 → 1.2.80

package/docs/shell.js

@@ -1,205 +1,197 @@
 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 keys = prefix === '/' ? Object.keys(snap()) : Object.keys(snap()).filter(k => k.startsWith(prefix));
-      wl(keys.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]) => {
-      window.__debug.idbSnapshot[toKey(resolvePath(ctx.cwd, p)) + '/.keep'] = '';
-      window.__debug.idbPersist?.();
-    },
-    rm: ([f]) => {
-      delete window.__debug.idbSnapshot[toKey(resolvePath(ctx.cwd, f))];
-      window.__debug.idbPersist?.();
-    },
-    cp: ([s, d]) => {
-      window.__debug.idbSnapshot[toKey(resolvePath(ctx.cwd, d))] = snap()[toKey(resolvePath(ctx.cwd, s))];
-      window.__debug.idbPersist?.();
-    },
-    mv: ([s, d]) => {
-      const src = toKey(resolvePath(ctx.cwd, s)), dst = toKey(resolvePath(ctx.cwd, d));
-      window.__debug.idbSnapshot[dst] = snap()[src];
-      delete window.__debug.idbSnapshot[src];
-      window.__debug.idbPersist?.();
-    },
-    env: () => wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n')),
-    export: ([kv]) => { const [k, ...v] = (kv || '').split('='); ctx.env[k] = v.join('='); },
-    clear: () => ctx.term.clear(),
-    help: () => wl(Object.keys(makeBuiltins(ctx)).join('  ')),
-    exit: (actor) => {
-      const st = actor.getSnapshot().value;
-      if (st === 'node-repl') { actor.send({ type: 'EXIT_REPL' }); wl('[shell]'); }
-    },
-    node: async ([file], actor) => {
-      if (!file) { actor.send({ type: 'ENTER_REPL' }); wl('[node repl — type exit to return]'); return; }
-      const path = resolvePath(ctx.cwd, file);
-      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);
-    },
-    npm: async (args, actor) => {
-      if (args[0] !== 'install') throw new Error('only npm install supported');
-      const pkg = args[1];
-      if (!pkg) throw new Error('npm install <pkg>');
-      actor.send({ type: 'NPM_START' });
-      w('fetching ' + pkg + '...\r\n');
-      const r = await fetch('https://esm.sh/' + pkg);
-      if (!r.ok) throw new Error('fetch failed: ' + r.status);
-      const key = 'node_modules/' + pkg + '/index.js';
-      window.__debug.idbSnapshot[key] = await r.text();
-      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', NPM_START: 'npm-installing', NODE_START: 'node-running' } },
+  idle: { on: { RUN: 'executing', ENTER_REPL: 'node-repl', NODE_START: 'node-running' } },
   executing: { on: { DONE: 'idle', ERROR: 'idle' } },
-  'npm-installing': { on: { DONE: 'idle', ERROR: 'idle' } },
   'node-running': { on: { DONE: 'idle', ERROR: 'idle' } },
   'node-repl': { on: { EXIT_REPL: 'idle', RUN: 'node-repl' } },
 }});
 
 export function createShell({ term, onPreviewWrite }) {
-  const ctx = { term, cwd: '/', env: {}, history: [], httpHandlers: {} };
-  const 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); }
 
-  function drainQueue(onData) {
-    const items = inputQueue.slice();
-    inputQueue = [];
-    for (const d of items) onData(d);
+  const toKey = p => p.replace(/^\//, '');
+  const snap = () => window.__debug.idbSnapshot || {};
+
+  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;
   }
 
-  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: ctx.httpHandlers,
-    get inputQueue() { return inputQueue.slice(); },
-  };
+  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 runCmd(line, capture, actor) {
-    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 '';
+  async function invokeBuiltin(name, args, withCaptureInto, stdinBuf) {
+    if (ctx.functions[name]) {
+      if (!withCaptureInto) { await runFunction(name, args); return ''; }
+      return captureFn(() => runFunction(name, args));
     }
-    let out = '';
-    const orig = term.write.bind(term);
-    term.write = s => { out += s; };
-    try { if (fn) await fn(args, actor); else out += 'command not found: ' + cmd + '\r\n'; }
-    finally { term.write = orig; }
-    return out;
+    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));
   }
 
-  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' });
+  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, actor);
-        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, actor);
+      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 snap = window.__debug.idbSnapshot || {};
-    const files = Object.keys(snap);
-    const tokens = line.trim().split(/\s+/);
-    if (tokens.length <= 1 && !line.includes(' ')) {
-      const cmds = Object.keys(BUILTINS);
-      return cmds.filter(c => c.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));
     }
-    return files.filter(f => f.startsWith(word));
+    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));
 
-  function onData(data) {
-    if (data === '\x03') {
-      actor.send({ type: 'ERROR' });
-      inputQueue = [];
-      term.write('^C');
-      rl.showPrompt();
+  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 = []; 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$/, '')) };
 }
 

package/docs/todo.html

@@ -0,0 +1,211 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Todo App</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding: 20px;
+        }
+
+        .container {
+            background: white;
+            border-radius: 10px;
+            box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
+            width: 100%;
+            max-width: 500px;
+            padding: 30px;
+        }
+
+        h1 {
+            color: #333;
+            margin-bottom: 20px;
+            text-align: center;
+        }
+
+        .input-group {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+
+        input[type="text"] {
+            flex: 1;
+            padding: 12px;
+            border: 2px solid #e0e0e0;
+            border-radius: 5px;
+            font-size: 16px;
+            transition: border-color 0.3s;
+        }
+
+        input[type="text"]:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+        button {
+            background: #667eea;
+            color: white;
+            border: none;
+            padding: 12px 25px;
+            border-radius: 5px;
+            font-size: 16px;
+            cursor: pointer;
+            transition: background 0.3s;
+        }
+
+        button:hover {
+            background: #764ba2;
+        }
+
+        .todo-list {
+            list-style: none;
+        }
+
+        .todo-item {
+            display: flex;
+            align-items: center;
+            gap: 12px;
+            padding: 15px;
+            background: #f5f5f5;
+            border-radius: 5px;
+            margin-bottom: 10px;
+            transition: all 0.3s;
+        }
+
+        .todo-item:hover {
+            background: #efefef;
+        }
+
+        .todo-item.completed {
+            opacity: 0.6;
+        }
+
+        .todo-item.completed .todo-text {
+            text-decoration: line-through;
+        }
+
+        .todo-checkbox {
+            width: 20px;
+            height: 20px;
+            cursor: pointer;
+        }
+
+        .todo-text {
+            flex: 1;
+            color: #333;
+            word-break: break-word;
+        }
+
+        .delete-btn {
+            background: #ff6b6b;
+            padding: 8px 12px;
+            font-size: 14px;
+        }
+
+        .delete-btn:hover {
+            background: #ff5252;
+        }
+
+        .empty-state {
+            text-align: center;
+            color: #999;
+            padding: 40px 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>📝 Todo App</h1>
+
+        <div class="input-group">
+            <input type="text" id="todoInput" placeholder="Add a new todo...">
+            <button onclick="addTodo()">Add</button>
+        </div>
+
+        <ul class="todo-list" id="todoList">
+            <li class="empty-state">No todos yet. Add one to get started!</li>
+        </ul>
+    </div>
+
+    <script>
+        let todos = JSON.parse(localStorage.getItem('todos')) || [];
+
+        function renderTodos() {
+            const todoList = document.getElementById('todoList');
+
+            if (todos.length === 0) {
+                todoList.innerHTML = '<li class="empty-state">No todos yet. Add one to get started!</li>';
+                return;
+            }
+
+            todoList.innerHTML = todos.map((todo, index) => `
+                <li class="todo-item ${todo.completed ? 'completed' : ''}">
+                    <input type="checkbox" class="todo-checkbox"
+                           ${todo.completed ? 'checked' : ''}
+                           onchange="toggleTodo(${index})">
+                    <span class="todo-text">${escapeHtml(todo.text)}</span>
+                    <button class="delete-btn" onclick="deleteTodo(${index})">Delete</button>
+                </li>
+            `).join('');
+        }
+
+        function addTodo() {
+            const input = document.getElementById('todoInput');
+            const text = input.value.trim();
+
+            if (text === '') {
+                alert('Please enter a todo!');
+                return;
+            }
+
+            todos.push({ text, completed: false });
+            localStorage.setItem('todos', JSON.stringify(todos));
+            input.value = '';
+            renderTodos();
+        }
+
+        function toggleTodo(index) {
+            todos[index].completed = !todos[index].completed;
+            localStorage.setItem('todos', JSON.stringify(todos));
+            renderTodos();
+        }
+
+        function deleteTodo(index) {
+            todos.splice(index, 1);
+            localStorage.setItem('todos', JSON.stringify(todos));
+            renderTodos();
+        }
+
+        function escapeHtml(text) {
+            const map = {
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#039;'
+            };
+            return text.replace(/[&<>"']/g, m => map[m]);
+        }
+
+        document.getElementById('todoInput').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') addTodo();
+        });
+
+        renderTodos();
+    </script>
+</body>
+</html>

package/package.json

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