@khalilgharbaoui/opencode-claude-code-plugin 0.42.2 → 0.42.3

package/dist/index.js

@@ -5862,6 +5862,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "stale scratch directory sweep failed",
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
+  "the interactive turn did not take a forwarded user message",
   "this opencode process is running an older plugin build than the one on disk",
   "timed out pending proxy call",
   "turn abort listener threw",
@@ -8999,6 +9000,9 @@ var ClaudeSession = class {
    *  (the TUI repaints it while it takes the key, measured on 2.1.288) can
    *  never stand in for the next call's dialog. */
   planDialog = null;
+  /** `queue-operation` enqueue records read, which is how `queueInput` knows
+   *  the TUI took a message into the running turn. */
+  enqueued = 0;
   /** This turn's `ExitPlanMode` calls already answered. */
   answeredPlans = /* @__PURE__ */ new Set();
   abandonTurn = false;
@@ -9057,7 +9061,9 @@ var ClaudeSession = class {
       // The decision arrives after opencode's own question round trip, by
       // which time the dialog has long been drawn; this only bounds a TUI
       // that never draws it.
-      planDialogWaitMs: opts.planDialogWaitMs ?? 3e4
+      planDialogWaitMs: opts.planDialogWaitMs ?? 3e4,
+      // 100 times the longest silence measured while Claude works (h #g207).
+      idleEndMs: opts.idleEndMs ?? 2e4
     };
   }
   /** The CLI arguments this session spawns with. */
@@ -9335,7 +9341,8 @@ var ClaudeSession = class {
         end: null,
         sawUserRecord: false,
         lastBeat: Date.now(),
-        awaitingOwnPrompt: this.forkPending ? normalizedPrompt(prompt) : null
+        awaitingOwnPrompt: this.forkPending ? normalizedPrompt(prompt) : null,
+        sawReply: false
       };
       this.forkPending = false;
       this.scan = scan;
@@ -9358,6 +9365,9 @@ var ClaudeSession = class {
         if (scan.stopReason && Date.now() - scan.stopSeenAt >= this.o.stopSettleMs) {
           return { stopReason: scan.stopReason, end: "stop", denied: this.turnDenied };
         }
+        if (scan.sawReply && !this.planApprovalToolUseId && Date.now() - this.lastDataAt >= this.o.idleEndMs && Date.now() - scan.stopSeenAt >= this.o.idleEndMs) {
+          return { stopReason: null, end: "ended", denied: this.turnDenied };
+        }
         if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
         if (this.abandonTurn) return { stopReason: null, end: "interrupted", denied: this.turnDenied };
         const now = Date.now();
@@ -9407,9 +9417,11 @@ var ClaudeSession = class {
         scan.awaitingOwnPrompt = null;
       }
       if (rec) this.notePlanApproval(rec);
+      if (rec?.type === "queue-operation" && rec.operation === "enqueue") this.enqueued++;
       scan.onRecord(s, rec);
       if (rec) {
         if (rec.type === "assistant" && rec.message) {
+          scan.sawReply = true;
           const reason = rec.message.stop_reason;
           if (typeof reason === "string") {
             scan.stopReason = TERMINAL_STOP.has(reason) ? reason : null;
@@ -9498,6 +9510,29 @@ var ClaudeSession = class {
     this.write("\r");
     return true;
   }
+  /**
+   * Type a message into the running turn's own input queue, not as a turn of
+   * its own (h #g206). Measured on 2.1.288: text pasted and submitted while a
+   * tool call runs is recorded as `queue-operation` enqueue and remove plus a
+   * `queued_command` attachment, answered in the same turn, which still ends
+   * once. Resolves true once the enqueue is in the transcript; false with no
+   * turn running, or with a plan approval dialog up, which would take the
+   * keys as its answer.
+   */
+  async queueInput(text, timeoutMs = 3e3) {
+    if (!this.turn || !this.proc || this.exited || this.pendingPlanApproval) return false;
+    const before = this.enqueued;
+    this.write(this.o.bracketedPaste ? "\x1B[200~" + text + "\x1B[201~" : text);
+    await delay(this.o.submitMinMs);
+    this.write("\r");
+    const deadline = Date.now() + timeoutMs;
+    while (this.enqueued === before) {
+      if (!this.turn || this.exited || Date.now() >= deadline) return false;
+      await delay(this.o.pollMs);
+      this.scanTranscript();
+    }
+    return true;
+  }
   /** Wait until the PTY has been quiet for `permissionQuietMs`, at most 3 s. */
   async waitForQuiet() {
     const until = Date.now() + 3e3;
@@ -10123,6 +10158,13 @@ function spawnInteractiveProcess(opts) {
       },
       flushTranscript: () => session.flushTranscript(),
       planApprovalPending: () => session.pendingPlanApproval !== null,
+      // Text only: an image in a mid-call message is dropped with the
+      // decoder's own warning rather than staged for a turn that is not ours.
+      queueInput: async (content) => {
+        const text = decodeUserEnvelope(JSON.stringify({ type: "user", message: { role: "user", content } })).trim();
+        if (!text) return false;
+        return session.queueInput(text);
+      },
       askAside
     }
   };
@@ -14332,9 +14374,10 @@ var ClaudeCodeLanguageModel = class {
           state.proc.on("error", procErrorHandler);
           if (hasMatchedPendingResults) {
             state.cliAskedForWork = true;
-            const forwardTrailingUserMessages = () => {
+            const forwardTrailingUserMessages = async () => {
               if (compactionMode || !state.activeProcess) return 0;
-              if (state.activeProcess.interactiveControl) return 0;
+              const control = state.activeProcess.interactiveControl;
+              if (control && (!control.queueInput || !control.turnRunning())) return 0;
               const trailing = getTrailingUserMessages(effectivePrompt, {
                 stripContextReminders: self.stripContextRemindersEnabled()
               });
@@ -14345,6 +14388,21 @@ var ClaudeCodeLanguageModel = class {
                 assistantIndex: trailing.assistantIndex,
                 count: trailing.messages.length
               };
+              if (control) {
+                let queued = 0;
+                for (const content of fresh) if (await control.queueInput(content)) queued++;
+                if (queued < fresh.length) {
+                  log.warn("the interactive turn did not take a forwarded user message", {
+                    sessionKey: sk,
+                    messages: fresh.length - queued
+                  });
+                }
+                log.info("forwarded user messages into the interactive turn's input queue", {
+                  sessionKey: sk,
+                  messages: queued
+                });
+                return queued;
+              }
               for (const content of fresh) {
                 state.proc.stdin?.write(
                   JSON.stringify({ type: "user", message: { role: "user", content } }) + "\n"
@@ -14356,7 +14414,7 @@ var ClaudeCodeLanguageModel = class {
               });
               return fresh.length;
             };
-            if (!state.unattendedTurnEnded && forwardTrailingUserMessages() > 0) {
+            if (!state.unattendedTurnEnded && await forwardTrailingUserMessages() > 0) {
               await new Promise((resolve6) => setTimeout(resolve6, FORWARD_SETTLE_MS));
               if (state.controllerClosed) return;
             }
@@ -14391,7 +14449,7 @@ var ClaudeCodeLanguageModel = class {
             }
             if (state.unattendedTurnEnded) {
               deliverPendingCompletions(state);
-              forwardTrailingUserMessages();
+              await forwardTrailingUserMessages();
             }
             const unemitted = getPendingProxyCalls(sk).filter(
               (call) => !call.emitted