opencode-queue 0.5.1 → 0.6.1

package/README.md

@@ -7,12 +7,13 @@ This plugin adds a real `/queue` slash command that keeps the current run focuse
 ## What it does
 
 - Queues normal prompts entered while a session is busy
-- Queues slash commands like `/queue /review` and `/queue /commit`
-- Queues shell commands like `/queue !systemctl suspend`
+- 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
-- Replays queued shell commands as shell tool blocks without adding a literal `!command` user message
 - Registers `/queue` as a real OpenCode slash command
 - Shows the current queue with `/queue list`
 - Clears the current queue with `/queue clear`
@@ -39,7 +40,9 @@ While the agent is busy:
 /queue continue after the current task finishes
 /queue /review
 /queue /commit
-/queue !systemctl suspend
+/queue !ls
+continue after the current task finishes /queue
+/review /queue
 /queue list
 /queue clear
 ```
@@ -50,6 +53,8 @@ When the session is idle:
 /queue hello
 /queue /review
 /queue !date
+hello /queue
+/review /queue
 /queue
 ```
 
@@ -59,11 +64,12 @@ Queued items stay hidden while the current run is still working, then replay aut
 
 - 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 a shell tool block.
+- 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.
-- Shell commands do not support attached files.
+- Native shell-mode suffixes like `!command /queue` are not supported because OpenCode handles leading `!` before plugin command hooks run.
 
 ## License
 

package/index.ts

@@ -2,13 +2,16 @@ import type { Plugin } from "@opencode-ai/plugin"
 import type { AgentPartInput, FilePart, FilePartInput, SubtaskPartInput, TextPart, TextPartInput } from "@opencode-ai/sdk"
 
 const QUEUE = /^\/queue(?:\s+([\s\S]*))?$/
+const SUFFIX = /^([\s\S]*?)\s+\/queue\s*$/
 const CMD = /^\/(\S+)(?:\s+([\s\S]*))?$/
 const HANDLED = "__QUEUE_HANDLED__"
 
 type InputPart = TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput
 type Model = { providerID: string; modelID: string }
-type Info = { agent: string; model: Model }
+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 Item =
   | { kind: "prompt"; info: Info; text: string; parts: InputPart[] }
@@ -18,7 +21,7 @@ type Item =
 type Op =
   | { kind: "list" }
   | { kind: "clear" }
-  | { kind: "invalid"; message: string; warn?: string }
+  | { kind: "invalid"; text: string }
   | { kind: "prompt"; text: string; body: string }
   | { kind: "command"; text: string; cmd: string; args: string }
   | { kind: "shell"; text: string; shell: string }
@@ -37,8 +40,8 @@ const parse = (body: string, files = 0): Op => {
 
   if (text.startsWith("!")) {
     const shell = text.slice(1).trim()
-    if (!shell) return { kind: "invalid", message: "Queue shell command is empty" }
-    if (files) return { kind: "invalid", message: "Queued shell commands do not support attachments", warn: "QueuePlugin skipped shell command attachments" }
+    if (!shell) return { kind: "invalid", text: "Queue shell command is empty" }
+    if (files) return { kind: "invalid", text: "Queued shell commands do not support attachments" }
     return { kind: "shell", text, shell }
   }
 
@@ -47,6 +50,10 @@ const parse = (body: string, files = 0): Op => {
   return { kind: "prompt", text: label(body, files), body }
 }
 
+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)
+
 export const QueuePlugin: Plugin = async ({ client }) => {
   const queue = new Map<string, Item[]>()
   const hidden = new Set<string>()
@@ -66,9 +73,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     Object.assign(part, { text: "", synthetic: true, ignored: true })
   }
 
