@volter/supercode-teams 0.3.113 → 0.3.114

package/bin/workspace.mjs

@@ -1010,13 +1010,19 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     const sync = saved ? { ...(readSyncStatus(state.directory) ?? { not_syncing: [], last_error: null, queued_captures: 0 }), agent_identity: agentIdentityStatus(teamsHome()) } : null;
     // The mail this machine's mailbox still has to deliver: after a failed attempt, or for a machine that is offline.
     let mailWaiting = [];
-    try { mailWaiting = JSON.parse(execFileSync(process.env.SUPERCODE_TEAMS_TEST_BIN ?? process.env.SUPERCODE_BIN ?? 'supercode', ['message', 'waiting', '--json'], { encoding: 'utf8', timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] })); } catch { /* an older supercode has no such door */ }
-    const value = { version: 1, context: scope(context), data: { mail_waiting: mailWaiting, reachable, account, connector: saved ? { enrolled: true, running: running || busy, ...(busy ? { busy: true } : {}), machine: saved.machine, source: saved.source, sync } : { enrolled: false, running: false }, sources: reachable && !context.machine_only ? (await team.sources.list()).items : [] } };
+    // asked of the daemon, which keeps these records (mail step 1); a daemon that does not answer is said, never read as none
+    let mailWaitingError = null;
+    try {
+      const channel = await openLocalMachine(paths(teamsHome()).socket);
+      try { const rpc = await nodeRpc(channel); mailWaiting = (await rpc.call('harness.v1.mail.waiting', {}, { timeoutMs: 15000 }))?.rows ?? []; }
+      finally { channel.close?.(); }
+    } catch (error) { mailWaitingError = error.message; }
+    const value = { version: 1, context: scope(context), data: { mail_waiting: mailWaiting, ...(mailWaitingError ? { mail_waiting_error: mailWaitingError } : {}), reachable, account, connector: saved ? { enrolled: true, running: running || busy, ...(busy ? { busy: true } : {}), machine: saved.machine, source: saved.source, sync } : { enrolled: false, running: false }, sources: reachable && !context.machine_only ? (await team.sources.list()).items : [] } };
     if (flags.json) return output(value);
     const lines = [`Team       ${context.team_name ?? context.team_id} · ${new URL(context.origin).host}${reachable ? '' : ' · unreachable'}`];
     lines.push(saved?.machine ? `Connector  ${saved.machine.name ?? saved.machine.id} · ${running ? 'running' : busy ? 'running (busy: its control socket did not answer within 1 s)' : 'not running'}${saved.service?.kind ? ` (${saved.service.kind})` : ''}` : 'Connector  not connected (supercode teams connect)');
     lines.push(...syncStatusLines(sync));
-    lines.push(...mailWaitingLines(mailWaiting));
+    lines.push(...(mailWaitingError ? [`Mail       waiting mail unknown: this machine's daemon did not answer (${mailWaitingError})`] : mailWaitingLines(mailWaiting)));
     process.stdout.write(`${lines.join('\n')}\n`);
     return;
   }

package/machine.mjs

@@ -42,10 +42,12 @@ import { Agents } from './mail/agents.mjs';
 import { Relays } from './mail/relay.mjs';
 import { serveRelayEndpoint } from './mail/relay-endpoint.mjs';
 import { MailCarrier } from './mail/carrier.mjs';
+
+const NO_CALLER = "Can't tell which session is running this command, so replies would have nowhere to go. Nothing was sent. Run it from your agent session's own shell tool.";
 import { MailSend } from './mail/send.mjs';
 import { AgentVerbs } from './mail/verbs.mjs';
 import { deliverToRuntime } from './mail/runtime.mjs';
-import { envelope as envelopeOf, linkOf, parseAddress, senderIdentity } from './mail/compose.mjs';
+import { envelope as envelopeOf, linkOf, makeAddress, parseAddress, senderIdentity } from './mail/compose.mjs';
 import { codexQuestions } from './native-questions.mjs';
 import { Duplex, PassThrough } from 'node:stream';
 
