oh-my-opencode 4.9.1 → 4.10.0

package/.agents/skills/opencode-qa/SKILL.md

@@ -54,6 +54,7 @@ sandbox, free port, server start/stop, and an EXIT-trap cleanup). It requires
 | Export a whole session as JSON | D | `scripts/export-roundtrip.sh <ses_id>` | `references/db-investigation.md` |
 | Check the HTTP server / an endpoint | B | `scripts/server-smoke.sh` | `references/server-api.md` |
 | Prove a hook / action / event fired | B | `scripts/sse-hook-probe.sh` | `references/events-hooks.md` |
+| Prove serve-topology wake runner-split (reproduced/fixed) | B | `scripts/serve-wake-split-probe.sh --expect reproduced\|fixed --evidence-dir DIR` (self-test: `--self-test`; fake LLM: `scripts/lib/fake-openai-server.mjs`) | `references/events-hooks.md` |
 | Smoke-test the TUI | C | `scripts/tui-smoke.sh` | `references/tui-tmux.md` |
 | Write/run a test in the opencode source | - | (bun test) | `references/testing-harness.md` |
 | Drive opencode from a Bun/TS script | - | (SDK) | `references/sdk.md` |

package/.agents/skills/opencode-qa/scripts/lib/common.sh

@@ -54,6 +54,16 @@ oqa_db_query() {
   opencode db "$1" --format json 2>/dev/null
 }
 
+# Preserve HOME-based opencode shims after HOME is sandboxed. Some installed
+# opencode wrappers resolve the real binary via "$HOME/.opencode/bin/opencode";
+# after oqa_mk_isolated_xdg rewrites HOME, that path must still exist.
+oqa_preserve_home_opencode_bin() {
+  local real_home="$1" sandbox_home="$2"
+  [ -d "$real_home/.opencode/bin" ] || return 0
+  mkdir -p "$sandbox_home/.opencode" || return 1
+  ln -s "$real_home/.opencode/bin" "$sandbox_home/.opencode/bin" 2>/dev/null || return 1
+}
+
 # Create an isolated XDG sandbox so a spawned opencode never touches the real
 # DB. Sets globals OQA_XDG_ROOT + OQA_PROJ and exports XDG_*; registers the
 # root for cleanup.