-  const warn = (op: Extract<Op, { kind: "invalid" }>) => op.warn && console.warn(op.warn)
-
-  const files = (parts: { type: string }[]) => parts.flatMap((part) => (part.type === "file" ? [{ ...(part as FilePart) }] : []))
+  const files = (parts: { type: string }[]) => parts.filter((part): part is FilePart => part.type === "file").map((part) => ({ ...part }))
 
   const manage = (sid: string, op: Extract<Op, { kind: "list" | "clear" }>) => {
     if (op.kind === "list") return (queue.get(sid) ?? []).map((item, i) => `${i + 1}. ${item.text}`).join("\n") || "Queue is empty"
@@ -78,38 +83,43 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     return count ? `Cleared ${count} queued item${count === 1 ? "" : "s"}` : "Queue is empty"
   }
 
-  const latest = async (sid: string): Promise<Run> => {
+  const latest = async (sid: string): Promise<Info | undefined> => {
     const result = await client.session.messages({ path: { id: sid }, query: { limit: 100 } }).catch((error) => {
-      console.warn("QueuePlugin could not inspect session messages for shell replay", error)
+      console.warn("QueuePlugin could not inspect session messages for queued placeholder metadata", error)
       return []
     })
 
-    for (const msg of [...(Array.isArray(result) ? result : (result.data ?? []))].reverse()) {
-      if (msg.info.role === "user") return { agent: msg.info.agent, model: msg.info.model }
-      if (msg.info.role === "assistant") return { agent: msg.info.mode, model: { providerID: msg.info.providerID, modelID: msg.info.modelID } }
+    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 }
+      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 undefined
+  }
+
+  const run = async (sid: string): Promise<Run> => {
+    const info = await latest(sid)
+    if (info) return info
     console.warn("QueuePlugin shell replay fell back to the build agent because the session has no message context")
     return { agent: "build" }
   }
 
-  const visible = (sid: string, text: string, info?: Info, parts: FilePartInput[] = []) =>
-    client.session.prompt({
-      path: { id: sid },
-      body: { agent: info?.agent, model: info?.model, noReply: true, parts: [{ type: "text", text }, ...parts] },
-    })
+  const opts = (info: Info) => ({ agent: info.agent, model: info.model, variant: info.variant, controls: info.controls, fast: info.fast })
 
-  const shell = (sid: string, command: string, run: Run) => client.session.shell({ path: { id: sid }, body: { ...run, command } })
+  const prompt = (sid: string, info: Info, parts: InputPart[], noReply?: boolean) => client.session.prompt({ path: { id: sid }, body: { ...opts(info), noReply, parts } as any })
+  const shell = (sid: string, command: string, info: Run) => client.session.shell({ path: { id: sid }, body: { agent: info.agent, model: info.model, command } })
 
   const replay = async (sid: string, item: Item) => {
     if (item.kind === "shell") return shell(sid, item.shell, item.info)
 
     if (item.kind === "command") {
-      await visible(sid, item.text, item.info, item.files)
+      await prompt(sid, item.info, [{ type: "text", text: item.text }, ...item.files], true)
       await client.session.command({
         path: { id: sid },
         body: {
-          agent: item.info.agent,
+          ...opts(item.info),
           model: `${item.info.model.providerID}/${item.info.model.modelID}`,
           command: item.cmd,
           arguments: item.args,
@@ -120,10 +130,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
     }
 
     if (item.parts.length) {
-      return client.session.prompt({
-        path: { id: sid },
-        body: { agent: item.info.agent, model: item.info.model, parts: item.parts.map((part) => ({ ...part, id: undefined })) },
-      })
+      return prompt(sid, item.info, item.parts.map((part) => ({ ...part, id: undefined })))
     }
     console.warn("QueuePlugin skipped queued item without replayable content")
   }
@@ -163,48 +170,59 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       await flush(sid)
     },
     "command.execute.before": async (input, output) => {
-      if (input.command !== "queue") return
-
       const sid = input.sessionID
       const body = input.arguments ?? ""
-      const found = files(output.parts)
-      const op = parse(body, found.length)
+      const parts = files(output.parts)
 
-      if (op.kind === "list" || op.kind === "clear") return stop(manage(sid, op))
-      if (op.kind === "invalid") {
-        warn(op)
-        return stop(op.message, "error")
+      if (input.command !== "queue") {
+        const args = trailing(body)
+        if (args === undefined) return
+
+        if (!busy.has(sid)) {
+          for (const part of output.parts) if (part.type === "text") part.text = strip(part.text)
+          return
+        }
+
+        output.parts.length = 0
+        output.parts.push({ type: "text", text: `/queue /${input.command}${args.trim() ? ` ${args.trim()}` : ""}` } as any, ...parts)
+        return
       }
 
+      const op = parse(body, parts.length)
+
+      if (op.kind === "list" || op.kind === "clear") return stop(manage(sid, op))
+      if (op.kind === "invalid") return stop(op.text, "error")
+
       if (!busy.has(sid)) {
         if (op.kind === "shell") {
-          await shell(sid, op.shell, await latest(sid))
+          await shell(sid, op.shell, await run(sid))
           throw new Error(HANDLED)
         }
 
         if (op.kind === "command") {
-          await visible(sid, op.text, undefined, found)
-          await client.session.command({ path: { id: sid }, body: { command: op.cmd, arguments: op.args, parts: found } as any })
+          await client.session.prompt({ path: { id: sid }, body: { noReply: true, parts: [{ type: "text", text: op.text }, ...parts] } })
+          await client.session.command({ path: { id: sid }, body: { command: op.cmd, arguments: op.args, parts } as any })
           throw new Error(HANDLED)
         }
 
         output.parts.length = 0
-        output.parts.push({ type: "text", text: op.body } as any, ...found)
+        output.parts.push({ type: "text", text: op.body } as any, ...parts)
         return
       }
 
       output.parts.length = 0
-      output.parts.push({ type: "text", text: `/queue ${body}` } as any, ...found)
+      output.parts.push({ type: "text", text: `/queue ${body}` } as any, ...parts)
     },
-    "chat.message": async ({ sessionID: sid }, output) => {
+    "chat.message": async (input, output) => {
+      const sid = input.sessionID
       const text = output.parts.find((part): part is TextPart => part.type === "text" && !part.synthetic)
       if (!text) return
 
-      const body = text.text.match(QUEUE)?.[1]
+      const body = queued(text.text)
       if (body === undefined) return
 
-      const found = files(output.parts)
-      const op = parse(body, found.length)
+      const parts = files(output.parts)
+      const op = parse(body, parts.length)
 
       if (op.kind === "list" || op.kind === "clear") {
         hide(output.message.id, text)
@@ -214,18 +232,26 @@ export const QueuePlugin: Plugin = async ({ client }) => {
 
       if (op.kind === "invalid") {
         hide(output.message.id, text)
-        warn(op)
-        await toast(op.message, "error")
+        await toast(op.text, "error", 5000)
         return
       }
 
       if (!busy.has(sid)) {
         if (op.kind === "command") return
+        if (op.kind === "shell") {
+          hide(output.message.id, text)
+          await shell(sid, op.shell, { agent: output.message.agent, model: output.message.model })
+          return
+        }
         text.text = body
         return
       }
 
-      const info = { agent: output.message.agent, model: { ...output.message.model } }
+      const meta = input as Meta
+      const info = { agent: output.message.agent, model: { ...output.message.model }, variant: meta.variant, controls: meta.controls, fast: meta.fast }
+      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 }]
@@ -233,7 +259,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
           console.warn("QueuePlugin skipped unexpected part", part.type)
           return []
         })
-      const item: Item = op.kind === "shell" ? { ...op, info } : op.kind === "command" ? { ...op, info, files: found } : { ...op, info, parts: inputParts() }
+      const item: Item = op.kind === "shell" ? { ...op, info } : op.kind === "command" ? { ...op, info, files: parts } : { ...op, info, parts: inputParts() }
 
       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.5.1",
+  "version": "0.6.1",
   "type": "module",
   "description": "Queue OpenCode prompts and slash commands until the agent is idle",
   "main": "./index.ts",