feat: add automation scheduler timers

packages/opencode/src/automation/index.ts

@@ -234,7 +234,7 @@ export namespace Automation {
     definitions: Map<string, Definition>
     runs: Map<string, Run[]>
     activeWriters: Set<string>
-    activeRuns: Map<string, { writerKey: string; controller: AbortController }>
+    activeRuns: Map<string, { writerKey: string; controller: AbortController; runID: string }>
   }
   const state = Instance.state<State>(() => ({
     definitions: new Map(),
@@ -503,11 +503,15 @@ export namespace Automation {
     return replaceRun(Run.parse(next))
   }
 
-  function stopRun(run: Run, stopReason: Extract<Run, { state: "stopped" }>["stopReason"]): Run {
+  function stopRun(
+    run: Run,
+    stopReason: Extract<Run, { state: "stopped" }>["stopReason"],
+    options?: { now?: number },
+  ): Run {
     if (run.state === "stopped" || run.state === "succeeded" || run.state === "failed") return run
     return reviseRun(run, {
       state: "stopped",
-      completedAt: Date.now(),
+      completedAt: options?.now ?? Date.now(),
       result: null,
       error: null,
       stopReason,
@@ -518,12 +522,26 @@ export namespace Automation {
     const active = state().activeRuns.get(automationID)
     if (!active) return undefined
     active.controller.abort()
-    const current = state().runs.get(automationID)?.find((run) => (
-      run.state === "scheduled" || run.state === "running" || run.state === "awaiting_input"
-    ))
+    const current = state().runs.get(automationID)?.find((run) => run.id === active.runID)
     return current ? stopRun(current, "cancelled") : undefined
   }
 
+  export function stopRunByID(
+    runID: string,
+    stopReason: Extract<Run, { state: "stopped" }>["stopReason"],
+    options?: { now?: number },
+  ): Run | undefined {
+    for (const runs of state().runs.values()) {
+      const run = runs.find((item) => item.id === runID)
+      if (!run) continue
+      const active = state().activeRuns.get(run.automationID)
+      if (active?.runID === runID) active.controller.abort()
+      const stopped = stopRun(run, stopReason, options)
+      return stopped === run ? undefined : stopped
+    }
+    return undefined
+  }
+
   export function markRunStarted(run: Run, sessionID: SessionID, options?: { now?: number }): Run {
     return reviseRun(run, {
       state: "running",
@@ -584,6 +602,32 @@ export namespace Automation {
     return run
   }
 
+  export function hasActiveRun(automationID: string): boolean {
+    if (state().activeRuns.has(automationID)) return true
+    return (state().runs.get(automationID) ?? []).some(
+      (run) => run.state === "scheduled" || run.state === "running" || run.state === "awaiting_input",
+    )
+  }
+
+  export function hasRunTriggeredAtOrAfter(automationID: string, triggeredAt: number): boolean {
+    return (state().runs.get(automationID) ?? []).some((run) => run.triggeredAt >= triggeredAt)
+  }
+
+  export function completedRunCount(automationID: string): number {
+    get(automationID)
+    const runs = state().runs.get(automationID) ?? []
+    return runs.filter((run) => run.state === "succeeded" || run.state === "failed").length
+  }
+
+  export function recordStoppedRun(
+    automationID: string,
+    stopReason: Extract<Run, { state: "stopped" }>["stopReason"],
+    options?: { now?: number; triggeredAt?: number },
+  ): Run {
+    const run = runNow(automationID, { now: options?.triggeredAt ?? options?.now })
+    return stopRun(run, stopReason, options)
+  }
+
   export function runNowExecuting(
     id: string,
     options: { executor: RunExecutor; attendance?: AutomationRunAttendance; now?: number },
@@ -608,7 +652,7 @@ export namespace Automation {
     }
     data.activeWriters.add(writerKey)
     const controller = new AbortController()
-    data.activeRuns.set(initial.automationID, { writerKey, controller })
+    data.activeRuns.set(initial.automationID, { writerKey, controller, runID: initial.id })
     let current = initial
     try {
       const prepared = await executor({ definition, run: initial, attendance, signal: controller.signal })
@@ -663,8 +707,11 @@ export namespace Automation {
       })
       await publishRunUpdated(failed)
     } finally {
-      data.activeRuns.delete(initial.automationID)
-      data.activeWriters.delete(writerKey)
+      const active = data.activeRuns.get(initial.automationID)
+      if (active?.runID === initial.id) {
+        data.activeRuns.delete(initial.automationID)
+        data.activeWriters.delete(writerKey)
+      }
     }
   }