@volter/supercode-teams 0.2.104 → 0.2.106

package/machine.mjs

@@ -187,6 +187,7 @@ export class TeamsMachine extends MachineCore {
     //. The launch reply does not wait for delivery — a cold TUI can take
     // 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.inputInFlight = new Set(); // one input transaction per pane
     this.pendingInitialInputs = new Map(); // launch key → { abort, task }
     this.registerDoor('harness', (entry, stream, accept, refuse, index) => this.#serveHarness(index, entry, stream, accept, refuse));
     this.registerDoor('terminal', (entry, stream, accept, refuse) => this.#attachTerminal(entry, stream, accept, refuse));
@@ -596,7 +597,11 @@ export class TeamsMachine extends MachineCore {
       let out = '';
       let child;
       try {
-        child = spawn(this.supercodeBin, ['teams', 'caller', '--peer-fd', '3'], { stdio: ['ignore', 'pipe', 'ignore', entry.socket], env: this.env, windowsHide: true });
+        // The descriptor's number, not the socket: a stream handed to spawn stops being read here, and the
+        // connection's next request would never be answered. The child gets its own duplicate of the descriptor.
+        const fd = entry.socket._handle?.fd;
+        if (!Number.isInteger(fd) || fd < 0) { resolve({ unsupported: true }); return; }
+        child = spawn(this.supercodeBin, ['teams', 'caller', '--peer-fd', '3'], { stdio: ['ignore', 'pipe', 'ignore', fd], env: this.env, windowsHide: true });
       } catch { resolve({ unknown: true }); return; }
       child.stdout.on('data', (chunk) => { out += chunk; });
       child.on('error', () => resolve({ unknown: true }));
@@ -748,30 +753,16 @@ export class TeamsMachine extends MachineCore {
     const task = (async () => {
       const readyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
       if (readyBy === 'aborted') return;
-      if (readyBy === 'pane-gone') {
+      if (readyBy === 'pane-gone' || readyBy === 'deadline') {
         this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputReadyBy: readyBy });
-        act('launch', `pane:${contextKey}`, 'failed', 'first input undelivered: the pane ended before it was ready');
+        act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${readyBy}`);
         return;
       }
-      // `single` stays `single`: one paste, one submit. The repeated Enter of
-      // `retry` exists for a composer that swallowed the first one, and pressing
-      // Enter again at an agent that already took the message sends an empty
-      // turn. The fix for a lost submit is waiting until there is something to
-      // submit into, which is what happened above.
-      try {
-        await this.host.sendInput(session.id, submission(input), { submitMode: 'single' });
-      } catch (error) {
-        this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputReadyBy: readyBy, inputError: error.message });
-        act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${error.code ?? error.message}`);
-        return;
-      }
-      // `inputDeliveredLate` is the deadline's own confession: the pane never
-      // showed us it was ready, and the message went in on a screen nobody
-      // vouched for. A launch that reads `ready` without it was given its
-      // message by an input box that existed.
-      const late = readyBy === 'deadline';
-      this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: true, inputReadyBy: readyBy, ...(late ? { inputDeliveredLate: true } : {}) });
-      act('launch', `pane:${contextKey}`, 'ok', `first input delivered (${readyBy})`);
+      const result = await this.#deliverPaneText(session, contextKey, input, { signal: abort.signal });
+      this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: result.delivered,
+        inputReadyBy: readyBy, ...(!result.delivered ? { inputError: result.reason } : {}) });
+      act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : 'failed',
+        result.delivered ? `first input delivered (${readyBy})` : `first input unconfirmed: ${result.reason}`);
     })().catch((error) => {
       // Nothing above is expected to throw; if something does, the launch record
       // is where it is answerable, not a crashed daemon.
@@ -782,6 +773,24 @@ export class TeamsMachine extends MachineCore {
     this.pendingInitialInputs.set(key, { abort, task });
   }
 
+  async #deliverPaneText(session, contextKey, text, options = {}) {
+    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 (typeof terminal.deliverComposerInput !== 'function') return { delivered: false, reason: 'terminal-package-too-old' };
+        return await terminal.deliverComposerInput(this.host, session.id, kind, submission(text, false), options);
+      }
+      const delivery = await this.host.sendInput(session.id, submission(text), { ...options, submitMode: 'single' });
+      return { delivered: true, delivery };
+    } catch (error) {
+      return { delivered: false, reason: error?.message ?? String(error) };
+    } finally {
+      this.inputInFlight.delete(session.id);
+    }
+  }
+
   /** The program a pane runs, as the terminal package names kinds: what it was
    *  launched as, else what its foreground command is. */
   #paneKind(contextKey, session) {
