agentbox-app 0.1.13 → 0.1.16

package/main/team/memory-cloud.mjs

@@ -10,6 +10,12 @@ import { EventEmitter } from 'node:events';
 import crypto from 'node:crypto';
 import { asPulled } from '../../shared/team-rules.mjs';
 import { cleanStatus } from '../../shared/team-status.mjs';
+import { PHONE_COMMANDS } from '../../shared/phone-snapshot.mjs';
+import { roomsMemory } from './rooms-memory.mjs';
+
+// The database's own checks on a message's file (20261013000000_message_files.sql).
+const FILE_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,159}$/;
+const MAX_FILE_DATA = 14_000_000;
 
 export function createMemoryCloud() {
   return {
@@ -21,6 +27,7 @@ export function createMemoryCloud() {
     projectPeople: [], // { projectId, personId }
     lines: [], // { seq, projectId, uid, byPerson, body, createdAt }
     cards: new Map(), // `${personId}:${threadId}` -> a thread card, as shared/thread-cards.mjs makes them
+    files: new Map(), // `${projectId}:${name}` -> { projectId, name, byPerson, data (base64) }
     seq: 0,
     teamsMade: 0, // the order teams were made in, which is their age
     now: () => Date.now(), // the server's clock
@@ -36,6 +43,18 @@ export function signUpMemory(cloud, { id = crypto.randomUUID(), email, name, ava
   return id;
 }
 
+// WHAT THE CLOUD SERVER DOES WITH THE SERVICE ROLE (cloud/gateway/phone.mjs):
+// claims a command nobody has for the run it starts, as the database lets one
+// claim win. Here so a test can be the server.
+export function claimForTheCloud(cloud, id, runId) {
+  const c = (cloud.phoneCommands ?? []).find((x) => x.id === id);
+  if (!c || c.takenAt || c.claimedAt) return false;
+  c.claimedAt = new Date(cloud.now()).toISOString();
+  c.claimedBy = `cloud:${runId}`;
+  cloud.events.emit('phone', 1);
+  return true;
+}
+
 export function memoryBackend(cloud, personId) {
   const myTeams = () => cloud.members.filter((m) => m.personId === personId).map((m) => m.teamId)
     .sort((a, b) => (cloud.teams.get(a)?.made ?? 0) - (cloud.teams.get(b)?.made ?? 0));
@@ -96,6 +115,7 @@ export function memoryBackend(cloud, personId) {
       if (at < 0) refuse('join a team that did not invite you');
       cloud.invites.splice(at, 1);
       if (!cloud.members.some((m) => m.teamId === teamId && m.personId === personId)) cloud.members.push({ teamId, personId, role: 'member' });
+      cloud.events.emit('rooms', { kind: 'membership' });
       return teamId;
     },
 
@@ -145,6 +165,7 @@ export function memoryBackend(cloud, personId) {
     async removeMember(teamId, who) {
       if (who !== personId && !owns(teamId)) refuse('remove somebody from a team you do not own');
       cloud.members = cloud.members.filter((m) => !(m.teamId === teamId && m.personId === who));
+      cloud.events.emit('rooms', { kind: 'membership' });
     },
 
     async listInvites(teamId) {
@@ -236,12 +257,173 @@ export function memoryBackend(cloud, personId) {
         .map(({ teamId, ...c }) => structuredClone(c));
     },
 
+    // THE FILES A CONVERSATION'S MESSAGES LINK TO (w-140ac855b1). Read and
+    // written by whoever may see the project, each name stored once and never
+    // replaced: 20261013000000_message_files.sql.
+    async hasFiles(projectId, names) {
+      if (!canSee(projectId)) return [];
+      return names.filter((n) => cloud.files.has(`${projectId}:${n}`));
+    },
+
+    async getFile(projectId, name) {
+      if (!canSee(projectId)) return null;
+      return cloud.files.get(`${projectId}:${name}`)?.data ?? null;
+    },
+
+    async putFile(projectId, name, data) {
+      if (!canSee(projectId)) refuse('send a file to a project you cannot see');
+      if (!FILE_NAME.test(name)) refuse('a file name that is not a plain name');
+      if (data.length > MAX_FILE_DATA) refuse('a file that big');
+      const key = `${projectId}:${name}`;
+      if (cloud.files.has(key)) return false;
+      cloud.files.set(key, { projectId, name, byPerson: personId, data });
+      cloud.events.emit('files', 1);
+      return true;
+    },
+
+    // HER OWN ROWS FOR HER PHONE (20261014000200_phone_inbox.sql): every one
+    // keyed by its owner and the computer it came from, and only ever that
+    // owner's. A command is written once and marked taken once.
+    // Each write may name who it is for; a write for somebody other than
+    // whoever this backend is signed in as is refused, as the database's
+    // `owner = auth.uid()` refuses it.
+    async putPhoneProject({ owner, device, project, name, cloud: carriesOn }) {
+      if (owner && owner !== personId) refuse('write to somebody else\'s phone');
+      const k = `${personId}:${device}:${project}`;
+      const was = cloud.phoneProjects?.get(k);
+      (cloud.phoneProjects ??= new Map()).set(k, { owner: personId, device, project, name, cloud: carriesOn === undefined ? was?.cloud ?? false : !!carriesOn, updatedAt: cloud.now() });
+    },
+    async dropPhoneProject(device, project, owner) {
+      if (owner && owner !== personId) return;
+      cloud.phoneProjects?.delete(`${personId}:${device}:${project}`);
+      for (const k of [...(cloud.phoneThreads?.keys() ?? [])]) if (k.startsWith(`${personId}:${device}:${project}:`)) cloud.phoneThreads.delete(k);
+    },
+    async putPhoneThreads(device, project, rows, owner) {
+      if (owner && owner !== personId) refuse('write to somebody else\'s phone');
+      cloud.phoneThreads ??= new Map();
+      if (!cloud.phoneProjects?.has(`${personId}:${device}:${project}`)) refuse('a thread of a project not on the phone');
+      for (const r of rows) {
+        if (new TextEncoder().encode(JSON.stringify(r.snapshot)).length > 1_000_000) refuse('a thread copy that big');
+      }
+      for (const r of rows) {
+        cloud.phoneThreads.set(`${personId}:${device}:${project}:${r.item}`, { owner: personId, device, project, item: r.item, snapshot: r.snapshot, updatedAt: cloud.now() });
+      }
+      cloud.events.emit('phone', 1);
+    },
+    // Her files for the phone (20261017000000_phone_files.sql): kept under her
+    // own id, never replaced, at most the bucket's size.
+    async putPhoneFile({ owner, device, name, data, type }) {
+      if (owner && owner !== personId) refuse('write to somebody else\'s phone');
+      if (!/^[0-9a-f]{64}\.[a-z0-9]{1,8}$/.test(name)) refuse('a file named that');
+      if (data.length > 26_214_400) refuse('a file that big');
+      const key = `${personId}/${device}/${name}`;
+      if (!(cloud.phoneFiles ??= new Map()).has(key)) cloud.phoneFiles.set(key, { data: Buffer.from(data), type });
+    },
+    async getPhoneFile({ owner, device, name }) {
+      if (owner && owner !== personId) refuse('read somebody else\'s phone');
+      const f = cloud.phoneFiles?.get(`${personId}/${device}/${name}`);
+      return f ? Buffer.from(f.data) : null;
+    },
+    async dropPhoneFiles({ owner, device, names }) {
+      if (owner && owner !== personId) return;
+      for (const n of names) cloud.phoneFiles?.delete(`${personId}/${device}/${n}`);
+    },
+    async dropPhoneThreads(device, project, items, owner) {
+      if (owner && owner !== personId) return;
+      for (const item of items) cloud.phoneThreads?.delete(`${personId}:${device}:${project}:${item}`);
+    },
+    async phoneThreads() {
+      return [...(cloud.phoneThreads?.values() ?? [])].filter((t) => t.owner === personId);
+    },
+    async phoneProjects() {
+      return [...(cloud.phoneProjects?.values() ?? [])].filter((p) => p.owner === personId);
+    },
+    // One row per computer (20261023000000_phone_settings.sql).
+    async putPhoneSettings({ owner, device, name, settings }) {
+      if (owner && owner !== personId) refuse('write to somebody else\'s phone');
+      if (!/^[0-9a-f]{12}$/.test(String(device))) refuse('settings for no computer');
+      if (new TextEncoder().encode(JSON.stringify(settings)).length > 200_000) refuse('settings that big');
+      (cloud.phoneSettings ??= new Map()).set(`${personId}:${device}`, { owner: personId, device, name, settings, updatedAt: cloud.now() });
+    },
+    async phoneSettings() {
+      return [...(cloud.phoneSettings?.values() ?? [])].filter((s) => s.owner === personId).map((s) => ({ ...s }));
+    },
+    // The phones her alerts go to (20261025000000_push_devices.sql), hers alone.
+    async putPushDevice({ token, platform, appVersion = null }) {
+      if (!/^ExponentPushToken\[[A-Za-z0-9_-]{10,200}\]$/.test(String(token))) refuse('a phone address that is not Expo\'s');
+      if (!['ios', 'android'].includes(platform)) refuse(`a ${platform} phone`);
+      (cloud.pushDevices ??= new Map()).set(`${personId}:${token}`, { owner: personId, token, platform, appVersion, updatedAt: cloud.now() });
+    },
+    async pushDevices(owner) {
+      if (owner && owner !== personId) return [];
+      return [...(cloud.pushDevices?.values() ?? [])].filter((d) => d.owner === personId).map((d) => ({ ...d }));
+    },
+    async dropPushDevice(token, owner) {
+      if (owner && owner !== personId) return;
+      cloud.pushDevices?.delete(`${personId}:${token}`);
+    },
+    // What her phone does: a command, as herself, for one computer, not yet taken.
+    async addPhoneCommand({ device, project = null, item = null, kind, payload = {} }) {
+      if (!/^[0-9a-f]{12}$/.test(String(device))) refuse('a command for no computer');
+      if (!PHONE_COMMANDS.includes(kind)) refuse(`a ${kind} command`);
+      if ((kind === 'setting') !== (project == null) || (kind === 'setting' && item != null)) refuse(`a ${kind} command for ${project == null ? 'no project' : 'a project'}`);
+      const row = { id: crypto.randomUUID(), owner: personId, device, project, item, kind, payload, createdAt: new Date(cloud.now()).toISOString(), claimedAt: null, claimedBy: null, takenAt: null, outcome: null };
+      (cloud.phoneCommands ??= []).push(row);
+      cloud.events.emit('phone', 1);
+      return { ...row };
+    },
+    async waitingPhoneCommands(device) {
+      return (cloud.phoneCommands ?? []).filter((c) => c.owner === personId && c.device === device && !c.takenAt).map((c) => ({ ...c }));
+    },
+    async phoneCommands() {
+      return (cloud.phoneCommands ?? []).filter((c) => c.owner === personId).map((c) => ({ ...c }));
+    },
+    async cloudPhoneCommands(device, since) {
+      return (cloud.phoneCommands ?? []).filter((c) => c.owner === personId && c.device === device && c.claimedBy && c.createdAt >= since).map((c) => ({ ...c }));
+    },
+    // THE COMPUTER CLAIMS ONE BEFORE IT DOES IT; the phone takes one back only
+    // while nobody has. Exactly one of the two wins, as in the database.
+    // 'claimed' is a claim made now, 'ours' one made before (this computer,
+    // starting again), 'gone' a command taken back or already done.
+    async claimPhoneCommand(id, owner) {
+      if (owner && owner !== personId) return 'gone';
+      const c = (cloud.phoneCommands ?? []).find((x) => x.id === id && x.owner === personId);
+      if (!c || c.takenAt) return 'gone';
+      if (c.claimedBy) return 'cloud';
+      if (c.claimedAt) return 'ours';
+      c.claimedAt = new Date(cloud.now()).toISOString();
+      return 'claimed';
+    },
+    async takeBackPhoneCommand(id, outcome) {
+      const c = (cloud.phoneCommands ?? []).find((x) => x.id === id && x.owner === personId);
+      if (!c || c.takenAt || c.claimedAt) return false;
+      c.takenAt = new Date(cloud.now()).toISOString();
+      c.outcome = outcome;
+      cloud.events.emit('phone', 1);
+      return true;
+    },
+    async markPhoneCommand(id, outcome, owner) {
+      if (owner && owner !== personId) return;
+      // Somebody else's command is not there for you, as row level security
+      // has it: the mark changes nothing rather than failing. Your own is
+      // marked once; a second mark finds nothing waiting and changes nothing,
+      // as the real backend's `taken_at is null` filter has it.
+      const c = (cloud.phoneCommands ?? []).find((x) => x.id === id && x.owner === personId);
+      if (!c || c.takenAt) return;
+      c.takenAt = new Date(cloud.now()).toISOString();
+      c.outcome = outcome;
+      cloud.events.emit('phone', 1);
+    },
+
     subscribe(onChange) {
       const fire = () => onChange();
       cloud.events.on('lines', fire);
       cloud.events.on('cards', fire);
       cloud.events.on('people', fire);
-      return () => { cloud.events.off('lines', fire); cloud.events.off('cards', fire); cloud.events.off('people', fire); };
+      cloud.events.on('phone', fire);
+      return () => { cloud.events.off('lines', fire); cloud.events.off('cards', fire); cloud.events.off('people', fire); cloud.events.off('phone', fire); };
     },
+
+    ...roomsMemory(cloud, personId, { confirmedEmail, refuse }),
   };
 }

package/main/team/room-hours.mjs

@@ -0,0 +1,48 @@
+// MY AGENT HOURS FOR MY PRESENCE ROW (w-3d0fa23ffb). The run ledger is
+// tens of thousands of lines on a busy Mac, and the presence row is checked
+// every few seconds, so the summary is worked out again only when the ledger
+// has changed or the day may have turned. The old run logs are read into the
+// ledger once, the first time Rooms asks.
+import fs from 'node:fs';
+import path from 'node:path';
+import { allRuns, backfillRuns, runLedgerPath } from '../run-ledger.mjs';
+import { summarizeRuns } from '../../shared/agent-hours.mjs';
+
+const RECHECK_MS = 10 * 60_000;
+
+export function createRoomHours({ home, products = () => [], cloudLines = () => [], now = Date.now, log = () => {} }) {
+  const file = runLedgerPath(home);
+  const marker = path.join(home, 'runs.backfilled');
+  let cached = null;
+  let seen = null;
+  let at = 0;
+  let backfilling = null;
+
+  function backfillOnce() {
+    if (backfilling || fs.existsSync(marker)) return backfilling;
+    backfilling = backfillRuns({ home, products: products(), file, now: now() })
+      .then((n) => {
+        try { fs.writeFileSync(marker, `${new Date(now()).toISOString()} ${n}\n`); } catch { /* read again next start */ }
+        log(`rooms: read ${n} past runs into the run ledger`);
+        cached = null;
+      })
+      .catch((err) => log(`rooms: reading past runs: ${err.message}`));
+    return backfilling;
+  }
+
+  return {
+    backfillOnce,
+    summary() {
+      backfillOnce();
+      let stamp = '';
+      try { const s = fs.statSync(file); stamp = `${s.size}:${s.mtimeMs}`; } catch { stamp = 'none'; }
+      if (cached && stamp === seen && now() - at < RECHECK_MS) return cached;
+      let cloud = [];
+      try { cloud = cloudLines() ?? []; } catch { cloud = []; }
+      cached = summarizeRuns(allRuns({ file, cloudLines: cloud }), { now: now() });
+      seen = stamp;
+      at = now();
+      return cached;
+    },
+  };
+}

package/main/team/room-setup.mjs

@@ -0,0 +1,31 @@
+// What the team service needs to run Rooms on this Mac, built once for the
+// desktop (main/main.mjs) and the browser copy (main/serve.mjs) alike.
+import path from 'node:path';
+import { appHome } from '../store/home.mjs';
+import { readEnv } from '../../shared/product-name.mjs';
+import { readCloudUsage } from '../cloud/usage.mjs';
+import { phoneDevice } from '../phone-inbox.mjs';
+import { roomPrefsFile } from './rooms.mjs';
+import { createRoomHours } from './room-hours.mjs';
+
+export function roomsSetup({ config, store, supervisor, userDir, log = (line) => console.log(line) }) {
+  const hours = createRoomHours({
+    home: appHome(),
+    products: () => { try { return store.listProducts({ includeArchived: true }); } catch { return []; } },
+    // A copy with a home of its own reads its own cloud runs, not this Mac's.
+    cloudLines: () => (readEnv('HOME') ? readCloudUsage({ file: path.join(appHome(), 'cloud-usage.jsonl') }) : readCloudUsage()),
+    log,
+  });
+  return {
+    enabled: () => config.alphaRooms === true,
+    device: () => phoneDevice(userDir, config.storeRoot),
+    prefsFile: roomPrefsFile(config.storeRoot),
+    presenceFacts: () => {
+      const running = supervisor.runsGoing().map((s) => ({ itemId: s.itemId, product: s.product, startedAt: s.startedAt }));
+      const items = running.map((r) => { try { return store.readItem(r.product, r.itemId); } catch { return null; } }).filter(Boolean);
+      let products = [];
+      try { products = store.listProducts(); } catch { /* none to name */ }
+      return { running, items, products, summary: hours.summary() };
+    },
+  };
+}