@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 317 lines 12.4 KB
Raw
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 );