atris 3.34.0 → 3.36.0

package/commands/computer.js

@@ -2,6 +2,7 @@
  * Atris Computer — interact with your EC2 AI Computer
  *
  *   atris computer                  — Open SMART mode (cloud in business workspace, local elsewhere)
+ *   atris computer setup            — Connect coding accounts to a computer
  *   atris computer --cloud          — Open CLOUD workspace mode
  *   atris computer create <name>    — Create and wake a business computer
  *   atris computer wake             — Start the computer
@@ -21,9 +22,18 @@ const os = require('os');
 const path = require('path');
 const readline = require('readline');
 const { spawnSync } = require('child_process');
-const { loadCredentials, decodeJwtClaims } = require('../utils/auth');
+const { loadCredentials, decodeJwtClaims, promptUser } = require('../utils/auth');
 const { apiRequestJson, getApiBaseUrl, getAppBaseUrl } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
+const {
+  engineLoginSeatError,
+  formatEngineSeats,
+  listEngineSeats,
+  normalizeEngineLoginSeat,
+  readyCheckEngineLogin,
+  runEngineDeviceLoginCommand,
+  validEngineLoginSeat,
+} = require('./engine');
 const { consoleCommand, gatherAtrisContext, buildSystemPrompt } = require('./console');
 const { streamSession } = require('./serve');
 const { buildRemoteAtrisBootstrapCommand } = require('../lib/runtime-bootstrap');
