agentbox-app 0.1.12 → 0.1.16

package/main/cloud/docs.mjs

@@ -0,0 +1,219 @@
+// THE PROJECT'S DOCUMENTS FOLDER, FOR A CLOUD RUN.
+//
+// A worker on this Mac reads the plans and notes in the project's documents
+// folder and writes its designs and reports there, where the app draws them.
+// A cloud run gets a copy at the same path: everything small, and this
+// thread's own designs folder, newest first, as much as fits. What it writes
+// there comes back while it works and once more at the end
+// (main/cloud/run.mjs), and is laid in here. Never a deletion, never over a
+// file someone changed on this Mac while the run was away, and never over one
+// the run did not take with it: those are kept, and the run's copy goes beside.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { run } from './exec.mjs';
+
+// The folders that hold pictures by the gigabyte. Only this thread's own
+// designs go up from them; the rest of the folder is small.
+const HEAVY = new Set(['designs', 'attachments']);
+export const DOCS_LIMITS = {
+  file: 256 * 1024,
+  ownFile: 25 * 1024 * 1024,
+  own: 50 * 1024 * 1024,
+  total: 100 * 1024 * 1024,
+  files: 5000,
+};
+
+const inside = (p, root) => p === root || p.startsWith(root + path.sep);
+
+/** The files, by path inside `dir`, that go up with a cloud run for `item`. */
+export function docsToSend(dir, { item = null, limits = DOCS_LIMITS } = {}) {
+  const own = item && /^[A-Za-z0-9_-]+$/.test(item) ? `designs/${item}` : null;
+  const picked = [];
+  let total = 0;
+  let ownTotal = 0;
+  const walk = (rel) => {
+    let entries = [];
+    try { entries = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }); } catch { return; }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      if (picked.length >= limits.files) return;
+      if (e.name.startsWith('.')) continue;
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (/[\n\r]/.test(r)) continue;
+      if (e.isDirectory()) {
+        if (!rel && HEAVY.has(e.name)) { if (own && e.name === 'designs') walkOwn(); continue; }
+        walk(r);
+        continue;
+      }
+      if (!e.isFile()) continue;
+      let size;
+      try { size = fs.statSync(path.join(dir, r)).size; } catch { continue; }
+      if (size > limits.file || total + size > limits.total) continue;
+      picked.push(r);
+      total += size;
+    }
+  };
+  // Newest first: a thread whose designs do not all fit takes its latest
+  // work, and the rest stays on this Mac.
+  const walkOwn = () => {
+    const found = [];
+    const stack = [own];
+    while (stack.length) {
+      const rel = stack.shift();
+      let entries = [];
+      try { entries = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }); } catch { continue; }
+      for (const e of entries) {
+        if (e.name.startsWith('.')) continue;
+        const r = `${rel}/${e.name}`;
+        if (/[\n\r]/.test(r)) continue;
+        if (e.isDirectory()) { stack.push(r); continue; }
+        if (!e.isFile()) continue;
+        let st;
+        try { st = fs.statSync(path.join(dir, r)); } catch { continue; }
+        if (st.size <= limits.ownFile) found.push({ r, size: st.size, at: st.mtimeMs });
+      }
+    }
+    found.sort((a, b) => b.at - a.at || a.r.localeCompare(b.r));
+    for (const f of found) {
+      if (picked.length >= limits.files) return;
+      if (ownTotal + f.size > limits.own) continue;
+      picked.push(f.r);
+      ownTotal += f.size;
+    }
+  };
+  walk('');
+  return picked;
+}
+
+/** Those files as one gzipped tar, paths inside `dir`. */
+export function tarDocs(dir, files) {
+  return run('tar', ['-czf', '-', '-C', dir, '--null', '-T', '-'], { input: files.join('\0') + '\0', encoding: null, env: { ...process.env, COPYFILE_DISABLE: '1' } });
+}
+
+const stampOf = (st) => `${st.size}:${Math.round(st.mtimeMs)}`;
+const hashOf = (body) => crypto.createHash('sha256').update(body).digest('hex');
+
+// `notes.md` -> `notes (cloud).md`, then `notes (cloud 2).md`, and so on.
+function besideName(file) {
+  const ext = path.extname(file);
+  const base = file.slice(0, file.length - ext.length);
+  for (let i = 1; ; i += 1) {
+    const p = `${base} (cloud${i > 1 ? ` ${i}` : ''})${ext}`;
+    if (!fs.existsSync(p)) return p;
+  }
+}
+
+/**
+ * Lay an archive of documents the run wrote into `dir`.
+ *
+ * `sentAt` is when the run left with the folder; `laid` is what earlier calls
+ * for the same run wrote, path -> { stamp, hash }, and is updated in place. A
+ * version this run already laid is never laid again: the run sends a file
+ * until the Mac confirms it, so the same one can arrive twice. Otherwise a file
+ * is written over only if it is missing here, unchanged here since the run
+ * left, or is still exactly what this run itself laid. Anything else is a
+ * change made on this Mac, and the run's copy goes beside it.
+ *
+ * `sent` is every path the run took with it. A file here that is not one of
+ * them was never the run's to change, however old it is, so its copy goes
+ * beside it too. A run recorded before the list was kept passes none.
+ */
+export async function layDocs({ tgz, dir, sentAt = 0, laid = {}, sent = null }) {
+  const took = sent ? new Set(sent) : null;
+  const out = { written: [], beside: [], moved: [] };
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentbox-docs-'));
+  try {
+    // From a file, not a pipe: tar may stop reading at the archive's end
+    // marker, and a pipe it stopped reading fails the write (EPIPE) on a busy Mac.
+    const file = path.join(tmp, '.agentbox-docs.tgz');
+    fs.writeFileSync(file, tgz);
+    const into = path.join(tmp, 'docs');
+    fs.mkdirSync(into);
+    await run('tar', ['-xzf', file, '-C', into]);
+    fs.mkdirSync(dir, { recursive: true });
+    const root = fs.realpathSync(dir);
+    const files = [];
+    const walk = (rel) => {
+      for (const e of fs.readdirSync(path.join(into, rel), { withFileTypes: true })) {
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) walk(r);
+        else if (e.isFile()) files.push(r);
+      }
+    };
+    walk('');
+    // The nearest folder that exists, after links, must be this one or in
+    // it: a link inside the folder never carries a file out of it.
+    const safeParent = (file) => {
+      let parent = path.dirname(file);
+      while (!fs.existsSync(parent)) parent = path.dirname(parent);
+      if (!inside(fs.realpathSync(parent), root)) return false;
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      return inside(fs.realpathSync(path.dirname(file)), root);
+    };
+    for (const rel of files) {
+      const asIs = path.join(root, rel);
+      let target = asIs;
+      const body = fs.readFileSync(path.join(into, rel));
+      const hash = hashOf(body);
+      if (laid[rel]?.hash === hash) continue;
+      // A file whose folder here is a link out of it is not dropped: it lands
+      // in a folder of its own, and the run's work is all still home.
+      if (!safeParent(target)) {
+        target = path.join(root, 'from-the-cloud', rel);
+        if (!safeParent(target)) throw new Error(`nowhere safe to put ${rel}`);
+        out.moved.push(path.relative(root, target));
+      }
+      let here = null;
+      try { here = fs.lstatSync(target); } catch { /* new */ }
+      // A link or a folder where the file goes is left as it is, and the
+      // run's copy goes beside it.
+      if (here && !here.isFile()) {
+        target = besideName(target);
+        out.beside.push(path.relative(root, target));
+        here = null;
+      }
+      if (here) {
+        // The same bytes already here: nothing to write. It becomes the run's
+        // only if the run took it or wrote it before, never a file left here.
+        if (here.size === body.length && fs.readFileSync(target).equals(body)) {
+          const owned = !took || took.has(rel) || !!laid[rel]?.stamp;
+          laid[rel] = { stamp: owned ? stampOf(here) : null, hash };
+          continue;
+        }
+        const mine = laid[rel]?.stamp === stampOf(here);
+        // Whole milliseconds on both sides: `sentAt` is a Date.now() and counts
+        // them, an mtime does not, so a file saved 0.7 ms before the run left
+        // read as newer than it and the run's own edit went beside a file
+        // nobody had touched.
+        const untouched = mine || (Math.floor(here.mtimeMs) <= sentAt && (!took || took.has(rel)));
+        if (!untouched) {
+          target = besideName(target);
+          out.beside.push(path.relative(root, target));
+        }
+      }
+      // A fresh name, made only if nothing is there: a link left at a name
+      // this could guess would otherwise be written through.
+      const part = path.join(path.dirname(target), `.agentbox-${crypto.randomUUID()}.part`);
+      fs.writeFileSync(part, body, { flag: 'wx' });
+      fs.renameSync(part, target);
+      if (target === asIs) out.written.push(rel);
+      laid[rel] = { stamp: target === asIs ? stampOf(fs.statSync(target)) : laid[rel]?.stamp ?? null, hash };
+    }
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+  return out;
+}
+
+/** The documents folder a run may take, or null: it must exist and must not hold, or sit in, the task folder. */
+export function docsFolderFor(docs, cwd) {
+  if (!docs || !path.isAbsolute(docs)) return null;
+  let real;
+  let realCwd;
+  try { real = fs.realpathSync(docs); realCwd = fs.realpathSync(cwd); } catch { return null; }
+  if (!fs.statSync(real).isDirectory()) return null;
+  if (inside(real, realCwd) || inside(realCwd, real)) return null;
+  return docs;
+}

