@bybrawe/opencode-loop 0.5.32 → 0.5.34

package/scripts/schedule-policy-test.mjs

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict"
+import {
+  dueJobs,
+  inferredScheduleMode,
+  jobDueAt,
+  jobIsDue,
+  nextDueDelay,
+  scheduleDescription,
+  scheduleState,
+} from "../src/source/runtime/schedule-policy.js"
+
+const current = 1_000_000
+const base = {
+  id: "job",
+  enabled: true,
+  paused: false,
+  maxRuns: 0,
+  runCount: 0,
+  intervalMs: 0,
+  immediate: true,
+  lastRunAt: 0,
+  createdAt: new Date(current - 10_000).toISOString(),
+}
+
+{
+  const job = { ...base, scheduleMode: "idle" }
+  assert.equal(inferredScheduleMode(job), "idle")
+  assert.equal(jobDueAt(job, current), current)
+  assert.equal(jobIsDue(job, current), true)
+  assert.equal(scheduleDescription(job), "every idle")
+  assert.equal(scheduleState(job, current), "waiting for idle")
+}
+
+{
+  const job = {
+    ...base,
+    scheduleMode: "interval",
+    intervalMs: 300_000,
+    immediate: false,
+    createdAt: new Date(current).toISOString(),
+  }
+  assert.equal(jobDueAt(job, current), current + 300_000)
+  assert.equal(jobIsDue(job, current), false)
+  assert.equal(scheduleDescription(job), "every 5m, first after 5m")
+  assert.equal(scheduleState(job, current), "due in 5m")
+}
+
+{
+  const job = {
+    ...base,
+    scheduleMode: "interval",
+    intervalMs: 300_000,
+    immediate: true,
+  }
+  assert.equal(jobDueAt(job, current), current)
+  assert.equal(scheduleDescription(job), "every 5m, starts on next idle")
+}
+
+{
+  const job = {
+    ...base,
+    scheduleMode: "once",
+    intervalMs: 300_000,
+    immediate: false,
+    maxRuns: 1,
+    createdAt: new Date(current).toISOString(),
+  }
+  assert.equal(inferredScheduleMode(job), "once")
+  assert.equal(scheduleDescription(job), "once after 5m")
+  assert.equal(jobIsDue(job, current + 299_999), false)
+  assert.equal(jobIsDue(job, current + 300_000), true)
+  const completed = { ...job, runCount: 1 }
+  assert.equal(jobDueAt(completed, current + 300_000), Infinity)
+}
+
+{
+  const watch = { ...base, watchPaths: ["progress.md"], watchTriggered: false }
+  assert.equal(inferredScheduleMode(watch), "watch")
+  assert.equal(jobDueAt(watch, current), Infinity)
+  assert.equal(jobDueAt({ ...watch, watchTriggered: true }, current), current)
+}
+
+{
+  const expired = {
+    ...base,
+    intervalMs: 3_600_000,
+    immediate: false,
+    maxRuntimeMs: 5_000,
+    createdAt: new Date(current - 6_000).toISOString(),
+  }
+  assert.equal(jobDueAt(expired, current), current, "expired max-runtime must wake admission so it can remove the job")
+}
+
+{
+  const dueNow = { ...base, id: "normal" }
+  const targeted = { ...base, id: "targeted", runNowRequestedAt: current }
+  const state = { jobs: [dueNow, targeted] }
+  assert.deepEqual(dueJobs(state, current).map((job) => job.id), ["targeted", "normal"])
+  assert.equal(nextDueDelay(state, current), 0)
+}
+
+{
+  const delayed = {
+    ...base,
+    intervalMs: 60_000,
+    immediate: false,
+    createdAt: new Date(current).toISOString(),
+  }
+  assert.equal(nextDueDelay({ jobs: [delayed] }, current), 60_000)
+  assert.equal(jobIsDue({ ...delayed, paused: true }, current + 60_000), false)
+  assert.equal(jobIsDue({ ...delayed, enabled: false }, current + 60_000), false)
+}
+
+console.log("schedule policy tests passed")

