@volter/supercode-teams 0.2.150 → 0.2.152

package/bin/fleet.mjs

@@ -30,6 +30,7 @@ for (let i = 0; i < argv.length; i += 1) {
     const eq = a.indexOf('=');
     if (eq > 0) { flags[a.slice(2, eq)] = a.slice(eq + 1); continue; } // --args=--norc
     const key = a.slice(2);
+    if (key === 'act-for-caller') { flags[key] = true; continue; }
     const next = argv[i + 1];
     if (next !== undefined && !next.startsWith('--')) { flags[key] = next; i += 1; } else flags[key] = true;
   } else positional.push(a);

package/bin/teams.mjs

@@ -47,7 +47,7 @@ import { NODE_PROTOCOL } from '@volter/teams/channel';
 
 const MACHINE_VERBS = new Set(['machine', 'describe', 'panes', 'input', 'suspend', 'resume', 'files', 'ports', 'port', 'browser', 'stream', 'jobs', 'workspace', 'title', 'attention', 'watch', 'rpc', 'launches', 'log', 'mail']);
 // Every flag a machine verb reads; any other is refused rather than silently ignored.
-const KNOWN_FLAGS = new Set(['home', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'clear-draft']);
+const KNOWN_FLAGS = new Set(['home', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'clear-draft', 'message-ids']);
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -237,8 +237,8 @@ async function main() {
         if (flags.key === true || rest.length) die('input <pane> --key NAMES: keys by tmux name, space- or comma-separated (Escape, Enter, Tab, BTab, BSpace, Space, Up, Down, Left, Right, Home, End, PPage, NPage, DC, C-a … C-z)');
         return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: keyBytes(String(flags.key)), submit: false, keys: true, caller: caller() })));
       }
