@bybrawe/opencode-loop 0.5.15 → 0.5.17

package/scripts/comprehensive-test.mjs

@@ -0,0 +1,455 @@
+import assert from "node:assert/strict"
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+import OpenCodeLoopPlugin from "../src/index.js"
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+let harnessNumber = 0
+
+async function createHarness(options = {}) {
+  harnessNumber++
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), `opencode-loop-comprehensive-${harnessNumber}-`))
+  const sessionID = `ses_comprehensive_${harnessNumber}`
+  const records = {
+    aborts: [],
+    commands: [],
+    logs: [],
+    prompts: [],
+    shells: [],
+    toasts: [],
+    tuiCommands: [],
+  }
+  const statuses = new Map([[sessionID, "idle"]])
+
+  const client = {
+    app: {
+      log: async (args) => {
+        assert.ok(args?.body, "app.log must use the SDK body shape")
+        records.logs.push(args.body)
+        return { data: true }
+      },
+    },
+    tui: {
+      executeCommand: async (args) => {
+        assert.ok(args?.body?.command, "tui.executeCommand must use the SDK body shape")
+        records.tuiCommands.push(args.body.command)
+        if (options.failCompact) throw new Error("simulated TUI compact failure")
+        return { data: true }
+      },
+      showToast: async (args) => {
+        assert.ok(args?.body?.message, "tui.showToast must use the SDK body shape")
+        records.toasts.push(args.body)
+        return { data: true }
+      },
+    },
+    session: {
+      list: async (args) => {
+        assert.equal(args?.query?.directory, directory)
+        return {
+          data: [...statuses.keys()].map((id) => ({
+            id,
+            directory,
+            projectID: "comprehensive",
+            title: id,
+            version: "test",
+            time: { created: Date.now(), updated: Date.now() },
+          })),
+        }
+      },
+      get: async (args) => {
+        assert.equal(args?.path?.id, sessionID)
+        return { data: { id: sessionID, agent: "build", model: { id: "test-model", providerID: "test-provider" } } }
+      },
+      abort: async (args) => {
+        records.aborts.push(args?.path?.id)
+        return { data: true }
+      },
+      command: async (args) => {
+        assert.equal(args?.path?.id, sessionID)
+        records.commands.push(args.body)
+        return { data: true }
+      },
+      prompt: async (args) => {
+        assert.equal(args?.path?.id, sessionID)
+        const text = args.body.parts.map((part) => part.text || "").join("\n")
+        records.prompts.push({ text, noReply: args.body.noReply === true, agent: args.body.agent, model: args.body.model })
+        return { data: true }
+      },
+      shell: async (args) => {
+        assert.equal(args?.path?.id, sessionID)
+        records.shells.push(args.body)
+        return { data: true }
+      },
+      status: async (args) => {
+        assert.equal(args?.query?.directory, directory)
+        // Current OpenCode omits idle sessions from this response.
+        return {
+          data: Object.fromEntries(
+            [...statuses].filter(([, type]) => type !== "idle").map(([id, type]) => [id, { type }]),
+          ),
+        }
+      },
+      summarize: async () => {
+        if (options.failCompact) throw new Error("simulated summarize failure")
+        return { data: true }
+      },
+    },
+  }
+
+  const hooks = await OpenCodeLoopPlugin({ client, directory })
+  const stateFile = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+  return {
+    client,
+    directory,
+    hooks,
+    records,
+    sessionID,
+    statuses,
+    async command(command, argumentsText = "", output = { parts: [] }) {
+      await hooks["command.execute.before"]({ command, sessionID, arguments: argumentsText }, output)
+      return output
+    },
+    async commandEvent(command, argumentsText = "", messageID = `msg_${Date.now()}_${Math.random()}`) {
+      await hooks.event({ event: { type: "command.executed", properties: { name: command, sessionID, arguments: argumentsText, messageID } } })
+    },
+    async idle() {
+      statuses.set(sessionID, "idle")
+      await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+    },
+    async readState() {
+      try {
+        return JSON.parse(await fs.readFile(stateFile, "utf8"))
+      } catch (error) {
+        if (error?.code === "ENOENT") return { version: 4, jobs: [] }
+        throw error
+      }
+    },
+    reportTexts() {
+      return records.prompts.filter((item) => item.noReply).map((item) => item.text)
+    },
+    actionTexts() {
+      return records.prompts.filter((item) => !item.noReply).map((item) => item.text)
+    },
+    async cleanup() {
+      await hooks.dispose?.()
+      await fs.rm(directory, { recursive: true, force: true })
+    },
+  }
+}
+
+function jsonReport(harness) {
+  const report = [...harness.reportTexts()].reverse().find((text) => text.includes("```json"))
+  assert.ok(report, "expected a JSON report")
+  const match = report.match(/```json\s*([\s\S]*?)\s*```/)
+  assert.ok(match, "expected a fenced JSON object")
+  return JSON.parse(match[1])
+}
+
+async function testParserAndPresets() {
+  const h = await createHarness()
+  try {
+    await h.command("loop", "3m --name matrix --no-now --allow-overlap --safe --quiet --ask-never --git-checkpoint --checkpoint-only --pause-on-verify-fail --multi --prompt --max-runs 4 --max-no-progress 2 --timeout 7s --max-runtime 2h --max-failures 3 --until \"2030-01-01T00:00:00Z\" --stop-file stop.txt --progress-file progress.md --prompt-file prompt.md --goal-file goal.md --evidence-file evidence.md --test \"npm test\" --verify \"npm run verify\" --preflight \"npm run preflight\" --postrun \"npm run postrun\" --notify \"node notify.js\" --branch feature/test --batch 2 --compact-every 5 --watch one.txt --watch two.txt --include-file context.md --acceptance \"criterion A\" --success \"criterion B\" --check \"npm test\" --dry-run perform matrix work")
+    const job = jsonReport(h)
+    assert.equal(job.intervalMs, 180_000)
+    assert.equal(job.name, "matrix")
+    assert.equal(job.action, "perform matrix work")
+    assert.equal(job.kind, "prompt")
+    assert.equal(job.immediate, false)
+    assert.equal(job.noOverlap, false)
+    assert.equal(job.safe, true)
+    assert.equal(job.quiet, true)
+    assert.equal(job.askNever, true)
+    assert.equal(job.gitCheckpoint, true)
+    assert.equal(job.checkpointOnly, true)
+    assert.equal(job.pauseOnVerifyFail, true)
+    assert.equal(job.multi, true)
+    assert.equal(job.maxRuns, 4)
+    assert.equal(job.maxNoProgress, 2)
+    assert.equal(job.timeoutMs, 7_000)
+    assert.equal(job.maxRuntimeMs, 7_200_000)
+    assert.equal(job.maxFailures, 3)
+    assert.equal(job.stopFile, "stop.txt")
+    assert.equal(job.testCommand, "npm test")
+    assert.equal(job.verifyCommand, "npm run verify")
+    assert.equal(job.preflightCommand, "npm run preflight")
+    assert.equal(job.postrunCommand, "npm run postrun")
+    assert.equal(job.notifyCommand, "node notify.js")
+    assert.equal(job.branch, "feature/test")
+    assert.equal(job.batch, 2)
+    assert.equal(job.compactEveryRuns, 5)
+    assert.deepEqual(job.watchPaths, ["one.txt", "two.txt"])
+    assert.deepEqual(job.includeFiles, ["context.md"])
+    assert.deepEqual(job.goalAcceptance, ["criterion A", "criterion B"])
+    assert.deepEqual(job.goalChecks, ["npm test"])
+
+    await h.command("loop-compact", "0s --dry-run")
+    let preset = jsonReport(h)
+    assert.equal(preset.intervalMs, 0, "explicit 0s must not become the 200m default")
+    assert.equal(preset.action, "/compact")
+    assert.equal(preset.kind, "compact")
+
+    await h.command("loop-compact", "--dry-run")
+    preset = jsonReport(h)
+    assert.equal(preset.intervalMs, 12_000_000)
+    assert.equal(preset.action, "/compact", "a flag-only preset must keep its real default action")
+
+    await h.command("loop-safe-dev", "--dry-run --safe")
+    preset = jsonReport(h)
+    assert.match(preset.action, /Develop the project/)
+    assert.notEqual(preset.action, "--safe")
+
+    await h.command("loop-testfix", "5m pnpm test --dry-run")
+    preset = jsonReport(h)
+    assert.equal(preset.intervalMs, 300_000)
+    assert.equal(preset.verifyCommand, "pnpm test")
+    assert.match(preset.action, /Test command hint: pnpm test/)
+
+    await h.command("loop-testfix", "--verify \"npm run ci\" --dry-run")
+    preset = jsonReport(h)
+    assert.equal(preset.verifyCommand, "npm run ci")
+    assert.match(preset.action, /Test command hint: npm run ci/)
+
+    const toastCount = h.records.toasts.length
+    await h.command("loop", "nonsense")
+    await h.command("loop", "5m")
+    assert.equal(h.records.toasts.length, toastCount + 2)
+    assert.ok(h.records.toasts.slice(-2).every((item) => item.variant === "warning"))
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testLifecycleAndCommandDedupe() {
+  const h = await createHarness()
+  try {
+    await h.command("loop", "10m --no-now --name same first action")
+    await h.command("loop", "10m --no-now --name same replacement action")
+    let state = await h.readState()
+    assert.equal(state.jobs.length, 1)
+    assert.equal(state.jobs[0].action, "replacement action")
+
+    await h.command("loop", "10m --no-now --multi --name extra additional action")
+    state = await h.readState()
+    assert.equal(state.jobs.length, 2)
+
+    await h.command("loop-pause", "same")
+    state = await h.readState()
+    assert.equal(state.jobs.find((item) => item.name === "same").paused, true)
+    await h.command("loop-resume", "same")
+    state = await h.readState()
+    assert.equal(state.jobs.find((item) => item.name === "same").paused, false)
+
+    const beforeReports = h.reportTexts().length
+    await h.command("loop-status")
+    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")
+    await h.commandEvent("loop-status", "", "msg_status_2")
+    assert.equal(h.reportTexts().length, beforeReports + 2, "an intentional repeated command must not be swallowed")
+    await h.commandEvent("loop-status", "", "msg_event_only")
+    await h.commandEvent("loop-status", "", "msg_event_only")
+    assert.equal(h.reportTexts().length, beforeReports + 3, "the same event message must only be handled once")
+
+    await h.command("loop-stop", "same")
+    state = await h.readState()
+    assert.deepEqual(state.jobs.map((item) => item.name), ["extra"])
+    await h.command("loop-clear")
+    state = await h.readState()
+    assert.equal(state.jobs.length, 0)
+
+    await h.command("loop-init")
+    const progress = path.join(h.directory, "progress.md")
+    assert.match(await fs.readFile(progress, "utf8"), /Active TODO/)
+    await fs.writeFile(progress, "custom progress", "utf8")
+    await h.command("loop-init")
+    assert.equal(await fs.readFile(progress, "utf8"), "custom progress", "loop-init must not overwrite user progress")
+
+    for (const command of ["loop-help", "loop-doctor", "loop-export", "loop-logs"]) await h.command(command)
+    assert.ok(h.reportTexts().some((text) => text.includes("OpenCode Loop help")))
+    assert.ok(h.reportTexts().some((text) => text.includes("OpenCode Loop doctor")))
+    assert.ok(h.reportTexts().some((text) => text.includes("state export")))
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testWatchScheduling() {
+  const h = await createHarness()
+  try {
+    const watched = path.join(h.directory, "watched.txt")
+    await fs.writeFile(watched, "one", "utf8")
+    await h.command("loop", "0s --watch watched.txt --max-runs 1 react to watched file")
+    await h.idle()
+    await delay(1_400)
+    assert.equal(h.actionTexts().length, 0, "watch loop must not run until a watched file changes")
+
+    await fs.writeFile(watched, "two and changed size", "utf8")
+    await h.idle()
+    await delay(1_500)
+    assert.equal(h.actionTexts().length, 1, "watch loop must run after a watched file changes")
+    assert.match(h.actionTexts()[0], /react to watched file/)
+    const actionPrompt = h.records.prompts.find((item) => !item.noReply)
+    assert.equal(actionPrompt.agent, "build", "scheduled work must restore the normal coding agent")
+    assert.deepEqual(actionPrompt.model, { providerID: "test-provider", modelID: "test-model" })
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testActionRoutingAndSafety() {
+  let h = await createHarness()
+  try {
+    await h.command("loop-shell", "0s --safe npm run format")
+    await h.command("loop-now", "shell")
+    await delay(25)
+    assert.equal(h.records.shells.length, 1)
+    assert.equal(h.records.shells[0].command, "npm run format", "safe mode must allow a harmless format script")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop-shell", "0s --safe Remove-Item -Recurse ./important")
+    await h.command("loop-now", "shell")
+    await delay(25)
+    assert.equal(h.records.shells.length, 0)
+    const state = await h.readState()
+    assert.equal(state.jobs[0].paused, true, "a blocked synchronous action must pause instead of retrying forever")
+    assert.equal(state.jobs[0].failureCount, 1)
+    assert.equal(state.jobs[0].lastFailureReason, "safe_shell_blocked")
+
+    await h.command("loop-clear")
+    await h.command("loop-shell", "0s --safe rm -r -f ./important")
+    await h.command("loop-now", "shell")
+    const separateFlagsState = await h.readState()
+    assert.equal(h.records.shells.length, 0)
+    assert.equal(separateFlagsState.jobs[0].lastFailureReason, "safe_shell_blocked", "separate rm -r -f flags must be blocked")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await fs.writeFile(path.join(h.directory, "empty.md"), "fallback context", "utf8")
+    await h.command("loop-command", "0s --prompt-file empty.md")
+    await h.command("loop-now", "command")
+    const state = await h.readState()
+    assert.equal(state.jobs[0].paused, true)
+    assert.equal(state.jobs[0].lastFailureReason, "empty_command")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness({ failCompact: true })
+  try {
+    await h.command("loop-compact", "0s")
+    await h.command("loop-now", "compact")
+    const state = await h.readState()
+    assert.equal(state.jobs[0].paused, true)
+    assert.equal(state.jobs[0].lastFailureReason, "compact_failed")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop-command", "0s /custom-command alpha beta")
+    await h.command("loop-now", "command")
+    await delay(25)
+    assert.deepEqual(h.records.commands[0], {
+      command: "custom-command",
+      arguments: "alpha beta",
+      agent: "build",
+      model: "test-provider/test-model",
+    })
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testStopsPreflightAndGoalLifecycle() {
+  let h = await createHarness()
+  try {
+    await h.command("loop", "5m --no-now --stop-file STOP continue")
+    await fs.writeFile(path.join(h.directory, "STOP"), "stop", "utf8")
+    await h.command("loop-now")
+    assert.equal((await h.readState()).jobs.length, 0)
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop", "5m --no-now --preflight \"node -e process.exit(7)\" continue")
+    await h.command("loop-now")
+    const state = await h.readState()
+    assert.equal(state.jobs[0].paused, true)
+    assert.equal(state.jobs[0].failureCount, 1)
+    assert.match(state.jobs[0].lastPreflightFailure, /exit=7/)
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop-goal", "Ship the feature --acceptance \"tests pass\" --max-turns 3")
+    await h.command("loop-now", "goal")
+    await delay(25)
+    assert.match(h.actionTexts()[0], /Goal objective:\nShip the feature/)
+    const progress = await h.hooks.tool.opencode_loop_goal_progress.execute(
+      { summary: "Implemented the first part", next: "Run verification" },
+      { directory: h.directory, sessionID: h.sessionID },
+    )
+    assert.equal(progress.title, "Goal progress")
+    let state = await h.readState()
+    assert.equal(state.jobs[0].goalProgress.length, 1)
+    const blocked = await h.hooks.tool.opencode_loop_goal_blocked.execute(
+      { reason: "Credential is missing", needed: "Provide a test credential" },
+      { directory: h.directory, sessionID: h.sessionID },
+    )
+    assert.equal(blocked.title, "Goal blocked")
+    state = await h.readState()
+    assert.equal(state.jobs[0].goalStatus, "blocked")
+    assert.equal(state.jobs[0].paused, true)
+    await h.command("loop-goal-resume")
+    state = await h.readState()
+    assert.equal(state.jobs[0].goalStatus, "active")
+    assert.equal(state.jobs[0].paused, false)
+    await h.command("loop-goal-clear")
+    assert.equal((await h.readState()).jobs.length, 0)
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testInitializationDoesNotWaitForLocalApi() {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-init-deadlock-"))
+  const never = new Promise(() => {})
+  const client = {
+    app: { log: async () => never },
+    tui: { showToast: async () => ({ data: true }) },
+    session: { list: async () => never },
+  }
+  try {
+    const hooks = await Promise.race([
+      OpenCodeLoopPlugin({ client, directory }),
+      delay(500).then(() => { throw new Error("plugin initialization waited for the local OpenCode API") }),
+    ])
+    assert.equal(typeof hooks.event, "function")
+    await hooks.dispose?.()
+  } finally {
+    await fs.rm(directory, { recursive: true, force: true })
+  }
+}
+
+await testParserAndPresets()
+await testLifecycleAndCommandDedupe()
+await testWatchScheduling()
+await testActionRoutingAndSafety()
+await testStopsPreflightAndGoalLifecycle()
+await testInitializationDoesNotWaitForLocalApi()
+
+console.log("OpenCode Loop comprehensive test passed")

package/scripts/install-node.mjs

@@ -8,7 +8,87 @@ const root = dirname(dirname(fileURLToPath(import.meta.url)))
 const config = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode")
 const pluginDir = join(config, "plugins")
 const commandDir = join(config, "commands")
+const agentDir = join(config, "agents")
 const packagePath = join(config, "package.json")
+const packageName = "@bybrawe/opencode-loop"
+
+function stripJsonComments(input) {
+  let output = ""
+  let quote = ""
+  let escaped = false
+  let lineComment = false
+  let blockComment = false
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index]
+    const next = input[index + 1]
+    if (lineComment) {
+      if (char === "\n" || char === "\r") { lineComment = false; output += char }
+      continue
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") { blockComment = false; index++ }
+      else if (char === "\n" || char === "\r") output += char
+      continue
+    }
+    if (quote) {
+      output += char
+      if (escaped) escaped = false
+      else if (char === "\\") escaped = true
+      else if (char === quote) quote = ""
+      continue
+    }
+    if (char === '"') { quote = char; output += char; continue }
+    if (char === "/" && next === "/") { lineComment = true; index++; continue }
+    if (char === "/" && next === "*") { blockComment = true; index++; continue }
+    output += char
+  }
+  return output
+}
+
+function stripTrailingCommas(input) {
+  let output = ""
+  let quote = ""
+  let escaped = false
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index]
+    if (quote) {
+      output += char
+      if (escaped) escaped = false
+      else if (char === "\\") escaped = true
+      else if (char === quote) quote = ""
+      continue
+    }
+    if (char === '"') { quote = char; output += char; continue }
+    if (char === ",") {
+      let lookahead = index + 1
+      while (/\s/.test(input[lookahead] || "")) lookahead++
+      if (input[lookahead] === "]" || input[lookahead] === "}") continue
+    }
+    output += char
+  }
+  return output
+}
+
+function parseJsonc(input) {
+  return JSON.parse(stripTrailingCommas(stripJsonComments(input)))
+}
+
+function isPackageSpec(value) {
+  const spec = String(value || "").trim()
+  return spec === packageName || spec.startsWith(`${packageName}@`)
+}
+
+async function packagePluginConfigured() {
+  for (const name of ["opencode.json", "opencode.jsonc", "config.json", "config.jsonc"]) {
+    try {
+      const parsed = parseJsonc(await readFile(join(config, name), "utf8"))
+      if (Array.isArray(parsed?.plugin) && parsed.plugin.some(isPackageSpec)) return true
+    } catch (error) {
+      if (error?.code !== "ENOENT") console.warn(`Could not inspect ${join(config, name)} for duplicate plugin entries: ${error.message}`)
+    }
+  }
+  return false
+}
 
 async function ensureDependency() {
   let pkg = {}
@@ -31,9 +111,16 @@ async function ensureDependency() {
 
 await mkdir(pluginDir, { recursive: true })
 await mkdir(commandDir, { recursive: true })
-await ensureDependency()
-await copyFile(join(root, "src", "index.js"), join(pluginDir, "opencode-loop.ts"))
-await rm(join(pluginDir, "opencode-loop.js"), { force: true })
+await mkdir(agentDir, { recursive: true })
+const useConfiguredPackage = await packagePluginConfigured()
+if (useConfiguredPackage) {
+  await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
+  await rm(join(pluginDir, "opencode-loop.js"), { force: true })
+} else {
+  await ensureDependency()
+  await copyFile(join(root, "src", "index.js"), join(pluginDir, "opencode-loop.ts"))
+  await rm(join(pluginDir, "opencode-loop.js"), { force: true })
+}
 
 for (const name of await readdir(join(root, "commands"))) {
   if (name.endsWith(".md")) {
@@ -41,5 +128,14 @@ for (const name of await readdir(join(root, "commands"))) {
   }
 }
 
-console.log(`Installed OpenCode Loop plugin to ${config}`)
+for (const name of await readdir(join(root, "agents"))) {
+  if (name.endsWith(".md")) {
+    await copyFile(join(root, "agents", name), join(agentDir, name))
+  }
+}
+
+if (useConfiguredPackage) console.log(`OpenCode Loop is already configured as a package in ${config}; removed the duplicate local plugin copy.`)
+else console.log(`Installed OpenCode Loop plugin to ${config}`)
+console.log(`Installed ${packageName} commands to ${commandDir}`)
+console.log(`Installed ${packageName} local command agent to ${agentDir}`)
 console.log("Restart OpenCode, then run: /loop-help")

package/scripts/install-test.mjs

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict"
+import { spawn } from "node:child_process"
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
+const installer = path.join(root, "scripts", "install-node.mjs")
+const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-installer-"))
+
+async function runInstaller(config) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [installer], {
+      cwd: root,
+      env: { ...process.env, OPENCODE_CONFIG_DIR: config },
+      windowsHide: true,
+    })
+    const stdout = []
+    const stderr = []
+    child.stdout.on("data", (data) => stdout.push(Buffer.from(data)))
+    child.stderr.on("data", (data) => stderr.push(Buffer.from(data)))
+    child.on("error", reject)
+    child.on("close", (code) => resolve({
+      code,
+      stdout: Buffer.concat(stdout).toString("utf8"),
+      stderr: Buffer.concat(stderr).toString("utf8"),
+    }))
+  })
+}
+
+async function commandCount(config) {
+  return (await fs.readdir(path.join(config, "commands"))).filter((name) => name.endsWith(".md")).length
+}
+
+async function exists(target) {
+  try { await fs.access(target); return true } catch { return false }
+}
+
+try {
+  const local = path.join(temporaryRoot, "local")
+  const localResult = await runInstaller(local)
+  assert.equal(localResult.code, 0, localResult.stderr)
+  assert.equal(await exists(path.join(local, "plugins", "opencode-loop.ts")), true)
+  assert.equal(await commandCount(local), 30)
+  assert.equal(await exists(path.join(local, "agents", "opencode-loop-local.md")), true)
+  const localPackage = JSON.parse(await fs.readFile(path.join(local, "package.json"), "utf8"))
+  assert.equal(localPackage.dependencies["@opencode-ai/plugin"], ">=1.4.0")
+
+  const configured = path.join(temporaryRoot, "configured")
+  await fs.mkdir(path.join(configured, "plugins"), { recursive: true })
+  await fs.writeFile(path.join(configured, "opencode.json"), JSON.stringify({ plugin: ["@bybrawe/opencode-loop@latest"] }), "utf8")
+  await fs.writeFile(path.join(configured, "plugins", "opencode-loop.ts"), "duplicate", "utf8")
+  await fs.writeFile(path.join(configured, "plugins", "opencode-loop.js"), "legacy duplicate", "utf8")
+  const configuredResult = await runInstaller(configured)
+  assert.equal(configuredResult.code, 0, configuredResult.stderr)
+  assert.match(configuredResult.stdout, /removed the duplicate local plugin copy/i)
+  assert.equal(await exists(path.join(configured, "plugins", "opencode-loop.ts")), false)
+  assert.equal(await exists(path.join(configured, "plugins", "opencode-loop.js")), false)
+  assert.equal(await commandCount(configured), 30)
+  assert.equal(await exists(path.join(configured, "agents", "opencode-loop-local.md")), true)
+
+  const jsonc = path.join(temporaryRoot, "jsonc")
+  await fs.mkdir(jsonc, { recursive: true })
+  await fs.writeFile(path.join(jsonc, "opencode.jsonc"), `{
+    // A configured package is authoritative; a local copy would load twice.
+    "plugin": [
+      "other-plugin",
+      "@bybrawe/opencode-loop",
+    ],
+  }`, "utf8")
+  const jsoncResult = await runInstaller(jsonc)
+  assert.equal(jsoncResult.code, 0, jsoncResult.stderr)
+  assert.equal(await exists(path.join(jsonc, "plugins", "opencode-loop.ts")), false)
+
+  const lookalike = path.join(temporaryRoot, "lookalike")
+  await fs.mkdir(lookalike, { recursive: true })
+  await fs.writeFile(path.join(lookalike, "opencode.json"), JSON.stringify({ plugin: ["@bybrawe/opencode-loop-extra"] }), "utf8")
+  const lookalikeResult = await runInstaller(lookalike)
+  assert.equal(lookalikeResult.code, 0, lookalikeResult.stderr)
+  assert.equal(await exists(path.join(lookalike, "plugins", "opencode-loop.ts")), true)
+
+  console.log("OpenCode Loop installer test passed")
+} finally {
+  await fs.rm(temporaryRoot, { recursive: true, force: true })
+}