Blame for terminal.js

function segLine(a) {
  if (!a || !a.enabled || a.segment == null) return '';
  const link = a.prev_head ? 'linked to previous head ' + String(a.prev_head).slice(0, 16) : 'first segment';
  return '\nsegment       ' + a.segment + ' (' + link + ')' +
    '\narchived      ' + a.archived_records + ' records, ' + a.segments_verified + ' earlier segment' + (a.segments_verified === 1 ? '' : 's') + ' re-verified' +
    (a.segments_failed && a.segments_failed.length ? ', FAILED: ' + a.segments_failed.join(',') : '');
}
/* ViKernel Desktop: Terminal app.

 * Browser-only shell over an in-memory virtual filesystem. Nothing here runs on a real server.

 * Live calls go only to api/ag/* through h.api. Security-sensitive commands are sent to the real gate.

 */
(function () {
  'use strict';

  const CDN = 'https://cdn.jsdelivr.net/npm/';
  const XTERM_JS = CDN + '@xterm/xterm@5.5.0/lib/xterm.js';
  const XTERM_CSS = CDN + '@xterm/xterm@5.5.0/css/xterm.css';
  const FIT_JS = CDN + '@xterm/addon-fit@0.10.0/lib/addon-fit.js';
  const VFS_KEY = 'vk_term_vfs_v1';
  const HIST_KEY = 'vk_term_hist_v1';
  const HOME = '/home/guest';

  // ANSI helpers
  const C = {
    r: s => '\x1b[31m' + s + '\x1b[0m', g: s => '\x1b[32m' + s + '\x1b[0m',
    y: s => '\x1b[33m' + s + '\x1b[0m', b: s => '\x1b[34m' + s + '\x1b[0m',
    c: s => '\x1b[36m' + s + '\x1b[0m', m: s => '\x1b[35m' + s + '\x1b[0m',
    dim: s => '\x1b[2m' + s + '\x1b[0m', bold: s => '\x1b[1m' + s + '\x1b[0m',
  };
  const stripAnsi = s => String(s).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');

  // ---------- CDN loader (inject once, await) ----------
  function loadTag(kind, url) {
    return new Promise((res, rej) => {
      const sel = kind === 'script' ? 'script[src="' + url + '"]' : 'link[href="' + url + '"]';
      const prev = document.querySelector(sel);
      if (prev) {
        if (prev.dataset.loaded === '1') return res();
        prev.addEventListener('load', () => res());
        prev.addEventListener('error', () => rej(new Error('cdn')));
        return;
      }
      const el = document.createElement(kind);
      if (kind === 'script') { el.src = url; el.async = false; } else { el.rel = 'stylesheet'; el.href = url; }
      el.addEventListener('load', () => { el.dataset.loaded = '1'; res(); });
      el.addEventListener('error', () => rej(new Error('cdn')));
      document.head.appendChild(el);
    });
  }
  function loadXterm() {
    if (!window.__vkXtermP) {
      window.__vkXtermP = Promise.all([loadTag('link', XTERM_CSS), loadTag('script', XTERM_JS)])
        .then(() => loadTag('script', FIT_JS))
        .then(() => { if (!window.Terminal || !window.FitAddon) throw new Error('cdn'); });
      window.__vkXtermP.catch(() => { window.__vkXtermP = null; });
    }
    return window.__vkXtermP;
  }

  // ---------- Virtual filesystem ----------
  const dir = (c) => ({ t: 'd', c: c || {} });
  const file = (d) => ({ t: 'f', d: d });

  function defaultFS() {
    return dir({
      home: dir({ guest: dir({
        'readme.txt': file('Welcome to ViKernel Desktop.\nThis terminal runs entirely in your browser on a virtual filesystem.\nTry: help, vik status, vik audit tail, ask "list my files", rm -rf /\n'),
        'notes.md': file('# Notes\n- Every agent action passes the gate first.\n- The audit log is a hash chain; verify it with `vik audit verify`.\n- The kill switch halts everything: `vik kill`.\n'),
        project: dir({
          'main.py': file('def main():\n    print("hello from a sandboxed project")\n\nif __name__ == "__main__":\n    main()\n'),
          'config.json': file('{\n  "name": "demo-project",\n  "version": "0.1.0",\n  "policy": "allowlist"\n}\n'),
        }),
      }) }),
      etc: dir({
        hostname: file('vikernel\n'),
        'os-release': file('NAME="ViKernel Secure OS"\nVERSION="1.0 (demo)"\nID=vikernel\nPRETTY_NAME="ViKernel Secure OS 1.0 (browser demo)"\n'),
        passwd: file('root:x:0:0:root:/root:/bin/vsh\ngate:x:100:100:policy gate:/var/gate:/sbin/nologin\nagent:x:200:200:agent runtime:/var/agent:/sbin/nologin\nguest:x:1000:1000:Guest:/home/guest:/bin/vsh\n'),
        shadow: file('(protected)'),
      }),
      var: dir({ log: dir({
        'vikernel.log': file('[    0.000] vikernel: boot, mode B (CPU reference)\n[    0.012] integrity: measured boot OK\n[    0.031] gate: policy loaded (allowlist + rules)\n[    0.044] audit: chain opened\n[    0.090] agent: runtime attached, model muse-spark-1.3\n'),
      }) }),
      apps: dir({}),
      tmp: dir({}),
    });
  }

  window.VK_TERM = (body, h) => {
    h = h || {};
    const api = h.api;
    let root;
    try { root = JSON.parse(sessionStorage.getItem(VFS_KEY) || 'null'); } catch (e) { root = null; }
    if (!root || root.t !== 'd') root = defaultFS();
    let cwd = HOME;
    let history = [];
    try { history = JSON.parse(sessionStorage.getItem(HIST_KEY) || '[]') || []; } catch (e) { history = []; }
    let halted = false;
    const poll = setInterval(() => { if (!body.isConnected) { clearInterval(poll); return; } refreshState(); }, 12000);
    window.addEventListener('vk-kernel-state', e => { halted = e.detail === 'HALTED'; });
    let online = true;

    const save = () => {
      try { sessionStorage.setItem(VFS_KEY, JSON.stringify(root)); } catch (e) { /* storage unavailable */ }
      try { sessionStorage.setItem(HIST_KEY, JSON.stringify(history.slice(-200))); } catch (e) { /* ignore */ }
    };

    // Sync /apps from the store's installed apps (shape tolerant).
    function installedIds() {
      const s = h.store;
      let list = [];
      try {
        if (typeof s === 'function') list = s() || [];
        else if (Array.isArray(s)) list = s;
        else if (s && Array.isArray(s.installed)) list = s.installed;
        else if (s && typeof s.installed === 'string') list = [s.installed];
        else if (s && s.installed && typeof s.installed === 'object') list = [s.installed];
      } catch (e) { list = []; }
      return list.map(a => (typeof a === 'string' ? a : (a && (a.id || a.name)))).filter(Boolean);
    }
    function addAppManifest(id, meta) {
      const apps = root.c.apps || (root.c.apps = dir());
      const d = apps.c[id] || (apps.c[id] = dir());
      d.c['manifest.json'] = file(JSON.stringify(Object.assign({ id: id, source: 'store', note: 'installed for this session' }, meta || {}), null, 2) + '\n');
    }
    installedIds().forEach(id => { if (!root.c.apps.c[id]) addAppManifest(id); });

    // Path helpers
    function norm(p) {
      if (!p || p === '~') p = HOME;
      else if (p.startsWith('~/')) p = HOME + p.slice(1);
      if (!p.startsWith('/')) p = cwd + '/' + p;
      const out = [];
      p.split('/').forEach(seg => {
        if (!seg || seg === '.') return;
        if (seg === '..') out.pop(); else out.push(seg);
      });
      return '/' + out.join('/');
    }
    function lookup(p) {
      let n = root;
      for (const seg of norm(p).split('/').filter(Boolean)) {
        if (!n || n.t !== 'd' || !n.c[seg]) return null;
        n = n.c[seg];
      }
      return n;
    }
    function parentOf(p) {
      const a = norm(p); const i = a.lastIndexOf('/');
      return { dir: lookup(a.slice(0, i) || '/'), name: a.slice(i + 1), path: a };
    }
    const disp = p => (p === HOME ? '~' : p.startsWith(HOME + '/') ? '~' + p.slice(HOME.length) : p);
    const isShadow = p => norm(p) === '/etc/shadow';
    function readFile(p) {
      if (isShadow(p)) throw new Error(p + ': permission denied (sandbox)');
      const n = lookup(p);
      if (!n) throw new Error(p + ': no such file or directory');
      if (n.t === 'd') throw new Error(p + ': is a directory');
      return n.d;
    }
    function writeFile(p, data, append) {
      if (isShadow(p) || norm(p).startsWith('/etc/')) throw new Error(p + ': permission denied (sandbox)');
      const { dir: d, name } = parentOf(p);
      if (!d || d.t !== 'd') throw new Error(p + ': no such file or directory');
      if (d.c[name] && d.c[name].t === 'd') throw new Error(p + ': is a directory');
      d.c[name] = file((append && d.c[name] ? d.c[name].d : '') + data);
      save();
    }
    function mkdirP(p) {
      let n = root;
      for (const seg of norm(p).split('/').filter(Boolean)) {
        if (!n.c[seg]) n.c[seg] = dir();
        n = n.c[seg];
        if (n.t !== 'd') throw new Error(p + ': not a directory');
      }
    }
    const clone = n => JSON.parse(JSON.stringify(n));
    function walk(n, p, fn) {
      fn(p, n);
      if (n.t === 'd') Object.keys(n.c).sort().forEach(k => walk(n.c[k], (p === '/' ? '' : p) + '/' + k, fn));
    }
    async function sha256(text) {
      const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
      return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
    }

    // Flag parsing: returns {f:Set, n:value, rest:[]}
    function flags(args, withValue) {
      const f = new Set(); const rest = []; const vals = {};
      for (let i = 0; i < args.length; i++) {
        const a = args[i];
        if (withValue && withValue.includes(a)) { vals[a] = args[++i]; continue; }
        if (/^-[A-Za-z]+$/.test(a)) a.slice(1).split('').forEach(ch => f.add(ch)); else rest.push(a);
      }
      return { f, vals, rest };
    }

    // ---------- Live backend helpers ----------
    function apiErr(e) {
      if (e && e.message === 'rate') return C.y('The live backend is busy (rate limit). Please wait a few seconds and try again.');
      online = false;
      return C.r('live backend unavailable (' + ((e && e.message) || 'error') + ')');
    }
    async function refreshState() {
      try { const s = await api('status'); halted = String(s.kernel_state || '').toUpperCase() === 'HALTED'; online = true; return s; }
      catch (e) { return null; }
    }
    function verdictLine(v) {
      const verdict = String(v.verdict || '?').toUpperCase();
      const col = verdict === 'ALLOW' ? C.g : verdict === 'HALTED' ? C.y : C.r;
      const rule = v.reason ? ' (' + v.reason + ')' : (v.rule ? ' (rule ' + v.rule + ')' : '');
      const seq = v.audit_seq != null ? ' audit #' + v.audit_seq : '';
      return col(verdict + rule + seq);
    }
    async function gate(fn, args) {
      try {
        const v = await api('gate/decide', { fn: fn, args: args });
        if (String(v.verdict).toUpperCase() === 'HALTED') halted = true;
        return v;
      } catch (e) { return { error: apiErr(e) }; }
    }

    // ---------- Commands: (args, stdin) -> string ----------
    const HELP = {
      ls: 'ls [-l] [-a] [path]  list directory', cd: 'cd [dir]  change directory', pwd: 'pwd  print working directory',
      cat: 'cat <file...>  print files', echo: 'echo <text>  print text', mkdir: 'mkdir [-p] <dir>  create directory',
      touch: 'touch <file>  create empty file', rm: 'rm [-r] [-f] <path>  remove', cp: 'cp [-r] <src> <dst>  copy',
      mv: 'mv <src> <dst>  move or rename', grep: 'grep [-i] [-n] <pattern> [file]  search text',
      head: 'head [-n N] [file]  first lines', tail: 'tail [-n N] [file]  last lines', wc: 'wc [-l] [-w] [-c] [file]  count',
      find: 'find [path] [-name pattern]  find files', tree: 'tree [path]  directory tree', whoami: 'whoami  current user',
      uname: 'uname [-a]  system info', date: 'date  current date', history: 'history  command history',
      clear: 'clear  clear the screen (Ctrl+L)', help: 'help  list commands', man: 'man <cmd>  command manual',
      top: 'top  process snapshot', ps: 'ps  process list', download: 'download <file>  save a VFS file to your computer',
      vik: 'vik status | kill | resume --key <k> | audit tail [n] | audit verify | policy list | apps list|install <id>|remove',
      vdrpack: 'vdrpack init <dir> | build <dir> <out.vdr> | sign <file> | verify <file>  (browser preview)',
      ask: 'ask "<prompt>"  send a request to the gated agent (Meta Muse Spark 1.3)',
    };

    function lsLine(name, n, long) {
      const label = n.t === 'd' ? C.b(name + '/') : name;
      if (!long) return label;
      const size = n.t === 'd' ? 4096 : n.d.length;
      return (n.t === 'd' ? 'drwxr-xr-x' : '-rw-r--r--') + ' guest guest ' + String(size).padStart(6) + ' ' + label;
    }
    function procTable() {
      const apps = Object.keys((root.c.apps && root.c.apps.c) || {});
      const rows = [['1', 'root', '0.3', '1.2', halted ? 'T' : 'S', 'vikernel (kernel, mode B)'],
        ['42', 'gate', '0.8', '0.6', 'S', 'gate --policy allowlist+rules'],
        ['77', 'agent', '2.1', '3.4', halted ? 'T' : 'S', 'agent --model muse-spark-1.3'],
        ['91', 'root', '0.1', '0.2', 'S', 'auditd --chain sha256']];
      apps.forEach((a, i) => rows.push([String(120 + i), 'guest', '0.2', '0.5', halted ? 'T' : 'S', 'app ' + a + ' (sandboxed)']));
      rows.push(['300', 'guest', '0.0', '0.1', 'R', 'vsh (this terminal)']);
      return '  PID USER   %CPU %MEM S COMMAND\n' + rows.map(r => r[0].padStart(5) + ' ' + r[1].padEnd(6) + ' ' + r[2].padStart(4) + ' ' + r[3].padStart(4) + ' ' + r[4] + ' ' + r[5]).join('\n');
    }

    const cmds = {
      async help() {
        return C.bold('ViKernel shell (browser preview). Commands:') + '\n' +
          Object.keys(HELP).sort().map(k => '  ' + C.c(k.padEnd(9)) + ' ' + HELP[k].replace(/^\S+\s*/, '')).join('\n') +
          '\nPipes (|) and redirects (>, >>) work. Tab completes. Ctrl+Shift+C copies, Ctrl+V pastes.';
      },
      async man(a) {
        if (!a[0]) return 'What manual page do you want?';
        return HELP[a[0]] ? C.bold(a[0].toUpperCase() + '(1)') + '\n\nSYNOPSIS\n  ' + HELP[a[0]] : 'No manual entry for ' + a[0];
      },
      async pwd() { return cwd; },
      async whoami() { return 'guest'; },
      async date() { return new Date().toString(); },
      async uname(a) { return a.includes('-a') ? 'ViKernel vikernel 1.0-demo #1 SMP mode-B (CPU reference) wasm32 browser ViKernel/OS' : 'ViKernel'; },
      async history() { return history.map((l, i) => String(i + 1).padStart(4) + '  ' + l).join('\n'); },
      async echo(a) { return a.join(' '); },
      async ps() { return procTable(); },
      async top() { return C.bold('top - ' + new Date().toTimeString().slice(0, 8) + ' up 0 min, 1 user, kernel ' + (halted ? C.y('HALTED') : C.g('RUNNING'))) + '\n' + procTable() + '\n' + C.dim('(static snapshot)'); },
      async cd(a) {
        const p = norm(a[0] || '~'); const n = lookup(p);
        if (!n) throw new Error('cd: ' + a[0] + ': no such file or directory');
        if (n.t !== 'd') throw new Error('cd: ' + a[0] + ': not a directory');
        cwd = p; return '';
      },
      async ls(a) {
        const { f, rest } = flags(a);
        const targets = rest.length ? rest : ['.'];
        return targets.map(t => {
          const n = lookup(t);
          if (!n) throw new Error('ls: cannot access ' + t + ': no such file or directory');
          if (n.t === 'f') return lsLine(t, n, f.has('l'));
          let names = Object.keys(n.c).sort();
          if (!f.has('a')) names = names.filter(x => !x.startsWith('.'));
          else names = ['.', '..'].concat(names);
          const lines = names.map(x => lsLine(x, n.c[x] || dir(), f.has('l')));
          const body = f.has('l') ? lines.join('\n') : lines.join('  ');
          return (targets.length > 1 ? t + ':\n' : '') + body;
        }).join('\n');
      },
      async cat(a, stdin) {
        if (!a.length) return stdin || '';
        return a.map(p => readFile(p)).join('').replace(/\n$/, '');
      },
      async mkdir(a) {
        const { f, rest } = flags(a);
        rest.forEach(p => {
          if (f.has('p')) return mkdirP(p);
          const { dir: d, name } = parentOf(p);
          if (!d) throw new Error('mkdir: cannot create ' + p + ': no such file or directory');
          if (d.c[name]) throw new Error('mkdir: cannot create ' + p + ': file exists');
          d.c[name] = dir();
        });
        save(); return '';
      },
      async touch(a) { a.forEach(p => { if (!lookup(p)) writeFile(p, ''); }); return ''; },
      async rm(a) {
        const { f, rest } = flags(a);
        rest.forEach(p => {
          const { dir: d, name, path } = parentOf(p);
          if (path.startsWith('/etc') || path === '/') throw new Error('rm: ' + p + ': permission denied (sandbox)');
          if (!d || !d.c[name]) { if (!f.has('f')) throw new Error('rm: cannot remove ' + p + ': no such file or directory'); return; }
          if (d.c[name].t === 'd' && !f.has('r')) throw new Error('rm: cannot remove ' + p + ': is a directory');
          delete d.c[name];
        });
        save(); return '';
      },
      async cp(a) {
        const { f, rest } = flags(a);
        if (rest.length < 2) throw new Error('cp: missing operand');
        const src = lookup(rest[0]);
        if (!src || isShadow(rest[0])) throw new Error('cp: cannot stat ' + rest[0]);
        if (src.t === 'd' && !f.has('r')) throw new Error('cp: -r not specified; omitting directory ' + rest[0]);
        let dst = rest[1]; const dn = lookup(dst);
        if (dn && dn.t === 'd') dst = norm(dst) + '/' + norm(rest[0]).split('/').pop();
        const { dir: d, name } = parentOf(dst);
        if (!d) throw new Error('cp: cannot create ' + rest[1]);
        d.c[name] = clone(src); save(); return '';
      },
      async mv(a) {
        if (a.length < 2) throw new Error('mv: missing operand');
        const s = parentOf(a[0]);
        if (!s.dir || !s.dir.c[s.name] || s.path.startsWith('/etc')) throw new Error('mv: cannot move ' + a[0]);
        let dst = a[1]; const dn = lookup(dst);
        if (dn && dn.t === 'd') dst = norm(dst) + '/' + s.name;
        const d = parentOf(dst);
        if (!d.dir) throw new Error('mv: cannot move to ' + a[1]);
        d.dir.c[d.name] = s.dir.c[s.name]; delete s.dir.c[s.name]; save(); return '';
      },
      async grep(a, stdin) {
        const { f, rest } = flags(a);
        if (!rest.length) throw new Error('usage: grep [-i] [-n] pattern [file]');
        let re;
        try { re = new RegExp(rest[0], f.has('i') ? 'i' : ''); } catch (e) { throw new Error('grep: bad pattern'); }
        const text = rest[1] ? readFile(rest[1]) : (stdin || '');
        return text.split('\n').map((l, i) => re.test(l) ? (f.has('n') ? C.g(String(i + 1)) + ':' : '') + l : null).filter(x => x !== null).join('\n');
      },
      async head(a, stdin) {
        const { vals, rest } = flags(a, ['-n']); const n = parseInt(vals['-n'] || '10', 10);
        return (rest[0] ? readFile(rest[0]) : stdin || '').replace(/\n$/, '').split('\n').slice(0, n).join('\n');
      },
      async tail(a, stdin) {
        const { vals, rest } = flags(a, ['-n']); const n = parseInt(vals['-n'] || '10', 10);
        return (rest[0] ? readFile(rest[0]) : stdin || '').replace(/\n$/, '').split('\n').slice(-n).join('\n');
      },
      async wc(a, stdin) {
        const { f, rest } = flags(a);
        const t = rest[0] ? readFile(rest[0]) : (stdin || '');
        const l = (t.match(/\n/g) || []).length, w = (t.match(/\S+/g) || []).length, c = new TextEncoder().encode(t).length;
        const parts = [];
        if (!f.size || f.has('l')) parts.push(l);
        if (!f.size || f.has('w')) parts.push(w);
        if (!f.size || f.has('c')) parts.push(c);
        return parts.map(x => String(x).padStart(7)).join('') + (rest[0] ? ' ' + rest[0] : '');
      },
      async find(a) {
        const { vals, rest } = flags(a, ['-name']);
        const base = norm(rest[0] || '.'); const n = lookup(base);
        if (!n) throw new Error('find: ' + rest[0] + ': no such file or directory');
        const pat = vals['-name'] ? new RegExp('^' + vals['-name'].replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$') : null;
        const out = [];
        walk(n, base, (p) => { if (!pat || pat.test(p.split('/').pop())) out.push(p); });
        return out.join('\n');
      },
      async tree(a) {
        const base = norm(a[0] || '.'); const n = lookup(base);
        if (!n || n.t !== 'd') throw new Error('tree: ' + (a[0] || '.') + ': not a directory');
        const lines = [C.b(disp(base))]; let nd = 0, nf = 0;
        (function rec(d, pre) {
          const ks = Object.keys(d.c).sort();
          ks.forEach((k, i) => {
            const last = i === ks.length - 1; const c = d.c[k];
            lines.push(pre + (last ? '`-- ' : '|-- ') + (c.t === 'd' ? C.b(k) : k));
            if (c.t === 'd') { nd++; rec(c, pre + (last ? '    ' : '|   ')); } else nf++;
          });
        })(n, '');
        return lines.join('\n') + '\n\n' + nd + ' directories, ' + nf + ' files';
      },
      async download(a) {
        if (!a[0]) throw new Error('usage: download <file>');
        const text = readFile(a[0]);
        const url = URL.createObjectURL(new Blob([text], { type: 'application/octet-stream' }));
        const link = document.createElement('a');
        link.href = url; link.download = norm(a[0]).split('/').pop();
        document.body.appendChild(link); link.click(); link.remove();
        setTimeout(() => URL.revokeObjectURL(url), 2000);
        return C.g('downloaded ' + link.download + ' (' + text.length + ' bytes, from the browser VFS)');
      },

      async vik(a) {
        const sub = a[0], sub2 = a[1];
        try {
          if (sub === 'status') {
            const s = await api('status');
            halted = String(s.kernel_state || '').toUpperCase() === 'HALTED'; online = true;
            const st = halted ? C.y(s.kernel_state) : C.g(s.kernel_state);
            return 'kernel_state  ' + st + '\naudit_n       ' + s.audit_n + '\naudit_head    ' + String(s.audit_head || '').slice(0, 16) +
              '\nverified      ' + (s.verified ? C.g('true') : C.r(String(s.verified))) + segLine(s.archive);
          }
          if (sub === 'kill') {
            const r = await api('kill', {}); await refreshState();
            return C.y((r && (r.message || r.msg)) || 'kill switch engaged');
          }
          if (sub === 'resume') {
            const i = a.indexOf('--key'); const key = i >= 0 ? a[i + 1] : '';
            if (!key) return 'usage: vik resume --key <operator key>';
            const r = await api('resume', { key: key }); await refreshState();
            const msg = (r && (r.message || r.msg)) || (halted ? 'refused' : 'resumed');
            return halted ? C.r(msg) : C.g(msg);
          }
          if (sub === 'audit' && sub2 === 'tail') {
            const n = parseInt(a[2] || '10', 10) || 10;
            const r = await api('audit');
            const rows = (r.entries || r.audit || r.rows || (Array.isArray(r) ? r : [])).slice(-n);
            if (!rows.length) return '(audit log is empty)';
            return rows.map(e => {
              const ok = e.ok === false || /DENY|REFUS/i.test(String(e.verdict || '')) ? C.r('refused') : C.g('ok');
              return '#' + e.seq + ' ' + (e.actor || '-') + ' ' + (e.cmd || e.fn || '-') + ' ' + ok + ' ' + (e.state || e.kernel_state || '-') + ' ' + C.dim(String(e.chain || e.hash || '').slice(0, 12));
            }).join('\n');
          }
          if (sub === 'audit' && sub2 === 'verify') {
            const r = await api('audit'); const v = r.verify || {};
            return 'verify.ok  ' + (v.ok ? C.g('true') : C.r(String(v.ok))) + '\nverify.n   ' + v.n;
          }
          if (sub === 'policy' && sub2 === 'list') {
            return C.bold('RULE  MEANING') + '\n' +
              '  ' + C.g('A') + '   allowlisted action: allowed and recorded in the audit chain\n' +
              '  ' + C.r('D') + '   dangerous action (shell, network send, secrets): denied\n' +
              '  ' + C.r('F') + '   function not on the allowlist: denied\n' +
              '  ' + C.c('M') + '   store apps may only call what their manifest declares\n' +
              '  ' + C.y('HALT') + ' kill switch engaged: every action is refused until operator resume';
          }
          if (sub === 'apps') {
            if (sub2 === 'list') {
              const r = await api('store/catalog');
              const apps = r.apps || r.catalog || r.items || (Array.isArray(r) ? r : []);
              const inst = Object.keys(root.c.apps.c);
              return apps.map(x => (inst.includes(x.id) ? C.g('* ') : '  ') + C.c(String(x.id).padEnd(18)) + ' ' + (x.name || '') + (x.desc || x.description ? C.dim('  ' + (x.desc || x.description)) : '')).join('\n') + '\n' + C.dim('(* = installed in this session)');
            }
            if (sub2 === 'install') {
              if (!a[2]) return 'usage: vik apps install <id>';
              const r = await api('store/install', { id: a[2], session: window.VK_SID });
              addAppManifest(a[2], r && r.manifest ? r.manifest : null); save();
              return C.g('installed ' + a[2]) + ' -> /apps/' + a[2] + '/manifest.json' + (r && r.message ? '\n' + r.message : '');
            }
            if (sub2 === 'remove') {
              const r = await api('store/install', { id: '', session: window.VK_SID });
              root.c.apps = dir(); save();
              return C.y((r && r.message) || 'apps removed for this session');
            }
          }
        } catch (e) { return apiErr(e); }
        return 'usage: ' + HELP.vik;
      },

      async vdrpack(a) {
        const note = C.dim('browser preview. Real packages are built with vdrpack.py (downloadable at downloads/vdrpack.py).');
        const [sub, x, y] = a;
        if (sub === 'init') {
          if (!x) return 'usage: vdrpack init <dir>';
          mkdirP(x + '/app');
          const name = norm(x).split('/').pop();
          writeFile(x + '/manifest.json', JSON.stringify({ id: name, version: '0.1.0', entry: 'app/workflow.json', permissions: ['read_file'] }, null, 2) + '\n');
          writeFile(x + '/app/workflow.json', JSON.stringify({ steps: [{ fn: 'read_file', args: { path: '~/readme.txt' } }] }, null, 2) + '\n');
          writeFile(x + '/icon.png', '(placeholder icon)');
          return C.g('initialized ' + disp(norm(x))) + ': manifest.json, app/workflow.json, icon.png\n' + note;
        }
        if (sub === 'build') {
          if (!x || !y) return 'usage: vdrpack build <dir> <out.vdr>';
          const n = lookup(x); if (!n || n.t !== 'd') throw new Error('vdrpack: ' + x + ': not a directory');
          const base = norm(x); const files = [];
          const list = []; walk(n, base, (p, m) => { if (m.t === 'f') list.push([p, m.d]); });
          for (const [p, d] of list) files.push({ path: p.slice(base.length + 1), size: d.length, sha256: await sha256(d) });
          writeFile(y, JSON.stringify({ format: 'vdr-preview', label: 'browser preview', built: new Date().toISOString(), files: files }, null, 2) + '\n');
          return C.g('built ' + y) + ' (' + files.length + ' files hashed with sha256)\n' + note;
        }
        if (sub === 'sign') {
          if (!x) return 'usage: vdrpack sign <file>';
          const pkg = JSON.parse(readFile(x));
          const digest = await sha256(JSON.stringify(pkg.files || []));
          pkg.signature = { label: 'demo signature (browser preview, not ed25519)', value: 'demo-' + digest.slice(0, 32) };
          writeFile(x, JSON.stringify(pkg, null, 2) + '\n');
          return C.y('signed ' + x + ' with a demo signature (browser preview, not ed25519)') + '\n' + note;
        }
        if (sub === 'verify') {
          if (!x) return 'usage: vdrpack verify <file>';
          const pkg = JSON.parse(readFile(x));
          const dirGuess = norm(x).replace(/\/[^/]*$/, '');
          const out = []; let bad = 0;
          for (const fl of pkg.files || []) {
            let cur = null;
            const cands = [dirGuess + '/' + (norm(x).split('/').pop().replace(/\.vdr$/, '')) + '/' + fl.path, dirGuess + '/' + fl.path];
            for (const c of cands) { const m = lookup(c); if (m && m.t === 'f') { cur = await sha256(m.d); break; } }
            const ok = cur === fl.sha256; if (!ok) bad++;
            out.push((ok ? C.g('OK  ') : C.r(cur ? 'BAD ' : 'MISS')) + ' ' + fl.path);
          }
          out.push(pkg.signature ? C.y('signature: ' + pkg.signature.label) : C.dim('unsigned'));
          out.push(bad ? C.r(bad + ' file(s) failed') : C.g('all hashes match'));
          return out.join('\n') + '\n' + note;
        }
        return 'usage: ' + HELP.vdrpack + '\n' + note;
      },

      async ask(a) {
        const msg = a.join(' ').trim();
        if (!msg) return 'usage: ask "<prompt>"';
        let r;
        try { r = await withSpinner(api('chat', { message: msg, session: window.VK_SID })); } catch (e) { return apiErr(e); }
        const out = [];
        (r.events || []).forEach(ev => {
          const t = ev.type;
          if (t === 'proposed') out.push(C.dim('proposed  ' + ev.fn + '(' + JSON.stringify(ev.args || {}) + ')  ' + (ev.model || '') + ' ' + (ev.model_ms != null ? ev.model_ms + 'ms' : '') + ' ' + (ev.tokens != null ? ev.tokens + ' tok' : '')));
          else if (t === 'verdict') { out.push('verdict   ' + ev.fn + ' ' + verdictLine(ev)); if (String(ev.verdict).toUpperCase() === 'HALTED') halted = true; }
          else if (t === 'executed') { const res = typeof ev.result === 'string' ? ev.result : JSON.stringify(ev.result); out.push(C.c('executed  ' + ev.fn) + C.dim(' -> ' + String(res).slice(0, 300))); }
          else if (t === 'final') out.push('\n' + C.bold(ev.text || '') + (ev.model ? C.dim('\n[' + ev.model + ']') : ''));
        });
        return out.join('\n') || '(no response)';
      },
    };

    // ---------- Security demo routing ----------
    async function securityIntercept(line) {
      const t = line.trim();
      let fn = null, args = null, label = '';
      if (/^sudo\b/.test(t)) { fn = 'run_shell'; args = { command: t }; }
      else if (/^rm\b/.test(t) && /(^|\s)\/(\s|$|\*)|(^|\s)\/etc\b/.test(t)) { fn = 'run_shell'; args = { command: t }; }
      else if (/^(curl|wget)\b/.test(t)) {
        const url = (t.split(/\s+/).find(x => /^https?:\/\//i.test(x)) || t.split(/\s+/).pop() || '');
        fn = 'http_post'; args = { url: url, body: '' };
      } else if (/\/etc\/shadow\b/.test(t)) { fn = 'read_file'; args = { path: '/etc/shadow' }; label = 'shadow'; }
      if (!fn) return null;
      const v = await withSpinner(gate(fn, args));
      if (v.error) return v.error + '\n' + C.r('blocked locally (sandbox)');
      let out = C.dim('gate/decide ' + fn) + '\n' + verdictLine(v);
      if (String(v.verdict).toUpperCase() === 'ALLOW') out += '\n' + C.r(label === 'shadow' ? 'permission denied (sandbox)' : 'not executed: this terminal is a sandbox');
      return out;
    }

    // ---------- Parser and pipeline ----------
    function tokenize(s) {
      const toks = []; let cur = ''; let q = null; let has = false;
      for (let i = 0; i < s.length; i++) {
        const ch = s[i];
        if (q) { if (ch === q) q = null; else if (ch === '\\' && q === '"' && i + 1 < s.length) cur += s[++i]; else cur += ch; continue; }
        if (ch === '"' || ch === "'") { q = ch; has = true; continue; }
        if (/\s/.test(ch)) { if (cur || has) toks.push(cur); cur = ''; has = false; continue; }
        if (ch === '|') { if (cur || has) toks.push(cur); toks.push({ op: '|' }); cur = ''; has = false; continue; }
        if (ch === '>') {
          if (cur || has) toks.push(cur); cur = ''; has = false;
          if (s[i + 1] === '>') { toks.push({ op: '>>' }); i++; } else toks.push({ op: '>' });
          continue;
        }
        cur += ch;
      }
      if (q) throw new Error('syntax error: unterminated quote');
      if (cur || has) toks.push(cur);
      return toks;
    }
    const ALWAYS = l => /^\s*(vik\s+status|vik\s+resume|clear|help)\b/.test(l);

    async function execLine(line) {
      if (!line.trim()) return '';
      if (halted && !ALWAYS(line)) await refreshState();
      if (halted && !ALWAYS(line)) return C.y('Kernel halted in your session. Press RESUME or type: vik resume --key <demo key from the guide> to continue.');
      const sec = await securityIntercept(line);
      if (sec !== null) return sec;
      const toks = tokenize(line);
      let redirect = null;
      const ri = toks.findIndex(x => typeof x === 'object' && x.op !== '|');
      if (ri >= 0) {
        if (typeof toks[ri + 1] !== 'string') throw new Error('syntax error near ' + toks[ri].op);
        redirect = { op: toks[ri].op, path: toks[ri + 1] };
        toks.splice(ri, 2);
      }
      const segs = [[]];
      toks.forEach(x => { if (typeof x === 'object' && x.op === '|') segs.push([]); else segs[segs.length - 1].push(x); });
      let data = '';
      for (const seg of segs) {
        if (!seg.length) throw new Error('syntax error near |');
        const name = seg[0];
        if (name === 'clear') { term.clear(); data = ''; continue; }
        const fnc = cmds[name];
        if (!fnc) throw new Error(name + ': command not found (try help)');
        data = await fnc(seg.slice(1), data);
        if (data == null) data = '';
        if (segs.length > 1) data = stripAnsi(data) + (data && !data.endsWith('\n') ? '\n' : '');
      }
      if (redirect) {
        writeFile(redirect.path, stripAnsi(data) + (data && !data.endsWith('\n') ? '\n' : ''), redirect.op === '>>');
        return '';
      }
      return String(data).replace(/\n$/, '');
    }

    // ---------- Terminal front end (xterm or fallback) ----------
    let term = null;
    let busy = false;
    let spinTimer = null;
    const prompt = () => C.g('guest@vikernel') + ':' + C.b(disp(cwd)) + '$ ';

    async function withSpinner(p) {
      const frames = ['|', '/', '-', '\\']; let i = 0;
      if (term && term.write) {
        term.write(C.dim(' working '));
        spinTimer = setInterval(() => term.write('\b' + frames[i++ % 4]), 100);
        term.write(' ');
      }
      try { return await p; }
      finally {
        clearInterval(spinTimer); spinTimer = null;
        if (term && term.write) term.write('\r\x1b[K');
      }
    }

    function out(s) { if (s) term.write(String(s).replace(/\r?\n/g, '\r\n') + '\r\n'); }

    async function runAndPrint(line) {
      busy = true;
      if (line.trim()) { history.push(line); save(); }
      try {
        const res = await execLine(line);
        out(res);
        if (/^\s*vik\s+(kill|resume)\b/.test(line) && h.toast) h.toast(halted ? 'Kernel halted' : 'Kernel running');
      } catch (e) { out(C.r(e.message || String(e))); }
      busy = false;
    }

    function completions(line) {
      const words = line.split(/\s+/); const last = words[words.length - 1];
      if (words.length === 1) return { last, items: Object.keys(cmds).concat(['clear']).filter(c => c.startsWith(last)) };
      const slash = last.lastIndexOf('/');
      const dpart = slash >= 0 ? last.slice(0, slash + 1) : '';
      const base = slash >= 0 ? last.slice(slash + 1) : last;
      const n = lookup(dpart || '.');
      if (!n || n.t !== 'd') return { last, items: [] };
      return { last, items: Object.keys(n.c).filter(k => k.startsWith(base)).map(k => dpart + k + (n.c[k].t === 'd' ? '/' : '')) };
    }

    async function boot() {
      let skip = false;
      const skipper = () => { skip = true; };
      body.addEventListener('keydown', skipper, true);
      const pause = ms => skip ? Promise.resolve() : new Promise(r => setTimeout(r, ms));
      const ln = async (s, ms) => { out(s); await pause(ms); };
      await ln(C.bold('ViKernel Secure OS boot'), 220);
      await ln('[ ' + C.g('OK') + ' ] integrity check ... OK', 220);
      await ln('[ ' + C.g('OK') + ' ] kernel mode B (CPU reference)', 220);
      await ln('[ ' + C.g('OK') + ' ] policy loaded (allowlist + rules)', 200);
      const s = await refreshState();
      if (s) {
        await ln('[ ' + C.g('OK') + ' ] audit chain head ' + String(s.audit_head || '').slice(0, 16), 220);
        await ln('[ ' + C.g('OK') + ' ] agent: Meta Muse Spark 1.3', 200);
        if (halted) out(C.y('kernel is HALTED. Resume with: vik resume --key <operator key>'));
      } else {
        await ln('[ ' + C.y('!!') + ' ] live backend unavailable, offline mode', 200);
        await ln('[ ' + C.g('OK') + ' ] agent: Meta Muse Spark 1.3', 100);
      }
      body.removeEventListener('keydown', skipper, true);
      out(C.dim('Type help for commands. Everything here runs in your browser; security actions go to the live gate.'));
    }

    function startXterm() {
      body.innerHTML = '';
      body.style.background = '#0B1020';
      const host = document.createElement('div');
      host.style.cssText = 'width:100%;height:100%;padding:6px;box-sizing:border-box;background:#0B1020;';
      body.appendChild(host);
      term = new window.Terminal({
        cursorBlink: true, scrollback: 2000, fontSize: 13, convertEol: false,
        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace',
        theme: { background: '#0B1020', foreground: '#D6DEEB', cursor: '#7FDBCA', selectionBackground: '#1D3B53',
          black: '#1B2333', red: '#EF5350', green: '#22DA6E', yellow: '#FFCB6B', blue: '#82AAFF', magenta: '#C792EA', cyan: '#7FDBCA', white: '#D6DEEB',
          brightBlack: '#637777', brightRed: '#FF6B6B', brightGreen: '#5CF19E', brightYellow: '#FFE08A', brightBlue: '#A3C2FF', brightMagenta: '#DDB3FF', brightCyan: '#A5F0E0', brightWhite: '#FFFFFF' },
      });
      const fit = new window.FitAddon.FitAddon();
      term.loadAddon(fit); term.open(host);
      const doFit = () => { try { fit.fit(); } catch (e) { /* hidden window */ } };
      doFit();
      try { new ResizeObserver(doFit).observe(body); } catch (e) { window.addEventListener('resize', doFit); }

      const copySel = () => { const s = term.getSelection(); if (s && navigator.clipboard) navigator.clipboard.writeText(s).catch(() => {}); return !!s; };
      term.attachCustomKeyEventHandler(ev => {
        if (ev.type !== 'keydown') return true;
        if (ev.ctrlKey && ev.shiftKey && (ev.key === 'C' || ev.key === 'c')) { copySel(); if (h.toast) h.toast('Copied'); return false; }
        if (ev.ctrlKey && (ev.key === 'v' || ev.key === 'V')) return false; // let the browser paste event reach xterm
        return true;
      });
      host.addEventListener('contextmenu', ev => { if (copySel()) { ev.preventDefault(); if (h.toast) h.toast('Copied'); } });

      let line = '', cur = 0, hIdx = -1, draft = '';
      const redraw = () => {
        term.write('\r\x1b[K' + prompt() + line);
        const back = line.length - cur; if (back > 0) term.write('\x1b[' + back + 'D');
      };
      const showPrompt = () => { line = ''; cur = 0; hIdx = -1; term.write(prompt()); };

      term.onData(async d => {
        if (busy) return;
        if (d === '\r') {
          term.write('\r\n'); const l = line; line = ''; cur = 0; hIdx = -1;
          await runAndPrint(l); showPrompt(); return;
        }
        if (d === '\x03') { term.write('^C\r\n'); showPrompt(); return; }
        if (d === '\x0c') { term.clear(); redraw(); return; }
        if (d === '\x7f' || d === '\b') { if (cur > 0) { line = line.slice(0, cur - 1) + line.slice(cur); cur--; redraw(); } return; }
        if (d === '\x1b[3~') { if (cur < line.length) { line = line.slice(0, cur) + line.slice(cur + 1); redraw(); } return; }
        if (d === '\x1b[D') { if (cur > 0) { cur--; term.write(d); } return; }
        if (d === '\x1b[C') { if (cur < line.length) { cur++; term.write(d); } return; }
        if (d === '\x1b[H' || d === '\x1bOH' || d === '\x1b[1~' || d === '\x01') { cur = 0; redraw(); return; }
        if (d === '\x1b[F' || d === '\x1bOF' || d === '\x1b[4~' || d === '\x05') { cur = line.length; redraw(); return; }
        if (d === '\x1b[A') {
          if (!history.length) return;
          if (hIdx === -1) { draft = line; hIdx = history.length; }
          hIdx = Math.max(0, hIdx - 1); line = history[hIdx]; cur = line.length; redraw(); return;
        }
        if (d === '\x1b[B') {
          if (hIdx === -1) return;
          hIdx++; if (hIdx >= history.length) { hIdx = -1; line = draft; } else line = history[hIdx];
          cur = line.length; redraw(); return;
        }
        if (d === '\t') {
          const { last, items } = completions(line.slice(0, cur));
          if (items.length === 1) {
            const add = items[0].slice(last.length) + (items[0].endsWith('/') ? '' : ' ');
            line = line.slice(0, cur) + add + line.slice(cur); cur += add.length; redraw();
          } else if (items.length > 1) { term.write('\r\n' + items.join('  ') + '\r\n'); redraw(); }
          return;
        }
        if (d.startsWith('\x1b')) return;
        const text = d.replace(/\r?\n/g, ' ').replace(/[\x00-\x1f]/g, '');
        if (!text) return;
        line = line.slice(0, cur) + text + line.slice(cur); cur += text.length; redraw();
      });

      term.focus();
      busy = true;
      boot().then(() => { busy = false; showPrompt(); });
    }

    function startFallback() {
      body.innerHTML = '';
      const wrap = document.createElement('div');
      wrap.style.cssText = 'display:flex;flex-direction:column;width:100%;height:100%;background:#0B1020;color:#D6DEEB;font:13px ui-monospace,Menlo,Consolas,monospace;';
      const pre = document.createElement('pre');
      pre.style.cssText = 'flex:1;margin:0;padding:8px;overflow:auto;white-space:pre-wrap;word-break:break-word;';
      const row = document.createElement('div');
      row.style.cssText = 'display:flex;gap:6px;padding:6px 8px;border-top:1px solid #1D3B53;';
      const pl = document.createElement('span');
      const inp = document.createElement('input');
      inp.style.cssText = 'flex:1;background:transparent;border:0;outline:0;color:inherit;font:inherit;';
      inp.setAttribute('aria-label', 'terminal input');
      row.appendChild(pl); row.appendChild(inp); wrap.appendChild(pre); wrap.appendChild(row); body.appendChild(wrap);
      term = {
        write: s => {
          s = String(s);
          if (s.indexOf('\r\x1b[K') === 0) return; // spinner clear: ignore in fallback
          if (/^\x1b\[2m working|^\b/.test(s)) return;
          pre.textContent += stripAnsi(s).replace(/\r\n/g, '\n').replace(/\r/g, '');
          pre.scrollTop = pre.scrollHeight;
        },
        clear: () => { pre.textContent = ''; },
      };
      const setP = () => { pl.textContent = stripAnsi(prompt()); };
      let hIdx = -1;
      inp.addEventListener('keydown', async ev => {
        if (ev.key === 'Enter' && !busy) {
          const l = inp.value; inp.value = ''; hIdx = -1;
          term.write(stripAnsi(prompt()) + l + '\n');
          await runAndPrint(l); setP();
        } else if (ev.key === 'ArrowUp' && history.length) {
          hIdx = hIdx === -1 ? history.length - 1 : Math.max(0, hIdx - 1); inp.value = history[hIdx]; ev.preventDefault();
        } else if (ev.key === 'ArrowDown' && hIdx !== -1) {
          hIdx++; if (hIdx >= history.length) { hIdx = -1; inp.value = ''; } else inp.value = history[hIdx];
        } else if (ev.key === 'l' && ev.ctrlKey) { term.clear(); ev.preventDefault(); }
      });
      out(C.dim('(terminal library unavailable; using the simple console)'));
      busy = true; setP();
      boot().then(() => { busy = false; inp.focus(); });
    }

    body.textContent = 'Loading terminal...';
    loadXterm().then(startXterm, startFallback).catch(() => { try { startFallback(); } catch (e) { /* give up quietly */ } });
  };
})();