-      if (flags['when-composer-empty']) return withNode(async (rpc) => out(await rpc.call('panes.turn', { pane: sub, text: rest.join(' '), caller: caller() })));
-      return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: rest.join(' '), submit: !flags['no-enter'], caller: caller() })));
+      if (flags['when-composer-empty']) return withNode(async (rpc) => out(await rpc.call('panes.turn', { pane: sub, text: rest.join(' '), message_ids: flags['message-ids'] ? String(flags['message-ids']).split(',') : undefined, caller: caller() })));
+      return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: rest.join(' '), submit: !flags['no-enter'], message_ids: flags['message-ids'] ? String(flags['message-ids']).split(',') : undefined, caller: caller() })));
     case 'port': {
       // `port <pane>/<n> [--listen host:port]`: a machine port forwarded here. Stays up until ctrl-c.
       const spec = String(sub ?? '');

package/machine.mjs

@@ -50,6 +50,7 @@ import { request as httpRequest } from 'node:http';
 import { DEFAULT_RANK, normalizeRank, judge } from './attention.mjs';
 import { popupTerminal, openPopup } from './popup-terminals.mjs';
 import { JobOwner, executionCapabilities, streamProgram, serveWorkspace } from './execution.mjs';
+import { TerminalMailbox, retainedTerminalMail } from './terminal-mail.mjs';
 import { confirmNativeInitialInput } from './native-initial-input.mjs';
 import { canonicalCodexFolderTrust, settleCodexHookReview } from './codex-startup.mjs';
 
@@ -197,6 +198,13 @@ export class TeamsMachine extends MachineCore {
     // longer than the caller's own RPC timeout — so the wait lives here, where
     // `stop()` can abandon it rather than leave a timer running past the daemon.
     this.voiceProcesses = new Map(); // session address -> optional voice pack child
+    this.terminalMailboxes = new Map();
+    this.terminalMailRoot = join(this.env.SUPERCODE_HOME || join(this.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'supercode'), 'mail');
+    this.terminalMailTimer = setInterval(() => {
+      if (this.terminalMailWork) return;
+      this.terminalMailWork = this.#drainTerminalMail().catch(error => this.emit('mail-watch-stderr', `terminal mailbox: ${error.message}`)).finally(() => { this.terminalMailWork = null; });
+    }, 1000);
+    this.terminalMailTimer.unref?.();
     this.inputInFlight = new Set(); // one input transaction per pane
     this.inputRepairsPath = join(this.home, 'input-repairs.json');
     this.inputRepairs = readJson(this.inputRepairsPath, {});
@@ -229,6 +237,7 @@ export class TeamsMachine extends MachineCore {
   }
 
   async beforeClose() {
+    clearInterval(this.terminalMailTimer); await this.terminalMailWork;
     clearInterval(this.inputRepairTimer);this.inputRepairTimer=null;
     await this.inputRepairWork;
     clearInterval(this.endWatch); this.endWatch = null;
@@ -894,13 +903,46 @@ export class TeamsMachine extends MachineCore {
     this.pendingInitialInputs.set(key, { abort, task });
   }
 
+  async #drainTerminalMail() {
+    for (const saved of retainedTerminalMail(this.terminalMailRoot)) {
+      if (this.terminalMailboxes.has(saved.recipient) || !saved.binding) continue;
+      const session = await this.#paneByContext(saved.binding.context);
+      if (!session || session.id !== saved.binding.terminal || session.rootPid !== saved.binding.pid) continue;
+      const queue = new TerminalMailbox(this.terminalMailRoot, saved.recipient, receipt => this.log.append({ principal: null, cap: 'control',
+        target: `pane:${saved.binding.context}`, outcome: receipt.delivered ? 'input-delivered' : 'input-pending', detail: JSON.stringify(receipt) }), (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
+      queue.identity = saved.binding.identity; queue.host = this.host; queue.session = session;
+      this.terminalMailboxes.set(saved.recipient, queue);
+    }
+    await Promise.all([...this.terminalMailboxes.values()].filter(queue => !this.inputRepairs[queue.state.binding?.context] && !this.inputInFlight.has(queue.session?.id)).map(queue => queue.kick()));
+  }
+
+  async #terminalMail(session, contextKey, kind, text, options) {
+    const activity = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] });
+    const native = activity?.activities?.find(row => row.pid === session.rootPid)?.activity;
+    if (!native?.session_id) return { delivered: false, reason: 'native-session-unresolved' };
+    const found = await this.#serveRequest('harness.v1.sessions.discover', { query: native.session_id, harnesses: [kind], limit: 20 });
+    const row = found?.sessions?.find(row => row.locator?.session_id === native.session_id);
+    const path = row?.locator?.storage?.path;
+    if (!row?.locator || (kind === 'codex' && !path)) return { delivered: false, reason: 'native-transcript-unresolved' };
+    const key = `${kind}:${native.session_id}`;
+    let queue = this.terminalMailboxes.get(key);
+    if (!queue) {
+      queue = new TerminalMailbox(this.terminalMailRoot, key, receipt => this.log.append({ principal: null, cap: 'control', target: `pane:${contextKey}`,
+        outcome: receipt.delivered ? 'input-delivered' : 'input-pending', detail: JSON.stringify(receipt) }), (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
+      this.terminalMailboxes.set(key, queue);
+    }
+    const ids = queue.enqueue(text, options.messageIds, { kind, path, locator: row.locator }, this.host, session);
+    return queue.receipt(ids);
+  }
+
   async #deliverPaneText(session, contextKey, text, options = {}) {
+    const kind = this.#paneKind(contextKey, session);
+    if (['codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) return this.#terminalMail(session, contextKey, kind, submission(text, false), options);
     if(this.inputRepairs[contextKey])return {delivered:false,reason:'input-cleanup-pending',cleanup_required:true};
     if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
     this.inputInFlight.add(session.id);
     try {
-      const kind = this.#paneKind(contextKey, session);
-      if (kind === 'claude-code' || kind === 'codex') {
+      if (kind === 'claude-code') {
         if (typeof terminal.deliverComposerInput !== 'function') return { delivered: false, reason: 'terminal-package-too-old' };
         const result=await terminal.deliverComposerInput(this.host, session.id, kind, submission(text, false), options);
         if(result.cleanup_required){
@@ -1542,15 +1584,16 @@ export class TeamsMachine extends MachineCore {
         if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
         let result;
         if (params.keys || params.submit === false) {
+          if (!params.keys && [...this.terminalMailboxes.values()].some(queue => queue.session?.id === session.id && (queue.state.active || queue.state.pending.length))) return { delivered: false, reason: 'terminal mailbox has an unconfirmed paste' };
           this.inputInFlight.add(session.id);
           try {
             const delivery = await this.host.sendInput(session.id, params.keys ? String(params.text ?? '') : submission(params.text, false), { submitMode: 'single', deadlineMs });
             result = { delivered: true, delivery };
           } finally { this.inputInFlight.delete(session.id); }
         } else {
-          result = await this.#deliverPaneText(session, params.pane, params.text, { deadlineMs });
+          result = await this.#deliverPaneText(session, params.pane, params.text, { deadlineMs, messageIds: params.message_ids });
         }
-        act('control', `pane:${params.pane}`, result.delivered ? 'input' : 'failed', result.reason);
+        act('control', `pane:${params.pane}`, result.delivered ? 'input' : 'failed', JSON.stringify(result));
         return result;
       }
       case 'panes.clearDraft': {
@@ -1620,15 +1663,15 @@ export class TeamsMachine extends MachineCore {
         if (!session) throw Object.assign(new Error(`no pane with context ${params.pane}`), { code: 404 });
         if (this.suspended.has(params.pane)) throw Object.assign(new Error(`pane ${params.pane} is suspended: remote input is refused until resume`), { code: 423 });
         const kind = this.#paneKind(params.pane, session);
-        const draftOf = async () => composerHoldsDraft(kind, await this.host.capture(session.id, { lines: 200, preserveEscapes: true }));
-        const first = await draftOf();
-        await new Promise((resolve) => setTimeout(resolve, COMPOSER_RECHECK_MS));
-        const second = await draftOf();
-        if (first !== false || second !== false) {
-          return { delivered: false, reason: first === true || second === true ? 'draft' : 'no-composer' };
+        if (kind === 'claude-code') {
+          const draftOf = async () => composerHoldsDraft(kind, await this.host.capture(session.id, { lines: 200, preserveEscapes: true }));
+          const first = await draftOf();
+          await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
+          const second = await draftOf();
+          if (first !== false || second !== false) return { delivered: false, reason: first === true || second === true ? 'draft' : 'no-composer' };
         }
-        const result = await this.#deliverPaneText(session, params.pane, params.text, { deadlineMs: Date.now() + 10_000 });
-        act('control', `pane:${params.pane}`, result.delivered ? 'input' : 'failed', result.reason);
+        const result = await this.#deliverPaneText(session, params.pane, params.text, { deadlineMs: Date.now() + 10_000, messageIds: params.message_ids });
+        act('control', `pane:${params.pane}`, result.delivered ? 'input' : 'failed', JSON.stringify(result));
         return result;
       }
       case 'panes.capture': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.150",
+  "version": "0.2.152",
   "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",

package/terminal-mail.mjs

@@ -0,0 +1,120 @@
+// Per-recipient terminal mailbox. A retained paste is never repeated: retries
+// press Enter and look for the exact user message in the native transcript.
+import { mkdirSync, readFileSync, writeFileSync, renameSync, appendFileSync, statSync, openSync, readSync, closeSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { StringDecoder } from 'node:string_decoder';
+
+const hash = value => createHash('sha256').update(value).digest('hex');
+const textOf = content => typeof content === 'string' ? content : Array.isArray(content) && content.every(p => ['text', 'input_text'].includes(p.type)) ? content.map(p => p.text).join('') : null;
+
+function confirmed(batch) {
+  const fd = openSync(batch.path, 'r');
+  try {
+    let offset = batch.offset, buffered = '';
+    const decoder = new StringDecoder('utf8');
+    const bytes = Buffer.alloc(64 * 1024);
+    for (;;) {
+      const count = readSync(fd, bytes, 0, bytes.length, offset);
+      if (!count) return false;
+      offset += count; buffered += decoder.write(bytes.subarray(0, count));
+      let end;
+      while ((end = buffered.indexOf('\n')) >= 0) {
+        const line = buffered.slice(0, end); buffered = buffered.slice(end + 1);
+        let row; try { row = JSON.parse(line); } catch { continue; }
+        const content = batch.kind === 'codex' && row.type === 'response_item' && row.payload?.type === 'message' && row.payload.role === 'user'
+          ? row.payload.content : batch.kind === 'grok' && row.type === 'user' ? row.content : null;
+        if (textOf(content) === batch.text) return true;
+      }
+    }
+  } finally { closeSync(fd); }
+}
+
+export class TerminalMailbox {
+  constructor(root, recipient, log, load) {
+    this.dir = join(root, 'terminal-delivery', hash(recipient));
+    mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+    this.file = join(this.dir, 'queue.json'); this.log = log; this.load = load;
+    try { this.state = JSON.parse(readFileSync(this.file, 'utf8')); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; this.state = { recipient, pending: [], active: null, receipts: [] }; }
+    this.work = null;
+  }
+  save() {
+    const encoded = JSON.stringify(this.state) + '\n';
+    if (encoded === this.saved) return;
+    const temporary = `${this.file}.${process.pid}.tmp`;
+    writeFileSync(temporary, encoded, { mode: 0o600 });
+    renameSync(temporary, this.file); this.saved = encoded;
+  }
+  receipt(ids) {
+    const delivered = ids.every(id => this.state.receipts.some(r => r.message_ids.includes(id)));
+    const batch = this.state.active;
+    return { delivered, queued: !delivered, message_ids: ids,
+      ...(delivered ? { receipt: 'native-user-message' } : { reason: batch?.error ?? 'queued', batch: batch?.id ?? null }) };
+  }
+  enqueue(text, ids, identity, host, session) {
+    const messageIds = ids?.length ? ids : [`input-${randomUUID()}`];
+    const known = new Set([...this.state.pending.flatMap(m => m.ids), ...(this.state.active?.message_ids ?? []), ...this.state.receipts.flatMap(r => r.message_ids)]);
+    if (messageIds.some(id => !known.has(id))) {
+      // One caller retry is one queued envelope, including when a prior batch is
+      // waiting for confirmation. New mail joins the next paste, never this one.
+      this.state.pending.push({ ids: messageIds, text }); this.save();
+    }
+    this.identity = identity; this.host = host; this.session = session;
+    this.state.binding = { context: session.contextKey, terminal: session.id, pid: session.rootPid, identity }; this.save();
+    return messageIds;
+  }
+  kick() {
+    if (this.work) return this.work;
+    this.work = this.drain().catch(error => {
+      if (this.state.active) { this.state.active.error = error.message; this.save(); }
+      this.log({ delivered: false, reason: error.message, message_ids: this.state.active?.message_ids ?? [] });
+    }).finally(() => { this.work = null; });
+    return this.work;
+  }
+  async drain() {
+    let batch = this.state.active;
+    if (!batch && this.state.pending.length) {
+      const items = this.state.pending.slice();
+      const text = items.map(m => m.text).join('\n\n');
+      const incremental = this.identity.kind === 'codex';
+      const baseline = incremental ? null : await this.load(this.identity.locator, { message_tail: 1 });
+      batch = { id: randomUUID(), message_ids: items.flatMap(m => m.ids), text, kind: this.identity.kind,
+        path: this.identity.path, offset: incremental ? statSync(this.identity.path).size : null,
+        locator: this.identity.locator, messageOffset: baseline?.window?.total_messages ?? null, phase: 'prepared', enters: 0, last_enter: 0 };
+      this.state.active = batch; this.state.pending = this.state.pending.filter(message => !items.includes(message)); this.save();
+    }
+    if (!batch) return;
+    const seen = batch.offset !== null ? confirmed(batch) : (await this.load(batch.locator, { message_offset: batch.messageOffset, message_limit: 1000 })).session?.messages?.some(message => message.role === 'user' && textOf(message.content) === batch.text);
+    if (seen) {
+      const receipt = { batch: batch.id, message_ids: batch.message_ids, delivered: true, receipt: 'native-user-message', at: Date.now() };
+      appendFileSync(join(this.dir, 'receipts.jsonl'), JSON.stringify(receipt) + '\n', { mode: 0o600 });
+      this.state.receipts.push(receipt);
+      this.state.active = null; this.save(); this.log(receipt); return;
+    }
+    if (batch.phase === 'prepared') {
+      // Persist uncertainty before I/O. A daemon restart checks the transcript;
+      // it never guesses that an unacknowledged paste did not happen.
+      batch.phase = 'paste_started'; this.save();
+      await this.host.sendInput(this.session.id, batch.text, { submitMode: 'none' });
+      batch.phase = 'pasted'; this.save();
+    }
+    if (batch.phase === 'paste_started') {
+      batch.error = 'paste outcome uncertain; native transcript confirmation pending'; this.save(); return;
+    }
+    if (batch.enters < 3 && Date.now() - batch.last_enter >= 5000) {
+      batch.enters += 1; batch.last_enter = Date.now(); this.save();
+      await this.host.sendInput(this.session.id, '\r', { submitMode: 'single' });
+      this.log({ delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, attempt: batch.enters });
+    }
+    batch.error = batch.enters >= 3 ? 'native transcript unconfirmed after Enter retries' : 'native transcript confirmation pending';
+    this.save();
+  }
+}
+
+export function retainedTerminalMail(root) {
+  const directory = join(root, 'terminal-delivery');
+  let names; try { names = readdirSync(directory); } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  return names.map(name => JSON.parse(readFileSync(join(directory, name, 'queue.json'), 'utf8')))
+    .filter(state => state.active || state.pending.length);
+}