@bybrawe/opencode-loop 0.5.16 → 0.5.18

package/scripts/install-test.mjs

@@ -0,0 +1,104 @@
+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 packageVersion = JSON.parse(await fs.readFile(path.join(root, "package.json"), "utf8")).version
+const expectedPackageSpec = `@bybrawe/opencode-loop@${packageVersion}`
+const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-installer-"))
+
+async function runInstaller(config, cliArgs = []) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [installer, ...cliArgs], {
+      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 helpConfig = path.join(temporaryRoot, "help-must-not-install")
+  const helpResult = await runInstaller(helpConfig, ["--help"])
+  assert.equal(helpResult.code, 0, helpResult.stderr)
+  assert.match(helpResult.stdout, /OpenCode Loop installer/)
+  assert.equal(await exists(helpConfig), false, "--help must not mutate the OpenCode config directory")
+
+  const versionResult = await runInstaller(helpConfig, ["--version"])
+  assert.equal(versionResult.code, 0, versionResult.stderr)
+  assert.equal(versionResult.stdout.trim(), packageVersion)
+  assert.equal(await exists(helpConfig), false, "--version must not mutate the OpenCode config directory")
+
+  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 configuredJson = JSON.parse(await fs.readFile(path.join(configured, "opencode.json"), "utf8"))
+  assert.deepEqual(configuredJson.plugin, [expectedPackageSpec], "the installer must bust OpenCode's stale package cache with an exact version spec")
+
+  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 updatedJsonc = await fs.readFile(path.join(jsonc, "opencode.jsonc"), "utf8")
+  assert.match(updatedJsonc, /A configured package is authoritative/, "pinning must preserve JSONC comments")
+  assert.match(updatedJsonc, new RegExp(expectedPackageSpec.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
+
+  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 })
+}

package/scripts/install.ps1

@@ -1,36 +1,10 @@
 $ErrorActionPreference = "Stop"
 
-$ConfigDir = if ($env:OPENCODE_CONFIG_DIR) { $env:OPENCODE_CONFIG_DIR } else { Join-Path $env:USERPROFILE ".config\opencode" }
-$PluginDir = Join-Path $ConfigDir "plugins"
-$CommandDir = Join-Path $ConfigDir "commands"
 $Root = Split-Path -Parent $PSScriptRoot
+$Installer = Join-Path $Root "scripts\install-node.mjs"
+$Runtime = Get-Command node -ErrorAction SilentlyContinue
+if (-not $Runtime) { $Runtime = Get-Command bun -ErrorAction SilentlyContinue }
+if (-not $Runtime) { throw "OpenCode Loop source installation requires Node.js or Bun." }
 
-New-Item -ItemType Directory -Force -Path $PluginDir | Out-Null
-New-Item -ItemType Directory -Force -Path $CommandDir | Out-Null
-
-$PackageFile = Join-Path $ConfigDir "package.json"
-if (Test-Path $PackageFile) {
-  try {
-    $PackageJson = Get-Content -Raw -Path $PackageFile | ConvertFrom-Json
-    if (-not $PackageJson.dependencies) {
-      $PackageJson | Add-Member -MemberType NoteProperty -Name dependencies -Value ([pscustomobject]@{})
-    }
-    if (-not $PackageJson.dependencies.PSObject.Properties["@opencode-ai/plugin"]) {
-      $PackageJson.dependencies | Add-Member -MemberType NoteProperty -Name "@opencode-ai/plugin" -Value ">=1.4.0"
-      $PackageJson | ConvertTo-Json -Depth 20 | Set-Content -Path $PackageFile -Encoding UTF8
-    }
-  } catch {
-    Write-Warning "Could not update $PackageFile. Add '@opencode-ai/plugin': '>=1.4.0' if OpenCode cannot load the local plugin."
-  }
-} else {
-  '{"dependencies":{"@opencode-ai/plugin":">=1.4.0"}}' | Set-Content -Path $PackageFile -Encoding UTF8
-}
-
-Copy-Item -Force (Join-Path $Root "src\index.js") (Join-Path $PluginDir "opencode-loop.ts")
-Remove-Item -Force -ErrorAction SilentlyContinue (Join-Path $PluginDir "opencode-loop.js")
-Copy-Item -Force (Join-Path $Root "commands\*.md") $CommandDir
-
-Write-Host "Installed OpenCode Loop plugin." -ForegroundColor Green
-Write-Host "Plugin:   $PluginDir\opencode-loop.ts"
-Write-Host "Commands: $CommandDir\loop*.md"
-Write-Host "Restart OpenCode, then run: /loop-help"
+& $Runtime.Source $Installer
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