@@ -1927,6 +1929,30 @@ export class TeamsMachine extends MachineCore {
    * a claim is the same user's word, held to what the map holds. A request the Teams connector forwards from another
    * machine keeps the caller it carries. A local claim the map does not hold is refused.
    */
+  /** The caller's unread mail claimed under its reader's process (a reader that ends gives it back), with the token its
+   *  reader acknowledges once it has shown it: `message inbox`, `read_messages` and `message wait`. */
+  async #claimInbox(caller, { all, last, pid, via }) {
+    const read = await this.mail.inbox(caller, { all, last, pid, via });
+    let token = null;
+    if (read.claimed.length) {
+      token = randomBytes(12).toString('hex');
+      this.inboxClaims ??= new Map();
+      // a reader that never acknowledges leaves its claims under its own pid (given back when it ends): its token
+      // is let go after a while, never held for good
+      for (const [old] of [...this.inboxClaims].slice(0, Math.max(0, this.inboxClaims.size - 255))) this.inboxClaims.delete(old);
+      this.inboxClaims.set(token, { address: caller, claimed: read.claimed });
+    }
+    // `plain`: each message as its reader is shown it (the envelope rendered), with no listing's line about when
+    const plain = read.stored.map((item) => render(item.envelope));
+    const claimedIds = new Set(read.claimed.map((item) => item.envelope.id));
+    const kept = inboxKept(read.stored.length,
+      (index) => Buffer.byteLength(read.rendered[index] ?? '') + Buffer.byteLength(plain[index] ?? '') + Buffer.byteLength(JSON.stringify(read.rows[index] ?? null)),
+      (index) => claimedIds.has(read.stored[index].envelope.id));
+    const left = read.stored.length - kept.length;
+    const note = left ? [inboxNote(left)] : [];
+    return { code: 0, address: caller, rendered: [...note, ...kept.map((index) => read.rendered[index])], plain: [...note, ...kept.map((index) => plain[index])], rows: kept.map((index) => read.rows[index]), omitted: left, token };
+  }
+
   #callerOf(entry, params) {
     const named = typeof params.caller === 'string' && params.caller ? params.caller : null;
     if (entry.principal !== 'local') return Promise.resolve(named);
@@ -3673,28 +3699,65 @@ export class TeamsMachine extends MachineCore {
         // the caller's own inbox: its unread mail claimed under its own process (a reader that ends gives it back), then
         // acknowledged once it has printed it (harness.v1.mail.acknowledge)
         const caller = await this.#callerOf(entry, params);
-        if (typeof caller !== 'string' || /^sc:[^:]+:board:/.test(caller)) return { code: 2, text: "Can't tell which session is running this command, so replies would have nowhere to go. Nothing was sent. Run it from your agent session's own shell tool." };
+        if (typeof caller !== 'string' || /^sc:[^:]+:board:/.test(caller)) return { code: 2, text: NO_CALLER };
         // `via`: the door the claims record (`inbox`, or `read_messages` for `message mcp`'s tool)
-        const via = params.via === 'read_messages' ? 'read_messages' : 'inbox';
-        const read = await this.mail.inbox(caller, { all: params.all === true, last, pid: Number(params.claim?.pid) || process.pid, via });
-        let token = null;
-        if (read.claimed.length) {
-          token = randomBytes(12).toString('hex');
-          this.inboxClaims ??= new Map();
-          // a reader that never acknowledges leaves its claims under its own pid (given back when it ends): its token
-          // is let go after a while, never held for good
-          for (const [old] of [...this.inboxClaims].slice(0, Math.max(0, this.inboxClaims.size - 255))) this.inboxClaims.delete(old);
-          this.inboxClaims.set(token, { address: caller, claimed: read.claimed });
+        return this.#claimInbox(caller, { all: params.all === true, last, pid: Number(params.claim?.pid) || process.pid, via: params.via === 'read_messages' ? 'read_messages' : 'inbox' });
+      }
+      // `message wait` (step 1): the caller's next unread mail (from one sender, with `from`), waited for on the store's
+      // own change events, at most 100 s, then claimed as its inbox claims it; nothing polls
+      case 'harness.v1.mail.wait': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is read here by this machine\'s own processes'), { code: 403 });
+        const caller = await this.#callerOf(entry, params);
+        if (typeof caller !== 'string' || /^sc:[^:]+:board:/.test(caller)) return { code: 2, text: NO_CALLER };
+        let wanted = null;
+        if (typeof params.from === 'string' && params.from) { const found = this.mail.resolve(params.from); wanted = found.error ? params.from : found.address; }
+        const seconds = Math.min(100, Math.max(0, Number.isFinite(Number(params.timeout)) ? Math.floor(Number(params.timeout)) : 100));
+        // exactly what its claim would take (store.claimUnread): never a live reader's claimed copy or a user's own turn
+        // waiting for its pane, so a wait never wakes for mail it then cannot claim; an abandoned claim is given back first
+        const waiting = () => this.mailStore.hasClaimable(caller, wanted ? (envelope) => envelope.from === wanted || String(envelope.from_name ?? '').startsWith(wanted) : null);
+        if (!waiting()) {
+          const arrived = await new Promise((resolve) => {
+            const changed = (address) => { if (address === caller && waiting()) done(true); };
+            const done = (value) => { clearTimeout(timer); this.mailStore.off('changed', changed); resolve(value); };
+            const timer = setTimeout(() => done(false), seconds * 1000);
+            this.mailStore.on('changed', changed);
+          });
+          if (!arrived) return { code: 6, timeout: true, text: `No mail within ${seconds} seconds; nothing is lost.` };
+        }
+        // everything unread is handed over, not only the awaited sender's: a message not shown now would stay silent
+        return this.#claimInbox(caller, { all: false, last: null, pid: Number(params.claim?.pid) || process.pid, via: 'wait' });
+      }
+      // harness serve's `sessions.inbox` (step 1), asked here by serve: an operator's own mailbox (`from_name`) has its
+      // unread mail claimed and acknowledged, so a second read does not return it; any other address (`address`) is only
+      // looked at, never consumed
+      case 'harness.v1.mail.operator_inbox': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('sessions.inbox is answered here for this machine\'s own harness serve'), { code: 403 });
+        if (params.address != null && params.from_name != null) throw Object.assign(new Error('sessions.inbox takes from_name or address, not both'), { code: 400 });
+        let address;
+        if (typeof params.address === 'string') {
+          if (!parseAddress(params.address)) throw Object.assign(new Error(`not an address: ${params.address}`), { code: 400 });
+          address = params.address;
+        } else {
+          const name = Array.from(String(params.from_name ?? 'supercode').trim(), (c) => /\s|@/.test(c) ? '-' : c).join('');
+          if (!name) throw Object.assign(new Error('from_name must not be empty'), { code: 400 });
+          address = makeAddress(machineName(this.env), 'operator', name);
+          if (!address) throw Object.assign(new Error(`from_name is not a mailbox name: ${name}`), { code: 400 });
         }
