@bybrawe/opencode-loop 0.5.19 → 0.5.21

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.5.21
+
+- Verified server-plugin compatibility against OpenCode 1.18.15 and updated the development plugin dependency accordingly.
+- Stopped clearing `command.execute.before` output parts. Current OpenCode still creates a command prompt turn for server-plugin slash commands, so control commands keep the valid tool-denied `opencode-loop-local` acknowledgement instead of producing an empty message.
+- Prefer the current `session.compact` TUI command value while retaining `session_compact` and `session.summarize` as compatibility fallbacks.
+- Fixed the comprehensive preflight failure test to use a cross-platform shell-safe Node expression.
+- Added Ubuntu and Windows pull-request CI, and hardened npm publishing with full tests, tag/version verification, and `npm pack --dry-run`.
+- Retained the v0.5.20 Windows state-write retry hardening and deterministic EPERM/partial-read regressions.
+
+## 0.5.20
+
+- Fixed Windows TUI loop state writes failing with `EPERM` / `EEXIST` when renaming a project-local `*.tmp` over an existing session state file. Heartbeat and due-timer updates no longer drop jobs when antivirus, IDE indexers, or OpenCode snapshots briefly lock the destination.
+- Write atomic state payloads under the OS temp directory first, then replace the target with rename plus a copy/unlink fallback and short retries, so project trees no longer accumulate `opencode-loop/*.tmp` files that OpenCode tried to git-snapshot.
+
 ## 0.5.19
 
 - Made the asynchronous goal prompt smoke test wait for the observable SDK call instead of assuming a single event-loop tick is always sufficient under load.

package/README.md

@@ -16,7 +16,7 @@ v0.5.11 includes a referenced heartbeat scheduler. This is important in OpenCode
 
 ## Current status
 
-**v0.5.19 hardens Goal Mode, package updates, and the background daemon.** Package installs are pinned to the installed version so OpenCode cannot keep loading an older cached release, scheduler-created goal messages no longer self-interrupt on delayed updates, finite daemon failures return nonzero, model/agent selection is supported, Windows scheduled tasks use a short launcher that stays below the `/TR` limit, and asynchronous release verification is reliable under load.
+**v0.5.21 targets current OpenCode 1.18.x compatibility and safer releases.** Server-plugin control commands keep their locked-down acknowledgement prompt instead of creating an empty command message, `/compact` prefers the current `session.compact` TUI command, and CI now covers Ubuntu and Windows before publishing. **v0.5.20 fixes Windows TUI state writes.** Session job state is written through the OS temp directory with rename plus copy/unlink fallback and short retries, so antivirus locks and OpenCode snapshots no longer drop `/loop` jobs with `EPERM` on rename. **v0.5.19** hardens Goal Mode, package updates, and the background daemon: package installs are pinned to the installed version so OpenCode cannot keep loading an older cached release, scheduler-created goal messages no longer self-interrupt on delayed updates, finite daemon failures return nonzero, model/agent selection is supported, Windows scheduled tasks use a short launcher that stays below the `/TR` limit, and asynchronous release verification is reliable under load.
 
 The known update-related symptoms from older builds are fixed:
 