package/scripts/install.sh

@@ -1,42 +1,14 @@
 #!/usr/bin/env sh
 set -eu
 
-CONFIG_DIR="${OPENCODE_CONFIG_DIR:-$HOME/.config/opencode}"
-PLUGIN_DIR="$CONFIG_DIR/plugins"
-COMMAND_DIR="$CONFIG_DIR/commands"
 ROOT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
 
-mkdir -p "$PLUGIN_DIR" "$COMMAND_DIR"
-PACKAGE_FILE="$CONFIG_DIR/package.json"
 if command -v node >/dev/null 2>&1; then
-  PACKAGE_FILE="$PACKAGE_FILE" node --input-type=module - <<'NODE'
-import fs from "node:fs"
-
-const file = process.env.PACKAGE_FILE
-let pkg = {}
-try {
-  pkg = JSON.parse(fs.readFileSync(file, "utf8"))
-} catch (error) {
-  if (error.code !== "ENOENT") {
-    console.warn(`Could not update ${file}: ${error.message}`)
-    process.exit(0)
-  }
-}
-if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) pkg = {}
-if (!pkg.dependencies || typeof pkg.dependencies !== "object" || Array.isArray(pkg.dependencies)) pkg.dependencies = {}
-if (!pkg.dependencies["@opencode-ai/plugin"]) {
-  pkg.dependencies["@opencode-ai/plugin"] = ">=1.4.0"
-  fs.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n")
-}
-NODE
-elif [ ! -f "$PACKAGE_FILE" ]; then
-  printf '%s\n' '{"dependencies":{"@opencode-ai/plugin":">=1.4.0"}}' > "$PACKAGE_FILE"
+  exec node "$ROOT_DIR/scripts/install-node.mjs"
+fi
+if command -v bun >/dev/null 2>&1; then
+  exec bun "$ROOT_DIR/scripts/install-node.mjs"
 fi
