opencode-agent-skill 13.0.0-beta.2 → 14.2.0-beta.1

package/lib/pi-rpc-pool.mjs

@@ -0,0 +1,433 @@
+import { spawn } from "node:child_process"
+import { terminateProcessTree } from "./process-supervisor.mjs"
+
+function clamp(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+const RPC_CONTROL_TIMEOUT_MS = clamp(
+  process.env.UES_RPC_CONTROL_TIMEOUT_MS,
+  3_000,
+  500,
+  30_000,
+)
+
+async function waitForProcessClose(proc, timeoutMs = 2_000) {
+  if (!proc) return
+  const delayAfterExitMs = process.platform === "win32" ? 75 : 0
+
+  if (proc.exitCode !== null || proc.signalCode !== null) {
+    if (delayAfterExitMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayAfterExitMs))
+    }
+    return
+  }
+
+  await new Promise((resolve) => {
+    let settled = false
+    let timer = null
+    const finish = () => {
+      if (settled) return
+      settled = true
+      if (timer) clearTimeout(timer)
+      proc.removeListener("close", finish)
+      resolve()
+    }
+    // "close" fires after the process has exited and its stdio handles have
+    // closed. That distinction matters on Windows, where removing the worker's
+    // temporary cwd immediately after only "exit" can still fail with EBUSY.
+    proc.once("close", finish)
+    timer = setTimeout(finish, timeoutMs)
+    timer.unref?.()
+  })
+
+  if (delayAfterExitMs > 0) {
+    await new Promise((resolve) => setTimeout(resolve, delayAfterExitMs))
+  }
+}
+
+class RpcWorker {
+  constructor(spec) {
+    this.spec = spec
+    this.proc = null
+    this.buffer = ""
+    this.stderr = ""
+    this.pending = new Map()
+    this.listeners = new Set()
+    this.requestId = 0
+    this.runs = 0
+    this.dead = false
+    this.active = false
+    this.activeAbort = null
+    this.lastActivityAt = 0
+    this.tail = Promise.resolve()
+  }
+
+  async start() {
+    if (this.proc && !this.dead) return
+    const proc = spawn(this.spec.command, this.spec.args, {
+      cwd: this.spec.cwd,
+      env: this.spec.env || process.env,
+      shell: false,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+    this.proc = proc
+    this.dead = false
+    this.stderr = ""
+
+    proc.stdout.on("data", (data) => {
+      this.buffer += data.toString()
+      const lines = this.buffer.split("\n")
+      this.buffer = lines.pop() || ""
+      for (const line of lines) this.handleLine(line)
+    })
+    proc.stderr.on("data", (data) => {
+      if (this.stderr.length < 128 * 1024) this.stderr += data.toString()
+    })
+    proc.stdin.on("error", (error) => this.fail(new Error("Pi RPC stdin error: " + error.message)))
+    proc.on("error", (error) => this.fail(error))
+    proc.on("exit", (code, signal) => {
+      this.fail(new Error(`Pi RPC worker exited code=${code} signal=${signal || "none"}\n${this.stderr}`))
+    })
+
+    // Probe readiness through the protocol rather than relying on an arbitrary sleep.
+    await this.send({ type: "get_state" }, { timeoutMs: 30_000 })
+  }
+
+  handleLine(line) {
+    if (!line.trim()) return
+    let event
+    try {
+      event = JSON.parse(line)
+    } catch {
+      return
+    }
+    if (event?.type === "response" && event?.id && this.pending.has(event.id)) {
+      const request = this.pending.get(event.id)
+      this.pending.delete(event.id)
+      clearTimeout(request.timer)
+      if (event.success === false) request.reject(new Error(event.error || event.message || "Pi RPC command failed"))
+      else request.resolve(event)
+      return
+    }
+    for (const listener of [...this.listeners]) {
+      try { listener(event) } catch {}
+    }
+  }
+
+  fail(error) {
+    if (this.dead) return
+    this.dead = true
+    for (const request of this.pending.values()) {
+      clearTimeout(request.timer)
+      request.reject(error)
+    }
+    this.pending.clear()
+    for (const listener of [...this.listeners]) {
+      try { listener({ type: "ues_rpc_worker_error", error: String(error?.message || error) }) } catch {}
+    }
+  }
+
+  async send(body, options = {}) {
+    await this.startIfNeededForSend(body)
+    if (!this.proc?.stdin || this.dead) throw new Error("Pi RPC worker is not available")
+    const id = "ues-" + (++this.requestId)
+    const timeoutMs = clamp(options.timeoutMs, 30_000, 1000, 30 * 60_000)
+    const payload = JSON.stringify({ id, ...body }) + "\n"
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id)
+        reject(new Error(`Pi RPC command timeout: ${body.type}`))
+      }, timeoutMs)
+      timer.unref?.()
+      this.pending.set(id, { resolve, reject, timer })
+      this.proc.stdin.write(payload, (error) => {
+        if (!error) return
+        const request = this.pending.get(id)
+        if (!request) return
+        clearTimeout(request.timer)
+        this.pending.delete(id)
+        reject(error)
+      })
+    })
+  }
+
+  async startIfNeededForSend(body) {
+    // start() itself probes with get_state, so allow that first write through.
+    if (this.proc && !this.dead) return
+    if (body?.type === "get_state" && this.proc && !this.dead) return
+    if (!this.proc || this.dead) await this.start()
+  }
+
+  onEvent(listener) {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  async steer(message) {
+    if (!this.proc || this.dead || !this.active) {
+      return { accepted: false, reason: "worker-not-active" }
+    }
+    await this.send(
+      { type: "steer", message: String(message || "") },
+      { timeoutMs: RPC_CONTROL_TIMEOUT_MS },
+    )
+    return { accepted: true }
+  }
+
+  async abortTransport() {
+    if (!this.proc || this.dead) return false
+    try {
+      await this.send({ type: "abort" }, { timeoutMs: RPC_CONTROL_TIMEOUT_MS })
+      return true
+    } catch {
+      const proc = this.proc
+      terminateProcessTree(proc, { graceMs: 1000 })
+      this.dead = true
+      await waitForProcessClose(proc)
+      return true
+    }
+  }
+
+  async abort() {
+    if (!this.proc || this.dead) return false
+    if (typeof this.activeAbort === "function") {
+      await this.activeAbort("aborted")
+      return true
+    }
+    return this.abortTransport()
+  }
+
+  async stop() {
+    const proc = this.proc
+    if (!proc) return
+    terminateProcessTree(proc, { graceMs: 500 })
+    this.dead = true
+    await waitForProcessClose(proc)
+    if (this.proc === proc) this.proc = null
+  }
+
+  run(message, options = {}) {
+    const execute = async () => {
+      try {
+        await this.start()
+        if (this.runs > 0) {
+          await this.send({ type: "new_session" }, { timeoutMs: 30_000 })
+        }
+      } catch (error) {
+        if (error && typeof error === "object") error.uesRpcPhase = "startup"
+        throw error
+      }
+      this.runs += 1
+      this.stderr = ""
+
+      const hardTimeoutMs = clamp(options.hardTimeoutMs, 30 * 60_000, 30_000, 2 * 60 * 60_000)
+      const idleTimeoutMs = clamp(options.idleTimeoutMs, 5 * 60_000, 10_000, 30 * 60_000)
+      let lastActivityAt = Date.now()
+      this.lastActivityAt = lastActivityAt
+      this.active = true
+      let finalMessage = null
+      let toolCalls = 0
+      let lastToolErrorAt = 0
+      const toolNames = new Set()
+      let settledResolve
+      let settledReject
+      const settled = new Promise((resolve, reject) => {
+        settledResolve = resolve
+        settledReject = reject
+      })
+
+      let aborting = false
+      const abortFor = async (reason) => {
+        if (aborting) return
+        aborting = true
+        try { await this.abortTransport() } catch {}
+        settledReject(new Error("UES RPC " + reason))
+      }
+      this.activeAbort = abortFor
+
+      const unsubscribe = this.onEvent((event) => {
+        lastActivityAt = Date.now()
+        this.lastActivityAt = lastActivityAt
+        if (event.type === "tool_execution_start") {
+          toolCalls += 1
+          lastToolErrorAt = 0
+          if (event.toolName) toolNames.add(String(event.toolName))
+        }
+        if (event.type === "tool_execution_end") {
+          lastToolErrorAt = event.isError === true ? Date.now() : 0
+        }
+        if (event.type === "message_end" && event.message?.role === "assistant") {
+          finalMessage = event.message
+        }
+        try {
+          const decision = options.onEvent?.(event)
+          if (decision?.abort === true) void abortFor(decision.reason || "event-abort")
+        } catch {}
+        if (event.type === "agent_settled" && !aborting) settledResolve()
+        if (event.type === "ues_rpc_worker_error") settledReject(new Error(event.error || "RPC worker failed"))
+      })
+
+      const hardTimer = setTimeout(() => void abortFor("hard-timeout"), hardTimeoutMs)
+      hardTimer.unref?.()
+      const postToolErrorIdleTimeoutMs = clamp(
+        options.postToolErrorIdleTimeoutMs,
+        60_000,
+        5_000,
+        idleTimeoutMs,
+      )
+      const idleTimer = setInterval(() => {
+        const now = Date.now()
+        const threshold = lastToolErrorAt > 0 ? Math.min(idleTimeoutMs, postToolErrorIdleTimeoutMs) : idleTimeoutMs
+        if (now - lastActivityAt >= threshold) {
+          void abortFor(lastToolErrorAt > 0 ? "post-tool-error-stall" : "idle-timeout")
+        }
+      }, 1000)
+      idleTimer.unref?.()
+
+      const signal = options.signal
+      const onAbort = () => void abortFor("aborted")
+      if (signal) {
+        if (signal.aborted) onAbort()
+        else signal.addEventListener("abort", onAbort, { once: true })
+      }
+
+      try {
+        await this.send({ type: "prompt", message }, { timeoutMs: 30_000 })
+        await settled
+        return {
+          message: finalMessage,
+          stderr: this.stderr,
+          toolCalls,
+          toolNames: [...toolNames],
+        }
+      } catch (error) {
+        if (error && typeof error === "object") error.uesRpcPhase = "runtime"
+        throw error
+      } finally {
+        this.active = false
+        this.activeAbort = null
+        clearTimeout(hardTimer)
+        clearInterval(idleTimer)
+        unsubscribe()
+        if (signal) signal.removeEventListener("abort", onAbort)
+      }
+    }
+
+    const promise = this.tail.then(execute, execute)
+    this.tail = promise.catch(() => {})
+    return promise
+  }
+}
+
+export class PiRpcWorkerPool {
+  constructor(options = {}) {
+    this.maxWorkers = Math.max(1, Math.min(16, Number(options.maxWorkers || 8)))
+    this.workers = new Map()
+  }
+
+  async pruneIdleWorkers(protectedKey = null) {
+    while (this.workers.size > this.maxWorkers) {
+      let candidateKey = null
+      let candidate = null
+      for (const [key, worker] of this.workers.entries()) {
+        if (key === protectedKey) continue
+        if (!worker || worker.dead) {
+          candidateKey = key
+          candidate = worker
+          break
+        }
+        if (worker.active) continue
+        candidateKey = key
+        candidate = worker
+        break
+      }
+      if (!candidateKey) break
+      this.workers.delete(candidateKey)
+      await candidate?.stop().catch(() => {})
+    }
+  }
+
+  async run(key, spec, message, options = {}) {
+    let worker = this.workers.get(key)
+    let workerReused = Boolean(worker && !worker.dead && worker.runs > 0)
+    if (!worker || worker.dead) {
+      if (worker) {
+        await worker.stop().catch(() => {})
+        this.workers.delete(key)
+      }
+      worker = new RpcWorker(spec)
+      workerReused = false
+      this.workers.set(key, worker)
+      await this.pruneIdleWorkers(key)
+    } else {
+      // Refresh insertion order so the bounded worker map behaves as an LRU.
+      this.workers.delete(key)
+      this.workers.set(key, worker)
+    }
+
+    try {
+      const result = await worker.run(message, options)
+      await this.pruneIdleWorkers(key)
+      return { ...result, workerReused }
+    } catch (error) {
+      this.workers.delete(key)
+      await worker.stop().catch(() => {})
+      await this.pruneIdleWorkers().catch(() => {})
+      throw error
+    }
+  }
+
+  activeEntries() {
+    return [...this.workers.entries()]
+      .filter(([, worker]) => worker && !worker.dead && worker.active)
+      .map(([key, worker]) => ({
+        key,
+        lastActivityAt: worker.lastActivityAt || 0,
+      }))
+  }
+
+  async steerActive(message) {
+    const active = [...this.workers.entries()]
+      .filter(([, worker]) => worker && !worker.dead && worker.active)
+    if (active.length !== 1) {
+      return {
+        accepted: false,
+        reason: active.length === 0 ? "no-active-worker" : "multiple-active-workers",
+        active: active.length,
+      }
+    }
+    const [key, worker] = active[0]
+    const result = await worker.steer(message)
+    return { ...result, key, active: 1 }
+  }
+
+  async abortActive() {
+    const active = [...this.workers.values()]
+      .filter((worker) => worker && !worker.dead && worker.active)
+    const outcomes = await Promise.all(
+      active.map((worker) => worker.abort().catch(() => false)),
+    )
+    return { aborted: outcomes.filter(Boolean).length }
+  }
+
+  async stopAll() {
+    const workers = [...this.workers.values()]
+    this.workers.clear()
+    await Promise.all(workers.map((worker) => worker.stop().catch(() => {})))
+  }
+
+  status() {
+    const active = this.activeEntries()
+    return {
+      workers: this.workers.size,
+      activeWorkers: active.length,
+      keys: [...this.workers.keys()],
+      active,
+    }
+  }
+}