@@ -41,6 +51,132 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function askComputerSetup(question, deps = {}) {
+  const prompt = deps.prompt || promptUser;
+  return String(await prompt(question) || '').trim();
+}
+
+function setupComputerChoices(data) {
+  const businesses = Array.isArray(data)
+    ? data
+    : (Array.isArray(data?.businesses) ? data.businesses : []);
+  return businesses
+    .filter((business) => business && business.id)
+    .map((business) => {
+      const owner = business.name || business.slug || 'business';
+      const computer = business.computer_name || business.workspace_name || '';
+      return {
+        label: computer ? `${owner}: ${computer}` : `${owner} computer`,
+        target: { type: 'business', id: business.id },
+      };
+    });
+}
+
+async function chooseSetupComputer(computers, deps = {}) {
+  const choices = computers.length
+    ? computers
+    : [{ label: 'your personal computer', target: { type: 'user' } }];
+  if (choices.length === 1) {
+    console.log(`using ${choices[0].label}.`);
+    return choices[0];
+  }
+
+  choices.forEach((computer, index) => console.log(`${index + 1}. ${computer.label}`));
+  const answer = await askComputerSetup('which computer? [1] ', deps);
+  const selected = Number.parseInt(answer || '1', 10);
+  return choices[selected >= 1 && selected <= choices.length ? selected - 1 : 0];
+}
+
+async function chooseSetupProviders(deps = {}) {
+  while (true) {
+    const answer = (await askComputerSetup(
+      'which coding accounts do you want to connect? (codex / claude / both) [both] ',
+      deps
+    ) || 'both').toLowerCase();
+    if (answer === 'codex') return ['codex'];
+    if (answer === 'claude') return ['claude'];
+    if (answer === 'both') return ['codex', 'claude'];
+    console.error('choose codex, claude, or both.');
+  }
+}
+
+async function computerSetup(deps = {}) {
+  try {
+    const load = deps.loadCredentials || loadCredentials;
+    const credentials = await load();
+    if (!credentials?.token) {
+      console.error('run: atris login');
+      return 1;
+    }
+
+    const api = deps.apiRequestJson || apiRequestJson;
+    const computersResult = await api('/business/', {
+      method: 'GET',
+      token: credentials.token,
+      timeoutMs: 15000,
+      retries: 0,
+    });
+    if (!computersResult.ok) {
+      console.error('could not load your computers; please try again.');
+      return 1;
+    }
+
+    const computer = await chooseSetupComputer(setupComputerChoices(computersResult.data), deps);
+    const providers = await chooseSetupProviders(deps);
+    const deviceLogin = deps.runEngineDeviceLoginCommand || runEngineDeviceLoginCommand;
+    const readyCheck = deps.readyCheckEngineLogin || readyCheckEngineLogin;
+
+    for (const provider of providers) {
+      while (true) {
+        const providerHint = provider === 'claude'
+          ? ' you will get a code in the browser, paste it back here.'
+          : '';
+        const rawSeat = await askComputerSetup(
+          `connect a ${provider} account?${providerHint} give it a short name like personal or work (enter to finish) `,
+          deps
+        );
+        if (!rawSeat) break;
+        const seat = normalizeEngineLoginSeat(rawSeat);
+        if (!validEngineLoginSeat(seat)) {
+          console.error(engineLoginSeatError());
+          continue;
+        }
+
+        const code = await deviceLogin(provider, {
+          target: computer.target,
+          seat,
+          setup: true,
+        }, deps);
+        if (code !== 0) return 1;
+        let working = false;
+        try {
+          const checked = await readyCheck(provider, computer.target, deps);
+          working = Boolean(checked?.ok && checked.data?.status === 'ready');
+        } catch {}
+        const seatName = seat.toLowerCase();
+        console.log(working
+          ? `${seatName}: working`
+          : `${seatName}: linked, but the check failed - it may still work, try: atris engine seats`);
+      }
+    }
+
+    const listSeats = deps.listEngineSeats || listEngineSeats;
+    const seats = await listSeats(deps);
+    if (!seats.ok) {
+      console.error('could not check the linked accounts; please try again.');
+      return 1;
+    }
+
+    const now = typeof deps.now === 'function' ? deps.now() : Date.now();
+    console.log(formatEngineSeats(seats.data, now));
+    console.log('Done. Your computer can now work on these accounts.');
+    return 0;
+  } catch {
+    console.error('could not finish computer setup; please try again.');
+    return 1;
+  }
+}
+
 const VALID_CLOUD_WORKERS = new Set(['claude', 'openai']);
 const LOCAL_BRIDGE_RECONNECT_MS = 2000;
 const VALID_COMPUTER_TYPES = new Set([
@@ -3974,12 +4110,18 @@ async function runRecruitingComputerShortcut(token, args, cloudOptions = {}) {
   }
 }
 
-async function runComputer() {
-  const parsed = parseComputerOptions(process.argv.slice(3));
+async function runComputer(argv = process.argv.slice(3), deps = {}) {
+  const parsed = parseComputerOptions(argv);
   const args = parsed.positional;
   const cloudOptions = parsed.options;
   const sub = args[0];
 
+  if (sub === 'setup') {
+    const code = await computerSetup(deps);
+    if (code !== 0) process.exitCode = code;
+    return code;
+  }
+
   if (!sub) {
     if (cloudOptions.businessSlug || cloudOptions.workspaceId) {
       const token = getToken();
@@ -4085,6 +4227,7 @@ async function runComputer() {
     console.log('');
     console.log('Modes:');
     console.log('  (default)       Choose CLOUD vs LOCAL when both are available');
+    console.log('  setup           Connect named Codex or Claude accounts to a computer');
     console.log('  card            Show the local owner/computer card, no login required');
     console.log('  local           Open LOCAL Atris mode; cloud brain edits this folder');
     console.log('  proof           Run the local-edit + cloud-isolation + audit proof');
@@ -4124,6 +4267,7 @@ async function runComputer() {
     console.log('');
     console.log('Examples:');
     console.log('  atris computer');
+    console.log('  atris computer setup');
     console.log('  atris computer card --write');
     console.log('  atris business init "My Lab"     # first/default computer with Atris + operator');
     console.log('  atris computer create "Hiring Computer" --business my-lab --type recruiting');
@@ -4245,6 +4389,9 @@ async function runComputer() {
 
 module.exports = {
   runComputer,
+  computerSetup,
+  setupComputerChoices,
+  formatEngineSeats,
   buildComputerCard,
   renderComputerCard,
   renderComputerCardMarkdown,

package/commands/dream.js

@@ -0,0 +1,365 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const {
+  DEFAULT_CLAUDE_RUNNER_MODEL,
+  RUNNER_PROFILE_DEFS,
+} = require('../lib/runner-command');
+
+const DREAMS_FILE = ['.atris', 'state', 'dreams.jsonl'];
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DREAM_TIMEOUT_MS = 60 * 1000;
+const MAX_CONTEXT_CHARS = 7000;
+const MAX_SECTION_CHARS = 2400;
+
+function dreamsPath(root) {
+  return path.join(root, ...DREAMS_FILE);
+}
+
+function safeRead(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch { return ''; }
+}
+
+function readJsonLines(file) {
+  const text = safeRead(file);
+  if (!text) return [];
+  return text.split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function appendDreamRows(root, rows) {
+  if (!rows.length) return [];
+  const file = dreamsPath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`, 'utf8');
+  return rows;
+}
+
+function rowTimestamp(row) {
+  const keys = ['ts', 'at', 'created_at', 'updated_at', 'completed_at', 'finished_at', 'generated_at'];
+  for (const key of keys) {
+    const parsed = Date.parse(String(row && row[key] || ''));
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return NaN;
+}
+
+function isRecentTime(ms, nowMs, windowMs = DAY_MS) {
+  return Number.isFinite(ms) && ms >= nowMs - windowMs && ms <= nowMs + 5 * 60 * 1000;
+}
+
+function latestJournalFiles(root, limit = 2) {
+  const logsDir = path.join(root, 'atris', 'logs');
+  let years;
+  try { years = fs.readdirSync(logsDir).filter((name) => /^\d{4}$/.test(name)).sort(); } catch { return []; }
+  const files = [];
+  for (const year of years) {
+    const dir = path.join(logsDir, year);
+    let names;
+    try { names = fs.readdirSync(dir).filter((name) => /^\d{4}-\d{2}-\d{2}\.md$/.test(name)); } catch { names = []; }
+    for (const name of names) files.push(path.join(dir, name));
+  }
+  return files.sort().slice(-limit);
+}
+
+function clipTail(text, maxChars) {
+  const clean = String(text || '').trim();
+  if (clean.length <= maxChars) return clean;
+  return `[cut]\n${clean.slice(clean.length - maxChars + 6)}`;
+}
+
+function addSection(parts, budget, label, text, maxChars = MAX_SECTION_CHARS) {
+  const clean = String(text || '').trim();
+  if (!clean || budget.left <= 0) return;
+  const header = `\n[${label}]\n`;
+  const room = Math.min(maxChars, Math.max(0, budget.left - header.length));
+  if (room <= 0) return;
+  const body = clipTail(clean, room);
+  parts.push(`${header}${body}`);
+  budget.left -= header.length + body.length;
+}
+
+function recentJsonlRows(root, relativePath, nowMs, limit = 20) {
+  const rows = readJsonLines(path.join(root, relativePath));
+  return rows
+    .filter((row) => isRecentTime(rowTimestamp(row), nowMs))
+    .sort((a, b) => rowTimestamp(a) - rowTimestamp(b))
+    .slice(-limit);
+}
+
+function relativeToRoot(root, file) {
+  return path.relative(root, file).replace(/\\/g, '/');
+}
+
+function recentMissionReceipts(root, nowMs, limit = 6) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  let names;
+  try { names = fs.readdirSync(runsDir).filter((name) => /^mission-.*\.json$/.test(name)); } catch { return []; }
+  const receipts = [];
+  for (const name of names) {
+    const file = path.join(runsDir, name);
+    let stat;
+    try { stat = fs.statSync(file); } catch { continue; }
+    let parsed = null;
+    try { parsed = JSON.parse(safeRead(file)); } catch { parsed = null; }
+    const stamped = Number.isFinite(rowTimestamp(parsed)) ? rowTimestamp(parsed) : stat.mtimeMs;
+    if (!isRecentTime(stamped, nowMs)) continue;
+    receipts.push({ stamped, file: relativeToRoot(root, file), body: parsed || safeRead(file) });
+  }
+  return receipts.sort((a, b) => a.stamped - b.stamped).slice(-limit);
+}
+
+function collectDreamMaterial(root = process.cwd(), options = {}) {
+  const nowDate = options.now instanceof Date ? options.now : new Date(options.now || Date.now());
+  const nowMs = nowDate.getTime();
+  const parts = [];
+  const budget = { left: options.maxContextChars || MAX_CONTEXT_CHARS };
+
+  for (const file of latestJournalFiles(root, 2)) {
+    addSection(parts, budget, `journal ${path.basename(file, '.md')}`, safeRead(file));
+  }
+
+  const wishes = recentJsonlRows(root, path.join('.atris', 'state', 'wishes.jsonl'), nowMs);
+  if (wishes.length) addSection(parts, budget, 'wishes from the last day', wishes.map((row) => JSON.stringify(row)).join('\n'));
+
+  const missions = recentJsonlRows(root, path.join('.atris', 'state', 'missions.jsonl'), nowMs);
+  if (missions.length) addSection(parts, budget, 'missions from the last day', missions.map((row) => JSON.stringify(row)).join('\n'));
+
+  const receipts = recentMissionReceipts(root, nowMs);
+  if (receipts.length) {
+    addSection(parts, budget, 'mission receipts from the last day', receipts.map((receipt) => {
+      const body = typeof receipt.body === 'string' ? receipt.body : JSON.stringify(receipt.body);
+      return `${receipt.file}\n${body}`;
+    }).join('\n\n'));
+  }
+
+  return {
+    text: parts.join('\n').trim(),
+    sectionCount: parts.length,
+    now: nowDate.toISOString(),
+  };
+}
+
+function buildDreamPrompt(material) {
+  return [
+    'You are atris dream.',
+    'Read the day notes below.',
+    'Return only JSON.',
+    'Make 2 or 3 cards.',
+    'Use this exact shape:',
+    '[{"title":"three to five plain words","why":"one short line","move":"one concrete next action"}]',
+    'Use plain words a child gets.',
+    'Do not use em dashes.',
+    '',
+    material,
+  ].join('\n');
+}
+
+function replaceLongDashes(value) {
+  return String(value || '').replace(/[\u2012-\u2015]/g, '-');
+}
+
+function oneLine(value, max = 180) {
+  return replaceLongDashes(value)
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, max)
+    .trim();
+}
+
+function findJsonArrayText(output) {
+  const text = String(output || '').trim();
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const target = fenced ? fenced[1] : text;
+  const start = target.indexOf('[');
+  if (start === -1) return '';
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < target.length; index += 1) {
+    const ch = target[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === '[') {
+      depth += 1;
+    } else if (ch === ']') {
+      depth -= 1;
+      if (depth === 0) return target.slice(start, index + 1);
+    }
+  }
+  return '';
+}
+
+function parseDreamCards(output) {
+  const jsonText = findJsonArrayText(output);
+  if (!jsonText) throw new Error('missing json');
+  let parsed;
+  try { parsed = JSON.parse(jsonText); } catch (error) { throw new Error(`bad json: ${error.message}`); }
+  if (!Array.isArray(parsed) || parsed.length < 2 || parsed.length > 3) {
+    throw new Error('expected 2 or 3 cards');
+  }
+  return parsed.map((card) => {
+    const title = oneLine(card && card.title, 80);
+    const why = oneLine(card && card.why);
+    const move = oneLine(card && card.move);
+    const wordCount = title ? title.split(/\s+/).length : 0;
+    if (!title || !why || !move || wordCount < 3 || wordCount > 5) {
+      throw new Error('bad card shape');
+    }
+    return { title, why, move };
+  });
+}
+
+function dreamModels() {
+  const models = [
+    RUNNER_PROFILE_DEFS.haiku && RUNNER_PROFILE_DEFS.haiku.model,
+    DEFAULT_CLAUDE_RUNNER_MODEL,
+  ].filter(Boolean);
+  return Array.from(new Set(models));
+}
+
+function defaultDreamRunner({ prompt, model, cwd, timeoutMs = DREAM_TIMEOUT_MS }) {
+  return new Promise((resolve) => {
+    const bin = (RUNNER_PROFILE_DEFS.haiku && RUNNER_PROFILE_DEFS.haiku.bin) || 'claude';
+    const proc = spawn(bin, ['-p', prompt, '--model', model], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try { proc.kill('SIGTERM'); } catch {}
+    }, timeoutMs);
+    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ ok: code === 0 && !timedOut, stdout, stderr, exitCode: code, timedOut });
+    });
+    proc.on('error', (error) => {
+      clearTimeout(timer);
+      resolve({ ok: false, error: error.message, stdout, stderr, timedOut });
+    });
+  });
+}
+
+function attemptFailureReason(result) {
+  if (result && result.garbled) return 'could not read dream cards';
+  if (result && result.timedOut) return 'model timed out';
+  if (result && result.error) return 'model could not start';
+  if (result && result.exitCode) return 'model stopped early';
+  return 'model did not answer';
+}
+
+function writeDreamCards(root, cards, stamp) {
+  const ts = stamp || new Date().toISOString();
+  return appendDreamRows(root, cards.map((card) => ({
+    ts,
+    title: card.title,
+    why: card.why,
+    move: card.move,
+    source: 'dream',
+  })));
+}
+
+function writeDreamNoop(root, reason, stamp) {
+  return appendDreamRows(root, [{
+    ts: stamp || new Date().toISOString(),
+    kind: 'dream_noop',
+    reason,
+  }])[0];
+}
+
+async function runDream(root = process.cwd(), options = {}) {
+  const stamp = options.stamp || new Date().toISOString();
+  try {
+    const material = collectDreamMaterial(root, options);
+    if (!material.text) return { ok: false, cards: [], reason: 'nothing to read' };
+
+    const prompt = buildDreamPrompt(material.text);
+    const runner = options.runner || defaultDreamRunner;
+    let lastFailure = null;
+    for (const model of dreamModels()) {
+      const result = await runner({
+        prompt,
+        model,
+        cwd: root,
+        timeoutMs: options.timeoutMs || DREAM_TIMEOUT_MS,
+      });
+      if (!result || result.ok === false || result.timedOut) {
+        lastFailure = result || { ok: false };
+        continue;
+      }
+      const output = result.stdout != null ? result.stdout : (result.result || result.output || '');
+      let cards;
+      try {
+        cards = parseDreamCards(output);
+      } catch {
+        lastFailure = { ok: false, garbled: true };
+        continue;
+      }
+      return { ok: true, cards: writeDreamCards(root, cards, stamp), reason: null };
+    }
+
+    const reason = attemptFailureReason(lastFailure);
+    writeDreamNoop(root, reason, stamp);
+    return { ok: false, cards: [], reason, noop: true };
+  } catch {
+    const reason = 'could not finish dream';
+    try { writeDreamNoop(root, reason, stamp); } catch {}
+    return { ok: false, cards: [], reason, noop: true };
+  }
+}
+
+function showHelp(log = console.log) {
+  log('');
+  log('Usage: atris dream');
+  log('');
+  log('Reads today and writes 2 or 3 cards for atris next.');
+  log('');
+  log('Run me nightly: atris dream');
+  log('launchd line: run atris dream at 4:00 every morning');
+  log('');
+  return 0;
+}
+
+async function dreamCommand(args = [], root = process.cwd(), options = {}) {
+  const log = options.log || console.log;
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') return showHelp(log);
+  const result = await runDream(root, options);
+  if (result.cards && result.cards.length) {
+    const noun = result.cards.length === 1 ? 'card' : 'cards';
+    log(`Dreamed ${result.cards.length} ${noun}.`);
+  } else {
+    log(`No dreams tonight: ${result.reason || 'nothing useful'}`);
+  }
+  log('Run me nightly: atris dream');
+  return 0;
+}
+
+module.exports = {
+  DREAM_TIMEOUT_MS,
+  dreamsPath,
+  collectDreamMaterial,
+  buildDreamPrompt,
+  parseDreamCards,
+  dreamModels,
+  defaultDreamRunner,
+  runDream,
+  dreamCommand,
+};