@volter/supercode-teams 0.3.151 → 0.3.152

package/mail/send.mjs

@@ -3,9 +3,7 @@
 // came through another machine's link to this machine's mail door. It resolves the receiver on the live-session map,
 // routes to another machine through Teams or to the receiver's door here, guards against loops and repeats, and words
 // the outcome for the sending agent, as crates/harness/src/mail_send.rs and mail_route.rs `deliver` did (their texts
-// kept word for word: an agent reads them). The mail it files is mailbox.rs's, through the store (store.mjs).
-import { appendFileSync, chmodSync, closeSync, fsyncSync, linkSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, writeSync } from 'node:fs';
-import { join } from 'node:path';
+// kept word for word: an agent reads them). Mail is filed through the daemon's SQLite store.
 import { blake3Hex, render, shortId } from './envelope.mjs';
 import { AGENT_HARNESS, RESUME_WAIT_MS } from './agents.mjs';
 import { MAX_RELAYED_BYTES, RELAY_NAME_PREFIX } from './relay.mjs';
@@ -44,7 +42,6 @@ const outcome = (code, text, receipt = null) => ({ code, text, receipt });
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** The daemon pane a live session runs in, or null (mail_route.rs `daemon_pane`). */
 const paneOf = (session) => { const pane = typeof session.pane === 'string' ? session.pane.split(':')[0] : null; return pane && /^p_[A-Za-z0-9_-]+$/.test(pane) ? pane : null; };
-const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
 
 /** A delivery a door refused before anything was sent. */
 class Refused extends Error { constructor(kind, bytes = 0) { super(kind); this.kind = kind; this.bytes = bytes; } }
@@ -61,6 +58,16 @@ export class MailSend {
     Object.assign(this, { machine, mailRoot, live, store, agents, relays, askMachine, deliverRuntime, codexAnswer, typeTurn, claudeProjects, log });
     this.handing = new Set(); // `<address>\n<id>` of each hand-over running here (handOver)
     this.relaying = new Set(); // `<address>\n<id>` of each relay send running here (route): its wake waits for it
+    for (const name of ['askMachine', 'deliverRuntime', 'codexAnswer', 'typeTurn']) {
+      const operation = this[name];
+      this[name] = (...args) => { this.#active(); return operation(...args); };
+    }
+  }
+
+  stop() { this.stopped = true; }
+
+  #active() {
+    if (this.stopped || this.store.database?.closed) throw Object.assign(new Error('the daemon is stopping; no mail delivery was submitted'), { code: 503, notAsked: true });
   }
 
   // ---- one send ----------------------------------------------------------------------------------------------------
