atris 3.82.10 → 3.82.12

package/commands/sentinel-fix.js

@@ -222,6 +222,14 @@ async function fixCommand(argv, deps = {}) {
     }
   }
 
+  {
+    const rec = require('../lib/sentinel-record');
+    const o = { recordHome: deps.recordHome, homeDir: deps.homeDir, env: deps.env, record: deps.record };
+    let r;
+    try { r = rec.appendSafe(root, results.map((x) => rec.entryFromFix(x.record, x.res)), o); } catch (e) { r = { ok: false, reason: e.message }; }
+    const w = rec.warnLine(r);
+    if (w) console.log(w);
+  }
   const done = results.filter((x) => x.res.ok);
   if (done.length) {
     const events = require('../lib/sentinel-events');

package/commands/sentinel-powers.js

@@ -78,6 +78,22 @@ function startUpdateNotice(argv = [], { env = process.env, check, timeoutMs = 15
   };
 }
 
+// ---------------------------------------------------------------- record
+
+// Each check adds a signed entry to the security record
+// (lib/sentinel-record.js). A failure is a warning line, never an exit code.
+function addToRecord(root, build, deps = {}) {
+  const rec = require('../lib/sentinel-record');
+  const o = { recordHome: deps.recordHome, homeDir: deps.homeDir, env: deps.env, record: deps.record };
+  if (deps.record === false) return { ok: true, skipped: true };
+  try { return rec.appendSafe(root, build(rec, o), o); } catch (e) { return { ok: false, reason: String(e.message || e).split('\n')[0] }; }
+}
+
+function recordWarn(res, json) {
+  const w = require('../lib/sentinel-record').warnLine(res);
+  if (w) (json ? console.error : console.log)(w);
+}
+
 // ---------------------------------------------------------------- agents
 
 async function runAgents(root, { home = false, upload = true, deps = {} } = {}) {
@@ -90,7 +106,8 @@ async function runAgents(root, { home = false, upload = true, deps = {} } = {})
   try {
     res = await events.reportFindings(root, 'agent_check', evs, { token: upload ? tokenFor(deps) : '', base: deps.base, env: deps.env || process.env, upload });
   } catch (e) { res = { ok: false, reason: e.message }; }
-  return { result, events: evs, upload: res };
+  const record = addToRecord(root, (rec, o) => rec.entryFromAgents(root, result, o), deps);
+  return { result, events: evs, upload: res, record };
 }
 
 async function agentsCommand(argv, deps = {}) {
@@ -98,7 +115,8 @@ async function agentsCommand(argv, deps = {}) {
   try { opts = parseFlags(argv, ['home', 'json', 'no-upload']); } catch (e) { console.error(`  ${e.message}`); return 2; }
   let root;
   try { root = resolveRoot(opts, deps); } catch (e) { console.error(`  ${e.message}`); return 2; }
-  const { result, upload } = await runAgents(root, { home: Boolean(opts.home), upload: !opts.noUpload, deps });
+  const { result, upload, record } = await runAgents(root, { home: Boolean(opts.home), upload: !opts.noUpload, deps });
+  recordWarn(record, opts.json);
   if (opts.json) {
     console.log(JSON.stringify({ ok: result.grade !== 'fail', grade: result.grade, areas: result.areas, files: result.files, findings: result.findings, upload }, null, 2));
   } else {
@@ -153,7 +171,8 @@ async function runWatchCheck(root, { upload = true, deps = {} } = {}) {
       res.heldBranch = why.branch;
     } catch (e) { res = { ok: false, reason: e.message }; }
   }
-  return { result, events: evs, upload: res, branch };
+  const record = addToRecord(root, (rec, o) => rec.entryFromWatch(root, result, { ...o, branch }), deps);
+  return { result, events: evs, upload: res, branch, record };
 }
 
 function heldLines(upload, branch) {
@@ -186,7 +205,8 @@ async function watchCommand(argv, deps = {}) {
   let root;
   try { root = resolveRoot(opts, deps); } catch (e) { console.error(`  ${e.message}`); return 2; }
   const watch = require('../lib/sentinel-watch');
-  const { result, upload, branch } = await runWatchCheck(root, { upload: !opts.noUpload, deps });
+  const { result, upload, branch, record } = await runWatchCheck(root, { upload: !opts.noUpload, deps });
+  recordWarn(record, opts.json);
   let fix = null;
   if (opts.fix && !result.offline && result.affected.length) {
     try { fix = watch.applyFix(root, result, { run: deps.run, allowMajor: Boolean(opts.allowMajor) }); } catch (e) { fix = { ok: false, reason: String(e.message || e).split('\n')[0] }; }
@@ -279,6 +299,7 @@ async function guardCommand(argv, deps = {}) {
     const blocks = inst.recentBlocks({ env });
     const events = require('../lib/sentinel-events');
     const waiting = events.queueSize(env);
+    recordWarn(addToRecord(root, (rec, o) => rec.entryFromGuard(root, o), { ...deps, env }), opts.json);
     if (opts.json) { console.log(JSON.stringify({ ...st, blocked_today: blocks.length, waiting_to_send: waiting }, null, 2)); return 0; }
     console.log('');
     if (st.installed) console.log(`  the sentinel guard is on for ${where}`);

package/commands/sentinel-record.js

@@ -0,0 +1,139 @@
+'use strict';
+
+// atris sentinel record: the signed security record a reviewer can check.
+//
+//   atris sentinel record [show] [path]               plain summary
+//   atris sentinel record key [path]                  public key and fingerprint
+//   atris sentinel record export [path] --out FILE [--json]
+//   atris sentinel record verify FILE                 offline check of an export
+//   atris sentinel record backfill [path]             add past review runs, marked as added later
+//
+// The guarantee and its limits sit at the top of lib/sentinel-record.js.
+
+const fs = require('fs');
+const path = require('path');
+
+function help() {
+  console.log(`
+  atris sentinel record, a signed security record you can hand to a reviewer
+
+    atris sentinel record [path]                 what sentinel checked, what is open and fixed
+    atris sentinel record key [path]             this project's public key and its fingerprint
+    atris sentinel record export [path] --out record.html
+                                                 one html file a reviewer opens and checks in the browser
+    atris sentinel record export [path] --out record.json --json
+    atris sentinel record verify FILE            check an exported record offline
+    atris sentinel record backfill [path]        add past reviews, marked as added later with their dates
+
+  every review, recheck, agent check, watch, guard status and fix adds an
+  entry. each entry holds the hash of the one before it and is signed with
+  a key kept in ~/.atris. an edited, moved or removed entry shows.
+
+  what it proves: the record came from this key and was not changed.
+  what it does not prove: that the checks were thorough or the code is safe.
+  entries hold plain sentences, counts, file:line places and short ids only.
+`);
+  return 0;
+}
+
+function parse(argv) {
+  const opts = { paths: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--out') { opts.out = argv[++i]; if (!opts.out) throw new Error('--out needs a file'); }
+    else if (a === '--json') opts.json = true;
+    else if (a.startsWith('-')) throw new Error(`unknown flag: ${a}`);
+    else opts.paths.push(a);
+  }
+  return opts;
+}
+
+function rootOf(opts, deps) {
+  const root = path.resolve(opts.paths[0] || deps.root || process.cwd());
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) throw new Error(`${root} is not a folder`);
+  return root;
+}
+
+function libOpts(deps) {
+  const o = {};
+  if (deps.recordHome) o.recordHome = deps.recordHome;
+  if (deps.homeDir) o.homeDir = deps.homeDir;
+  if (deps.env) o.env = deps.env;
+  if (deps.now) o.now = deps.now;
+  return o;
+}
+
+async function recordCommand(argv = [], deps = {}) {
+  const rec = require('../lib/sentinel-record');
+  const known = ['show', 'key', 'export', 'verify', 'backfill', 'help'];
+  const sub = known.includes(argv[0]) ? argv[0] : 'show';
+  const rest = known.includes(argv[0]) ? argv.slice(1) : argv;
+  if (sub === 'help' || rest.includes('--help') || rest.includes('-h')) return help();
+  let opts;
+  try { opts = parse(rest); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  const lo = libOpts(deps);
+
+  if (sub === 'verify') {
+    const file = opts.paths[0];
+    if (!file) { console.error('  name the exported file: atris sentinel record verify FILE'); return 2; }
+    let doc;
+    try { doc = rec.readExport(path.resolve(file)); } catch (e) { console.error(`  could not read ${file}: ${e.message}`); return 2; }
+    const r = rec.verifyDoc(doc);
+    if (opts.json) { console.log(JSON.stringify(r, null, 2)); return r.ok ? 0 : 1; }
+    if (r.ok) {
+      console.log(`  verified: all ${r.entries} entries for ${doc.project} are signed by key ${r.fingerprint}`);
+      console.log('  none were changed, moved or removed. compare the fingerprint with the one the company gave you');
+      return 0;
+    }
+    console.log(`  broken at ${r.label}: ${r.reason}`);
+    return 1;
+  }
+
+  let root;
+  try { root = rootOf(opts, deps); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  const project = rec.projectName(root);
+  const id = rec.projectId(root);
+
+  if (sub === 'key') {
+    let key;
+    try { key = rec.loadKey(id, { ...lo, name: project }); } catch (e) { console.error(`  could not open the record key: ${e.message}`); return 1; }
+    if (opts.json) { console.log(JSON.stringify({ project, project_id: id, public_key: key.publicKey, fingerprint: key.fingerprint }, null, 2)); return 0; }
+    console.log(`\n  record key for ${project}${key.created ? ' (made just now)' : ''}`);
+    console.log(`  public key: ${key.publicKey}`);
+    console.log(`  fingerprint: ${key.fingerprint}`);
+    console.log('  give the fingerprint to reviewers through a channel they trust. the private key stays in ~/.atris\n');
+    return 0;
+  }
+
+  if (sub === 'backfill') {
+    let res;
+    try { res = rec.backfill(root, lo); } catch (e) { console.error(`  could not backfill the record: ${e.message}`); return 1; }
+    console.log(`  added ${res.added.length} past run${res.added.length === 1 ? '' : 's'} to the record, each marked as added later with its original date`);
+    if (res.skipped.length) console.log(`  ${res.skipped.length} already in the record or unreadable`);
+    return 0;
+  }
+
+  if (sub === 'export') {
+    if (!opts.out) { console.error('  name the output file: atris sentinel record export --out record.html'); return 2; }
+    let doc;
+    try { doc = rec.buildExport(root, lo); } catch (e) { console.error(`  could not export the record: ${e.message}`); return 1; }
+    const out = path.resolve(opts.out);
+    const body = opts.json ? `${JSON.stringify(doc, null, 2)}\n` : rec.renderHtml(doc);
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    fs.writeFileSync(out, body);
+    console.log(`  wrote ${doc.entries.length} signed entries to ${out}`);
+    console.log(`  key fingerprint: ${doc.key_fingerprint}`);
+    console.log(opts.json ? '  check it with: atris sentinel record verify FILE' : '  a reviewer opens it in a browser. it checks itself and shows verified or broken');
+    return 0;
+  }
+
+  // show
+  let entries;
+  try { entries = rec.readEntries(rec.recordPath(root, lo)); } catch (e) { console.error(`  could not read the record: ${e.message}`); return 1; }
+  const key = rec.loadKey(id, { ...lo, create: false });
+  if (opts.json) { console.log(JSON.stringify({ project, project_id: id, key_fingerprint: key ? key.fingerprint : null, ...rec.summarize(entries) }, null, 2)); return 0; }
+  console.log(rec.renderShow(project, entries, key));
+  return 0;
+}
+
+module.exports = { recordCommand };

package/lib/known-commands.js

@@ -4,7 +4,7 @@ const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'work
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
-                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an

package/lib/memory-files.js

@@ -0,0 +1,226 @@
+'use strict';
+
+// Real files in an Atris memory folder: photos, PDFs, recordings, anything
+// under files/. The bytes go straight between this laptop and the private
+// bucket, on short-lived links the Atris server signs for one file at a time.
+// They never pass through the server, and no file is ever held whole in
+// memory here: hashing, sending and fetching all stream in 1 MB pieces.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const http = require('http');
+const https = require('https');
+const { Transform, pipeline } = require('stream');
+
+// Pages the server writes and reads as text, up to its 1 MB write limit.
+// Everything else (any other type, or bigger) goes as a file.
+const TEXT_ENDINGS = ['.md', '.txt', '.json', '.jsonl', '.csv', '.yaml', '.yml'];
+const TEXT_MAX_BYTES = 1000000;
+const LARGE_BYTES = 4 * 1024 * 1024; // files this big move one at a time, with a progress line
+const PIECE = 1024 * 1024;
+const IDLE_MS = 60000;
+
+function goesAsFile(rel, size) {
+  const lower = String(rel).toLowerCase();
+  return !(Number(size) <= TEXT_MAX_BYTES) || !TEXT_ENDINGS.some((ending) => lower.endsWith(ending));
+}
+
+function printOf(buffer) {
+  return {
+    sha256: crypto.createHash('sha256').update(buffer).digest('hex'),
+    md5: crypto.createHash('md5').update(buffer).digest('hex'),
+    bytes: buffer.length,
+  };
+}
+
+// The fingerprints of a file on disk, read 1 MB at a time.
+function hashFileSync(abs) {
+  const sha = crypto.createHash('sha256');
+  const md5 = crypto.createHash('md5');
+  const piece = Buffer.allocUnsafe(PIECE);
+  const fd = fs.openSync(abs, 'r');
+  let bytes = 0;
+  try {
+    for (;;) {
+      const n = fs.readSync(fd, piece, 0, PIECE, null);
+      if (!n) break;
+      sha.update(piece.subarray(0, n));
+      md5.update(piece.subarray(0, n));
+      bytes += n;
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+  return { sha256: sha.digest('hex'), md5: md5.digest('hex'), bytes };
+}
+
+function size(n) {
+  const units = [['GB', 1024 ** 3], ['MB', 1024 ** 2], ['KB', 1024]];
+  for (const [unit, step] of units) {
+    if (n >= step) return `${(n / step).toFixed(n % step === 0 || n >= 10 * step ? 0 : 1)} ${unit}`;
+  }
+  return `${n} bytes`;
+}
+
+// Links come from the Atris server. Only https, or plain http to this machine (tests, a local server).
+function transportFor(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol === 'https:') return { parsed, transport: https };
+  if (parsed.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(parsed.hostname)) {
+    return { parsed, transport: http };
+  }
+  throw new Error('the Atris server sent a link that is not https');
+}
+
+// What S3 said, without the link (it carries a signature).
+function s3Said(status, body) {
+  const code = /<Code>([^<]{1,80})<\/Code>/.exec(body);
+  const message = /<Message>([^<]{1,200})<\/Message>/.exec(body);
+  if (code) return `storage refused it (${code[1]}${message ? `: ${message[1]}` : ''})`;
+  return `storage answered ${status}`;
+}
+
+function readSmall(res, done) {
+  const chunks = [];
+  let kept = 0;
+  res.on('data', (chunk) => { if (kept < 16384) { chunks.push(chunk); kept += chunk.length; } });
+  res.on('end', () => done(Buffer.concat(chunks).toString('utf8')));
+  res.on('error', () => done(''));
+}
+
+// POST one file to a signed S3 upload form: every field the server gave, the file last.
+// Resolves with the fingerprints of exactly the bytes sent.
+function sendFile({ url, fields, abs, bytes: expected, onProgress = null }) {
+  const { parsed, transport } = transportFor(url);
+  const boundary = `----atris-${crypto.randomBytes(16).toString('hex')}`;
+  let head = '';
+  for (const [name, value] of Object.entries(fields || {})) {
+    if (!/^[A-Za-z0-9_-]{1,100}$/.test(name)) throw new Error('the upload form has a field this tool does not send');
+    head += `--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`;
+  }
+  head += `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="file"\r\n`
+    + 'Content-Type: application/octet-stream\r\n\r\n';
+  const start = Buffer.from(head, 'utf8');
+  const end = Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8');
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let sent = null;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (error) reject(error); else resolve(value);
+    };
+    const req = transport.request(parsed, {
+      method: 'POST',
+      headers: {
+        'Content-Type': `multipart/form-data; boundary=${boundary}`,
+        'Content-Length': start.length + expected + end.length,
+      },
+    });
+    req.setTimeout(IDLE_MS, () => req.destroy(new Error('the upload stalled for a minute')));
+    req.on('error', (error) => finish(error));
+    req.on('response', (res) => readSmall(res, (body) => {
+      if (res.statusCode >= 200 && res.statusCode < 300 && sent) finish(null, sent);
+      else finish(new Error(s3Said(res.statusCode, body)));
+    }));
+    const drained = () => new Promise((go) => {
+      const on = () => { req.off('drain', on); req.off('close', on); go(); };
+      req.on('drain', on);
+      req.on('close', on);
+    });
+    (async () => {
+      const sha = crypto.createHash('sha256');
+      const md5 = crypto.createHash('md5');
+      let count = 0;
+      const stream = fs.createReadStream(abs, { highWaterMark: PIECE });
+      req.write(start);
+      try {
+        for await (const chunk of stream) {
+          if (settled || req.destroyed) return;
+          count += chunk.length;
+          if (count > expected) throw new Error('the file changed while it was being sent');
+          sha.update(chunk);
+          md5.update(chunk);
+          if (onProgress) onProgress(count, expected);
+          if (!req.write(chunk)) await drained();
+        }
+      } finally {
+        stream.destroy();
+      }
+      if (count !== expected) throw new Error('the file changed while it was being sent');
+      sent = { sha256: sha.digest('hex'), md5: md5.digest('hex'), bytes: count };
+      req.end(end);
+    })().catch((error) => req.destroy(error));
+  });
+}
+
+// GET a signed download link into `temp`, streaming. Resolves with the fingerprints of what arrived.
+function fetchFile({ url, temp, bytes: expected = 0, onProgress = null }) {
+  const { parsed, transport } = transportFor(url);
+  return new Promise((resolve, reject) => {
+    const req = transport.get(parsed, (res) => {
+      if (res.statusCode !== 200) {
+        readSmall(res, (body) => reject(new Error(s3Said(res.statusCode, body))));
+        return;
+      }
+      const sha = crypto.createHash('sha256');
+      const md5 = crypto.createHash('md5');
+      let count = 0;
+      const tap = new Transform({
+        transform(chunk, _encoding, next) {
+          count += chunk.length;
+          sha.update(chunk);
+          md5.update(chunk);
+          if (onProgress) onProgress(count, expected);
+          next(null, chunk);
+        },
+      });
+      pipeline(res, tap, fs.createWriteStream(temp, { flags: 'wx' }), (error) => {
+        if (error) reject(error);
+        else resolve({ sha256: sha.digest('hex'), md5: md5.digest('hex'), bytes: count });
+      });
+    });
+    req.setTimeout(IDLE_MS, () => req.destroy(new Error('the download stalled for a minute')));
+    req.on('error', reject);
+  });
+}
+
+// A hidden name beside the target, so a half-fetched file is never mistaken for the real one.
+function tempBeside(abs) {
+  return path.join(path.dirname(abs), `.${path.basename(abs)}.atris-tmp-${process.pid}-${crypto.randomBytes(4).toString('hex')}`);
+}
+
+// One line per large file. On a terminal it updates in place with a percent;
+// otherwise it is printed once, when the file starts moving.
+function progressPrinter({ log, tty = null }) {
+  const shown = new Map();
+  return ({ rel, verb, done, total, finished = false }) => {
+    if (total < LARGE_BYTES) return;
+    const label = `${verb} ${rel} (${size(total)})`;
+    if (!tty) {
+      if (!shown.has(rel)) { shown.set(rel, true); log(`${label}...`); }
+      return;
+    }
+    if (finished) {
+      if (shown.has(rel)) tty.write('\n');
+      return;
+    }
+    const percent = Math.floor((done * 100) / Math.max(1, total));
+    if (shown.get(rel) === percent) return;
+    shown.set(rel, percent);
+    tty.write(`\r${label} ${percent}%`);
+  };
+}
+
+module.exports = {
+  LARGE_BYTES,
+  fetchFile,
+  goesAsFile,
+  hashFileSync,
+  printOf,
+  progressPrinter,
+  sendFile,
+  tempBeside,
+};