The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 2 | import { expect, it } from "@effect/vitest"; |
| 3 | import { ScheduledTaskUpsertInput } from "@t3tools/contracts"; |
| 4 | import * as Effect from "effect/Effect"; |
| 5 | import * as Layer from "effect/Layer"; |
| 6 | import * as Schema from "effect/Schema"; |
| 7 | import * as SqlClient from "effect/sql/SqlClient"; |
| 8 | import * as TestClock from "effect/testing/TestClock"; |
| 9 | import { afterEach, vi } from "vite-plus/test"; |
| 10 | |
| 11 | import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts"; |
| 12 | import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts"; |
| 13 | import * as SqlitePersistence from "../persistence/Sqlite.ts"; |
| 14 | import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts"; |
| 15 | import * as Scheduler from "../scheduling/Scheduler.ts"; |
| 16 | import * as SecretRequests from "../secrets/SecretRequests.ts"; |
| 17 | import { ServerActivation } from "../serverActivation.ts"; |
| 18 | import * as ScheduledTaskService from "./ScheduledTaskService.ts"; |
| 19 | import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; |
| 20 | |
| 21 | afterEach(() => vi.unstubAllEnvs()); |
| 22 | |
| 23 | const dependencies = Layer.mergeAll( |
| 24 | NodeCrypto.layer, |
| 25 | Scheduler.layer, |
| 26 | ManagedPolicy.layerTest(), |
| 27 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 28 | launch: () => Effect.die("synthetic dispatch failure"), |
| 29 | isNonGitProject: () => Effect.succeed(false), |
| 30 | }), |
| 31 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 32 | namedProjectsRoot: "/projects", |
| 33 | isScratchProject: () => Effect.succeed(false), |
| 34 | }), |
| 35 | Layer.mock(ThreadManagementService.ThreadManagementService)({}), |
| 36 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 37 | ); |
| 38 | const serviceLayer = ScheduledTaskService.layer.pipe(Layer.provide(dependencies)); |
| 39 | const decodeInput = Schema.decodeUnknownEffect(ScheduledTaskUpsertInput); |
| 40 | const input = { |
| 41 | commandId: "interval-duration", |
| 42 | title: "Interval review", |
| 43 | prompt: "Review the open pull requests.", |
| 44 | enabled: true, |
| 45 | projectId: "project-interval-duration", |
| 46 | workspaceStrategy: { type: "root" }, |
| 47 | modelSelection: { instanceId: "codex", model: "gpt-5.4" }, |
| 48 | runtimeMode: "full-access", |
| 49 | interactionMode: "default", |
| 50 | }; |
| 51 | |
| 52 | it.effect.each([ |
| 53 | { |
| 54 | zone: "America/New_York", |
| 55 | from: "2026-03-08T06:30:00.000Z", |
| 56 | everyMs: 7_200_000, |
| 57 | expected: "2026-03-08T08:30:00.000Z", |
| 58 | }, |
| 59 | { |
| 60 | zone: "America/New_York", |
| 61 | from: "2026-11-01T05:30:00.000Z", |
| 62 | everyMs: 7_200_000, |
| 63 | expected: "2026-11-01T07:30:00.000Z", |
| 64 | }, |
| 65 | { |
| 66 | zone: "America/New_York", |
| 67 | from: "2026-11-01T06:30:00.000Z", |
| 68 | everyMs: 60_000, |
| 69 | expected: "2026-11-01T06:31:00.000Z", |
| 70 | }, |
| 71 | { |
| 72 | zone: "UTC", |
| 73 | from: "2026-11-01T06:30:00.000Z", |
| 74 | everyMs: 60_000, |
| 75 | expected: "2026-11-01T06:31:00.000Z", |
| 76 | }, |
| 77 | { |
| 78 | zone: "Asia/Tokyo", |
| 79 | from: "2026-03-08T06:30:00.000Z", |
| 80 | everyMs: 7_200_000, |
| 81 | expected: "2026-03-08T08:30:00.000Z", |
| 82 | }, |
| 83 | ] as const)("persists elapsed interval $zone from $from", ({ zone, from, everyMs, expected }) => |
| 84 | Effect.gen(function* () { |
| 85 | vi.stubEnv("TZ", zone); |
| 86 | yield* TestClock.setTime(Date.parse(from)); |
| 87 | yield* Effect.gen(function* () { |
| 88 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 89 | const decoded = yield* decodeInput({ ...input, schedule: { type: "interval", everyMs } }); |
| 90 | const created = yield* service.upsert(decoded); |
| 91 | expect(created.task.nextRunAt).toBe(expected); |
| 92 | expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expected); |
| 93 | |
| 94 | const paused = yield* service.setEnabled({ id: created.task.id, enabled: false }); |
| 95 | expect(paused.task.nextRunAt).toBeNull(); |
| 96 | const resumed = yield* service.setEnabled({ id: created.task.id, enabled: true }); |
| 97 | expect(resumed.task.nextRunAt).toBe(expected); |
| 98 | |
| 99 | // Exercise completion rescheduling without starting any provider process. |
| 100 | const completed = yield* service.runNow({ id: created.task.id }); |
| 101 | expect(completed.task.lastRunStatus).toBe("failed"); |
| 102 | expect(completed.threadId).toBeNull(); |
| 103 | expect(completed.task.runCount).toBe(1); |
| 104 | expect(completed.task.nextRunAt).toBe(expected); |
| 105 | expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expected); |
| 106 | }).pipe(Effect.provide(serviceLayer)); |
| 107 | }).pipe( |
| 108 | // Keep the real scheduler parked while exercising finite service actions. |
| 109 | Effect.provideService(ServerActivation, Effect.never), |
| 110 | Effect.provide(SqlitePersistence.layerMemory), |
| 111 | ), |
| 112 | ); |
| 113 | |
| 114 | it.effect.each([ |
| 115 | { from: "2026-03-07T23:30:00.000Z", expected: "2026-03-08T13:00:00.000Z" }, |
| 116 | { from: "2026-10-31T23:30:00.000Z", expected: "2026-11-01T14:00:00.000Z" }, |
| 117 | ] as const)("keeps fixed-time schedules on the local calendar from $from", ({ from, expected }) => |
| 118 | Effect.gen(function* () { |
| 119 | vi.stubEnv("TZ", "America/New_York"); |
| 120 | yield* TestClock.setTime(Date.parse(from)); |
| 121 | yield* Effect.gen(function* () { |
| 122 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 123 | const decoded = yield* decodeInput({ |
| 124 | ...input, |
| 125 | schedule: { type: "fixed_time", timeOfDay: "09:00" }, |
| 126 | }); |
| 127 | const created = yield* service.upsert(decoded); |
| 128 | expect(created.task.nextRunAt).toBe(expected); |
| 129 | expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expected); |
| 130 | }).pipe(Effect.provide(serviceLayer)); |
| 131 | }).pipe( |
| 132 | Effect.provideService(ServerActivation, Effect.never), |
| 133 | Effect.provide(SqlitePersistence.layerMemory), |
| 134 | ), |
| 135 | ); |
| 136 | |
| 137 | // Each launch takes two minutes, so a manual run can start before the run time and end after it. |
| 138 | const slowLaunchLayer = ScheduledTaskService.layer.pipe( |
| 139 | Layer.provide( |
| 140 | Layer.merge( |
| 141 | dependencies, |
| 142 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 143 | launch: () => TestClock.adjust("2 minutes").pipe(Effect.andThen(Effect.die("synthetic"))), |
| 144 | }), |
| 145 | ), |
| 146 | ), |
| 147 | ); |
| 148 | |
| 149 | it.effect("runs a one-time schedule once and rejects past times", () => |
| 150 | Effect.gen(function* () { |
| 151 | yield* TestClock.setTime(Date.parse("2026-11-01T07:59:00.000Z")); |
| 152 | yield* Effect.gen(function* () { |
| 153 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 154 | const decoded = yield* decodeInput({ |
| 155 | ...input, |
| 156 | schedule: { type: "once", runAt: "2026-11-01T03:00:00-05:00" }, |
| 157 | }); |
| 158 | const created = yield* service.upsert(decoded); |
| 159 | expect(created.task.schedule).toEqual({ type: "once", runAt: "2026-11-01T08:00:00.000Z" }); |
| 160 | expect(created.task.nextRunAt).toBe("2026-11-01T08:00:00.000Z"); |
| 161 | |
| 162 | // A manual run that starts before the time keeps the scheduled run, even if it ends after. |
| 163 | const early = yield* service.runNow({ id: created.task.id }); |
| 164 | expect(early.task.nextRunAt).toBe("2026-11-01T08:00:00.000Z"); |
| 165 | |
| 166 | const due = yield* service.runNow({ id: created.task.id }); |
| 167 | expect(due.task.nextRunAt).toBeNull(); |
| 168 | expect((yield* service.list()).tasks[0]?.nextRunAt).toBeNull(); |
| 169 | |
| 170 | yield* service.setEnabled({ id: created.task.id, enabled: false }); |
| 171 | const resumed = yield* service |
| 172 | .setEnabled({ id: created.task.id, enabled: true }) |
| 173 | .pipe(Effect.flip); |
| 174 | expect(resumed.message).toBe("The run time has passed. Pick a time in the future."); |
| 175 | |
| 176 | const past = yield* service |
| 177 | .upsert({ ...decoded, commandId: undefined, title: "Late" }) |
| 178 | .pipe(Effect.flip); |
| 179 | expect(past.message).toBe("The run time has passed. Pick a time in the future."); |
| 180 | }).pipe(Effect.provide(slowLaunchLayer)); |
| 181 | }).pipe( |
| 182 | Effect.provideService(ServerActivation, Effect.never), |
| 183 | Effect.provide(SqlitePersistence.layerMemory), |
| 184 | ), |
| 185 | ); |
| 186 | |
| 187 | const ONCE = { type: "once", runAt: "2026-11-01T08:00:00Z" } as const; |
| 188 | /** A next run that only the simulated concurrent write produces. */ |
| 189 | const MOVED = "2030-01-01T00:00:00.000Z"; |
| 190 | |
| 191 | const onceInput = { |
| 192 | ...input, |
| 193 | commandId: "once-race", |
| 194 | schedule: { type: "once", runAt: "2026-11-01T08:00:00Z" }, |
| 195 | }; |
| 196 | |
| 197 | it.effect.each([ |
| 198 | { change: "a run completes", saved: ONCE, edited: ONCE, pause: false, expected: MOVED }, |
| 199 | { |
| 200 | change: "a run completes during a padded-time edit", |
| 201 | saved: { type: "fixed_time", timeOfDay: "9:00" }, |
| 202 | edited: { type: "fixed_time", timeOfDay: "09:00" }, |
| 203 | pause: false, |
| 204 | expected: MOVED, |
| 205 | }, |
| 206 | { |
| 207 | change: "another client pauses the task", |
| 208 | saved: ONCE, |
| 209 | edited: ONCE, |
| 210 | pause: true, |
| 211 | expected: "2026-11-01T08:00:00.000Z", |
| 212 | }, |
| 213 | ] as const)( |
| 214 | "a title save keeps the stored next run only while nothing else changed: $change", |
| 215 | ({ saved, edited, pause, expected }) => |
| 216 | Effect.gen(function* () { |
| 217 | yield* TestClock.setTime(Date.parse("2026-11-01T07:00:00.000Z")); |
| 218 | // The project check runs between the save's read and write, so it stands in for |
| 219 | // a concurrent write in that gap. |
| 220 | const writeMidSave = Layer.unwrap( |
| 221 | Effect.gen(function* () { |
| 222 | const sql = yield* SqlClient.SqlClient; |
| 223 | return Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 224 | namedProjectsRoot: "/projects", |
| 225 | isScratchProject: () => |
| 226 | sql`UPDATE scheduled_tasks SET next_run_at = ${MOVED}, enabled = ${pause ? 0 : 1}`.pipe( |
| 227 | Effect.as(false), |
| 228 | Effect.orDie, |
| 229 | ), |
| 230 | }); |
| 231 | }), |
| 232 | ); |
| 233 | const layer = ScheduledTaskService.layer.pipe( |
| 234 | Layer.provide(Layer.merge(dependencies, writeMidSave)), |
| 235 | ); |
| 236 | yield* Effect.gen(function* () { |
| 237 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 238 | const worktree = { type: "worktree", baseRef: "main" }; |
| 239 | yield* service.upsert( |
| 240 | yield* decodeInput({ |
| 241 | ...onceInput, |
| 242 | schedule: saved, |
| 243 | workspaceStrategy: { type: "root" }, |
| 244 | }), |
| 245 | ); |
| 246 | const renamed = yield* service.upsert( |
| 247 | yield* decodeInput({ |
| 248 | ...onceInput, |
| 249 | schedule: edited, |
| 250 | workspaceStrategy: worktree, |
| 251 | title: "Renamed", |
| 252 | }), |
| 253 | ); |
| 254 | expect(renamed.task.enabled).toBe(true); |
| 255 | expect(renamed.task.nextRunAt).toBe(expected); |
| 256 | }).pipe(Effect.provide(layer)); |
| 257 | }).pipe( |
| 258 | Effect.provideService(ServerActivation, Effect.never), |
| 259 | Effect.provide(SqlitePersistence.layerMemory), |
| 260 | ), |
| 261 | ); |
| 262 | |
| 263 | it.effect("keeps a one-time run after a restart interrupts an earlier manual run", () => |
| 264 | Effect.gen(function* () { |
| 265 | yield* TestClock.setTime(Date.parse("2026-11-01T07:59:00.000Z")); |
| 266 | const sql = yield* SqlClient.SqlClient; |
| 267 | const created = yield* Effect.gen(function* () { |
| 268 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 269 | return yield* service.upsert(yield* decodeInput(onceInput)); |
| 270 | }).pipe(Effect.provide(serviceLayer)); |
| 271 | yield* sql`UPDATE scheduled_tasks SET last_run_status = 'running', last_run_at = '2026-11-01T07:59:00.000Z'`; |
| 272 | |
| 273 | yield* TestClock.setTime(Date.parse("2026-11-01T08:05:00.000Z")); |
| 274 | yield* Effect.gen(function* () { |
| 275 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 276 | const [task] = (yield* service.list()).tasks; |
| 277 | expect(task?.id).toBe(created.task.id); |
| 278 | expect(task?.lastRunStatus).toBe("failed"); |
| 279 | expect(task?.nextRunAt).toBe("2026-11-01T08:00:00.000Z"); |
| 280 | }).pipe(Effect.provide(serviceLayer)); |
| 281 | }).pipe( |
| 282 | Effect.provideService(ServerActivation, Effect.never), |
| 283 | Effect.provide(SqlitePersistence.layerMemory), |
| 284 | ), |
| 285 | ); |
| 286 | |
| 287 | it.effect("reports the stored task when the row was replaced during the run", () => |
| 288 | Effect.gen(function* () { |
| 289 | yield* TestClock.setTime(Date.parse("2026-11-01T07:00:00.000Z")); |
| 290 | // The launch stands in for a delete and same-id recreate while the run is out. |
| 291 | const replaceRowDuringLaunch = Layer.unwrap( |
| 292 | Effect.gen(function* () { |
| 293 | const sql = yield* SqlClient.SqlClient; |
| 294 | return Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 295 | launch: () => |
| 296 | sql`UPDATE scheduled_tasks SET last_run_status = 'never', last_run_at = NULL, run_count = 0`.pipe( |
| 297 | Effect.orDie, |
| 298 | Effect.andThen(Effect.die("synthetic dispatch failure")), |
| 299 | ), |
| 300 | }); |
| 301 | }), |
| 302 | ); |
| 303 | const layer = ScheduledTaskService.layer.pipe( |
| 304 | Layer.provide(Layer.merge(dependencies, replaceRowDuringLaunch)), |
| 305 | ); |
| 306 | yield* Effect.gen(function* () { |
| 307 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 308 | const created = yield* service.upsert(yield* decodeInput(onceInput)); |
| 309 | const ran = yield* service.runNow({ id: created.task.id }); |
| 310 | expect(ran.task.runCount).toBe(0); |
| 311 | expect(ran.task.lastRunStatus).toBe("never"); |
| 312 | }).pipe(Effect.provide(layer)); |
| 313 | }).pipe( |
| 314 | Effect.provideService(ServerActivation, Effect.never), |
| 315 | Effect.provide(SqlitePersistence.layerMemory), |
| 316 | ), |
| 317 | ); |