@bybrawe/opencode-loop 0.6.6 → 0.6.8

package/src/source/core/state.js

@@ -1,4 +1,5 @@
 import { promises as fs } from "node:fs"
+import { randomUUID as stateLockRandomUUID } from "node:crypto"
 import os from "node:os"
 import path from "node:path"
 import { safeID } from "./args.js"
@@ -12,6 +13,218 @@ function statePath(directory, sessionID) { return path.join(stateDir(directory),
 export async function ensureDir(directory) { await fs.mkdir(directory, { recursive: true }) }
 export async function pathExists(filePath) { try { await fs.access(filePath); return true } catch { return false } }
 
+const STATE_PROCESS_LOCK_TIMEOUT_MS = 5_000
+const STATE_PROCESS_LOCK_POLL_MS = 20
+
+function stateLockError(kind, detail) {
+  const error = new Error(`OpenCode Loop state lock ${kind}: ${detail}`)
+  error.code = "OPENCODE_LOOP_STATE_LOCK"
+  return error
+}
+
+async function assertStatePathSafe(directory, target) {
+  const root = path.resolve(directory)
+  const relative = path.relative(root, path.resolve(target))
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw stateLockError("unsafe_path", `path escapes project: ${target}`)
+  }
+  let current = root
+  for (const part of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, part)
+    let info
+    try { info = await fs.lstat(current) }
+    catch (error) {
+      if (error?.code === "ENOENT") return
+      throw error
+    }
+    if (info.isSymbolicLink()) throw stateLockError("unsafe_path", `symbolic link or junction: ${current}`)
+  }
+}
+
+function stateProcessLockOwner() {
+  const token = stateLockRandomUUID()
+  return {
+    schemaVersion: 1, pid: process.pid, token, acquiredAt: Date.now(),
+    candidateName: `.loop-lock-${process.pid}-${token}.json`,
+  }
+}
+
+function stateProcessLockOwnerValid(owner) {
+  return owner?.schemaVersion === 1
+    && Number.isSafeInteger(owner.pid) && owner.pid > 0
+    && typeof owner.token === "string" && /^[0-9a-f-]{36}$/i.test(owner.token)
+    && Number.isFinite(owner.acquiredAt) && owner.acquiredAt > 0
+    && owner.candidateName === `.loop-lock-${owner.pid}-${owner.token}.json`
+    && path.basename(owner.candidateName) === owner.candidateName
+}
+
+async function readStateProcessOwner(file) {
+  let raw
+  for (let attempt = 0; ; attempt++) {
+    try { raw = await fs.readFile(file, "utf8"); break }
+    catch (error) {
+      if (error?.code === "ENOENT") return null
+      if (process.platform !== "win32" || !["EPERM", "EACCES", "EBUSY"].includes(error?.code) || attempt >= 5) throw error
+      await delay(10 * (attempt + 1))
+    }
+  }
+  // An exclusive-file fallback publishes an empty lock briefly before
+  // writing its owner. Allow a bounded read retry; stale empty locks still
+  // fail closed rather than being taken over.
+  if (raw.length === 0) {
+    for (let attempt = 0; attempt < 8 && raw.length === 0; attempt++) {
+      await delay(10 * (attempt + 1))
+      try { raw = await fs.readFile(file, "utf8") }
+      catch (error) {
+        if (error?.code === "ENOENT") return null
+        throw error
+      }
+    }
+  }
+  let owner
+  try { owner = JSON.parse(raw) }
+  catch { throw stateLockError("invalid_owner", `corrupt lock metadata at ${file}`) }
+  if (!stateProcessLockOwnerValid(owner)) throw stateLockError("invalid_owner", `invalid lock metadata at ${file}`)
+  return owner
+}
+
+function stateProcessAlive(pid) {
+  if (pid === process.pid) return true
+  try { process.kill(pid, 0); return true }
+  catch (error) { return error?.code !== "ESRCH" }
+}
+
+async function removeStateProcessFile(file) {
+  for (let attempt = 0; ; attempt++) {
+    try { await fs.rm(file, { force: true }); return }
+    catch (error) {
+      if (process.platform !== "win32" || !["EPERM", "EACCES", "EBUSY"].includes(error?.code) || attempt >= 5) throw error
+      await delay(10 * (attempt + 1))
+    }
+  }
+}
+
+// Keep atomic hard links on capable volumes. FAT/exFAT and some remote volumes
+// reject them, so fall back to exclusive creation (O_EXCL) without overwriting
+// any existing live lock or stale-owner cleanup election.
+async function claimStateProcessLock(candidate, canonical) {
+  for (let attempt = 0; ; attempt++) {
+    try { await fs.link(candidate, canonical); return true }
+    catch (error) {
+      if (error?.code === "EEXIST") return false
+      if (["EISDIR", "ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EPERM", "EACCES"].includes(error?.code)) {
+        const contents = await fs.readFile(candidate)
+        let handle
+        try { handle = await fs.open(canonical, "wx", 0o600) }
+        catch (failure) {
+          if (failure?.code === "EEXIST") return false
+          throw failure
+        }
+        try { await handle.writeFile(contents) }
+        catch (failure) {
+          await handle.close().catch(() => {})
+          await removeStateProcessFile(canonical).catch(() => {})
+          throw failure
+        }
+        await handle.close()
+        return true
+      }
+      if (process.platform !== "win32" || !["EPERM", "EACCES", "EBUSY"].includes(error?.code) || attempt >= 5) throw error
+      await delay(10 * (attempt + 1))
+    }
+  }
+}
+
+async function createStateLockCandidate(directory, owner) {
+  const candidate = path.join(stateDir(directory), owner.candidateName)
+  await assertStatePathSafe(directory, candidate)
+  await fs.writeFile(candidate, `${JSON.stringify(owner)}\n`, { flag: "wx", mode: 0o600 })
+  return candidate
+}
+
+// A cleanup-election hard link prevents two processes from deleting a newer
+// lock while reclaiming a dead owner. Never reclaim a live or corrupt owner.
+async function recoverDeadStateProcessLock(directory, canonical, stale, depth = 0) {
+  const cleanupFile = `${canonical}.cleanup`
+  const cleanupOwner = stateProcessLockOwner()
+  const cleanupCandidate = await createStateLockCandidate(directory, cleanupOwner)
+  let elected = false
+  try {
+    await assertStatePathSafe(directory, cleanupFile)
+    elected = await claimStateProcessLock(cleanupCandidate, cleanupFile)
+    if (!elected) {
+      // The previous cleanup winner may itself have crashed. Reclaim that
+      // dead election through another hard-linked, owner-verified election.
+      // Never blindly unlink the election path: a live winner may replace it.
+      const existing = await readStateProcessOwner(cleanupFile)
+      if (existing && !stateProcessAlive(existing.pid)) {
+        if (depth >= 6) throw stateLockError("recovery_depth", `too many orphaned cleanup elections for ${canonical}`)
+        await recoverDeadStateProcessLock(directory, cleanupFile, existing, depth + 1)
+      }
+      return false
+    }
+    const current = await readStateProcessOwner(canonical)
+    if (!current || current.token !== stale.token || current.pid !== stale.pid || stateProcessAlive(current.pid)) return false
+    await assertStatePathSafe(directory, canonical)
+    await removeStateProcessFile(canonical)
+    const staleCandidate = path.join(stateDir(directory), current.candidateName)
+    await assertStatePathSafe(directory, staleCandidate)
+    await removeStateProcessFile(staleCandidate).catch(() => {})
+    return true
+  } finally {
+    if (elected) {
+      const current = await readStateProcessOwner(cleanupFile).catch(() => null)
+      if (current?.token === cleanupOwner.token) await removeStateProcessFile(cleanupFile)
+    }
+    await removeStateProcessFile(cleanupCandidate).catch(() => {})
+  }
+}
+
+async function acquireStateProcessLock(directory, sessionID) {
+  const targetDirectory = stateDir(directory)
+  await assertStatePathSafe(directory, targetDirectory)
+  await ensureDir(targetDirectory)
+  await assertStatePathSafe(directory, targetDirectory)
+  const target = statePath(directory, sessionID)
+  const canonical = `${target}.lock`
+  await assertStatePathSafe(directory, target)
+  await assertStatePathSafe(directory, canonical)
+  const owner = stateProcessLockOwner()
+  const candidate = await createStateLockCandidate(directory, owner)
+  const started = Date.now()
+  let acquired = false
+  try {
+    while (true) {
+      await assertStatePathSafe(directory, canonical)
+      if (await claimStateProcessLock(candidate, canonical)) {
+        acquired = true
+        break
+      }
+      const current = await readStateProcessOwner(canonical)
+      if (current && !stateProcessAlive(current.pid)) await recoverDeadStateProcessLock(directory, canonical, current)
+      if (Date.now() - started >= STATE_PROCESS_LOCK_TIMEOUT_MS) {
+        throw stateLockError("timeout", `session ${sessionID} remained locked for ${STATE_PROCESS_LOCK_TIMEOUT_MS}ms`)
+      }
+      await delay(STATE_PROCESS_LOCK_POLL_MS)
+    }
+    return async () => {
+      const current = await readStateProcessOwner(canonical)
+      if (current?.token !== owner.token || current.pid !== owner.pid) {
+        throw stateLockError("lost", `session ${sessionID} lock ownership changed`)
+      }
+      await assertStatePathSafe(directory, canonical)
+      await removeStateProcessFile(canonical)
+      await removeStateProcessFile(candidate)
+    }
+  } catch (error) {
+    if (acquired && (await readStateProcessOwner(canonical).catch(() => null))?.token === owner.token) {
+      await removeStateProcessFile(canonical).catch(() => {})
+    }
+    await removeStateProcessFile(candidate).catch(() => {})
+    throw error
+  }
+}
+
 function stateLockKey(directory, sessionID) {
   return `${path.resolve(directory)}:${safeID(sessionID)}`
 }
