From e76c67a250734cf0a9efcc2bd16809c53c1d35c8 Mon Sep 17 00:00:00 2001 From: Kit Langton Date: Fri, 30 Oct 2026 07:22:05 -0700 Subject: [PATCH] feat(core,server): enable schedules by default and run loop in opencode serve (#60478) --- packages/core/src/schedule.ts | 110 +++++++++++++++++++--- packages/core/src/tool/plugin/schedule.ts | 2 +- packages/core/test/schedule.test.ts | 62 +++++++++++- packages/core/test/tool-schedule.test.ts | 9 +- packages/protocol/openapi.json | 12 +-- packages/protocol/src/groups/schedule.ts | 3 +- packages/server/src/process.ts | 4 +- packages/server/test/schedule.test.ts | 105 ++++++++++++++++++++- 8 files changed, 274 insertions(+), 33 deletions(-) diff --git a/packages/core/src/schedule.ts b/packages/core/src/schedule.ts index a31ec5243ad..946503ff163 100644 --- a/packages/core/src/schedule.ts +++ b/packages/core/src/schedule.ts @@ -1,7 +1,8 @@ export * as Schedule from "./schedule.js" -import { and, asc, eq, gt, isNull, lte, min, or } from "drizzle-orm" -import { Cause, Clock, Context, Cron, DateTime, Effect, Latch, Layer, Option, Result, Schema } from "effect" +import { randomUUID } from "node:crypto" +import { and, asc, eq, gt, isNull, lte, min, or, sql } from "drizzle-orm" +import { Cause, Clock, Context, Cron, DateTime, Effect, Latch, Layer, Option, Result, Schedule as EffectSchedule, Schema } from "effect" import { Node, makeGlobalNode } from "@opencode/util/effect/app-node" import { LayerNode } from "@opencode/util/effect/layer-node" import { @@ -23,6 +24,7 @@ import { Config } from "./config.js" import { Database } from "./database/database.js" import { FileSystem } from "./filesystem.js" import { Instance } from "./instance/service.js" +import { KVTable } from "./kv/sql.js" import type { Permission } from "./permission.js" import { Session } from "./session.js" import { SessionExecution } from "./session/execution.js" @@ -52,7 +54,7 @@ export class InvalidError extends Schema.TaggedError()("Schedule.I export class DisabledError extends Schema.TaggedError()("Schedule.DisabledError", {}) { override get message() { - return "Scheduled tasks are disabled; set experimental.schedules in config" + return "Scheduled tasks are disabled by experimental.schedules: false in config" } } @@ -70,8 +72,9 @@ export interface Interface { /** Fires every schedule that is due now, at most once each. */ readonly tick: Effect.Effect /** - * Runs `tick` whenever a schedule falls due, until interrupted. All state lives in the table, so exactly one - * process may run this: the managed server. + * Runs `tick` whenever a schedule falls due, until interrupted. Elects at most one active leader per SQLite + * database via a lease row, so auxiliary processes (`opencode acp`, `--standalone`) sharing a data directory + * never double-fire alongside a managed service. */ readonly run: Effect.Effect } @@ -90,6 +93,8 @@ const DEFAULT_UNTIL_AFTER = 24 * HOUR const LATE_AFTER = 60_000 /** The loop re-reads the table at least this often, so clock jumps and missed doorbells are caught. */ const MAX_SLEEP = 30_000 +const LEADER_KEY = "schedule:leader" +const LEADER_TTL = 2 * MAX_SLEEP /** How long a due schedule waits before its location's flag is read again, while schedules are off there. */ const DISABLED_RETRY = HOUR /** How long a schedule whose prompt failed waits before trying again. */ @@ -211,10 +216,10 @@ const layer = Layer.effect( const settings = (session: SessionSchema.Info) => Effect.gen(function* () { const config = yield* Effect.serviceOption(Config.Service) - if (Option.isNone(config)) return { enabled: false, timezone: undefined } + if (Option.isNone(config)) return { enabled: true, timezone: undefined } const entries = yield* config.value.entries() return { - enabled: Config.latest(entries, "experimental")?.schedules === true, + enabled: Config.latest(entries, "experimental")?.schedules !== false, timezone: Config.latest(entries, "timezone"), } }).pipe(instances.provide(session)) @@ -442,6 +447,7 @@ const layer = Layer.effect( const step = Effect.fnUntraced(function* (row: Row, now: number) { const due = row.next_due_at if (due === null || row.session_id === null) return + if (!(yield* claimLeader(yield* Clock.currentTimeMillis))) return const session = yield* sessions.get(row.session_id) if (!(yield* settings(session)).enabled) { // Reading the flag boots the Session's location, so check again in an hour rather than every tick. The row @@ -538,18 +544,98 @@ const layer = Layer.effect( ), ) + const hasActiveRows = db + .select({ id: ScheduleTable.id }) + .from(ScheduleTable) + .where(eq(ScheduleTable.status, "active")) + .limit(1) + .get() + .pipe( + Effect.orDie, + Effect.map((row) => row !== undefined), + ) + + const ownerID = randomUUID() + let leading = false + let bootChecked = false + + const claimLeader = Effect.fnUntraced(function* (now: number) { + const value = { owner: ownerID, until: now + LEADER_TTL } + const claimed = yield* db + .insert(KVTable) + .values({ key: LEADER_KEY, value, time_created: now, time_updated: now }) + .onConflictDoUpdate({ + target: KVTable.key, + set: { value, time_updated: now }, + where: sql`json_extract(${KVTable.value}, '$.owner') = ${ownerID} or json_extract(${KVTable.value}, '$.until') <= ${now}`, + }) + .returning({ key: KVTable.key }) + .get() + .pipe(Effect.orDie) + return claimed !== undefined + }) + + const releaseLeader = Effect.sync(() => { + leading = false + }).pipe( + Effect.andThen( + db + .delete(KVTable) + .where(and(eq(KVTable.key, LEADER_KEY), sql`json_extract(${KVTable.value}, '$.owner') = ${ownerID}`)) + .run() + .pipe(Effect.ignore), + ), + ) + + const heartbeat = Clock.currentTimeMillis.pipe( + Effect.flatMap(claimLeader), + Effect.ignore, + Effect.schedule(EffectSchedule.spaced(LEADER_TTL / 3)), + ) + const loop = Effect.gen(function* () { yield* doorbell.close + const active = yield* hasActiveRows + if (!active && bootChecked) { + if (leading) yield* releaseLeader + yield* doorbell.await.pipe(Effect.timeoutOption(MAX_SLEEP)) + return + } const now = yield* Clock.currentTimeMillis - yield* tickAt(now).pipe(Effect.catchCause((cause) => Effect.logError("schedule tick failed", { cause }))) + const isLeader = yield* claimLeader(now) + if (!isLeader) { + leading = false + bootChecked = true + yield* doorbell.await.pipe(Effect.timeoutOption(MAX_SLEEP)) + return + } + if (!leading) { + leading = true + bootChecked = true + yield* rewake.pipe(Effect.catchCause((cause) => Effect.logError("schedule rewake failed", { cause }))) + } + if (!active) { + yield* releaseLeader + yield* doorbell.await.pipe(Effect.timeoutOption(MAX_SLEEP)) + return + } + yield* Effect.scoped( + Effect.forkScoped(heartbeat).pipe( + Effect.andThen( + tickAt(now).pipe(Effect.catchCause((cause) => Effect.logError("schedule tick failed", { cause }))), + ), + ), + ) + if (!(yield* hasActiveRows)) { + yield* releaseLeader + yield* doorbell.await.pipe(Effect.timeoutOption(MAX_SLEEP)) + return + } const wait = yield* nextWake(now) if (wait > 0) yield* doorbell.await.pipe(Effect.timeoutOption(wait)) }) - const run = rewake.pipe( - Effect.catchCause((cause) => Effect.logError("schedule rewake failed", { cause })), - Effect.andThen(Effect.forever(loop)), - ) + const run = Effect.forever(loop).pipe(Effect.ensuring(releaseLeader)) const resolveZone = (tz: string | undefined) => { if (tz === undefined) return Effect.succeed(DateTime.zoneMakeLocal()) diff --git a/packages/core/src/tool/plugin/schedule.ts b/packages/core/src/tool/plugin/schedule.ts index 781ef69a5bd..f5147f3e620 100644 --- a/packages/core/src/tool/plugin/schedule.ts +++ b/packages/core/src/tool/plugin/schedule.ts @@ -52,7 +52,7 @@ export const Plugin = { ctx.event, Effect.andThen(ctx.tool.reload(), ctx.command.reload()), ) - const enabled = () => Config.latest(loaded.entries, "experimental")?.schedules === true + const enabled = () => Config.latest(loaded.entries, "experimental")?.schedules !== false // A request keeps the tools it started with after config reloads, so each call rechecks the flag. const allowed = (sessionID: Session.ID) => diff --git a/packages/core/test/schedule.test.ts b/packages/core/test/schedule.test.ts index 342aff3db37..024e919ac80 100644 --- a/packages/core/test/schedule.test.ts +++ b/packages/core/test/schedule.test.ts @@ -1,6 +1,6 @@ import { describe, expect } from "bun:test" import { FileSystem } from "@opencode/core/filesystem" -import { DateTime, Effect, Fiber, Latch, Layer, LayerMap, Queue, Schema, Sink, Stream } from "effect" +import { Clock, DateTime, Effect, Fiber, Latch, Layer, LayerMap, Queue, Schema, Sink, Stream } from "effect" import { ChildProcessSpawner } from "effect/process" import { ExitCode, makeHandle, ProcessId } from "effect/process/ChildProcessSpawner" import { TestClock } from "effect/testing" @@ -76,11 +76,19 @@ const enabledEntries = [ type: "document", info: new Info({ timezone: "America/New_York", - experimental: new ConfigExperimental.Info({ schedules: true }), + }), + }), +] +const disabledEntries = [ + new Document({ + type: "document", + info: new Info({ + experimental: new ConfigExperimental.Info({ schedules: false }), }), }), ] const enabled = Config.testLayer(enabledEntries) +const disabled = Config.testLayer(disabledEntries) /** A location whose flag the test turns on, counting every config read. */ const toggle = { on: false, reads: 0 } const toggled = Layer.succeed( @@ -89,7 +97,7 @@ const toggled = Layer.succeed( entries: () => Effect.sync(() => { toggle.reads++ - return toggle.on ? enabledEntries : [] + return toggle.on ? enabledEntries : disabledEntries }), changes: () => Stream.empty, }), @@ -224,7 +232,7 @@ const locations = makeGlobalNode({ ? enabled : ref.directory === toggleDirectory ? toggled - : Layer.empty, + : disabled, configureAgent.pipe( Layer.provideMerge( LayerNode.compile( @@ -1466,5 +1474,51 @@ describe("Schedule", () => { }) }), ) + + it.effect("picks up a schedule created by another process sharing the DB while idle", () => + Effect.gen(function* () { + const primary = yield* setup() + const { db } = yield* Database.Service + const runner = yield* Effect.forkChild(primary.run) + yield* Effect.repeat(Effect.yieldNow, { times: 5 }) + + // Insert directly into SQLite (bypassing primary.create so primary's in-memory doorbell is never opened) + // to simulate a short-lived `opencode serve` / `--standalone` writing a schedule and exiting. + const now = yield* Clock.currentTimeMillis + const externalID = Schedule.ID.create() + yield* db + .insert(ScheduleTable) + .values({ + id: externalID, + session_id: sessionID, + name: "external", + check: null, + state: null, + checks: 0, + action: { type: "prompt", prompt: "Cross-process wake." }, + when: { type: "in", in: "10 seconds" }, + tz: "UTC", + status: "active", + next_due_at: now + 10_000, + ends_at: null, + remaining_runs: 1, + time_created: now, + time_updated: now, + }) + .run() + .pipe(Effect.orDie) + + // Bounded MAX_SLEEP (30s) wakes the idle loop, claims leadership, and fires the row. + yield* TestClock.adjust("30 seconds") + yield* Effect.repeat(Effect.yieldNow, { times: 5 }) + yield* Fiber.interrupt(runner) + + expect(yield* primary.get(externalID)).toMatchObject({ + status: "done", + runCount: 1, + lastOutcome: "fired", + }) + }), + ) }) }) diff --git a/packages/core/test/tool-schedule.test.ts b/packages/core/test/tool-schedule.test.ts index 63b7dd83e5a..9796a15c9fe 100644 --- a/packages/core/test/tool-schedule.test.ts +++ b/packages/core/test/tool-schedule.test.ts @@ -141,15 +141,14 @@ const paths = (registry: Tool.Interface) => ) describe("ScheduleTools", () => { - it.effect("are absent unless experimental.schedules is enabled", () => + it.effect("are registered by default unless experimental.schedules is false", () => Effect.gen(function* () { - expect(yield* paths((yield* setup(undefined)).registry)).not.toContain(names[0]) const off = yield* setup(new ConfigExperimental.Info({ schedules: false })) expect(yield* paths(off.registry)).not.toContain(names[0]) expect(off.commands).toEqual([]) - const on = yield* setup(new ConfigExperimental.Info({ schedules: true })) - expect(yield* paths(on.registry)).toEqual(expect.arrayContaining(names)) - expect(on.commands.map((command) => command.name)).toEqual(["schedule"]) + const byDefault = yield* setup(undefined) + expect(yield* paths(byDefault.registry)).toEqual(expect.arrayContaining(names)) + expect(byDefault.commands.map((command) => command.name)).toEqual(["schedule"]) }), ) diff --git a/packages/protocol/openapi.json b/packages/protocol/openapi.json index d5f7cd24d33..fb34fdde1dc 100644 --- a/packages/protocol/openapi.json +++ b/packages/protocol/openapi.json @@ -12722,7 +12722,7 @@ } } }, - "description": "Schedule a prompt that wakes the Session once after a delay, at a time, every interval, or on a cron. Experimental: needs experimental.schedules in the Session's config and may change without notice.", + "description": "Schedule a prompt that wakes the Session once after a delay, at a time, every interval, or on a cron. Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false).", "summary": "Create schedule", "requestBody": { "content": { @@ -12811,7 +12811,7 @@ } } }, - "description": "List a Session's schedules, oldest first. Experimental: needs experimental.schedules in the Session's config and may change without notice.", + "description": "List a Session's schedules, oldest first. Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false).", "summary": "List schedules" } }, @@ -12889,7 +12889,7 @@ } } }, - "description": "Read one schedule. Experimental: needs experimental.schedules in the Session's config and may change without notice.", + "description": "Read one schedule. Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false).", "summary": "Get schedule" }, "delete": { @@ -12951,7 +12951,7 @@ } } }, - "description": "Delete a schedule. Experimental: needs experimental.schedules in the Session's config and may change without notice.", + "description": "Delete a schedule. Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false).", "summary": "Delete schedule" } }, @@ -13029,7 +13029,7 @@ } } }, - "description": "Stop a schedule from firing until it is resumed. Experimental: needs experimental.schedules in the Session's config and may change without notice.", + "description": "Stop a schedule from firing until it is resumed. Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false).", "summary": "Pause schedule" } }, @@ -13107,7 +13107,7 @@ } } }, - "description": "Resume a paused schedule. A one-shot that fell due while paused fires once; a repeating schedule resumes at its next slot. Experimental: needs experimental.schedules in the Session's config and may change without notice.", + "description": "Resume a paused schedule. A one-shot that fell due while paused fires once; a repeating schedule resumes at its next slot. Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false).", "summary": "Resume schedule" } }, diff --git a/packages/protocol/src/groups/schedule.ts b/packages/protocol/src/groups/schedule.ts index fec9a101ac8..baa19eab9e4 100644 --- a/packages/protocol/src/groups/schedule.ts +++ b/packages/protocol/src/groups/schedule.ts @@ -4,7 +4,8 @@ import { Schema } from "effect" import { HttpApiEndpoint, HttpApiSchema, OpenApi } from "effect/http-api" import { ForbiddenError, InvalidRequestError, ScheduleNotFoundError, SessionNotFoundError } from "../errors.js" -const EXPERIMENTAL = "Experimental: needs experimental.schedules in the Session's config and may change without notice." +const EXPERIMENTAL = + "Experimental: internal OpenCode schedule API; wire shape may change without notice (disable with experimental.schedules: false)." const errors = [ScheduleNotFoundError, ForbiddenError] as const const params = { scheduleID: Schedule.ID } const annotations = (identifier: string, summary: string, description: string) => diff --git a/packages/server/src/process.ts b/packages/server/src/process.ts index 5ae353d3dff..9058d497228 100644 --- a/packages/server/src/process.ts +++ b/packages/server/src/process.ts @@ -110,9 +110,9 @@ export const start = Effect.fn("ServerProcess.start")(function* ( yield* installRestartContinuity(Context.get(context, SessionRestart.Service)).pipe( Effect.provideService(Scope.Scope, applicationScope), ) - // Schedules fire from one process only; the table holds all their state. - yield* Effect.forkIn(Context.get(context, Schedule.Service).run, applicationScope) } + // Schedules fire from any server process (`service`, `opencode serve`, or `--standalone`); the table holds all their state. + yield* Effect.forkIn(Context.get(context, Schedule.Service).run, applicationScope) yield* Ref.set(application, Option.some(Context.get(context, HttpRouter.HttpRouter).asHttpEffect())) yield* status.ready const bus = Context.get(context, Bus.Service) diff --git a/packages/server/test/schedule.test.ts b/packages/server/test/schedule.test.ts index afc7b697473..976e2040f0d 100644 --- a/packages/server/test/schedule.test.ts +++ b/packages/server/test/schedule.test.ts @@ -6,6 +6,8 @@ import { Effect } from "effect" import { tmpdirScoped } from "../../core/test/fixture/tmpdir" import { it } from "../../core/test/lib/effect" import { ServerFetch } from "../src/fetch" +import { ServerProcess } from "../src/process" +import { startServer } from "./fixture/server" const client = (handler: (request: Request) => Promise) => OpenCode.make({ @@ -15,7 +17,7 @@ const client = (handler: (request: Request) => Promise) => }), }) -it.live("manages schedules through the experimental API where the session's config enables them", () => +it.live("manages schedules by default through the experimental API and honors experimental.schedules: false", () => Effect.gen(function* () { const dir = (yield* tmpdirScoped("opencode-schedule-api-")).path const global = path.join(dir, "global") @@ -23,7 +25,7 @@ it.live("manages schedules through the experimental API where the session's conf const disabled = path.join(dir, "disabled") yield* Effect.promise(async () => { await Promise.all([global, enabled, disabled].map((item) => fs.mkdir(item, { recursive: true }))) - await fs.writeFile(path.join(enabled, "opencode.json"), JSON.stringify({ experimental: { schedules: true } })) + await fs.writeFile(path.join(disabled, "opencode.json"), JSON.stringify({ experimental: { schedules: false } })) }) const handler = yield* ServerFetch.make({ app: { version: "test" }, @@ -142,3 +144,102 @@ it.live("manages schedules through the experimental API where the session's conf }) }).pipe(Effect.scoped), ) + +it.live("ticks due schedules in standalone ServerProcess.start without lifecycle", () => + Effect.gen(function* () { + const dir = (yield* tmpdirScoped("opencode-schedule-serve-")).path + const server = yield* startServer(dir) + const api = OpenCode.make({ baseUrl: server.base, headers: server.headers }) + + yield* Effect.promise(async () => { + await fs.writeFile(path.join(dir, "opencode.json"), JSON.stringify({ permission: { shell: "allow" } })) + const session = await api.session.create({ location: { directory: dir } }) + const created = await api.experimental.schedule.create({ + sessionID: session.id, + when: { in: "150 millis" }, + if: { run: "false" }, + prompt: "wake from serve", + }) + expect(created.status).toBe("active") + + const deadline = Date.now() + 5_000 + let current = created + while (current.status === "active" && Date.now() < deadline) { + await new Promise((resolve) => setTimeout(resolve, 50)) + current = await api.experimental.schedule.get({ scheduleID: created.id }) + } + expect(current).toMatchObject({ + status: "done", + lastOutcome: "checked", + }) + }) + }).pipe(Effect.scoped), +) + +it.live("elects one scheduler leader when two server processes boot against a due schedule", () => + Effect.gen(function* () { + const dir = (yield* tmpdirScoped("opencode-schedule-leader-")).path + const dbPath = path.join(dir, "shared.db") + const marker = path.join(dir, "runs.txt") + yield* Effect.promise(() => + fs.writeFile(path.join(dir, "opencode.json"), JSON.stringify({ permission: { shell: "allow" } })), + ) + + // Seed an active schedule in a short-lived scope so it falls due while no server is running. + const createdID = yield* Effect.scoped( + Effect.gen(function* () { + const handler = yield* ServerFetch.make({ + app: { version: "test" }, + database: { path: dbPath }, + config: { directory: dir, project: true, claude: false }, + models: { fetch: false }, + fs: { filewatcher: false }, + }) + const seededApi = client(handler) + return yield* Effect.promise(async () => { + const session = await seededApi.session.create({ location: { directory: dir } }) + const created = await seededApi.experimental.schedule.create({ + sessionID: session.id, + when: { in: "80 millis" }, + if: { run: `printf 'x\\n' >> ${JSON.stringify(marker)} && false` }, + prompt: "single leader check", + }) + return created.id + }) + }), + ) + yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 120))) + + const boot = () => + ServerProcess.start({ + hostname: "127.0.0.1", + port: 0, + password: "secret", + app: { version: "test-version" }, + database: { path: dbPath }, + config: { directory: dir }, + fs: { filewatcher: false }, + models: { fetch: false }, + }) + // Both servers start against the same already-due row at t=0; without leader election both run the check. + const [first] = yield* Effect.all([boot(), boot()], { concurrency: 2 }) + const base = `http://127.0.0.1:${"port" in first.address ? first.address.port : 0}` + const api = OpenCode.make({ + baseUrl: base, + headers: { authorization: `Basic ${btoa("opencode:secret")}` }, + }) + + yield* Effect.promise(async () => { + const deadline = Date.now() + 5_000 + let current = await api.experimental.schedule.get({ scheduleID: createdID }) + while (current.status === "active" && Date.now() < deadline) { + await new Promise((resolve) => setTimeout(resolve, 50)) + current = await api.experimental.schedule.get({ scheduleID: createdID }) + } + await new Promise((resolve) => setTimeout(resolve, 150)) + const lines = (await fs.readFile(marker, "utf8")).trim().split("\n").filter(Boolean) + expect(current.status).toBe("done") + expect(lines).toEqual(["x"]) + }) + }).pipe(Effect.scoped), +)