-        // `plain`: each message as its reader is shown it (the envelope rendered), with no listing's line about when
-        const plain = read.stored.map((item) => render(item.envelope));
-        const claimedIds = new Set(read.claimed.map((item) => item.envelope.id));
-        const kept = inboxKept(read.stored.length,
-          (index) => Buffer.byteLength(read.rendered[index] ?? '') + Buffer.byteLength(plain[index] ?? '') + Buffer.byteLength(JSON.stringify(read.rows[index] ?? null)),
-          (index) => claimedIds.has(read.stored[index].envelope.id));
-        const left = read.stored.length - kept.length;
-        const note = left ? [inboxNote(left)] : [];
-        return { code: 0, address: caller, rendered: [...note, ...kept.map((index) => read.rendered[index])], plain: [...note, ...kept.map((index) => plain[index])], rows: kept.map((index) => read.rows[index]), omitted: left, token };
+        const all = params.all === true;
+        const shown = (item, state) => { const envelope = this.mailStore.body(item) ?? item.envelope; return { state, envelope, rendered: render(envelope) }; };
+        if (typeof params.address === 'string') {
+          const { stored } = this.mailStore.inventory(address);
+          return { address, messages: stored.filter((item) => all || item.state === 'unread').map((item) => shown(item, item.state)), looked: true };
+        }
+        const read = await this.mail.inbox(address, { all, last: null, pid: process.pid, via: 'sessions.inbox' });
+        const messages = [...(all ? read.stored.filter((item) => item.state === 'read').map((item) => shown(item, 'read')) : []), ...read.claimed.map((item) => shown(item, 'unread'))];
+        this.mail.acknowledge(address, read.claimed);
+        return { address, messages };
+      }
+      // `message waiting` and `message expired` (step 1): the carrier's own records
+      case 'harness.v1.mail.waiting': case 'harness.v1.mail.expired': {
+        if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('mail is read here by this machine\'s own processes'), { code: 403 });
+        return { code: 0, rows: method === 'harness.v1.mail.waiting' ? this.carrier.waiting() : this.carrier.expired() };
       }
       // Who a local client is, from its claim (live-sessions.mjs callerOf): what a command acting on another machine sends
       // there as its caller, resolved here, where the map that holds it is. Local only; never the app door's.

