@h-ai/scheduler 1.0.0-beta.3 → 1.0.0-beta.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1,11 +1,10 @@
1
1
  import { z } from 'zod';
2
- import { core, ok, err, HaiCommonError } from '@h-ai/core';
3
- import { migrateSchema, reldb, schemaColumns, BaseReldbCrudRepository } from '@h-ai/reldb';
2
+ import { core, ok, err } from '@h-ai/core';
3
+ import { reldb, BaseReldbCrudRepository } from '@h-ai/reldb';
4
4
  import { randomUUID, createHash } from 'crypto';
5
5
  import { isDeepStrictEqual } from 'util';
6
6
  import { Cron } from 'croner';
7
7
  import { Script } from 'vm';
8
- import { Worker } from 'worker_threads';
9
8
 
10
9
  // src/scheduler-config.ts
11
10
  var SchedulerConfigSchema = z.object({
@@ -176,7 +175,15 @@ function executionId(taskId, type, key) {
176
175
  return createHash("sha256").update(JSON.stringify([taskId, type, key])).digest("hex");
177
176
  }
178
177
  function executionEntry(row) {
179
- return { occurrenceId: row.occurrenceId, taskId: row.taskId, status: row.status, sequence: row.sequence, attemptCount: row.attemptCount, updatedAt: row.updatedAt, logPersistence: row.logPersistence };
178
+ return {
179
+ occurrenceId: row.occurrenceId,
180
+ taskId: row.taskId,
181
+ status: row.status,
182
+ sequence: row.sequence,
183
+ attemptCount: row.attemptCount,
184
+ updatedAt: row.updatedAt,
185
+ logPersistence: row.logPersistence
186
+ };
180
187
  }
181
188
  function failed(cause) {
182
189
  return err(HaiSchedulerError.DB_SAVE_FAILED, schedulerM("scheduler_executionStateFailed"), cause);
@@ -188,22 +195,58 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
188
195
  idColumn: "sequence",
189
196
  idField: "sequence",
190
197
  fields: [
191
- { fieldName: "sequence", columnName: "sequence", def: { type: "INTEGER", primaryKey: true, autoIncrement: true }, select: true, create: false, update: false },
198
+ {
199
+ fieldName: "sequence",
200
+ columnName: "sequence",
201
+ def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
202
+ select: true,
203
+ create: false,
204
+ update: false
205
+ },
192
206
  ...[
193
- ["occurrenceId", "occurrence_id", true, true],
207
+ [
208
+ "occurrenceId",
209
+ "occurrence_id",
210
+ true,
211
+ true
212
+ ],
194
213
  ["taskId", "task_id", true, false],
195
- ["activeTask", "active_task", false, true],
214
+ [
215
+ "activeTask",
216
+ "active_task",
217
+ false,
218
+ true
219
+ ],
196
220
  ["status", "status", true, false],
197
221
  ["owner", "owner", false, false],
198
222
  ["snapshot", "snapshot", true, false],
199
- ["triggerJson", "trigger_json", true, false],
223
+ [
224
+ "triggerJson",
225
+ "trigger_json",
226
+ true,
227
+ false
228
+ ],
200
229
  ["logJson", "log_json", false, false],
201
230
  ["logsJson", "logs_json", false, false],
202
- ["logPersistence", "log_persistence", true, false]
231
+ [
232
+ "logPersistence",
233
+ "log_persistence",
234
+ true,
235
+ false
236
+ ]
203
237
  ].map(([fieldName, columnName, notNull, unique]) => ({
204
238
  fieldName: String(fieldName),
205
239
  columnName: String(columnName),
206
- def: { type: ["snapshot", "triggerJson", "logJson", "logsJson"].includes(String(fieldName)) ? "JSON" : "TEXT", notNull: Boolean(notNull), unique: Boolean(unique) },
240
+ def: {
241
+ type: [
242
+ "snapshot",
243
+ "triggerJson",
244
+ "logJson",
245
+ "logsJson"
246
+ ].includes(String(fieldName)) ? "JSON" : "TEXT",
247
+ notNull: Boolean(notNull),
248
+ unique: Boolean(unique)
249
+ },
207
250
  select: true,
208
251
  create: true,
209
252
  update: true
@@ -222,10 +265,21 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
222
265
  create: true,
223
266
  update: true
224
267
  })),
225
- { fieldName: "idempotent", columnName: "idempotent", def: { type: "BOOLEAN", notNull: true }, select: true, create: true, update: true }
268
+ {
269
+ fieldName: "idempotent",
270
+ columnName: "idempotent",
271
+ def: { type: "BOOLEAN", notNull: true },
272
+ select: true,
273
+ create: true,
274
+ update: true
275
+ }
226
276
  ]
227
277
  });
228
278
  }
279
+ /** 等待执行表就绪并验证当前字段定义。 */
280
+ ready() {
281
+ return this.ensureSchema();
282
+ }
229
283
  /**
230
284
  * 只按已初始化的数据库类型选择存储端毫秒时钟。
231
285
  * PostgreSQL/MySQL 使用执行时钟,不能使用固定在事务/语句开始处的时间快照。
@@ -260,11 +314,23 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
260
314
  /** 读取统一校验 BIGINT,不能把 PG 字符串时间或舍入的序号用于 owner 判断。 */