@@ -63,10 +73,12 @@ oqa_db_query() {
 #   oqa_mk_isolated_xdg            # good
 #   root="$OQA_XDG_ROOT"           # read the global afterwards
 oqa_mk_isolated_xdg() {
-  local root
+  local root real_home
   root="$(mktemp -d -t oqa-xdg.XXXXXX)" || return 1
+  real_home="$HOME"
   OQA_TMPDIRS+=("$root")
   mkdir -p "$root/data" "$root/config" "$root/cache" "$root/state" "$root/home" "$root/proj"
+  oqa_preserve_home_opencode_bin "$real_home" "$root/home" || return 1
   export OQA_XDG_ROOT="$root"
   export HOME="$root/home"
   export OPENCODE_TEST_HOME="$root/home"
@@ -214,6 +226,32 @@ oqa__self_check() {
     oqa_log "FAIL: sandbox HOME not isolated (HOME='$home' OPENCODE_TEST_HOME='$test_home' root='$isodir')"; fails=$((fails+1))
   fi
 
+  local shim_marker shim_result
+  shim_marker="$(mktemp -t oqa-shim.XXXXXX)"
+  bash -c '
+    set -u
+    . "'"${BASH_SOURCE[0]}"'"
+    fake_home="$(mktemp -d -t oqa-fake-home.XXXXXX)"
+    mkdir -p "$fake_home/.local/bin" "$fake_home/.opencode/bin"
+    printf "%s\n" "#!/usr/bin/env bash" "exec \"\$HOME/.opencode/bin/opencode\" \"\$@\"" > "$fake_home/.local/bin/opencode"
+    printf "%s\n" "#!/usr/bin/env bash" "exec \"\$HOME/.opencode/bin/opencode-real\" \"\$@\"" > "$fake_home/.opencode/bin/opencode"
+    printf "%s\n" "#!/usr/bin/env bash" "printf fake-opencode-ok" > "$fake_home/.opencode/bin/opencode-real"
+    chmod +x "$fake_home/.local/bin/opencode" "$fake_home/.opencode/bin/opencode" "$fake_home/.opencode/bin/opencode-real"
+    HOME="$fake_home"
+    PATH="$fake_home/.local/bin:$PATH"
+    oqa_mk_isolated_xdg
+    opencode > "'"$shim_marker"'"
+    oqa_cleanup
+    rm -rf "$fake_home"
+  '
+  shim_result="$(cat "$shim_marker" 2>/dev/null)"
+  rm -f "$shim_marker"
+  if [ "$shim_result" = "fake-opencode-ok" ]; then
+    oqa_pass "isolated HOME preserves HOME-based opencode shim"
+  else
+    oqa_log "FAIL: HOME-based opencode shim returned '$shim_result'"; fails=$((fails+1))
+  fi
+
   if [ "$fails" -eq 0 ]; then
     oqa_pass "common.sh self-check"
     return 0

package/.agents/skills/opencode-qa/scripts/lib/fake-openai-branches.mjs

@@ -0,0 +1,39 @@
+export const branchCounts = {
+  title: 0,
+  "parent-tool-call": 0,
+  "parent-hold": 0,
+  child: 0,
+  wake: 0,
+  default: 0,
+}
+
+export const latches = {
+  parentToolCallIssued: false,
+  parentHoldIssued: false,
+}
+
+export function hasToolResult(inputStr) {
+  return (
+    inputStr.includes('"type":"function_call_output"') ||
+    inputStr.includes('"type": "function_call_output"') ||
+    inputStr.includes('"type":"tool_result"') ||
+    inputStr.includes('"type": "tool_result"') ||
+    inputStr.includes('"role":"tool"') ||
+    inputStr.includes('"role": "tool"')
+  )
+}
+
+export function selectBranch(inputStr) {
+  const isTitle = inputStr.includes("Generate a title")
+  const isSplitProbe = inputStr.includes("Run the split probe")
+  const isChild = inputStr.includes("SPLIT_CHILD_TASK")
+  const isWake = inputStr.includes("[BACKGROUND TASK")
+  const hasResult = hasToolResult(inputStr)
+
+  if (isTitle) return "title"
+  if (isChild && !isSplitProbe) return "child"
+  if (isWake) return "wake"
+  if (isSplitProbe && !hasResult && !latches.parentToolCallIssued) return "parent-tool-call"
+  if (isSplitProbe && (hasResult || latches.parentToolCallIssued) && !latches.parentHoldIssued) return "parent-hold"
+  return "default"
+}

package/.agents/skills/opencode-qa/scripts/lib/fake-openai-events.mjs

@@ -0,0 +1,106 @@
+import fs from "node:fs"
+
+export function completedUsage() {
+  return {
+    input_tokens: 10,
+    output_tokens: 5,
+    input_tokens_details: { cached_tokens: 0 },
+    output_tokens_details: { reasoning_tokens: 0 },
+  }
+}
+
+export function sendSse(res, events) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    connection: "keep-alive",
+  })
+  for (const event of events) {
+    res.write(`data: ${JSON.stringify(event)}\n\n`)
+  }
+  res.write("data: [DONE]\n\n")
+  res.end()
+}
+
+export function textEvents(callCount, text) {
+  const id = `resp_${callCount}`
+  const item = `msg_${callCount}`
+  return [
+    {
+      type: "response.created",
+      response: { id, created_at: Math.floor(Date.now() / 1000), model: "gpt-fake" },
+    },
+    {
+      type: "response.output_item.added",
+      output_index: 0,
+      item: { type: "message", id: item },
+    },
+    {
+      type: "response.output_text.delta",
+      item_id: item,
+      output_index: 0,
+      delta: text,
+    },
+    {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: { type: "message", id: item },
+    },
+    {
+      type: "response.completed",
+      response: { usage: completedUsage() },
+    },
+  ]
+}
+
+export function toolCallEvents(callCount, name, callId, argsObj) {
+  const id = `resp_${callCount}`
+  const fcId = `fc_${callCount}`
+  const argsStr = JSON.stringify(argsObj)
+  return [
+    {
+      type: "response.created",
+      response: { id, created_at: Math.floor(Date.now() / 1000), model: "gpt-fake" },
+    },
+    {
+      type: "response.output_item.added",
+      output_index: 0,
+      item: {
+        type: "function_call",
+        id: fcId,
+        call_id: callId,
+        name,
+        arguments: "",
+      },
+    },
+    {
+      type: "response.function_call_arguments.delta",
+      item_id: fcId,
+      output_index: 0,
+      delta: argsStr,
+    },
+    {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: {
+        type: "function_call",
+        id: fcId,
+        call_id: callId,
+        name,
+        arguments: argsStr,
+        status: "completed",
+      },
+    },
+    {
+      type: "response.completed",
+      response: { usage: completedUsage() },
+    },
+  ]
+}
+
+export function appendLog(logFile, line) {
+  try {
+    fs.appendFileSync(logFile, line)
+  } catch {
+  }
+}

