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
| 1 | import * as Scheduler from "../scheduling/Scheduler.ts"; |
| 2 | import * as NodeUtil from "node:util"; |
| 3 | |
| 4 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 5 | import { assert, it, vi } from "@effect/vitest"; |
| 6 | import { |
| 7 | CommandId, |
| 8 | ProjectId, |
| 9 | ProviderInstanceId, |
| 10 | ScheduledTaskError, |
| 11 | ScheduledTaskId, |
| 12 | type ScheduledTaskUpsertInput, |
| 13 | SecretRef, |
| 14 | ThreadId, |
| 15 | } from "@t3tools/contracts"; |
| 16 | import * as DateTime from "effect/DateTime"; |
| 17 | import * as Effect from "effect/Effect"; |
| 18 | import * as Exit from "effect/Exit"; |
| 19 | import * as Layer from "effect/Layer"; |
| 20 | import * as Logger from "effect/Logger"; |
| 21 | import * as Option from "effect/Option"; |
| 22 | import * as SqlClient from "effect/sql/SqlClient"; |
| 23 | |
| 24 | import * as Fiber from "effect/Fiber"; |
| 25 | import * as Stream from "effect/Stream"; |
| 26 | import * as Deferred from "effect/Deferred"; |
| 27 | import * as Ref from "effect/Ref"; |
| 28 | import * as Schema from "effect/Schema"; |
| 29 | import * as TestClock from "effect/testing/TestClock"; |
| 30 | |
| 31 | import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts"; |
| 32 | import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts"; |
| 33 | import { OrchestratorDispatchError } from "../orchestration-v2/Orchestrator.ts"; |
| 34 | import * as SecretRequests from "../secrets/SecretRequests.ts"; |
| 35 | import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts"; |
| 36 | import * as SqlitePersistence from "../persistence/Sqlite.ts"; |
| 37 | import * as ScheduledTaskService from "./ScheduledTaskService.ts"; |
| 38 | import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; |
| 39 | |
| 40 | const isScheduledTaskError = Schema.is(ScheduledTaskError); |
| 41 | |
| 42 | const threadShell = ( |
| 43 | projectId: ProjectId, |
| 44 | state: { archivedAt?: string | null; deletedAt?: string | null } = {}, |
| 45 | ) => ({ projectId, archivedAt: null, deletedAt: null, ...state }) as never; |
| 46 | |
| 47 | const insertRow = ( |
| 48 | sql: SqlClient.SqlClient, |
| 49 | row: { |
| 50 | id: string | null; |
| 51 | next: string | null; |
| 52 | enabled: number; |
| 53 | status: string; |
| 54 | scheduleJson?: string; |
| 55 | prompt?: string; |
| 56 | }, |
| 57 | now: string, |
| 58 | ) => |
| 59 | sql`INSERT INTO scheduled_tasks ${sql.insert({ |
| 60 | task_id: row.id, |
| 61 | title: "task", |
| 62 | prompt: row.prompt ?? "Run task", |
| 63 | enabled: row.enabled, |
| 64 | schedule_json: row.scheduleJson ?? '{"type":"interval","everyMs":60000}', |
| 65 | project_id: "project:test", |
| 66 | thread_id: null, |
| 67 | workspace_strategy_json: '{"type":"root"}', |
| 68 | model_selection_json: '{"instanceId":"codex","model":"gpt-5"}', |
| 69 | runtime_mode: "full-access", |
| 70 | interaction_mode: "default", |
| 71 | created_by: "user", |
| 72 | creation_source: "web", |
| 73 | created_at: now, |
| 74 | updated_at: now, |
| 75 | next_run_at: row.next, |
| 76 | last_run_at: null, |
| 77 | last_run_status: row.status, |
| 78 | last_run_error: null, |
| 79 | run_count: 0, |
| 80 | })}`; |
| 81 | |
| 82 | it.effect("loads only due tasks and skips corrupt due rows without decoding settled tasks", () => |
| 83 | Effect.gen(function* () { |
| 84 | const sql = yield* SqlClient.SqlClient; |
| 85 | const now = "2026-09-09T12:00:00.000Z"; |
| 86 | const secret = "PROMPT-SECRET-DO-NOT-LOG"; |
| 87 | const credential = "CREDENTIAL-SECRET-DO-NOT-LOG"; |
| 88 | for (const row of [ |
| 89 | { id: "due-now", next: now, enabled: 1, status: "never" }, |
| 90 | { id: "", next: now, enabled: 1, status: "never" }, |
| 91 | { id: " ", next: now, enabled: 1, status: "never" }, |
| 92 | { id: null, next: now, enabled: 1, status: "never" }, |
| 93 | { |
| 94 | id: "due-earlier", |
| 95 | next: "2026-09-09T11:00:00.000Z", |
| 96 | enabled: 1, |
| 97 | status: "failed", |
| 98 | }, |
| 99 | { id: "due-bad-date", next: "", enabled: 1, status: "never" }, |
| 100 | { |
| 101 | id: "due-corrupt", |
| 102 | next: now, |
| 103 | enabled: 1, |
| 104 | status: "never", |
| 105 | scheduleJson: "broken", |
| 106 | }, |
| 107 | { |
| 108 | id: "due-cred", |
| 109 | next: now, |
| 110 | enabled: 1, |
| 111 | status: "never", |
| 112 | scheduleJson: `{"type":"interval","everyMs":"${credential}"}`, |
| 113 | }, |
| 114 | { id: "disabled", next: now, enabled: 0, status: "never", scheduleJson: "broken" }, |
| 115 | { |
| 116 | id: "future", |
| 117 | next: "2026-09-09T12:00:00.001Z", |
| 118 | enabled: 1, |
| 119 | status: "never", |
| 120 | scheduleJson: "broken", |
| 121 | }, |
| 122 | { |
| 123 | id: "unscheduled", |
| 124 | next: null, |
| 125 | enabled: 1, |
| 126 | status: "never", |
| 127 | scheduleJson: "broken", |
| 128 | }, |
| 129 | { id: "running", next: now, enabled: 1, status: "running", scheduleJson: "broken" }, |
| 130 | ]) { |
| 131 | yield* insertRow(sql, { ...row, prompt: secret }, now); |
| 132 | } |
| 133 | const warnings: unknown[] = []; |
| 134 | const tasks = yield* ScheduledTaskService.listDueTasks(DateTime.makeUnsafe(now)).pipe( |
| 135 | Effect.provide( |
| 136 | Logger.layer([ |
| 137 | Logger.make(({ message }) => { |
| 138 | warnings.push(message); |
| 139 | }), |
| 140 | ]), |
| 141 | ), |
| 142 | ); |
| 143 | assert.deepEqual( |
| 144 | tasks.map((task) => task.id), |
| 145 | ["due-earlier", "due-now"], |
| 146 | ); |
| 147 | assert.equal(warnings.length, 6); |
| 148 | const annotations = warnings.map( |
| 149 | (warning) => (warning as ReadonlyArray<unknown>)[1] as Record<string, unknown>, |
| 150 | ); |
| 151 | assert.deepEqual( |
| 152 | annotations.map((annotation) => annotation.taskId), |
| 153 | ["due-bad-date", null, "", " ", "due-corrupt", "due-cred"], |
| 154 | ); |
| 155 | const causes = annotations.map((annotation) => annotation.cause); |
| 156 | assert.deepEqual( |
| 157 | causes.map((cause) => (isScheduledTaskError(cause) ? cause.taskId : undefined)), |
| 158 | [undefined, undefined, undefined, undefined, "due-corrupt", "due-cred"], |
| 159 | ); |
| 160 | for (const cause of causes) { |
| 161 | if (cause !== undefined) assert.isTrue(isScheduledTaskError(cause)); |
| 162 | } |
| 163 | const rendered = NodeUtil.inspect(annotations, { depth: null }); |
| 164 | assert.isFalse(rendered.includes(secret)); |
| 165 | assert.isFalse(rendered.includes(credential)); |
| 166 | const running = yield* sql<{ |
| 167 | last_run_status: string; |
| 168 | }>`SELECT last_run_status FROM scheduled_tasks WHERE task_id = 'running'`; |
| 169 | assert.equal(running[0]?.last_run_status, "running"); |
| 170 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 171 | ); |
| 172 | |
| 173 | it.effect( |
| 174 | "releases interrupted runs on startup and still executes due tasks, skipping corrupt rows", |
| 175 | () => |
| 176 | Effect.gen(function* () { |
| 177 | const sql = yield* SqlClient.SqlClient; |
| 178 | const now = "2026-09-09T12:00:00.000Z"; |
| 179 | const hugeInterval = '{"type":"interval","everyMs":9000000000000000}'; |
| 180 | for (const row of [ |
| 181 | { id: "stuck-valid", next: now, status: "running" }, |
| 182 | { id: "stuck-corrupt", next: now, status: "running", scheduleJson: "broken" }, |
| 183 | { id: "stuck-huge", next: now, status: "running", scheduleJson: hugeInterval }, |
| 184 | { id: null, next: now, status: "running" }, |
| 185 | { id: "due-bad-date", next: "", status: "never" }, |
| 186 | { id: "due-healthy", next: now, status: "never" }, |
| 187 | { id: "due-huge", next: now, status: "never", scheduleJson: hugeInterval }, |
| 188 | { id: "due-second", next: now, status: "never" }, |
| 189 | { id: "due-third", next: now, status: "never" }, |
| 190 | ]) { |
| 191 | yield* insertRow(sql, { ...row, enabled: 1 }, now); |
| 192 | } |
| 193 | |
| 194 | yield* TestClock.setTime(Date.parse(now) + 1_000); |
| 195 | const dispatched = yield* Ref.make(0); |
| 196 | const lastDispatched = yield* Deferred.make<void>(); |
| 197 | const releaseLast = yield* Deferred.make<void>(); |
| 198 | yield* Effect.scoped( |
| 199 | Effect.gen(function* () { |
| 200 | yield* Layer.build( |
| 201 | Layer.provideMerge( |
| 202 | ScheduledTaskService.layer, |
| 203 | Layer.mergeAll( |
| 204 | ManagedPolicy.layerTest(), |
| 205 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 206 | launch: () => |
| 207 | Ref.updateAndGet(dispatched, (n) => n + 1).pipe( |
| 208 | Effect.andThen((n) => |
| 209 | n === 4 |
| 210 | ? Deferred.succeed(lastDispatched, undefined).pipe( |
| 211 | Effect.andThen(Deferred.await(releaseLast)), |
| 212 | ) |
| 213 | : Effect.void, |
| 214 | ), |
| 215 | Effect.andThen(Effect.die(new Error("test launch failure"))), |
| 216 | ), |
| 217 | }), |
| 218 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 219 | namedProjectsRoot: "/projects", |
| 220 | isScratchProject: () => Effect.succeed(false), |
| 221 | }), |
| 222 | Layer.mock(ThreadManagementService.ThreadManagementService)({}), |
| 223 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 224 | NodeCrypto.layer, |
| 225 | Scheduler.layer, |
| 226 | ), |
| 227 | ), |
| 228 | ); |
| 229 | // The poll delays before its first pass; advance the frozen clock once. |
| 230 | yield* TestClock.adjust("6 seconds"); |
| 231 | yield* Deferred.await(lastDispatched); |
| 232 | const inflight = yield* sql<{ |
| 233 | last_run_status: string; |
| 234 | }>`SELECT last_run_status FROM scheduled_tasks WHERE task_id = 'due-third'`; |
| 235 | assert.equal(inflight[0]?.last_run_status, "running"); |
| 236 | yield* Deferred.succeed(releaseLast, undefined); |
| 237 | }), |
| 238 | ); |
| 239 | |
| 240 | const rows = yield* sql<{ |
| 241 | task_id: string | null; |
| 242 | last_run_status: string; |
| 243 | last_run_error: string | null; |
| 244 | next_run_at: string | null; |
| 245 | run_count: number; |
| 246 | }>`SELECT task_id, last_run_status, last_run_error, next_run_at, run_count |
| 247 | FROM scheduled_tasks ORDER BY task_id`; |
| 248 | const byId = new Map(rows.map((row) => [row.task_id, row])); |
| 249 | assert.equal(rows.length, 9); |
| 250 | assert.equal(byId.get("stuck-valid")?.last_run_status, "failed"); |
| 251 | assert.isNotNull(byId.get("stuck-valid")?.next_run_at); |
| 252 | assert.equal(byId.get("stuck-corrupt")?.last_run_status, "failed"); |
| 253 | assert.equal(byId.get(null)?.last_run_status, "failed"); |
| 254 | const stuckHuge = byId.get("stuck-huge"); |
| 255 | assert.equal(stuckHuge?.last_run_status, "failed"); |
| 256 | assert.isNull(stuckHuge?.next_run_at); |
| 257 | for (const id of ["stuck-valid", "stuck-corrupt", "stuck-huge", null]) { |
| 258 | const row = byId.get(id); |
| 259 | assert.equal(row?.last_run_error, "Run was interrupted by a server restart."); |
| 260 | assert.equal(row?.run_count, 1); |
| 261 | } |
| 262 | for (const id of ["due-healthy", "due-huge", "due-second"]) { |
| 263 | const row = byId.get(id); |
| 264 | assert.equal(row?.last_run_status, "failed"); |
| 265 | assert.isTrue(row?.last_run_error?.includes("test launch failure") === true); |
| 266 | assert.equal(row?.run_count, 1); |
| 267 | } |
| 268 | assert.isNull(byId.get("due-huge")?.next_run_at); |
| 269 | assert.equal(byId.get("due-bad-date")?.last_run_status, "never"); |
| 270 | assert.equal(byId.get("due-bad-date")?.run_count, 0); |
| 271 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 272 | ); |
| 273 | |
| 274 | it.effect( |
| 275 | "treats a next_run_at corrupted before the dispatch re-read as not due instead of defecting the poll", |
| 276 | () => |
| 277 | Effect.gen(function* () { |
| 278 | const sql = yield* SqlClient.SqlClient; |
| 279 | const now = "2026-09-09T12:00:00.000Z"; |
| 280 | for (const row of [ |
| 281 | { id: "run-a", next: now, status: "never" }, |
| 282 | { id: "run-b-victim", next: now, status: "never" }, |
| 283 | { id: "run-c", next: now, status: "never" }, |
| 284 | { id: "run-d", next: now, status: "never" }, |
| 285 | ]) { |
| 286 | yield* insertRow(sql, { ...row, enabled: 1 }, now); |
| 287 | } |
| 288 | yield* TestClock.setTime(Date.parse(now) + 1_000); |
| 289 | const dispatched = yield* Ref.make(0); |
| 290 | const lastDispatched = yield* Deferred.make<void>(); |
| 291 | const releaseLast = yield* Deferred.make<void>(); |
| 292 | yield* Effect.scoped( |
| 293 | Effect.gen(function* () { |
| 294 | yield* Layer.build( |
| 295 | Layer.provideMerge( |
| 296 | ScheduledTaskService.layer, |
| 297 | Layer.mergeAll( |
| 298 | ManagedPolicy.layerTest(), |
| 299 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 300 | launch: () => |
| 301 | Ref.updateAndGet(dispatched, (n) => n + 1).pipe( |
| 302 | Effect.andThen((n) => |
| 303 | n === 1 |
| 304 | ? sql`UPDATE scheduled_tasks |
| 305 | SET next_run_at = '' |
| 306 | WHERE task_id = 'run-b-victim'`.pipe(Effect.asVoid, Effect.orDie) |
| 307 | : n === 3 |
| 308 | ? Deferred.succeed(lastDispatched, undefined).pipe( |
| 309 | Effect.andThen(Deferred.await(releaseLast)), |
| 310 | ) |
| 311 | : Effect.void, |
| 312 | ), |
| 313 | Effect.andThen(Effect.die(new Error("test launch failure"))), |
| 314 | ), |
| 315 | }), |
| 316 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 317 | namedProjectsRoot: "/projects", |
| 318 | isScratchProject: () => Effect.succeed(false), |
| 319 | }), |
| 320 | Layer.mock(ThreadManagementService.ThreadManagementService)({}), |
| 321 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 322 | NodeCrypto.layer, |
| 323 | Scheduler.layer, |
| 324 | ), |
| 325 | ), |
| 326 | ); |
| 327 | yield* TestClock.adjust("6 seconds"); |
| 328 | yield* Deferred.await(lastDispatched); |
| 329 | assert.equal(yield* Ref.get(dispatched), 3); |
| 330 | const rows = yield* sql<{ |
| 331 | task_id: string; |
| 332 | last_run_status: string; |
| 333 | next_run_at: string | null; |
| 334 | run_count: number; |
| 335 | }>`SELECT task_id, last_run_status, next_run_at, run_count |
| 336 | FROM scheduled_tasks ORDER BY task_id`; |
| 337 | const byId = new Map(rows.map((row) => [row.task_id, row])); |
| 338 | const victim = byId.get("run-b-victim"); |
| 339 | assert.equal(victim?.last_run_status, "never"); |
| 340 | assert.equal(victim?.run_count, 0); |
| 341 | assert.equal(victim?.next_run_at, ""); |
| 342 | for (const id of ["run-a", "run-c"]) { |
| 343 | const row = byId.get(id); |
| 344 | assert.equal(row?.last_run_status, "failed"); |
| 345 | assert.equal(row?.run_count, 1); |
| 346 | } |
| 347 | yield* Deferred.succeed(releaseLast, undefined); |
| 348 | }), |
| 349 | ); |
| 350 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 351 | ); |
| 352 | |
| 353 | it.effect("thread cleanup notifies subscribers and a finishing run cannot recreate the task", () => |
| 354 | Effect.gen(function* () { |
| 355 | const started = yield* Deferred.make<void>(); |
| 356 | const release = yield* Deferred.make<void>(); |
| 357 | const subscribed = yield* Deferred.make<void>(); |
| 358 | const running = yield* Deferred.make<void>(); |
| 359 | const removed = yield* Deferred.make<void>(); |
| 360 | const layer = ScheduledTaskService.layer.pipe( |
| 361 | Layer.provide( |
| 362 | Layer.mergeAll( |
| 363 | ManagedPolicy.layerTest(), |
| 364 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 365 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 366 | sendToThread: () => |
| 367 | Deferred.succeed(started, undefined).pipe( |
| 368 | Effect.andThen(Deferred.await(release)), |
| 369 | Effect.andThen(Effect.die("test dispatch failure")), |
| 370 | ), |
| 371 | getThreadShell: () => Effect.succeed(threadShell(ProjectId.make("project:test"))), |
| 372 | }), |
| 373 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 374 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 375 | namedProjectsRoot: "/projects", |
| 376 | isScratchProject: () => Effect.succeed(false), |
| 377 | }), |
| 378 | NodeCrypto.layer, |
| 379 | Scheduler.layer, |
| 380 | ), |
| 381 | ), |
| 382 | ); |
| 383 | yield* Effect.gen(function* () { |
| 384 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 385 | const threadId = ThreadId.make("thread:deleted-during-run"); |
| 386 | const { task } = yield* service.upsert({ |
| 387 | id: ScheduledTaskId.make("task:deleted-during-run"), |
| 388 | title: "Check orchestration", |
| 389 | prompt: "Check progress", |
| 390 | enabled: true, |
| 391 | schedule: { type: "interval", everyMs: 60_000 }, |
| 392 | projectId: ProjectId.make("project:test"), |
| 393 | threadId, |
| 394 | workspaceStrategy: { type: "root" }, |
| 395 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 396 | runtimeMode: "full-access", |
| 397 | interactionMode: "default", |
| 398 | }); |
| 399 | yield* service.subscribeList().pipe( |
| 400 | Stream.runForEach(({ tasks }) => { |
| 401 | const current = tasks.find((candidate) => candidate.id === task.id); |
| 402 | if (current === undefined) return Deferred.succeed(removed, undefined); |
| 403 | return current.lastRunStatus === "running" |
| 404 | ? Deferred.succeed(running, undefined) |
| 405 | : Deferred.succeed(subscribed, undefined); |
| 406 | }), |
| 407 | Effect.forkChild, |
| 408 | ); |
| 409 | yield* Deferred.await(subscribed); |
| 410 | const run = yield* service.runNow({ id: task.id }).pipe(Effect.forkChild); |
| 411 | yield* Deferred.await(started); |
| 412 | yield* Deferred.await(running); |
| 413 | const refused = yield* service.runNow({ id: task.id }).pipe(Effect.flip); |
| 414 | assert.equal(refused.message, "Schedule task is already running."); |
| 415 | yield* service.deleteForThread(threadId); |
| 416 | yield* Deferred.await(removed); |
| 417 | yield* Deferred.succeed(release, undefined); |
| 418 | yield* Fiber.join(run); |
| 419 | assert.lengthOf((yield* service.list()).tasks, 0); |
| 420 | }).pipe(Effect.provide(layer)); |
| 421 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 422 | ); |
| 423 | |
| 424 | it.effect.each([ |
| 425 | { status: "failed", error: "Weekly usage limit reached", heldWarning: false }, |
| 426 | { status: "failed", error: "Weekly usage limit reached", heldWarning: true }, |
| 427 | { status: "interrupted", error: "The run was stopped.", heldWarning: false }, |
| 428 | { status: "cancelled", error: "The run was cancelled.", heldWarning: false }, |
| 429 | ] as const)("a run that ends $status after its message was accepted records it", (outcome) => |
| 430 | Effect.gen(function* () { |
| 431 | const projectId = ProjectId.make("project:test"); |
| 432 | const ended = yield* Deferred.make<void>(); |
| 433 | const sent = yield* Ref.make(""); |
| 434 | const run = { id: "run:2", status: outcome.status, rootNodeId: "node:root" }; |
| 435 | const layer = ScheduledTaskService.layer.pipe( |
| 436 | Layer.provide( |
| 437 | Layer.mergeAll( |
| 438 | ManagedPolicy.layerTest(), |
| 439 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 440 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 441 | sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)), |
| 442 | getThreadShell: () => Effect.succeed(threadShell(projectId)), |
| 443 | getProjectThreadRecords: () => |
| 444 | Effect.map( |
| 445 | Ref.get(sent), |
| 446 | (userMessageId) => |
| 447 | ({ |
| 448 | runs: [ |
| 449 | { id: "run:1", status: "completed", userMessageId: "message:earlier" }, |
| 450 | { ...run, userMessageId }, |
| 451 | ], |
| 452 | messages: [{ id: userMessageId, runId: "run:2" }], |
| 453 | turnItems: [ |
| 454 | { |
| 455 | type: "error", |
| 456 | status: "failed", |
| 457 | runId: "run:2", |
| 458 | nodeId: "node:root", |
| 459 | failure: { message: "Weekly usage limit reached" }, |
| 460 | }, |
| 461 | ], |
| 462 | }) as never, |
| 463 | ), |
| 464 | waitForThread: (input) => |
| 465 | Deferred.await(ended).pipe( |
| 466 | Effect.as({ |
| 467 | threadId: input.threadId, |
| 468 | run: { ...run, id: input.runId, userMessageId: "" }, |
| 469 | timedOut: false, |
| 470 | } as never), |
| 471 | ), |
| 472 | }), |
| 473 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 474 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 475 | namedProjectsRoot: "/projects", |
| 476 | isScratchProject: () => Effect.succeed(false), |
| 477 | }), |
| 478 | NodeCrypto.layer, |
| 479 | Scheduler.layer, |
| 480 | ), |
| 481 | ), |
| 482 | ); |
| 483 | yield* Effect.gen(function* () { |
| 484 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 485 | const { task } = yield* service.upsert({ |
| 486 | id: ScheduledTaskId.make("task:quota"), |
| 487 | title: "Quota bookkeeping", |
| 488 | prompt: "Update the notes", |
| 489 | enabled: true, |
| 490 | schedule: { type: "interval", everyMs: 60_000 }, |
| 491 | projectId, |
| 492 | threadId: ThreadId.make("thread:quota"), |
| 493 | workspaceStrategy: { type: "root" }, |
| 494 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 495 | runtimeMode: "full-access", |
| 496 | interactionMode: "default", |
| 497 | }); |
| 498 | yield* service.runNow({ id: task.id }); |
| 499 | if (outcome.heldWarning) { |
| 500 | const sql = yield* SqlClient.SqlClient; |
| 501 | yield* sql`UPDATE scheduled_tasks SET last_run_status = 'failed', |
| 502 | last_run_error = 'A previous occurrence is held in the thread queue. Resume or remove it to run this task again.' |
| 503 | WHERE task_id = ${task.id}`; |
| 504 | } |
| 505 | const failed = yield* service.subscribeList().pipe( |
| 506 | Stream.map(({ tasks }) => tasks.find((candidate) => candidate.id === task.id)), |
| 507 | Stream.filter((current) => current?.lastRunError === outcome.error), |
| 508 | Stream.runHead, |
| 509 | Effect.forkChild, |
| 510 | ); |
| 511 | yield* Deferred.succeed(ended, undefined); |
| 512 | const recorded = Option.getOrUndefined(yield* Fiber.join(failed)); |
| 513 | assert.equal(recorded?.lastRunError, outcome.error); |
| 514 | assert.equal(recorded?.runCount, 1); |
| 515 | }).pipe(Effect.provide(layer)); |
| 516 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 517 | ); |
| 518 | |
| 519 | it.effect("a one-time task is removed once its turn completes", () => |
| 520 | Effect.gen(function* () { |
| 521 | yield* TestClock.setTime(Date.parse("2026-11-01T07:00:00.000Z")); |
| 522 | const projectId = ProjectId.make("project:test"); |
| 523 | const ended = yield* Deferred.make<void>(); |
| 524 | const sent = yield* Ref.make(""); |
| 525 | const run = { id: "run:1", status: "completed", rootNodeId: "node:root" }; |
| 526 | const layer = ScheduledTaskService.layer.pipe( |
| 527 | Layer.provide( |
| 528 | Layer.mergeAll( |
| 529 | ManagedPolicy.layerTest(), |
| 530 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 531 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 532 | sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)), |
| 533 | getThreadShell: () => Effect.succeed(threadShell(projectId)), |
| 534 | getProjectThreadRecords: () => |
| 535 | Effect.map( |
| 536 | Ref.get(sent), |
| 537 | (userMessageId) => ({ runs: [{ ...run, userMessageId }] }) as never, |
| 538 | ), |
| 539 | waitForThread: (input) => |
| 540 | Deferred.await(ended).pipe( |
| 541 | Effect.as({ threadId: input.threadId, run, timedOut: false } as never), |
| 542 | ), |
| 543 | }), |
| 544 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 545 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 546 | namedProjectsRoot: "/projects", |
| 547 | isScratchProject: () => Effect.succeed(false), |
| 548 | }), |
| 549 | NodeCrypto.layer, |
| 550 | Scheduler.layer, |
| 551 | ), |
| 552 | ), |
| 553 | ); |
| 554 | yield* Effect.gen(function* () { |
| 555 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 556 | const { task } = yield* service.upsert({ |
| 557 | id: ScheduledTaskId.make("task:once"), |
| 558 | title: "Release notes", |
| 559 | prompt: "Draft the release notes", |
| 560 | enabled: true, |
| 561 | schedule: { type: "once", runAt: "2026-11-01T07:01:00.000Z" }, |
| 562 | projectId, |
| 563 | threadId: ThreadId.make("thread:once"), |
| 564 | workspaceStrategy: { type: "root" }, |
| 565 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 566 | runtimeMode: "full-access", |
| 567 | interactionMode: "default", |
| 568 | }); |
| 569 | const dispatched = service.subscribeList().pipe( |
| 570 | Stream.map(({ tasks }) => tasks.find((candidate) => candidate.id === task.id)), |
| 571 | Stream.filter((current) => current?.lastRunStatus === "succeeded"), |
| 572 | Stream.runHead, |
| 573 | ); |
| 574 | const removed = service.subscribeList().pipe( |
| 575 | Stream.filter(({ tasks }) => tasks.every((candidate) => candidate.id !== task.id)), |
| 576 | Stream.runHead, |
| 577 | ); |
| 578 | const recorded = yield* Effect.forkChild(dispatched); |
| 579 | const gone = yield* Effect.forkChild(removed); |
| 580 | yield* TestClock.adjust("2 minutes"); |
| 581 | // The dispatch alone keeps it: the turn can still fail. |
| 582 | assert.isNull(Option.getOrThrow(yield* Fiber.join(recorded))?.nextRunAt); |
| 583 | yield* Deferred.succeed(ended, undefined); |
| 584 | yield* Fiber.join(gone); |
| 585 | assert.lengthOf((yield* service.list()).tasks, 0); |
| 586 | }).pipe(Effect.provide(layer)); |
| 587 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 588 | ); |
| 589 | |
| 590 | it.effect("a paused one-time task run by hand before its time is kept", () => |
| 591 | Effect.gen(function* () { |
| 592 | yield* TestClock.setTime(Date.parse("2026-11-01T07:00:00.000Z")); |
| 593 | const projectId = ProjectId.make("project:test"); |
| 594 | const ended = yield* Deferred.make<void>(); |
| 595 | const outcomeRead = yield* Deferred.make<void>(); |
| 596 | const sent = yield* Ref.make(""); |
| 597 | const run = { id: "run:1", status: "completed", rootNodeId: "node:root" }; |
| 598 | const layer = ScheduledTaskService.layer.pipe( |
| 599 | Layer.provide( |
| 600 | Layer.mergeAll( |
| 601 | ManagedPolicy.layerTest(), |
| 602 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 603 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 604 | sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)), |
| 605 | getThreadShell: () => Effect.succeed(threadShell(projectId)), |
| 606 | getProjectThreadRecords: () => |
| 607 | Effect.map( |
| 608 | Ref.get(sent), |
| 609 | (userMessageId) => ({ runs: [{ ...run, userMessageId }] }) as never, |
| 610 | ), |
| 611 | waitForThread: (input) => |
| 612 | Deferred.await(ended).pipe( |
| 613 | Effect.tap(() => Deferred.succeed(outcomeRead, undefined)), |
| 614 | Effect.as({ threadId: input.threadId, run, timedOut: false } as never), |
| 615 | ), |
| 616 | }), |
| 617 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 618 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 619 | namedProjectsRoot: "/projects", |
| 620 | isScratchProject: () => Effect.succeed(false), |
| 621 | }), |
| 622 | NodeCrypto.layer, |
| 623 | Scheduler.layer, |
| 624 | ), |
| 625 | ), |
| 626 | ); |
| 627 | yield* Effect.gen(function* () { |
| 628 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 629 | const { task } = yield* service.upsert({ |
| 630 | id: ScheduledTaskId.make("task:paused-once"), |
| 631 | title: "Release notes", |
| 632 | prompt: "Draft the release notes", |
| 633 | enabled: true, |
| 634 | schedule: { type: "once", runAt: "2026-11-01T08:00:00.000Z" }, |
| 635 | projectId, |
| 636 | threadId: ThreadId.make("thread:once"), |
| 637 | workspaceStrategy: { type: "root" }, |
| 638 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 639 | runtimeMode: "full-access", |
| 640 | interactionMode: "default", |
| 641 | }); |
| 642 | yield* service.setEnabled({ id: task.id, enabled: false }); |
| 643 | yield* service.runNow({ id: task.id }); |
| 644 | yield* Deferred.succeed(ended, undefined); |
| 645 | yield* Deferred.await(outcomeRead); |
| 646 | yield* TestClock.adjust("1 second"); |
| 647 | const [kept] = (yield* service.list()).tasks; |
| 648 | assert.equal(kept?.id, task.id); |
| 649 | assert.equal(kept?.runCount, 1); |
| 650 | const resumed = yield* service.setEnabled({ id: task.id, enabled: true }); |
| 651 | assert.equal(resumed.task.nextRunAt, "2026-11-01T08:00:00.000Z"); |
| 652 | }).pipe(Effect.provide(layer)); |
| 653 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 654 | ); |
| 655 | |
| 656 | it.effect("a bound run follows its thread when promotion moves it mid-send", () => |
| 657 | Effect.gen(function* () { |
| 658 | const scratch = ProjectId.make("project:scratch"); |
| 659 | const promoted = ProjectId.make("project:promoted"); |
| 660 | const sends = yield* Ref.make<Array<{ projectId: ProjectId; commandId: string }>>([]); |
| 661 | // Saving reads it first. Then the rebind lands, and the promotion commits between the shell |
| 662 | // read and the retry. |
| 663 | const shellProjects = yield* Ref.make([promoted, scratch, promoted]); |
| 664 | const layer = ScheduledTaskService.layer.pipe( |
| 665 | Layer.provide( |
| 666 | Layer.mergeAll( |
| 667 | ManagedPolicy.layerTest(), |
| 668 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 669 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 670 | sendToThread: (input) => |
| 671 | Ref.updateAndGet(sends, (all) => [ |
| 672 | ...all, |
| 673 | { projectId: input.projectId, commandId: input.commandId }, |
| 674 | ]).pipe( |
| 675 | Effect.flatMap((all) => |
| 676 | all.length < 3 |
| 677 | ? Effect.fail( |
| 678 | new ThreadManagementService.ThreadManagementThreadNotFoundError({ |
| 679 | projectId: input.projectId, |
| 680 | threadId: input.threadId, |
| 681 | }), |
| 682 | ) |
| 683 | : Effect.succeed({} as never), |
| 684 | ), |
| 685 | ), |
| 686 | getThreadShell: () => |
| 687 | Ref.modify(shellProjects, ([next, ...rest]) => [threadShell(next ?? promoted), rest]), |
| 688 | }), |
| 689 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 690 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 691 | namedProjectsRoot: "/projects", |
| 692 | isScratchProject: () => Effect.succeed(false), |
| 693 | }), |
| 694 | NodeCrypto.layer, |
| 695 | Scheduler.layer, |
| 696 | ), |
| 697 | ), |
| 698 | ); |
| 699 | yield* Effect.gen(function* () { |
| 700 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 701 | const threadId = ThreadId.make("thread:promoted-during-run"); |
| 702 | const { task } = yield* service.upsert({ |
| 703 | id: ScheduledTaskId.make("task:promoted-during-run"), |
| 704 | title: "Check in", |
| 705 | prompt: "Check progress", |
| 706 | enabled: true, |
| 707 | schedule: { type: "interval", everyMs: 60_000 }, |
| 708 | projectId: promoted, |
| 709 | threadId, |
| 710 | workspaceStrategy: { type: "root" }, |
| 711 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 712 | runtimeMode: "full-access", |
| 713 | interactionMode: "default", |
| 714 | }); |
| 715 | |
| 716 | const result = yield* service.runNow({ id: task.id }); |
| 717 | |
| 718 | assert.equal(result.threadId, threadId); |
| 719 | const attempts = yield* Ref.get(sends); |
| 720 | assert.deepEqual( |
| 721 | attempts.map((attempt) => attempt.projectId), |
| 722 | [promoted, scratch, promoted], |
| 723 | ); |
| 724 | assert.equal(new Set(attempts.map((attempt) => attempt.commandId)).size, 1); |
| 725 | }).pipe(Effect.provide(layer)); |
| 726 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 727 | ); |
| 728 | |
| 729 | it.effect("a fresh-session task launches one thread, then starts each later run fresh in it", () => |
| 730 | Effect.gen(function* () { |
| 731 | const launches = yield* Ref.make(0); |
| 732 | const sends = yield* Ref.make<Array<{ threadId: ThreadId; freshContext?: boolean }>>([]); |
| 733 | const launched = ThreadId.make("thread:fresh-session-task"); |
| 734 | const layer = ScheduledTaskService.layer.pipe( |
| 735 | Layer.provide( |
| 736 | Layer.mergeAll( |
| 737 | ManagedPolicy.layerTest(), |
| 738 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 739 | launch: () => |
| 740 | Ref.update(launches, (n) => n + 1).pipe( |
| 741 | Effect.as({ threadId: launched, resumed: false } as never), |
| 742 | ), |
| 743 | }), |
| 744 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 745 | getThreadShell: () => |
| 746 | Effect.succeed({ |
| 747 | deletedAt: null, |
| 748 | archivedAt: null, |
| 749 | projectId: ProjectId.make("project:test"), |
| 750 | } as never), |
| 751 | sendToThread: (input) => |
| 752 | Ref.update(sends, (all) => [ |
| 753 | ...all, |
| 754 | { |
| 755 | threadId: input.threadId, |
| 756 | ...(input.freshContext === undefined ? {} : { freshContext: input.freshContext }), |
| 757 | }, |
| 758 | ]).pipe(Effect.as({} as never)), |
| 759 | }), |
| 760 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 761 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 762 | namedProjectsRoot: "/projects", |
| 763 | isScratchProject: () => Effect.succeed(false), |
| 764 | }), |
| 765 | NodeCrypto.layer, |
| 766 | Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }), |
| 767 | ), |
| 768 | ), |
| 769 | ); |
| 770 | yield* Effect.gen(function* () { |
| 771 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 772 | const input = { |
| 773 | id: ScheduledTaskId.make("task:fresh-session"), |
| 774 | title: "Triage", |
| 775 | prompt: "Triage new issues", |
| 776 | enabled: true, |
| 777 | schedule: { type: "interval", everyMs: 60_000 }, |
| 778 | projectId: ProjectId.make("project:test"), |
| 779 | workspaceStrategy: { type: "root" }, |
| 780 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 781 | runtimeMode: "full-access", |
| 782 | interactionMode: "default", |
| 783 | } as const; |
| 784 | yield* service.upsert({ ...input, threadMode: "fresh_session" }); |
| 785 | |
| 786 | assert.equal((yield* service.runNow({ id: input.id })).threadId, launched); |
| 787 | // A form opened before the first run saves no thread; the binding stays. |
| 788 | const { task } = yield* service.upsert({ |
| 789 | ...input, |
| 790 | threadId: null, |
| 791 | threadMode: "fresh_session", |
| 792 | }); |
| 793 | assert.equal(task.threadId, launched); |
| 794 | assert.equal(task.threadMode, "fresh_session"); |
| 795 | // A client that predates thread modes sends neither; both stay. |
| 796 | const legacy = yield* service.upsert({ ...input, threadId: null }); |
| 797 | assert.equal(legacy.task.threadId, launched); |
| 798 | assert.equal(legacy.task.threadMode, "fresh_session"); |
| 799 | yield* service.runNow({ id: input.id }); |
| 800 | |
| 801 | assert.equal(yield* Ref.get(launches), 1); |
| 802 | assert.deepEqual(yield* Ref.get(sends), [{ threadId: launched, freshContext: true }]); |
| 803 | // Its thread stays in the old project, so moving the task leaves it for a new one. |
| 804 | const moved = yield* service.upsert({ |
| 805 | ...input, |
| 806 | projectId: ProjectId.make("project:moved"), |
| 807 | threadId: launched, |
| 808 | }); |
| 809 | assert.equal(moved.task.threadId, null); |
| 810 | assert.equal(moved.task.threadMode, "fresh_session"); |
| 811 | const unbound = yield* service.upsert({ ...input, threadMode: "new_thread" }); |
| 812 | assert.equal(unbound.task.threadId, null); |
| 813 | // Clearing the thread keeps the mode, so the next run starts a thread for later runs. |
| 814 | yield* service.upsert({ ...input, threadId: launched, threadMode: "continue" }); |
| 815 | const cleared = yield* service.upsert({ |
| 816 | ...input, |
| 817 | threadId: null, |
| 818 | unbindThread: true, |
| 819 | threadMode: "continue", |
| 820 | }); |
| 821 | assert.equal(cleared.task.threadId, null); |
| 822 | assert.equal(cleared.task.threadMode, "continue"); |
| 823 | }).pipe(Effect.provide(layer)); |
| 824 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 825 | ); |
| 826 | |
| 827 | it.effect("a refused dispatch records its refusal, and opaque causes stay generic", () => |
| 828 | Effect.gen(function* () { |
| 829 | const refusal = "Thread thread:refused was stopped."; |
| 830 | const refused = (cause: unknown) => |
| 831 | new OrchestratorDispatchError({ |
| 832 | commandId: CommandId.make("command:refused"), |
| 833 | commandType: "message.dispatch", |
| 834 | cause, |
| 835 | }); |
| 836 | const generic = refused(undefined).message; |
| 837 | const cases = [ |
| 838 | [refusal, refusal], |
| 839 | [" ", generic], |
| 840 | [new Error("private-nested-secret"), generic], |
| 841 | ] as const; |
| 842 | const failure = yield* Ref.make<unknown>(undefined); |
| 843 | const layer = ScheduledTaskService.layer.pipe( |
| 844 | Layer.provide( |
| 845 | Layer.mergeAll( |
| 846 | ManagedPolicy.layerTest(), |
| 847 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 848 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 849 | getThreadShell: () => Effect.succeed(threadShell(ProjectId.make("project:test"))), |
| 850 | sendToThread: () => |
| 851 | Ref.get(failure).pipe(Effect.flatMap((cause) => Effect.fail(refused(cause)))), |
| 852 | }), |
| 853 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 854 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 855 | namedProjectsRoot: "/projects", |
| 856 | isScratchProject: () => Effect.succeed(false), |
| 857 | }), |
| 858 | NodeCrypto.layer, |
| 859 | Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }), |
| 860 | ), |
| 861 | ), |
| 862 | ); |
| 863 | yield* Effect.gen(function* () { |
| 864 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 865 | const { task } = yield* service.upsert({ |
| 866 | id: ScheduledTaskId.make("task:refused"), |
| 867 | title: "Refused dispatch", |
| 868 | prompt: "Check progress", |
| 869 | enabled: true, |
| 870 | schedule: { type: "interval", everyMs: 60_000 }, |
| 871 | projectId: ProjectId.make("project:test"), |
| 872 | threadId: ThreadId.make("thread:refused"), |
| 873 | workspaceStrategy: { type: "root" }, |
| 874 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 875 | runtimeMode: "full-access", |
| 876 | interactionMode: "default", |
| 877 | }); |
| 878 | for (const [cause, expected] of cases) { |
| 879 | yield* Ref.set(failure, cause); |
| 880 | const result = yield* service.runNow({ id: task.id }); |
| 881 | assert.equal(result.task.lastRunStatus, "failed"); |
| 882 | assert.equal(result.task.lastRunError, expected); |
| 883 | } |
| 884 | }).pipe(Effect.provide(layer)); |
| 885 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 886 | ); |
| 887 | |
| 888 | it.effect("a first run whose thread was deleted before it bound removes the task", () => |
| 889 | Effect.gen(function* () { |
| 890 | const layer = ScheduledTaskService.layer.pipe( |
| 891 | Layer.provide( |
| 892 | Layer.mergeAll( |
| 893 | ManagedPolicy.layerTest(), |
| 894 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 895 | launch: () => |
| 896 | Effect.succeed({ |
| 897 | threadId: ThreadId.make("thread:deleted"), |
| 898 | resumed: false, |
| 899 | } as never), |
| 900 | }), |
| 901 | // Deleted before the binding landed, so its cleanup found no task to remove. |
| 902 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 903 | getThreadShell: () => |
| 904 | Effect.succeed({ deletedAt: DateTime.makeUnsafe("2026-11-03T00:00:00Z") } as never), |
| 905 | }), |
| 906 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 907 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 908 | namedProjectsRoot: "/projects", |
| 909 | isScratchProject: () => Effect.succeed(false), |
| 910 | }), |
| 911 | NodeCrypto.layer, |
| 912 | Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }), |
| 913 | ), |
| 914 | ), |
| 915 | ); |
| 916 | yield* Effect.gen(function* () { |
| 917 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 918 | const { task } = yield* service.upsert({ |
| 919 | id: ScheduledTaskId.make("task:thread-deleted-mid-launch"), |
| 920 | title: "Triage", |
| 921 | prompt: "Triage new issues", |
| 922 | enabled: true, |
| 923 | schedule: { type: "interval", everyMs: 60_000 }, |
| 924 | projectId: ProjectId.make("project:test"), |
| 925 | threadMode: "continue", |
| 926 | workspaceStrategy: { type: "root" }, |
| 927 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 928 | runtimeMode: "full-access", |
| 929 | interactionMode: "default", |
| 930 | }); |
| 931 | yield* service.runNow({ id: task.id }); |
| 932 | assert.deepEqual((yield* service.list()).tasks, []); |
| 933 | }).pipe(Effect.provide(layer)); |
| 934 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 935 | ); |
| 936 | |
| 937 | it.effect.each(["recreated under the same id", "moved to another project"] as const)( |
| 938 | "a first run never binds its thread to a task %s", |
| 939 | (change) => |
| 940 | Effect.gen(function* () { |
| 941 | const launching = yield* Deferred.make<void>(); |
| 942 | const proceed = yield* Deferred.make<void>(); |
| 943 | const layer = ScheduledTaskService.layer.pipe( |
| 944 | Layer.provide( |
| 945 | Layer.mergeAll( |
| 946 | ManagedPolicy.layerTest(), |
| 947 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 948 | launch: () => |
| 949 | Deferred.succeed(launching, undefined).pipe( |
| 950 | Effect.andThen(Deferred.await(proceed)), |
| 951 | Effect.as({ |
| 952 | threadId: ThreadId.make("thread:old-generation"), |
| 953 | resumed: false, |
| 954 | } as never), |
| 955 | ), |
| 956 | }), |
| 957 | Layer.mock(ThreadManagementService.ThreadManagementService)({}), |
| 958 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 959 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 960 | namedProjectsRoot: "/projects", |
| 961 | isScratchProject: () => Effect.succeed(false), |
| 962 | }), |
| 963 | NodeCrypto.layer, |
| 964 | Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }), |
| 965 | ), |
| 966 | ), |
| 967 | ); |
| 968 | yield* Effect.gen(function* () { |
| 969 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 970 | const input = { |
| 971 | id: ScheduledTaskId.make("task:recreated-mid-launch"), |
| 972 | title: "Triage", |
| 973 | prompt: "Triage new issues", |
| 974 | enabled: true, |
| 975 | schedule: { type: "interval", everyMs: 60_000 }, |
| 976 | projectId: ProjectId.make("project:test"), |
| 977 | threadMode: "fresh_session", |
| 978 | workspaceStrategy: { type: "root" }, |
| 979 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 980 | runtimeMode: "full-access", |
| 981 | interactionMode: "default", |
| 982 | } as const; |
| 983 | yield* service.upsert(input); |
| 984 | const run = yield* Effect.forkChild(service.runNow({ id: input.id })); |
| 985 | yield* Deferred.await(launching); |
| 986 | if (change === "recreated under the same id") { |
| 987 | yield* service.delete({ id: input.id }); |
| 988 | yield* TestClock.adjust("1 second"); |
| 989 | yield* service.upsert(input); |
| 990 | } else { |
| 991 | yield* service.upsert({ ...input, projectId: ProjectId.make("project:moved") }); |
| 992 | } |
| 993 | yield* Deferred.succeed(proceed, undefined); |
| 994 | yield* Fiber.await(run); |
| 995 | |
| 996 | const replacement = (yield* service.list()).tasks.find((task) => task.id === input.id); |
| 997 | assert.equal(replacement?.threadId, null); |
| 998 | }).pipe(Effect.provide(layer)); |
| 999 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 1000 | ); |
| 1001 | |
| 1002 | it.effect("refuses saving an enabled task above the policy ceiling", () => |
| 1003 | Effect.gen(function* () { |
| 1004 | const layer = ScheduledTaskService.layer.pipe( |
| 1005 | Layer.provide( |
| 1006 | Layer.mergeAll( |
| 1007 | ManagedPolicy.layerTest({ |
| 1008 | schemaVersion: 1, |
| 1009 | organization: "Example Corp", |
| 1010 | limits: { maxRuntimeMode: "auto-accept-edits" }, |
| 1011 | }), |
| 1012 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 1013 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 1014 | getThreadShell: () => Effect.succeed(threadShell(ProjectId.make("project:test"))), |
| 1015 | }), |
| 1016 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 1017 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 1018 | namedProjectsRoot: "/projects", |
| 1019 | isScratchProject: () => Effect.succeed(false), |
| 1020 | }), |
| 1021 | NodeCrypto.layer, |
| 1022 | Scheduler.layer, |
| 1023 | ), |
| 1024 | ), |
| 1025 | ); |
| 1026 | yield* Effect.gen(function* () { |
| 1027 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 1028 | const save = (enabled: boolean) => |
| 1029 | service.upsert({ |
| 1030 | id: ScheduledTaskId.make("task:above-ceiling"), |
| 1031 | title: "Nightly", |
| 1032 | prompt: "Check progress", |
| 1033 | enabled, |
| 1034 | schedule: { type: "interval", everyMs: 60_000 }, |
| 1035 | projectId: ProjectId.make("project:test"), |
| 1036 | workspaceStrategy: { type: "root" }, |
| 1037 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 1038 | runtimeMode: "full-access", |
| 1039 | interactionMode: "default", |
| 1040 | }); |
| 1041 | const refused = yield* save(true).pipe(Effect.flip); |
| 1042 | assert.equal(refused.message, "Example Corp limits threads to Auto-accept edits."); |
| 1043 | assert.lengthOf((yield* service.list()).tasks, 0); |
| 1044 | // A disabled task does not run, so it can still be saved. |
| 1045 | yield* save(false); |
| 1046 | assert.lengthOf((yield* service.list()).tasks, 1); |
| 1047 | // Nor can it be switched back on while its mode is above the ceiling. |
| 1048 | const reenabled = yield* service |
| 1049 | .setEnabled({ id: ScheduledTaskId.make("task:above-ceiling"), enabled: true }) |
| 1050 | .pipe(Effect.flip); |
| 1051 | assert.equal(reenabled.message, "Example Corp limits threads to Auto-accept edits."); |
| 1052 | // A task bound to a thread runs in that thread's mode, so its own is not checked. |
| 1053 | const bound = { |
| 1054 | id: ScheduledTaskId.make("task:bound"), |
| 1055 | title: "Follow up", |
| 1056 | prompt: "Check progress", |
| 1057 | enabled: true, |
| 1058 | schedule: { type: "interval", everyMs: 60_000 }, |
| 1059 | projectId: ProjectId.make("project:test"), |
| 1060 | workspaceStrategy: { type: "root" }, |
| 1061 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 1062 | runtimeMode: "full-access", |
| 1063 | interactionMode: "default", |
| 1064 | } as const; |
| 1065 | yield* service.upsert({ ...bound, threadId: ThreadId.make("thread:bound") }); |
| 1066 | // Nor when an edit omits the thread it stays bound to. |
| 1067 | yield* service.upsert(bound); |
| 1068 | }).pipe(Effect.provide(layer)); |
| 1069 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 1070 | ); |
| 1071 | |
| 1072 | it.effect("checks a task's destination thread only when the destination changes", () => |
| 1073 | Effect.gen(function* () { |
| 1074 | const project = ProjectId.make("project:test"); |
| 1075 | const otherProject = ProjectId.make("project:other"); |
| 1076 | const destination = ThreadId.make("thread:destination"); |
| 1077 | const archivedAt = "2026-11-05T00:00:00.000Z"; |
| 1078 | const shells = yield* Ref.make<ReadonlyMap<ThreadId, never>>( |
| 1079 | new Map([ |
| 1080 | [destination, threadShell(project)], |
| 1081 | [ThreadId.make("thread:archived"), threadShell(project, { archivedAt })], |
| 1082 | [ThreadId.make("thread:deleted"), threadShell(project, { deletedAt: archivedAt })], |
| 1083 | [ThreadId.make("thread:other-project"), threadShell(otherProject)], |
| 1084 | ]), |
| 1085 | ); |
| 1086 | const consumed = yield* Ref.make(0); |
| 1087 | const layer = ScheduledTaskService.layer.pipe( |
| 1088 | Layer.provide( |
| 1089 | Layer.mergeAll( |
| 1090 | ManagedPolicy.layerTest(), |
| 1091 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), |
| 1092 | Layer.mock(ThreadManagementService.ThreadManagementService)({ |
| 1093 | getThreadShell: (threadId) => |
| 1094 | Ref.get(shells).pipe(Effect.map((all) => all.get(threadId) ?? null)), |
| 1095 | }), |
| 1096 | Layer.mock(SecretRequests.SecretRequests)({ |
| 1097 | consume: () => Ref.update(consumed, (count) => count + 1).pipe(Effect.as("secret")), |
| 1098 | }), |
| 1099 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 1100 | namedProjectsRoot: "/projects", |
| 1101 | isScratchProject: () => Effect.succeed(false), |
| 1102 | }), |
| 1103 | NodeCrypto.layer, |
| 1104 | Scheduler.layer, |
| 1105 | ), |
| 1106 | ), |
| 1107 | ); |
| 1108 | yield* Effect.gen(function* () { |
| 1109 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 1110 | const id = ScheduledTaskId.make("task:destination"); |
| 1111 | const save = ( |
| 1112 | threadId: ThreadId, |
| 1113 | schedule: ScheduledTaskUpsertInput["schedule"] = { type: "interval", everyMs: 60_000 }, |
| 1114 | ) => |
| 1115 | service.upsert({ |
| 1116 | id, |
| 1117 | title: "Follow up", |
| 1118 | prompt: "Check progress", |
| 1119 | enabled: true, |
| 1120 | schedule, |
| 1121 | projectId: project, |
| 1122 | threadId, |
| 1123 | workspaceStrategy: { type: "root" }, |
| 1124 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 1125 | runtimeMode: "full-access", |
| 1126 | interactionMode: "default", |
| 1127 | }); |
| 1128 | |
| 1129 | for (const [threadId, message] of [ |
| 1130 | ["thread:missing", "That thread no longer exists."], |
| 1131 | ["thread:deleted", "That thread no longer exists."], |
| 1132 | ["thread:archived", "That thread is archived. Unarchive it or pick another destination."], |
| 1133 | ["thread:other-project", "That thread belongs to a different project."], |
| 1134 | ] as const) { |
| 1135 | const refused = yield* save(ThreadId.make(threadId)).pipe(Effect.flip); |
| 1136 | assert.equal(refused.message, message); |
| 1137 | } |
| 1138 | assert.lengthOf((yield* service.list()).tasks, 0); |
| 1139 | |
| 1140 | // A rejected save must not burn a one-shot secret. |
| 1141 | yield* save(ThreadId.make("thread:missing"), { |
| 1142 | type: "webhook", |
| 1143 | signature: { |
| 1144 | header: "x-signature", |
| 1145 | encoding: "hex", |
| 1146 | prefix: "", |
| 1147 | secretRef: SecretRef.make("secret-ref:00000000000000000000000000000001"), |
| 1148 | }, |
| 1149 | }).pipe(Effect.flip); |
| 1150 | assert.equal(yield* Ref.get(consumed), 0); |
| 1151 | |
| 1152 | yield* save(destination); |
| 1153 | // A task whose thread was archived later stays editable. |
| 1154 | yield* Ref.update(shells, (all) => |
| 1155 | new Map(all).set(destination, threadShell(project, { archivedAt })), |
| 1156 | ); |
| 1157 | assert.equal((yield* save(destination)).task.threadId, destination); |
| 1158 | }).pipe(Effect.provide(layer)); |
| 1159 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 1160 | ); |
| 1161 | |
| 1162 | it.effect("a run interrupted right after it reserves the task does not block the next run", () => |
| 1163 | Effect.gen(function* () { |
| 1164 | const launches = yield* Ref.make(0); |
| 1165 | const layer = ScheduledTaskService.layer.pipe( |
| 1166 | Layer.provide( |
| 1167 | Layer.mergeAll( |
| 1168 | ManagedPolicy.layerTest(), |
| 1169 | Layer.mock(ThreadLaunchService.ThreadLaunchService)({ |
| 1170 | launch: () => |
| 1171 | Ref.update(launches, (n) => n + 1).pipe( |
| 1172 | Effect.as({ threadId: ThreadId.make("thread:launched"), resumed: false } as never), |
| 1173 | ), |
| 1174 | }), |
| 1175 | Layer.mock(ThreadManagementService.ThreadManagementService)({}), |
| 1176 | Layer.mock(SecretRequests.SecretRequests)({}), |
| 1177 | Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ |
| 1178 | namedProjectsRoot: "/projects", |
| 1179 | isScratchProject: () => Effect.succeed(false), |
| 1180 | }), |
| 1181 | NodeCrypto.layer, |
| 1182 | Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }), |
| 1183 | ), |
| 1184 | ), |
| 1185 | ); |
| 1186 | yield* Effect.gen(function* () { |
| 1187 | const service = yield* ScheduledTaskService.ScheduledTaskService; |
| 1188 | const { task } = yield* service.upsert({ |
| 1189 | id: ScheduledTaskId.make("task:interrupted-reservation"), |
| 1190 | title: "Check in", |
| 1191 | prompt: "Check progress", |
| 1192 | enabled: true, |
| 1193 | schedule: { type: "interval", everyMs: 60_000 }, |
| 1194 | projectId: ProjectId.make("project:test"), |
| 1195 | workspaceStrategy: { type: "root" }, |
| 1196 | modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, |
| 1197 | runtimeMode: "full-access", |
| 1198 | interactionMode: "default", |
| 1199 | }); |
| 1200 | |
| 1201 | // The reservation is the first Set.add of the task id; interrupt the run right there. |
| 1202 | const add = Set.prototype.add; |
| 1203 | let interrupted = false; |
| 1204 | const first = yield* Effect.gen(function* () { |
| 1205 | using _reserve = vi.spyOn(Set.prototype, "add").mockImplementation(function ( |
| 1206 | this: Set<unknown>, |
| 1207 | value: unknown, |
| 1208 | ) { |
| 1209 | const result = add.call(this, value); |
| 1210 | if (value === task.id && !interrupted) { |
| 1211 | interrupted = true; |
| 1212 | Fiber.getCurrent()?.interruptUnsafe(); |
| 1213 | } |
| 1214 | return result; |
| 1215 | }); |
| 1216 | return yield* service |
| 1217 | .runNow({ id: task.id }) |
| 1218 | .pipe(Effect.forkChild, Effect.flatMap(Fiber.await)); |
| 1219 | }); |
| 1220 | assert.isTrue(interrupted); |
| 1221 | assert.isTrue(Exit.hasInterrupts(first)); |
| 1222 | |
| 1223 | const second = yield* service.runNow({ id: task.id }); |
| 1224 | assert.equal(second.threadId, ThreadId.make("thread:launched")); |
| 1225 | assert.equal(yield* Ref.get(launches), 1); |
| 1226 | }).pipe(Effect.provide(layer)); |
| 1227 | }).pipe(Effect.provide(SqlitePersistence.layerMemory)), |
| 1228 | ); |