-cp "$ROOT_DIR/src/index.js" "$PLUGIN_DIR/opencode-loop.ts"
-rm -f "$PLUGIN_DIR/opencode-loop.js"
-cp "$ROOT_DIR/commands"/*.md "$COMMAND_DIR/"
 
-echo "Installed OpenCode Loop plugin."
-echo "Plugin:   $PLUGIN_DIR/opencode-loop.ts"
-echo "Commands: $COMMAND_DIR/loop*.md"
-echo "Restart OpenCode, then run: /loop-help"
+echo "OpenCode Loop source installation requires Node.js or Bun." >&2
+exit 1

package/scripts/loopd-test.mjs

@@ -0,0 +1,208 @@
+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 loopd = path.join(root, "scripts", "loopd.mjs")
+const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loopd-test-"))
+
+function runCli(cliArgs, env = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [loopd, ...cliArgs], {
+      cwd: root,
+      env: { ...process.env, ...env },
+      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, signal) => resolve({
+      code: code ?? (signal ? 1 : 0),
+      stdout: Buffer.concat(stdout).toString("utf8"),
+      stderr: Buffer.concat(stderr).toString("utf8"),
+    }))
+  })
+}
+
+async function makeFakeCommand(name) {
+  const script = path.join(temporaryRoot, `${name}.mjs`)
+  const log = path.join(temporaryRoot, `${name}.jsonl`)
+  await fs.writeFile(script, `
+import fs from "node:fs"
+const log = process.env.FAKE_COMMAND_LOG
+let previous = []
+try { previous = fs.readFileSync(log, "utf8").trim().split(/\\r?\\n/).filter(Boolean) } catch {}
+fs.appendFileSync(log, JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd() }) + "\\n")
+const codes = String(process.env.FAKE_EXIT_CODES || "0").split(",").map((value) => Number(value.trim()))
+const code = codes[Math.min(previous.length, codes.length - 1)]
+process.exit(Number.isInteger(code) ? code : 0)
+`, "utf8")
+
+  if (process.platform === "win32") {
+    const command = path.join(temporaryRoot, `${name}.cmd`)
+    const escapeCmd = (value) => String(value).replace(/%/g, "%%")
+    await fs.writeFile(command, `@echo off\r\n"${escapeCmd(process.execPath)}" "${escapeCmd(script)}" %*\r\nexit /b %errorlevel%\r\n`, "utf8")
+    return { command, log }
+  }
+
+  const command = path.join(temporaryRoot, name)
+  await fs.writeFile(command, `#!/bin/sh\nexec "${process.execPath.replace(/"/g, '\\"')}" "${script.replace(/"/g, '\\"')}" "$@"\n`, { mode: 0o755 })
+  return { command, log }
+}
+
+async function readLog(log) {
+  try {
+    return (await fs.readFile(log, "utf8")).trim().split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
+  } catch (error) {
+    if (error?.code === "ENOENT") return []
+    throw error
+  }
+}
+
+try {
+  const project = path.join(temporaryRoot, "project with spaces")
+  await fs.mkdir(project, { recursive: true })
+  const fakeOpenCode = await makeFakeCommand("fake-opencode")
+
+  const inlinePrompt = 'continue "quoted text" & keep | characters literal'
+  let result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--model", "opencode/nemotron-3-ultra-free",
+    "--agent", "build",
+    "--prompt", inlinePrompt,
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: fakeOpenCode.log,
+  })
+  assert.equal(result.code, 0, result.stderr)
+  let calls = await readLog(fakeOpenCode.log)
+  assert.equal(calls.length, 1)
+  assert.equal(path.resolve(calls[0].cwd), path.resolve(project))
+  assert.deepEqual(calls[0].args, [
+    "run", "--continue",
+    "--model", "opencode/nemotron-3-ultra-free",
+    "--agent", "build",
+    inlinePrompt,
+  ], "loopd must preserve model, agent, quotes, and shell metacharacters as literal arguments")
+
+  const promptFile = path.join(project, "goal prompt.md")
+  await fs.writeFile(promptFile, "\uFEFFPrompt loaded from a BOM file.", "utf8")
+  result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--prompt-file", path.basename(promptFile),
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: fakeOpenCode.log,
+  })
+  assert.equal(result.code, 0, result.stderr)
+  calls = await readLog(fakeOpenCode.log)
+  assert.equal(calls.at(-1).args.at(-1), "Prompt loaded from a BOM file.")
+
+  const failureLog = path.join(temporaryRoot, "failure.jsonl")
+  result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--prompt", "fail once",
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: failureLog,
+    FAKE_EXIT_CODES: "7",
+    OPENCODE_LOOPD_FAILED_RUN_RETRY_MS: "0",
+  })
+  assert.equal(result.code, 7, "a finite daemon run must propagate the failing OpenCode exit code")
+
+  result = await runCli(["--project", project, "--max-runs", "not-a-number", "--prompt", "test"], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: path.join(temporaryRoot, "invalid-count.jsonl"),
+  })
+  assert.equal(result.code, 1)
+  assert.match(result.stderr, /Invalid --max-runs value/)
+
+  result = await runCli(["--project", path.join(temporaryRoot, "missing-project"), "--max-runs", "1", "--prompt", "test"], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: path.join(temporaryRoot, "missing-project.jsonl"),
+  })
+  assert.equal(result.code, 1)
+  assert.match(result.stderr, /Project directory does not exist/)
+
+  if (process.platform === "win32") {
+    const fakeTasks = await makeFakeCommand("fake-schtasks")
+    const taskName = "OpenCodeLoop-Test"
+    result = await runCli([
+      "install-task",
+      "--project", project,
+      "--every", "90s",
+      "--name", taskName,
+      "--prompt", "scheduled task prompt",
+      "--model", "opencode/nemotron-3-ultra-free",
+      "--agent", "build",
+    ], {
+      SCHTASKS_BIN: fakeTasks.command,
+      FAKE_COMMAND_LOG: fakeTasks.log,
+      OPENCODE_BIN: fakeOpenCode.command,
+      OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "task-files"),
+    })
+    assert.equal(result.code, 0, result.stderr)
+    const taskCalls = await readLog(fakeTasks.log)
+    assert.equal(taskCalls.length, 1)
+    const taskArgs = taskCalls[0].args
+    assert.equal(taskArgs[0], "/Create")
+    assert.equal(taskArgs[taskArgs.indexOf("/MO") + 1], "2")
+    assert.equal(taskArgs[taskArgs.indexOf("/TN") + 1], taskName)
+    const taskCommand = taskArgs[taskArgs.indexOf("/TR") + 1]
+    assert.ok(taskCommand.length <= 261, "the Task Scheduler /TR command must stay within its documented limit")
+    assert.match(taskCommand, /^cmd\.exe \/d \/s \/c /)
+    const taskFiles = await fs.readdir(path.join(temporaryRoot, "task-files"))
+    const taskConfigFile = path.join(temporaryRoot, "task-files", taskFiles.find((name) => name.endsWith(".json")))
+    const taskConfig = JSON.parse(await fs.readFile(taskConfigFile, "utf8"))
+    assert.equal(taskConfig.project, project)
+    assert.equal(taskConfig.prompt, "scheduled task prompt")
+    assert.equal(taskConfig.model, "opencode/nemotron-3-ultra-free")
+    assert.equal(taskConfig.agent, "build")
+    assert.equal(taskConfig.opencodeBin, fakeOpenCode.command)
+
+    const taskRunLog = path.join(temporaryRoot, "task-run.jsonl")
+    result = await runCli(["task-run", "--config", taskConfigFile], {
+      FAKE_COMMAND_LOG: taskRunLog,
+    })
+    assert.equal(result.code, 0, result.stderr)
+    const taskRunCall = (await readLog(taskRunLog))[0]
+    assert.deepEqual(taskRunCall.args, [
+      "run", "--continue",
+      "--model", "opencode/nemotron-3-ultra-free",
+      "--agent", "build",
+      "scheduled task prompt",
+    ])
+
+    result = await runCli(["uninstall-task", "--name", taskName], {
+      SCHTASKS_BIN: fakeTasks.command,
+      FAKE_COMMAND_LOG: fakeTasks.log,
+      OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "task-files"),
+    })
+    assert.equal(result.code, 0, result.stderr)
+    const uninstallArgs = (await readLog(fakeTasks.log)).at(-1).args
+    assert.deepEqual(uninstallArgs, ["/Delete", "/F", "/TN", taskName])
+    assert.deepEqual(await fs.readdir(path.join(temporaryRoot, "task-files")), [], "uninstall-task must remove its launcher and config")
+
+    result = await runCli(["install-task", "--project", project, "--name", taskName, "--prompt", "test"], {
+      SCHTASKS_BIN: path.join(temporaryRoot, "missing-schtasks.exe"),
+      OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "missing-task-files"),
+    })
+    assert.equal(result.code, 1, "a missing Task Scheduler executable must not report success")
+    assert.match(result.stderr, /failed to start/i)
+  }
+
+  console.log("OpenCode Loop daemon test passed")
+} finally {
+  await fs.rm(temporaryRoot, { recursive: true, force: true })
+}