opencode-queue 0.12.2 → 0.13.1

package/README.md

@@ -6,7 +6,7 @@
 
 Queue OpenCode input until the current session is idle.
 
-`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.
+`opencode-queue` adds `/queue` and its shorter `/q` alias. It lets you type the next prompt, slash command, or shell command while an agent is still working, without interrupting the current run.
 
 ## Install
 
@@ -23,10 +23,11 @@ Restart OpenCode after installing. OpenCode installs npm plugins automatically a
 ## Quick Examples
 
 ```text
-/queue continue after this task
+/q continue after this task
 continue after this task /queue
 /queue front do this next
 do this next /queue front
+/queue now send this immediately
 
 /queue /review
 /review /queue
@@ -50,12 +51,15 @@ do this next /queue front
 
 ## Syntax
 
+`/q` is accepted anywhere `/queue` is shown.
+
 | Input | What it does |
 | --- | --- |
 | `/queue message` | Queue a normal prompt. |
 | `message /queue` | Queue a normal prompt using trailing syntax. |
 | `/queue front message` | Queue a normal prompt before existing queued entries. |
 | `message /queue front` | Queue a normal prompt before existing queued entries using trailing syntax. |
+| `/queue now input` | Send a prompt or slash command immediately. Shell commands still wait until the session is idle. |
 | `/queue /review` | Queue a slash command. |
 | `/review /queue` | Queue a slash command using trailing syntax. |
 | `/queue front /review` | Queue a slash command before existing queued entries. |
@@ -68,6 +72,9 @@ do this next /queue front
 | `/queue list` | Show the current queue. |
 | `/queue stop` | Pause automatic sending of queued entries. |
 | `/queue start` | Resume automatic sending of queued entries. |
+| `/queue always` | Show whether automatic queueing is enabled globally. |
+| `/queue always on` | Enable automatic queueing in every project. |
+| `/queue always off` | Disable automatic queueing in every project. |
 | `/queue flush` | Send all queued entries immediately. |
 | `/queue clear` | Clear the current queue. |
 | `/queue clear 1` | Clear item 1 from the current queue. |
@@ -82,9 +89,11 @@ When the session is busy:
 - Each queued entry replays with the agent, model, and thinking variant selected when it was queued.
 - Queued entries replay in order after the session completes normally and becomes idle.
 - `/queue front ...` puts an entry before the existing queued entries.
+- `/queue now ...` sends prompts and slash commands immediately regardless of queue state or mode. Shell commands remain queued until the session is idle.
 - Only one queued entry is sent per idle transition, so queued work runs one item at a time.
 - Queued entries are kept in place after an error, abort, crash, or restart.
 - `/queue stop` pauses automatic replay without clearing queued entries, and `/queue start` resumes it.
+- `/queue always on` also queues plain prompts and custom slash commands while the session is busy, paused, or already has queued work. OpenCode does not expose native shell or `/compact` submissions to these plugin hooks.
 - `/queue flush` sends all queued entries immediately in one batch, even before the session is idle.
 
 When the session is idle:
@@ -100,24 +109,10 @@ When the session is idle:
 - `/queue flush` sends all queued entries immediately in one batch.
 - `/queue clear` clears the current queue, and `/queue clear 1` clears a specific queued item.
 
-## Queue Management
-
-```text
-/queue
-/queue list
-/queue stop
-/queue start
-/queue flush
-/queue clear
-/queue clear 1
-/queue clear 2 3
-```
-
-Queues are scoped to the current project and session. They are stored in OpenCode's user data directory and restored with their previous running or stopped state after OpenCode restarts or crashes. Restored queues do not replay just because the session starts idle; a running queue resumes after the session becomes busy and then finishes successfully. A send interrupted by a crash remains queued because the plugin cannot know whether OpenCode accepted it before exiting.
+Queues are scoped to the current project and session. They are stored in OpenCode's user data directory and restored with their previous running or stopped state after OpenCode restarts or crashes. The `always` setting applies to every OpenCode project. Restored queues do not replay just because the session starts idle; a running queue resumes after the session becomes busy and then finishes successfully. A send interrupted by a crash remains queued because the plugin cannot know whether OpenCode accepted it before exiting.
 
 ## Notes
 
-- 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