package/scripts/schedule-syntax-test.mjs

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict"
+import { normalizeLoopScheduleArgs } from "../src/source/core/schedule-syntax.js"
+
+{
+  const result = normalizeLoopScheduleArgs("continue the project")
+  assert.equal(result.ok, true)
+  assert.equal(result.args, "continue the project")
+  assert.equal(result.defaults.intervalMs, 0)
+  assert.equal(result.defaults.immediate, true)
+  assert.equal(result.scheduleMode, "idle")
+  assert.equal(result.scheduleSyntax, "idle-shorthand")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("--safe --ask-never continue the project")
+  assert.equal(result.ok, true)
+  assert.equal(result.defaults.intervalMs, 0)
+  assert.equal(result.args, "--safe --ask-never continue the project")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("idle continue forever")
+  assert.equal(result.args, "continue forever")
+  assert.equal(result.defaults.intervalMs, 0)
+  assert.equal(result.defaults.immediate, true)
+  assert.equal(result.scheduleMode, "idle")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("every 5m continue forever")
+  assert.equal(result.args, "continue forever")
+  assert.equal(result.defaults.intervalMs, 300_000)
+  assert.equal(result.defaults.immediate, false)
+  assert.equal(result.scheduleMode, "interval")
+  assert.equal(result.scheduleSyntax, "every")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("after 5m continue once")
+  assert.equal(result.args, "continue once")
+  assert.equal(result.defaults.intervalMs, 300_000)
+  assert.equal(result.defaults.immediate, false)
+  assert.equal(result.defaults.maxRuns, 1)
+  assert.equal(result.scheduleMode, "once")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("in 30s ping once")
+  assert.equal(result.args, "ping once")
+  assert.equal(result.defaults.intervalMs, 30_000)
+  assert.equal(result.defaults.maxRuns, 1)
+  assert.equal(result.scheduleSyntax, "after")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("5m continue legacy")
+  assert.equal(result.args, "5m continue legacy")
+  assert.equal(result.scheduleMode, "interval")
+  assert.equal(result.scheduleSyntax, "legacy")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("--allow-goal-overlap continue")
+  assert.equal(result.args, "continue")
+  assert.equal(result.allowGoalOverlap, true)
+  assert.equal(result.scheduleMode, "idle")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("every nope continue")
+  assert.equal(result.ok, false)
+  assert.match(result.error, /Invalid every schedule/)
+}
+
+console.log("schedule syntax tests passed")

package/scripts/session-status-idle-recovery-test.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict"
+import { clearSessionActivity } from "../src/source/runtime/session-activity.js"
+import { createSessionStatusRuntime } from "../src/source/runtime/session-status.js"
+
+const activeRuns = new Map()
+const logs = []
+let clock = 100_000
+let completion = "completed"
+
+const runtime = createSessionStatusRuntime({
+  activeRuns,
+  now: () => clock,
+  sessionStatusCacheMs: 0,
+  appendLoopLog: async (...args) => logs.push(args),
+  activeRunCompletionFromMessages: async () => completion,
+})
+
+const busyClient = {
+  session: {
+    status: async () => ({ data: { session: { type: "busy" } } }),
+  },
+}
+
+try {
+  runtime.markSessionStatus("session", "busy", clock - 2_000)
+  assert.equal(await runtime.sessionStatusType(busyClient, "session", "/repo"), "idle")
+  assert.equal(logs.at(-1)[1], "status-message-idle-recovery")
+  assert.equal(logs.at(-1)[2].staleStatus, "busy")
+
+  runtime.clearSessionStatus("session")
+  completion = "incomplete"
+  clock += 5_000
+  assert.equal(await runtime.sessionStatusType(busyClient, "session", "/repo"), "busy", "an unfinished tail must never be force-recovered")
+
+  runtime.clearSessionStatus("session")
+  completion = "unknown"
+  clock += 5_000
+  assert.equal(await runtime.sessionStatusType(busyClient, "session", "/repo"), "busy", "unknown tail completion must remain conservative")
+
+  console.log("session status idle recovery tests passed")
+} finally {
+  activeRuns.clear()
+  clearSessionActivity("session")
+}