opencode-ultracode 0.1.0 → 1.0.0

package/README.md

@@ -108,6 +108,20 @@ Sub-agents run in their own child sessions with the project's tools and
 permissions. When one of them is blocked on a permission or a question, the
 workflow views flag it and let you answer without leaving the screen.
 
+For unattended runs you can have the plugin approve sub-agent permission
+prompts automatically. This is off by default and controlled by an environment
+variable when you start opencode:
+
+```sh
+ULTRACODE_AUTO_ALLOW=1 opencode            # approve every permission sub-agents ask for
+ULTRACODE_AUTO_ALLOW=bash,edit opencode    # approve only these permission types
+```
+
+Only workflow sessions are affected: the sub-agent sessions themselves and any
+session they open in turn. Your chat session and the plan
+approval prompt still ask as usual, and questions from sub-agents are still
+routed to you. Every auto-approval is written to the opencode log.
+
 If opencode exits while a run is in progress, the run is not lost. Every
 completed agent is journaled, so resuming replays those results and only runs
 the remaining agents again.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultracode",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Workflow orchestration for opencode: model-authored scripts, parallel sub-agent fleet, live TUI progress view",
   "type": "module",
   "license": "MIT",

package/skills/workflow-authoring/SKILL.md

@@ -65,7 +65,9 @@ ALL of stage N-1's results at once (dedup across findings, early-exit on zero, c
   Pass timestamps in via `args`; vary prompts/labels by index instead of randomness.
 - Concurrency is capped (~min(16, cpus-2) parallel agents); the total agent cap is 1000.
 - Sub-agents run in their own sessions with the project's tools and permissions — for
-  long autonomous runs, pre-allow the tools agents need.
+  long autonomous runs, pre-allow the tools agents need, or start opencode with
+  `ULTRACODE_AUTO_ALLOW=1` (or a type list like `bash,edit`) so sub-agent permission
+  prompts are approved automatically. The chat session itself keeps asking.
 
 ## Quality patterns
 

package/src/server/index.ts

@@ -54,6 +54,50 @@ export default async (input: PluginInput): Promise<Hooks> => {
   const childSessionRun = new Map<string, string>()
   const childSessions = new Set<string>()
 
+  // Opt-in auto-approval of permission prompts raised by workflow sub-agents.
+  // ULTRACODE_AUTO_ALLOW=1|true|all approves every permission a child session
+  // asks for; a comma list ("bash,edit,webfetch") approves only those types.
+  // Off by default: the project's permission config applies unchanged.
+  const autoAllow = parseAutoAllow(process.env.ULTRACODE_AUTO_ALLOW)
+
+  // Sessions opened *by* sub-agents (a task / sub-agent tool used inside a
+  // workflow agent) are workflow sessions too. They are picked up from
+  // session events; when a permission arrives before the event did, the
+  // parentID chain is walked through the API instead. Both paths memoize.
+  const descendantSessions = new Set<string>()
+  const parentOf = new Map<string, string | undefined>()
+  const isTracked = (id: string): boolean => childSessions.has(id) || descendantSessions.has(id)
+  const noteSession = (info: { id?: string; parentID?: string } | undefined): void => {
+    if (!info?.id) return
+    parentOf.set(info.id, info.parentID)
+    if (info.parentID && isTracked(info.parentID)) descendantSessions.add(info.id)
+  }
+  const isWorkflowSession = async (sessionID: string): Promise<boolean> => {
+    if (isTracked(sessionID)) return true
+    const chain: string[] = []
+    let id: string | undefined = sessionID
+    while (id && chain.length < 16 && !chain.includes(id)) {
+      chain.push(id)
+      if (!parentOf.has(id)) {
+        try {
+          const res: any = await input.client.session.get({ path: { id } })
+          const info = res?.data ?? res
+          parentOf.set(id, typeof info?.parentID === "string" ? info.parentID : undefined)
+        } catch {
+          return false
+        }
+      }
+      const parent: string | undefined = parentOf.get(id)
+      if (!parent) return false
+      if (isTracked(parent)) {
+        for (const s of chain) descendantSessions.add(s)
+        return true
+      }
+      id = parent
+    }
+    return false
+  }
+
   const log = (level: "debug" | "info" | "warn" | "error", message: string, meta?: Record<string, unknown>) => {
     try {
       input.client.app.log({ body: { level, service: "workflow", message, ...meta } }).catch(() => {})
@@ -329,6 +373,20 @@ export default async (input: PluginInput): Promise<Hooks> => {
       if (label && !childSessions.has(i.sessionID)) sessionModel.set(i.sessionID, label)
     },
 
+    // With auto-allow on, permission prompts raised inside workflow child
+    // sessions are approved here instead of reaching the user. The main
+    // session (including the plan approval prompt) is never affected.
+    "permission.ask": async (perm, output) => {
+      if (!autoAllow) return
+      if (!(await isWorkflowSession(perm.sessionID))) return
+      if (autoAllow !== "all" && !autoAllow.has(perm.type)) return
+      output.status = "allow"
+      log("info", `auto-allowed ${perm.type} permission for workflow sub-agent`, {
+        sessionID: perm.sessionID,
+        pattern: Array.isArray(perm.pattern) ? perm.pattern.join(", ") : perm.pattern,
+      })
+    },
+
     "chat.message": async (i, o) => {
       if (childSessions.has(i.sessionID)) return
       const text = (o.parts ?? []).map((p) => (p as any).type === "text" ? (p as any).text ?? "" : "").join("\n")
@@ -348,6 +406,7 @@ export default async (input: PluginInput): Promise<Hooks> => {
 
     event: async ({ event }) => {
       const e = event as any
+      if (e?.type === "session.created" || e?.type === "session.updated") noteSession(e.properties?.info)
       if (e?.type === "message.part.updated") {
         const part = e.properties?.part
         const runId = part?.sessionID ? childSessionRun.get(part.sessionID) : undefined
@@ -379,6 +438,15 @@ export default async (input: PluginInput): Promise<Hooks> => {
 
 // --- small helpers -----------------------------------------------------------
 
+/** ULTRACODE_AUTO_ALLOW → false (off), "all", or the set of permission types to allow. */
+function parseAutoAllow(raw: string | undefined): false | "all" | Set<string> {
+  const v = (raw ?? "").trim().toLowerCase()
+  if (!v || v === "0" || v === "false" || v === "off" || v === "no") return false
+  if (v === "1" || v === "true" || v === "all" || v === "*" || v === "yes") return "all"
+  const types = new Set(v.split(",").map((t) => t.trim()).filter(Boolean))
+  return types.size ? types : false
+}
+
 function safeName(n: string): string {
   return n.replace(/[^a-zA-Z0-9_-]/g, "-")
 }