package/main/cloud/exec.mjs

@@ -0,0 +1,27 @@
+// A command run without holding up this process, which every cloud run's relay
+// shares (./host.mjs): one run's git or tar must not stop the others.
+import { spawn } from 'node:child_process';
+
+// Resolves to stdout (a string, or a Buffer when `encoding` is null); rejects,
+// as execFileSync throws, with "Command failed: <command>" and its stderr.
+export function run(cmd, args, { cwd, env = process.env, input = null, encoding = 'utf8' } = {}) {
+  return new Promise((resolve, reject) => {
+    let child;
+    try { child = spawn(cmd, args, { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] }); } catch (err) { reject(err); return; }
+    const out = [];
+    const err = [];
+    child.stdout.on('data', (d) => out.push(d));
+    child.stderr.on('data', (d) => err.push(d));
+    child.on('error', reject);
+    child.on('close', (code, signal) => {
+      const stdout = Buffer.concat(out);
+      if (code === 0) { resolve(encoding ? stdout.toString(encoding) : stdout); return; }
+      const stderr = Buffer.concat(err).toString('utf8');
+      const e = new Error(`Command failed: ${cmd} ${args.join(' ')}\n${stderr}`);
+      Object.assign(e, { status: code, signal, stderr });
+      reject(e);
+    });
+    child.stdin.on('error', () => {});
+    child.stdin.end(input ?? undefined);
+  });
+}