package/.agents/skills/opencode-qa/scripts/lib/fake-openai-server.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import http from "node:http"
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+import { sendSse, textEvents, toolCallEvents, appendLog } from "./fake-openai-events.mjs"
+import { branchCounts, latches, selectBranch } from "./fake-openai-branches.mjs"
+
+const requestedPort = Number(process.env.FAKE_OPENAI_PORT ?? 0)
+const logFile = process.env.FAKE_LLM_LOG ?? path.join(os.tmpdir(), "fake-llm.log")
+
+let callCount = 0
+
+function logBranch(branch, extra = {}) {
+  const now = new Date().toISOString()
+  const line = `[${now}] branch=${branch} call=${callCount}${Object.keys(extra).length ? " " + JSON.stringify(extra) : ""}\n`
+  appendLog(logFile, line)
+  process.stdout.write(line)
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    req.on("data", (chunk) => chunks.push(chunk))
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")))
+    req.on("error", reject)
+  })
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+const server = http.createServer(async (req, res) => {
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "content-type": "text/plain" }).end("ok")
+    return
+  }
+
+  if (req.method !== "POST" || !req.url?.includes("/responses")) {
+    res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "not found" }))
+    return
+  }
+
+  callCount++
+  const raw = await readBody(req)
+  let body
+  try { body = JSON.parse(raw) } catch { body = {} }
+
+  const inputStr = JSON.stringify(body.input ?? body.messages ?? body)
+  const branch = selectBranch(inputStr)
+  branchCounts[branch] = (branchCounts[branch] ?? 0) + 1
+  logBranch(branch)
+
+  if (branch === "title") {
+    sendSse(res, textEvents(callCount, "wake split probe session"))
+    return
+  }
+
+  if (branch === "child") {
+    sendSse(res, textEvents(callCount, "DONE"))
+    return
+  }
+
+  if (branch === "wake") {
+    await sleep(3000)
+    sendSse(res, textEvents(callCount, `WAKE_ACK ${callCount}`))
+    return
+  }
+
+  if (branch === "parent-tool-call") {
+    latches.parentToolCallIssued = true
+    sendSse(res, toolCallEvents(callCount, "task", `call_agent_${callCount}`, {
+      description: "split probe child",
+      prompt: "SPLIT_CHILD_TASK: reply exactly DONE",
+      subagent_type: "explore",
+      run_in_background: true,
+      load_skills: [],
+    }))
+    return
+  }
+
+  if (branch === "parent-hold") {
+    latches.parentHoldIssued = true
+    sendSse(res, toolCallEvents(callCount, "bash", `call_bash_${callCount}`, {
+      command: "i=0; while [ $i -lt 8 ]; do i=$((i+1)); sleep 1; done",
+      description: "hold turn",
+    }))
+    return
+  }
+
+  if (inputStr.includes("say exactly: TUI_NOREG_OK")) {
+    sendSse(res, textEvents(callCount, "TUI_NOREG_OK"))
+    return
+  }
+  sendSse(res, textEvents(callCount, `fake response ${callCount}`))
+})
+
+function logFinalCounts() {
+  const summary = Object.entries(branchCounts).map(([k, v]) => `${k}=${v}`).join(" ")
+  const line = `[${new Date().toISOString()}] FINAL_COUNTS ${summary}\n`
+  appendLog(logFile, line)
+  process.stdout.write(line)
+}
+
+server.listen(requestedPort, "127.0.0.1", () => {
+  const addr = server.address()
+  const port = typeof addr === "object" && addr !== null ? addr.port : requestedPort
+  try {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true })
+    appendLog(logFile, `[${new Date().toISOString()}] START port=${port}\n`)
+  } catch {}
+  process.stdout.write(`fake-openai listening on ${port}\n`)
+})
+
+process.on("SIGTERM", () => { logFinalCounts(); server.close(() => process.exit(0)) })
+process.on("SIGINT", () => { logFinalCounts(); server.close(() => process.exit(0)) })