@@ -809,13 +818,13 @@ export class TeamsMachine extends MachineCore {
    *              the foreground command (`awaiting_me`'s evidence: a prompt,
    *              turn over).
    *   deadline   neither, for `INITIAL_INPUT_READY_DEADLINE_MS`. The caller
-   *              delivers anyway and says so.
+   *              leaves input undelivered without typing into that screen.
    */
   async #awaitInputReady(session, contextKey, kind, signal) {
-    const composerKind = typeof kind === 'string' ? kind.trim().toLowerCase() : '';
+    const composerKind = this.#paneKind(contextKey, session);
     const until = Date.now() + INITIAL_INPUT_READY_DEADLINE_MS;
     while (!signal.aborted && Date.now() < until) {
-      const capture = await this.#safeCapture(session.id);
+      const capture = await Promise.resolve().then(() => this.host.capture(session.id, { preserveEscapes: true })).catch(() => '');
       const unchangedMs = this.#screenUnchangedMs(session.id, capture, Date.now());
       const blank = capture.trim() === '';
       // A blank screen is the one reading that can mean the pane is GONE rather
@@ -1301,13 +1310,22 @@ export class TeamsMachine extends MachineCore {
         const session = await this.#paneByContext(params.pane);
         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 });
-        // `deadlineMs` is how long the caller will wait (default 10 s, which covers `retry`'s 5.5 s of
-        // submit presses; at most 30 s); the terminal host takes an absolute deadline.
-        // `keys`: the bytes of named keys, delivered as they are (a trailing Enter is a key, not a line ending).
-        const data = params.keys ? String(params.text ?? '') : submission(params.text, params.submit !== false);
-        const delivery = await this.host.sendInput(session.id, data, { submitMode: params.submit === false || params.keys ? 'single' : 'retry', deadlineMs: Date.now() + Math.min(Number(params.deadlineMs) || 10_000, 30_000) });
-        act('control', `pane:${params.pane}`, 'input');
-        return { delivered: true, delivery };
+        // Named keys and no-submit input are raw terminal writes. A submitted
+        // Claude/Codex turn needs evidence from the composer before claiming delivery.
+        const deadlineMs = Date.now() + Math.min(Number(params.deadlineMs) || 10_000, 30_000);
+        if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
+        let result;
+        if (params.keys || params.submit === false) {
+          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 });
+        }
+        act('control', `pane:${params.pane}`, result.delivered ? 'input' : 'failed', result.reason);
+        return result;
       }
       case 'panes.turn': {
         // A user's own turn, as its own submitted turn: typed only into an empty
@@ -1328,9 +1346,9 @@ export class TeamsMachine extends MachineCore {
         if (first !== false || second !== false) {
           return { delivered: false, reason: first === true || second === true ? 'draft' : 'no-composer' };
         }
-        const delivery = await this.host.sendInput(session.id, submission(params.text, true), { submitMode: 'single', deadlineMs: Date.now() + 10_000 });
-        act('control', `pane:${params.pane}`, 'input');
-        return { delivered: true, delivery };
+        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);
+        return result;
       }
       case 'panes.capture': {
         need('observe', `pane:${params.pane}`);

package/package.json

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