@bybrawe/opencode-loop 0.5.15 → 0.5.17

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/smoke-test.mjs

@@ -9,6 +9,7 @@ const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-smoke-"
 const sessionID = "ses_smoke_goal"
 const attempts = { log: 0, prompt: 0, status: 0, toast: 0 }
 const prompts = []
+const liveStatuses = new Map([[sessionID, "idle"]])
 let hooks
 
 function legacyBody(name) {
@@ -31,6 +32,10 @@ const client = {
     showToast: legacyBody("toast"),
   },
   session: {
+    list: async (args) => {
+      assert.equal(args?.query?.directory, directory)
+      return { data: [{ id: sessionID, directory, projectID: "project", title: "smoke", version: "test", time: { created: Date.now(), updated: Date.now() } }] }
+    },
     abort: async (args) => {
       assert.equal(args?.path?.id, sessionID)
       return { data: true }
@@ -55,7 +60,7 @@ const client = {
     status: async (args) => {
       attempts.status++
       assert.equal(args?.query?.directory, directory, "session.status must use query.directory first")
-      return { data: { [sessionID]: { type: "idle" } } }
+      return { data: Object.fromEntries([...liveStatuses].filter(([, type]) => type !== "idle").map(([id, type]) => [id, { type }])) }
     },
     summarize: async (args) => {
       assert.equal(args?.path?.id, sessionID)
@@ -78,7 +83,7 @@ try {
     sessionID,
     arguments: "Create proof.txt and verify it --max-turns 3",
   }, output)
-  assert.match(output.parts[0].text, /handled by the local plugin/i)
+  assert.equal(output.parts.length, 0, "a locally handled slash command must not start a placeholder model turn")
 
   await hooks["command.execute.before"]({ command: "loop-now", sessionID, arguments: "goal" }, { parts: [] })
   await new Promise((resolve) => setTimeout(resolve, 0))
@@ -103,6 +108,44 @@ try {
   assert.equal(completedState.jobs[0].paused, true)
   assert.equal(completedState.jobs[0].enabled, false)
 
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+
+  const promptCountBeforeBackgroundTool = prompts.length
+  await hooks["tool.execute.before"]({ tool: "bash", sessionID, callID: "call_background" }, { args: {} })
+  await hooks["command.execute.before"]({
+    command: "loop",
+    sessionID,
+    arguments: "0s --max-runs 1 continue after the background task",
+  }, { parts: [] })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundTool, "an active tool call must keep the loop busy even when session.status says idle")
+
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "call_background", args: {} }, { title: "done", output: "", metadata: {} })
+  await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundTool + 1, "the due loop must resume after the active tool finishes and the session becomes idle")
+
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+
+  const childSessionID = "ses_background_child"
+  liveStatuses.set(childSessionID, "busy")
+  await hooks.event({ event: { type: "session.created", properties: { info: { id: childSessionID, parentID: sessionID } } } })
+  await hooks.event({ event: { type: "session.status", properties: { sessionID: childSessionID, status: { type: "busy" } } } })
+  const promptCountBeforeBackgroundChild = prompts.length
+  await hooks["command.execute.before"]({
+    command: "loop",
+    sessionID,
+    arguments: "0s --max-runs 1 continue after the background subtask",
+  }, { parts: [] })
+  await new Promise((resolve) => setTimeout(resolve, 2_700))
+  assert.equal(prompts.length, promptCountBeforeBackgroundChild, "a running background child session must keep its parent loop busy")
+
+  liveStatuses.set(childSessionID, "idle")
+  await hooks.event({ event: { type: "session.status", properties: { sessionID: childSessionID, status: { type: "idle" } } } })
+  await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundChild + 1, "the parent loop must resume after its background child becomes idle")
+
   await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
   assert.equal(attempts.log, 1)
   assert.ok(attempts.prompt >= 1)