feat(opencode): add interactive split-footer mode to run (#23557)

packages/opencode/src/cli/cmd/run/runtime.queue.ts

@@ -0,0 +1,293 @@
+// Serial prompt queue for direct interactive mode.
+//
+// Prompts arrive from the footer (user types and hits enter) and queue up
+// here. The queue drains one turn at a time: it appends the user row to
+// scrollback, calls input.run() to execute the turn through the stream
+// transport, and waits for completion before starting the next prompt.
+//
+// The queue also handles /exit, /quit, and /new commands, empty-prompt rejection,
+// and tracks per-turn wall-clock duration for the footer status line.
+//
+// Resolves when the footer closes and all in-flight work finishes.
+import * as Locale from "@/util/locale"
+import { isExitCommand, isNewCommand } from "./prompt.shared"
+import type { FooterApi, FooterEvent, RunPrompt } from "./types"
+
+type Trace = {
+  write(type: string, data?: unknown): void
+}
+
+type Deferred<T = void> = {
+  promise: Promise<T>
+  resolve: (value: T | PromiseLike<T>) => void
+  reject: (error?: unknown) => void
+}
+
+export type QueueInput = {
+  footer: FooterApi
+  initialInput?: string
+  trace?: Trace
+  onSend?: (prompt: RunPrompt) => void
+  onNewSession?: () => void | Promise<void>
+  run: (prompt: RunPrompt, signal: AbortSignal) => Promise<void>
+}
+
+type State = {
+  queue: RunPrompt[]
+  ctrl?: AbortController
+  closed: boolean
+}
+
+function defer<T = void>(): Deferred<T> {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (error?: unknown) => void
+  const promise = new Promise<T>((next, fail) => {
+    resolve = next
+    reject = fail
+  })
+
+  return { promise, resolve, reject }
+}
+
+// Runs the prompt queue until the footer closes.
+//
+// Subscribes to footer prompt events, queues them, and drains one at a
+// time through input.run(). If the user submits multiple prompts while
+// a turn is running, they queue up and execute in order. The footer shows
+// the queue depth so the user knows how many are pending.
+export async function runPromptQueue(input: QueueInput): Promise<void> {
+  const stop = defer<{ type: "closed" }>()
+  const done = defer()
+  const state: State = {
+    queue: [],
+    closed: input.footer.isClosed,
+  }
+  let draining: Promise<void> | undefined
+
+  const emit = (next: FooterEvent, row: Record<string, unknown>) => {
+    input.trace?.write("ui.patch", row)
+    input.footer.event(next)
+  }
+
+  const finish = () => {
+    if (!state.closed || draining) {
+      return
+    }
+
+    done.resolve()
+  }
+
+  const close = () => {
+    if (state.closed) {
+      return
+    }
+
+    state.closed = true
+    state.queue.length = 0
+    state.ctrl?.abort()
+    stop.resolve({ type: "closed" })
+    finish()
+  }
+
+  const drain = () => {
+    if (draining || state.closed || state.queue.length === 0) {
+      return
+    }
+
+    draining = (async () => {
+      try {
+        while (!state.closed && state.queue.length > 0) {
+          const prompt = state.queue.shift()
+          if (!prompt) {
+            continue
+          }
+
+          if (isNewCommand(prompt.text)) {
+            emit(
+              {
+                type: "queue",
+                queue: state.queue.length,
+              },
+              {
+                queue: state.queue.length,
+              },
+            )
+            if (!input.onNewSession) {
+              emit(
+                {
+                  type: "stream.patch",
+                  patch: {
+                    status: "new sessions unavailable",
+                  },
+                },
+                {
+                  status: "new sessions unavailable",
+                },
+              )
+              continue
+            }
+
+            emit(
+              {
+                type: "stream.patch",
+                patch: {
+                  phase: "running",
+                  status: "starting new session",
+                  queue: state.queue.length,
+                },
+              },
+              {
+                phase: "running",
+                status: "starting new session",
+                queue: state.queue.length,
+              },
+            )
+            await input.onNewSession()
+            continue
+          }
+
+          emit(
+            {
+              type: "turn.send",
+              queue: state.queue.length,
+            },
+            {
+              phase: "running",
+              status: "sending prompt",
+              queue: state.queue.length,
+            },
+          )
+          const start = Date.now()
+          const ctrl = new AbortController()
+          state.ctrl = ctrl
+
+          try {
+            await input.footer.idle()
+            if (state.closed) {
+              break
+            }
+
+            const commit = { kind: "user", text: prompt.text, phase: "start", source: "system" } as const
+            input.trace?.write("ui.commit", commit)
+            input.footer.append(commit)
+            input.onSend?.(prompt)
+
+            if (state.closed) {
+              break
+            }
+
+            const task = input.run(prompt, ctrl.signal).then(
+              () => ({ type: "done" as const }),
+              (error) => ({ type: "error" as const, error }),
+            )
+
+            const next = await Promise.race([task, stop.promise])
+            if (next.type === "closed") {
+              ctrl.abort()
+              break
+            }
+
+            if (next.type === "error") {
+              throw next.error
+            }
+          } finally {
+            if (state.ctrl === ctrl) {
+              state.ctrl = undefined
+            }
+
+            const duration = Locale.duration(Math.max(0, Date.now() - start))
+            emit(
+              {
+                type: "turn.duration",
+                duration,
+              },
+              {
+                duration,
+              },
+            )
+          }
+        }
+      } catch (error) {
+        done.reject(error)
+        return
+      } finally {
+        draining = undefined
+        emit(
+          {
+            type: "turn.idle",
+            queue: state.queue.length,
+          },
+          {
+            phase: "idle",
+            status: "",
+            queue: state.queue.length,
+          },
+        )
+      }
+
+      finish()
+    })()
+  }
+
+  const submit = (prompt: RunPrompt) => {
+    if (!prompt.text.trim() || state.closed) {
+      return
+    }
+
+    if (isExitCommand(prompt.text)) {
+      input.footer.close()
+      return
+    }
+
+    state.queue.push(prompt)
+    emit(
+      {
+        type: "queue",
+        queue: state.queue.length,
+      },
+      {
+        queue: state.queue.length,
+      },
+    )
+    if (isNewCommand(prompt.text)) {
+      drain()
+      return
+    }
+
+    emit(
+      {
+        type: "first",
+        first: false,
+      },
+      {
+        first: false,
+      },
+    )
+    drain()
+  }
+
+  const offPrompt = input.footer.onPrompt((prompt) => {
+    submit(prompt)
+  })
+  const offClose = input.footer.onClose(() => {
+    close()
+  })
+
+  try {
+    if (state.closed) {
+      return
+    }
+
+    submit({
+      text: input.initialInput ?? "",
+      parts: [],
+    })
+    finish()
+    await done.promise
+  } finally {
+    offPrompt()
+    offClose()
+    close()
+    await draining?.catch(() => {})
+  }
+}