Activity

1. synergiator

   added

   discussionUsed for feature requests, proposals, ideas, etc. Open discussionUsed for feature requests, proposals, ideas, etc. Open discussion

   on Dec 21, 2025
2. github-actions

   assigned

   thdxr

   on Dec 21, 2025
3. github-actions commented on Dec 21, 2025

   

   github-actionsbot

   on Dec 21, 2025 – with GitHub Actions

   Contributor

   More actions

   This issue might be a duplicate of existing issues. Please check:

   • [feat] True Async/Background Sub-Agent Delegation #5887: [feat] True Async/Background Sub-Agent Delegation - Addresses async/background execution for delegated tasks while maintaining interactive control
   • [FEATURE]: Delayed queue feature #5408: [FEATURE]: Delayed queue feature - Addresses queuing work to run when OpenCode is waiting for user input
   • [FEATURE]: Graceful handling of queued messages after session interrupt #5333: [FEATURE]: Graceful handling of queued messages after session interrupt - Addresses queue persistence and message handling during idle states
   • What is the deterministic way to monitor a session is completed #3815: What is the deterministic way to monitor a session is completed - Discusses event semantics and finished signal detection mentioned in your references

   Feel free to ignore if none of these address your specific case.

   👍React with 👍1Reacted by chrislawso