package/main/cloud/host.mjs

@@ -0,0 +1,165 @@
+// ONE PROCESS ON THIS MAC FOR EVERY CLOUD RUN'S RELAY (main/cloud/run.mjs).
+// The supervisor holds, for each run, a stand-in of a few megabytes
+// (scripts/cloud-shim.pl) that carries the run's input, output, signals and
+// exit code here and back, so to the supervisor a cloud run is still one
+// process.
+//
+// Lines over a socket only this user can reach. The stand-in sends a hello
+// ({ argv, env, cwd, pid }), then `i <b64>` input, `I` end of input,
+// `k <signal>`; this answers `o <b64>` output, `e <b64>` errors, `x <code>`.
+// A stand-in that goes without saying (killed outright) is a run whose app
+// has gone: it is left going in the cloud, as on a quit, and brought home
+// later. With no run for a minute this process ends.
+//
+//   ELECTRON_RUN_AS_NODE=1 <electron> main/cloud/host.mjs <socket>
+import fs from 'node:fs';
+import os from 'node:os';
+import net from 'node:net';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { fileURLToPath } from 'node:url';
+import { nameSlug } from '../../shared/product-name.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+// The files a host is made of. A host started by an older app serves only the
+// stand-ins of that app: a newer one starts its own beside it.
+const MADE_OF = ['host.mjs', 'run.mjs', 'run-cli.mjs', 'docs.mjs', 'exec.mjs', 'marker.mjs', 'aws.mjs', '../approval-prompt-core.mjs', '../../mcp/stdio.mjs', '../../mcp/tools.mjs'];
+const TRANSPORT_FAULT = 75;
+// The exit of a host that found one of this app's already serving its socket.
+export const HOST_ALREADY_THERE = 3;
+let hosts = 0;
+
+// Whether this perl has every module the stand-in uses: some Linux perls ship
+// without JSON::PP.
+export function perlRunsTheShim(perl) {
+  try {
+    return spawnSync(perl, ['-MIO::Socket::UNIX', '-MIO::Select', '-MMIME::Base64', '-MJSON::PP', '-MCwd', '-MPOSIX', '-e1'], { stdio: 'ignore', timeout: 10_000 }).status === 0;
+  } catch { return false; }
+}
+
+export function hostStamp() {
+  const h = crypto.createHash('sha1');
+  for (const f of MADE_OF) { try { h.update(fs.readFileSync(path.join(HERE, f))); } catch { h.update(f); } }
+  return h.digest('hex').slice(0, 12);
+}
+
+// Short enough for a socket's path (104 bytes on macOS), and this user's own.
+export function hostSocketPath({ stamp = hostStamp(), dir = os.tmpdir(), uid = process.getuid?.() ?? 0 } = {}) {
+  return path.join(dir, `${nameSlug}-cloud-${uid}-${stamp}.sock`);
+}
+
+/**
+ * Serves runs on `sockPath`; `runOne(opts)` is one run, resolving to its exit
+ * code. `started` says 'serving', or 'taken' when a host already answers there.
+ */
+export function startCloudHost({ sockPath, runOne, idleMs = 60_000, onIdle = () => {}, log = () => {} }) {
+  let live = 0;
+  let idleTimer = null;
+  const idle = () => {
+    clearTimeout(idleTimer);
+    if (live === 0) { idleTimer = setTimeout(() => { if (live === 0) onIdle(); }, idleMs); idleTimer.unref?.(); }
+  };
+  const server = net.createServer((sock) => {
+    let buf = '';
+    let started = false;
+    let done = false;
+    const stdin = new PassThrough();
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    const signals = new EventEmitter();
+    const send = (line) => { if (!sock.destroyed) return sock.write(line + '\n'); return true; };
+    // What the run prints goes out as it comes, never faster than the
+    // stand-in takes it.
+    for (const [stream, tag] of [[stdout, 'o'], [stderr, 'e']]) {
+      stream.on('data', (b) => { if (send(`${tag} ${b.toString('base64')}`) === false && !sock.destroyed) { stream.pause(); sock.once('drain', () => stream.resume()); } });
+    }
+    const finish = (code) => {
+      if (done) return;
+      done = true;
+      let open = 2;
+      const both = () => { open -= 1; if (open === 0) { send(`x ${Number.isInteger(code) ? code : TRANSPORT_FAULT}`); sock.end(); live -= 1; idle(); } };
+      stdout.once('end', both); stderr.once('end', both);
+      stdout.end(); stderr.end();
+      stdout.resume(); stderr.resume();
+    };
+    sock.setEncoding('utf8');
+    sock.on('data', (d) => {
+      buf += d;
+      let n;
+      while ((n = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, n);
+        buf = buf.slice(n + 1);
+        if (!started) {
+          let hello = null;
+          try { hello = JSON.parse(line); } catch { /* not a hello */ }
+          if (!Array.isArray(hello?.argv) || typeof hello.cwd !== 'string') { send(`e ${Buffer.from('agentbox cloud: the stand-in sent no run\n').toString('base64')}`); send(`x ${TRANSPORT_FAULT}`); sock.end(); return; }
+          started = true;
+          live += 1;
+          clearTimeout(idleTimer);
+          Promise.resolve()
+            .then(() => runOne({ args: hello.argv, env: hello.env || {}, cwd: hello.cwd, stdin, stdout, stderr, signals, pid: Number(hello.pid) || undefined, watchParent: false }))
+            .then((code) => finish(code), (err) => { stderr.write(`agentbox cloud: stopped: ${err?.message || err}\n`); finish(TRANSPORT_FAULT); });
+          continue;
+        }
+        if (line.startsWith('i ')) stdin.write(Buffer.from(line.slice(2), 'base64'));
+        else if (line === 'I') stdin.end();
+        else if (line.startsWith('k ') && /^SIG(TERM|INT|HUP)$/.test(line.slice(2))) signals.emit(line.slice(2));
+      }
+    });
+    // Gone without a word: its app is gone, so the run carries on in the
+    // cloud and is brought home when the app next opens.
+    // Its output then goes nowhere, so a run held waiting for room is let go.
+    sock.on('close', () => { stdout.resume(); stderr.resume(); if (started && !done) signals.emit('SIGHUP'); });
+    sock.on('error', () => {});
+  });
+  server.on('error', (err) => log(`cloud host: ${err.message}`));
+  // The socket file this host made. Ending, it takes away that one only: a
+  // newer host may have put its own at the same path. Node deletes the path a
+  // server listened on as it closes, so it listens on a name of its own and
+  // moves it into place.
+  let mine = null;
+  const own = `${sockPath}.${process.pid}${(hosts += 1)}`;
+  const ours = () => { try { return mine !== null && fs.statSync(sockPath).ino === mine; } catch { return false; } };
+  const started = new Promise((resolve) => {
+    const probe = net.connect(sockPath);
+    probe.once('connect', () => { probe.destroy(); resolve('taken'); });
+    probe.once('error', () => {
+      try { fs.unlinkSync(own); } catch { /* not there */ }
+      server.listen(own, () => {
+        try { fs.chmodSync(own, 0o600); fs.renameSync(own, sockPath); mine = fs.statSync(sockPath).ino; } catch (err) { log(`cloud host: ${err.message}`); }
+        idle();
+        resolve('serving');
+      });
+    });
+  });
+  return {
+    server,
+    started,
+    live: () => live,
+    close: () => started.then(() => new Promise((resolve) => {
+      clearTimeout(idleTimer);
+      if (ours()) { try { fs.unlinkSync(sockPath); } catch { /* gone */ } }
+      if (server.listening) server.close(() => resolve()); else resolve();
+    })),
+  };
+}
+
+// Started as a program by the supervisor (Supervisor#_cloudHost).
+if (path.basename(process.argv[1] || '') === 'host.mjs') {
+  const sockPath = process.argv[2];
+  const { cloudRunFromArgs, dropAwsSignIns } = await import('./run-cli.mjs');
+  dropAwsSignIns();
+  const host = startCloudHost({
+    sockPath,
+    runOne: cloudRunFromArgs,
+    onIdle: () => host.close().then(() => process.exit(0)),
+    log: (m) => process.stderr.write(`${m}\n`),
+  });
+  if (await host.started === 'taken') process.exit(HOST_ALREADY_THERE);
+  // A run's stray error is that run's, not every run's.
+  process.on('uncaughtException', (err) => process.stderr.write(`cloud host: ${err?.stack || err}\n`));
+  process.on('unhandledRejection', (err) => process.stderr.write(`cloud host: ${err?.stack || err}\n`));
+}