@@ -2,15 +2,15 @@ import type { Plugin } from "@opencode-ai/plugin"
 import type { AgentPartInput, FilePart, FilePartInput, SubtaskPartInput, TextPart, TextPartInput } from "@opencode-ai/sdk"
 import { HttpServerResponse } from "effect/unstable/http"
 import { createHash, randomUUID } from "node:crypto"
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
+import { link, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join } from "node:path"
 
-const QUEUE = /^\/queue(?:\s+([\s\S]*))?$/
-const SUFFIX = /^([\s\S]*?)\s+\/queue(?:\s+(front))?\s*$/
+const SUFFIX = /^(?:([\s\S]*?)\s+)?\/(\S+)(?:\s+(front))?\s*$/
 const CMD = /^\/(\S+)(?:\s+([\s\S]*))?$/
 const ITEM_NUMBER = /^[1-9]\d*$/
 const TUI_COMPACT = "session_compact"
+const INTERNAL = "opencodeQueueInternal"
 
 type InputPart = TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput
 type Model = { providerID: string; modelID: string }
@@ -19,7 +19,7 @@ type Info = { agent: string; model: Model; variant?: string }
 type Msg = { info: { role: string; agent?: string; mode?: string; model?: Model; providerID?: string; modelID?: string; variant?: string } }
 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 QueueInput = { body: string; front: boolean }
+type QueueInput = { body: string; modifier?: "front" | "now" }
 
 type Item =
   | { kind: "prompt"; info: Info; body: string; parts: InputPart[] }
@@ -33,32 +33,36 @@ type EntryOp =
   | { kind: "compact"; source: string }
   | { kind: "shell"; source: string; shell: string }
 
+type ControlOp =
+  | { kind: "list" }
+  | { kind: "clear"; indices: number[] }
+  | { kind: "flush" }
+  | { kind: "start" }
+  | { kind: "stop" }
+  | { kind: "always"; enabled?: boolean }
+
 type Activity = { kind: "idle" } | { kind: "restored" } | { kind: "busy" } | { kind: "sending"; idle: boolean; items: Item[] }
 type State = { items: Item[]; activity: Activity; stopped: boolean; failed: boolean; hidden: Set<string> }
-type Durable = Pick<State, "items" | "stopped" | "hidden">
+type Draft = Pick<State, "items" | "stopped" | "hidden">
 type Store = { version: 1; projectID: string; sessions: Record<string, { items: Item[]; stopped: boolean; hidden: string[] }> }
 type Placeholder = { id: string; part: TextPart }
 
 type Op =
-  | { kind: "list" }
-  | { kind: "clear"; indices: number[] }
-  | { kind: "flush" }
-  | { kind: "start" }
-  | { kind: "stop" }
+  | ControlOp
   | { kind: "invalid"; message: string }
   | (EntryOp & { front: boolean })
 
