@tensor.chat/companion 0.4.1 → 0.4.3

package/src/setup/tree.js

@@ -0,0 +1,174 @@
+'use strict';
+// The folder tree of the setup's explorer, and the one rule its ticks follow: a
+// ticked folder covers everything inside it, so the list keeps the outermost ones.
+
+const fs = require('fs');
+const path = require('path');
+
+const fsp = fs.promises;
+const WIN_HIDDEN = new Set(['appdata', 'system volume information', 'recovery', 'config.msi', 'perflogs', 'msocache']);
+const GIT_MARK_LIMIT = 400;
+const DRIVE_WAIT_MS = 1500;
+
+function samePath(platform) {
+  const norm = (p) => (platform === 'win32' ? String(p).toLowerCase() : String(p));
+  return {
+    equal: (a, b) => norm(a) === norm(b),
+    // b lies inside a (not equal)
+    inside: (a, b) => {
+      const rel = path.relative(norm(a), norm(b));
+      return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+    },
+  };
+}
+
+// 'on' (ticked), 'covered' (inside a ticked one), 'partial' (holds ticked ones), 'off'
+function tickState(p, selected, platform) {
+  const s = samePath(platform);
+  if (selected.some((x) => s.equal(x, p))) return 'on';
+  const parent = selected.find((x) => s.inside(x, p));
+  if (parent) return 'covered';
+  if (selected.some((x) => s.inside(p, x))) return 'partial';
+  return 'off';
+}
+
+// The new list, or { blockedBy } when a ticked folder around it already covers it
+function toggleTick(p, selected, platform) {
+  const s = samePath(platform);
+  if (selected.some((x) => s.equal(x, p))) return { list: selected.filter((x) => !s.equal(x, p)) };
+  const parent = selected.find((x) => s.inside(x, p));
+  if (parent) return { blockedBy: parent };
+  return { list: [...selected.filter((x) => !s.inside(p, x)), p] };
+}
+
+function hiddenName(name, platform) {
+  if (name.startsWith('.')) return true;
+  return platform === 'win32' && (name.startsWith('$') || WIN_HIDDEN.has(name.toLowerCase()));
+}
+
+async function withTimeout(promise, ms, fallback) {
+  let timer;
+  const late = new Promise((resolve) => { timer = setTimeout(() => resolve(fallback), ms); });
+  try { return await Promise.race([promise, late]); } finally { clearTimeout(timer); }
+}
+
+// Drive letters that answer within a moment; a network drive that hangs is left out
+async function windowsDrives() {
+  const letters = 'CDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+  const found = await Promise.all(letters.map((l) => withTimeout(fsp.stat(`${l}:\\`).then((s) => s.isDirectory(), () => false), DRIVE_WAIT_MS, false)));
+  return letters.filter((_, i) => found[i]).map((l) => `${l}:\\`);
+}
+
+async function listFolders(dir, platform) {
+  const entries = await fsp.readdir(dir, { withFileTypes: true });
+  const out = [];
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    let link = false;
+    if (e.isSymbolicLink()) {
+      try { if (!(await fsp.stat(full)).isDirectory()) continue; } catch (_) { continue; }
+      link = true;
+    } else if (!e.isDirectory()) continue;
+    out.push({ path: full, name: e.name, link, hidden: hiddenName(e.name, platform) });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: 'base' }));
+  if (out.length <= GIT_MARK_LIMIT) {
+    await Promise.all(out.map(async (f) => { try { f.git = (await fsp.stat(path.join(f.path, '.git'))).isDirectory(); } catch (_) { f.git = false; } }));
+  }
+  return out;
+}
+
+function expandHome(p, home) {
+  if (p === '~') return home;
+  return p.startsWith('~/') || p.startsWith('~\\') ? path.join(home, p.slice(2)) : p;
+}
+
+// Tab on a typed path: the one folder it can only mean, or as far as all matches agree
+// and the matches to choose from. null when no folder fits.
+function completeFolder(typed, { home, platform }) {
+  const raw = expandHome(typed, home);
+  const endsInSep = /[\\/]$/.test(raw);
+  const dir = endsInSep ? raw : path.dirname(raw);
+  const prefix = endsInSep ? '' : path.basename(raw);
+  let names = [];
+  try { names = fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() || d.isSymbolicLink()).map((d) => d.name); } catch (_) { names = []; }
+  const fold = (s) => (platform === 'win32' ? s.toLowerCase() : s);
+  const hits = names.filter((n) => fold(n).startsWith(fold(prefix)) && (prefix.startsWith('.') || !n.startsWith('.'))).sort();
+  if (!hits.length) return null;
+  let common = hits[0];
+  for (const h of hits) while (!fold(h).startsWith(fold(common))) common = common.slice(0, -1);
+  const typedDir = endsInSep ? typed : typed.slice(0, typed.length - prefix.length);
+  if (hits.length === 1) return { typed: typedDir + hits[0] + path.sep, hints: [] };
+  return { typed: typedDir + (common.length > prefix.length ? common : prefix), hints: hits };
+}
+
+class FolderTree {
+  // base: the folder whose content is the top level; null on Windows = the drives
+  constructor({ base, platform = process.platform, onChange = () => {} }) {
+    this.platform = platform;
+    this.onChange = onChange;
+    this.showHidden = false;
+    this.ready = this.setBase(base);
+  }
+
+  setBase(base) {
+    this.base = base;
+    this.root = { path: base, name: base, open: true, children: null, loading: false, error: null, depth: -1 };
+    return this.load(this.root);
+  }
+
+  async load(node) {
+    if (node.children || node.loading) return;
+    node.loading = true;
+    this.onChange();
+    try {
+      const list = node.path === null ? (await windowsDrives()).map((d) => ({ path: d, name: d, link: false, hidden: false, git: false })) : await listFolders(node.path, this.platform);
+      node.children = list.map((f) => ({ ...f, open: false, children: null, loading: false, error: null, depth: node.depth + 1 }));
+    } catch (e) {
+      node.children = [];
+      node.error = e.code === 'EACCES' || e.code === 'EPERM' ? 'noAccess' : (e.code || e.message);
+    }
+    node.loading = false;
+    this.onChange();
+  }
+
+  // The visible lines: { node, parent }
+  rows() {
+    const out = [];
+    const walk = (node) => {
+      for (const child of node.children || []) {
+        if (child.hidden && !this.showHidden) continue;
+        out.push({ node: child, parent: node });
+        if (child.open) walk(child);
+      }
+    };
+    walk(this.root);
+    return out;
+  }
+
+  open(node) {
+    node.open = true;
+    return this.load(node);
+  }
+
+  close(node) { node.open = false; }
+
+  // One folder up: the old top level stays open inside the new one
+  async up() {
+    if (this.base === null) return null;
+    const parent = path.dirname(this.base);
+    const from = this.base;
+    if (parent === this.base) {
+      if (this.platform !== 'win32') return null;
+      await this.setBase(null);
+    } else await this.setBase(parent);
+    const again = (this.root.children || []).find((c) => samePath(this.platform).equal(c.path, from));
+    if (again) {
+      if (again.hidden) this.showHidden = true;
+      await this.open(again);
+    }
+    return again || null;
+  }
+}
+
+module.exports = { FolderTree, tickState, toggleTick, samePath, listFolders, windowsDrives, hiddenName, expandHome, completeFolder };