@@ -71,6 +78,7 @@ export class MailSend {
    * came through (`{ principal, name }`), or null for this machine's own callers. Answers `{ code, text, receipt }`.
    */
   async send(caller, to, body, options = {}, context = {}) {
+    this.#active();
     if (context.link && this.#remoteMachine(to)) return outcome(EXIT_UNKNOWN, `${to} is not on this machine; a send through its mail door is for its own sessions.`);
     // Every stream earns its current route's grants before it can join the existing same-ID send in flight.
     let receiver = null;
@@ -81,6 +89,7 @@ export class MailSend {
       const refused = await this.#authorizeReceiver(context, receiver.continuation?.chain ?? [receiver.address]);
       if (refused) return refused;
     }
+    this.#active();
     // A send under an --id is held while it runs: the sent marker is written only once it is done, so a second send
     // under the same key meanwhile waits for the first and takes its outcome (sent once), never delivering it again; one
     // after a first that was not sent sends.
@@ -140,6 +149,7 @@ export class MailSend {
   async #authorizeReceiver(context, addresses) {
     if (!context.authorizeRecipients) return null;
     const reason = await context.authorizeRecipients(addresses);
+    this.#active();
     return reason ? outcome(EXIT_REFUSED, `Not sent: ${reason}. Nothing was filed or delivered by this request.`) : null;
   }
 
@@ -174,7 +184,7 @@ export class MailSend {
   #answeredId(callerAddress, answered) {
     if (typeof answered !== 'string' || answered.length >= FULL_ID_LEN) return { id: answered ?? null };
     const found = this.store.findPrefixIn(callerAddress, answered).map((item) => item.envelope.id);
-    for (const id of this.#sentIds(callerAddress)) if (id.startsWith(answered) && !found.includes(id)) found.push(id);
+    for (const id of this.store.sentIds(callerAddress, answered)) if (!found.includes(id)) found.push(id);
     if (found.length === 1) return { id: found[0] };
     if (!found.length) return { refused: outcome(EXIT_REFUSED, `Not sent: no message you received or sent has an id starting ${answered}. Name the message you answer as its envelope or your send showed it.`) };
     return { refused: outcome(EXIT_REFUSED, `Not sent: ${answered} names ${found.length} messages you received or sent (${found.join(', ')}). Give more of its id.`) };
@@ -275,9 +285,8 @@ export class MailSend {
     if (address === caller.address) return outcome(EXIT_REFUSED, 'Not sent: that address is your own session.');
     const door = parseAddress(address).harness === AGENT_HARNESS ? null : this.#door(address, sessions);
     const messageId = id == null && chosen ? chosen : messageIdFor(caller.address, id);
-    const marker = this.#sentMarker(caller.address, messageId);
     const terminal = door?.kind === 'hook' && door.pane != null;
-    let previous = null; try { previous = readFileSync(marker, 'utf8'); } catch { /* not sent before */ }
+    const previous = this.store.sentMarker(caller.address, messageId);
     if (previous !== null) {
       if (terminal && !queue) this.store.requestWake(address, messageId);
       return outcome(0, `Already sent with --id ${id ?? ''}: ${previous} Nothing was sent again.`, this.#deliveryReceipt(address, messageId, terminal));
@@ -339,7 +348,7 @@ export class MailSend {
     const text = code === 0
       ? `sent to ${name} (${harness}, ${door.kind}): ${what}. Message id ${shortId(messageId)}.${receiver.alias ?? ''}${idleNote} Don't poll; carry on.`
       : `${name} (${harness}): ${what}. Message id ${shortId(messageId)}.${idleNote}`;
-    if (code === 0 && id != null) { try { mkdirSync(join(marker, '..'), { recursive: true }); writeFileSync(marker, text); } catch { /* the marker is best kept */ } }
+    if (code === 0 && id != null) { try { this.store.setSentMarker(caller.address, messageId, text); } catch { /* the marker is best kept */ } }
     return outcome(code, text, code === 0 ? this.#deliveryReceipt(address, messageId, terminal) : null);
   }
 
@@ -358,6 +367,7 @@ export class MailSend {
    * refused before anything was sent, and an Error with what failed.
    */
   async route(sent, to, door, wake, notifyWhenIdle) {
+    this.#active();
     this.store.open(to);
     let finalReply = false;
     let delivered;
@@ -421,7 +431,7 @@ export class MailSend {
         if (filedHere && wake) { try { this.store.requestWake(to, handed.id); } catch { /* the wake filed above stands */ } }
         throw Object.assign(new Error(relayed.detail), { unanswered: true });
       }
-      if (!relayed.delivered && !received) { if (filedHere) { try { unlinkSync(filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
+      if (!relayed.delivered && !received) { if (filedHere) { try { this.store.remove(to, filed); } catch { /* gone */ } } throw new Error(relayed.detail); }
       // relayed: a copy filed unread before this delivery (an earlier unanswered or queued one, held for the receiver's
       // own read) is moved to cur/, so that read never hands it over a second time
       if (relayed.delivered && !received) {
@@ -565,6 +575,7 @@ export class MailSend {
       try { await this.agents.resume(to); } catch (error) { throw new Error(`not resumed: ${error.message}`); }
       const started = Date.now();
       for (;;) {
+        this.#active();
         door = this.#door(to, this.live.sessions());
         if (door) break;
         if (Date.now() - started > RESUME_WAIT_MS) return { how: 'not_running', text: 'resumed; the message waits in its mailbox' };
@@ -650,7 +661,7 @@ export class MailSend {
       if (typeof key !== 'string' || !key || Buffer.byteLength(key) > 256) return refused('invalid_key', 'idempotency_key needs 1–256 bytes');
       id = `m-${blake3Hex(JSON.stringify([sender, receiver, key]))}`.slice(0, 26);
       const previous = this.store.findIn(receiver, id);
-      const saved = previous ? readJson(previous.path) : null;
+      const saved = previous ? this.store.body(previous) : null;
       if (saved && (saved.body !== text || (saved.subject ?? null) !== subject || saved.kind !== (params.channel ? 'channel' : 'peer') || saved.from_name !== (params.sender_name ?? `${fromName}@${this.machine}`) || (saved.in_reply_to ?? null) !== (params.in_reply_to ?? null) || (saved.voice_for ?? null) !== (params.voice_for ?? null))) {
         return refused('idempotency_conflict', 'this key already names different mail');
       }
@@ -785,9 +796,11 @@ export class MailSend {
    * (mail_route.rs `type_user_turns`).
    */
   async typeUserTurns(address, pane) {
+    this.#active();
     const typed = [];
     const harness = parseAddress(address).harness;
     for (const waiting of this.store.userTurns(address)) {
+      this.#active();
       const claimed = this.store.claimUserTurn(address, waiting);
       if (!claimed) break;
       let result;
@@ -817,9 +830,10 @@ export class MailSend {
    * `{ outcome: 'delivered' | 'filed' | 'later', detail }`.
    */
   async handOver(address, id, { wake = false } = {}) {
+    this.#active();
     const found = this.store.findIn(address, id);
     if (!found) return { outcome: 'filed', detail: 'not in its mailbox' };
-    const sent = readJson(found.path);
+    const sent = this.store.body(found);
     if (!sent) return { outcome: 'later', detail: 'its envelope could not be read' };
     if (found.state !== 'unread') return { outcome: 'filed', detail: 'already read' };
     // one already handed to its receiver's door (that delivery's claim, the door's or the carrier's: a daemon that ended
@@ -868,8 +882,10 @@ export class MailSend {
       return error instanceof Refused ? { outcome: 'filed', detail: error.kind } : { outcome: 'later', detail: error.message };
     } finally {
       this.handing.delete(key);
-      const after = this.store.wakeState(address, id);
-      this.store.setWakeState(address, id, { ...after, handover_at_ms: null });
+      if (!this.stopped) {
+        const after = this.store.wakeState(address, id);
+        this.store.setWakeState(address, id, { ...after, handover_at_ms: null });
+      }
     }
   }
 
@@ -877,13 +893,13 @@ export class MailSend {
 
   /** Answer the native question `id` asked in `to` (mail_question.rs `reply`): only its recorded creator answers, once. */
   async #questionReply(caller, to, id, body, link) {
-    const dir = join(this.mailRoot, 'native-questions');
-    const path = (suffix) => join(dir, `${id}.${suffix}`);
-    const question = readJson(path('json'));
+    const key = (suffix) => `${id}.${suffix}`;
+    const question = this.store.record('native_questions', key('json'));
     if (!question) return outcome(EXIT_FAILED, `Not answered: question ${id} could not be read.`);
     if (question.binding?.session !== to || question.binding?.creator !== caller.address) return outcome(EXIT_REFUSED, 'Not answered: this question belongs to a different session or recipient.');
+    if (this.store.record('native_questions', key('claim'))) return outcome(EXIT_REFUSED, 'An answer is already recorded for this question. Nothing was submitted again; inspect its thread for delivery.');
     if (parseAddress(to).harness === 'claude-code') {
-      const waiting = readJson(path('waiting'));
+      const waiting = this.store.record('native_questions', key('waiting'));
       if (!waiting) return outcome(EXIT_REFUSED, 'Not answered: the native question hook is no longer waiting.');
       let alive = false; try { process.kill(waiting.pid, 0); alive = true; } catch (error) { alive = error.code === 'EPERM'; }
       if (!Number.isInteger(waiting.pid) || !alive) return outcome(EXIT_REFUSED, 'Not answered: the native question hook has ended.');
@@ -894,24 +910,25 @@ export class MailSend {
       envelope: makeEnvelope({ id: `u-${blake3Hex(`${id}\n${caller.address}`).slice(0, 24)}`, from: caller.address, from_name: caller.name, sender_identity: senderIdentity(caller.address, link, this.machine), kind: 'user', reply_via: { mode: 'none' }, in_reply_to: id, thread: id, body }),
       answers,
     };
-    try { createPrivate(dir, path('claim'), reply); }
-    catch (error) {
-      if (error.code === 'EEXIST') return outcome(EXIT_REFUSED, 'An answer is already recorded for this question. Nothing was submitted again; inspect its thread for delivery.');
-      throw error;
-    }
-    this.store.deliver(to, reply.envelope);
-    // published to the hook only once the whole reply is in mail
-    linkSync(path('claim'), path('reply'));
+    const claimed = this.store.transaction(() => {
+      if (!this.store.putRecord('native_questions', key('claim'), reply, { create: true })) return false;
+      this.store.deliver(to, reply.envelope);
+      this.store.putRecord('native_questions', key('reply'), reply, { create: true });
+      return true;
+    });
+    if (!claimed) return outcome(EXIT_REFUSED, 'An answer is already recorded for this question. Nothing was submitted again; inspect its thread for delivery.');
     if (parseAddress(to).harness === 'claude-code') return outcome(0, `Answer ${shortId(reply.envelope.id)} recorded in reply to ${id}; awaiting confirmation from the native question hook. It is not composer input.`);
-    const binding = readJson(join(dir, `binding-${blake3Hex(to)}.json`));
+    const binding = this.store.record('native_questions', `binding-${blake3Hex(to)}.json`);
     if (!binding?.socket_path) return outcome(EXIT_STORED, 'Answer recorded but NOT delivered: this launch has no native question endpoint. Nothing was typed.');
     let result;
     try { result = await this.codexAnswer({ socketPath: binding.socket_path, threadId: parseAddress(to).session, answer: { question: question.native, answers: reply.answers } }); }
     catch (error) { result = { delivered: false, reason: error.code ?? 'native-question-error' }; }
     if (result?.delivered === true) {
-      const filed = this.store.findIn(to, reply.envelope.id);
-      if (filed?.state === 'unread') this.store.markRead(to, filed.path);
-      try { createPrivate(dir, path('delivered'), Date.now()); } catch (error) { if (error.code !== 'EEXIST') throw error; }
+      this.store.transaction(() => {
+        const filed = this.store.findIn(to, reply.envelope.id);
+        if (filed?.state === 'unread') this.store.markRead(to, filed.path);
+        this.store.putRecord('native_questions', key('delivered'), Date.now(), { create: true });
+      });
       return outcome(0, `Answer ${shortId(reply.envelope.id)} delivered to native question ${id}.`);
     }
     return outcome(EXIT_STORED, `Answer recorded but NOT confirmed by the native question: ${JSON.stringify(result?.reason ?? null)}. It will not be typed or automatically resent.`);
@@ -919,29 +936,10 @@ export class MailSend {
 
   // ---- the send log and its guards ---------------------------------------------------------------------------------
 
-  #sentDir(sender) { return join(this.mailRoot, 'sent', blake3Hex(sender).slice(0, 24)); }
-  #sentMarker(sender, id) { return join(this.#sentDir(sender), id); }
-
-  #logOf(sender) {
-    let text = '';
-    try { text = readFileSync(join(this.#sentDir(sender), 'log.jsonl'), 'utf8'); } catch { return []; }
-    return text.split('\n').map((line) => { try { return JSON.parse(line); } catch { return null; } }).filter(Boolean);
-  }
-
-  #sentIds(sender) { return this.#logOf(sender).map((entry) => entry.id).filter((id) => typeof id === 'string'); }
-  #sentThread(sender, id) { return this.#logOf(sender).find((entry) => entry.id === id && typeof entry.thread === 'string')?.thread ?? null; }
+  #sentThread(sender, id) { return this.store.sentThread(sender, id); }
 
   /** The thread any author on this machine sent `id` in, as its send log keeps it. */
-  #sentThreadHere(id) {
-    let names = [];
-    try { names = readdirSync(join(this.mailRoot, 'sent')); } catch { return null; }
-    for (const name of names) {
-      let text = '';
-      try { text = readFileSync(join(this.mailRoot, 'sent', name, 'log.jsonl'), 'utf8'); } catch { continue; }
-      for (const line of text.split('\n')) { let entry = null; try { entry = JSON.parse(line); } catch { continue; } if (entry?.id === id && typeof entry.thread === 'string') return entry.thread; }
-    }
-    return null;
-  }
+  #sentThreadHere(id) { return this.store.sentThreadHere(id); }
 
   /** The thread `parent` is filed in on this machine (mailbox.rs `filed_thread`). */
   #filedThread(parent) {
@@ -959,19 +957,19 @@ export class MailSend {
     return parent;
   }
 
-  /** How deep the reply chain ending at `answered` runs between `a` and `b`, read from both mailboxes' folders. */
+  /** The bounded reply chain between `a` and `b`, from exact message keys. */
   #replyChainDepth(a, b, answered) {
-    const links = new Map([...this.store.links(a), ...this.store.links(b)]);
     let depth = 0, current = answered;
-    while (current != null && depth <= REPLY_CHAIN_LIMIT && links.has(current)) { depth += 1; current = links.get(current); }
+    while (current != null && depth <= REPLY_CHAIN_LIMIT) {
+      const parent = this.store.replyParent(a, b, current);
+      if (parent === undefined) break;
+      depth += 1; current = parent;
+    }
     return depth;
   }
 
   #recordSend(sender, to, id, thread, continuation = null) {
-    try {
-      mkdirSync(this.#sentDir(sender), { recursive: true });
-      appendFileSync(join(this.#sentDir(sender), 'log.jsonl'), `${JSON.stringify({ to, at_ms: Date.now(), id, thread, ...(continuation ? { continuation } : {}) })}\n`);
-    } catch { /* the log is best kept */ }
+    try { this.store.recordSend(sender, to, id, thread, continuation); } catch { /* the log is best kept */ }
   }
 
   /** A terminal's acknowledgement from the native watch's retained receipts, never from a filing (mail_send.rs
@@ -980,11 +978,8 @@ export class MailSend {
     if (!terminal) return { delivered: true, message_ids: [id], receipt: 'native-mail' };
     const parsed = parseAddress(address);
     const recipient = `${parsed.harness}:${parsed.session}`;
-    let names = [];
-    try { names = readdirSync(join(this.mailRoot, 'terminal-delivery')); } catch { /* none yet */ }
-    for (const name of names) {
-      const state = readJson(join(this.mailRoot, 'terminal-delivery', name, 'queue.json'));
-      if (state?.recipient !== recipient) continue;
+    const state = this.store.terminalState(recipient);
+    if (state) {
       const receipt = (Array.isArray(state.receipts) ? state.receipts : []).find((item) => Array.isArray(item?.message_ids) && item.message_ids.includes(id));
       if (receipt) return receipt;
       return { delivered: false, queued: true, message_ids: [id], reason: state.active?.error ?? null };
@@ -1003,7 +998,7 @@ export class MailSend {
 
   /** rememberedName for each of `addresses`, the ledger read once. */
   rememberedNames(addresses) {
-    const names = readJson(join(this.mailRoot, 'names.json'));
+    const names = Object.fromEntries(this.store.records('names').map(({ key, value }) => [key, value]));
     const wanted = new Set(addresses), best = new Map();
     if (names && typeof names === 'object') {
       for (const [name, record] of Object.entries(names)) {
@@ -1016,7 +1011,7 @@ export class MailSend {
   }
 
   #rememberedAddress(name) {
-    const record = readJson(join(this.mailRoot, 'names.json'))?.[name];
+    const record = this.store.record('names', name);
     if (!record || Date.now() - Math.max(record.seen_ms ?? 0, record.since_ms ?? 0) > NAME_KEPT_MS) return null;
     return parseAddress(record.address)?.address ?? null;
   }
@@ -1024,10 +1019,7 @@ export class MailSend {
   /** Each running session's name recorded (mail_route.rs `remember_names`): a name two sessions carry is left as it was;
    *  written only when a name is new, names another session, or its last listing is an hour old. */
   rememberNames(sessions) {
-    const path = join(this.mailRoot, 'names.json');
-    let names;
-    try { names = JSON.parse(readFileSync(path, 'utf8')); } catch (error) { if (error.code !== 'ENOENT') return; names = {}; }
-    if (!names || typeof names !== 'object') return;
+    const names = Object.fromEntries(this.store.records('names').map(({ key, value }) => [key, value]));
     const carried = new Map();
     for (const row of sessions) {
       const name = row.name.split('@')[0];
@@ -1035,7 +1027,7 @@ export class MailSend {
     }
     const now = Date.now();
     const latest = (address) => Object.entries(names).filter(([, record]) => record.address === address).sort((x, y) => y[1].since_ms - x[1].since_ms)[0]?.[0] ?? null;
-    let changed = false;
+    const changed = [];
     for (const [name, addresses] of carried) {
       if (addresses.length !== 1) continue;
       const [address] = addresses;
@@ -1044,11 +1036,11 @@ export class MailSend {
       if (current && latest(address) === name) continue;
       const renewed = record?.address === address && latest(address) === name;
       names[name] = { address, since_ms: renewed ? record.since_ms : now, seen_ms: now };
-      changed = true;
+      changed.push(name);
     }
-    if (!changed) return;
-    const staged = `${path}.${process.pid}.tmp`;
-    try { writeFileSync(staged, JSON.stringify(names)); renameSync(staged, path); } catch { /* kept for the next listing */ }
+    if (!changed.length) return;
+    try { this.store.transaction(() => { for (const name of changed) this.store.putRecord('names', name, names[name]); }); }
+    catch { /* kept for the next listing */ }
   }
 }
 
@@ -1070,11 +1062,3 @@ function questionAnswers(question, body) {
   if (!values || typeof values !== 'object' || Object.keys(values).length !== Object.keys(out).length) throw new Error('answer only the question ids shown');
   return out;
 }
-
-/** A file made once, owner-only, written whole and synced (mail_question.rs `create`). */
-function createPrivate(dir, path, value) {
-  mkdirSync(dir, { recursive: true });
-  try { chmodSync(dir, 0o700); } catch { /* not ours to set */ }
-  const fd = openSync(path, 'wx', 0o600);
-  try { writeSync(fd, JSON.stringify(value)); fsyncSync(fd); } finally { closeSync(fd); }
-}