@volter/supercode-teams 0.3.113 → 0.3.115

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';
 
@@ -124,6 +126,13 @@ export function claudeUsageLimitWait(screen) {
 /** The settle floor for a pane whose kind has no composer pattern: the screen
  *  must have stopped changing for this long before the pane counts as ready. */
 const INITIAL_INPUT_SETTLE_MS = 1_000;
+/** A Windows Codex's typed first input waits, before pasting, for an empty composer on a screen unchanged this long
+ *  (CODEX_PASTE_SETTLE_DEADLINE_MS at most); gives the paste CODEX_PASTE_SHOWN_MS to show, and watches
+ *  CODEX_PASTE_LATE_MS more to clear one shown after that. */
+const CODEX_PASTE_SETTLE_MS = 1_500;
+const CODEX_PASTE_SETTLE_DEADLINE_MS = 30_000;
+const CODEX_PASTE_SHOWN_MS = 5_000;
+const CODEX_PASTE_LATE_MS = 15_000;
 
 /**
  * Claude asks whether to trust a folder it has not opened before, whatever its permission mode, and has no flag that
@@ -1927,6 +1936,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);
@@ -2341,18 +2374,37 @@ export class TeamsMachine extends MachineCore {
       const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
       // Styled, so the composer's dim placeholder ("Ask Codex to do anything") reads as empty.
       const composer = async () => terminal.composerText?.('codex', await this.host.capture(session.id, { preserveEscapes: true })) ?? null;
-      if (await composer() !== '') return { delivered: false, reason: 'composer-not-empty' };
+      // A composer that reads ready can still be mid-layout: a fresh Codex redraws its screen for about a second more
+      // (measured on volter-desktop: ready from the first frame, redrawn at ~1.1 s and ~1.3 s), and a paste sent into
+      // that is shown late or not at all. Paste only into an empty composer on a screen that has stopped changing.
+      let settled = false;
+      for (const until = Date.now() + CODEX_PASTE_SETTLE_DEADLINE_MS; !settled && !signal.aborted && Date.now() < until;) {
+        const capture = await this.host.capture(session.id, { preserveEscapes: true });
+        settled = terminal.composerText?.('codex', capture) === '' &&
+          this.#screenUnchangedMs(session.id, capture, Date.now()) >= CODEX_PASTE_SETTLE_MS;
+        if (!settled) await pause(150);
+      }
+      if (signal.aborted) return { delivered: false, reason: 'aborted' };
+      if (!settled) return { delivered: false, reason: await composer() === '' ? 'screen-unsettled' : 'composer-not-empty' };
       for (const paste of codexWindowsPastes(body)) {
         if (signal.aborted) return { delivered: false, reason: 'aborted' };
         await this.host.sendInput(session.id, paste, { submitMode: 'none' });
         await pause(300);
       }
       let held = false;
-      for (let attempt = 0; attempt < 20 && !held && !signal.aborted; attempt += 1) {
+      for (const until = Date.now() + CODEX_PASTE_SHOWN_MS; !held && !signal.aborted && Date.now() < until;) {
         held = Boolean(await composer());
         if (!held) await pause(150);
       }
-      if (!held) return { delivered: false, reason: 'paste-unconfirmed' };
+      if (!held) {
+        // A paste shown after this gave up would sit in the composer unsent: watch a while longer and clear it, so the
+        // pane is left as it was found (the launch records the input as undelivered either way).
+        for (const until = Date.now() + CODEX_PASTE_LATE_MS; !signal.aborted && Date.now() < until;) {
+          if (await composer()) { await this.#clearCodexComposer(session, composer, pause); break; }
+          await pause(250);
+        }
+        return { delivered: false, reason: 'paste-unconfirmed' };
+      }
       await this.host.sendInput(session.id, '\r', { submitMode: 'single' });
       return { delivered: true };
     } catch (error) {
@@ -2362,6 +2414,17 @@ export class TeamsMachine extends MachineCore {
     }
   }
 
+  /** Empty a Windows Codex composer this launch pasted into: line clear, then deletes until it reads empty (a paste
+   *  placeholder goes with one delete). Never Enter, Escape or Ctrl-C. */
+  async #clearCodexComposer(session, composer, pause) {
+    await this.host.sendInput(session.id, '\u0015', { submitMode: 'none' });
+    await pause(300);
+    for (let round = 0; round < 40 && await composer(); round += 1) {
+      await this.host.sendInput(session.id, '\u007f'.repeat(200), { submitMode: 'none' });
+      await pause(200);
+    }
+  }
+
   async #deliverPaneText(session, contextKey, text, options = {}) {
     const kind = this.#paneKind(contextKey, session);
     if (kind === 'codex' && codexUpdatePrompt(await this.host.capture(session.id, { lines: 120 }))) return { delivered: false, reason: 'codex-update-prompt: delivery refused; restart Codex with check_for_update_on_startup=false' };
@@ -3673,28 +3736,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 });
+        }
+        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 };
         }
-        // `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 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.115",
   "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",