package/src/setup/wizard.js

@@ -0,0 +1,457 @@
+'use strict';
+// The guided setup: what this computer lets the AI use. It edits only the local
+// approvals in ~/.tensor-companion/config.json - the website cannot change them.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { styles, width, pad, openScreen } = require('./term');
+const layout = require('./layout');
+const { translator, pickLanguage } = require('./i18n');
+const { suggestPlaces } = require('./places');
+const { FolderTree, tickState, toggleTick, samePath, windowsDrives, expandHome, completeFolder } = require('./tree');
+
+const CONTENT_MAX = 92;
+const LABEL_MAX = 44;
+const STEP = { start: 0, places: 1, browse: 1, type: 1, everything: 1, shell: 2, review: 3 };
+
+const { wrap, cell, spread } = layout;
+
+function shellUntilOf(cfg, now) {
+  const until = Date.parse(String((cfg && cfg.shellApprovedUntil) || ''));
+  return Number.isFinite(until) && until > now ? new Date(until).toISOString() : null;
+}
+
+// Resolves to { saved, roots, shellUntil, everything } once the user saved or left
+function runSetup({
+  input = process.stdin, output = process.stdout, env = process.env, store = require('../config'),
+  platform = process.platform, home = os.homedir(), user = '', device = '', isRoot = false, lang, now = Date.now, system,
+} = {}) {
+  const t = translator(pickLanguage(env, lang));
+  const S = styles(!('NO_COLOR' in env) && env.TERM !== 'dumb');
+  const same = samePath(platform);
+  const screen = openScreen({ input, output });
+  const show = (p) => {
+    if (platform === 'win32' || !home) return p;
+    if (same.equal(p, home)) return '~';
+    return same.inside(home, p) ? `~/${path.relative(home, p)}` : p;
+  };
+  const initial = store.approvedRoots().map(String);
+  const shellUntil = shellUntilOf(store.load(), now());
+  const posixEverything = platform !== 'win32' && initial.some((r) => r === '/');
+  const st = {
+    screen: 'start', cursor: { start: posixEverything ? 2 : 0, places: 0, browse: 0, everything: 0, shell: 0, review: 0 },
+    selected: [...initial], scope: posixEverything ? 'everything' : 'folders', places: null, tree: null,
+    typed: '', typeError: null, typeHints: [], shell: shellUntil ? 'keep' : 'no', message: null, shellFrom: 'places',
+  };
+
+  return new Promise((resolve) => {
+    let done = false;
+    const restore = () => screen.stop();
+    process.once('exit', restore);
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      process.removeListener('exit', restore);
+      screen.stop();
+      resolve(result);
+    };
+    const draw = () => { if (!done) screen.draw(render()); };
+
+    suggestPlaces({ platform, home, env, system }).then((list) => { st.places = list; draw(); }, () => { st.places = []; draw(); });
+
+    // ---- drawing ----
+    const K = t('keys');
+    const N = t('keyNames');
+    const contentWidth = () => Math.min(screen.size().cols - 4, CONTENT_MAX);
+    const keyLines = (keys, w) => layout.keyLines(S, keys, w);
+    const panel = (lines, tone) => layout.panel(S, lines, tone, Math.min(contentWidth(), 80));
+    function frame({ title, right = '', body, focus = 0, help = '', keys }) {
+      const { rows } = screen.size();
+      const w = contentWidth();
+      const step = STEP[st.screen];
+      const steps = t('steps').map((name, i) => (i < step ? S.green(`✔ ${name}`) : i === step ? S.bold(S.cyan(`● ${name}`)) : S.dim(`○ ${name}`))).join(S.dim('  ─  '));
+      const top = [
+        '',
+        '  ' + spread(`${S.cyan('◆')} ${S.bold('Tensor.Chat Companion')}  ${S.dim(t('setup'))}`, S.dim([device, user].filter(Boolean).join(' · ')), w),
+        '  ' + steps,
+        '',
+        '  ' + spread(S.bold(title), right, w),
+        '',
+      ];
+      // the status, or the help for the line under the cursor; two lines at most
+      const note = st.message ? wrap(st.message.text, w).slice(0, 2).map((l) => '  ' + S[st.message.tone](l)) : wrap(help, w).slice(0, 2).map((l) => '  ' + S.dim(l));
+      const bottom = [
+        ...(note.length ? note : ['']),
+        '  ' + S.dim('─'.repeat(w)),
+        ...keyLines(keys, w),
+      ];
+      const space = Math.max(3, rows - top.length - bottom.length - 1);
+      let start = 0;
+      if (body.length > space) start = Math.min(Math.max(0, focus - Math.floor(space / 2)), body.length - space);
+      const shown = body.slice(start, start + space);
+      if (start > 0) shown[0] = '      ' + S.dim('↑');
+      if (start + space < body.length) shown[shown.length - 1] = '      ' + S.dim('↓');
+      while (shown.length < space) shown.push('');
+      return [...top, ...shown, '', ...bottom];
+    }
+
+    const pointer = (on) => (on ? S.cyan('❯') : ' ');
+    function radio(options, cursor) {
+      const col = Math.min(LABEL_MAX, Math.max(...options.map((o) => width(o.label))) + 3);
+      return options.map((o, i) => {
+        const on = i === cursor;
+        const note = o.note ? (o.tone ? S[o.tone](o.note) : S.dim(o.note)) : '';
+        return `  ${pointer(on)} ${on ? S.cyan('●') : S.dim('○')} ${cell(on ? S.bold(o.label) : o.label, col)}${note}`;
+      });
+    }
+
+    function box(state) {
+      if (state === 'on') return S.green('◼');
+      if (state === 'covered') return S.dim(S.green('◼'));
+      return S.dim('◻');
+    }
+
+    function insideCount(p) { return st.selected.filter((x) => same.inside(p, x)).length; }
+
+    function stateNote(p, state) {
+      if (state === 'covered') return S.dim(t('note.inside', { path: show(st.selected.find((x) => same.inside(x, p))) }));
+      if (state === 'partial') return S.cyan(t('selected', { n: insideCount(p) }));
+      return '';
+    }
+
+    // ---- the screens ----
+    const START = ['folders', 'nothing', 'everything'];
+    function startView() {
+      const opts = [
+        { label: t('start.folders'), note: t('start.foldersNote'), tone: 'green' },
+        { label: t('start.nothing'), note: t('start.nothingNote') },
+        { label: t('start.everything'), note: t('start.everythingNote'), tone: 'yellow' },
+      ];
+      const { cols } = screen.size();
+      const body = [...radio(opts, st.cursor.start), '', ...wrap(t('start.help'), Math.min(cols - 6, CONTENT_MAX)).map((l) => '  ' + S.dim(l))];
+      if (initial.length) body.push('', '  ' + S.dim(t('start.now')), ...initial.slice(0, 4).map((r) => `    ${S.green('◼')} ${show(r)}`), ...(initial.length > 4 ? ['    …'] : []));
+      body.push('', '  ' + S.dim(t('start.later')) + ' ' + S.cyan('npx @tensor.chat/companion setup'));
+      return frame({ title: t('start.title'), body, focus: st.cursor.start, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.quit]] });
+    }
+
+    function placeRows() {
+      const rows = [];
+      for (const x of st.selected) {
+        if (!(st.places || []).some((p) => same.equal(p.path, x))) rows.push({ type: 'place', path: x, kind: initial.some((i) => same.equal(i, x)) ? 'earlier' : 'added' });
+      }
+      for (const p of st.places || []) rows.push({ type: 'place', path: p.path, kind: p.kind, git: p.git, readOnly: p.readOnly });
+      rows.push({ type: 'browse' }, { type: 'type' }, { type: 'continue' });
+      return rows;
+    }
+
+    function placeNote(r, state) {
+      const parts = [];
+      const extra = stateNote(r.path, state);
+      if (r.kind === 'code' && r.git) parts.push(S.dim(r.git === 1 ? t('note.git1') : t('note.git', { n: r.git })));
+      else if (r.kind === 'project') parts.push(S.dim(t('note.project')));
+      else if (['web', 'srv', 'opt', 'log', 'earlier', 'added'].includes(r.kind)) parts.push(S.dim(t(`note.${r.kind}`)));
+      else if (r.kind === 'etc' || r.kind === 'home') parts.push(S.yellow(t(`note.${r.kind}`)));
+      if (r.readOnly) parts.push(S.dim(t('note.readOnly')));
+      if (extra) parts.push(extra);
+      return parts.join(S.dim(' · '));
+    }
+
+    function placeHelp(r) {
+      if (!r) return '';
+      if (r.type !== 'place') return t(`help.${r.type}`);
+      if (r.readOnly) return t('help.readOnly');
+      const kind = r.kind === 'project' ? 'code' : r.kind;
+      return ['home', 'etc', 'log', 'web', 'srv', 'opt', 'code'].includes(kind) ? t(`help.${kind}`, { home }) : '';
+    }
+
+    function placesView() {
+      const rows = placeRows();
+      const cur = Math.min(st.cursor.places, rows.length - 1);
+      const labels = rows.filter((r) => r.type === 'place').map((r) => width(show(r.path)));
+      const col = Math.min(LABEL_MAX, Math.max(12, ...labels) + 3);
+      const body = [];
+      let focus = 0;
+      if (!st.places) body.push('  ' + S.dim(t('places.loading')));
+      else if (!st.places.length && !st.selected.length) body.push('  ' + S.dim(t('places.none')));
+      rows.forEach((r, i) => {
+        const on = i === cur;
+        if (r.type !== 'place' && rows[i - 1] && rows[i - 1].type === 'place') body.push('');
+        if (on) focus = body.length;
+        if (r.type === 'place') {
+          const state = tickState(r.path, st.selected, platform);
+          const label = on ? S.bold(show(r.path)) : show(r.path);
+          body.push(`  ${pointer(on)} ${box(state)} ${cell(label, col)}${placeNote(r, state)}`);
+        } else if (r.type === 'continue') {
+          body.push(`  ${pointer(on)} ${on ? S.bold(S.cyan(t('places.continue') + ' →')) : S.cyan(t('places.continue') + ' →')}`);
+        } else {
+          const label = t(r.type === 'browse' ? 'places.browse' : 'places.type');
+          body.push(`  ${pointer(on)} ${S.cyan('+')} ${on ? S.bold(label) : label}`);
+        }
+      });
+      return frame({ title: t('places.title'), right: S.cyan(t('selected', { n: st.selected.length })), body, focus, help: placeHelp(rows[cur]), keys: [['↑↓', K.move], [`${N.space}/${N.enter}`, K.toggle], [N.esc, K.back]] });
+    }
+
+    function treeLines() {
+      const lines = [];
+      const items = [];
+      const tree = st.tree;
+      if (tree.root.loading) lines.push('  ' + S.dim(t('browse.loading')));
+      else if (tree.root.error) lines.push('  ' + S.red(t('browse.noAccess')));
+      else if (!tree.rows().length) lines.push('  ' + S.dim(t('browse.empty')));
+      for (const row of tree.rows()) {
+        const n = row.node;
+        const on = items.length === st.cursor.browse;
+        const indent = '  '.repeat(n.depth);
+        const state = tickState(n.path, st.selected, platform);
+        const tags = [];
+        if (n.git) tags.push(S.cyan('git'));
+        if (n.link) tags.push(S.dim(t('browse.link')));
+        const extra = stateNote(n.path, state);
+        if (extra) tags.push(extra);
+        const name = on ? S.bold(n.name) : (n.hidden ? S.dim(n.name) : n.name);
+        items.push({ node: n, line: lines.length });
+        lines.push(`  ${pointer(on)} ${indent}${S.dim(n.open ? '▾' : '▸')} ${box(state)} ${name}${tags.length ? '  ' + tags.join(S.dim(' · ')) : ''}`);
+        if (n.open && n.loading) lines.push(`      ${indent}${S.dim(t('browse.loading'))}`);
+        else if (n.open && n.children && !n.children.filter((c) => tree.showHidden || !c.hidden).length) lines.push(`      ${indent}${S.dim(n.error === 'noAccess' ? t('browse.noAccess') : t('browse.empty'))}`);
+      }
+      return { lines, items };
+    }
+
+    function browseView() {
+      const { lines, items } = treeLines();
+      const at = items[Math.min(st.cursor.browse, items.length - 1)];
+      const where = st.tree.base === null ? t('browse.thisPc') : show(st.tree.base);
+      return frame({
+        title: `${t('browse.title')}  ${S.dim(where)}`, right: S.cyan(t('selected', { n: st.selected.length })), body: lines, focus: at ? at.line : 0,
+        keys: [['↑↓', K.move], [N.space, K.toggle], ['→ ←', K.openClose], [N.backspace, K.up], ['.', K.hidden], [N.esc, K.done]],
+      });
+    }
+
+    function typeView() {
+      const body = [`  ${S.dim(t('type.label'))}  ${S.cyan('›')} ${st.typed}${S.inverse(' ')}`];
+      if (st.typeError) body.push('', '  ' + S.red(st.typeError));
+      if (st.typeHints.length) body.push('', ...st.typeHints.slice(0, 8).map((h) => '    ' + S.dim(h)));
+      return frame({ title: t('type.title'), body, help: t('help.type'), keys: [[N.tab, K.tab], [N.enter, K.add], [N.esc, K.back]] });
+    }
+
+    function everythingView() {
+      const text = [t('everything.body', { user: user || '?' })];
+      if (isRoot) text.push(S.red(t('everything.root')));
+      text.push('', S.yellow(t('everything.free')));
+      const body = [...panel(text, 'yellow'), ''];
+      body.push(...radio([{ label: t('everything.no') }, { label: t('everything.yes'), tone: 'yellow' }], st.cursor.everything));
+      return frame({ title: `${S.yellow('▲')}  ${t('everything.title')}`, body, focus: body.length - 1, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
+    }
+
+    function shellOptions() {
+      const quiet = t('shell.noNote');
+      const list = shellUntil
+        ? [{ id: 'keep', label: t('shell.keep'), note: t('shell.keepNote', { date: t.date(shellUntil) }) }, { id: 'off', label: t('shell.off'), note: quiet }]
+        : [{ id: 'no', label: t('shell.no'), note: quiet }];
+      return [...list, { id: 7, label: t('shell.d7') }, { id: 30, label: t('shell.d30') }, { id: 365, label: t('shell.d365'), tone: 'yellow' }];
+    }
+
+    function shellView() {
+      const body = [...panel([t('shell.body', { user: user || '?' })]), '', ...radio(shellOptions(), st.cursor.shell)];
+      return frame({ title: t('shell.title'), body, focus: body.length - 1, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
+    }
+
+    function changes() {
+      return {
+        removed: initial.filter((x) => !st.selected.some((y) => same.equal(x, y))),
+        added: st.selected.filter((x) => !initial.some((y) => same.equal(x, y))),
+      };
+    }
+
+    function reviewView() {
+      const { removed } = changes();
+      const label = (s) => pad(S.dim(s), 12);
+      const body = [];
+      if (st.scope === 'everything') body.push(`${label(t('review.folders'))}${S.yellow('▲ ' + t('everything.summary'))}`);
+      else if (!st.selected.length) body.push(`${label(t('review.folders'))}${S.dim(t('review.noFolders'))}`);
+      else st.selected.forEach((x, i) => body.push(`${label(i ? '' : t('review.folders'))}${S.green('◼')} ${show(x)}`));
+      if (st.scope !== 'everything') for (const x of removed) body.push(`${label('')}${S.red('−')} ${S.dim(show(x))}  ${S.red(t('review.removed'))}`);
+      const shellLine = st.shell === 'keep' ? t('review.cmdUntil', { date: t.date(shellUntil) })
+        : typeof st.shell === 'number' ? t('review.cmdUntil', { date: t.date(new Date(now() + st.shell * 864e5).toISOString()) }) : t('review.cmdNo');
+      body.push('', `${label(t('review.commands'))}${typeof st.shell === 'number' || st.shell === 'keep' ? S.yellow(shellLine) : shellLine}`);
+      const lines = [...panel(body), ''];
+      const opts = [t('review.save'), t('review.back'), t('review.quit')];
+      opts.forEach((o, i) => lines.push(`  ${pointer(i === st.cursor.review)} ${i === st.cursor.review ? S.bold(i === 0 ? S.green(o) : o) : o}`));
+      return frame({ title: t('review.title'), body: lines, focus: lines.length - 1, help: t('review.where', { file: show(store.configPath()) }), keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
+    }
+
+    function render() {
+      return ({ start: startView, places: placesView, browse: browseView, type: typeView, everything: everythingView, shell: shellView, review: reviewView })[st.screen]();
+    }
+
+    // ---- keys ----
+    const go = (name) => { st.screen = name; st.message = null; draw(); };
+    const moveIn = (name, n, key) => {
+      const c = st.cursor[name];
+      if (key.name === 'up') st.cursor[name] = (c - 1 + n) % n;
+      else if (key.name === 'down') st.cursor[name] = (c + 1) % n;
+      else if (key.name === 'pageup') st.cursor[name] = Math.max(0, c - 10);
+      else if (key.name === 'pagedown') st.cursor[name] = Math.min(n - 1, c + 10);
+      else if (key.name === 'home') st.cursor[name] = 0;
+      else if (key.name === 'end') st.cursor[name] = n - 1;
+      else return false;
+      return true;
+    };
+    const tick = (p) => {
+      const r = toggleTick(p, st.selected, platform);
+      if (r.blockedBy) st.message = { tone: 'yellow', text: t('browse.blocked', { path: show(p), parent: show(r.blockedBy) }) };
+      else { st.selected = r.list; st.message = null; }
+    };
+
+    const keys = {
+      start(str, key) {
+        if (moveIn('start', START.length, key)) return draw();
+        if (key.name === 'escape' || str === 'q') return finish({ saved: false });
+        if (key.name !== 'return') return;
+        const choice = START[st.cursor.start];
+        if (choice === 'folders') {
+          if (st.scope === 'everything') st.selected = st.selected.filter((x) => path.parse(x).root !== x);
+          st.scope = 'folders';
+          st.shellFrom = 'places';
+          return go('places');
+        }
+        if (choice === 'nothing') { st.scope = 'nothing'; st.selected = []; st.shellFrom = 'start'; return go('shell'); }
+        st.cursor.everything = 0;
+        return go('everything');
+      },
+      places(str, key) {
+        const rows = placeRows();
+        if (moveIn('places', rows.length, key)) { st.message = null; return draw(); }
+        if (key.name === 'escape') return go('start');
+        const r = rows[Math.min(st.cursor.places, rows.length - 1)];
+        if (key.name !== 'return' && key.name !== 'space') return;
+        if (r.type === 'place') { tick(r.path); return draw(); }
+        if (r.type === 'continue') return go('shell');
+        if (r.type === 'type') { st.typed = platform === 'win32' ? home + path.sep : '~/'; st.typeError = null; st.typeHints = []; return go('type'); }
+        if (!st.tree) {
+          st.tree = new FolderTree({ base: home, platform, onChange: draw });
+          st.cursor.browse = 0;
+        }
+        return go('browse');
+      },
+      async browse(str, key) {
+        const tree = st.tree;
+        const items = tree.rows();
+        if (moveIn('browse', Math.max(1, items.length), key)) { st.message = null; return draw(); }
+        if (key.name === 'escape') return go('places');
+        if (str === '.') {
+          const at = items[st.cursor.browse];
+          tree.showHidden = !tree.showHidden;
+          st.message = { tone: 'dim', text: t(tree.showHidden ? 'browse.hidden' : 'browse.hiddenOff') };
+          // the cursor stays on its folder; one that is hidden now gives way to the first
+          const again = tree.rows().findIndex((r) => at && r.node === at.node);
+          st.cursor.browse = Math.max(0, again);
+          return draw();
+        }
+        if (key.name === 'backspace') {
+          const from = await tree.up();
+          if (from) st.cursor.browse = Math.max(0, tree.rows().findIndex((r) => r.node === from));
+          return draw();
+        }
+        const row = items[Math.min(st.cursor.browse, items.length - 1)];
+        if (!row) return;
+        const n = row.node;
+        if (key.name === 'space') { tick(n.path); return draw(); }
+        if (key.name === 'right' || key.name === 'return') {
+          if (!n.open) { await tree.open(n); return draw(); }
+          if ((n.children || []).some((c) => tree.showHidden || !c.hidden)) st.cursor.browse++;
+          return draw();
+        }
+        if (key.name === 'left') {
+          if (n.open) tree.close(n);
+          else if (row.parent !== tree.root) st.cursor.browse = Math.max(0, tree.rows().findIndex((r) => r.node === row.parent));
+          return draw();
+        }
+      },
+      type(str, key) {
+        if (key.name === 'escape') return go('places');
+        if (key.name === 'tab') { complete(); return draw(); }
+        if (key.name === 'return') return addTyped();
+        if (key.name === 'backspace') st.typed = st.typed.slice(0, -1);
+        else if (key.ctrl && key.name === 'u') st.typed = '';
+        else if (str && !key.ctrl && !key.meta && str >= ' ' && str !== '\x7f') st.typed += str;
+        st.typeError = null;
+        st.typeHints = [];
+        return draw();
+      },
+      async everything(str, key) {
+        if (moveIn('everything', 2, key)) return draw();
+        if (key.name === 'escape') return go('start');
+        if (key.name !== 'return') return;
+        if (st.cursor.everything === 0) return go('start');
+        st.selected = platform === 'win32' ? await windowsDrives() : ['/'];
+        st.scope = 'everything';
+        st.shellFrom = 'start';
+        return go('shell');
+      },
+      shell(str, key) {
+        const opts = shellOptions();
+        if (moveIn('shell', opts.length, key)) return draw();
+        if (key.name === 'escape') return go(st.shellFrom);
+        if (key.name !== 'return') return;
+        st.shell = opts[st.cursor.shell].id;
+        st.cursor.review = 0;
+        return go('review');
+      },
+      review(str, key) {
+        if (moveIn('review', 3, key)) return draw();
+        if (key.name === 'escape') return go('shell');
+        if (key.name !== 'return') return;
+        if (st.cursor.review === 1) return go('shell');
+        if (st.cursor.review === 2) return finish({ saved: false });
+        try {
+          save();
+        } catch (e) {
+          st.message = { tone: 'red', text: e.message };
+          return draw();
+        }
+        const cfg = store.load();
+        return finish({ saved: true, roots: store.approvedRoots(), shellUntil: shellUntilOf(cfg, now()), everything: st.scope === 'everything' });
+      },
+    };
+
+    function complete() {
+      const r = completeFolder(st.typed, { home, platform });
+      if (r) { st.typed = r.typed; st.typeHints = r.hints; }
+    }
+
+    function addTyped() {
+      const raw = expandHome(st.typed.trim(), home);
+      let real = null;
+      try { real = fs.realpathSync.native(path.resolve(raw)); if (!fs.statSync(real).isDirectory()) real = null; } catch (_) { real = null; }
+      if (!raw || !real) { st.typeError = t('type.notFound', { path: st.typed.trim() || '?' }); return draw(); }
+      if (tickState(real, st.selected, platform) !== 'on') tick(real);
+      const message = st.message;
+      go('places');
+      st.message = message;
+      const at = placeRows().findIndex((r) => r.path && same.equal(r.path, real));
+      if (at >= 0) st.cursor.places = at;
+      return draw();
+    }
+
+    function save() {
+      const { removed, added } = changes();
+      for (const r of removed) store.revokeRoot(r);
+      for (const a of added) store.approveRoot(a);
+      if (st.shell === 'off') store.revokeShell();
+      else if (typeof st.shell === 'number') store.approveShell(st.shell);
+    }
+
+    screen.onKey((str, key) => {
+      if (done) return;
+      if (key.ctrl && key.name === 'c') return finish({ saved: false });
+      Promise.resolve(keys[st.screen](str, key)).catch((e) => { st.message = { tone: 'red', text: e.message }; draw(); });
+    });
+    screen.onResize(draw);
+    screen.start();
+    draw();
+  });
+}
+
+module.exports = { runSetup };