package/lib/process-hang-detector.mjs

@@ -0,0 +1,83 @@
+const SHELL_TOOLS = new Set(["bash", "powershell"])
+
+const JEST_OPEN_HANDLE =
+  /Jest did not exit one second after the test run has completed\.?/i
+
+const JEST_OPEN_HANDLE_HINT =
+  /asynchronous operations that weren't stopped in your tests|--detectOpenHandles/i
+
+function bounded(text, limit = 6000) {
+  const value = String(text || "")
+  return value.length <= limit ? value : value.slice(value.length - limit)
+}
+
+export function toolResultText(value) {
+  if (value == null) return ""
+  if (typeof value === "string") return value
+  if (Array.isArray(value)) return value.map((item) => toolResultText(item)).filter(Boolean).join("\n")
+  if (typeof value !== "object") return String(value)
+
+  if (typeof value.text === "string") return value.text
+  if (Array.isArray(value.content)) {
+    return value.content
+      .map((item) => toolResultText(item))
+      .filter(Boolean)
+      .join("\n")
+  }
+  if (value.partialResult) return toolResultText(value.partialResult)
+  if (value.result) return toolResultText(value.result)
+  return ""
+}
+
+export function detectHungToolEvidence(input = {}) {
+  const toolName = String(input.toolName || "").toLowerCase()
+  if (!SHELL_TOOLS.has(toolName)) return null
+
+  const text = String(input.text || "")
+  if (!text) return null
+
+  if (JEST_OPEN_HANDLE.test(text)) {
+    return {
+      schemaVersion: 1,
+      kind: "jest-open-handle",
+      confidence: "high",
+      toolName,
+      message:
+        "Jest reported that the test run completed but the process did not exit, indicating an open async handle/resource leak.",
+      evidence: bounded(text),
+      diagnosticHint: JEST_OPEN_HANDLE_HINT.test(text)
+        ? "Run the narrow failing suite with --detectOpenHandles and close leaked timers, servers, Prisma/Redis/BullMQ connections or workers."
+        : "Run the narrow failing suite with --detectOpenHandles and inspect leaked async resources.",
+    }
+  }
+
+  return null
+}
+
+export function createToolOutputAccumulator(options = {}) {
+  const maxChars = Math.max(1024, Math.min(64 * 1024, Number(options.maxChars || 12_000)))
+  const values = new Map()
+
+  return {
+    append(toolCallId, text) {
+      const key = String(toolCallId || "")
+      if (!key) return String(text || "")
+      const next = (String(values.get(key) || "") + String(text || "")).slice(-maxChars)
+      values.set(key, next)
+      return next
+    },
+    get(toolCallId) {
+      return String(values.get(String(toolCallId || "")) || "")
+    },
+    delete(toolCallId) {
+      values.delete(String(toolCallId || ""))
+    },
+    clear() {
+      values.clear()
+    },
+  }
+}
+
+export function isToolExecutionError(event = {}) {
+  return event?.type === "tool_execution_end" && event?.isError === true
+}

