@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/src/source/opencode2/native-plugin.js

@@ -0,0 +1,153 @@
+import path from "node:path"
+import { createNativeSessionLocationGuard } from "./session-location.js"
+import { createNativeShellHost } from "./native-shell.js"
+import { createNativeLoopRuntime } from "./native-runtime.js"
+import { createOpenCode2EventBridge } from "./event-bridge.js"
+import { registerOpenCode2LoopCommands, OPENCODE_LOOP_V2_PRESET_NAMES, commandArguments } from "./commands.js"
+import { readSmallTextFile, appendLoopLog } from "../core/process.js"
+import { stateDir } from "../core/state.js"
+import { initializeProgressFile } from "../core/progress.js"
+
+const HELP = `OpenCode Loop: native OpenCode 2 runtime
+/loop 0s <task> --max-runs 3
+/loop 5m <task> --verify "npm test" --pause-on-verify-fail
+/loop --watch progress.md <task>
+/loop 0s <task> --prompt-file instructions.md --include-file progress.md
+/loop 0s <task> --compact-every 3
+/loop 5m --shell npm test
+/loop 15m --compact /compact
+Presets: /loop-dev, /loop-testfix, /loop-progress, /loop-safe-dev, /loop-ask, /loop-prompt, /loop-command, /loop-cmd, /loop-shell, /loop-compact.
+/loop-init [progress.md] creates a missing project-local progress file without overwriting existing data.
+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 when the plugin context has no session.shell.
+Scheduled/manual compaction requires session.compact on the host; unavailable capability is rejected before creating a job. Native automatic compaction is always left to OpenCode.
+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.
+Native sessions stay serialized; --allow-overlap is rejected.
+Use @bybrawe/opencode-goal and /goal for native Goal contracts. Legacy Loop Goal state is not silently migrated.
+An uncertain admission after a restart is paused for review instead of being replayed automatically.`
+
+async function cleanup(value) {
+  if (typeof value === "function") await value()
+  else if (typeof value?.dispose === "function") await value.dispose()
+  else if (typeof value?.unsubscribe === "function") await value.unsubscribe()
+}
+
+export const OpenCodeLoopNativePlugin = Object.freeze({
+  id: "@bybrawe/opencode-loop",
+  async setup(ctx) {
+    for (const [label, fn] of [["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
+      if (typeof fn !== "function") throw new Error(`Native OpenCode Loop requires ${label}; use OpenCode 2.0.18 or newer.`)
+    }
+    const directory = String(ctx.location?.directory || ctx.options?.directory || "").trim()
+    if (!directory) throw new Error("Native OpenCode Loop requires a project directory")
+    const ownsSession = createNativeSessionLocationGuard({
+      directory, workspaceID: ctx.location?.workspaceID,
+      getSession: (input) => ctx.session.get(input),
+    })
+    const registrations = []
+    const lifecycleAbort = new AbortController()
+    const prompt = (request) => ctx.session.prompt({ ...request, delivery: request.delivery || "queue", metadata: { ...request.metadata, opencode_loop_v2: true } })
+    const shellHost = createNativeShellHost({
+      directory,
+      onTerminal: (event) => runtime.onEvent(event),
+      onError: (error) => { void appendLoopLog(directory, "v2-shell-error", { message: String(error?.message || error) }).catch(() => {}) },
+    })
+    const runtime = createNativeLoopRuntime({
+      directory,
+      scopeAllowed: (scope) => ownsSession(scope.sessionID),
+      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: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact({ ...request, delivery: "queue" }) : undefined,
+      shell: typeof ctx.session.shell === "function" ? (request) => ctx.session.shell(request) : (request) => shellHost.dispatch(request),
+      // cancel() returns void. The durable inbox.cancelled event, not this
+      // response alone, proves that an undelivered input can be refunded.
+      cancel: typeof ctx.session.inbox?.cancel === "function" ? async (request) => { await ctx.session.inbox.cancel(request); return false } : undefined,
+      onError: (error) => { void appendLoopLog(directory, "v2-native-error", { message: String(error?.message || error) }).catch(() => {}) },
+    })
+    const bridge = createOpenCode2EventBridge({ directory, allowInboxCommands: false, onEvent: async (event) => {
+      if (event.sessionID && !(event.kind === "session" && event.action === "deleted") && !await ownsSession(event.sessionID)) return
+      return runtime.onEvent(event)
+    }, onError: (error) => { void appendLoopLog(directory, "v2-native-event-error", { message: String(error?.message || error) }).catch(() => {}) } })
+    let closed = false
+    let disposeTask
+    function dispose() {
+      if (disposeTask) return disposeTask
+      closed = true
+      disposeTask = Promise.resolve().then(async () => {
+        const errors = []
+        // Stop accepting events before aborting next(); iterator.return() alone
+        // cannot wake an async generator blocked on a public server stream.
+        const stopped = bridge.dispose("native-plugin-disposed").catch((error) => { errors.push(error) })
+        lifecycleAbort.abort()
+        for (const action of [() => runtime.dispose(), () => shellHost.dispose()]) {
+          try { await action() } catch (error) { errors.push(error) }
+        }
+        await stopped
+        for (const registration of [...registrations].reverse()) {
+          try { await cleanup(registration) } catch (error) { errors.push(error) }
+        }
+        if (errors.length) throw new AggregateError(errors, "Native Loop cleanup failed")
+      })
+      return disposeTask
+    }
+    async function execute({ name, sessionID, arguments: argumentsText }) {
+      if (closed) throw new Error("Native Loop is disposed")
+      if (!await ownsSession(sessionID)) throw new Error("Native Loop cannot resolve this session in the plugin location; use its own project/worktree.")
+      if (closed) throw new Error("Native Loop is disposed")
+      if (name === "loop-init") {
+        const output = await initializeProgressFile(directory, argumentsText)
+        await prompt({ sessionID, text: output.created ? `Created ${output.file}.` : `${output.file} already exists; preserved unchanged.`, resume: false })
+        return { handled: true, accepted: true, ...output }
+      }
+      if (["loop-help", "loop-doctor", "loop-logs"].includes(name)) {
+        const text = name === "loop-logs"
+          ? (await readSmallTextFile(path.join(stateDir(directory), "loop.log"), 2_000_000)).split("\n").slice(-60).join("\n") || "No Loop log entries."
+          : name === "loop-doctor"
+            ? `Native OpenCode Loop\nHost: ${ctx.app?.version || "unknown"}\nDirectory: ${directory}\nPrompt hooks: enabled\nCompaction ownership: native host\nDelivery: durable queue\nScheduled timers: ${runtime.scheduledCount()}\nUse /loop-status for paused/admitted job state.`
+            : HELP
+        await prompt({ sessionID, text, resume: false })
+        return { handled: true, accepted: true }
+      }
+      const event = { kind: "command", action: "executed", directory, sessionID, name, arguments: argumentsText }
+      const result = await runtime.onEvent(event)
+      if (result?.accepted === false) throw new Error(result.error || result.blockers?.join(" ") || "Loop command rejected")
+      const shouldWake = result?.job ? result.job.immediate !== false : ["loop-now", "loop-resume"].includes(name)
+      if (result?.accepted && shouldWake) await runtime.wake(event)
+      return result
+    }
+    try {
+      registrations.push(await ctx.session.hook("prompt", async (event) => {
+        if (closed || event.metadata?.opencode_loop_v2 === true || !await ownsSession(event.sessionID)) return
+        if (closed) return
+        return runtime.onEvent({ kind: "foreground", directory, sessionID: event.sessionID })
+      }))
+      registrations.push(await ctx.session.hook("compaction", async (event) => {
+      if (closed || !await ownsSession(event.sessionID)) return
+      if (!closed) return runtime.onEvent({ kind: "compaction", action: "started", directory, sessionID: event.sessionID })
+    }))
+      registrations.push(await ctx.command.transform((draft) => {
+        registerOpenCode2LoopCommands(draft, { execute })
+        if (typeof draft.add !== "function") return
+        for (const name of [...OPENCODE_LOOP_V2_PRESET_NAMES, "loop-init"]) {
+          draft.add({
+            name,
+            description: name === "loop-init" ? "Create a missing project-local progress file." : `Native Loop ${name.slice(5)} preset`,
+            execute: (input) => execute({ name, sessionID: input.sessionID, arguments: commandArguments(input) }),
+          })
+        }
+      }))
+      await bridge.attach(() => ctx.event.subscribe({ signal: lifecycleAbort.signal }))
+      await appendLoopLog(directory, "v2-native-ready", { host: ctx.app?.version || "unknown" })
+      return dispose
+    } catch (error) {
+      await dispose().catch(() => {})
+      throw error
+    }
+  },
+})
+
+export default OpenCodeLoopNativePlugin

package/src/source/opencode2/native-policy.js

@@ -0,0 +1,106 @@
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import { runShellCommand, appendLoopLog } from "../core/process.js"
+import { createJobWorkspaceRuntime, dangerousShell } from "../runtime/job-workspace.js"
+
+export function createNativeJobPolicy(options = {}) {
+  const now = options.now || Date.now
+  const run = options.runShellCommand || runShellCommand
+  const workspace = options.workspace || createJobWorkspaceRuntime({ toast: async () => {} })
+
+  function pause(job, reason, failed = false) {
+    job.paused = true
+    job.pauseReason = reason
+    if (failed) job.failureCount = (job.failureCount || 0) + 1
+    return false
+  }
+
+  async function shell(scope, job, command, phase) {
+    if (job.safe && dangerousShell(command)) {
+      return { code: -1, stdout: "", stderr: `Blocked ${phase} by --safe command guard`, blocked: true }
+    }
+    const result = await run(command, scope.directory, Math.max(1, Number(job.timeoutMs) || 120_000))
+    await appendLoopLog(scope.directory, `v2-${phase}`, {
+      sessionID: scope.sessionID, job: job.name || job.id, code: result.code,
+      output: String(result.stdout || "").slice(-8000), error: String(result.stderr || "").slice(-8000),
+    })
+    return result
+  }
+
+  async function checkStop(scope, job) {
+    const created = Date.parse(job.createdAt)
+    if (job.maxRuntimeMs > 0 && Number.isFinite(created) && now() - created >= job.maxRuntimeMs) {
+      job.enabled = false
+      return pause(job, "max-runtime")
+    }
+    if (job.stopFile) {
+      try {
+        await stat(path.resolve(scope.directory, job.stopFile))
+        job.enabled = false
+        return pause(job, "stop-file")
+      } catch (error) { if (error?.code !== "ENOENT") throw error }
+    }
+    if (await workspace.untilReached(scope.directory, job)) {
+      job.enabled = false
+      return pause(job, "until-reached")
+    }
+    return true
+  }
+
+  async function prepare(scope, job, isCurrent = () => true) {
+    if (!await checkStop(scope, job) || !isCurrent()) return false
+    if (job.dryRun) return true
+    if (job.preflightCommand) {
+      const result = await shell(scope, job, job.preflightCommand, "preflight")
+      job.lastPreflightCode = result.code
+      if (result.code !== 0) return pause(job, "preflight-failed", true)
+    }
+    if (!isCurrent()) return false
+    if (job.branch) {
+      await workspace.ensureBranch(scope.directory, job, undefined, scope.sessionID)
+      if (!job.branchDone) return pause(job, "branch-unavailable", true)
+    }
+    return isCurrent()
+  }
+
+  async function finish(scope, job, isCurrent = () => true) {
+    if (!isCurrent() || job.dryRun) return
+    if (job.verifyCommand) {
+      const result = await shell(scope, job, job.verifyCommand, "verify")
+      job.lastVerifyCode = result.code
+      job.lastVerifyAt = now()
+      job.lastVerifyOutput = `${result.stdout || ""}\n${result.stderr || ""}`.trim().slice(-8000)
+      if (result.code !== 0) {
+        job.failureCount = (job.failureCount || 0) + 1
+        if (result.blocked || job.pauseOnVerifyFail || (job.maxFailures > 0 && job.failureCount >= job.maxFailures)) pause(job, "verification-failed")
+        return
+      }
+      job.failureCount = 0
+    }
+    if (!isCurrent()) return
+    if (job.postrunCommand) {
+      const result = await shell(scope, job, job.postrunCommand, "postrun")
+      job.lastPostrunCode = result.code
+      if (result.code !== 0) {
+        pause(job, "postrun-failed", true)
+        return
+      }
+    }
+    if (isCurrent()) await workspace.createCheckpoint(scope.directory, scope.sessionID, job, undefined)
+  }
+
+  async function notify(scope, job, reason) {
+    if (!job.notifyCommand || job.dryRun) return
+    // Placeholders are data, not a route for event/error strings to become shell syntax.
+    const literal = (value) => String(value || "").replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 160)
+    const command = String(job.notifyCommand).replace(/\{reason\}/g, literal(reason)).replace(/\{job\}/g, literal(job.name || job.id))
+    await shell(scope, job, command, "notify")
+  }
+
+  return {
+    pause, checkStop, prepare, finish, notify, shell,
+    buildPrompt: workspace.buildPrompt,
+    snapshotPaths: workspace.snapshotPaths,
+    watchChanged: workspace.watchChanged,
+  }
+}