package/mail/carrier.mjs

@@ -262,6 +262,49 @@ export class MailCarrier {
     catch (error) { this.log(`carrier: ${machine}'s wait was not kept: ${error.message}`); }
   }
 
+  // ---- what waits, and what expired (`message waiting`, `message expired`) -----------------------------------------
+
+  /** Every message here still waiting to be delivered after a failed attempt, or for a machine that is offline, oldest
+   *  filed first (mailbox.rs `waiting_mail`, field for field). */
+  waiting() {
+    const all = [];
+    let folders = [];
+    try { folders = readdirSync(this.mailRoot); } catch { return all; }
+    for (const folder of folders) {
+      let ids = [];
+      try { ids = readdirSync(join(this.mailRoot, folder, 'wake')); } catch { continue; }
+      if (!ids.length) continue;
+      const address = this.#address(folder);
+      if (!address) continue;
+      const machine = address.split(':')[1];
+      const wait = machine !== this.machine ? readJson(this.#machineWaitPath(machine)) : null;
+      for (const id of ids) {
+        const state = this.store.wakeState(address, id);
+        if (!wait && !(state.attempts > 0) && state.last_error == null) continue;
+        const found = this.store.findIn(address, id);
+        const envelope = found ? readJson(found.path) : null;
+        if (!envelope) continue;
+        all.push({ id, to: address, from: envelope.from ?? '', subject: envelope.subject ?? null, filed_at_ms: Number(envelope.created_at_ms) || 0,
+          waiting_for: wait ? wait.machine : null, since_ms: wait?.offline_since_ms ?? state.failing_since_ms ?? (Number(envelope.created_at_ms) || 0),
+          attempts: state.attempts ?? 0, last_error: wait?.last_error ?? state.last_error ?? null });
+      }
+    }
+    return all.sort((a, b) => a.filed_at_ms - b.filed_at_ms);
+  }
+
+  /** Every wake that expired here, oldest first (mailbox.rs `expired_wakes`). */
+  expired() {
+    const all = [];
+    let folders = [];
+    try { folders = readdirSync(this.mailRoot); } catch { return all; }
+    for (const folder of folders) {
+      let names = [];
+      try { names = readdirSync(join(this.mailRoot, folder, 'expired')); } catch { continue; }
+      for (const name of names) { const expiry = readJson(join(this.mailRoot, folder, 'expired', name)); if (expiry?.id) all.push(expiry); }
+    }
+    return all.sort((a, b) => (a.expired_at_ms ?? 0) - (b.expired_at_ms ?? 0));
+  }
+
   // ---- how an attempt went ---------------------------------------------------------------------------------------
 
   /** Record how a wake went: done, waiting for its next attempt, or expired at its bound (mail_watch.rs `settle`). */

package/mail/store.mjs

@@ -191,6 +191,22 @@ export class MailStore extends EventEmitter {
   /** The unread mail of `address` (not the user's own turns) moved into `claimed/` under its reader's pid (`pid`, the
    *  reading process: a claim whose reader ends goes back to `new/`), each claim recorded; another reader that took one
    *  first keeps it (mailbox.rs `claim_unread`). Oldest first. */
+  /** Whether `claimUnread` would take anything now, taking nothing: abandoned claims given back first, as it does, then
+   *  any envelope in new/ that is not a user's own turn (`message wait` wakes only for mail it can claim). From the
+   *  mailbox's own folders, as claimUnread reads them. */
+  hasClaimable(address, wanted = null) {
+    const box = this.boxOf(address) ?? this.#named(address);
+    if (!box) return false;
+    this.#recoverAbandoned(box);
+    let names = [];
+    try { names = readdirSync(join(box.dir, 'new')); } catch { return false; }
+    return names.some((file) => {
+      if (!file.endsWith('.json')) return false;
+      const envelope = readEnvelope(join(box.dir, 'new', file));
+      return envelope && typeof envelope.id === 'string' && envelope.kind !== 'user' && (!wanted || wanted(envelope));
+    });
+  }
+
   claimUnread(address, via, caller, pid = process.pid) {
     // the mailbox's own folders, read here (one named read): what decides a delivery never comes from the watch-fed
     // index alone, whose events a platform can drop (an FSEvents drop, an inotify overflow)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.113",
+  "version": "0.3.114",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",