-type ControlOp = Extract<Op, { kind: "list" | "clear" | "flush" | "start" | "stop" }>
+const isQueue = (command: string) => command === "q" || command === "queue"
 
 const parsePrefix = (body: string): QueueInput => {
-  const match = body.trim().match(/^front(?:\s+([\s\S]*))?$/)
-  return match ? { body: match[1] ?? "", front: true } : { body, front: false }
+  const match = body.trim().match(/^(front|now)(?:\s+([\s\S]*))?$/)
+  return match ? { body: match[2] ?? "", modifier: match[1] === "front" ? "front" : "now" } : { body }
 }
 
 const parse = (input: QueueInput, files = 0): Op => {
   const text = input.body.trim()
-  const front = input.front
-  if (!front && !files) {
+  const front = input.modifier === "front"
+  if (!input.modifier && !files) {
     switch (text) {
       case "":
       case "list":
@@ -71,6 +75,10 @@ const parse = (input: QueueInput, files = 0): Op => {
         return { kind: "stop" }
     }
 
+    if (text === "always") return { kind: "always" }
+    if (text === "always on" || text === "always off") return { kind: "always", enabled: text === "always on" }
+    if (/^always(?:\s|$)/.test(text)) return { kind: "invalid", message: "Queue always expects on or off" }
+
     const clear = text.match(/^clear(?:\s+([\s\S]+))?$/)
     if (clear) {
       const values = clear[1]?.trim().split(/\s+/) ?? []
@@ -79,7 +87,7 @@ const parse = (input: QueueInput, files = 0): Op => {
       return { kind: "clear", indices }
     }
   }
-  if (front && !text && !files) return { kind: "invalid", message: "Queue front input is empty" }
+  if (input.modifier && !text && !files) return { kind: "invalid", message: `Queue ${input.modifier} input is empty` }
 
   if (text.startsWith("!")) {
     const shell = text.slice(1).trim()
@@ -103,17 +111,13 @@ const parse = (input: QueueInput, files = 0): Op => {
 }
 
 const parseSuffix = (text: string): QueueInput | undefined => {
-  const trimmed = text.trim()
-  if (trimmed === "/queue") return { body: "", front: false }
-  if (trimmed === "/queue front") return { body: "", front: true }
-
   const match = text.match(SUFFIX)
-  return match ? { body: match[1], front: match[2] === "front" } : undefined
+  return match && isQueue(match[2]) ? { body: match[1] ?? "", modifier: match[3] ? "front" : undefined } : undefined
 }
 const stripSuffix = (text: string) => parseSuffix(text)?.body ?? text
 const parseInput = (text: string): QueueInput | undefined => {
-  const prefix = text.match(QUEUE)
-  return prefix ? parsePrefix(prefix[1] ?? "") : parseSuffix(text)
+  const prefix = text.match(CMD)
+  return prefix && isQueue(prefix[1]) ? parsePrefix(prefix[2] ?? "") : parseSuffix(text)
 }
 const control = (op: Op): op is ControlOp => {
   switch (op.kind) {
@@ -122,6 +126,7 @@ const control = (op: Op): op is ControlOp => {
     case "flush":
     case "start":
     case "stop":
+    case "always":
       return true
     default:
       return false
@@ -192,14 +197,41 @@ const dataHome = () => {
   return join(homedir(), ".local", "share")
 }
 
+const writeJson = async (path: string, value: unknown, commit = rename) => {
+  await mkdir(dirname(path), { recursive: true })
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`
+  try {
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 })
+    await commit(temporary, path)
+  } finally {
+    await rm(temporary, { force: true }).catch((error) => console.warn("QueuePlugin failed to remove temporary storage", error))
+  }
+}
+
 export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
   const sessions = new Map<string, State>()
   const deleted = new Set<string>()
   const enqueueTurns = new Map<string, Promise<unknown>>()
+  const internalCommands: { sid: string; command: string; args: string; used: boolean }[] = []
+  const origin = randomUUID()
   const post = (client as unknown as { _client?: { post?: Post } })._client?.post
-  const path = join(dataHome(), "opencode", "opencode-queue", `${createHash("sha256").update(project.id).digest("hex")}.json`)
+  const root = join(dataHome(), "opencode", "opencode-queue")
+  const path = join(root, `${createHash("sha256").update(project.id).digest("hex")}.json`)
+  const settingsPath = join(root, "settings.json")
   let writes = Promise.resolve()
 
+  const readAlways = async () => {
+    try {
+      const parsed: unknown = JSON.parse(await readFile(settingsPath, "utf8"))
+      if (record(parsed) && typeof parsed.always === "boolean") return parsed.always
+      console.warn("QueuePlugin ignored invalid global settings", settingsPath)
+    } catch (error) {
+      if (!record(error) || error.code !== "ENOENT") console.error("QueuePlugin failed to load global settings", error)
+    }
+    return false
+  }
+  let legacyAlways = false
+
   try {
     const parsed: unknown = JSON.parse(await readFile(path, "utf8"))
     if (!record(parsed) || parsed.version !== 1 || parsed.projectID !== project.id || !record(parsed.sessions)) {
@@ -218,12 +250,19 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
         const activity: Activity = { kind: items.length && !value.stopped ? "restored" : "idle" }
         if (items.length || value.stopped || hidden.size) sessions.set(sid, { items, activity, stopped: value.stopped, failed: false, hidden })
       }
+      legacyAlways = parsed.always === true
     }
   } catch (error) {
     if (!record(error) || error.code !== "ENOENT") console.error("QueuePlugin failed to load queue storage", error)
   }
-
-  const save = async (sid?: string, draft?: Durable) => {
+  if (legacyAlways) {
+    try {
+      await writeJson(settingsPath, { always: true }, link)
+    } catch (error) {
+      if (!record(error) || error.code !== "EEXIST") throw error
+    }
+  }
+  const save = async (sid?: string, draft?: Draft) => {
     const stored: Store = { version: 1, projectID: project.id, sessions: {} }
     for (const [id, current] of sessions) {
       if (deleted.has(id) || (id === sid && !draft)) continue
@@ -231,15 +270,7 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
       const items = current.activity.kind === "sending" ? [...current.activity.items, ...durable.items] : durable.items
       if (items.length || durable.stopped || durable.hidden.size) stored.sessions[id] = { items, stopped: durable.stopped, hidden: [...durable.hidden] }
     }
-    const contents = `${JSON.stringify(stored, null, 2)}\n`
-    await mkdir(dirname(path), { recursive: true })
-    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`
-    try {
-      await writeFile(temporary, contents, { mode: 0o600 })
-      await rename(temporary, path)
-    } finally {
-      await rm(temporary, { force: true }).catch((error) => console.warn("QueuePlugin failed to remove temporary queue storage", error))
-    }
+    await writeJson(path, stored)
   }
 
   const serialize = <T>(action: () => Promise<T>) => {
@@ -257,7 +288,9 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
     return current
   }
 
-  const store = async (sid: string, current: State, draft: Durable, placeholder?: Placeholder) => {
+  const automaticallyQueue = async (sid: string) => shouldQueue(sessions.get(sid)) && (await readAlways())
+
+  const store = async (sid: string, current: State, draft: Draft, placeholder?: Placeholder) => {
     try {
       await save(sid, draft)
     } catch (error) {
@@ -270,11 +303,11 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
     if (placeholder) Object.assign(placeholder.part, { text: "", synthetic: true, ignored: true })
   }
 
-  const persist = <T>(sid: string, placeholder: Placeholder | undefined, mutate: (draft: Durable) => T) =>
+  const persist = <T>(sid: string, placeholder: Placeholder | undefined, mutate: (draft: Draft) => T) =>
     serialize(async () => {
       if (deleted.has(sid)) throw new Error(`QueuePlugin cannot persist queue state for deleted session ${sid}`)
       const current = state(sid)
-      const draft: Durable = { items: [...current.items], stopped: current.stopped, hidden: new Set(current.hidden) }
+      const draft: Draft = { items: [...current.items], stopped: current.stopped, hidden: new Set(current.hidden) }
       if (placeholder) draft.hidden.add(placeholder.id)
       const value = mutate(draft)
       await store(sid, current, draft, placeholder)
@@ -364,6 +397,21 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
       throwOnError: true,
     })
 
+  const markInternal = (parts: { type: string; metadata?: Record<string, unknown> }[]) => {
+    const text = parts.find((part) => part.type === "text")
+    if (text) text.metadata = { ...text.metadata, [INTERNAL]: origin }
+  }
+
+  const callCommand = async <T>(sid: string, command: string, args: string, call: () => Promise<T>) => {
+    const pending = { sid, command, args, used: false }
+    internalCommands.push(pending)
+    try {
+      return await call()
+    } finally {
+      internalCommands.splice(internalCommands.indexOf(pending), 1)
+    }
+  }
+
   const replay = async (sid: string, item: Item) => {
     switch (item.kind) {
       case "shell":
@@ -371,19 +419,22 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
       case "compact":
         return compact(sid, item.info)
       case "command":
-        return client.session.command({
-          path: { id: sid },
-          body: {
-            ...opts(item.info),
-            model: `${item.info.model.providerID}/${item.info.model.modelID}`,
-            command: item.cmd,
-            arguments: item.args,
-            parts: item.files,
-          } as any,
-          throwOnError: true,
-        })
+        return callCommand(sid, item.cmd, item.args, () =>
+          client.session.command({
+            path: { id: sid },
+            body: {
+              ...opts(item.info),
+              model: `${item.info.model.providerID}/${item.info.model.modelID}`,
+              command: item.cmd,
+              arguments: item.args,
+              parts: item.files,
+            } as any,
+            throwOnError: true,
+          }),
+        )
       case "prompt": {
         const parts = item.parts.map((part) => ({ ...part, id: undefined }))
+        markInternal(parts)
         return client.session.prompt({ path: { id: sid }, body: { ...opts(item.info), parts } as any, throwOnError: true })
       }
     }
@@ -420,7 +471,7 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
 
       const items = current.items.slice(0, count)
       if (placeholder) {
-        const draft: Durable = { items: [...current.items], stopped: current.stopped, hidden: new Set(current.hidden).add(placeholder.id) }
+        const draft: Draft = { items: [...current.items], stopped: current.stopped, hidden: new Set(current.hidden).add(placeholder.id) }
         await store(sid, current, draft, placeholder)
         if (deleted.has(sid)) return undefined
       }
@@ -488,6 +539,16 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
       return result.failed ? `${message}; ${result.failed} failed` : message
     }
 
+    if (op.kind === "always") {
+      const enabled = await serialize(async () => {
+        if (op.enabled === undefined) return readAlways()
+        await writeJson(settingsPath, { always: op.enabled })
+        return op.enabled
+      })
+      if (placeholder) await persist(sid, placeholder, () => undefined)
+      return `Always queue is ${enabled ? "on" : "off"} globally`
+    }
+
     const message = await persist(sid, placeholder, (draft) => {
       switch (op.kind) {
         case "list": {
@@ -514,7 +575,7 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
   const hooks: Awaited<ReturnType<Plugin>> = {
     config: async (cfg) => {
       cfg.command ??= {}
-      cfg.command.queue = { template: "", description: "Queue input until the session is idle" }
+      cfg.command.q = cfg.command.queue = { template: "", description: "Queue input until the session is idle" }
     },
     event: async ({ event }) => {
       if (plan(event)) {
@@ -576,8 +637,15 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
       const body = input.arguments ?? ""
       const parts = files(output.parts)
 
-      if (input.command !== "queue") {
-        const queued = parseSuffix(body)
+      const internal = internalCommands.find((pending) => !pending.used && pending.sid === sid && pending.command === input.command && pending.args === body)
+      if (internal) {
+        internal.used = true
+        markInternal(output.parts)
+        return
+      }
+
+      if (!isQueue(input.command)) {
+        const queued = parseSuffix(body) ?? ((await automaticallyQueue(sid)) ? { body } : undefined)
         if (!queued) return
 
         if (!shouldQueue(sessions.get(sid))) {
@@ -585,16 +653,17 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
           return
         }
 
-        output.parts.splice(0, output.parts.length, { type: "text", text: `/queue${queued.front ? " front" : ""} /${input.command}${queued.body.trim() ? ` ${queued.body.trim()}` : ""}` } as any, ...parts)
+        output.parts.splice(0, output.parts.length, { type: "text", text: `/queue${queued.modifier === "front" ? " front" : ""} /${input.command}${queued.body.trim() ? ` ${queued.body.trim()}` : ""}` } as any, ...parts)
         return
       }
 
-      const op = parse(parsePrefix(body), parts.length)
+      const request = parsePrefix(body)
+      const op = parse(request, parts.length)
 
       if (control(op)) return stop(await afterEnqueue(sid, () => manage(sid, op)))
       if (op.kind === "invalid") return stop(op.message, "error")
 
-      if (!shouldQueue(sessions.get(sid))) {
+      if (!shouldQueue(sessions.get(sid)) || (request.modifier === "now" && op.kind !== "prompt" && op.kind !== "shell")) {
         if (op.kind === "shell") {
           await shell(sid, op.shell, await run(sid))
           return handled()
@@ -606,7 +675,7 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
         }
 
         if (op.kind === "command") {
-          await client.session.command({ path: { id: sid }, body: { command: op.cmd, arguments: op.args, parts } as any })
+          await callCommand(sid, op.cmd, op.args, () => client.session.command({ path: { id: sid }, body: { command: op.cmd, arguments: op.args, parts } as any }))
           return handled()
         }
 
@@ -622,10 +691,15 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
         console.warn("QueuePlugin ignored input for a deleted session", sid)
         return
       }
+      const internal = output.parts.find((part): part is TextPart => part.type === "text" && part.metadata?.[INTERNAL] === origin)
+      if (internal) {
+        delete internal.metadata![INTERNAL]
+        return
+      }
       const text = output.parts.find((part): part is TextPart => part.type === "text" && !part.synthetic)
       if (!text) return
 
-      const request = parseInput(text.text)
+      const request = parseInput(text.text) ?? ((await automaticallyQueue(sid)) ? { body: text.text } : undefined)
       if (!request) return
 
       const current = state(sid)
@@ -645,7 +719,7 @@ export const QueuePlugin: Plugin = async ({ client, project, directory }) => {
         return
       }
 
-      if (!shouldQueue(current)) {
+      if ((request.modifier === "now" && op.kind !== "shell") || !shouldQueue(current)) {
         if (op.kind === "command") return
         if (op.kind === "compact") {
           await persist(sid, placeholder, () => undefined)

package/package.json

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