opencode-queue 0.6.2 → 0.6.4

package/README.md

@@ -1,26 +1,16 @@
 # opencode-queue
 
-Queue OpenCode input until the current agent run is actually idle.
+[![npm version](https://img.shields.io/npm/v/opencode-queue?color=cb3837)](https://www.npmjs.com/package/opencode-queue)
+[![CI](https://github.com/mirsella/opencode-queue/actions/workflows/ci.yml/badge.svg)](https://github.com/mirsella/opencode-queue/actions/workflows/ci.yml)
+[![npm downloads](https://img.shields.io/npm/dm/opencode-queue)](https://www.npmjs.com/package/opencode-queue)
 
-This plugin adds a real `/queue` slash command that keeps the current run focused instead of injecting your next message into the still-running loop.
+Queue OpenCode input until the current session is idle.
 
-## What it does
-
-- Queues normal prompts entered while a session is busy
-- Queues prompts with either `/queue prompt` or `prompt /queue`
-- Queues slash commands with either `/queue /review` or `/review /queue`
-- Queues shell commands with `/queue !ls`
-- Hides queued placeholders from both the UI transcript and the running agent
-- Preserves the selected agent, model, and thinking variant for queued input
-- Replays queued input in order once the session becomes idle
-- Replays queued commands as a visible `/command` message before executing them
-- Registers `/queue` as a real OpenCode slash command
-- Shows the current queue with `/queue list`
-- Clears the current queue with `/queue clear`
+`opencode-queue` adds a real `/queue` slash command. It lets you type the next prompt, slash command, or shell command while an agent is still working, without interrupting the current run.
 
 ## Install
 
-Add it to your OpenCode plugin list:
+Add the plugin to your OpenCode config:
 
 ```jsonc
 {
@@ -28,49 +18,68 @@ Add it to your OpenCode plugin list:
 }
 ```
 
-OpenCode installs npm plugins automatically at startup.
-
-Restart OpenCode after installing.
-
-## Usage
+Restart OpenCode after installing. OpenCode installs npm plugins automatically at startup.
 
-While the agent is busy:
+## Quick Examples
 
 ```text
-/queue continue after the current task finishes
+/queue continue after this task
+continue after this task /queue
+
 /queue /review
-/queue /commit
-/queue !ls
-continue after the current task finishes /queue
 /review /queue
+
+/queue !ls
+
 /queue list
 /queue clear
 ```
 
+## Syntax
+
+| Input | What it does |
+| --- | --- |
+| `/queue message` | Queue a normal prompt. |
+| `message /queue` | Queue a normal prompt using trailing syntax. |
+| `/queue /review` | Queue a slash command. |
+| `/review /queue` | Queue a slash command using trailing syntax. |
+| `/queue !ls` | Queue an OpenCode shell block. |
+| `/queue` | Show the current queue. |
+| `/queue list` | Show the current queue. |
+| `/queue clear` | Clear the current queue. |
+
+## Behavior
+
+When the session is busy:
+
+- Queued entries are hidden from the transcript and from the running agent.
+- The current agent run keeps using its original agent, model, and thinking variant.
+- Queued entries replay in order after the session becomes idle.
+- Only one queued entry is sent per idle transition, so queued work runs one item at a time.
+
 When the session is idle:
 
+- `/queue message` sends `message` immediately.
+- `message /queue` sends `message` immediately.
+- `/queue /review` runs `/review` immediately.
+- `/review /queue` runs `/review` immediately.
+- `/queue !ls` runs `ls` immediately as an OpenCode shell block.
+- `/queue` and `/queue list` show the current queue.
+- `/queue clear` clears the current queue.
+
+## Queue Management
+
 ```text
-/queue hello
-/queue /review
-/queue !date
-hello /queue
-/review /queue
 /queue
+/queue list
+/queue clear
 ```
 
-Queued items stay hidden while the current run is still working, then replay automatically when the session becomes idle.
+The queue is in-memory and scoped to the current session.
 
 ## Notes
 
-- This is a `/queue` plugin, not a keyboard shortcut plugin. OpenCode plugins cannot currently register custom TUI keybindings.
-- Idle `/queue some text` is treated like a normal prompt with the `/queue` prefix removed.
-- Idle `some text /queue` and `/command /queue` run immediately with the trailing `/queue` removed.
-- Idle `/queue /command` immediately runs the nested command.
-- Idle `/queue !command` immediately runs the shell command as an OpenCode shell block.
-- `/queue` and `/queue list` show the in-memory queue for the current session.
-- `/queue clear` drops all currently queued items for the current session.
-- Native shell-mode suffixes like `!command /queue` are not supported because OpenCode handles leading `!` before plugin command hooks run.
-
-## License
-
-MIT
+- This plugin registers `/queue` as a real OpenCode slash command.
+- It does not add a keyboard shortcut. OpenCode plugins cannot currently register custom TUI keybindings.
+- Queued placeholders are hidden instead of deleted, then filtered out before messages are sent to the model.
+- If plan mode asks to switch to the build agent while more queued work is waiting, the plugin answers `No` so the queue can continue.

package/index.ts

@@ -12,6 +12,8 @@ type Meta = { variant?: string; controls?: string[]; fast?: boolean }
 type Run = { agent: string; model?: Model }
 type Info = { agent: string; model: Model } & Meta
 type Msg = { info: { role: string; agent?: string; mode?: string; model?: Model; providerID?: string; modelID?: string } & Meta }
+type Ask = { type: string; properties: { id: string; sessionID: string; questions: { question: string; header: string }[] } }
+type Post = (input: { url: string; path?: Record<string, string>; body?: unknown; headers?: Record<string, string> }) => Promise<{ response?: Response; error?: unknown } | undefined>
 
 type Item =
   | { kind: "prompt"; info: Info; text: string; parts: InputPart[] }
@@ -53,12 +55,18 @@ const parse = (body: string, files = 0): Op => {
 const trailing = (text: string) => (text.trim() === "/queue" ? "" : text.match(SUFFIX)?.[1])
 const strip = (text: string) => trailing(text) ?? text
 const queued = (text: string) => text.match(QUEUE)?.[1] ?? trailing(text)
+const plan = (event: unknown): event is Ask => {
+  if (typeof event !== "object" || !event || !("type" in event) || event.type !== "question.asked") return false
+  const question = (event as Ask).properties?.questions?.[0]
+  return question?.header === "Build Agent" && question.question.includes("switch to the build agent")
+}
 
 export const QueuePlugin: Plugin = async ({ client }) => {
   const queue = new Map<string, Item[]>()
   const hidden = new Set<string>()
   const busy = new Set<string>()
-  const flushing = new Set<string>()
+  const active = new Set<string>()
+  const post = (client as unknown as { _client?: { post?: Post } })._client?.post
 
   const toast = (message: string, variant: "info" | "error", duration = 2500) =>
     client.tui.showToast({ body: { message, variant, duration } }).catch(() => undefined)
@@ -68,6 +76,19 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     throw new Error(HANDLED)
   }
 
+  const no = async (id: string) => {
+    if (!post) {
+      console.warn("QueuePlugin cannot answer plan prompt because the SDK client has no internal request method")
+      return
+    }
+
+    const result = await post({ url: "/question/{requestID}/reply", path: { requestID: id }, body: { answers: [["No"]] } }).catch((error) => {
+      console.warn("QueuePlugin failed to answer plan prompt", error)
+      return undefined
+    })
+    if (!result?.response?.ok) console.warn("QueuePlugin failed to answer plan prompt", result?.error ?? result?.response?.status)
+  }
+
   const hide = (id: string, part: TextPart) => {
     hidden.add(id)
     Object.assign(part, { text: "", synthetic: true, ignored: true })
@@ -89,14 +110,13 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       return []
     })
 
-    for (const msg of [...(Array.isArray(result) ? result : (result.data ?? []))].reverse() as Msg[]) {
-      if (msg.info.role === "user" && msg.info.agent && msg.info.model) return { agent: msg.info.agent, model: msg.info.model, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }
+    return ([...(Array.isArray(result) ? result : (result.data ?? []))].reverse() as Msg[]).flatMap((msg): Info[] => {
+      if (msg.info.role === "user" && msg.info.agent && msg.info.model) return [{ agent: msg.info.agent, model: msg.info.model, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }]
       if (msg.info.role === "assistant" && (msg.info.agent || msg.info.mode) && msg.info.providerID && msg.info.modelID) {
-        return { agent: msg.info.agent ?? msg.info.mode!, model: { providerID: msg.info.providerID, modelID: msg.info.modelID }, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }
+        return [{ agent: msg.info.agent ?? msg.info.mode!, model: { providerID: msg.info.providerID, modelID: msg.info.modelID }, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }]
       }
-    }
-
-    return undefined
+      return []
+    })[0]
   }
 
   const run = async (sid: string): Promise<Run> => {
@@ -135,21 +155,20 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     console.warn("QueuePlugin skipped queued item without replayable content")
   }
 
-  const flush = async (sid: string) => {
+  const flush = (sid: string) => {
     const list = queue.get(sid)
-    if (flushing.has(sid) || !list?.length) return
+    if (!list?.length) return
+    const item = list.shift()
+    if (!item) return
+    if (!list.length) queue.delete(sid)
 
-    flushing.add(sid)
-    try {
-      await replay(sid, list.shift()!)
-    } catch (error) {
+    active.add(sid)
+    void replay(sid, item).catch(async (error) => {
       console.error("QueuePlugin failed to flush queued input", error)
       await toast(`Queue failed: ${error instanceof Error ? error.message : String(error)}`, "error")
-    } finally {
-      if (list.length) queue.set(sid, list)
-      else queue.delete(sid)
-      flushing.delete(sid)
-    }
+    }).finally(() => {
+      active.delete(sid)
+    })
   }
 
   return {
@@ -158,6 +177,14 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       cfg.command.queue = { template: "", description: "Queue input until the session is idle" }
     },
     event: async ({ event }) => {
+      if (plan(event)) {
+        const sid = event.properties.sessionID
+        if (!active.has(sid) && !queue.get(sid)?.length) return
+        await no(event.properties.id)
+        await toast("Declined plan approval to continue queued work", "info")
+        return
+      }
+
       if (event.type !== "session.status") return
 
       const sid = event.properties.sessionID
@@ -167,7 +194,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       }
 
       busy.delete(sid)
-      await flush(sid)
+      flush(sid)
     },
     "command.execute.before": async (input, output) => {
       const sid = input.sessionID
@@ -183,8 +210,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
           return
         }
 
-        output.parts.length = 0
-        output.parts.push({ type: "text", text: `/queue /${input.command}${args.trim() ? ` ${args.trim()}` : ""}` } as any, ...parts)
+        output.parts.splice(0, output.parts.length, { type: "text", text: `/queue /${input.command}${args.trim() ? ` ${args.trim()}` : ""}` } as any, ...parts)
         return
       }
 
@@ -205,13 +231,11 @@ export const QueuePlugin: Plugin = async ({ client }) => {
           throw new Error(HANDLED)
         }
 
-        output.parts.length = 0
-        output.parts.push({ type: "text", text: op.body } as any, ...parts)
+        output.parts.splice(0, output.parts.length, { type: "text", text: op.body } as any, ...parts)
         return
       }
 
-      output.parts.length = 0
-      output.parts.push({ type: "text", text: `/queue ${body}` } as any, ...parts)
+      output.parts.splice(0, output.parts.length, { type: "text", text: `/queue ${body}` } as any, ...parts)
     },
     "chat.message": async (input, output) => {
       const sid = input.sessionID
@@ -252,14 +276,19 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       const prior = await latest(sid)
       if (prior) Object.assign(output.message, opts(prior))
       else console.warn("QueuePlugin could not neutralize queued placeholder metadata because the session has no previous message context")
-      const inputParts = () =>
-        output.parts.flatMap((part): InputPart[] => {
-          if (part.type === "text") return part.id === text.id ? (body ? [{ ...part, text: body }] : []) : [{ ...part }]
-          if (part.type === "file" || part.type === "agent" || part.type === "subtask") return [{ ...part }]
-          console.warn("QueuePlugin skipped unexpected part", part.type)
-          return []
-        })
-      const item: Item = op.kind === "shell" ? { ...op, info } : op.kind === "command" ? { ...op, info, files: parts } : { ...op, info, parts: inputParts() }
+      const item: Item =
+        op.kind === "shell" ? { ...op, info } :
+        op.kind === "command" ? { ...op, info, files: parts } :
+        {
+          ...op,
+          info,
+          parts: output.parts.flatMap((part): InputPart[] => {
+            if (part.type === "text") return part.id === text.id ? (body ? [{ ...part, text: body }] : []) : [{ ...part }]
+            if (part.type === "file" || part.type === "agent" || part.type === "subtask") return [{ ...part }]
+            console.warn("QueuePlugin skipped unexpected part", part.type)
+            return []
+          }),
+        }
 
       queue.set(sid, [...(queue.get(sid) ?? []), item])
       hide(output.message.id, text)

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-queue",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "type": "module",
   "description": "Queue OpenCode prompts and slash commands until the agent is idle",
   "main": "./index.ts",