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

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