@humwick/runner 0.0.0-stage → 0.130.0

package/src/adapters/claude-submit-confirmation.ts

@@ -0,0 +1,287 @@
+// A tmux command exiting 0 only proves that tmux accepted a key. Claude can still
+// have the pasted prompt in its composer (for example when Enter lands in copy mode).
+// Claude's UserPromptSubmit hook proves acceptance; the composer only decides whether
+// another Enter is safe, and confirms alone only on hookless launches (#2664).
+import { ProviderSubmitFailure } from "../provider-submit-failure";
+import type { ClaudePromptHookExpectation } from "./claude-prompt-hook";
+import { claudeHookPromptMatches } from "./claude-prompt-hook";
+import { CLAUDE_COMPOSER_RULE_RE } from "./claude-status-detectors";
+import { stat } from "node:fs/promises";
+import { IncrementalClaudeTranscriptTail, type IncrementalTranscriptPollResult } from "./claude-transcript-tail";
+
+export const CLAUDE_SUBMIT_MAX_ENTERS = 3;
+export const CLAUDE_SUBMIT_HOOK_WAIT_MS = 3_000;
+/** Extra hook wait once our Enter left the composer: a slow hook is still proof (#3081). */
+export const CLAUDE_SUBMIT_LATE_HOOK_WAIT_MS = 10_000;
+const PASTE_RENDER_TIMEOUT_MS = 3_000;
+const SUBMIT_SETTLE_MS = 1_200;
+const POLL_MS = 100;
+
+/** Watch the current transcript, resolving it again if the first user turn creates the file. */
+export class ClaudeSubmitTranscriptProbe {
+  private readonly tail = new IncrementalClaudeTranscriptTail();
+  private path?: string;
+  private ready = false;
+  private knownMissing = false;
+  private readonly startedAt: number;
+  private recoveryPoll?: IncrementalTranscriptPollResult;
+
+  constructor(private readonly resolvePath: () => Promise<string | undefined>, now: () => number = Date.now) {
+    this.startedAt = now();
+  }
+
+  async start(path?: string): Promise<void> {
+    this.path = path;
+    this.ready = path ? await this.tail.seekToEnd(path).catch(() => false) : false;
+    this.knownMissing = Boolean(path && !this.ready && await stat(path).then(() => false, (error: NodeJS.ErrnoException) => error.code === "ENOENT"));
+  }
+
+  async poll(): Promise<IncrementalTranscriptPollResult | null> {
+    const fresh = await this.pollTail();
+    const retained = this.recoveryPoll;
+    this.recoveryPoll = undefined;
+    if (!retained) return fresh;
+    if (!fresh) return retained;
+    return { ...fresh, reset: retained.reset || fresh.reset,
+      userPrompts: retained.userPrompts.concat(fresh.userPrompts),
+      userPromptOccurredAts: retained.userPromptOccurredAts.concat(fresh.userPromptOccurredAts) };
+  }
+
+  private async pollTail(): Promise<IncrementalTranscriptPollResult | null> {
+    const path = this.path ?? await this.resolvePath().catch(() => undefined);
+    if (!path) return null;
+    if (!this.ready) {
+      let missing = false;
+      const file = await stat(path).catch((error: NodeJS.ErrnoException) => {
+        missing = error.code === "ENOENT";
+        return null;
+      });
+      if (!file) {
+        if (missing && this.path === path) this.knownMissing = true;
+        return null;
+      }
+      this.path = path;
+      // A late resolver may reveal an old conversation. Seek past clearly old
+      // files without loading their potentially large histories into memory.
+      if (!this.knownMissing && file.birthtimeMs < this.startedAt - 10_000) {
+        this.ready = await this.tail.seekToEnd(path).catch(() => false);
+        return null;
+      }
+      const first = await this.tail.poll(path).catch(() => null);
+      if (!first?.available) return null;
+      this.ready = true;
+      if (this.knownMissing || first.reset) return first;
+      // File timestamps can lag Date.now even when a file was created after
+      // submit. Use Claude's user-entry timestamp to distinguish a fresh turn
+      // from old history when the path was unknown at submit time.
+      const recent = first.userPrompts.flatMap((prompt, index) =>
+        (first.userPromptOccurredAts[index] ?? -Infinity) >= this.startedAt ? [{ prompt, occurredAt: first.userPromptOccurredAts[index] }] : []);
+      if (recent.length === 0) return null;
+      return { ...first, userPrompts: recent.map((item) => item.prompt), userPromptOccurredAts: recent.map((item) => item.occurredAt) };
+    }
+    return this.tail.poll(path).catch(() => null);
+  }
+
+  async confirms(text: string, offeredAt: number, imagePaths: readonly string[] = []): Promise<boolean> {
+    // A consumption check must leave its read available to submit recovery (#2691).
+    const result = this.recoveryPoll = (await this.poll()) ?? undefined;
+    return result?.userPrompts.some((prompt, i) =>
+      (result.userPromptOccurredAts[i] ?? -Infinity) >= offeredAt && claudeHookPromptMatches(prompt, text, imagePaths)) === true;
+  }
+}
+
+/** Hold an ambiguous submission until a new tmux incarnation is created. */
+export class ClaudeSubmitFence {
+  private readonly uncertain = new Map<string, (turnStarted: boolean) => Promise<boolean>>();
+
+  async run(session: string, submit: (markPasteStarted: () => void) => Promise<unknown>, recovery: (turnStarted: boolean) => Promise<boolean>): Promise<void> {
+    // Probe here too: a dashboard prompt reaches the fence directly, and the turn that would
+    // otherwise trigger recovery may have started before the failure was recorded (#2664).
+    if (this.uncertain.has(session) && !await this.recover(session)) {
+      throw new ProviderSubmitFailure("Claude prompt submit remains unconfirmed from an earlier attempt; inspect the TUI before retrying", false);
+    }
+    let pasteStarted = false;
+    try { await submit(() => { pasteStarted = true; }); }
+    catch (error) {
+      const retrySafe = !pasteStarted && (!(error instanceof ProviderSubmitFailure) || error.retrySafe);
+      const failure = new ProviderSubmitFailure(String(error), retrySafe, error);
+      if (!failure.retrySafe) this.uncertain.set(session, recovery);
+      throw failure;
+    }
+  }
+
+  async recover(session: string, turnStarted = false): Promise<boolean> {
+    const probe = this.uncertain.get(session);
+    if (!probe) return true; // nothing unconfirmed is outstanding
+    if (!await probe(turnStarted).catch(() => false) || this.uncertain.get(session) !== probe) return false;
+    this.uncertain.delete(session);
+    return true;
+  }
+
+  clear(session: string): void { this.uncertain.delete(session); }
+}
+
+/** Composer recovery: a settled empty composer plus turn or transcript evidence. A matching hook also recovers. */
+export async function claudeSubmitRecoveryConfirmed(deps: ClaudeComposerReadDeps & {
+  readNewUserPrompts?: () => Promise<{ reset: boolean; userPrompts: string[] } | null>;
+  paneShowsTurnStarted: (pane: string) => boolean;
+}, turnStarted: boolean): Promise<boolean> {
+  // Turn evidence is only required on top of a settled empty composer, never instead of it.
+  const settled = await settleClaudeComposer(deps, null);
+  if (settled.verdict !== "empty") return false;
+  if (turnStarted || deps.paneShowsTurnStarted(plainPaneText(settled.pane))) return true;
+  const transcript = await deps.readNewUserPrompts?.();
+  return transcript?.reset === false && transcript.userPrompts.length > 0;
+}
+
+export interface ClaudeComposerReadDeps {
+  readPane: (timeoutMs: number) => Promise<string>;
+  sleep?: (ms: number) => Promise<unknown>;
+  now?: () => number;
+}
+
+// Hookless (degraded) composer acceptance (#2664): empty only after a readable empty composer
+// has lasted SUBMIT_SETTLE_MS from its FIRST empty frame, with no input re-shown meanwhile.
+// A torn frame neither confirms nor withdraws, but the window must end on a readable empty
+// frame; an unsettled or unreadable end is "unreadable", so no key goes into a dialog.
+export async function settleClaudeComposer(deps: ClaudeComposerReadDeps, expected: string | null): Promise<{ verdict: "empty" | "retained" | "changed" | "unreadable"; pane: string }> {
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? Bun.sleep;
+  const deadline = now() + 2 * SUBMIT_SETTLE_MS;
+  let emptySince: number | undefined, text: string | null = null, pane = "";
+  for (;;) {
+    // A full capture budget per read: a read clipped to the window's remainder would end every
+    // window on a timed-out, "unreadable" frame.
+    try { pane = await deps.readPane(PASTE_RENDER_TIMEOUT_MS); text = claudeComposerText(pane); }
+    catch { text = null; }
+    if (text === "") emptySince ??= now();
+    else if (text !== null) {
+      emptySince = undefined;
+      if (expected === null) return { verdict: "retained", pane };
+      if (text !== expected) return { verdict: "changed", pane };
+    }
+    if (text === "" && now() - emptySince! >= SUBMIT_SETTLE_MS) return { verdict: "empty", pane };
+    if (now() >= deadline) break;
+    await sleep(Math.min(POLL_MS, Math.max(0, deadline - now())));
+  }
+  return { verdict: text !== null && emptySince === undefined ? "retained" : "unreadable", pane };
+}
+
+async function readComposer(deps: ClaudeComposerReadDeps, timeoutMs: number): Promise<string | null> {
+  try { return claudeComposerText(await deps.readPane(timeoutMs)); }
+  catch { return null; }
+}
+
+// Claude renders composer placeholders ("Press up to edit queued messages" after a
+// mid-turn submit, "Try …") dim; typed and pasted input never is. Reading a styled
+// capture keeps a placeholder from looking like an unsubmitted prompt (#2664).
+const TERMINAL_ESCAPE = /\x1b\[([0-9;:]*)m|\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+
+function sgrDim(params: string, dim: boolean): boolean {
+  const codes = params === "" ? ["0"] : params.split(";");
+  for (let i = 0; i < codes.length; i++) {
+    const code = Number(codes[i]);
+    if (code === 0 || code === 22) dim = false;
+    else if (code === 2) dim = true;
+    else if ((code === 38 || code === 48 || code === 58) && !codes[i]!.includes(":")) i += codes[i + 1] === "5" ? 2 : codes[i + 1] === "2" ? 4 : 0;
+  }
+  return dim;
+}
+
+/** Visible text per line plus the undimmed part of it. SGR state carries across tmux lines. */
+function paneLines(pane: string): { text: string; input: string }[] {
+  let dim = false;
+  return pane.split("\n").map((line) => {
+    let text = "", input = "", last = 0;
+    for (const match of line.matchAll(TERMINAL_ESCAPE)) {
+      const chunk = line.slice(last, match.index);
+      text += chunk;
+      if (!dim) input += chunk;
+      last = match.index + match[0].length;
+      if (match[1] !== undefined) dim = sgrDim(match[1], dim);
+    }
+    const tail = line.slice(last);
+    return { text: text + tail, input: dim ? input : input + tail };
+  });
+}
+
+export function plainPaneText(pane: string): string {
+  return pane.includes("\x1b") ? pane.replace(TERMINAL_ESCAPE, "") : pane;
+}
+
+const COMPOSER_PROMPT = /^\s*❯[\u00a0 ]?(.*)$/;
+
+/** null = no recognizable Claude composer, "" = empty composer (or only a dim placeholder). */
+export function claudeComposerText(pane: string): string | null {
+  const lines = paneLines(pane);
+  for (let i = lines.length - 2; i >= 0; i--) {
+    const match = COMPOSER_PROMPT.exec(lines[i]!.text);
+    if (!match) continue;
+    const border = lines.findIndex((line, index) => index > i && CLAUDE_COMPOSER_RULE_RE.test(line.text));
+    if (border < 0) continue;
+    const body = lines.slice(i + 1, border);
+    const input = [COMPOSER_PROMPT.exec(lines[i]!.input)?.[1] ?? "", ...body.map((line) => line.input)].join("").trim();
+    return input === "" ? "" : [match[1], ...body.map((line) => line.text)].join("\n").trim();
+  }
+  return null;
+}
+
+export interface ClaudeSubmitConfirmationDeps extends ClaudeComposerReadDeps {
+  paste: () => Promise<void>;
+  sendEnter: () => Promise<void>;
+  cancelCopyMode: () => Promise<void>;
+  delayBeforeFirstEnterMs: number;
+  /** Matching UserPromptSubmit hook; absent on hookless (monitorless) launches. */
+  hook?: Pick<ClaudePromptHookExpectation, "arm" | "accepted" | "wait">;
+  onRetry?: (attempt: number) => void;
+}
+
+export async function submitClaudePromptConfirmed(deps: ClaudeSubmitConfirmationDeps): Promise<"hook" | "degraded"> {
+  // A failure before our Enter still arms the hook, so a later operator Enter can release the fence.
+  try { return await submitConfirmed(deps); }
+  catch (error) { deps.hook?.arm(); throw error; }
+}
+
+async function submitConfirmed(deps: ClaudeSubmitConfirmationDeps): Promise<"hook" | "degraded"> {
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? Bun.sleep;
+  // A fresh read right before the paste; no remembered frame can vouch for an empty composer.
+  const before = await readComposer(deps, PASTE_RENDER_TIMEOUT_MS);
+  if (before === null) throw new Error("Claude prompt submit failed: input composer is not visible before paste");
+  if (before !== "") throw new Error("Claude prompt submit failed: input composer already contains text");
+
+  await deps.paste();
+  const pasteDeadline = now() + PASTE_RENDER_TIMEOUT_MS;
+  let pasted: string | null = null;
+  while (now() < pasteDeadline) {
+    pasted = claudeComposerText(await deps.readPane(Math.max(1, pasteDeadline - now())));
+    if (pasted) break;
+    await sleep(Math.min(POLL_MS, Math.max(0, pasteDeadline - now())));
+  }
+  if (!pasted) throw new Error("Claude prompt submit failed: pasted text did not appear in the input composer");
+  await sleep(deps.delayBeforeFirstEnterMs);
+
+  for (let attempt = 1; attempt <= CLAUDE_SUBMIT_MAX_ENTERS; attempt++) {
+    if (attempt > 1) {
+      deps.onRetry?.(attempt);
+      // A user scrolling the web terminal can leave tmux in copy mode. An Enter
+      // sent there succeeds at the tmux layer but never reaches Claude.
+      await deps.cancelCopyMode();
+    }
+    deps.hook?.arm(); // only hooks fired from here on can vouch for this Enter
+    await deps.sendEnter();
+    if (deps.hook) {
+      if (await deps.hook.wait(CLAUDE_SUBMIT_HOOK_WAIT_MS)) return "hook";
+      const text = await readComposer(deps, PASTE_RENDER_TIMEOUT_MS);
+      if (deps.hook.accepted()) return "hook";
+      if (text === pasted) continue; // provably still pending: another Enter is safe
+      if (await deps.hook.wait(CLAUDE_SUBMIT_LATE_HOOK_WAIT_MS)) return "hook";
+      throw new Error(`Claude prompt submit unconfirmed: no UserPromptSubmit hook after Enter and the composer ${text === null ? "is unreadable" : text === "" ? "emptied" : "changed"}`);
+    }
+    const { verdict } = await settleClaudeComposer(deps, pasted);
+    if (verdict === "empty") return "degraded";
+    if (verdict === "changed") throw new Error("Claude prompt submit unconfirmed: composer changed after Enter; refusing another key");
+    if (verdict === "unreadable") throw new Error("Claude prompt submit unconfirmed: input composer did not settle after Enter");
+  }
+  throw new Error(`Claude prompt submit failed: pasted text remained after ${CLAUDE_SUBMIT_MAX_ENTERS} Enter attempts`);
+}