@volter/supercode-terminal 0.2.45 → 0.2.46

package/index.d.ts

@@ -56,7 +56,7 @@ export class TmuxTerminalHost {
   sendInput(
     sessionId: string,
     data: string,
-    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' },
+    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none' },
   ): Promise<TerminalInputDelivery>;
   /** Persist an opaque application context association on a session owned by this host. */
   bindContext(sessionId: string, contextKey: string): Promise<TerminalSession>;
@@ -81,7 +81,7 @@ export class PaneServerHost {
   listSessions(): Promise<TerminalSession[]>;
   createSession(input: { command: TmuxCommand; contextKey?: string; cwd?: string; env?: Record<string, string>; name?: string }): Promise<TerminalSession>;
   capture(sessionId: string, options?: { lines?: number; preserveEscapes?: boolean }): Promise<string>;
-  sendInput(sessionId: string, data: string, options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' }): Promise<TerminalInputDelivery>;
+  sendInput(sessionId: string, data: string, options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none' }): Promise<TerminalInputDelivery>;
   bindContext(sessionId: string, contextKey: string): Promise<TerminalSession>;
   renameWindow(sessionId: string, title?: string | null): Promise<string>;
   issueAttachment(sessionId: string, options?: { mode?: 'observe' | 'control' }): Promise<TerminalAttachmentGrant>;
@@ -111,7 +111,7 @@ export class PtyTerminalHost {
   sendInput(
     sessionId: string,
     data: string,
-    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' },
+    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none' },
   ): Promise<TerminalInputDelivery>;
   bindContext(sessionId: string, contextKey: string): Promise<TerminalSession>;
   /** A ConPTY pane has no window to rename; returns its label. */
@@ -250,3 +250,8 @@ export type {
 } from './substrate/session-lifecycle.js';
 
 export type { TerminalInputDelivery, TmuxCommand, TmuxWindowSize };
+
+/** The bounded live composer text, or null for an unrecognized screen. */
+export function composerText(kind: string, screen: string | undefined): string | null;
+/** False means unconfirmed and may leave a draft; never blindly resend. */
+export function deliverComposerInput(host: TmuxTerminalHost | PtyTerminalHost | PaneServerHost, sessionId: string, kind: string, text: string, options?: { deadlineMs?: number; signal?: AbortSignal }): Promise<{ delivered: boolean; reason?: string; delivery?: TerminalInputDelivery }>;

package/index.mjs

@@ -437,9 +437,8 @@ export class TmuxTerminalHost {
   }
 }
 
-// The submit cadence tmux.js keeps for a submitted line: one Enter after the paste settles, or three spaced ones.
+// Raw terminal writes submit once. Only a composer readback can authorize a retry.
 const SINGLE_SUBMIT_DELAY_MS = 500;
-const SUBMITTED_LINE_DELAYS_MS = [500, 1500, 3500];
 const PTY_DEFAULT_SIZE = Object.freeze({ cols: 80, rows: 24 });
 const PTY_SCROLLBACK = 5_000;
 // How long one read of the Windows process table answers every pane's activeCommand: the read costs a
@@ -650,7 +649,7 @@ export class PtyTerminalHost {
       this.#live(entry.id).child.write(bytes);
     };
     const submit = async () => {
-      for (const delayMs of options.submitMode === 'single' ? [SINGLE_SUBMIT_DELAY_MS] : SUBMITTED_LINE_DELAYS_MS) {
+      for (const delayMs of options.submitMode === 'none' ? [] : [SINGLE_SUBMIT_DELAY_MS]) {
         await sleep(delayMs);
         write('\r');
       }
@@ -663,7 +662,7 @@ export class PtyTerminalHost {
         await submit();
         return 'submitted-paste';
       }
-      await submit();
+      if (options.submitMode !== 'none') write('\r');
       return 'submitted-line';
     }
     // tmux sends a newline in a keystream as Enter.
@@ -1547,16 +1546,15 @@ export class SupercodeTerminalController {
     const task = (async () => {
       const deadline = Date.now() + 5 * 60_000;
       while (!abort.signal.aborted && Date.now() < deadline) {
-        const content = this.#host.capture(sessionId, { lines: 80 });
+        const content = await this.#host.capture(sessionId, { preserveEscapes: true });
         if (composerReadyForInput(harness, content) === true) {
-          if (harness === 'codex') {
-            await this.#submitCodexInitialInput(sessionId, input, abort.signal);
-          } else {
-            await this.#host.sendInput(sessionId, input, {
-              deadlineMs: Date.now() + 15_000,
-              submitMode: 'retry',
-            });
+          if (harness !== 'claude-code' && harness !== 'codex') {
+            await this.#host.sendInput(sessionId, input, { submitMode: 'single', deadlineMs: Date.now() + 10_000 });
+            return;
           }
+          const result = await deliverComposerInput(this.#host, sessionId, harness,
+            input.replace(/(?:\r\n|\n|\r)$/u, ''), { signal: abort.signal });
+          if (!result.delivered) throw new Error(result.reason);
           return;
         }
         await new Promise((resolve) => setTimeout(resolve, 250));
@@ -1574,28 +1572,6 @@ export class SupercodeTerminalController {
     this.#pendingInitialInputs.set(sessionId, { abort, task });
   }
 
-  async #submitCodexInitialInput(sessionId, input, signal) {
-    await this.#host.sendInput(sessionId, input, {
-      deadlineMs: Date.now() + 15_000,
-      submitMode: 'single',
-    });
-    const deadline = Date.now() + 60_000;
-    let sawPrompt = false;
-    while (!signal.aborted && Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      const state = codexInitialInputState(this.#host.capture(sessionId, { lines: 100 }), input);
-      sawPrompt ||= state.promptVisible;
-      if (state.turnStarted || (sawPrompt && state.emptyComposerVisible)) return;
-      await this.#host.sendInput(sessionId, '\n', {
-        deadlineMs: Date.now() + 15_000,
-        submitMode: 'retry',
-      });
-    }
-    if (!signal.aborted) {
-      throw new Error('codex accepted the initial terminal text but did not start the turn');
-    }
-  }
-
   #sessionName(harness) {
     const label = harness === 'claude-code' ? 'claude' : harness;
     return `${this.#sessionNamePrefix}-${label}-${randomUUID().slice(0, 8)}`;
@@ -1708,6 +1684,7 @@ function composerLine(screen, caret) {
  */
 export function composerReadyForInput(kind, screen) {
   if (!Object.hasOwn(COMPOSER_READY, kind)) return null;
+  if (kind === 'claude-code' || kind === 'codex') return composerText(kind, screen) === '';
   return COMPOSER_READY[kind](String(screen ?? ''));
 }
 
@@ -1724,6 +1701,10 @@ export function composerReadyForInput(kind, screen) {
  * The caret is the kind's own, the one `composerReadyForInput` reads.
  */
 export function composerHoldsDraft(kind, screen) {
+  if (kind === 'claude-code' || kind === 'codex') {
+    const text = composerText(kind, screen);
+    return text === null ? null : text.length > 0;
+  }
   const carets = COMPOSER_CARETS[kind];
   if (!carets) return null;
   const lines = String(screen ?? '').split('\n');
@@ -1747,6 +1728,72 @@ export function composerHoldsDraft(kind, screen) {
   return null;
 }
 
+/** Read only a bounded, live Claude/Codex composer, never a prompt in scrollback.
+ * Unknown layouts and collapsed pastes are deliberately unconfirmed.
+ */
+export function composerText(kind, screen) {
+  if (kind !== 'claude-code' && kind !== 'codex') return null;
+  const lines = String(screen ?? '').split('\n').map(styledCells);
+  const plain = lines.map((cells) => cells.map((cell) => cell.char).join(''));
+  const rule = /^\s*[─━]{4,}\s*$/u;
+  const caret = kind === 'codex' ? /^\s*›(?:\s|$)/u : /^\s*[❯>](?:\s|$)/u;
+  for (let row = plain.length - 1; row >= 0; row -= 1) {
+    if (!caret.test(plain[row])) continue;
+    let end = row + 1;
+    while (end < plain.length && !rule.test(plain[end]) &&
+      !/^\s*(?:\? for shortcuts|.*\bcontext left\b)/u.test(plain[end])) end += 1;
+    // Claude encloses the editor in rules; Codex ends it at its shortcut/context footer.
+    if (end === plain.length) return null;
+    if (kind === 'claude-code' && (row === 0 || !rule.test(plain[row - 1]))) return null;
+    const first = plain[row].match(caret)[0].length;
+    const value = lines.slice(row, end).map((cells, index) => cells
+      .slice(index === 0 || /^\s*$/u.test(plain[row + index].slice(0, first)) ? first : 0).filter((cell) => !cell.placeholder)
+      .map((cell) => cell.char).join('').trimEnd()).join('\n').trim();
+    return value;
+  }
+  return null;
+}
+
+/** Paste once, then submit only text read back from the live composer.
+ * False means unconfirmed, and can leave a draft: callers must not blindly resend.
+ */
+export async function deliverComposerInput(host, sessionId, kind, text, { deadlineMs = Date.now() + 10_000, signal } = {}) {
+  const read = async () => composerText(kind, await host.capture(sessionId, { preserveEscapes: true }));
+  const expired = () => signal?.aborted || Date.now() >= deadlineMs;
+  const failed = (reason) => ({ delivered: false, reason });
+  if (expired()) return failed('deadline');
+  const before = await read();
+  if (before !== '') return failed(before === null ? 'no-composer' : 'draft');
+  const wanted = String(text).trim();
+  if (!wanted || /[\x00-\x08\x0b-\x1f\x7f]/u.test(text)) return failed('unsupported-text');
+  if (expired()) return failed('deadline');
+  const delivery = await host.sendInput(sessionId, `${text}\n`, { submitMode: 'none', deadlineMs });
+  // A dropped paste must never be followed by Enter. Give the editor time to render it.
+  let pasted = false;
+  for (let attempt = 0; attempt < 10 && !expired(); attempt += 1) {
+    await sleep(100);
+    const current = await read();
+    if (current === wanted) { pasted = true; break; }
+    if (current !== '') return failed('paste-unconfirmed');
+  }
+  if (!pasted) return failed('paste-unconfirmed');
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    // Re-read immediately before each Enter, including the first one.
+    if (expired()) return failed('deadline');
+    if (await read() !== wanted) return failed('composer-changed');
+    if (expired()) return failed('deadline');
+    // A keystream Enter has no hidden delay or retry between the read and the write.
+    await host.sendInput(sessionId, '\r', { submitMode: 'single', deadlineMs });
+    for (let poll = 0; poll < 10 && !expired(); poll += 1) {
+      await sleep(100);
+      const current = await read();
+      if (current === '') return { delivered: true, delivery };
+      if (current !== wanted) return failed('submission-unconfirmed');
+    }
+  }
+  return failed('submit-unconfirmed');
+}
+
 /** The carets each kind draws at the start of its composer line (Claude on Windows draws `>`). */
 const COMPOSER_CARETS = Object.freeze({ 'claude-code': ['❯', '>'], codex: ['›'], gemini: ['>'], grok: ['❯'] });
 
@@ -1782,19 +1829,6 @@ function styledCells(line) {
   return cells;
 }
 
-function codexInitialInputState(content, input) {
-  const firstLine = input.replace(/(?:\r\n|\n|\r)$/u, '').split(/\r?\n/u, 1)[0] ?? '';
-  const marker = `› ${firstLine.slice(0, 24)}`;
-  const promptAt = marker.length > 2 ? content.lastIndexOf(marker) : -1;
-  const emptyComposerAt = content.lastIndexOf('› Ask Codex to do anything');
-  const tail = promptAt >= 0 ? content.slice(promptAt + marker.length) : '';
-  return {
-    emptyComposerVisible: emptyComposerAt > promptAt,
-    promptVisible: promptAt >= 0,
-    turnStarted: promptAt >= 0 && /(?:^|\n)\s*[•◦✦⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s/u.test(tail),
-  };
-}
-
 function validSessionPrefix(value) {
   if (!/^[A-Za-z0-9_-]{1,32}$/.test(value)) {
     throw new TerminalHostError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-terminal",
-  "version": "0.2.45",
+  "version": "0.2.46",
   "type": "module",
   "description": "Optional leak-safe terminal and tmux host adapter for Volter Harness frontends",
   "exports": {

package/substrate/tmux.d.ts

@@ -128,11 +128,12 @@ export declare function sendInterruptAsync({ socket, target }: {
     target: string;
     socket?: string;
 }): Promise<void>;
+/** `none` pastes without Enter. Legacy `retry` submits once; retries require composer evidence. */
 export declare function sendInputAsync({ data, deadlineMs, socket, submitMode, target }: {
     target: string;
     data: string;
     deadlineMs?: number;
-    submitMode?: "retry" | "single";
+    submitMode?: "retry" | "single" | "none";
     socket?: string;
 }): Promise<TerminalInputDelivery>;
 export declare function attachSession({ name, socket, window }: {

package/substrate/tmux.js

@@ -748,6 +748,7 @@ export async function sendInterruptAsync({ socket, target }) {
     }
     await runAsync("tmux", tmuxArgs(socket, ["send-keys", "-t", target, "Escape"]));
 }
+/** `none` pastes without Enter. Legacy `retry` submits once; retries require composer evidence. */
 export async function sendInputAsync({ data, deadlineMs, socket, submitMode = "retry", target }) {
     assertTmux();
     if (!target) {
@@ -768,7 +769,8 @@ export async function sendInputAsync({ data, deadlineMs, socket, submitMode = "r
             await sendSubmittedPasteAsync({ deadlineMs, socket, submitMode, target, text: submittedText });
             return "submitted-paste";
         }
-        await sendSubmitKeysAsync({ deadlineMs, socket, submitMode, target });
+        if (submitMode !== "none")
+            await runAsync("tmux", tmuxArgs(socket, ["send-keys", "-t", target, "Enter"]), terminalInputRunOptions(deadlineMs));
         return "submitted-line";
     }
     for (const token of tokenizeTerminalInput(data)) {
@@ -790,7 +792,6 @@ export function attachSession({ name, socket, window }) {
     spawnInherited("tmux", tmuxArgs(socket, ["attach-session", "-t", target]));
 }
 const SINGLE_SUBMIT_DELAY_MS = 500;
-const SUBMITTED_LINE_DELAYS_MS = [500, 1500, 3500];
 async function sleepAsync(ms) {
     await new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -834,15 +835,11 @@ async function sendSubmittedPasteAsync({ deadlineMs, socket, submitMode, target,
     await sendSubmitKeysAsync({ deadlineMs, socket, submitMode, target });
 }
 async function sendSubmitKeysAsync({ deadlineMs, socket, submitMode, target }) {
-    if (submitMode === "single") {
-        await sleepAsync(SINGLE_SUBMIT_DELAY_MS);
-        await runAsync("tmux", tmuxArgs(socket, ["send-keys", "-t", target, "Enter"]), terminalInputRunOptions(deadlineMs));
+    // Retrying Enter requires a composer readback; raw terminal writes cannot do that.
+    if (submitMode === "none")
         return;
-    }
-    for (const delayMs of SUBMITTED_LINE_DELAYS_MS) {
-        await sleepAsync(delayMs);
-        await runAsync("tmux", tmuxArgs(socket, ["send-keys", "-t", target, "Enter"]), terminalInputRunOptions(deadlineMs));
-    }
+    await sleepAsync(SINGLE_SUBMIT_DELAY_MS);
+    await runAsync("tmux", tmuxArgs(socket, ["send-keys", "-t", target, "Enter"]), terminalInputRunOptions(deadlineMs));
 }
 function terminalInputRunOptions(deadlineMs) {
     if (deadlineMs === undefined)