@threadbase-sh/streamer 1.70.1 → 1.70.2

package/dist/index.cjs

@@ -9877,6 +9877,58 @@ var PromptRegistry = class {
     this.publish(entry);
     return copyPrompt(entry.prompt);
   }
+  /**
+   * The provider's prompt left the screen.
+   *
+   * Distinct from `transition` because the detector cannot tell a teardown it
+   * observed on its own from one OUR OWN write caused. On a screen-scraped gate
+   * the answer keys remove the box, and pty-manager's sendKeys fires the close
+   * synchronously from inside the write — so the close always arrives before
+   * the answer that caused it has settled, and reporting it as a cancel failed
+   * every answer whose bytes had already landed (#720).
+   *
+   * While an answer is writing, the close is deferred and the answer decides:
+   * `resolved` if the write landed, the deferred close if it did not. Success
+   * is the adapter's own result, never the prompt's absence from the screen —
+   * a prompt that does not vanish when answered (a multi-select form) simply
+   * never reaches here, and is settled by the same adapter result (#721).
+   *
+   * ONLY this path defers. `replaced` from a different gate taking the screen,
+   * `unavailable` from invalidateSession and `expired` all still go through
+   * `transition` and still win, because none of them was caused by our write.
+   */
+  providerClosed(promptId, reason) {
+    const entry = this.byId.get(promptId);
+    if (!entry) return null;
+    if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") return null;
+    if (entry.answering) {
+      entry.deferredClose = reason;
+      return null;
+    }
+    return this.transition(promptId, "cancelled", reason);
+  }
+  /**
+   * Run a provider write that may close the prompt as a side effect, so the
+   * close it causes is deferred rather than applied. For callers outside this
+   * class that write without going through `answer()` — the legacy permission
+   * route. `performAnswer` manages the same two fields directly, because it
+   * needs the deferred value in its own control flow.
+   *
+   * The write's own failure needs no unwinding here: pty-manager fires the
+   * close as the last statement of a successful sendKeys, so a throw means no
+   * close was ever deferred and the record is still open for the caller.
+   */
+  whileAnswering(promptId, write) {
+    const entry = this.byId.get(promptId);
+    if (!entry) return write();
+    entry.answering = true;
+    try {
+      return write();
+    } finally {
+      entry.answering = false;
+      entry.deferredClose = void 0;
+    }
+  }
   invalidateSession(sessionId, reason = "session_ended") {
     const transitioned = [];
     for (const entry of this.bySession.get(sessionId)?.values() ?? []) {
@@ -9954,21 +10006,33 @@ var PromptRegistry = class {
     const responseError = this.validateResponses(prompt, answer);
     if (responseError) return { ok: false, code: responseError };
     if (!entry.adapter) return { ok: false, code: "prompt_unavailable" };
+    entry.answering = true;
     let adapterResult;
+    let threw = false;
     try {
       adapterResult = await entry.adapter({ prompt: copyPrompt(prompt), answer });
     } catch {
-      return { ok: false, code: "provider_error" };
+      threw = true;
+      adapterResult = { ok: false, code: "provider_error" };
+    } finally {
+      entry.answering = false;
     }
+    const deferred = entry.deferredClose;
+    entry.deferredClose = void 0;
+    const settle = (outcome) => {
+      if (deferred) this.providerClosed(prompt.promptId, deferred);
+      return outcome;
+    };
+    if (threw) return settle({ ok: false, code: "provider_error" });
     if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") {
-      return { ok: false, code: terminalError(entry.prompt.state) };
+      return settle({ ok: false, code: terminalError(entry.prompt.state) });
     }
     if (entry.prompt.revision !== answer.revision) {
-      return {
+      return settle({
         ok: false,
         code: "prompt_revision_mismatch",
         currentRevision: entry.prompt.revision
-      };
+      });
     }
     if (!adapterResult.ok) {
       if (adapterResult.terminal) {
@@ -9978,7 +10042,7 @@ var PromptRegistry = class {
           adapterResult.terminal.reason
         );
       }
-      return { ok: false, code: adapterResult.code };
+      return settle({ ok: false, code: adapterResult.code });
     }
     return { ok: true, prompt: this.transition(prompt.promptId, "resolved", "answered") };
   }
@@ -11189,10 +11253,7 @@ var SessionHandlers = class {
     if (gate === null) {
       const prior2 = this.pendingPermission.get(sessionId);
       if (!prior2) return;
-      const prompt2 = prior2.promptId ? this.promptRegistry.get(prior2.promptId) : null;
-      if (prompt2?.state === "open" || prompt2?.state === "updated") {
-        this.promptRegistry.transition(prompt2.promptId, "cancelled", "provider_closed");
-      }
+      if (prior2.promptId) this.promptRegistry.providerClosed(prior2.promptId, "provider_closed");
       this.pendingPermission.delete(sessionId);
       this.pendingPermissionKey.delete(sessionId);
       this.broadcastToSession(sessionId, { type: "permission_cancelled", sessionId });
@@ -11417,7 +11478,13 @@ var SessionHandlers = class {
       return;
     }
     try {
-      this.ptyManager.sendKeys(sessionId, option.answerKeys ?? permissionAnswerKeys(option.index));
+      this.promptRegistry.whileAnswering(
+        gate.promptId ?? "",
+        () => this.ptyManager.sendKeys(
+          sessionId,
+          option.answerKeys ?? permissionAnswerKeys(option.index)
+        )
+      );
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to send answer";
       json(res, 400, { ok: false, reason: message });