package/main/cloud/kit.mjs

@@ -0,0 +1,80 @@
+// THE COMPUTER'S SIDE OF A KIT (shared/cloud-kit.mjs): where its copy is kept
+// here, and the marker that makes a run the cloud server started from it this
+// thread's own, so the import path joins it or brings it home
+// (main/cloud/run.mjs `joining`, Supervisor#adoptCloudRun).
+import fs from 'node:fs';
+import path from 'node:path';
+import { PassThrough } from 'node:stream';
+import { cloudSessionId, APPROVALS_SERVER } from '../../shared/cloud-kit.mjs';
+import { serveApprovals } from '../approval-prompt-core.mjs';
+
+const safe = (s) => String(s).replace(/[^A-Za-z0-9_-]/g, '_');
+
+/** Where the last kit written for a thread is kept on this computer. */
+export const kitCopyPath = (userDir, product, item) => path.join(userDir, 'cloud-kits', `${safe(product)}--${safe(item)}.json`);
+/** Where the reply's place in the prompt waits for the kit writer, read once. */
+export const kitFramePath = (userDir, product, item) => path.join(userDir, 'cloud-kits', `${safe(product)}--${safe(item)}.frame.json`);
+
+export function readKitCopy(file) {
+  try {
+    const kit = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return kit && typeof kit === 'object' && kit.marker && typeof kit.cwd === 'string' ? kit : null;
+  } catch { return null; }
+}
+
+// None of its events have been read here (`cursor`). Left `detached`, as one
+// the app left going: the import path asks the sandbox which it is now, and
+// numbers this computer's input on from what the sandbox says it took
+// (`inSeq`), however many replies the server sent. Its input is closed when
+// joined (`unsent`), so the turn it is on ends and its work comes home; her
+// next reply is then an ordinary run here.
+export function markerForCloudRun(kit, runId) {
+  return {
+    ...kit.marker,
+    runId,
+    sessionId: cloudSessionId(kit.item, runId),
+    offline: true,
+    state: 'detached', pid: null, cursor: 0, conns: {},
+    unsent: [{ action: 'stdin', end: true }],
+  };
+}
+
+// PERMISSION REQUESTS WITH THE COMPUTER AWAY (cloud/sandbox/server.mjs
+// `offline.hold`). A run that asks permission names the app's approvals
+// server on its command line; one in a mode that never asks does not need it
+// held.
+export function asksPermission(argv) {
+  const args = (Array.isArray(argv) ? argv : []).map(String);
+  if (args.includes('--dangerously-skip-permissions')) return false;
+  const at = args.indexOf('--permission-prompt-tool');
+  if (at < 0 || !String(args[at + 1] ?? '').includes(`__${APPROVALS_SERVER}__`)) return false;
+  const mode = args.indexOf('--permission-mode');
+  return !(mode >= 0 && args[mode + 1] === 'bypassPermissions');
+}
+
+// The approvals server's own answers to a run opening it, read off the server
+// itself, so a run the computer never spoke to opens it in the cloud.
+export async function approvalsHandshakes({ timeoutMs = 5_000 } = {}) {
+  const input = new PassThrough();
+  const output = new PassThrough();
+  const server = serveApprovals({ env: {}, input, output, warn: () => {} });
+  const answers = new Map();
+  let buf = '';
+  const done = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('the approvals server did not answer its handshake')), timeoutMs);
+    output.on('data', (d) => {
+      buf += d;
+      let i;
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const msg = JSON.parse(buf.slice(0, i));
+        buf = buf.slice(i + 1);
+        answers.set(msg.id, msg.result);
+        if (answers.size === 2) { clearTimeout(timer); resolve(); }
+      }
+    });
+  });
+  input.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } })}\n`);
+  input.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list' })}\n`);
+  try { await done; } finally { server.close(); }
+  return { initialize: answers.get(1), 'tools/list': answers.get(2) };
+}