@@ -24,21 +237,30 @@ async function withStateWriteLock(directory, sessionID, fn) {
   const next = previous.catch(() => {}).then(() => current)
   stateWriteLocks.set(key, next)
   await previous.catch(() => {})
+  let unlock
   try {
+    unlock = await acquireStateProcessLock(directory, sessionID)
     return await fn()
   } finally {
-    release()
-    if (stateWriteLocks.get(key) === next) stateWriteLocks.delete(key)
+    try { if (unlock) await unlock() }
+    finally {
+      release()
+      if (stateWriteLocks.get(key) === next) stateWriteLocks.delete(key)
+    }
   }
 }
 
 async function readStateFile(directory, sessionID) {
   const target = statePath(directory, sessionID)
+  await assertStatePathSafe(directory, target)
   const attempts = 5
   for (let attempt = 0; attempt < attempts; attempt++) {
     try {
       const parsed = JSON.parse(await fs.readFile(target, "utf8"))
-      return { version: 4, jobs: Array.isArray(parsed.jobs) ? parsed.jobs : [] }
+      if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.jobs)) {
+        throw new SyntaxError("invalid Loop state schema: jobs must be an array")
+      }
+      return { version: 4, jobs: parsed.jobs }
     } catch (error) {
       if (error?.code === "ENOENT") return { version: 4, jobs: [] }
       const transient = error instanceof SyntaxError || isRetriableStateWriteError(error)
@@ -50,7 +272,7 @@ async function readStateFile(directory, sessionID) {
     await ensureDir(stateDir(directory))
     await fs.copyFile(target, `${target}.corrupt-${Date.now()}`)
   } catch {}
-  return { version: 4, jobs: [] }
+  throw new Error(`OpenCode Loop state at ${target} could not be read; refusing to replace persisted jobs.`)
 }
 
 export async function readState(directory, sessionID) {
@@ -189,23 +411,28 @@ function mergeStateJobs(baseJobs, intendedJobs, currentJobs) {
 
 export async function writeState(directory, sessionID, state) {
   await withStateWriteLock(directory, sessionID, async () => {
-    await ensureDir(stateDir(directory))
     const target = statePath(directory, sessionID)
+    await assertStatePathSafe(directory, target)
+    const current = await readStateFile(directory, sessionID)
     const baseline = state?.[STATE_BASELINE]
     let jobs = structuredClone(state.jobs || [])
     if (Array.isArray(baseline)) {
-      const current = await readStateFile(directory, sessionID)
       jobs = mergeStateJobs(baseline, jobs, current.jobs || [])
-      state.jobs = structuredClone(jobs)
-      state[STATE_BASELINE] = structuredClone(jobs)
     }
     const payload = JSON.stringify({ version: 4, jobs }, null, 2)
     await writeFileAtomically(target, payload)
+    // A failed disk write must not advance the in-memory snapshot baseline.
+    state.jobs = structuredClone(jobs)
+    if (Array.isArray(baseline)) state[STATE_BASELINE] = structuredClone(jobs)
   })
 }
 
 export async function removeState(directory, sessionID) {
   await withStateWriteLock(directory, sessionID, async () => {
-    try { await fs.unlink(statePath(directory, sessionID)) } catch {}
+    const target = statePath(directory, sessionID)
+    await assertStatePathSafe(directory, target)
+    try { await fs.unlink(target) }
+    catch (error) { if (error?.code !== "ENOENT") throw error }
   })
 }
+

package/src/source/opencode2/events.js

@@ -67,7 +67,7 @@ export function normalizeOpenCode2NativeEvent(raw) {
   }
   if (["session.compaction.started", "session.compaction.ended", "session.compaction.failed"].includes(type)) {
     if (!sessionID) return undefined
-    return Object.freeze({ kind: "compaction", action: type.split(".").at(-1), sessionID, directory })
+    return Object.freeze({ kind: "compaction", action: type.split(".").at(-1), sessionID, directory, reason: text(data.reason), inputID: text(data.inputID), error: text(record(data.error)?.message) })
   }
   if (["session.execution.failed", "session.execution.interrupted"].includes(type)) {
     if (!sessionID) return undefined

package/src/source/opencode2/native-plugin.js

@@ -21,7 +21,7 @@ Presets: /loop-dev, /loop-testfix, /loop-progress, /loop-safe-dev, /loop-ask, /l
 Controls: /loop-now, /loop-pause, /loop-resume, /loop-stop, /loop-remove, /loop-clear, /loop-status, /loop-export.
 Preflight, postrun, notifications, stop files, completion markers, runtime/failure/run limits, branches and checkpoints are supported.
 Scheduled shell commands run as bounded local child processes managed by Loop; OpenCode 2's ctx.shell surface is a hook API, not a shell-execution method.
-The public OpenCode 2 plugin API does not expose manual session compaction. /loop-compact, --compact and --compact-every are rejected before job creation on V2; native automatic compaction remains host-owned and is observed through the compaction hook.
+Manual /loop-compact, --compact and --compact-every use public session.compact when the V2 host exposes it. Loop matches the admitted manual compaction inputID and waits for host completion; older hosts without this capability reject the job before creation. Automatic compaction stays host-owned.
 An unfinished dedicated Goal reserves its session; Loop will not override it.
 --timeout pauses future iterations without aborting the current native model/tool/compaction operation.
 --safe is a command heuristic, not a sandbox. --dry-run does not dispatch or run hooks.
@@ -61,11 +61,9 @@ export const OpenCodeLoopNativePlugin = Object.freeze({
       prompt,
       command: typeof ctx.session.command === "function" ? (request) => ctx.session.command(request) : undefined,
       wait: typeof ctx.session.wait === "function" ? (request) => ctx.session.wait(request) : undefined,
-      // OpenCode 2 exposes ctx.shell as a hook domain, not an execution method,
-      // and SessionDomain has no public compact/inbox-cancel action. Keep those
-      // undocumented capabilities out of the V2 runtime instead of probing
-      // private host fields that may disappear between releases.
-      compact: undefined,
+      // Current V2 exposes public session.compact; older hosts may not.
+      // Shell execution and inbox cancellation remain separate from SessionDomain.
+      compact: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact(request) : undefined,
       shell: (request) => shellHost.dispatch(request),
       cancel: undefined,
       onError: (error) => { void appendLoopLog(directory, "v2-native-error", { message: String(error?.message || error) }).catch(() => {}) },

package/src/source/opencode2/native-runtime.js

@@ -134,7 +134,7 @@ export function createNativeLoopRuntime(options = {}) {
   async function finish(scope) {
     const run = scope.active
     if (!run || scope.compaction || scope.busy) return result({ reason: "no-terminal-boundary" })
-    if ((run.kind === "prompt" && !run.delivered) || (run.kind === "command" && !run.commandFinished) || (run.kind === "shell" && !run.shellFinished) || (["compact", "cadence"].includes(run.kind) && !run.compactFinished)) {
+    if ((run.kind === "prompt" && !run.delivered) || (run.kind === "command" && !run.commandFinished) || (run.kind === "shell" && !run.shellFinished) || (["compact", "cadence"].includes(run.kind) && (!run.compactionStarted || !run.compactFinished))) {
       return result({ reason: "awaiting-owned-completion" })
     }
     clear(scope, "deadline")
@@ -368,6 +368,14 @@ export function createNativeLoopRuntime(options = {}) {
     }
     if (event.kind === "compaction" && event.action === "started") {
       scope.compaction ||= { ended: false, terminal: false }
+      // Host versions may differ in compaction inbox-delivery events. The
+      // authoritative boundary is the published manual-compaction inputID
+      // matching our admitted durable item, not delivery alone.
+      if (
+        ["compact", "cadence"].includes(scope.active?.kind)
+        && event.reason === "manual"
+        && event.inputID && event.inputID === scope.active.inboxID
+      ) scope.active.compactionStarted = true
       scope.busy = true
       clear(scope, "timer")
       return result({ reason: "compacting" })
@@ -420,10 +428,28 @@ export function createNativeLoopRuntime(options = {}) {
         return finish(scope)
       }
       if ((event.kind === "session" && ["error", "failed", "interrupted"].includes(event.action)) || (event.kind === "compaction" && event.action === "failed")) {
+        const run = scope.active
+        // Unowned compaction failures must not pause unrelated scheduled Loop
+        // work. An automated host summary can fail when no Loop job owns it,
+        // and a different manual inputID cannot settle our pending request.
+        if (event.kind === "compaction" && event.action === "failed") {
+          const compactRun = ["compact", "cadence"].includes(run?.kind)
+          const owned = compactRun && event.reason === "manual" &&
+            ((event.inputID && event.inputID === run.inboxID) ||
+              (!event.inputID && run.compactionStarted))
+          if (!run || (compactRun && !owned)) {
+            delete scope.compaction
+            scope.busy = false
+            return result({ reason: "unowned-compaction-failed" })
+          }
+        }
         delete scope.compaction
         scope.busy = false
-        const run = scope.active
-        const paused = await pauseActive(scope, event.reason || `${event.kind}-${event.action}`)
+        const detail = String(event.error || "").replace(/\s+/g, " ").trim().slice(0, 160)
+        const reason = event.kind === "compaction"
+          ? `compaction-failed${detail ? `: ${detail}` : ""}`
+          : event.reason || `${event.kind}-${event.action}`
+        const paused = await pauseActive(scope, reason)
         if (run && (run.delivered || ["compact", "cadence", "shell"].includes(run.kind))) {
           const state = await read(scope)
           const job = (state.jobs || []).find((entry) => entry.id === run.jobID)
@@ -435,7 +461,7 @@ export function createNativeLoopRuntime(options = {}) {
       if (event.kind === "compaction" && event.action === "ended") {
         scope.compaction ||= { ended: false, terminal: false }
         scope.compaction.ended = true
-        if (["compact", "cadence"].includes(scope.active?.kind)) scope.active.compactFinished = true
+        if (["compact", "cadence"].includes(scope.active?.kind) && scope.active.compactionStarted && event.reason === "manual") scope.active.compactFinished = true
         if (!scope.compaction.terminal) return result({ reason: "awaiting-execution-terminal" })
       } else if (event.kind === "session" && event.action === "idle") {
         if (scope.compaction) { scope.compaction.terminal = true; if (!scope.compaction.ended) return result({ reason: "awaiting-compaction-end" }) }