gitroots 0.0.0-stage → 0.5.0

package/src/commands/status.js

@@ -0,0 +1,84 @@
+// gitroots status · everything at a glance
+import { c, h, pad } from '../ui/ansi.js';
+import { line } from '../ui/term.js';
+import { brand, dot, decision, json } from '../ui/components.js';
+import { apiRepos, apiAudit, sampleNote } from '../connected.js';
+
+export async function run(_cmd, _rest, flags, store) {
+  const { org } = store;
+  const needs = store.needsYou();
+  let repos = store.repos();
+  let audit = store.audit();
+  let apiError = null;
+  if (store.api) {
+    try { [repos, audit] = await Promise.all([apiRepos(store), apiAudit(store)]); } catch (e) { apiError = e.message; repos = []; audit = []; }
+  }
+  const sessions = store.sessions();
+  const machines = new Set(sessions.map((s) => s.machine));
+  const count = (st) => sessions.filter((s) => s.state === st).length;
+  const recent = [...audit].sort((a, b) => (b.at || '').localeCompare(a.at || '') || b.time.localeCompare(a.time)).slice(0, 4);
+
+  if (flags.json) {
+    json({
+      org: org.name, user: org.user, role: org.role, relay: org.relay,
+      needsYou: needs.map((n) => (n.kind === 'review' ? { kind: 'review', pr: n.pr.number } : n.kind === 'agent' ? { kind: 'agent', session: n.session.id, question: n.session.ask.question } : { kind: 'blocked', event: n.event.id })),
+      repos: repos.map((r) => ({ name: r.name, provider: r.provider, protected: r.protected, branches: r.branches, openPrs: r.openPrs, lastPush: r.lastPush })),
+      sessions: { total: sessions.length, machines: machines.size, running: count('running'), waiting: count('waiting'), suspended: count('suspended'), idle: count('idle') },
+      recent,
+    });
+    return 0;
+  }
+
+  const relay = org.relay.connected ? c.g('● connected') : c.r('✕ disconnected');
+  const where = store.api ? `server ${apiError ? c.r(`✕ ${apiError}`) : c.g(`● ${store.api.server.replace(/^https?:\/\//, '')}`)}` : `relay ${relay}`;
+  line(`${brand()} ${dot()} org ${c.b(org.name)} ${dot()} signed in as ${c.b(org.user)} ${c.m(`(${org.role})`)} ${dot()} ${where}`);
+  line();
+
+  line(h('Needs you'));
+  if (!needs.length) line(`  ${c.g('✓ nothing needs you')}`);
+  for (const n of needs) {
+    if (n.kind === 'review') {
+      const p = n.pr;
+      const what = pad(`PR #${p.number}  ${p.repo} · ${p.from} → ${p.into}`, 52);
+      const checks = p.checks.state === 'pass' ? 'checks ✓' : p.checks.state === 'fail' ? 'checks ✕' : 'checks running';
+      line(`  ${c.w(pad('◐ review', 11))}  ${what}${pad(`${p.approvals.length} of ${p.required} approvals · ${checks}`, 32)}${c.g(`→ gitroots pr view ${p.number}`)}`);
+    } else if (n.kind === 'agent') {
+      const s = n.session;
+      line(`  ${c.w(pad('◐ agent', 11))}  ${pad(`${s.id}   ${s.agent} asks: ${s.ask.short}`, 84)}${c.g(`→ gitroots attach ${s.id}`)}`);
+    } else {
+      const e = n.event;
+      line(`  ${c.r(pad('✕ blocked', 11))}  ${pad(`push     ${e.actor} → ${e.repo}/${e.target.split(' · ')[0]} · rule "${e.rule}" · ${e.time}`, 84)}${c.g(`→ gitroots audit ${e.id}`)}`);
+    }
+  }
+  sampleNote(store, 'pull requests and agent questions are');
+  line();
+
+  line(h('Repositories'));
+  line(`  ${h(`${pad('NAME', 14)}${pad('PROVIDER', 11)}${pad('PROTECTED BRANCHES', 26)}${pad('BRANCHES', 11)}${pad('OPEN PRS', 11)}LAST PUSH`)}`);
+  for (const r of repos) {
+    line(`  ${c.b(pad(r.name, 14))}${pad(r.provider, 11)}${pad(r.protected.length ? r.protected.join(' · ') : c.m('—'), 26)}${pad(String(r.branches), 11)}${pad(r.openPrs === null || r.openPrs === undefined ? c.m('—') : String(r.openPrs), 11)}${pad(r.lastPush || c.m('—'), 9)}${c.m(r.lastBranch || '')}`);
+  }
+  line();
+
+  line(`${h('Agent sessions')}   ${c.m(`${sessions.length} on ${machines.size} machines`)}`);
+  const bits = [];
+  if (count('running')) bits.push(c.g(`● ${count('running')} running`));
+  if (count('waiting')) bits.push(c.w(`◐ ${count('waiting')} waiting`));
+  if (count('idle')) bits.push(c.s(`○ ${count('idle')} idle`));
+  if (count('suspended')) bits.push(c.m(`⏸ ${count('suspended')} suspended · backed up`));
+  line(`  ${bits.join('   ')}          ${c.g('→ gitroots watch')}`);
+  sampleNote(store, 'agent sessions are');
+  line();
+
+  line(h(store.api ? 'Latest activity' : 'Last hour'));
+  if (!recent.length) line(c.m('  no activity yet'));
+  for (const e of recent) {
+    const ok = e.decision === 'allowed' && e.note ? c.g(`✓ ${e.note}`) : e.decision === 'allowed' ? '' : decision(e.decision);
+    line(`  ${c.m(e.time)}  ${c.s(pad(e.actor, 10))}${pad(`${e.action} ${e.target}`, 44)}${ok}`);
+  }
+  line();
+  const first = needs[0];
+  if (first) line(c.g(`→ ${first.kind === 'review' ? `gitroots pr view ${first.pr.number}` : first.kind === 'agent' ? `gitroots attach ${first.session.id}` : `gitroots audit ${first.event.id}`}`));
+  else line(c.g('→ gitroots watch'));
+  return 0;
+}

package/src/commands/transfer.js

@@ -0,0 +1,79 @@
+// gitroots transfer <session> --to <machine>
+import { c } from '../ui/ansi.js';
+import { line, runSteps, motion } from '../ui/term.js';
+import { brand, dot, json, next, sessionState } from '../ui/components.js';
+import { createBackup } from './backup.js';
+
+export async function run(_cmd, rest, flags, store) {
+  const [id] = rest;
+  const to = flags.to || rest[1];
+  if (!id || !to) throw new Error('usage: gitroots transfer <session> --to <machine>');
+  return transfer(store, id, to, flags);
+}
+
+export async function transfer(store, id, to, flags = {}) {
+  const s = store.session(id);
+  const from = store.machine(s.machine);
+  const dest = store.machine(to);
+  if (dest.name === from.name) throw new Error(`${s.id} is already on ${to}`);
+  if (!dest.online) throw new Error(`${to} is offline (${dest.offlineFor || 'unknown'}) · pick an online machine`);
+  if (s.state === 'stopped') throw new Error(`${s.id} is stopped · restore it instead`);
+
+  const convoMb = Math.round(s.turns * 0.0127 * 10) / 10;
+  const totalMb = Math.round((convoMb + 2 + s.changed * 4.6) * 10) / 10;
+  const uploadSecs = Math.round((totalMb / 4.1) * 10) / 10;
+
+  if (flags.json) {
+    const b = store.d.backupPolicy.beforeTransfer ? createBackup(store, s, `before move to ${to}`) : null;
+    s.machine = dest.name;
+    s.state = 'running';
+    const ev = store.record({ actor: store.org.user, action: 'transfer', target: `${s.id} ${from.name} → ${dest.name}`, decision: 'allowed', repo: s.repo });
+    store.save();
+    json({ session: s.id, from: from.name, to: dest.name, backup: b?.id, event: ev.id });
+    return 0;
+  }
+
+  line(`${brand()} ${dot()} ${c.b(`Transfer ${s.id}`)}   ${c.m(`${s.agent} · ${s.repo} · ${s.branch} · ${s.turns} turns`)}`);
+  line(`  ${c.b(from.name)} ${c.m(from.os)}   ${c.g('━━━━━━━━━━━▶')}   ${c.b(dest.name)} ${c.m(dest.os)}      ${c.m(`via relay ${store.org.relay.name} · end-to-end encrypted`)}`);
+  line(`  ${c.m(`ctrl-c cancels safely · the session stays paused on ${from.name} until verify passes`)}`);
+  line();
+
+  let cancelled = false;
+  const onInt = () => { cancelled = true; };
+  process.on('SIGINT', onInt);
+  const t0 = Date.now();
+  const results = await runSteps([
+    { name: 'Pause session', live: 'waiting for the agent to finish its turn…', ms: 500, ok: `agent stopped at a safe point, turn ${s.turns}`, time: '0.4s' },
+    { name: 'Snapshot conversation', live: `reading ${s.turns} turns…`, ms: 400, ok: `${s.turns} turns · ${convoMb} MB`, time: '0.2s' },
+    { name: 'Snapshot workspace', live: 'git stash · diff · untracked files…', ms: 600, ok: `HEAD ${s.head} · ${s.changed} files changed${s.stash ? ` · ${s.stash} stash` : ''}`, time: '0.9s' },
+    { name: 'Capture environment', live: 'sealing secrets…', ms: 300, ok: `cwd ~/work/${s.repo} · 12 vars · 2 secrets sealed`, time: '0.1s' },
+    { name: 'Upload', bar: true, ms: 3100, ok: `${totalMb} MB · 4.1 MB/s`, time: `${uploadSecs}s`, barLabel: (p) => `${Math.round(p * 100)}%  ${(p * totalMb).toFixed(1)} / ${totalMb} MB · 4.1 MB/s` },
+    { name: `Rebuild on ${dest.name}`, live: `checkout ${s.head} · apply diff · restore stash…`, ms: 800, ok: `checkout ${s.head} · diff applied${s.stash ? ' · stash restored' : ''}`, time: '0.6s' },
+    { name: 'Resume agent', live: `${s.resume}…`, ms: 500, ok: `${s.resume}, same conversation`, time: '0.2s' },
+    { name: `Verify, then release ${from.name}`, live: 'comparing checksums…', ms: 600, ok: 'files match · agent answers · source cleaned', time: '0.1s' },
+  ], { nameWidth: 30, detailWidth: 56, showQueued: true, cancelled: () => cancelled });
+  process.off('SIGINT', onInt);
+
+  if (results.cancelled) {
+    line();
+    line(`  ${c.w('◐ Transfer cancelled')}   ${s.id} resumed on ${from.name} ${dot()} nothing changed on ${dest.name}`);
+    return 130;
+  }
+
+  const b = store.d.backupPolicy.beforeTransfer ? createBackup(store, s, `before move to ${dest.name}`) : null;
+  s.machine = dest.name;
+  s.state = s.state === 'suspended' || s.state === 'paused' ? 'running' : s.state;
+  s.updated = 'just now';
+  const ev = store.record({ actor: store.org.user, action: 'transfer', target: `${s.id} ${from.name} → ${dest.name}`, decision: 'allowed', note: s.agent, repo: s.repo });
+  store.save();
+
+  const nominal = results.reduce((n, r) => n + parseFloat(r.time || '0'), 0);
+  const secs = (motion() ? (Date.now() - t0) / 1000 : nominal).toFixed(1);
+  line();
+  line(`  ${c.g(c.b(`✓ Transferred in ${secs}s`))}   ${s.id} is now ${sessionState(s)} on ${c.b(dest.name)}`);
+  line(`    ${c.s('conversation')}  ${s.turns} turns, intact          ${c.s('workspace')}  ${s.changed} files changed${s.stash ? `, ${s.stash} stash` : ''}`);
+  line(`    ${c.s('backup')}        ${b ? `${b.id} taken before move` : 'off by policy'}   ${c.s(from.name)}      released ${dot()} ${c.m(ev.id)}`);
+  line();
+  line(`  ${next(`gitroots attach ${s.id}`, `gitroots transfer ${s.id} --to ${from.name} to bring it back`)}`);
+  return 0;
+}

package/src/commands/tunnel.js

@@ -0,0 +1,116 @@
+// gitroots tunnel <session> --port n [--shell] · tunnel ls · tunnel close · share
+import crypto from 'node:crypto';
+import { c, h, pad } from '../ui/ansi.js';
+import { line, runSteps, copyToClipboard } from '../ui/term.js';
+import { dot, json, next } from '../ui/components.js';
+
+const KNOWN_PORTS = { 8069: 'Odoo', 8888: 'Jupyter', 3000: 'web', 5173: 'Vite', 8000: 'web', 8080: 'web', 5432: 'Postgres', 6006: 'TensorBoard' };
+
+function relayDomain(store) { return process.env.GITROOTS_RELAY_DOMAIN || `${store.org.relay.name}.relay.gitroots.com`; }
+
+export async function run(cmd, rest, flags, store) {
+  if (cmd === 'share') return share(rest, flags, store);
+  const [sub] = rest;
+  if (sub === 'ls' || sub === 'list' || (!sub && !flags.port)) return list(flags, store);
+  if (sub === 'close') return close(rest.slice(1), flags, store);
+  return open(rest, flags, store);
+}
+
+function parseDuration(s) {
+  const m = /^(\d+)\s*(m|h|d)$/.exec(String(s));
+  if (!m) throw new Error(`--expires takes 30m, 1h or 1d (got ${s})`);
+  return Number(m[1]) * { m: 60000, h: 3600000, d: 86400000 }[m[2]];
+}
+
+async function open([id], flags, store) {
+  if (!id) throw new Error('usage: gitroots tunnel <session> --port <n> | --shell');
+  const s = store.session(id);
+  const m = store.machine(s.machine);
+  if (!m.online) throw new Error(`${m.name} is offline`);
+  const shell = Boolean(flags.shell);
+  const port = shell ? null : Number(flags.port);
+  if (!shell && !(port > 0 && port < 65536)) throw new Error('--port takes a port number, e.g. --port 8069');
+  const what = shell ? 'shell' : `${port}${KNOWN_PORTS[port] ? ` ${KNOWN_PORTS[port]}` : ''}`;
+  const t = {
+    id: store.nextTunnelId(), session: s.id, machine: m.name, target: shell ? 'shell' : `:${what}`, access: 'only you', viewers: 0, traffic: '0 B', openFor: 'just now', at: new Date().toISOString(),
+    url: shell ? null : `https://${s.id}-${port}.${relayDomain(store)}`,
+  };
+  store.d.tunnels.push(t);
+  const ev = store.record({ actor: store.org.user, action: 'tunnel open', target: `${s.id} ${t.target}`, decision: 'allowed', note: m.name, repo: s.repo });
+  store.save();
+  if (flags.json) { json({ ...t, event: ev.id }); return 0; }
+
+  const dest = shell ? `shell on ${m.name}` : `localhost:${port}${KNOWN_PORTS[port] ? ` (${KNOWN_PORTS[port]})` : ''}`;
+  line(`  ${c.s('your browser')}  ${c.g('◀━━▶')}  ${c.s(`relay ${store.org.relay.name}`)}  ${c.g('◀━━')}  ${c.s(`agentd on ${m.name}`)}  ${c.g('━━▶')}  ${c.b(dest)}`);
+  line(`  ${' '.repeat(30)}${c.m(`outbound only · no ports opened on ${m.name} · TLS end to end`)}`);
+  line();
+  await runSteps([{ name: 'Opening tunnel', live: `asking agentd on ${m.name}…`, ms: 700, ok: `${t.id} ready` }], { nameWidth: 16 });
+  line(`  ${c.g('✓')} ${c.b(`Tunnel ${t.id} open`)}`);
+  if (t.url) line(`    ${c.s(pad('url', 11))}${c.i(t.url)}`);
+  else line(`    ${c.s(pad('shell', 11))}${c.g(`gitroots attach ${s.id} --shell`)} ${c.m('(no ssh keys needed)')}`);
+  line(`    ${c.s(pad('access', 11))}only you ${dot()} signed in with gitroots`);
+  line(`    ${c.s(pad('closes', 11))}when ${s.id} stops ${dot()} or gitroots tunnel close ${t.id}`);
+  line();
+  line(next(`gitroots share ${s.id} --read-only --expires 1h`));
+  return 0;
+}
+
+async function share([id], flags, store) {
+  if (!id) throw new Error('usage: gitroots share <session> --read-only [--expires 1h]');
+  const s = store.session(id);
+  if (flags['read-only'] === undefined && !flags.json) throw new Error('only read-only sharing is available · add --read-only');
+  const ms = parseDuration(flags.expires || '1h');
+  const exp = new Date(Date.now() + ms);
+  const token = crypto.randomBytes(4).toString('base64url').slice(0, 5);
+  const url = `https://${relayDomain(store)}/s/${token}`;
+  const t = { id: store.nextTunnelId(), session: s.id, machine: s.machine, target: 'live view', access: 'read-only link', viewers: 0, traffic: '0 B', openFor: 'just now', at: new Date().toISOString(), url, expires: exp.toISOString() };
+  store.d.tunnels.push(t);
+  const ev = store.record({ actor: store.org.user, action: 'share', target: `${s.id} read-only`, decision: 'allowed', note: `expires ${exp.toTimeString().slice(0, 5)}`, repo: s.repo });
+  store.save();
+  if (flags.json) { json({ ...t, event: ev.id }); return 0; }
+  const copied = await copyToClipboard(url);
+  const hhmm = exp.toTimeString().slice(0, 5);
+  line(`  ${c.g('✓')} ${c.b('Live view shared')}   ${c.m(`read-only · expires ${hhmm} (${flags.expires || '1h'})`)}`);
+  line(`    ${c.s(pad('link', 11))}${c.i(url)}${copied ? `    ${c.m('copied to clipboard')}` : ''}`);
+  line(`    ${c.s(pad('viewers', 11))}can watch output and diffs ${dot()} cannot type, approve or stop`);
+  line();
+  line(next('gitroots tunnel ls'));
+  return 0;
+}
+
+function list(flags, store) {
+  const rows = store.tunnels();
+  if (flags.json) { json(rows); return 0; }
+  line(`  ${h(`${pad('ID', 8)}${pad('SESSION', 10)}${pad('MACHINE', 13)}${pad('TARGET', 18)}${pad('ACCESS', 16)}${pad('VIEWERS', 10)}${pad('TRAFFIC', 10)}OPEN FOR`)}`);
+  for (const t of [...rows].reverse()) {
+    line(`  ${pad(t.id, 8)}${pad(t.session, 10)}${pad(t.machine, 13)}${pad(t.target, 18)}${pad(t.access, 16)}${pad(String(t.viewers), 10)}${pad(t.traffic, 10)}${t.at ? ago(t.at) : t.openFor}`);
+  }
+  if (!rows.length) line(c.m('  no open tunnels'));
+  line();
+  const first = rows[rows.length - 1];
+  line(`  ${c.m('ssh-free shell:')} ${c.s(`gitroots tunnel ${first ? first.session : '<session>'} --shell`)}   ${dot()}   ${c.m('kill all:')} ${c.s('gitroots tunnel close --all')}`);
+  return 0;
+}
+
+function ago(iso) {
+  const m = Math.floor((Date.now() - Date.parse(iso)) / 60000);
+  if (m < 1) return 'just now';
+  if (m < 60) return `${m}m`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+
+function close([id], flags, store) {
+  const before = store.d.tunnels.length;
+  if (flags.all) store.d.tunnels = [];
+  else {
+    if (!id) throw new Error('usage: gitroots tunnel close <t-id> | --all');
+    if (!store.d.tunnels.some((t) => t.id === id)) throw new Error(`no tunnel ${id} · see gitroots tunnel ls`);
+    store.d.tunnels = store.d.tunnels.filter((t) => t.id !== id);
+  }
+  const closed = before - store.d.tunnels.length;
+  store.record({ actor: store.org.user, action: 'tunnel close', target: flags.all ? 'all tunnels' : id, decision: 'allowed', note: `${closed} closed` });
+  store.save();
+  if (flags.json) { json({ closed }); return 0; }
+  line(`  ${c.g('✓')} Closed ${closed} tunnel${closed === 1 ? '' : 's'}`);
+  return 0;
+}

package/src/commands/update.js

@@ -0,0 +1,69 @@
+// gitroots update · uninstall
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { c } from '../ui/ansi.js';
+import { line, spinner, bar, confirm } from '../ui/term.js';
+import { json } from '../ui/components.js';
+import { VERSION, NPM_PACKAGE, DOWNLOAD_BASE, installMethod, nativePaths, platformKey } from '../runtime.js';
+import { latestVersion, installNative, newer, onPath } from '../installer.js';
+import { home } from '../data/store.js';
+
+export async function run(cmd, rest, flags) {
+  if (cmd === 'uninstall') return uninstall(flags);
+  return update(flags);
+}
+
+async function update(flags) {
+  const method = installMethod();
+  if (method === 'npm') {
+    const target = `${NPM_PACKAGE}@${flags.version || 'latest'}`;
+    line(`${c.i('○')} installed with npm · running ${c.b(`npm install -g ${target}`)}`);
+    const r = spawnSync(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['install', '-g', target], { stdio: 'inherit' });
+    return r.status ?? 1;
+  }
+  if (method === 'source') {
+    line(`${c.m('○')} running from a source checkout · update it with git pull, or install a release:`);
+    line(`  ${c.g(`curl -fsSL ${DOWNLOAD_BASE}/install.sh | bash`)}`);
+    return 0;
+  }
+  const sp = spinner((f) => `${c.i(f)} ${c.s(`Checking ${DOWNLOAD_BASE}…`)}`);
+  let target;
+  try { target = flags.version || await latestVersion(); } catch (e) { sp.stop(`${c.r('✕')} ${e.message}`); return 1; }
+  if (!flags.version && !newer(target, VERSION) && !flags.force) {
+    sp.stop(`${c.g('✓')} gitroots ${VERSION} is the latest`);
+    if (flags.json) json({ current: VERSION, latest: target, updated: false });
+    return 0;
+  }
+  sp.update((f) => `${c.i(f)} ${c.s(`Downloading gitroots ${target} for ${platformKey()}…`)}`);
+  let progress = 0;
+  sp.update((f) => `${c.i(f)} ${c.b('Downloading')}  ${bar(progress, 30)}  ${c.s(`${Math.round(progress * 100)}% · gitroots ${target}`)}`);
+  try {
+    const r = await installNative(target, { onProgress: (p) => { progress = p; } });
+    sp.stop(`${c.g('✓')} Updated ${VERSION} → ${c.b(target)}  ${c.m(`checksum verified · ${r.launcher}`)}`);
+    if (flags.json) json({ current: VERSION, latest: target, updated: true });
+    return 0;
+  } catch (e) {
+    sp.stop(`${c.r('✕')} ${e.message}`);
+    return 1;
+  }
+}
+
+async function uninstall(flags) {
+  const method = installMethod();
+  if (method === 'npm') { line(`installed with npm · run ${c.b(`npm uninstall -g ${NPM_PACKAGE}`)}`); return 0; }
+  const { data, launcher, bin } = nativePaths();
+  const targets = [launcher, data];
+  if (flags.purge) targets.push(home());
+  line('This removes:');
+  for (const t of targets) line(`  ${c.s(t)}${fs.existsSync(t) ? '' : c.m('  (not there)')}`);
+  line(c.w('◐ push hooks block pushes once gitroots is gone · run gitroots hooks uninstall in each repo first'));
+  const ok = await confirm('Uninstall gitroots?', { def: false, assumeYes: flags.yes || flags.y });
+  if (!ok) { line(c.m('  nothing removed')); return 1; }
+  for (const t of targets) fs.rmSync(t, { recursive: true, force: true });
+  line(`${c.g('✓')} gitroots removed${flags.purge ? '' : c.m(` · settings kept in ${home()} (--purge removes them)`)}`);
+  if (onPath(bin)) line(c.m(`  ${bin} stays on your PATH; remove the line the installer added to your shell profile if you no longer need it`));
+  return 0;
+}
+
+export { path };