package/lib/process-supervisor.mjs

@@ -0,0 +1,193 @@
+import { spawn, spawnSync } from "node:child_process"
+
+function clamp(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export function terminateProcessTree(proc, options = {}) {
+  if (!proc?.pid) return false
+  const graceMs = clamp(options.graceMs, 1500, 0, 30_000)
+
+  if (process.platform === "win32") {
+    const result = spawnSync("taskkill", ["/PID", String(proc.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true,
+    })
+    return result.status === 0
+  }
+
+  // Processes created with detached=true become their own process group.
+  let signaled = false
+  try {
+    process.kill(-proc.pid, "SIGTERM")
+    signaled = true
+  } catch {
+    try {
+      signaled = proc.kill("SIGTERM") !== false
+    } catch {}
+  }
+
+  if (signaled && graceMs > 0) {
+    const processGroupId = proc.pid
+    const timer = setTimeout(() => {
+      // The direct child can exit while a descendant survives and keeps an
+      // inherited pipe open. Probe the process group itself before escalation.
+      let groupAlive = false
+      try {
+        process.kill(-processGroupId, 0)
+        groupAlive = true
+      } catch {}
+      if (!groupAlive) return
+      try {
+        process.kill(-processGroupId, "SIGKILL")
+      } catch {
+        try { proc.kill("SIGKILL") } catch {}
+      }
+    }, graceMs)
+    timer.unref?.()
+  }
+  return signaled
+}
+
+export async function runSupervisedProcess(command, args = [], options = {}) {
+  const cwd = options.cwd || process.cwd()
+  const stdoutLimit = clamp(options.stdoutLimit, 512 * 1024, 1024, 64 * 1024 * 1024)
+  const stderrLimit = clamp(options.stderrLimit, 128 * 1024, 1024, 64 * 1024 * 1024)
+  const hardTimeoutMs = clamp(options.hardTimeoutMs, 0, 0, 24 * 60 * 60_000)
+  const idleTimeoutMs = clamp(options.idleTimeoutMs, 0, 0, 24 * 60 * 60_000)
+  const drainTimeoutMs = clamp(options.drainTimeoutMs, 1500, 50, 30_000)
+  const signal = options.signal
+
+  return await new Promise((resolve) => {
+    const startedAt = Date.now()
+    let lastActivityAt = startedAt
+    let stdout = ""
+    let stderr = ""
+    let stdoutTruncated = false
+    let stderrTruncated = false
+    let settled = false
+    let exitSeen = false
+    let exitCode = null
+    let exitSignal = null
+    let stopReason = null
+    let hardTimer = null
+    let idleTimer = null
+    let drainTimer = null
+    let abortListener = null
+
+    const proc = spawn(command, args, {
+      cwd,
+      env: options.env || process.env,
+      shell: false,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      stdio: options.stdin === "pipe" ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
+    })
+
+    const clear = () => {
+      if (hardTimer) clearTimeout(hardTimer)
+      if (idleTimer) clearInterval(idleTimer)
+      if (drainTimer) clearTimeout(drainTimer)
+      if (signal && abortListener) signal.removeEventListener("abort", abortListener)
+    }
+
+    const finish = () => {
+      if (settled) return
+      settled = true
+      clear()
+      resolve({
+        pid: proc.pid || null,
+        exitCode: stopReason === "aborted"
+          ? 130
+          : stopReason
+            ? 124
+            : Number.isInteger(exitCode)
+              ? exitCode
+              : 1,
+        signal: exitSignal,
+        stopReason,
+        stdout,
+        stderr,
+        stdoutTruncated,
+        stderrTruncated,
+        startedAt: new Date(startedAt).toISOString(),
+        finishedAt: new Date().toISOString(),
+        durationMs: Date.now() - startedAt,
+      })
+    }
+
+    const stop = (reason) => {
+      if (settled || stopReason) return
+      stopReason = reason
+      terminateProcessTree(proc, { graceMs: options.killGraceMs })
+      // Do not wait forever for inherited stdout/stderr descriptors held by grandchildren.
+      drainTimer = setTimeout(finish, drainTimeoutMs)
+      drainTimer.unref?.()
+    }
+
+    const append = (kind, chunk) => {
+      lastActivityAt = Date.now()
+      const text = String(chunk)
+      if (kind === "stdout") {
+        const room = stdoutLimit - stdout.length
+        if (room > 0) stdout += text.slice(0, room)
+        if (text.length > Math.max(0, room)) stdoutTruncated = true
+      } else {
+        const room = stderrLimit - stderr.length
+        if (room > 0) stderr += text.slice(0, room)
+        if (text.length > Math.max(0, room)) stderrTruncated = true
+      }
+      try { options.onOutput?.({ kind, text, at: Date.now() }) } catch {}
+    }
+
+    proc.stdout?.on("data", (data) => append("stdout", data))
+    proc.stderr?.on("data", (data) => append("stderr", data))
+
+    proc.on("error", (error) => {
+      stderr += (stderr ? "\n" : "") + String(error?.message || error)
+      exitCode = 1
+      finish()
+    })
+
+    proc.on("exit", (code, sig) => {
+      exitSeen = true
+      exitCode = code
+      exitSignal = sig
+      // close can be delayed forever if a grandchild inherited the pipe.
+      drainTimer = setTimeout(finish, drainTimeoutMs)
+      drainTimer.unref?.()
+    })
+    proc.on("close", (code, sig) => {
+      if (code !== null) exitCode = code
+      if (sig) exitSignal = sig
+      finish()
+    })
+
+    if (options.stdin === "pipe" && typeof options.input === "string") {
+      proc.stdin?.on("error", () => {})
+      proc.stdin?.end(options.input)
+    }
+
+    if (hardTimeoutMs > 0) {
+      hardTimer = setTimeout(() => stop("hard-timeout"), hardTimeoutMs)
+      hardTimer.unref?.()
+    }
+
+    if (idleTimeoutMs > 0) {
+      idleTimer = setInterval(() => {
+        if (!settled && !exitSeen && Date.now() - lastActivityAt >= idleTimeoutMs) {
+          stop("idle-timeout")
+        }
+      }, Math.min(1000, Math.max(100, Math.floor(idleTimeoutMs / 10))))
+      idleTimer.unref?.()
+    }
+
+    abortListener = () => stop("aborted")
+    if (signal) {
+      if (signal.aborted) abortListener()
+      else signal.addEventListener("abort", abortListener, { once: true })
+    }
+  })
+}