@@ -1087,6 +1087,8 @@ Recent plugin events are appended to:
 .opencode/opencode-loop/loop.log
 ```
 
+Add `.opencode/opencode-loop/` to project `.gitignore` when possible. Runtime state is rewritten often, and on Windows file locks from scanners or snapshot tools can interrupt in-place renames. Since v0.5.20 the plugin writes state payloads via the OS temp directory with a rename/copy fallback so jobs survive those locks; gitignoring the directory still keeps noise out of commits.
+
 ## Example progress.md
 
 Create one with:
@@ -1130,6 +1132,11 @@ Improve the application in small safe steps.
 
 ## Changelog highlights
 
+### v0.5.20
+
+- Fixed Windows `EPERM` / `EEXIST` failures when rewriting `.opencode/opencode-loop/ses_*.json` during heartbeat and due-timer updates.
+- Atomic state payloads are staged outside the project so OpenCode no longer git-snapshots `opencode-loop/*.tmp` pathspecs.
+
 ### v0.5.17
 
 - Added a tool-denied local command agent and restored the normal coding agent/model for scheduled iterations.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "description": "Claude Code/Codex style /loop and experimental goal mode for OpenCode: heartbeat scheduler, idle-safe loops, scheduled commands, compact scheduling, verification, checkpoints, and persistent coding goals.",
   "type": "module",
   "main": "src/index.js",
@@ -57,7 +57,7 @@
     "@opencode-ai/plugin": ">=1.4.0"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.4.0"
+    "@opencode-ai/plugin": "^1.18.15"
   },
   "bin": {
     "opencode-loop": "scripts/install-node.mjs",

package/scripts/comprehensive-test.mjs

@@ -106,6 +106,7 @@ async function createHarness(options = {}) {
     hooks,
     records,
     sessionID,
+    stateFile,
     statuses,
     async command(command, argumentsText = "", output = { parts: [] }) {
       await hooks["command.execute.before"]({ command, sessionID, arguments: argumentsText }, output)
@@ -242,7 +243,10 @@ async function testLifecycleAndCommandDedupe() {
     assert.equal(state.jobs.find((item) => item.name === "same").paused, false)
 
     const beforeReports = h.reportTexts().length
-    await h.command("loop-status")
+    const statusOutput = { parts: [{ type: "text", text: "OpenCode Loop status command handled locally. Reply exactly: OK." }] }
+    await h.command("loop-status", "", statusOutput)
+    assert.equal(statusOutput.parts.length, 1, "handled commands must keep a valid acknowledgement prompt")
+    assert.match(statusOutput.parts[0].text, /Reply exactly: OK/)
     await h.commandEvent("loop-status", "", "msg_status_1")
     assert.equal(h.reportTexts().length, beforeReports + 1, "command.executed must not duplicate the before hook")
     await h.command("loop-status")
@@ -383,7 +387,7 @@ async function testStopsPreflightAndGoalLifecycle() {
 
   h = await createHarness()
   try {
-    await h.command("loop", "5m --no-now --preflight \"node -e process.exit(7)\" continue")
+    await h.command("loop", "5m --no-now --preflight \"node -e process.exitCode=7\" continue")
     await h.command("loop-now")
     const state = await h.readState()
     assert.equal(state.jobs[0].paused, true)
@@ -475,6 +479,86 @@ async function testInitializationDoesNotWaitForLocalApi() {
   }
 }
 
+async function testWindowsSafeStatePersistence() {
+  const h = await createHarness()
+  try {
+    const stateDir = path.join(h.directory, ".opencode", "opencode-loop")
+
+    // Rapid replacements exercise atomic overwrite of an existing state file.
+    // On Windows this used to fail with EPERM when rename targeted a locked file
+    // next to a project-local *.tmp, leaving jobs empty and the heartbeat stuck.
+    for (let index = 0; index < 25; index++) {
+      await h.command("loop", `10m --no-now --name sticky action-${index}`)
+    }
+
+    const state = await h.readState()
+    assert.equal(state.jobs.length, 1)
+    assert.equal(state.jobs[0].name, "sticky")
+    assert.equal(state.jobs[0].action, "action-24")
+
+    // Temp payloads must live outside the project so OpenCode git snapshots and
+    // Windows file locks do not see opencode-loop/*.tmp pathspecs.
+    const leftovers = (await fs.readdir(stateDir)).filter((name) => name.endsWith(".tmp"))
+    assert.deepEqual(leftovers, [], "state writes must not leave project-local temp files")
+
+    await h.command("loop-clear")
+    const cleared = await h.readState()
+    assert.equal(cleared.jobs.length, 0)
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testWindowsStateRenameRetriesBeforeFallback() {
+  const h = await createHarness()
+  const originalRename = fs.rename
+  const originalCopyFile = fs.copyFile
+  let renameAttempts = 0
+  let fallbackCopies = 0
+  fs.rename = async (source, target) => {
+    if (target === h.stateFile && renameAttempts++ < 2) {
+      const error = new Error("simulated Windows destination lock")
+      error.code = "EPERM"
+      throw error
+    }
+    return await originalRename(source, target)
+  }
+  fs.copyFile = async (source, target, ...rest) => {
+    if (target === h.stateFile) fallbackCopies++
+    return await originalCopyFile(source, target, ...rest)
+  }
+  try {
+    await h.command("loop", "10m --no-now --name retry-safe keep-state")
+    const state = await h.readState()
+    assert.equal(state.jobs[0]?.name, "retry-safe")
+    assert.equal(renameAttempts, 3, "transient EPERM should retry rename")
+    assert.equal(fallbackCopies, 0, "successful rename retry should avoid non-atomic copy fallback")
+  } finally {
+    fs.rename = originalRename
+    fs.copyFile = originalCopyFile
+    await h.cleanup()
+  }
+}
+
+async function testStateReadRetriesTransientPartialJson() {
+  const h = await createHarness()
+  const originalReadFile = fs.readFile
+  try {
+    await h.command("loop", "10m --no-now --name sticky survive-partial-read")
+    let partialReads = 0
+    fs.readFile = async (filePath, ...rest) => {
+      if (filePath === h.stateFile && partialReads++ < 2) return "{"
+      return await originalReadFile(filePath, ...rest)
+    }
+    await h.command("loop-status")
+    assert.equal(partialReads, 3, "partial JSON should be retried before treating state as corrupt")
+    assert.equal(h.records.toasts.at(-1)?.message, "1 loop job(s).")
+  } finally {
+    fs.readFile = originalReadFile
+    await h.cleanup()
+  }
+}
+
 await testParserAndPresets()
 await testLifecycleAndCommandDedupe()
 await testWatchScheduling()
@@ -482,5 +566,8 @@ await testActionRoutingAndSafety()
 await testStopsPreflightAndGoalLifecycle()
 await testLoopOwnedGoalMessageUpdatesDoNotSelfInterrupt()
 await testInitializationDoesNotWaitForLocalApi()
+await testWindowsSafeStatePersistence()
+await testWindowsStateRenameRetriesBeforeFallback()
+await testStateReadRetriesTransientPartialJson()
 
 console.log("OpenCode Loop comprehensive test passed")

package/scripts/smoke-test.mjs

@@ -92,7 +92,8 @@ try {
     sessionID,
     arguments: "Create proof.txt and verify it --max-turns 3",
   }, output)
-  assert.equal(output.parts.length, 0, "a locally handled slash command must not start a placeholder model turn")
+  assert.equal(output.parts.length, 1, "a locally handled slash command must keep a valid acknowledgement prompt")
+  assert.equal(output.parts[0].text, "original command body")
 
   await hooks["command.execute.before"]({ command: "loop-now", sessionID, arguments: "goal" }, { parts: [] })
   assert.equal(

package/src/index.js

@@ -1,4 +1,5 @@
 import { promises as fs } from "node:fs"
+import os from "node:os"
 import path from "node:path"
 import { spawn } from "node:child_process"
 import { tool } from "@opencode-ai/plugin/tool"
@@ -373,17 +374,85 @@ async function withStateWriteLock(directory, sessionID, fn) {
 
 async function readState(directory, sessionID) {
   const target = statePath(directory, sessionID)
+  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 : [] }
+    } catch (error) {
+      if (error?.code === "ENOENT") return { version: 4, jobs: [] }
+      const transient = error instanceof SyntaxError || isRetriableStateWriteError(error)
+      if (!transient || attempt === attempts - 1) break
+      await delay(25 * (attempt + 1))
+    }
+  }
   try {
-    const parsed = JSON.parse(await fs.readFile(target, "utf8"))
-    return { version: 4, jobs: Array.isArray(parsed.jobs) ? parsed.jobs : [] }
-  } catch (error) {
-    if (error?.code !== "ENOENT") {
+    await ensureDir(stateDir(directory))
+    await fs.copyFile(target, `${target}.corrupt-${Date.now()}`)
+  } catch {}
+  return { version: 4, jobs: [] }
+}
+
+function isRetriableStateWriteError(error) {
+  const code = error?.code
+  return code === "EPERM" || code === "EACCES" || code === "EBUSY" || code === "EEXIST" || code === "EAGAIN"
+}
+
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+// Windows often fails POSIX-style "write temp next to target, then rename over it":
+// existing destinations can return EPERM/EEXIST while antivirus, IDE indexers, or
+// OpenCode's own snapshotter briefly hold the state file. Temp files next to the
+// target also show up in project git snapshots as *.tmp pathspec noise.
+//
+// Write the payload outside the project first, then replace the target with
+// rename when possible and a copy/unlink fallback with short retries.
+async function writeFileAtomically(target, contents, options = {}) {
+  const encoding = options.encoding || "utf8"
+  const attempts = Math.max(1, Number(options.attempts) || 5)
+  const temp = path.join(
+    os.tmpdir(),
+    `opencode-loop-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`,
+  )
+  await fs.writeFile(temp, contents, encoding)
+  try {
+    let lastError
+    // Prefer an atomic rename and retry transient Windows destination locks
+    // before falling back to a non-atomic copy/overwrite.
+    for (let attempt = 0; attempt < attempts; attempt++) {
       try {
-        await ensureDir(stateDir(directory))
-        await fs.copyFile(target, `${target}.corrupt-${Date.now()}`)
-      } catch {}
+        await fs.rename(temp, target)
+        return
+      } catch (error) {
+        lastError = error
+        if (error?.code === "EXDEV") break
+        if (!isRetriableStateWriteError(error)) throw error
+        if (attempt < attempts - 1) await delay(25 * (attempt + 1))
+      }
+    }
+
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        await fs.copyFile(temp, target)
+        return
+      } catch (error) {
+        lastError = error
+        if (!isRetriableStateWriteError(error)) throw error
+        if (attempt < attempts - 1) await delay(25 * (attempt + 1))
+      }
     }
-    return { version: 4, jobs: [] }
+
+    try {
+      await fs.writeFile(target, contents, encoding)
+      return
+    } catch (error) {
+      if (lastError && !error.cause) error.cause = lastError
+      throw error
+    }
+  } finally {
+    try { await fs.rm(temp, { force: true }) } catch {}
   }
 }
 
@@ -391,13 +460,8 @@ async function writeState(directory, sessionID, state) {
   await withStateWriteLock(directory, sessionID, async () => {
     await ensureDir(stateDir(directory))
     const target = statePath(directory, sessionID)
-    const temp = `${target}.${process.pid}.${Date.now()}.tmp`
-    try {
-      await fs.writeFile(temp, JSON.stringify({ version: 4, jobs: state.jobs || [] }, null, 2))
-      await fs.rename(temp, target)
-    } finally {
-      try { await fs.rm(temp, { force: true }) } catch {}
-    }
+    const payload = JSON.stringify({ version: 4, jobs: state.jobs || [] }, null, 2)
+    await writeFileAtomically(target, payload)
   })
 }
 
@@ -471,7 +535,7 @@ async function compactSession(client, sessionID) {
   // current builds, while some older docs/examples mention the event value
   // (session.compact). Try the alias first, then the event value, then the
   // session summarize endpoint as a last resort.
-  for (const command of ["session_compact", "session.compact"]) {
+  for (const command of ["session.compact", "session_compact"]) {
     try {
       await executeTuiCommand(client, command)
       return true
@@ -2156,12 +2220,9 @@ async function handleCommand(directory, client, input, fallbackName, fallbackArg
   if (isLoopCommandName(name)) guardLoopOwnedUserMessage(sessionID)
 
   const handled = () => {
-    if (output && Array.isArray(output.parts)) {
-      // The command has already been completed through toasts/noReply prompts
-      // and local state. Leaving a placeholder prompt starts an unnecessary
-      // model turn; weaker agents may even call tools or spawn subagents.
-      output.parts.length = 0
-    }
+    // OpenCode server plugins cannot currently cancel the command prompt turn.
+    // Keep the command markdown acknowledgement intact so opencode-loop-local
+    // receives a valid, tool-denied message instead of an empty parts array.
     return true
   }