@bybrawe/opencode-loop 0.6.5 → 0.6.7

package/src/native.js

@@ -547,6 +547,7 @@ var init_jobs = __esm(() => {
 
 // src/source/core/state.js
 import { promises as fs } from "fs";
+import { randomUUID as stateLockRandomUUID } from "crypto";
 import os from "os";
 import path3 from "path";
 function stateDir(directory) {
@@ -558,6 +559,192 @@ function statePath(directory, sessionID) {
 async function ensureDir(directory) {
   await fs.mkdir(directory, { recursive: true });
 }
+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 = path3.resolve(directory);
+  const relative = path3.relative(root, path3.resolve(target));
+  if (relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative)) {
+    throw stateLockError("unsafe_path", `path escapes project: ${target}`);
+  }
+  let current = root;
+  for (const part of relative.split(path3.sep).filter(Boolean)) {
+    current = path3.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` && path3.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));
+    }
+  }
+  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));
+    }
+  }
+}
+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 (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 = path3.join(stateDir(directory), owner.candidateName);
+  await assertStatePathSafe(directory, candidate);
+  await fs.writeFile(candidate, `${JSON.stringify(owner)}
+`, { flag: "wx", mode: 384 });
+  return candidate;
+}
+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) {
+      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 = path3.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 `${path3.resolve(directory)}:${safeID(sessionID)}`;
 }
@@ -571,21 +758,32 @@ 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: [] };
@@ -599,7 +797,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.`);
 }
 async function readState(directory, sessionID) {
   const state = await readStateFile(directory, sessionID);
@@ -729,28 +927,34 @@ function mergeStateJobs(baseJobs, intendedJobs, currentJobs) {
 }
 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);
+    state.jobs = structuredClone(jobs);
+    if (Array.isArray(baseline))
+      state[STATE_BASELINE] = structuredClone(jobs);
   });
 }
 async function removeState(directory, sessionID) {
   await withStateWriteLock(directory, sessionID, async () => {
+    const target = statePath(directory, sessionID);
+    await assertStatePathSafe(directory, target);
     try {
-      await fs.unlink(statePath(directory, sessionID));
-    } catch {}
+      await fs.unlink(target);
+    } catch (error) {
+      if (error?.code !== "ENOENT")
+        throw error;
+    }
   });
 }
-var STATE_DIR = ".opencode/opencode-loop", STATE_BASELINE, stateWriteLocks;
+var STATE_DIR = ".opencode/opencode-loop", STATE_BASELINE, stateWriteLocks, STATE_PROCESS_LOCK_TIMEOUT_MS = 5000, STATE_PROCESS_LOCK_POLL_MS = 20;
 var init_state = __esm(() => {
   STATE_BASELINE = Symbol("opencode-loop-state-baseline");
   stateWriteLocks = new Map;
@@ -1824,7 +2028,7 @@ function createNativeLoopRuntime(options = {}) {
     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");
@@ -2100,6 +2304,8 @@ ${await policy.buildPrompt(scope.directory, job)}`, delivery: "queue", metadata:
     }
     if (event.kind === "compaction" && event.action === "started") {
       scope.compaction ||= { ended: false, terminal: false };
+      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" });
@@ -2160,10 +2366,21 @@ ${await policy.buildPrompt(scope.directory, job)}`, delivery: "queue", metadata:
         return finish(scope);
       }
       if (event.kind === "session" && ["error", "failed", "interrupted"].includes(event.action) || event.kind === "compaction" && event.action === "failed") {
+        const run = scope.active;
+        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);
@@ -2179,7 +2396,7 @@ ${await policy.buildPrompt(scope.directory, job)}`, delivery: "queue", metadata:
       if (event.kind === "compaction" && event.action === "ended") {
         scope.compaction ||= { ended: false, terminal: false };
         scope.compaction.ended = true;
-        if (["compact", "cadence"].includes(scope.active?.kind))
+        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" });
@@ -2663,7 +2880,7 @@ function normalizeOpenCode2NativeEvent(raw) {
   if (["session.compaction.started", "session.compaction.ended", "session.compaction.failed"].includes(type)) {
     if (!sessionID)
       return;
-    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: text2(data.reason), inputID: text2(data.inputID), error: text2(record2(data.error)?.message) });
   }
   if (["session.execution.failed", "session.execution.interrupted"].includes(type)) {
     if (!sessionID)
@@ -2964,7 +3181,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.
@@ -3010,7 +3227,7 @@ var 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,
-      compact: undefined,
+      compact: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact(request) : undefined,
       shell: (request) => shellHost.dispatch(request),
       cancel: undefined,
       onError: (error) => {