261
315
  normalize(row) {
262
316
  const value = { ...row };
263
- for (const field of ["snapshot", "triggerJson", "logJson", "logsJson"]) {
317
+ for (const field of [
318
+ "snapshot",
319
+ "triggerJson",
320
+ "logJson",
321
+ "logsJson"
322
+ ]) {
264
323
  if (row[field] !== void 0 && row[field] !== null && typeof row[field] !== "string")
265
324
  value[field] = JSON.stringify(row[field]);
266
325
  }
267
- for (const field of ["sequence", "leasedUntil", "attemptCount", "maxAttempts", "updatedAt", "createdAt"]) {
326
+ for (const field of [
327
+ "sequence",
328
+ "leasedUntil",
329
+ "attemptCount",
330
+ "maxAttempts",
331
+ "updatedAt",
332
+ "createdAt"
333
+ ]) {
268
334
  const number = Number(row[field]);
269
335
  if (!Number.isSafeInteger(number) || number < 0)
270
336
  return failed();
@@ -274,7 +340,11 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
274
340
  }
275
341
  /** 按稳定回执读取。@example await repository.byOccurrence(id) */
276
342
  async byOccurrence(id) {
277
- const rows = await this.findAll({ where: "occurrence_id = ?", params: [id], limit: 1 });
343
+ const rows = await this.findAll({
344
+ where: "occurrence_id = ?",
345
+ params: [id],
346
+ limit: 1
347
+ });
278
348
  if (!rows.success)
279
349
  return failed(rows.error);
280
350
  return rows.data[0] ? this.normalize(rows.data[0]) : ok(null);
@@ -288,7 +358,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
288
358
  const result = await this.db.sql.execute(
289
359
  `UPDATE ${TABLE} SET status = ?, owner = NULL, leased_until = 0, updated_at = ${this.nextUpdatedAt()}
290
360
  WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${this.databaseClock()} AND status IN (?, ?)`,
291
- ["unknown", row.occurrenceId, row.owner, "claimed", "running"]
361
+ [
362
+ "unknown",
363
+ row.occurrenceId,
364
+ row.owner,
365
+ "claimed",
366
+ "running"
367
+ ]
292
368
  );
293
369
  return result.success && result.data.changes === 1 ? ok(void 0) : failed();
294
370
  }
@@ -311,7 +387,18 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
311
387
  const result = await this.db.sql.execute(
312
388
  `UPDATE ${TABLE} SET log_persistence = ?, log_json = ?, updated_at = ${this.nextUpdatedAt()}
313
389
  WHERE occurrence_id = ? AND updated_at = ? AND log_persistence = ? AND status NOT IN (?, ?)`,
314
- ["persisted", JSON.stringify({ ...log, persistence: { status: "persisted" } }), row.occurrenceId, row.updatedAt, "pending", "claimed", "running"]
390
+ [
391
+ "persisted",
392
+ JSON.stringify({
393
+ ...log,
394
+ persistence: { status: "persisted" }
395
+ }),
396
+ row.occurrenceId,
397
+ row.updatedAt,
398
+ "pending",
399
+ "claimed",
400
+ "running"
401
+ ]
315
402
  );
316
403
  if (result.success && result.data.changes === 1)
317
404
  return ok(void 0);
@@ -319,7 +406,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
319
406
  return current.success && current.data?.logPersistence === "persisted" && current.data.logsJson === row.logsJson ? ok(void 0) : failed();
320
407
  }
321
408
  async rows(where, params, limit, offset) {
322
- const result = await this.findAll({ where, params, limit, offset, orderBy: "sequence ASC" });
409
+ const result = await this.findAll({
410
+ where,
411
+ params,
412
+ limit,
413
+ offset,
414
+ orderBy: "sequence ASC"
415
+ });
323
416
  if (!result.success)
324
417
  return failed(result.error);
325
418
  const rows = [];
@@ -341,26 +434,52 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
341
434
  return failed(ready.error);
342
435
  const clock = this.databaseClock();
343
436
  const owner = `${nodeId}:${randomUUID()}`;
437
+ const postgres = this.db.config?.type === "postgresql";
438
+ const conflictClause = postgres ? " ON CONFLICT DO NOTHING" : "";
344
439
  let created;
345
440
  try {
346
441
  created = await this.db.sql.execute(
347
442
  `INSERT INTO ${TABLE} (occurrence_id, task_id, active_task, status, owner, leased_until, attempt_count, max_attempts, idempotent, snapshot, trigger_json, log_persistence, updated_at, created_at)
348
- VALUES (?, ?, ?, ?, ?, ${clock} + ?, 0, ?, ?, ?, ?, ?, ${clock}, ${clock})`,
349
- [id, task.id, task.id, "claimed", owner, leaseMs, task.retry?.maxAttempts ?? 1, this.db.config?.type === "postgresql" ? task.idempotent === true : Number(task.idempotent === true), JSON.stringify(task), JSON.stringify(trigger), "unconfirmed"]
443
+ VALUES (?, ?, ?, ?, ?, ${clock} + ?, 0, ?, ?, ?, ?, ?, ${clock}, ${clock})${conflictClause}`,
444
+ [
445
+ id,
446
+ task.id,
447
+ task.id,
448
+ "claimed",
449
+ owner,
450
+ leaseMs,
451
+ task.retry?.maxAttempts ?? 1,
452
+ postgres ? task.idempotent === true : Number(task.idempotent === true),
453
+ JSON.stringify(task),
454
+ JSON.stringify(trigger),
455
+ "unconfirmed"
456
+ ]
350
457
  );
351
458
  } catch (cause) {
352
459
  return failed(cause);
353
460
  }
461
+ if (postgres && !created.success)
462
+ return failed(created.error);
354
463
  const existing = await this.byOccurrence(id);
355
464
  if (!existing.success)
356
465
  return existing;
357
466
  if (!existing.data) {
358
- const active = await this.findAll({ where: "active_task = ?", params: [task.id], limit: 1 });
467
+ const active = await this.findAll({
468
+ where: "active_task = ?",
469
+ params: [task.id],
470
+ limit: 1
471
+ });
359
472
  return active.success && active.data.length > 0 ? ok(null) : failed(created.success ? void 0 : created.error);
360
473
  }
361
474
  const row = existing.data;
362
- if (created.success || ["success", "failed", "interrupted", "discarded"].includes(row.status))
475
+ if (created.success && created.data.changes === 1 || [
476
+ "success",
477
+ "failed",
478
+ "interrupted",
479
+ "discarded"
480
+ ].includes(row.status)) {
363
481
  return ok(row);
482
+ }
364
483
  if (row.status === "unknown")
365
484
  return ok(null);
366
485
  if (row.status === "running" && (!row.idempotent || row.attemptCount >= row.maxAttempts)) {
@@ -374,7 +493,15 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
374
493
  const recovered = await this.db.sql.execute(
375
494
  `UPDATE ${TABLE} SET status = ?, owner = ?, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
376
495
  WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${clock} AND status IN (?, ?)`,
377
- ["claimed", owner, leaseMs, id, row.owner, "claimed", "running"]
496
+ [
497
+ "claimed",
498
+ owner,
499
+ leaseMs,
500
+ id,
501
+ row.owner,
502
+ "claimed",
503
+ "running"
504
+ ]
378
505
  );
379
506
  if (!recovered.success)
380
507
  return failed(recovered.error);
@@ -386,7 +513,14 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
386
513
  const result = await this.db.sql.execute(
387
514
  `UPDATE ${TABLE} SET status = ?, attempt_count = attempt_count + 1, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
388
515
  WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?) AND attempt_count < max_attempts`,
389
- ["running", leaseMs, row.occurrenceId, row.owner, "claimed", "running"]
516
+ [
517
+ "running",
518
+ leaseMs,
519
+ row.occurrenceId,
520
+ row.owner,
521
+ "claimed",
522
+ "running"
523
+ ]
390
524
  );
391
525
  if (!result.success || result.data.changes !== 1)
392
526
  return failed(result.success ? void 0 : result.error);
@@ -399,7 +533,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
399
533
  const clock = this.databaseClock();
400
534
  const result = await this.db.sql.execute(
401
535
  `UPDATE ${TABLE} SET leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
402
- [leaseMs, row.occurrenceId, row.owner, "claimed", "running"]
536
+ [
537
+ leaseMs,
538
+ row.occurrenceId,
539
+ row.owner,
540
+ "claimed",
541
+ "running"
542
+ ]
403
543
  );
404
544
  return result.success && result.data.changes === 1 ? ok(void 0) : failed();
405
545
  }
@@ -409,7 +549,17 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
409
549
  const result = await this.db.sql.execute(
410
550
  `UPDATE ${TABLE} SET status = ?, active_task = ?, owner = NULL, leased_until = 0, log_json = ?, logs_json = ?, log_persistence = ?, updated_at = ${this.nextUpdatedAt()}
411
551
  WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
412
- [log.status, log.status === "unknown" ? row.taskId : null, JSON.stringify(log), JSON.stringify(logs), "pending", row.occurrenceId, row.owner, "claimed", "running"]
552
+ [
553
+ log.status,
554
+ log.status === "unknown" ? row.taskId : null,
555
+ JSON.stringify(log),
556
+ JSON.stringify(logs),
557
+ "pending",
558
+ row.occurrenceId,
559
+ row.owner,
560
+ "claimed",
561
+ "running"
562
+ ]
413
563
  );
414
564
  return result.success && result.data.changes === 1 ? ok(void 0) : failed();
415
565
  }
@@ -417,7 +567,12 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
417
567
  async resolve(id, status, expectedUpdatedAt) {
418
568
  const result = await this.db.sql.execute(
419
569
  `UPDATE ${TABLE} SET status = ?, active_task = NULL, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND status = ? AND updated_at = ?`,
420
- [status, id, "unknown", expectedUpdatedAt]
570
+ [
571
+ status,
572
+ id,
573
+ "unknown",
574
+ expectedUpdatedAt
575
+ ]
421
576
  );
422
577
  return result.success && result.data.changes === 1 ? ok(void 0) : failed();
423
578
  }
@@ -425,23 +580,110 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
425
580
  var logger = core.logger.child({ module: "scheduler", scope: "log-repository" });
426
581
  var SCHEDULER_LOG_TABLE = "hai_scheduler_logs";
427
582
  var SchedulerLogRepository = class extends BaseReldbCrudRepository {
583
+ ready() {
584
+ return this.ensureSchema();
585
+ }
428
586
  constructor(db) {
429
587
  super(db, {
430
588
  table: SCHEDULER_LOG_TABLE,
431
589
  idColumn: "id",
432
590
  fields: [
433
- { fieldName: "id", columnName: "id", def: { type: "TEXT", primaryKey: true }, select: true, create: true, update: false },
434
- { fieldName: "occurrenceId", columnName: "occurrence_id", def: { type: "TEXT" }, select: true, create: true, update: false },
435
- { fieldName: "taskId", columnName: "task_id", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
436
- { fieldName: "taskName", columnName: "task_name", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
437
- { fieldName: "taskType", columnName: "task_type", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
438
- { fieldName: "triggerType", columnName: "trigger_type", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
439
- { fieldName: "triggerSource", columnName: "trigger_source", def: { type: "TEXT" }, select: true, create: true, update: false },
440
- { fieldName: "status", columnName: "status", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
441
- { fieldName: "payload", columnName: "payload", def: { type: "JSON", notNull: true }, select: true, create: true, update: false },
442
- { fieldName: "startedAt", columnName: "started_at", def: { type: "BIGINT", notNull: true }, select: true, create: true, update: false },
443
- { fieldName: "finishedAt", columnName: "finished_at", def: { type: "BIGINT", notNull: true }, select: true, create: true, update: false },
444
- { fieldName: "duration", columnName: "duration", def: { type: "INTEGER", notNull: true }, select: true, create: true, update: false }
591
+ {
592
+ fieldName: "id",
593
+ columnName: "id",
594
+ def: { type: "TEXT", primaryKey: true },
595
+ select: true,
596
+ create: true,
597
+ update: false
598
+ },
599
+ {
600
+ fieldName: "occurrenceId",
601
+ columnName: "occurrence_id",
602
+ def: { type: "TEXT" },
603
+ select: true,
604
+ create: true,
605
+ update: false
606
+ },
607
+ {
608
+ fieldName: "taskId",
609
+ columnName: "task_id",
610
+ def: { type: "TEXT", notNull: true },
611
+ select: true,
612
+ create: true,
613
+ update: false
614
+ },
615
+ {
616
+ fieldName: "taskName",
617
+ columnName: "task_name",
618
+ def: { type: "TEXT", notNull: true },
619
+ select: true,
620
+ create: true,
621
+ update: false
622
+ },
623
+ {
624
+ fieldName: "taskType",
625
+ columnName: "task_type",
626
+ def: { type: "TEXT", notNull: true },
627
+ select: true,
628
+ create: true,
629
+ update: false
630
+ },
631
+ {
632
+ fieldName: "triggerType",
633
+ columnName: "trigger_type",
634
+ def: { type: "TEXT", notNull: true },
635
+ select: true,
636
+ create: true,
637
+ update: false
638
+ },
639
+ {
640
+ fieldName: "triggerSource",
641
+ columnName: "trigger_source",
642
+ def: { type: "TEXT" },
643
+ select: true,
644
+ create: true,
645
+ update: false
646
+ },
647
+ {
648
+ fieldName: "status",
649
+ columnName: "status",
650
+ def: { type: "TEXT", notNull: true },
651
+ select: true,
652
+ create: true,
653
+ update: false
654
+ },
655
+ {
656
+ fieldName: "payload",
657
+ columnName: "payload",
658
+ def: { type: "JSON", notNull: true },
659
+ select: true,
660
+ create: true,
661
+ update: false
662
+ },
663
+ {
664
+ fieldName: "startedAt",
665
+ columnName: "started_at",
666
+ def: { type: "BIGINT", notNull: true },
667
+ select: true,
668
+ create: true,
669
+ update: false
670
+ },
671
+ {
672
+ fieldName: "finishedAt",
673
+ columnName: "finished_at",
674
+ def: { type: "BIGINT", notNull: true },
675
+ select: true,
676
+ create: true,
677
+ update: false
678
+ },
679
+ {
680
+ fieldName: "duration",
681
+ columnName: "duration",
682
+ def: { type: "INTEGER", notNull: true },
683
+ select: true,
684
+ create: true,
685
+ update: false
686
+ }
445
687
  ]
446
688
  });
447
689
  }
@@ -450,7 +692,10 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
450
692
  * @example `const saved = await repository.saveLog(log); if (!saved.success) return saved`
451
693
  */
452
694
  async saveLog(log) {
453
- const payload = { ...log, persistence: { status: "persisted" } };
695
+ const payload = {
696
+ ...log,
697
+ persistence: { status: "persisted" }
698
+ };
454
699
  try {
455
700
  const created = await this.create({
456
701
  id: log.id,
@@ -517,20 +762,27 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
517
762
  if (!pageResult.success) {
518
763
  return err(
519
764
  HaiSchedulerError.DB_SAVE_FAILED,
520
- schedulerM("scheduler_dbSaveFailed", { params: { error: pageResult.error.message } }),
765
+ schedulerM("scheduler_dbSaveFailed", {
766
+ params: { error: pageResult.error.message }
767
+ }),
521
768
  pageResult.error
522
769
  );
523
770
  }
524
771
  return ok({
525
772
  ...pageResult.data,
526
- items: pageResult.data.items.map((row) => ({ ...row.payload, persistence: { status: "persisted" } }))
773
+ items: pageResult.data.items.map((row) => ({
774
+ ...row.payload,
775
+ persistence: { status: "persisted" }
776
+ }))
527
777
  });
528
778
  } catch (error) {
529
779
  logger.error("Failed to query execution logs", { error });
530
780
  return err(
531
781
  HaiSchedulerError.DB_SAVE_FAILED,
532
782
  schedulerM("scheduler_dbSaveFailed", {
533
- params: { error: error instanceof Error ? error.message : String(error) }
783
+ params: {
784
+ error: error instanceof Error ? error.message : String(error)
785
+ }
534
786
  }),
535
787
  error
536
788
  );
@@ -550,7 +802,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
550
802
  if (!retentionResult.success) {
551
803
  return err(
552
804
  HaiSchedulerError.DB_SAVE_FAILED,
553
- schedulerM("scheduler_dbSaveFailed", { params: { error: retentionResult.error.message } }),
805
+ schedulerM("scheduler_dbSaveFailed", {
806
+ params: { error: retentionResult.error.message }
807
+ }),
554
808
  retentionResult.error
555
809
  );
556
810
  }
@@ -571,7 +825,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
571
825
  if (!maxLogsResult.success) {
572
826
  return err(
573
827
  HaiSchedulerError.DB_SAVE_FAILED,
574
- schedulerM("scheduler_dbSaveFailed", { params: { error: maxLogsResult.error.message } }),
828
+ schedulerM("scheduler_dbSaveFailed", {
829
+ params: { error: maxLogsResult.error.message }
830
+ }),
575
831
  maxLogsResult.error
576
832
  );
577
833
  }
@@ -582,7 +838,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
582
838
  return err(
583
839
  HaiSchedulerError.DB_SAVE_FAILED,
584
840
  schedulerM("scheduler_dbSaveFailed", {
585
- params: { error: error instanceof Error ? error.message : String(error) }
841
+ params: {
842
+ error: error instanceof Error ? error.message : String(error)
843
+ }
586
844
  }),
587
845
  error
588
846
  );
@@ -599,7 +857,13 @@ var TaskRetryPolicySchema = z.object({
599
857
  var ApiTaskConfigSchema = z.object({
600
858
  kind: z.literal("api"),
601
859
  url: z.string().min(1),
602
- method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional(),
860
+ method: z.enum([
861
+ "GET",
862
+ "POST",
863
+ "PUT",
864
+ "DELETE",
865
+ "PATCH"
866
+ ]).optional(),
603
867
  headers: z.record(z.string(), z.string()).optional(),
604
868
  body: z.unknown().optional(),
605
869
  timeout: z.number().int().positive().optional(),
@@ -612,25 +876,126 @@ var JsTaskConfigSchema = z.object({
612
876
  });
613
877
  var TaskHandlerConfigSchema = z.discriminatedUnion("kind", [ApiTaskConfigSchema, JsTaskConfigSchema]);
614
878
  var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
879
+ ready() {
880
+ return this.ensureSchema();
881
+ }
615
882
  constructor(db) {
616
883
  super(db, {
617
884
  table: SCHEDULER_TASK_TABLE,
618
885
  idColumn: "id",
619
886
  fields: [
620
- { fieldName: "id", columnName: "id", def: { type: "INTEGER", primaryKey: true, autoIncrement: true }, select: true, create: false, update: false },
621
- { fieldName: "taskId", columnName: "task_id", def: { type: "TEXT", notNull: true, unique: true }, select: true, create: true, update: false },
622
- { fieldName: "taskName", columnName: "task_name", def: { type: "TEXT", notNull: true }, select: true, create: true, update: true },
623
- { fieldName: "description", columnName: "description", def: { type: "TEXT" }, select: true, create: true, update: true },
624
- { fieldName: "cron", columnName: "cron", def: { type: "TEXT", notNull: true }, select: true, create: true, update: true },
625
- { fieldName: "timezone", columnName: "timezone", def: { type: "TEXT" }, select: true, create: true, update: true },
626
- { fieldName: "enabled", columnName: "enabled", def: { type: "BOOLEAN", notNull: true, defaultValue: true }, select: true, create: true, update: true },
627
- { fieldName: "idempotent", columnName: "idempotent", def: { type: "BOOLEAN", notNull: true, defaultValue: false }, select: true, create: true, update: true },
628
- { fieldName: "deleteAfterRun", columnName: "delete_after_run", def: { type: "BOOLEAN", notNull: true, defaultValue: false }, select: true, create: true, update: true },
629
- { fieldName: "retry", columnName: "retry", def: { type: "JSON" }, select: true, create: true, update: true },
630
- { fieldName: "params", columnName: "params", def: { type: "JSON" }, select: true, create: true, update: true },
631
- { fieldName: "handler", columnName: "handler", def: { type: "JSON" }, select: true, create: true, update: true },
632
- { fieldName: "createdAt", columnName: "created_at", def: { type: "TIMESTAMP" }, select: true, create: true, update: false },
633
- { fieldName: "updatedAt", columnName: "updated_at", def: { type: "TIMESTAMP" }, select: true, create: false, update: true }
887
+ {
888
+ fieldName: "id",
889
+ columnName: "id",
890
+ def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
891
+ select: true,
892
+ create: false,
893
+ update: false
894
+ },
895
+ {
896
+ fieldName: "taskId",
897
+ columnName: "task_id",
898
+ def: { type: "TEXT", notNull: true, unique: true },
899
+ select: true,
900
+ create: true,
901
+ update: false
902
+ },
903
+ {
904
+ fieldName: "taskName",
905
+ columnName: "task_name",
906
+ def: { type: "TEXT", notNull: true },
907
+ select: true,
908
+ create: true,
909
+ update: true
910
+ },
911
+ {
912
+ fieldName: "description",
913
+ columnName: "description",
914
+ def: { type: "TEXT" },
915
+ select: true,
916
+ create: true,
917
+ update: true
918
+ },
919
+ {
920
+ fieldName: "cron",
921
+ columnName: "cron",
922
+ def: { type: "TEXT", notNull: true },
923
+ select: true,
924
+ create: true,
925
+ update: true
926
+ },
927
+ {
928
+ fieldName: "timezone",
929
+ columnName: "timezone",
930
+ def: { type: "TEXT" },
931
+ select: true,
932
+ create: true,
933
+ update: true
934
+ },
935
+ {
936
+ fieldName: "enabled",
937
+ columnName: "enabled",
938
+ def: { type: "BOOLEAN", notNull: true, defaultValue: true },
939
+ select: true,
940
+ create: true,
941
+ update: true
942
+ },
943
+ {
944
+ fieldName: "idempotent",
945
+ columnName: "idempotent",
946
+ def: { type: "BOOLEAN", notNull: true, defaultValue: false },
947
+ select: true,
948
+ create: true,
949
+ update: true
950
+ },
951
+ {
952
+ fieldName: "deleteAfterRun",
953
+ columnName: "delete_after_run",
954
+ def: { type: "BOOLEAN", notNull: true, defaultValue: false },
955
+ select: true,
956
+ create: true,
957
+ update: true
958
+ },
959
+ {
960
+ fieldName: "retry",
961
+ columnName: "retry",
962
+ def: { type: "JSON" },
963
+ select: true,
964
+ create: true,
965
+ update: true
966
+ },
967
+ {
968
+ fieldName: "params",
969
+ columnName: "params",
970
+ def: { type: "JSON" },
971
+ select: true,
972
+ create: true,
973
+ update: true
974
+ },
975
+ {
976
+ fieldName: "handler",
977
+ columnName: "handler",
978
+ def: { type: "JSON" },
979
+ select: true,
980
+ create: true,
981
+ update: true
982
+ },
983
+ {
984
+ fieldName: "createdAt",
985
+ columnName: "created_at",
986
+ def: { type: "TIMESTAMP" },
987
+ select: true,
988
+ create: true,
989
+ update: false
990
+ },
991
+ {
992
+ fieldName: "updatedAt",
993
+ columnName: "updated_at",
994
+ def: { type: "TIMESTAMP" },
995
+ select: true,
996
+ create: false,
997
+ update: true
998
+ }
634
999
  ]
635
1000
  });
636
1001
  }
@@ -651,10 +1016,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
651
1016
  createdAt: /* @__PURE__ */ new Date()
652
1017
  });
653
1018
  if (!createResult.success) {
654
- logger2.error("Failed to save task definition", { taskId: task.id, error: createResult.error.message });
1019
+ logger2.error("Failed to save task definition", { taskId: task.id, errorCode: createResult.error.code, traceId: createResult.error.traceId });
655
1020
  return err(
656
1021
  HaiSchedulerError.DB_SAVE_FAILED,
657
- schedulerM("scheduler_dbSaveFailed", { params: { error: createResult.error.message } }),
1022
+ schedulerM("scheduler_dbSaveFailed", {
1023
+ params: { error: createResult.error.message }
1024
+ }),
658
1025
  createResult.error
659
1026
  );
660
1027
  }
@@ -664,7 +1031,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
664
1031
  return err(
665
1032
  HaiSchedulerError.DB_SAVE_FAILED,
666
1033
  schedulerM("scheduler_dbSaveFailed", {
667
- params: { error: error instanceof Error ? error.message : String(error) }
1034
+ params: {
1035
+ error: error instanceof Error ? error.message : String(error)
1036
+ }
668
1037
  }),
669
1038
  error
670
1039
  );
@@ -672,11 +1041,18 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
672
1041
  }
673
1042
  async updateTask(taskId, updates) {
674
1043
  try {
675
- const rows = await this.findAll({ where: "task_id = ?", params: [taskId], limit: 1 });
1044
+ const rows = await this.findAll({
1045
+ where: "task_id = ?",
1046
+ params: [taskId],
1047
+ limit: 1
1048
+ });
676
1049
  if (!rows.success) {
1050
+ logger2.error("Failed to load task definition for update", { taskId, errorCode: rows.error.code, traceId: rows.error.traceId });
677
1051
  return err(
678
1052
  HaiSchedulerError.DB_SAVE_FAILED,
679
- schedulerM("scheduler_dbSaveFailed", { params: { error: rows.error.message } }),
1053
+ schedulerM("scheduler_dbSaveFailed", {
1054
+ params: { error: rows.error.message }
1055
+ }),
680
1056
  rows.error
681
1057
  );
682
1058
  }
@@ -708,10 +1084,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
708
1084
  return ok(void 0);
709
1085
  const updateResult = await this.updateById(rows.data[0].id, data);
710
1086
  if (!updateResult.success) {
711
- logger2.error("Failed to update task definition", { taskId, error: updateResult.error.message });
1087
+ logger2.error("Failed to update task definition", { taskId, errorCode: updateResult.error.code, traceId: updateResult.error.traceId });
712
1088
  return err(
713
1089
  HaiSchedulerError.DB_SAVE_FAILED,
714
- schedulerM("scheduler_dbSaveFailed", { params: { error: updateResult.error.message } }),
1090
+ schedulerM("scheduler_dbSaveFailed", {
1091
+ params: { error: updateResult.error.message }
1092
+ }),
715
1093
  updateResult.error
716
1094
  );
717
1095
  }
@@ -721,7 +1099,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
721
1099
  return err(
722
1100
  HaiSchedulerError.DB_SAVE_FAILED,
723
1101
  schedulerM("scheduler_dbSaveFailed", {
724
- params: { error: error instanceof Error ? error.message : String(error) }
1102
+ params: {
1103
+ error: error instanceof Error ? error.message : String(error)
1104
+ }
725
1105
  }),
726
1106
  error
727
1107
  );
@@ -731,13 +1111,35 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
731
1111
  async deleteTask(taskId, expected) {
732
1112
  try {
733
1113
  if (expected) {
734
- const conditions = ["task_id = ?", "task_name = ?", "cron = ?", "COALESCE(timezone, '') = ?", "COALESCE(description, '') = ?", "enabled = ?", "delete_after_run = ?", "idempotent = ?"];
1114
+ const conditions = [
1115
+ "task_id = ?",
1116
+ "task_name = ?",
1117
+ "cron = ?",
1118
+ "COALESCE(timezone, '') = ?",
1119
+ "COALESCE(description, '') = ?",
1120
+ "enabled = ?",
1121
+ "delete_after_run = ?",
1122
+ "idempotent = ?"
1123
+ ];
735
1124
  const postgres = this.db.config?.type === "postgresql";
736
1125
  const enabled = expected.enabled !== false;
737
1126
  const deleteAfterRun = expected.deleteAfterRun === true;
738
- const params = [taskId, expected.name, expected.cron, expected.timezone ?? "", expected.description ?? "", postgres ? enabled : Number(enabled), postgres ? deleteAfterRun : Number(deleteAfterRun), postgres ? expected.idempotent === true : Number(expected.idempotent === true)];
1127
+ const params = [
1128
+ taskId,
1129
+ expected.name,
1130
+ expected.cron,
1131
+ expected.timezone ?? "",
1132
+ expected.description ?? "",
1133
+ postgres ? enabled : Number(enabled),
1134
+ postgres ? deleteAfterRun : Number(deleteAfterRun),
1135
+ postgres ? expected.idempotent === true : Number(expected.idempotent === true)
1136
+ ];
739
1137
  const jsonValue = this.db.config?.type === "mysql" ? "CAST(? AS JSON)" : this.db.config?.type === "postgresql" ? "CAST(? AS JSONB)" : "?";
740
- const jsonFields = [["retry", expected.retry], ["params", expected.params ?? {}], ["handler", expected.handler]];
1138
+ const jsonFields = [
1139
+ ["retry", expected.retry],
1140
+ ["params", expected.params ?? {}],
1141
+ ["handler", expected.handler]
1142
+ ];
741
1143
  for (const [column, value] of jsonFields) {
742
1144
  if (value === void 0 || value === null) {
743
1145
  conditions.push(`(${column} IS NULL OR ${column} = ${jsonValue})`);
@@ -748,13 +1150,24 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
748
1150
  }
749
1151
  }
750
1152
  const deleted = await this.db.sql.execute(`DELETE FROM ${SCHEDULER_TASK_TABLE} WHERE ${conditions.join(" AND ")}`, params);
751
- return deleted.success ? ok(deleted.data.changes > 0) : deleted;
1153
+ if (!deleted.success) {
1154
+ logger2.error("Failed to delete task definition", { taskId, errorCode: deleted.error.code, traceId: deleted.error.traceId });
1155
+ return deleted;
1156
+ }
1157
+ return ok(deleted.data.changes > 0);
752
1158
  }
753
- const rows = await this.findAll({ where: "task_id = ?", params: [taskId], limit: 1 });
1159
+ const rows = await this.findAll({
1160
+ where: "task_id = ?",
1161
+ params: [taskId],
1162
+ limit: 1
1163
+ });
754
1164
  if (!rows.success) {
1165
+ logger2.error("Failed to load task definition for deletion", { taskId, errorCode: rows.error.code, traceId: rows.error.traceId });
755
1166
  return err(
756
1167
  HaiSchedulerError.DB_SAVE_FAILED,
757
- schedulerM("scheduler_dbSaveFailed", { params: { error: rows.error.message } }),
1168
+ schedulerM("scheduler_dbSaveFailed", {
1169
+ params: { error: rows.error.message }
1170
+ }),
758
1171
  rows.error
759
1172
  );
760
1173
  }
@@ -762,10 +1175,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
762
1175
  return ok(false);
763
1176
  const deleteResult = await this.deleteById(rows.data[0].id);
764
1177
  if (!deleteResult.success) {
765
- logger2.error("Failed to delete task definition", { taskId, error: deleteResult.error.message });
1178
+ logger2.error("Failed to delete task definition", { taskId, errorCode: deleteResult.error.code, traceId: deleteResult.error.traceId });
766
1179
  return err(
767
1180
  HaiSchedulerError.DB_SAVE_FAILED,
768
- schedulerM("scheduler_dbSaveFailed", { params: { error: deleteResult.error.message } }),
1181
+ schedulerM("scheduler_dbSaveFailed", {
1182
+ params: { error: deleteResult.error.message }
1183
+ }),
769
1184
  deleteResult.error
770
1185
  );
771
1186
  }
@@ -775,7 +1190,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
775
1190
  return err(
776
1191
  HaiSchedulerError.DB_SAVE_FAILED,
777
1192
  schedulerM("scheduler_dbSaveFailed", {
778
- params: { error: error instanceof Error ? error.message : String(error) }
1193
+ params: {
1194
+ error: error instanceof Error ? error.message : String(error)
1195
+ }
779
1196
  }),
780
1197
  error
781
1198
  );
@@ -785,9 +1202,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
785
1202
  try {
786
1203
  const rows = await this.findAll({ orderBy: "id ASC" });
787
1204
  if (!rows.success) {
1205
+ logger2.error("Failed to load task definitions", { errorCode: rows.error.code, traceId: rows.error.traceId });
788
1206
  return err(
789
1207
  HaiSchedulerError.DB_SAVE_FAILED,
790
- schedulerM("scheduler_dbSaveFailed", { params: { error: rows.error.message } }),
1208
+ schedulerM("scheduler_dbSaveFailed", {
1209
+ params: { error: rows.error.message }
1210
+ }),
791
1211
  rows.error
792
1212
  );
793
1213
  }
@@ -795,15 +1215,21 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
795
1215
  for (const row of rows.data) {
796
1216
  const paramsResult = TaskParamsSchema.safeParse(row.params ?? {});
797
1217
  if (!paramsResult.success) {
798
- return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", { params: { taskId: row.taskId, error: paramsResult.error.message } }));
1218
+ return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
1219
+ params: { taskId: row.taskId, error: paramsResult.error.message }
1220
+ }));
799
1221
  }
800
1222
  const handlerResult = row.handler == null ? { success: true, data: void 0 } : TaskHandlerConfigSchema.safeParse(row.handler);
801
1223
  if (!handlerResult.success) {
802
- return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", { params: { taskId: row.taskId, error: handlerResult.error.message } }));
1224
+ return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
1225
+ params: { taskId: row.taskId, error: handlerResult.error.message }
1226
+ }));
803
1227
  }
804
1228
  const retryResult = row.retry == null ? { success: true, data: void 0 } : TaskRetryPolicySchema.safeParse(row.retry);
805
1229
  if (!retryResult.success) {
806
- return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", { params: { taskId: row.taskId, error: retryResult.error.message } }));
1230
+ return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
1231
+ params: { taskId: row.taskId, error: retryResult.error.message }
1232
+ }));
807
1233
  }
808
1234
  tasks.push({
809
1235
  id: row.taskId,
@@ -825,7 +1251,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
825
1251
  return err(
826
1252
  HaiSchedulerError.DB_SAVE_FAILED,
827
1253
  schedulerM("scheduler_dbSaveFailed", {
828
- params: { error: error instanceof Error ? error.message : String(error) }
1254
+ params: {
1255
+ error: error instanceof Error ? error.message : String(error)
1256
+ }
829
1257
  }),
830
1258
  error
831
1259
  );
@@ -839,13 +1267,14 @@ function parseCronExpression(expression, timezone) {
839
1267
  } catch {
840
1268
  return err(
841
1269
  HaiSchedulerError.INVALID_CRON,
842
- schedulerM("scheduler_invalidCron", { params: { expression } })
1270
+ schedulerM("scheduler_invalidCron", {
1271
+ params: { expression }
1272
+ })
843
1273
  );
844
1274
  }
845
1275
  }
846
1276
 
847
1277
  // src/scheduler-functions.ts
848
- var logger3 = core.logger.child({ module: "scheduler", scope: "functions" });
849
1278
  var taskRegistry = /* @__PURE__ */ new Map();
850
1279
  var cronCache = /* @__PURE__ */ new Map();
851
1280
  var persistedTaskIds = /* @__PURE__ */ new Set();
@@ -918,7 +1347,9 @@ function validateRetryPolicy(taskId, retry) {
918
1347
  if (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1 || retry.maxAttempts > 100) {
919
1348
  return err(
920
1349
  HaiSchedulerError.EXECUTION_FAILED,
921
- schedulerM("scheduler_invalidRetryConfig", { params: { taskId } })
1350
+ schedulerM("scheduler_invalidRetryConfig", {
1351
+ params: { taskId }
1352
+ })
922
1353
  );
923
1354
  }
924
1355
  if (retry.backoffMs !== void 0) {
@@ -926,13 +1357,17 @@ function validateRetryPolicy(taskId, retry) {
926
1357
  if (hasInvalidBackoff) {
927
1358
  return err(
928
1359
  HaiSchedulerError.EXECUTION_FAILED,
929
- schedulerM("scheduler_invalidRetryConfig", { params: { taskId } })
1360
+ schedulerM("scheduler_invalidRetryConfig", {
1361
+ params: { taskId }
1362
+ })
930
1363
  );
931
1364
  }
932
1365
  }
933
1366
  return ok({
934
1367
  maxAttempts: retry.maxAttempts,
935
- ...retry.backoffMs ? { backoffMs: [...retry.backoffMs] } : {}
1368
+ ...retry.backoffMs ? {
1369
+ backoffMs: [...retry.backoffMs]
1370
+ } : {}
936
1371
  });
937
1372
  }
938
1373
  async function loadPersistedTasks(taskRepo2) {
@@ -955,7 +1390,10 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
955
1390
  });
956
1391
  let loadResult;
957
1392
  try {
958
- loadResult = await Promise.race([taskRepo2.loadTasks(), cancelled]);
1393
+ loadResult = await Promise.race([
1394
+ taskRepo2.loadTasks(),
1395
+ cancelled
1396
+ ]);
959
1397
  } finally {
960
1398
  signal.removeEventListener("abort", cancel);
961
1399
  }
@@ -970,8 +1408,11 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
970
1408
  for (const task of loadResult.data) {
971
1409
  if (!task.id)
972
1410
  return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_taskIdEmpty"));
973
- if (nextTasks.has(task.id))
974
- return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", { params: { taskId: task.id } }));
1411
+ if (nextTasks.has(task.id)) {
1412
+ return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", {
1413
+ params: { taskId: task.id }
1414
+ }));
1415
+ }
975
1416
  const cronResult = parseCronExpression(task.cron, task.timezone);
976
1417
  if (!cronResult.success)
977
1418
  return cronResult;
@@ -1010,7 +1451,9 @@ async function registerTask(task, taskRepo2) {
1010
1451
  }
1011
1452
  async function registerTaskDefinition(task, taskRepo2) {
1012
1453
  if (task.handler && !TaskHandlerConfigSchema.safeParse(task.handler).success || task.idempotent !== void 0 && typeof task.idempotent !== "boolean") {
1013
- return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } }));
1454
+ return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
1455
+ params: { taskId: task.id }
1456
+ }));
1014
1457
  }
1015
1458
  if (!task.id) {
1016
1459
  return err(
@@ -1021,7 +1464,9 @@ async function registerTaskDefinition(task, taskRepo2) {
1021
1464
  if (hasTask(task.id)) {
1022
1465
  return err(
1023
1466
  HaiSchedulerError.TASK_ALREADY_EXISTS,
1024
- schedulerM("scheduler_taskAlreadyExists", { params: { taskId: task.id } })
1467
+ schedulerM("scheduler_taskAlreadyExists", {
1468
+ params: { taskId: task.id }
1469
+ })
1025
1470
  );
1026
1471
  }
1027
1472
  const cronResult = parseCronExpression(task.cron, task.timezone);
@@ -1043,10 +1488,11 @@ async function registerTaskDefinition(task, taskRepo2) {
1043
1488
  if (taskRepo2) {
1044
1489
  const saveResult = await taskRepo2.saveTask(normalizedTask);
1045
1490
  if (!saveResult.success) {
1046
- logger3.warn("Failed to persist task definition", { taskId: task.id, error: saveResult.error.message });
1047
1491
  return err(
1048
1492
  HaiSchedulerError.DB_SAVE_FAILED,
1049
- schedulerM("scheduler_dbSaveFailed", { params: { error: saveResult.error.message } }),
1493
+ schedulerM("scheduler_dbSaveFailed", {
1494
+ params: { error: saveResult.error.message }
1495
+ }),
1050
1496
  saveResult.error
1051
1497
  );
1052
1498
  }
@@ -1070,16 +1516,19 @@ async function unregisterTaskDefinition(taskId, taskRepo2, expected) {
1070
1516
  if (!hasTask(taskId)) {
1071
1517
  return err(
1072
1518
  HaiSchedulerError.TASK_NOT_FOUND,
1073
- schedulerM("scheduler_taskNotFound", { params: { taskId } })
1519
+ schedulerM("scheduler_taskNotFound", {
1520
+ params: { taskId }
1521
+ })
1074
1522
  );
1075
1523
  }
1076
1524
  if (taskRepo2) {
1077
1525
  const deleteResult = await taskRepo2.deleteTask(taskId, expected);
1078
1526
  if (!deleteResult.success) {
1079
- logger3.warn("Failed to delete persisted task definition", { taskId, error: deleteResult.error.message });
1080
1527
  return err(
1081
1528
  HaiSchedulerError.DB_SAVE_FAILED,
1082
- schedulerM("scheduler_dbSaveFailed", { params: { error: deleteResult.error.message } }),
1529
+ schedulerM("scheduler_dbSaveFailed", {
1530
+ params: { error: deleteResult.error.message }
1531
+ }),
1083
1532
  deleteResult.error
1084
1533
  );
1085
1534
  }
@@ -1106,7 +1555,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
1106
1555
  if (!existingTask) {
1107
1556
  return err(
1108
1557
  HaiSchedulerError.TASK_NOT_FOUND,
1109
- schedulerM("scheduler_taskNotFound", { params: { taskId } })
1558
+ schedulerM("scheduler_taskNotFound", {
1559
+ params: { taskId }
1560
+ })
1110
1561
  );
1111
1562
  }
1112
1563
  let updatedCron = getCron(taskId);
@@ -1136,7 +1587,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
1136
1587
  ...updates.retry !== void 0 ? { retry: normalizedRetry } : {}
1137
1588
  };
1138
1589
  if (updates.handler && !TaskHandlerConfigSchema.safeParse(updates.handler).success || updates.idempotent !== void 0 && typeof updates.idempotent !== "boolean") {
1139
- return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", { params: { taskId } }));
1590
+ return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
1591
+ params: { taskId }
1592
+ }));
1140
1593
  }
1141
1594
  const updatedTask = {
1142
1595
  ...existingTask,
@@ -1154,10 +1607,11 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
1154
1607
  if (taskRepo2) {
1155
1608
  const updateResult = await taskRepo2.updateTask(taskId, normalizedUpdates);
1156
1609
  if (!updateResult.success) {
1157
- logger3.warn("Failed to update persisted task definition", { taskId, error: updateResult.error.message });
1158
1610
  return err(
1159
1611
  HaiSchedulerError.DB_SAVE_FAILED,
1160
- schedulerM("scheduler_dbSaveFailed", { params: { error: updateResult.error.message } }),
1612
+ schedulerM("scheduler_dbSaveFailed", {
1613
+ params: { error: updateResult.error.message }
1614
+ }),
1161
1615
  updateResult.error
1162
1616
  );
1163
1617
  }
@@ -1195,12 +1649,16 @@ function compileJsTaskHandler(config) {
1195
1649
  signal?.throwIfAborted();
1196
1650
  return await new Promise((resolve, reject) => {
1197
1651
  const timeout = config.timeout ?? 3e4;
1198
- const worker = new Worker(new URL("./scheduler-js-worker.js", import.meta.url), {
1199
- workerData: { code: config.code, context },
1200
- execArgv: []
1201
- });
1652
+ const worker = core.worker.start(
1653
+ new URL("./scheduler-js-worker.js", import.meta.url),
1654
+ {
1655
+ workerData: { code: config.code, context },
1656
+ execArgv: []
1657
+ }
1658
+ );
1202
1659
  let settled = false;
1203
1660
  let timer;
1661
+ let unsubscribe;
1204
1662
  const aborted = () => finish(new Error(schedulerM("scheduler_closing")));
1205
1663
  function finish(error, result) {
1206
1664
  if (settled)
@@ -1208,13 +1666,15 @@ function compileJsTaskHandler(config) {
1208
1666
  settled = true;
1209
1667
  clearTimeout(timer);
1210
1668
  signal?.removeEventListener("abort", aborted);
1669
+ unsubscribe?.();
1211
1670
  void worker.terminate().then(() => error ? reject(error) : resolve(result), reject);
1212
1671
  }
1213
- timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", { params: { timeout } }))), timeout);
1672
+ timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
1673
+ params: { timeout }
1674
+ }))), timeout);
1214
1675
  signal?.addEventListener("abort", aborted, { once: true });
1215
- worker.once("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
1216
- worker.once("exit", (code) => finish(new Error(`JS worker exited before returning a result (${code})`)));
1217
- worker.once("message", (message) => {
1676
+ void worker.exited.then(({ code, error }) => finish(error ?? new Error(`JS worker exited before returning a result (${code})`)));
1677
+ unsubscribe = worker.onMessage((message) => {
1218
1678
  if (message.success)
1219
1679
  finish(void 0, message.data);
1220
1680
  else
@@ -1228,85 +1688,14 @@ function compileJsTaskHandler(config) {
1228
1688
  return err(
1229
1689
  HaiSchedulerError.JS_COMPILE_FAILED,
1230
1690
  schedulerM("scheduler_jsCompileFailed", {
1231
- params: { error: error instanceof Error ? error.message : String(error) }
1691
+ params: {
1692
+ error: error instanceof Error ? error.message : String(error)
1693
+ }
1232
1694
  }),
1233
1695
  error
1234
1696
  );
1235
1697
  }
1236
1698
  }
1237
- function migrateScheduler(options = {}) {
1238
- const steps = [{
1239
- version: 1,
1240
- name: "explicit-task-idempotency",
1241
- async needed(sql) {
1242
- const columns = await schemaColumns(reldb, "hai_scheduler_tasks", sql);
1243
- return columns.success ? ok(columns.data.length > 0 && !columns.data.includes("idempotent")) : columns;
1244
- },
1245
- async apply(sql) {
1246
- return sql.execute("ALTER TABLE hai_scheduler_tasks ADD COLUMN idempotent BOOLEAN NOT NULL DEFAULT FALSE");
1247
- }
1248
- }, {
1249
- version: 2,
1250
- name: "execution-history-snapshots",
1251
- async needed(sql) {
1252
- const columns = await schemaColumns(reldb, "hai_scheduler_logs", sql);
1253
- if (!columns.success)
1254
- return columns;
1255
- if (columns.data.length && !columns.data.includes("payload"))
1256
- return ok(true);
1257
- const archive = await schemaColumns(reldb, "hai_scheduler_logs_alpha65", sql);
1258
- if (!archive.success)
1259
- return archive;
1260
- if (!archive.data.length)
1261
- return ok(false);
1262
- if (!columns.data.length)
1263
- return ok(true);
1264
- const identity = reldb.config?.type === "mysql" ? "CAST(n.id AS BINARY)=CAST(CONCAT('legacy:',CAST(a.id AS CHAR)) AS BINARY)" : "n.id='legacy:' || CAST(a.id AS TEXT)";
1265
- const missing = await sql.get(`SELECT id FROM hai_scheduler_logs_alpha65 a WHERE NOT EXISTS (SELECT 1 FROM hai_scheduler_logs n WHERE ${identity}) LIMIT 1`);
1266
- return missing.success ? ok(Boolean(missing.data)) : missing;
1267
- },
1268
- async apply(sql) {
1269
- const columns = await schemaColumns(reldb, "hai_scheduler_logs", sql);
1270
- if (!columns.success)
1271
- return columns;
1272
- if (columns.data.length && !columns.data.includes("payload")) {
1273
- const archive = await schemaColumns(reldb, "hai_scheduler_logs_alpha65", sql);
1274
- if (!archive.success)
1275
- return archive;
1276
- if (archive.data.length)
1277
- return err(HaiCommonError.INIT_FAILED, "Scheduler archive already exists");
1278
- const renamed = await sql.execute("ALTER TABLE hai_scheduler_logs RENAME TO hai_scheduler_logs_alpha65");
1279
- if (!renamed.success)
1280
- return renamed;
1281
- }
1282
- const text = reldb.config?.type === "mysql" ? "VARCHAR(255)" : "TEXT";
1283
- const json = reldb.config?.type === "postgresql" ? "JSONB" : reldb.config?.type === "mysql" ? "JSON" : "TEXT";
1284
- const created = await sql.execute(`CREATE TABLE IF NOT EXISTS hai_scheduler_logs (id ${text} NOT NULL,occurrence_id ${text},task_id ${text} NOT NULL,task_name ${text} NOT NULL,task_type ${text} NOT NULL,trigger_type ${text} NOT NULL,trigger_source ${text},status ${text} NOT NULL,payload ${json} NOT NULL,started_at BIGINT NOT NULL,finished_at BIGINT NOT NULL,duration INTEGER NOT NULL,CONSTRAINT pk_hai_scheduler_log_v2 PRIMARY KEY(id))`);
1285
- if (!created.success)
1286
- return created;
1287
- for (let offset = 0; ; offset += 100) {
1288
- const rows = await sql.query(`SELECT CAST(id AS ${reldb.config?.type === "mysql" ? "CHAR" : "TEXT"}) AS id,task_id,task_name,task_type,trigger_type,trigger_source,status,result,error,started_at,finished_at,duration FROM hai_scheduler_logs_alpha65 ORDER BY id LIMIT 100 OFFSET ?`, [offset]);
1289
- if (!rows.success)
1290
- return rows;
1291
- for (const row of rows.data) {
1292
- const id = `legacy:${row.id}`;
1293
- const existing = await sql.get("SELECT id FROM hai_scheduler_logs WHERE id=?", [id]);
1294
- if (!existing.success)
1295
- return existing;
1296
- if (existing.data)
1297
- continue;
1298
- const payload = { id, taskId: row.task_id, taskName: row.task_name, taskType: row.task_type, triggerType: row.trigger_type, triggerSource: row.trigger_source, status: row.status, result: row.result, error: row.error, startedAt: Number(row.started_at), finishedAt: Number(row.finished_at), duration: Number(row.duration), persistence: { status: "persisted" } };
1299
- const copied = await sql.execute("INSERT INTO hai_scheduler_logs(id,task_id,task_name,task_type,trigger_type,trigger_source,status,payload,started_at,finished_at,duration) VALUES(?,?,?,?,?,?,?,?,?,?,?)", [id, row.task_id, row.task_name, row.task_type, row.trigger_type, row.trigger_source, row.status, JSON.stringify(payload), row.started_at, row.finished_at, row.duration]);
1300
- if (!copied.success)
1301
- return copied;
1302
- }
1303
- if (rows.data.length < 100)
1304
- return ok(void 0);
1305
- }
1306
- }
1307
- }];
1308
- return migrateSchema(reldb, "scheduler", steps, options);
1309
- }
1310
1699
 
1311
1700
  // src/scheduler-cancellation.ts
1312
1701
  async function waitWithSignal(operation, signal) {
@@ -1321,7 +1710,7 @@ async function waitWithSignal(operation, signal) {
1321
1710
  }
1322
1711
 
1323
1712
  // src/scheduler-executor.ts
1324
- var logger4 = core.logger.child({ module: "scheduler", scope: "executor" });
1713
+ var logger3 = core.logger.child({ module: "scheduler", scope: "executor" });
1325
1714
  function resolveTaskType(task, hooks) {
1326
1715
  if (task.handler)
1327
1716
  return task.handler.kind;
@@ -1344,7 +1733,7 @@ async function notifyTaskStart(hooks, event) {
1344
1733
  try {
1345
1734
  await waitWithSignal(() => hooks.onTaskStart(event), event.signal);
1346
1735
  } catch (error) {
1347
- logger4.warn("Task start hook failed", { taskId: event.task.id, error });
1736
+ logger3.warn("Task start hook failed", { taskId: event.task.id, error });
1348
1737
  }
1349
1738
  }
1350
1739
  async function notifyTaskInterrupted(hooks, event) {
@@ -1353,7 +1742,7 @@ async function notifyTaskInterrupted(hooks, event) {
1353
1742
  try {
1354
1743
  await waitWithSignal(() => hooks.onTaskInterrupted(event), event.signal);
1355
1744
  } catch (error) {
1356
- logger4.warn("Task interrupted hook failed", { taskId: event.task.id, error });
1745
+ logger3.warn("Task interrupted hook failed", { taskId: event.task.id, error });
1357
1746
  }
1358
1747
  }
1359
1748
  async function notifyTaskFinish(hooks, event) {
@@ -1362,7 +1751,7 @@ async function notifyTaskFinish(hooks, event) {
1362
1751
  try {
1363
1752
  await waitWithSignal(() => hooks.onTaskFinish(event), event.signal);
1364
1753
  } catch (error) {
1365
- logger4.warn("Task finish hook failed", { taskId: event.task.id, error });
1754
+ logger3.warn("Task finish hook failed", { taskId: event.task.id, error });
1366
1755
  }
1367
1756
  }
1368
1757
  function createExecutionLog(task, trigger, taskType, status, startedAt, finishedAt, result, error, occurrenceId) {
@@ -1408,7 +1797,9 @@ async function executeJsTask(task, context, signal = new AbortController().signa
1408
1797
  if (!handler || handler.kind !== "js") {
1409
1798
  return err(
1410
1799
  HaiSchedulerError.EXECUTION_FAILED,
1411
- schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } })
1800
+ schedulerM("scheduler_invalidHandlerConfig", {
1801
+ params: { taskId: task.id }
1802
+ })
1412
1803
  );
1413
1804
  }
1414
1805
  const compileResult = compileJsTaskHandler(handler);
@@ -1419,10 +1810,12 @@ async function executeJsTask(task, context, signal = new AbortController().signa
1419
1810
  return ok(result !== void 0 ? JSON.stringify(result) : null);
1420
1811
  } catch (error) {
1421
1812
  const message = error instanceof Error ? error.message : String(error);
1422
- logger4.error("JS task execution failed", { taskId: task.id, error: message });
1813
+ logger3.error("JS task execution failed", { taskId: task.id, error: message });
1423
1814
  return err(
1424
1815
  HaiSchedulerError.JS_EXECUTION_FAILED,
1425
- schedulerM("scheduler_jsExecutionFailed", { params: { error: message } }),
1816
+ schedulerM("scheduler_jsExecutionFailed", {
1817
+ params: { error: message }
1818
+ }),
1426
1819
  error
1427
1820
  );
1428
1821
  }
@@ -1432,12 +1825,17 @@ async function executeApiTask(task, context, signal = new AbortController().sign
1432
1825
  if (!handler || handler.kind !== "api") {
1433
1826
  return err(
1434
1827
  HaiSchedulerError.EXECUTION_FAILED,
1435
- schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } })
1828
+ schedulerM("scheduler_invalidHandlerConfig", {
1829
+ params: { taskId: task.id }
1830
+ })
1436
1831
  );
1437
1832
  }
1438
1833
  const { url, method = "GET", headers, body, timeout = 3e4, maxResponseBytes = 1024 * 1024 } = handler;
1439
- if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)
1440
- return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } }));
1834
+ if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0) {
1835
+ return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
1836
+ params: { taskId: task.id }
1837
+ }));
1838
+ }
1441
1839
  const controller = new AbortController();
1442
1840
  const timer = setTimeout(() => controller.abort(), timeout);
1443
1841
  try {
@@ -1454,7 +1852,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
1454
1852
  method,
1455
1853
  headers: requestHeaders,
1456
1854
  signal: AbortSignal.any([signal, controller.signal]),
1457
- ...body !== void 0 ? { body: JSON.stringify(body) } : {}
1855
+ ...body !== void 0 ? {
1856
+ body: JSON.stringify(body)
1857
+ } : {}
1458
1858
  });
1459
1859
  let receivedBytes = 0;
1460
1860
  let responseText = "";
@@ -1469,7 +1869,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
1469
1869
  receivedBytes += chunk.value.byteLength;
1470
1870
  if (receivedBytes > maxResponseBytes) {
1471
1871
  controller.abort();
1472
- return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", { params: { maxResponseBytes } }));
1872
+ return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
1873
+ params: { maxResponseBytes }
1874
+ }));
1473
1875
  }
1474
1876
  responseText += decoder.decode(chunk.value, { stream: true });
1475
1877
  }
@@ -1479,7 +1881,7 @@ async function executeApiTask(task, context, signal = new AbortController().sign
1479
1881
  }
1480
1882
  }
1481
1883
  if (!response.ok) {
1482
- logger4.error("API task returned non-OK status", {
1884
+ logger3.error("API task returned non-OK status", {
1483
1885
  taskId: context.taskId,
1484
1886
  status: response.status,
1485
1887
  url: core.sanitize.sanitizeUrl(url)
@@ -1494,10 +1896,16 @@ async function executeApiTask(task, context, signal = new AbortController().sign
1494
1896
  return ok(responseText || null);
1495
1897
  } catch (error) {
1496
1898
  const message = error instanceof Error ? error.message : String(error);
1497
- logger4.error("API task execution failed", { taskId: context.taskId, error: message, url: core.sanitize.sanitizeUrl(url) });
1899
+ logger3.error("API task execution failed", {
1900
+ taskId: context.taskId,
1901
+ error: message,
1902
+ url: core.sanitize.sanitizeUrl(url)
1903
+ });
1498
1904
  return err(
1499
1905
  HaiSchedulerError.API_EXECUTION_FAILED,
1500
- schedulerM("scheduler_apiExecutionFailed", { params: { error: message } }),
1906
+ schedulerM("scheduler_apiExecutionFailed", {
1907
+ params: { error: message }
1908
+ }),
1501
1909
  error
1502
1910
  );
1503
1911
  } finally {
@@ -1508,7 +1916,9 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
1508
1916
  if (!hooks.onTaskExecute) {
1509
1917
  return err(
1510
1918
  HaiSchedulerError.EXECUTION_FAILED,
1511
- schedulerM("scheduler_taskHandlerMissing", { params: { taskId: task.id } })
1919
+ schedulerM("scheduler_taskHandlerMissing", {
1920
+ params: { taskId: task.id }
1921
+ })
1512
1922
  );
1513
1923
  }
1514
1924
  const executeEvent = {
@@ -1523,10 +1933,12 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
1523
1933
  return ok(result !== void 0 ? JSON.stringify(result) : null);
1524
1934
  } catch (error) {
1525
1935
  const message = error instanceof Error ? error.message : String(error);
1526
- logger4.error("Task execute hook failed", { taskId: task.id, error: message });
1936
+ logger3.error("Task execute hook failed", { taskId: task.id, error: message });
1527
1937
  return err(
1528
1938
  HaiSchedulerError.HOOK_EXECUTION_FAILED,
1529
- schedulerM("scheduler_hookExecutionFailed", { params: { error: message } }),
1939
+ schedulerM("scheduler_hookExecutionFailed", {
1940
+ params: { error: message }
1941
+ }),
1530
1942
  error
1531
1943
  );
1532
1944
  }
@@ -1535,7 +1947,13 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
1535
1947
  const startedAt = Date.now();
1536
1948
  const taskType = resolveTaskType(task, hooks);
1537
1949
  const context = createTaskContext(task, trigger, execution);
1538
- await notifyTaskStart(hooks, { task, trigger, startedAt, signal, context });
1950
+ await notifyTaskStart(hooks, {
1951
+ task,
1952
+ trigger,
1953
+ startedAt,
1954
+ signal,
1955
+ context
1956
+ });
1539
1957
  let executionResult;
1540
1958
  let shouldNotifyInterrupted = false;
1541
1959
  if (signal.aborted) {
@@ -1576,13 +1994,22 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
1576
1994
  context
1577
1995
  });
1578
1996
  }
1579
- if (status !== "interrupted" && !signal.aborted)
1580
- await notifyTaskFinish(hooks, { task, trigger, startedAt, finishedAt, log, signal, context });
1997
+ if (status !== "interrupted" && !signal.aborted) {
1998
+ await notifyTaskFinish(hooks, {
1999
+ task,
2000
+ trigger,
2001
+ startedAt,
2002
+ finishedAt,
2003
+ log,
2004
+ signal,
2005
+ context
2006
+ });
2007
+ }
1581
2008
  return log;
1582
2009
  }
1583
2010
 
1584
2011
  // src/scheduler-runner.ts
1585
- var logger5 = core.logger.child({ module: "scheduler", scope: "runner" });
2012
+ var logger4 = core.logger.child({ module: "scheduler", scope: "runner" });
1586
2013
  var runningTasks = /* @__PURE__ */ new Set();
1587
2014
  var activeRuns = /* @__PURE__ */ new Map();
1588
2015
  var activeRepairs = /* @__PURE__ */ new Set();
@@ -1607,13 +2034,24 @@ var publishedLogSchema = z.object({
1607
2034
  taskType: z.enum(["api", "js", "hook"]),
1608
2035
  triggerType: z.enum(["manual", "scheduled"]),
1609
2036
  triggerSource: z.string().nullable(),
1610
- status: z.enum(["success", "failed", "interrupted", "unknown"]),
2037
+ status: z.enum([
2038
+ "success",
2039
+ "failed",
2040
+ "interrupted",
2041
+ "unknown"
2042
+ ]),
1611
2043
  result: z.string().nullable(),
1612
2044
  error: z.string().nullable(),
1613
2045
  startedAt: z.number().safe(),
1614
2046
  finishedAt: z.number().safe(),
1615
2047
  duration: z.number().safe(),
1616
- persistence: z.object({ status: z.enum(["pending", "persisted", "unconfirmed"]), error: z.object({ code: z.string(), message: z.string() }).optional() })
2048
+ persistence: z.object({
2049
+ status: z.enum(["pending", "persisted", "unconfirmed"]),
2050
+ error: z.object({
2051
+ code: z.string(),
2052
+ message: z.string()
2053
+ }).optional()
2054
+ })
1617
2055
  });
1618
2056
  function repairExecutionLogs(id) {
1619
2057
  const operation = projectExecutionLogs(id);
@@ -1648,7 +2086,7 @@ async function projectExecutionLogs(id) {
1648
2086
  return err(HaiSchedulerError.LOG_PERSIST_FAILED, schedulerM("scheduler_logPersistFailed"));
1649
2087
  const cleanup = await logs.cleanupLogs(cleanupPolicy);
1650
2088
  if (!cleanup.success)
1651
- logger5.warn("Execution logs persisted but retention cleanup failed", { occurrenceId: id, errorCode: cleanup.error.code });
2089
+ logger4.warn("Execution logs persisted but retention cleanup failed", { occurrenceId: id, errorCode: cleanup.error.code });
1652
2090
  return ok(void 0);
1653
2091
  } catch {
1654
2092
  return err(HaiSchedulerError.LOG_PERSIST_FAILED, schedulerM("scheduler_logPersistFailed"));
@@ -1690,7 +2128,9 @@ async function drainRunner() {
1690
2128
  stopTimer();
1691
2129
  for (const controller of activeRuns.values())
1692
2130
  controller.abort(new Error(schedulerM("scheduler_closing")));
1693
- await Promise.allSettled([...activeRuns.keys()]);
2131
+ await Promise.allSettled([
2132
+ ...activeRuns.keys()
2133
+ ]);
1694
2134
  await Promise.allSettled([...activeRepairs]);
1695
2135
  }
1696
2136
  async function tick() {
@@ -1727,7 +2167,7 @@ async function tick() {
1727
2167
  return;
1728
2168
  continue;
1729
2169
  }
1730
- void runTask(task, trigger.minute, trigger, void 0, row).catch((error) => logger5.warn("Execution recovery failed", { taskId: task.id, error }));
2170
+ void runTask(task, trigger.minute, trigger, void 0, row).catch((error) => logger4.warn("Execution recovery failed", { taskId: task.id, error }));
1731
2171
  }
1732
2172
  }
1733
2173
  }
@@ -1749,7 +2189,7 @@ function scheduleDueTasks(databaseNow) {
1749
2189
  continue;
1750
2190
  if (!getCron(taskId)?.match(new Date(currentMinute * 6e4)))
1751
2191
  continue;
1752
- void runTask(task, currentMinute, { type: "scheduled", source: null }).catch((error) => logger5.error("Unhandled task execution error", { taskId, error }));
2192
+ void runTask(task, currentMinute, { type: "scheduled", source: null }).catch((error) => logger4.error("Unhandled task execution error", { taskId, error }));
1753
2193
  }
1754
2194
  }
1755
2195
  function runTask(task, minuteTimestamp, trigger = { type: "manual", source: null }, options, recovery) {
@@ -1768,20 +2208,35 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
1768
2208
  const leaseMs = currentLeaseMs;
1769
2209
  const occurrenceId = recovery?.occurrenceId ?? executionId(task.id, trigger.type, minute === void 0 ? options?.idempotencyKey ?? randomUUID() : String(minute));
1770
2210
  const interrupted = async (reason, observationOnly = false) => {
1771
- const log = { ...await interruptTask(task, trigger, reason, {}, controller.signal), occurrenceId };
2211
+ const log = {
2212
+ ...await interruptTask(task, trigger, reason, {}, controller.signal),
2213
+ occurrenceId
2214
+ };
1772
2215
  if (observationOnly && logRepository) {
1773
2216
  const saved = await logRepository.saveLog(log);
1774
- log.persistence = saved.success ? { status: "persisted" } : { status: "unconfirmed", error: { code: String(saved.error.code), message: saved.error.message } };
2217
+ log.persistence = saved.success ? { status: "persisted" } : {
2218
+ status: "unconfirmed",
2219
+ error: {
2220
+ code: String(saved.error.code),
2221
+ message: saved.error.message
2222
+ }
2223
+ };
1775
2224
  }
1776
2225
  return log;
1777
2226
  };
1778
2227
  if (!executionRepo2)
1779
2228
  return interrupted(schedulerM("scheduler_executionStateFailed"), true);
1780
- const claimed = await executionRepo2.claim(task, occurrenceId, { ...trigger, ...minute !== void 0 ? { minute } : {} }, currentNodeId, leaseMs);
2229
+ const claimed = await executionRepo2.claim(task, occurrenceId, {
2230
+ ...trigger,
2231
+ ...minute !== void 0 ? { minute } : {}
2232
+ }, currentNodeId, leaseMs);
1781
2233
  if (!claimed.success)
1782
2234
  return interrupted(claimed.error.message, true);
1783
- if (!claimed.data)
1784
- return interrupted(schedulerM("scheduler_taskRunning", { params: { taskId: task.id } }), true);
2235
+ if (!claimed.data) {
2236
+ return interrupted(schedulerM("scheduler_taskRunning", {
2237
+ params: { taskId: task.id }
2238
+ }), true);
2239
+ }
1785
2240
  const row = claimed.data;
1786
2241
  if (!["claimed", "running"].includes(row.status)) {
1787
2242
  if (minute === void 0) {
@@ -1802,12 +2257,19 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
1802
2257
  duration: row.updatedAt - row.createdAt
1803
2258
  };
1804
2259
  const status = row.status === "discarded" ? "interrupted" : row.status;
1805
- return { ...log, status, error: status === "success" ? null : log.error, occurrenceId };
2260
+ return {
2261
+ ...log,
2262
+ status,
2263
+ error: status === "success" ? null : log.error,
2264
+ occurrenceId
2265
+ };
1806
2266
  } catch {
1807
2267
  return interrupted(schedulerM("scheduler_executionStateFailed"));
1808
2268
  }
1809
2269
  }
1810
- return interrupted(schedulerM("scheduler_occurrenceHandled", { params: { taskId: task.id } }), true);
2270
+ return interrupted(schedulerM("scheduler_occurrenceHandled", {
2271
+ params: { taskId: task.id }
2272
+ }), true);
1811
2273
  }
1812
2274
  runningTasks.add(task.id);
1813
2275
  let timer;
@@ -1846,14 +2308,21 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
1846
2308
  } catch {
1847
2309
  }
1848
2310
  if (!refreshed.success || !latest || latest.enabled === false || !unchanged) {
1849
- log = await interrupted(schedulerM("scheduler_taskNoLongerDue", { params: { taskId: task.id } }));
2311
+ log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
2312
+ params: { taskId: task.id }
2313
+ }));
1850
2314
  if (row.attemptCount > 0)
1851
2315
  log.status = "unknown";
1852
2316
  break;
1853
2317
  }
1854
2318
  task = latest;
1855
2319
  if (!task.handler && !hooks.onTaskExecute) {
1856
- log = { ...await interruptTask(task, trigger, schedulerM("scheduler_taskHandlerMissing", { params: { taskId: task.id } }), hooks, controller.signal), occurrenceId };
2320
+ log = {
2321
+ ...await interruptTask(task, trigger, schedulerM("scheduler_taskHandlerMissing", {
2322
+ params: { taskId: task.id }
2323
+ }), hooks, controller.signal),
2324
+ occurrenceId
2325
+ };
1857
2326
  break;
1858
2327
  }
1859
2328
  const begun = await executionRepo2.begin(row, leaseMs);
@@ -1861,7 +2330,12 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
1861
2330
  lost = true;
1862
2331
  break;
1863
2332
  }
1864
- log = await executeTask(task, trigger, hooks, controller.signal, { occurrenceId, executionToken: row.owner, sequence: row.sequence, attempt: row.attemptCount });
2333
+ log = await executeTask(task, trigger, hooks, controller.signal, {
2334
+ occurrenceId,
2335
+ executionToken: row.owner,
2336
+ sequence: row.sequence,
2337
+ attempt: row.attemptCount
2338
+ });
1865
2339
  log.occurrenceId = occurrenceId;
1866
2340
  attempts.push(log);
1867
2341
  if (log.status !== "failed" || !row.idempotent || row.attemptCount >= row.maxAttempts)
@@ -1873,23 +2347,53 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
1873
2347
  if (!log)
1874
2348
  log = await interrupted(schedulerM("scheduler_executionStateFailed"));
1875
2349
  if (lost) {
1876
- return { ...log, status: "unknown", persistence: { status: "unconfirmed" }, error: schedulerM("scheduler_executionUnknown"), occurrenceId };
2350
+ return {
2351
+ ...log,
2352
+ status: "unknown",
2353
+ persistence: { status: "unconfirmed" },
2354
+ error: schedulerM("scheduler_executionUnknown"),
2355
+ occurrenceId
2356
+ };
2357
+ }
2358
+ if (controller.signal.aborted && row.attemptCount > 0) {
2359
+ log = {
2360
+ ...log,
2361
+ status: "unknown",
2362
+ error: schedulerM("scheduler_executionUnknown")
2363
+ };
1877
2364
  }
1878
- if (controller.signal.aborted && row.attemptCount > 0)
1879
- log = { ...log, status: "unknown", error: schedulerM("scheduler_executionUnknown") };
1880
2365
  const currentAttempt = attempts.findIndex((attempt) => attempt.id === log.id);
1881
2366
  if (currentAttempt >= 0)
1882
2367
  attempts[currentAttempt] = log;
1883
2368
  else
1884
2369
  attempts.push(log);
1885
- const published = attempts.map((attempt) => ({ ...attempt, persistence: { status: "pending" } }));
1886
- const finished = await executionRepo2.finish(row, { ...log, persistence: { status: "pending" } }, published);
1887
- if (!finished.success)
1888
- return { ...log, status: "unknown", persistence: { status: "unconfirmed" }, error: finished.error.message, occurrenceId };
2370
+ const published = attempts.map((attempt) => ({
2371
+ ...attempt,
2372
+ persistence: { status: "pending" }
2373
+ }));
2374
+ const finished = await executionRepo2.finish(row, {
2375
+ ...log,
2376
+ persistence: { status: "pending" }
2377
+ }, published);
2378
+ if (!finished.success) {
2379
+ return {
2380
+ ...log,
2381
+ status: "unknown",
2382
+ persistence: { status: "unconfirmed" },
2383
+ error: finished.error.message,
2384
+ occurrenceId
2385
+ };
2386
+ }
1889
2387
  const projected = await repairExecutionLogs(occurrenceId);
1890
- log.persistence = projected.success ? { status: "persisted" } : { status: "pending", error: { code: String(projected.error.code), message: projected.error.message } };
2388
+ log.persistence = projected.success ? { status: "persisted" } : {
2389
+ status: "pending",
2390
+ error: {
2391
+ code: String(projected.error.code),
2392
+ message: projected.error.message
2393
+ }
2394
+ };
1891
2395
  if (!projected.success)
1892
- logger5.warn("Execution completed with pending log persistence", { taskId: task.id, occurrenceId, errorCode: projected.error.code });
2396
+ logger4.warn("Execution completed with pending log persistence", { taskId: task.id, occurrenceId, errorCode: projected.error.code });
1893
2397
  if (task.deleteAfterRun && log.status === "success") {
1894
2398
  const refreshed = await loadPersistedTasks(repository);
1895
2399
  if (refreshed.success && isDeepStrictEqual(getTask(task.id), task))
@@ -1914,7 +2418,7 @@ function stopTimer() {
1914
2418
  }
1915
2419
 
1916
2420
  // src/scheduler-main.ts
1917
- var logger6 = core.logger.child({ module: "scheduler", scope: "main" });
2421
+ var logger5 = core.logger.child({ module: "scheduler", scope: "main" });
1918
2422
  var currentConfig = null;
1919
2423
  var initInProgress = false;
1920
2424
  var closeInProgress = null;
@@ -1922,25 +2426,30 @@ var taskRepo = null;
1922
2426
  var logRepo = null;
1923
2427
  var executionRepo = null;
1924
2428
  var executionIdSchema = z.string().regex(/^[a-f\d]{64}$/);
1925
- var executionListSchema = z.object({ limit: z.number().int().min(1).max(100).default(50), offset: z.number().int().min(0).max(1e6).default(0) });
2429
+ var executionListSchema = z.object({
2430
+ limit: z.number().int().min(1).max(100).default(50),
2431
+ offset: z.number().int().min(0).max(1e6).default(0)
2432
+ });
1926
2433
  var notInitialized = core.module.createNotInitializedKit(
1927
2434
  HaiSchedulerError.NOT_INITIALIZED,
1928
2435
  () => schedulerM("scheduler_notInitialized")
1929
2436
  );
1930
2437
  async function initDatabase(parsed) {
1931
2438
  if (!reldb.isInitialized) {
1932
- logger6.error("enableDb is true but @h-ai/reldb is not initialized");
2439
+ logger5.error("enableDb is true but @h-ai/reldb is not initialized");
1933
2440
  throw new Error(schedulerM("scheduler_reldbNotInitialized"));
1934
2441
  }
1935
- const migration = await migrateScheduler();
1936
- if (!migration.success)
1937
- throw migration.error;
1938
2442
  taskRepo = new SchedulerTaskRepository(reldb);
1939
2443
  logRepo = new SchedulerLogRepository(reldb);
1940
2444
  executionRepo = new SchedulerExecutionRepository(reldb);
1941
- const ready = await executionRepo.count();
1942
- if (!ready.success)
1943
- throw new Error(schedulerM("scheduler_executionStateFailed"));
2445
+ for (const ready of await Promise.all([
2446
+ taskRepo.ready(),
2447
+ logRepo.ready(),
2448
+ executionRepo.ready()
2449
+ ])) {
2450
+ if (!ready.success)
2451
+ throw ready.error;
2452
+ }
1944
2453
  setTaskRepository(taskRepo);
1945
2454
  setLogRepository(logRepo, {
1946
2455
  maxLogs: parsed.maxLogs,
@@ -1948,7 +2457,7 @@ async function initDatabase(parsed) {
1948
2457
  });
1949
2458
  const nodeId = parsed.nodeId ?? crypto.randomUUID();
1950
2459
  configureExecution(executionRepo, nodeId, parsed.leaseMs);
1951
- logger6.info("Shared execution repository configured", { nodeId, leaseMs: parsed.leaseMs });
2460
+ logger5.info("Shared execution repository configured", { nodeId, leaseMs: parsed.leaseMs });
1952
2461
  return { ...parsed, nodeId };
1953
2462
  }
1954
2463
  function normalizeTriggerInput(options) {
@@ -2003,10 +2512,12 @@ var scheduler = {
2003
2512
  },
2004
2513
  async init(config) {
2005
2514
  if (initInProgress) {
2006
- logger6.warn("Scheduler init already in progress, skipping concurrent call");
2515
+ logger5.warn("Scheduler init already in progress, skipping concurrent call");
2007
2516
  return err(
2008
2517
  HaiSchedulerError.INIT_FAILED,
2009
- schedulerM("scheduler_initFailed", { params: { error: "Concurrent initialization detected" } })
2518
+ schedulerM("scheduler_initFailed", {
2519
+ params: { error: "Concurrent initialization detected" }
2520
+ })
2010
2521
  );
2011
2522
  }
2012
2523
  initInProgress = true;
@@ -2014,17 +2525,19 @@ var scheduler = {
2014
2525
  if (closeInProgress)
2015
2526
  await closeInProgress;
2016
2527
  if (currentConfig) {
2017
- logger6.warn("Scheduler module is already initialized, reinitializing");
2528
+ logger5.warn("Scheduler module is already initialized, reinitializing");
2018
2529
  await scheduler.close();
2019
2530
  }
2020
- logger6.info("Initializing scheduler module");
2531
+ logger5.info("Initializing scheduler module");
2021
2532
  const { tasks = [], hooks = {}, ...configOptions } = config ?? {};
2022
2533
  const parseResult = SchedulerConfigSchema.safeParse(configOptions);
2023
2534
  if (!parseResult.success) {
2024
- logger6.error("Scheduler config validation failed", { error: parseResult.error.message });
2535
+ logger5.error("Scheduler config validation failed", { error: parseResult.error.message });
2025
2536
  return err(
2026
2537
  HaiSchedulerError.CONFIG_ERROR,
2027
- schedulerM("scheduler_configError", { params: { error: parseResult.error.message } }),
2538
+ schedulerM("scheduler_configError", {
2539
+ params: { error: parseResult.error.message }
2540
+ }),
2028
2541
  parseResult.error
2029
2542
  );
2030
2543
  }
@@ -2041,15 +2554,17 @@ var scheduler = {
2041
2554
  await scheduler.close();
2042
2555
  return configResult;
2043
2556
  }
2044
- logger6.info("Scheduler module initialized", { enableDb: currentConfig.enableDb, taskCount: getTaskRegistry().size });
2557
+ logger5.info("Scheduler module initialized", { enableDb: currentConfig.enableDb, taskCount: getTaskRegistry().size });
2045
2558
  return ok(void 0);
2046
2559
  } catch (error) {
2047
- logger6.error("Scheduler initialization failed", { error });
2560
+ logger5.error("Scheduler initialization failed", { error });
2048
2561
  await scheduler.close();
2049
2562
  return err(
2050
2563
  HaiSchedulerError.INIT_FAILED,
2051
2564
  schedulerM("scheduler_initFailed", {
2052
- params: { error: error instanceof Error ? error.message : String(error) }
2565
+ params: {
2566
+ error: error instanceof Error ? error.message : String(error)
2567
+ }
2053
2568
  }),
2054
2569
  error
2055
2570
  );
@@ -2069,7 +2584,7 @@ var scheduler = {
2069
2584
  return notInitialized.result();
2070
2585
  const registerResult = await registerTask(task, taskRepo);
2071
2586
  if (registerResult.success) {
2072
- logger6.info("Task registered", { taskId: task.id, taskName: task.name, cron: task.cron });
2587
+ logger5.info("Task registered", { taskId: task.id, taskName: task.name, cron: task.cron });
2073
2588
  }
2074
2589
  return registerResult;
2075
2590
  },
@@ -2078,15 +2593,19 @@ var scheduler = {
2078
2593
  return notInitialized.result();
2079
2594
  const unregisterResult = await unregisterTask(taskId, taskRepo);
2080
2595
  if (unregisterResult.success)
2081
- logger6.info("Task unregistered", { taskId });
2596
+ logger5.info("Task unregistered", { taskId });
2082
2597
  return unregisterResult;
2083
2598
  },
2084
2599
  async updateTask(taskId, updates) {
2085
2600
  if (!currentConfig)
2086
2601
  return notInitialized.result();
2087
2602
  const updateResult = await updateRegisteredTask(taskId, updates, taskRepo);
2088
- if (updateResult.success)
2089
- logger6.info("Task updated", { taskId, updates: Object.keys(updates) });
2603
+ if (updateResult.success) {
2604
+ logger5.info("Task updated", {
2605
+ taskId,
2606
+ updates: Object.keys(updates)
2607
+ });
2608
+ }
2090
2609
  return updateResult;
2091
2610
  },
2092
2611
  start() {
@@ -2099,7 +2618,7 @@ var scheduler = {
2099
2618
  );
2100
2619
  }
2101
2620
  startTimer(currentConfig.tickInterval);
2102
- logger6.info("Scheduler started", { tickInterval: currentConfig.tickInterval });
2621
+ logger5.info("Scheduler started", { tickInterval: currentConfig.tickInterval });
2103
2622
  return ok(void 0);
2104
2623
  },
2105
2624
  stop() {
@@ -2112,7 +2631,7 @@ var scheduler = {
2112
2631
  );
2113
2632
  }
2114
2633
  stopTimer();
2115
- logger6.info("Scheduler stopped");
2634
+ logger5.info("Scheduler stopped");
2116
2635
  return ok(void 0);
2117
2636
  },
2118
2637
  async trigger(taskId, options) {
@@ -2131,7 +2650,9 @@ var scheduler = {
2131
2650
  if (!task) {
2132
2651
  return err(
2133
2652
  HaiSchedulerError.TASK_NOT_FOUND,
2134
- schedulerM("scheduler_taskNotFound", { params: { taskId } })
2653
+ schedulerM("scheduler_taskNotFound", {
2654
+ params: { taskId }
2655
+ })
2135
2656
  );
2136
2657
  }
2137
2658
  const log = await runTask(task, void 0, normalizeTriggerInput(parsed.data), parsed.data);
@@ -2172,7 +2693,7 @@ var scheduler = {
2172
2693
  async close() {
2173
2694
  if (closeInProgress)
2174
2695
  return closeInProgress;
2175
- logger6.info("Closing scheduler module");
2696
+ logger5.info("Closing scheduler module");
2176
2697
  currentConfig = null;
2177
2698
  stopTimer();
2178
2699
  cancelTaskDefinitionReads();
@@ -2187,7 +2708,7 @@ var scheduler = {
2187
2708
  taskRepo = null;
2188
2709
  logRepo = null;
2189
2710
  executionRepo = null;
2190
- logger6.info("Scheduler module closed");
2711
+ logger5.info("Scheduler module closed");
2191
2712
  })();
2192
2713
  try {
2193
2714
  await closeInProgress;
@@ -2197,6 +2718,6 @@ var scheduler = {
2197
2718
  }
2198
2719
  };
2199
2720
 
2200
- export { ExecutionResolutionSchema, HaiSchedulerError, SchedulerConfigSchema, TriggerTaskSchema, migrateScheduler, scheduler };
2721
+ export { ExecutionResolutionSchema, HaiSchedulerError, SchedulerConfigSchema, TriggerTaskSchema, scheduler };
2201
2722
  //# sourceMappingURL=index.js.map
2202
2723
  //# sourceMappingURL=index.js.map