4. synergiator commented on Dec 22, 2025

   

   synergiator

   on Dec 22, 2025

   Author

   More actions

   TWIMC - after some iterations, I have now something I can work with, though I think that on long term we should aim to have an opencode bot to do chores inside CICD just like the renovate bot.

   This opencode plugins allows to process open beads in background.

   import type { Plugin } from "@opencode-ai/plugin";
   import { appendFile } from "node:fs/promises";
   
   type Bead = {
     id: string;
     title?: string;
     description?: string;
     priority?: number;
     created_at?: string;
     updated_at?: string;
     status?: string;
     issue_type?: string;
   };
   
   const LOG_FILE = process.env.AUTO_BEAD_LOG ?? "/tmp/opencode-auto-bead-runner.log";
   
   const ENABLED = (process.env.AUTO_BEAD_ENABLED ?? "1") === "1";
   const IDLE_DELAY_MS = Number(process.env.AUTO_BEAD_IDLE_DELAY_MS ?? "2000");
   const COOLDOWN_MS = Number(process.env.AUTO_BEAD_COOLDOWN_MS ?? "1000");
   
   const ENABLE_TOAST = (process.env.AUTO_BEAD_TOAST ?? "0") === "1";
   
   // Claim = move bead to in_progress before running it
   const CLAIM = (process.env.AUTO_BEAD_CLAIM ?? "1") === "1";
   
   // Autorun = dispatch a prompt to OpenCode so it actually edits files & completes the bead
   const AUTORUN = (process.env.AUTO_BEAD_AUTORUN ?? "1") === "1";
   
   // Hard stop if a worker prompt never returns (eg permission gate / waiting for human)
   const PROMPT_TIMEOUT_MS = Number(process.env.AUTO_BEAD_PROMPT_TIMEOUT_MS ?? "90000");
   
   const AGENT = "autobead" //  process.env.AUTO_BEAD_AGENT || undefined;
   const MODEL_PROVIDER = process.env.AUTO_BEAD_MODEL_PROVIDER || undefined;
   const MODEL_ID = process.env.AUTO_BEAD_MODEL_ID || undefined;
   
   let crashHooksInstalled = false;
   let logWriteFailedOnce = false;
   
   function ts() {
     return new Date().toISOString();
   }
   
   async function log(line: string) {
     try {
       await appendFile(LOG_FILE, `${ts()} ${line}\n`);
     } catch (e: any) {
       if (!logWriteFailedOnce) {
         logWriteFailedOnce = true;
         console.error("[AutoBeadRunner] log write failed:", e?.message ?? e);
       }
     }
   }
   
   function fireAndForget(p: Promise<any>) {
     p.catch((e) => void log(`[async-error] ${String(e?.message ?? e)}`));
   }
   
   function sleep(ms: number) {
     return new Promise<void>((r) => setTimeout(r, ms));
   }
   
   // Known noisy rejection you observed: session_share file missing.
   // This is unrelated to beads; swallow it to keep logs clean.
   function isBenignSessionShareNotFound(reason: any): boolean {
     const msg = String(reason?.data?.message ?? reason?.message ?? reason ?? "");
     return msg.includes("session_share") && msg.includes("Resource not found:");
   }
   
   function ensureCrashHooksInstalled() {
     if (crashHooksInstalled) return;
     crashHooksInstalled = true;
   
     process.on("unhandledRejection", (reason: any) => {
       if (isBenignSessionShareNotFound(reason)) {
         void log(
           `[unhandledRejection][swallowed] ${String(
             reason?.data?.message ?? reason?.message ?? reason
           )}`
         );
         return;
       }
       void log(
         `[unhandledRejection] ${String(reason?.data?.message ?? reason?.message ?? reason)}`
       );
     });
   
     process.on("uncaughtException", (err: any) => {
       void log(`[uncaughtException] ${String(err?.message ?? err)}`);
     });
   }
   
   // The SDK may return { data, request, response } (responseStyle="fields").
   // Unwrap defensively. (If already flat, return as-is.)
   function unwrap<T>(v: any): T {
     return (v && typeof v === "object" && "data" in v ? v.data : v) as T;
   }
   
   function parseBeads(jsonText: string): Bead[] {
     const v = JSON.parse(jsonText);
     return Array.isArray(v) ? (v as Bead[]) : [];
   }
   
   function beadSortKey(b: Bead) {
     const prio = Number.isFinite(b.priority) ? (b.priority as number) : 999999;
   
     const created = b.created_at ? Date.parse(b.created_at) : Number.POSITIVE_INFINITY;
     const createdKey = Number.isFinite(created) ? created : Number.POSITIVE_INFINITY;
   
     const id = b.id ?? "";
     return { prio, createdKey, id };
   }
   
   function pickNextBead(beads: Bead[]): Bead | null {
     const sorted = [...beads].sort((a, b) => {
       const ka = beadSortKey(a);
       const kb = beadSortKey(b);
       if (ka.prio !== kb.prio) return ka.prio - kb.prio;
       if (ka.createdKey !== kb.createdKey) return ka.createdKey - kb.createdKey;
       return ka.id.localeCompare(kb.id);
     });
     return sorted.length ? sorted[0] : null;
   }
   
   function singleLine(s: string, max = 180) {
     const v = (s ?? "").replace(/\s+/g, " ").trim();
     return v.length > max ? v.slice(0, max - 1) + "…" : v;
   }
   
   function textFromParts(msg: any): string {
     const parts = Array.isArray(msg?.parts) ? msg.parts : [];
     return parts
       .filter((p: any) => p && p.type === "text" && typeof p.text === "string")
       .map((p: any) => p.text)
       .join("\n")
       .trim();
   }
   
   function buildPrompt(bead: Bead, cwd: string) {
     const title = bead.title ?? "";
     const desc = bead.description ?? "";
   
     return [
       "You were triggered by an idle-time automation in OpenCode.",
       "",
       "Process exactly ONE bead (the one below) in an isolated worker session.",
       "",
       `Bead ID: ${bead.id}`,
       `Title: ${title}`,
       `Description: ${desc}`,
       "",
       "Constraints:",
       `- Work in repository worktree: ${cwd}`,
       "- Prefer minimal, safe edits.",
       "- Avoid using shell commands unless absolutely required (assume they may require human approval).",
       "- If you need consent/clarification: ask ONE concise question and STOP.",
       "",
       "Output contract (MANDATORY):",
       "End your final response with exactly ONE of:",
       "  AUTO_BEAD_RESULT: SUCCESS",
       "  AUTO_BEAD_RESULT: NEEDS_HUMAN",
       "",
       "If SUCCESS, include a short bullet list of changed files above the marker.",
       "If NEEDS_HUMAN, include your ONE question above the marker.",
     ].join("\n");
   }
   
   async function withTimeout<T>(
     p: Promise<T>,
     ms: number,
     onTimeout: () => Promise<void>
   ): Promise<T> {
     let timer: ReturnType<typeof setTimeout> | null = null;
   
     const timeoutP = new Promise<T>((_, reject) => {
       timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
     });
   
     try {
       return await Promise.race([p, timeoutP]);
     } catch (e: any) {
       const msg = String(e?.message ?? e);
       if (msg.includes("timeout after")) {
         await onTimeout();
       }
       throw e;
     } finally {
       if (timer) clearTimeout(timer);
     }
   }
   
   export const AutoBeadRunner: Plugin = async ({ client, $, directory, worktree }) => {
     ensureCrashHooksInstalled();
   
     const cwd = process.env.AUTO_BEAD_CWD ?? (worktree || directory);
     fireAndForget(log(`[loaded] cwd=${cwd} log=${LOG_FILE}`));
   
     if (!ENABLED) {
       fireAndForget(log(`[disabled] AUTO_BEAD_ENABLED=0`));
       return { event: async () => {} };
     }
   
     if (ENABLE_TOAST) {
       fireAndForget(
         client.tui.showToast?.({ body: { message: "[AutoBeadRunner] loaded", variant: "info" } }) ??
           Promise.resolve()
       );
     }
   
     let lastIdleAt = 0;
     let inFlight = false;
     let scheduled: ReturnType<typeof setTimeout> | null = null;
   
     async function runBdReady(): Promise<Bead[]> {
       const r = await $`bd ready --json`
         .cwd(cwd)
         .env({ ...process.env, NO_COLOR: "1", TERM: "dumb" })
         .quiet()
         .nothrow();
   
       const exitCode = Number(r.exitCode ?? -1);
       const stdout = String(r.stdout ?? "").trim();
       const stderr = String(r.stderr ?? "").trim();
   
       await log(`[bd.ready] exit=${exitCode}`);
       if (stderr) await log(`[bd.ready] stderr=${stderr}`);
       if (!stdout) return [];
       if (exitCode !== 0) return [];
   
       try {
         return parseBeads(stdout);
       } catch (e: any) {
         await log(`[bd.ready] parse error: ${String(e?.message ?? e)}`);
         await log(`[bd.ready] raw=${stdout}`);
         return [];
       }
     }
   
     async function bdUpdateStatus(id: string, status: string, notes?: string) {
       const note = notes ? singleLine(notes) : "";
       // Try with notes first; fall back if flag unsupported.
       if (note) {
         const u1 = await $`bd update ${id} --status ${status} --notes ${note} --json`
           .cwd(cwd)
           .env({ ...process.env, NO_COLOR: "1", TERM: "dumb" })
           .quiet()
           .nothrow();
         if (Number(u1.exitCode ?? -1) === 0) {
           await log(`[bd.update] id=${id} status=${status} notes=1 exit=0`);
           return;
         }
         await log(
           `[bd.update] id=${id} status=${status} notes=1 exit=${Number(u1.exitCode ?? -1)} (fallback without notes)`
         );
       }
   
       const u2 = await $`bd update ${id} --status ${status} --json`
         .cwd(cwd)
         .env({ ...process.env, NO_COLOR: "1", TERM: "dumb" })
         .quiet()
         .nothrow();
   
       await log(
         `[bd.update] id=${id} status=${status} notes=0 exit=${Number(u2.exitCode ?? -1)} stdout=${singleLine(
           String(u2.stdout ?? "")
         )} stderr=${singleLine(String(u2.stderr ?? ""))}`
       );
     }
   
     async function abortSession(sessionId: string) {
       const anyClient = client as any;
   
       try {
         if (typeof (client as any).session?.abort === "function") {
           await log(`[session.abort] via client.session.abort id=${sessionId}`);
           await (client as any).session.abort({ path: { id: sessionId } });
           return;
         }
         if (typeof anyClient.postSessionByIdAbort === "function") {
           await log(`[session.abort] via postSessionByIdAbort id=${sessionId}`);
           await anyClient.postSessionByIdAbort({ path: { id: sessionId } });
           return;
         }
         await log(`[session.abort] not available in client; cannot abort id=${sessionId}`);
       } catch (e: any) {
         await log(`[session.abort ERROR] id=${sessionId} ${String(e?.message ?? e)}`);
       }
     }
   
     async function createWorkerSession(parentSessionId: string | undefined, bead: Bead): Promise<string> {
       const title = `[AUTO-BEAD] ${bead.id} — ${bead.title ?? ""}`.trim();
   
       const res = await client.session.create({
         body: {
           title,
           // Keeping linkage optional; if you don’t want any coupling, remove parentID.
           ...(parentSessionId ? { parentID: parentSessionId } : {}),
         } as any,
       });
   
       const s = unwrap<any>(res);
       const id = s?.id as string | undefined;
   
       if (!id) {
         throw new Error(`session.create returned no id (keys=${Object.keys(s ?? {}).join(",")})`);
       }
   
       await log(`[session.create] id=${id} title=${JSON.stringify(title)}`);
       return id;
     }
   
     async function promptInSession(sessionId: string, promptText: string) {
       const body: any = { parts: [{ type: "text", text: promptText }] };
       if (AGENT) body.agent = AGENT;
       if (MODEL_PROVIDER && MODEL_ID) body.model = { providerID: MODEL_PROVIDER, modelID: MODEL_ID };
   
       await log(`[dispatch] session.prompt session=${sessionId}`);
       const res = await client.session.prompt({ path: { id: sessionId }, body } as any);
       return unwrap<any>(res);
     }
   
     async function handleTrigger(sessionId: string | undefined) {
       if (inFlight) return;
       inFlight = true;
   
       let bead: Bead | null = null;
       let workerSessionId: string | null = null;
   
       try {
         await log(`[handleTrigger] idle; delay=${IDLE_DELAY_MS}ms sessionId=${sessionId ?? "?"}`);
         if (IDLE_DELAY_MS > 0) await sleep(IDLE_DELAY_MS);
   
         const beads = await runBdReady();
         bead = pickNextBead(beads);
   
         if (!bead) {
           await log(`[handleTrigger] no ready beads`);
           if (ENABLE_TOAST) {
             fireAndForget(
               client.tui.showToast?.({ body: { message: "[AutoBeadRunner] no ready beads", variant: "info" } }) ??
                 Promise.resolve()
             );
           }
           return;
         }
   
         await log(`[handleTrigger] nextReady=${bead.id}`);
   
         if (ENABLE_TOAST) {
           fireAndForget(
             client.tui.showToast?.({
               body: { message: `[AutoBeadRunner] next bead: ${bead.id}`, variant: "success" },
             }) ?? Promise.resolve()
           );
         }
   
         if (CLAIM) {
           await bdUpdateStatus(bead.id, "in_progress");
         } else {
           await log(`[claim] disabled (AUTO_BEAD_CLAIM=0)`);
         }
   
         if (!AUTORUN) {
           await log(`[autorun] disabled (AUTO_BEAD_AUTORUN=0)`);
           return;
         }
   
         // Create isolated worker session (NOT the idle TUI session).
         workerSessionId = await createWorkerSession(sessionId, bead);
   
         const promptText = buildPrompt(bead, cwd);
         await log(`[autorun] dispatching bead=${bead.id} targetSession=${workerSessionId}`);
   
         const msg = await withTimeout(
           promptInSession(workerSessionId, promptText),
           PROMPT_TIMEOUT_MS,
           async () => {
             await log(`[autorun][timeout] bead=${bead?.id ?? "?"} session=${workerSessionId}`);
             if (workerSessionId) await abortSession(workerSessionId);
           }
         );
   
         const text = textFromParts(msg);
         await log(`[autorun] response.len=${text.length}`);
   
         // Decide outcome
         if (text.includes("AUTO_BEAD_RESULT: SUCCESS")) {
           await bdUpdateStatus(
             bead.id,
             "closed",
             `Auto-run SUCCESS in session ${workerSessionId}`
           );
           await log(`[autorun] bead=${bead.id} -> closed`);
         } else if (text.includes("AUTO_BEAD_RESULT: NEEDS_HUMAN")) {
           await bdUpdateStatus(
             bead.id,
             "open",
             `Auto-run needs human. Session=${workerSessionId}. ${singleLine(text)}`
           );
           await log(`[autorun] bead=${bead.id} -> open (needs human)`);
         } else {
           // Unclassified => do not leave in_progress forever
           await bdUpdateStatus(
             bead.id,
             "open",
             `Auto-run unclassified result. Session=${workerSessionId}`
           );
           await log(`[autorun] bead=${bead.id} -> open (unclassified)`);
         }
   
         if (ENABLE_TOAST) {
           fireAndForget(
             client.tui.showToast?.({
               body: { message: `[AutoBeadRunner] finished: ${bead.id}`, variant: "info" },
             }) ?? Promise.resolve()
           );
         }
       } catch (e: any) {
         const msg = String(e?.message ?? e);
         await log(`[handleTrigger ERROR] ${msg}`);
   
         // Safety: if we had claimed, unstick the bead.
         if (bead?.id) {
           await bdUpdateStatus(
             bead.id,
             "open",
             `Auto-run error; waiting for human. ${workerSessionId ? `Session=${workerSessionId}. ` : ""}${singleLine(msg)}`
           );
         }
       } finally {
         inFlight = false;
       }
     }
   
     return {
       event: async ({ event }) => {
         try {
           if (event?.type !== "session.idle") return;
   
           const now = Date.now();
           if (now - lastIdleAt < COOLDOWN_MS) return;
           lastIdleAt = now;
   
           // Property names come from the event payload.
           const sessionId = (event as any)?.properties?.sessionID as string | undefined;
   
           if (scheduled) clearTimeout(scheduled);
           scheduled = setTimeout(() => {
             scheduled = null;
             fireAndForget(handleTrigger(sessionId));
           }, 0);
         } catch (e: any) {
           await log(`[event ERROR] ${String(e?.message ?? e)}`);
         }
       },
     };
   };
   
   
   
5. thdxr

   closed this as completedon Mar 25, 2026