@h-ai/scheduler 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,1416 @@
+import { z } from 'zod';
+import { cache } from '@h-ai/cache';
+import { core, err, ok } from '@h-ai/core';
+import { reldb, BaseReldbCrudRepository } from '@h-ai/reldb';
+import { createHash } from 'crypto';
+import { Script } from 'vm';
+import { Cron } from 'croner';
+
+// src/scheduler-config.ts
+var SchedulerConfigSchema = z.object({
+  /** 是否启用数据库记录（默认 true，需要 @h-ai/reldb 已初始化） */
+  enableDb: z.boolean().default(true),
+  /** 调度检查间隔，单位毫秒（默认 1000，即每秒检查一次） */
+  tickInterval: z.number().int().min(100).default(1e3),
+  /** 分布式锁过期时间，单位毫秒（默认 300000，即 5 分钟） */
+  lockExpireMs: z.number().int().min(1e4).default(3e5),
+  /** 节点标识（默认自动生成 UUID，多节点部署时建议设置固定标识以便审计） */
+  nodeId: z.string().min(1).optional(),
+  /** 执行日志最大保留条数（启用 DB 时生效） */
+  maxLogs: z.number().int().min(1).optional(),
+  /** 执行日志保留天数（启用 DB 时生效） */
+  retentionDays: z.number().int().min(1).optional()
+});
+
+// messages/en-US.json
+var en_US_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  scheduler_notInitialized: "Scheduler not initialized, please call scheduler.init() first",
+  scheduler_initFailed: "Failed to initialize scheduler: {error}",
+  scheduler_alreadyRunning: "Scheduler is already running",
+  scheduler_notRunning: "Scheduler is not running",
+  scheduler_taskNotFound: "Task not found: {taskId}",
+  scheduler_taskAlreadyExists: "Task already exists: {taskId}",
+  scheduler_invalidCron: "Invalid cron expression: {expression}",
+  scheduler_executionFailed: "Task execution failed: {error}",
+  scheduler_jsExecutionFailed: "JS code execution failed: {error}",
+  scheduler_apiExecutionFailed: "API call failed: {error}",
+  scheduler_dbSaveFailed: "Failed to save execution log: {error}",
+  scheduler_dbNotInitialized: "Database not initialized, cannot save execution logs",
+  scheduler_configError: "Scheduler config validation failed: {error}",
+  scheduler_taskIdEmpty: "Task ID cannot be empty",
+  scheduler_taskRunning: "Task is currently running: {taskId}",
+  scheduler_invalidApiConfig: "Invalid api_config for task: {taskId}",
+  scheduler_lockAcquireFailed: "Failed to acquire distributed lock, another node already holds it: {taskId}",
+  scheduler_jsCompileFailed: "Failed to compile JS task: {error}",
+  scheduler_hookExecutionFailed: "Task lifecycle hook execution failed: {error}",
+  scheduler_taskHandlerMissing: "Task has no executable handler and no global execute hook is configured: {taskId}",
+  scheduler_invalidHandlerConfig: "Invalid task handler config: {taskId}",
+  scheduler_invalidRetryConfig: "Invalid retry policy config for task: {taskId}",
+  scheduler_reldbNotInitialized: "enableDb is true but @h-ai/reldb is not initialized, please call reldb.init() first"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  scheduler_notInitialized: "\u5B9A\u65F6\u4EFB\u52A1\u6A21\u5757\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 scheduler.init()",
+  scheduler_initFailed: "\u5B9A\u65F6\u4EFB\u52A1\u6A21\u5757\u521D\u59CB\u5316\u5931\u8D25: {error}",
+  scheduler_alreadyRunning: "\u5B9A\u65F6\u4EFB\u52A1\u8C03\u5EA6\u5668\u5DF2\u5728\u8FD0\u884C\u4E2D",
+  scheduler_notRunning: "\u5B9A\u65F6\u4EFB\u52A1\u8C03\u5EA6\u5668\u672A\u8FD0\u884C",
+  scheduler_taskNotFound: "\u4EFB\u52A1\u672A\u627E\u5230: {taskId}",
+  scheduler_taskAlreadyExists: "\u4EFB\u52A1\u5DF2\u5B58\u5728: {taskId}",
+  scheduler_invalidCron: "\u65E0\u6548\u7684 cron \u8868\u8FBE\u5F0F: {expression}",
+  scheduler_executionFailed: "\u4EFB\u52A1\u6267\u884C\u5931\u8D25: {error}",
+  scheduler_jsExecutionFailed: "JS \u4EE3\u7801\u6267\u884C\u5931\u8D25: {error}",
+  scheduler_apiExecutionFailed: "API \u8C03\u7528\u5931\u8D25: {error}",
+  scheduler_dbSaveFailed: "\u4FDD\u5B58\u6267\u884C\u8BB0\u5F55\u5931\u8D25: {error}",
+  scheduler_dbNotInitialized: "\u6570\u636E\u5E93\u672A\u521D\u59CB\u5316\uFF0C\u65E0\u6CD5\u4FDD\u5B58\u6267\u884C\u8BB0\u5F55",
+  scheduler_configError: "\u8C03\u5EA6\u5668\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A{error}",
+  scheduler_taskIdEmpty: "\u4EFB\u52A1 ID \u4E0D\u80FD\u4E3A\u7A7A",
+  scheduler_taskRunning: "\u4EFB\u52A1\u6B63\u5728\u6267\u884C\u4E2D: {taskId}",
+  scheduler_invalidApiConfig: "\u4EFB\u52A1 api_config \u683C\u5F0F\u65E0\u6548: {taskId}",
+  scheduler_lockAcquireFailed: "\u83B7\u53D6\u5206\u5E03\u5F0F\u9501\u5931\u8D25\uFF0C\u5176\u4ED6\u8282\u70B9\u5DF2\u83B7\u9501: {taskId}",
+  scheduler_jsCompileFailed: "JS \u4EFB\u52A1\u7F16\u8BD1\u5931\u8D25: {error}",
+  scheduler_hookExecutionFailed: "\u4EFB\u52A1\u751F\u547D\u5468\u671F\u56DE\u8C03\u6267\u884C\u5931\u8D25: {error}",
+  scheduler_taskHandlerMissing: "\u4EFB\u52A1\u7F3A\u5C11\u53EF\u6267\u884C handler\uFF0C\u4E14\u672A\u914D\u7F6E\u5168\u5C40\u6267\u884C\u56DE\u8C03: {taskId}",
+  scheduler_invalidHandlerConfig: "\u4EFB\u52A1 handler \u914D\u7F6E\u65E0\u6548: {taskId}",
+  scheduler_invalidRetryConfig: "\u4EFB\u52A1\u91CD\u8BD5\u7B56\u7565\u914D\u7F6E\u65E0\u6548: {taskId}",
+  scheduler_reldbNotInitialized: "enableDb \u4E3A true \u4F46 @h-ai/reldb \u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 reldb.init()"
+};
+
+// src/scheduler-i18n.ts
+var schedulerM = core.i18n.createMessageGetter({
+  "zh-CN": zh_CN_default,
+  "en-US": en_US_default
+});
+var SchedulerErrorInfo = {
+  NOT_INITIALIZED: "010:500",
+  INIT_FAILED: "011:500",
+  CONFIG_ERROR: "012:500",
+  TASK_NOT_FOUND: "020:404",
+  TASK_ALREADY_EXISTS: "021:409",
+  INVALID_CRON: "022:400",
+  EXECUTION_FAILED: "023:500",
+  JS_EXECUTION_FAILED: "024:500",
+  API_EXECUTION_FAILED: "025:502",
+  DB_SAVE_FAILED: "026:500",
+  ALREADY_RUNNING: "027:409",
+  NOT_RUNNING: "028:400",
+  LOCK_ACQUIRE_FAILED: "029:409",
+  JS_COMPILE_FAILED: "030:500",
+  HOOK_EXECUTION_FAILED: "031:500"
+};
+var HaiSchedulerError = core.error.buildHaiErrorsDef("scheduler", SchedulerErrorInfo);
+
+// src/repositories/scheduler-log-repository.ts
+var logger = core.logger.child({ module: "scheduler", scope: "log-repository" });
+var SCHEDULER_LOG_TABLE = "hai_scheduler_logs";
+var SchedulerLogRepository = class extends BaseReldbCrudRepository {
+  constructor(db) {
+    super(db, {
+      table: SCHEDULER_LOG_TABLE,
+      idColumn: "id",
+      fields: [
+        { fieldName: "id", columnName: "id", def: { type: "INTEGER", primaryKey: true, autoIncrement: true }, select: true, create: false, update: false },
+        { fieldName: "taskId", columnName: "task_id", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "taskName", columnName: "task_name", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "taskType", columnName: "task_type", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "triggerType", columnName: "trigger_type", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "triggerSource", columnName: "trigger_source", def: { type: "TEXT" }, select: true, create: true, update: false },
+        { fieldName: "status", columnName: "status", def: { type: "TEXT", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "result", columnName: "result", def: { type: "TEXT" }, select: true, create: true, update: false },
+        { fieldName: "error", columnName: "error", def: { type: "TEXT" }, select: true, create: true, update: false },
+        { fieldName: "startedAt", columnName: "started_at", def: { type: "INTEGER", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "finishedAt", columnName: "finished_at", def: { type: "INTEGER", notNull: true }, select: true, create: true, update: false },
+        { fieldName: "duration", columnName: "duration", def: { type: "INTEGER", notNull: true }, select: true, create: true, update: false }
+      ]
+    });
+  }
+  async saveLog(log) {
+    try {
+      const createResult = await this.create({
+        taskId: log.taskId,
+        taskName: log.taskName,
+        taskType: log.taskType,
+        triggerType: log.triggerType,
+        triggerSource: log.triggerSource,
+        status: log.status,
+        result: log.result,
+        error: log.error,
+        startedAt: log.startedAt,
+        finishedAt: log.finishedAt,
+        duration: log.duration
+      });
+      if (!createResult.success)
+        logger.error("Failed to save execution log", { taskId: log.taskId, error: createResult.error.message });
+    } catch (error) {
+      logger.error("Failed to save execution log", { taskId: log.taskId, error });
+    }
+  }
+  async queryLogs(options) {
+    const { taskId, status, triggerType, triggerSource, startedAfter, startedBefore, pagination } = options ?? {};
+    const conditions = [];
+    const params = [];
+    if (taskId) {
+      conditions.push("task_id = ?");
+      params.push(taskId);
+    }
+    if (status) {
+      conditions.push("status = ?");
+      params.push(status);
+    }
+    if (triggerType) {
+      conditions.push("trigger_type = ?");
+      params.push(triggerType);
+    }
+    if (triggerSource) {
+      conditions.push("trigger_source = ?");
+      params.push(triggerSource);
+    }
+    if (startedAfter !== void 0) {
+      conditions.push("started_at >= ?");
+      params.push(startedAfter);
+    }
+    if (startedBefore !== void 0) {
+      conditions.push("started_at <= ?");
+      params.push(startedBefore);
+    }
+    try {
+      const pageResult = await this.findPage({
+        where: conditions.length > 0 ? conditions.join(" AND ") : void 0,
+        params: params.length > 0 ? params : void 0,
+        orderBy: "id DESC",
+        pagination,
+        overrides: { defaultPageSize: 20, maxPageSize: 200 }
+      });
+      if (!pageResult.success) {
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: pageResult.error.message } }),
+          pageResult.error
+        );
+      }
+      return ok({
+        ...pageResult.data,
+        items: pageResult.data.items.map((row) => ({
+          id: row.id,
+          taskId: row.taskId,
+          taskName: row.taskName,
+          taskType: row.taskType,
+          triggerType: row.triggerType,
+          triggerSource: row.triggerSource ?? null,
+          status: row.status,
+          result: row.result ?? null,
+          error: row.error ?? null,
+          startedAt: row.startedAt,
+          finishedAt: row.finishedAt,
+          duration: row.duration
+        }))
+      });
+    } catch (error) {
+      logger.error("Failed to query execution logs", { error });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    }
+  }
+  async cleanupLogs(policy) {
+    const { maxLogs, retentionDays } = policy;
+    if (!maxLogs && !retentionDays)
+      return ok(void 0);
+    try {
+      if (retentionDays) {
+        const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+        const retentionResult = await this.sql().execute(
+          `DELETE FROM ${SCHEDULER_LOG_TABLE} WHERE started_at < ?`,
+          [cutoff]
+        );
+        if (!retentionResult.success) {
+          return err(
+            HaiSchedulerError.DB_SAVE_FAILED,
+            schedulerM("scheduler_dbSaveFailed", { params: { error: retentionResult.error.message } }),
+            retentionResult.error
+          );
+        }
+      }
+      if (maxLogs) {
+        const maxLogsResult = await this.sql().execute(
+          `DELETE FROM ${SCHEDULER_LOG_TABLE}
+           WHERE id NOT IN (
+             SELECT id FROM (
+               SELECT id
+               FROM ${SCHEDULER_LOG_TABLE}
+               ORDER BY started_at DESC, id DESC
+               LIMIT ?
+             ) AS keep_logs
+           )`,
+          [maxLogs]
+        );
+        if (!maxLogsResult.success) {
+          return err(
+            HaiSchedulerError.DB_SAVE_FAILED,
+            schedulerM("scheduler_dbSaveFailed", { params: { error: maxLogsResult.error.message } }),
+            maxLogsResult.error
+          );
+        }
+      }
+      return ok(void 0);
+    } catch (error) {
+      logger.error("Failed to cleanup execution logs", { error, maxLogs, retentionDays });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    }
+  }
+};
+var logger2 = core.logger.child({ module: "scheduler", scope: "task-repository" });
+var SCHEDULER_TASK_TABLE = "hai_scheduler_tasks";
+var TaskParamsSchema = z.record(z.string(), z.unknown());
+var TaskRetryPolicySchema = z.object({
+  maxAttempts: z.number().int().min(1),
+  backoffMs: z.array(z.number().int().min(0)).optional()
+});
+var ApiTaskConfigSchema = z.object({
+  kind: z.literal("api"),
+  url: z.string().min(1),
+  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  body: z.unknown().optional(),
+  timeout: z.number().int().positive().optional()
+});
+var JsTaskConfigSchema = z.object({
+  kind: z.literal("js"),
+  code: z.string().min(1),
+  timeout: z.number().int().positive().optional()
+});
+var TaskHandlerConfigSchema = z.discriminatedUnion("kind", [ApiTaskConfigSchema, JsTaskConfigSchema]);
+var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
+  constructor(db) {
+    super(db, {
+      table: SCHEDULER_TASK_TABLE,
+      idColumn: "id",
+      fields: [
+        { fieldName: "id", columnName: "id", def: { type: "INTEGER", primaryKey: true, autoIncrement: true }, select: true, create: false, update: false },
+        { fieldName: "taskId", columnName: "task_id", def: { type: "TEXT", notNull: true, unique: true }, select: true, create: true, update: false },
+        { fieldName: "taskName", columnName: "task_name", def: { type: "TEXT", notNull: true }, select: true, create: true, update: true },
+        { fieldName: "description", columnName: "description", def: { type: "TEXT" }, select: true, create: true, update: true },
+        { fieldName: "cron", columnName: "cron", def: { type: "TEXT", notNull: true }, select: true, create: true, update: true },
+        { fieldName: "enabled", columnName: "enabled", def: { type: "BOOLEAN", notNull: true, defaultValue: true }, select: true, create: true, update: true },
+        { fieldName: "deleteAfterRun", columnName: "delete_after_run", def: { type: "BOOLEAN", notNull: true, defaultValue: false }, select: true, create: true, update: true },
+        { fieldName: "retry", columnName: "retry", def: { type: "JSON" }, select: true, create: true, update: true },
+        { fieldName: "params", columnName: "params", def: { type: "JSON" }, select: true, create: true, update: true },
+        { fieldName: "handler", columnName: "handler", def: { type: "JSON" }, select: true, create: true, update: true },
+        { fieldName: "createdAt", columnName: "created_at", def: { type: "TIMESTAMP" }, select: true, create: true, update: false },
+        { fieldName: "updatedAt", columnName: "updated_at", def: { type: "TIMESTAMP" }, select: true, create: false, update: true }
+      ]
+    });
+  }
+  async saveTask(task) {
+    try {
+      const createResult = await this.create({
+        taskId: task.id,
+        taskName: task.name,
+        description: task.description ?? null,
+        cron: task.cron,
+        enabled: task.enabled !== false,
+        deleteAfterRun: task.deleteAfterRun === true,
+        retry: task.retry ?? null,
+        params: task.params ?? {},
+        handler: task.handler ?? null,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      if (!createResult.success) {
+        logger2.error("Failed to save task definition", { taskId: task.id, error: createResult.error.message });
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: createResult.error.message } }),
+          createResult.error
+        );
+      }
+      return ok(void 0);
+    } catch (error) {
+      logger2.error("Failed to save task definition", { taskId: task.id, error });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    }
+  }
+  async updateTask(taskId, updates) {
+    try {
+      const rows = await this.findAll({ where: "task_id = ?", params: [taskId], limit: 1 });
+      if (!rows.success) {
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: rows.error.message } }),
+          rows.error
+        );
+      }
+      if (rows.data.length === 0)
+        return ok(void 0);
+      const data = {};
+      if (updates.name !== void 0)
+        data.taskName = updates.name;
+      if (updates.description !== void 0)
+        data.description = updates.description ?? null;
+      if (updates.cron !== void 0)
+        data.cron = updates.cron;
+      if (updates.enabled !== void 0)
+        data.enabled = updates.enabled;
+      if (updates.deleteAfterRun !== void 0)
+        data.deleteAfterRun = updates.deleteAfterRun;
+      if (updates.retry !== void 0)
+        data.retry = updates.retry ?? null;
+      if (updates.params !== void 0)
+        data.params = updates.params;
+      if (updates.handler !== void 0)
+        data.handler = updates.handler ?? null;
+      data.updatedAt = /* @__PURE__ */ new Date();
+      if (Object.keys(data).length <= 1)
+        return ok(void 0);
+      const updateResult = await this.updateById(rows.data[0].id, data);
+      if (!updateResult.success) {
+        logger2.error("Failed to update task definition", { taskId, error: updateResult.error.message });
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: updateResult.error.message } }),
+          updateResult.error
+        );
+      }
+      return ok(void 0);
+    } catch (error) {
+      logger2.error("Failed to update task definition", { taskId, error });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    }
+  }
+  async deleteTask(taskId) {
+    try {
+      const rows = await this.findAll({ where: "task_id = ?", params: [taskId], limit: 1 });
+      if (!rows.success) {
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: rows.error.message } }),
+          rows.error
+        );
+      }
+      if (rows.data.length === 0)
+        return ok(void 0);
+      const deleteResult = await this.deleteById(rows.data[0].id);
+      if (!deleteResult.success) {
+        logger2.error("Failed to delete task definition", { taskId, error: deleteResult.error.message });
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: deleteResult.error.message } }),
+          deleteResult.error
+        );
+      }
+      return ok(void 0);
+    } catch (error) {
+      logger2.error("Failed to delete task definition", { taskId, error });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    }
+  }
+  async loadTasks() {
+    try {
+      const rows = await this.findAll({ orderBy: "id ASC" });
+      if (!rows.success) {
+        return err(
+          HaiSchedulerError.DB_SAVE_FAILED,
+          schedulerM("scheduler_dbSaveFailed", { params: { error: rows.error.message } }),
+          rows.error
+        );
+      }
+      const tasks = [];
+      for (const row of rows.data) {
+        const paramsResult = TaskParamsSchema.safeParse(row.params ?? {});
+        if (!paramsResult.success) {
+          logger2.warn("Skipping task with invalid params", { taskId: row.taskId, error: paramsResult.error.message });
+          continue;
+        }
+        const handlerResult = row.handler == null ? { success: true, data: void 0 } : TaskHandlerConfigSchema.safeParse(row.handler);
+        if (!handlerResult.success) {
+          logger2.warn("Skipping task with invalid handler config", { taskId: row.taskId, error: handlerResult.error.message });
+          continue;
+        }
+        const retryResult = row.retry == null ? { success: true, data: void 0 } : TaskRetryPolicySchema.safeParse(row.retry);
+        if (!retryResult.success) {
+          logger2.warn("Skipping task with invalid retry policy", { taskId: row.taskId, error: retryResult.error.message });
+          continue;
+        }
+        tasks.push({
+          id: row.taskId,
+          name: row.taskName,
+          ...row.description ? { description: row.description } : {},
+          cron: row.cron,
+          enabled: row.enabled,
+          deleteAfterRun: row.deleteAfterRun,
+          ...retryResult.data ? { retry: retryResult.data } : {},
+          params: paramsResult.data,
+          ...handlerResult.data ? { handler: handlerResult.data } : {}
+        });
+      }
+      return ok(tasks);
+    } catch (error) {
+      logger2.error("Failed to load task definitions", { error });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    }
+  }
+};
+var compiledHandlerCache = /* @__PURE__ */ new Map();
+function createCacheKey(config) {
+  const keySource = `${config.code}:${config.timeout ?? 0}`;
+  return createHash("sha256").update(keySource).digest("hex");
+}
+function clearJsTaskHandlerCache() {
+  compiledHandlerCache.clear();
+}
+function compileJsTaskHandler(config) {
+  const cacheKey = createCacheKey(config);
+  const cachedHandler = compiledHandlerCache.get(cacheKey);
+  if (cachedHandler)
+    return ok(cachedHandler);
+  try {
+    const script = new Script(`(${config.code})`);
+    const candidate = script.runInNewContext({});
+    if (typeof candidate !== "function") {
+      return err(
+        HaiSchedulerError.JS_COMPILE_FAILED,
+        schedulerM("scheduler_jsCompileFailed", { params: { error: "Compiled result is not a function" } })
+      );
+    }
+    const handler = async (context) => {
+      const functionResult = candidate(context);
+      if (!config.timeout || config.timeout <= 0)
+        return functionResult;
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error(`JS task timed out after ${config.timeout}ms`));
+        }, config.timeout);
+        Promise.resolve(functionResult).then(
+          (result) => {
+            clearTimeout(timer);
+            resolve(result);
+          },
+          (error) => {
+            clearTimeout(timer);
+            reject(error);
+          }
+        );
+      });
+    };
+    compiledHandlerCache.set(cacheKey, handler);
+    return ok(handler);
+  } catch (error) {
+    return err(
+      HaiSchedulerError.JS_COMPILE_FAILED,
+      schedulerM("scheduler_jsCompileFailed", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+
+// src/scheduler-executor.ts
+var logger3 = core.logger.child({ module: "scheduler", scope: "executor" });
+var currentLogRepo = null;
+var currentCleanupPolicy = {};
+function setLogRepository(repo, cleanupPolicy = {}) {
+  currentLogRepo = repo;
+  currentCleanupPolicy = { ...cleanupPolicy };
+}
+function sanitizeUrl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    if (parsedUrl.password)
+      parsedUrl.password = "***";
+    if (parsedUrl.username)
+      parsedUrl.username = "***";
+    return parsedUrl.toString();
+  } catch {
+    return "(invalid url)";
+  }
+}
+function resolveTaskType(task, hooks) {
+  if (task.handler)
+    return task.handler.kind;
+  if (hooks.onTaskExecute)
+    return "hook";
+  return "hook";
+}
+function createTaskContext(task, trigger) {
+  return {
+    task,
+    taskId: task.id,
+    params: task.params ?? {},
+    trigger
+  };
+}
+async function notifyTaskStart(hooks, event) {
+  if (!hooks.onTaskStart)
+    return;
+  try {
+    await hooks.onTaskStart(event);
+  } catch (error) {
+    logger3.warn("Task start hook failed", { taskId: event.task.id, error });
+  }
+}
+async function notifyTaskInterrupted(hooks, event) {
+  if (!hooks.onTaskInterrupted)
+    return;
+  try {
+    await hooks.onTaskInterrupted(event);
+  } catch (error) {
+    logger3.warn("Task interrupted hook failed", { taskId: event.task.id, error });
+  }
+}
+async function notifyTaskFinish(hooks, event) {
+  if (!hooks.onTaskFinish)
+    return;
+  try {
+    await hooks.onTaskFinish(event);
+  } catch (error) {
+    logger3.warn("Task finish hook failed", { taskId: event.task.id, error });
+  }
+}
+async function saveExecutionLog(task, trigger, taskType, status, startedAt, finishedAt, result, error) {
+  const log = {
+    id: 0,
+    taskId: task.id,
+    taskName: task.name,
+    taskType,
+    triggerType: trigger.type,
+    triggerSource: trigger.source,
+    status,
+    result,
+    error,
+    startedAt,
+    finishedAt,
+    duration: finishedAt - startedAt
+  };
+  if (!currentLogRepo)
+    return log;
+  await currentLogRepo.saveLog(log);
+  const cleanupResult = await currentLogRepo.cleanupLogs(currentCleanupPolicy);
+  if (!cleanupResult.success) {
+    logger3.warn("Failed to cleanup execution logs", {
+      taskId: task.id,
+      error: cleanupResult.error.message,
+      maxLogs: currentCleanupPolicy.maxLogs,
+      retentionDays: currentCleanupPolicy.retentionDays
+    });
+  }
+  return log;
+}
+async function saveInterruptedTaskLog(task, trigger, reason, taskType, startedAt, finishedAt) {
+  return saveExecutionLog(task, trigger, taskType, "interrupted", startedAt, finishedAt, null, reason);
+}
+async function interruptTask(task, trigger, reason, hooks) {
+  const startedAt = Date.now();
+  const taskType = resolveTaskType(task, hooks);
+  await notifyTaskStart(hooks, { task, trigger, startedAt });
+  const finishedAt = Date.now();
+  const interruptedLog = await saveInterruptedTaskLog(task, trigger, reason, taskType, startedAt, finishedAt);
+  await notifyTaskInterrupted(hooks, {
+    task,
+    trigger,
+    startedAt,
+    interruptedAt: finishedAt,
+    reason
+  });
+  return interruptedLog;
+}
+async function executeJsTask(task, context) {
+  const handler = task.handler;
+  if (!handler || handler.kind !== "js") {
+    return err(
+      HaiSchedulerError.EXECUTION_FAILED,
+      schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } })
+    );
+  }
+  const compileResult = compileJsTaskHandler(handler);
+  if (!compileResult.success)
+    return compileResult;
+  try {
+    const result = await compileResult.data(context);
+    return ok(result !== void 0 ? JSON.stringify(result) : null);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger3.error("JS task execution failed", { taskId: task.id, error: message });
+    return err(
+      HaiSchedulerError.JS_EXECUTION_FAILED,
+      schedulerM("scheduler_jsExecutionFailed", { params: { error: message } }),
+      error
+    );
+  }
+}
+async function executeApiTask(task, context) {
+  const handler = task.handler;
+  if (!handler || handler.kind !== "api") {
+    return err(
+      HaiSchedulerError.EXECUTION_FAILED,
+      schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } })
+    );
+  }
+  const { url, method = "GET", headers, body, timeout = 3e4 } = handler;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: {
+        ...headers,
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      signal: controller.signal,
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    clearTimeout(timer);
+    const responseText = await response.text();
+    if (!response.ok) {
+      logger3.error("API task returned non-OK status", {
+        taskId: context.taskId,
+        status: response.status,
+        url: sanitizeUrl(url)
+      });
+      return err(
+        HaiSchedulerError.API_EXECUTION_FAILED,
+        schedulerM("scheduler_apiExecutionFailed", {
+          params: { error: `HTTP ${response.status}: ${responseText.slice(0, 200)}` }
+        })
+      );
+    }
+    return ok(responseText || null);
+  } catch (error) {
+    clearTimeout(timer);
+    const message = error instanceof Error ? error.message : String(error);
+    logger3.error("API task execution failed", { taskId: context.taskId, error: message, url: sanitizeUrl(url) });
+    return err(
+      HaiSchedulerError.API_EXECUTION_FAILED,
+      schedulerM("scheduler_apiExecutionFailed", { params: { error: message } }),
+      error
+    );
+  }
+}
+async function executeHookTask(task, context, hooks, startedAt) {
+  if (!hooks.onTaskExecute) {
+    return err(
+      HaiSchedulerError.EXECUTION_FAILED,
+      schedulerM("scheduler_taskHandlerMissing", { params: { taskId: task.id } })
+    );
+  }
+  const executeEvent = {
+    task,
+    trigger: context.trigger,
+    startedAt,
+    context
+  };
+  try {
+    const result = await hooks.onTaskExecute(executeEvent);
+    return ok(result !== void 0 ? JSON.stringify(result) : null);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger3.error("Task execute hook failed", { taskId: task.id, error: message });
+    return err(
+      HaiSchedulerError.HOOK_EXECUTION_FAILED,
+      schedulerM("scheduler_hookExecutionFailed", { params: { error: message } }),
+      error
+    );
+  }
+}
+async function executeTask(task, trigger, hooks) {
+  const startedAt = Date.now();
+  const taskType = resolveTaskType(task, hooks);
+  const context = createTaskContext(task, trigger);
+  await notifyTaskStart(hooks, { task, trigger, startedAt });
+  let executionResult;
+  let shouldNotifyInterrupted = false;
+  if (!task.handler) {
+    executionResult = await executeHookTask(task, context, hooks, startedAt);
+    shouldNotifyInterrupted = !executionResult.success;
+  } else if (task.handler.kind === "api") {
+    executionResult = await executeApiTask(task, context);
+  } else {
+    executionResult = await executeJsTask(task, context);
+  }
+  const finishedAt = Date.now();
+  const status = executionResult.success ? "success" : shouldNotifyInterrupted ? "interrupted" : "failed";
+  const log = await saveExecutionLog(
+    task,
+    trigger,
+    taskType,
+    status,
+    startedAt,
+    finishedAt,
+    executionResult.success ? executionResult.data : null,
+    executionResult.success ? null : executionResult.error.message
+  );
+  if (!executionResult.success && shouldNotifyInterrupted) {
+    await notifyTaskInterrupted(hooks, {
+      task,
+      trigger,
+      startedAt,
+      interruptedAt: finishedAt,
+      reason: executionResult.error.message
+    });
+  }
+  if (status !== "interrupted")
+    await notifyTaskFinish(hooks, { task, trigger, startedAt, finishedAt, log });
+  return log;
+}
+function parseCronExpression(expression) {
+  try {
+    const cron = new Cron(expression, { legacyMode: false });
+    return ok(cron);
+  } catch {
+    return err(
+      HaiSchedulerError.INVALID_CRON,
+      schedulerM("scheduler_invalidCron", { params: { expression } })
+    );
+  }
+}
+
+// src/scheduler-functions.ts
+var logger4 = core.logger.child({ module: "scheduler", scope: "functions" });
+var taskRegistry = /* @__PURE__ */ new Map();
+var cronCache = /* @__PURE__ */ new Map();
+var currentHooks = {};
+function getTaskRegistry() {
+  return taskRegistry;
+}
+function getTask(taskId) {
+  return taskRegistry.get(taskId);
+}
+function hasTask(taskId) {
+  return taskRegistry.has(taskId);
+}
+function setTask(taskId, task) {
+  taskRegistry.set(taskId, task);
+}
+function deleteTask(taskId) {
+  taskRegistry.delete(taskId);
+}
+function getCron(taskId) {
+  return cronCache.get(taskId);
+}
+function setCron(taskId, cron) {
+  cronCache.set(taskId, cron);
+}
+function deleteCron(taskId) {
+  cronCache.delete(taskId);
+}
+function setHooks(hooks) {
+  currentHooks = { ...hooks };
+}
+function clearHooks() {
+  currentHooks = {};
+}
+function getHooks() {
+  return currentHooks;
+}
+function resetTaskState() {
+  taskRegistry.clear();
+  cronCache.clear();
+  currentHooks = {};
+}
+function normalizeTaskDescription(description) {
+  if (description === void 0)
+    return void 0;
+  const trimmed = description.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function validateRetryPolicy(taskId, retry) {
+  if (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1) {
+    return err(
+      HaiSchedulerError.EXECUTION_FAILED,
+      schedulerM("scheduler_invalidRetryConfig", { params: { taskId } })
+    );
+  }
+  if (retry.backoffMs !== void 0) {
+    const hasInvalidBackoff = retry.backoffMs.some((ms) => !Number.isInteger(ms) || ms < 0);
+    if (hasInvalidBackoff) {
+      return err(
+        HaiSchedulerError.EXECUTION_FAILED,
+        schedulerM("scheduler_invalidRetryConfig", { params: { taskId } })
+      );
+    }
+  }
+  return ok({
+    maxAttempts: retry.maxAttempts,
+    ...retry.backoffMs ? { backoffMs: [...retry.backoffMs] } : {}
+  });
+}
+async function loadPersistedTasks(taskRepo2) {
+  if (!taskRepo2)
+    return;
+  const loadResult = await taskRepo2.loadTasks();
+  if (!loadResult.success) {
+    logger4.warn("Failed to load persisted tasks", { error: loadResult.error.message });
+    return;
+  }
+  let loadedCount = 0;
+  for (const task of loadResult.data) {
+    const registerResult = await registerTask(task);
+    if (registerResult.success) {
+      loadedCount++;
+      logger4.debug("Loaded persisted task", { taskId: task.id, taskName: task.name });
+      continue;
+    }
+    logger4.warn("Failed to load persisted task", { taskId: task.id, error: registerResult.error.message });
+  }
+  if (loadedCount > 0)
+    logger4.info("Loaded persisted tasks", { count: loadedCount });
+}
+async function loadConfigTasks(tasks) {
+  let loadedCount = 0;
+  for (const task of tasks) {
+    if (!task.id) {
+      logger4.warn("Skipping config task with empty id");
+      continue;
+    }
+    if (hasTask(task.id)) {
+      logger4.debug("Skipping config task, already registered from DB", { taskId: task.id });
+      continue;
+    }
+    const registerResult = await registerTask(task);
+    if (registerResult.success) {
+      loadedCount++;
+      logger4.debug("Loaded config task", { taskId: task.id, taskName: task.name });
+      continue;
+    }
+    logger4.warn("Failed to load config task", { taskId: task.id, error: registerResult.error.message });
+  }
+  if (loadedCount > 0)
+    logger4.info("Loaded config tasks", { count: loadedCount });
+}
+async function registerTask(task, taskRepo2) {
+  if (!task.id) {
+    return err(
+      HaiSchedulerError.EXECUTION_FAILED,
+      schedulerM("scheduler_taskIdEmpty")
+    );
+  }
+  if (hasTask(task.id)) {
+    return err(
+      HaiSchedulerError.TASK_ALREADY_EXISTS,
+      schedulerM("scheduler_taskAlreadyExists", { params: { taskId: task.id } })
+    );
+  }
+  const cronResult = parseCronExpression(task.cron);
+  if (!cronResult.success)
+    return cronResult;
+  const retryResult = task.retry ? validateRetryPolicy(task.id, task.retry) : ok(void 0);
+  if (!retryResult.success)
+    return retryResult;
+  const normalizedTask = {
+    ...task,
+    description: normalizeTaskDescription(task.description),
+    enabled: task.enabled !== false,
+    deleteAfterRun: task.deleteAfterRun === true,
+    retry: retryResult.data,
+    params: task.params ?? {}
+  };
+  setTask(task.id, normalizedTask);
+  setCron(task.id, cronResult.data);
+  if (taskRepo2) {
+    const saveResult = await taskRepo2.saveTask(normalizedTask);
+    if (!saveResult.success) {
+      logger4.warn("Failed to persist task definition, rolling back in-memory registration", { taskId: task.id, error: saveResult.error.message });
+      deleteTask(task.id);
+      deleteCron(task.id);
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", { params: { error: saveResult.error.message } }),
+        saveResult.error
+      );
+    }
+  }
+  return ok(void 0);
+}
+async function unregisterTask(taskId, taskRepo2) {
+  if (!hasTask(taskId)) {
+    return err(
+      HaiSchedulerError.TASK_NOT_FOUND,
+      schedulerM("scheduler_taskNotFound", { params: { taskId } })
+    );
+  }
+  deleteTask(taskId);
+  deleteCron(taskId);
+  if (taskRepo2) {
+    const deleteResult = await taskRepo2.deleteTask(taskId);
+    if (!deleteResult.success) {
+      logger4.warn("Failed to delete persisted task definition", { taskId, error: deleteResult.error.message });
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", { params: { error: deleteResult.error.message } }),
+        deleteResult.error
+      );
+    }
+  }
+  return ok(void 0);
+}
+async function updateRegisteredTask(taskId, updates, taskRepo2) {
+  const existingTask = getTask(taskId);
+  if (!existingTask) {
+    return err(
+      HaiSchedulerError.TASK_NOT_FOUND,
+      schedulerM("scheduler_taskNotFound", { params: { taskId } })
+    );
+  }
+  const existingCron = getCron(taskId);
+  if (updates.cron !== void 0) {
+    const cronResult = parseCronExpression(updates.cron);
+    if (!cronResult.success)
+      return cronResult;
+    setCron(taskId, cronResult.data);
+  }
+  let normalizedRetry;
+  if (updates.retry !== void 0) {
+    if (updates.retry === null) {
+      normalizedRetry = null;
+    } else {
+      const retryResult = validateRetryPolicy(taskId, updates.retry);
+      if (!retryResult.success)
+        return retryResult;
+      normalizedRetry = retryResult.data;
+    }
+  }
+  const normalizedDescription = updates.description !== void 0 ? normalizeTaskDescription(updates.description) : void 0;
+  const normalizedUpdates = {
+    ...updates,
+    ...updates.description !== void 0 ? { description: normalizedDescription } : {},
+    ...updates.retry !== void 0 ? { retry: normalizedRetry } : {}
+  };
+  const updatedTask = {
+    ...existingTask,
+    ...normalizedUpdates.name !== void 0 ? { name: normalizedUpdates.name } : {},
+    ...normalizedUpdates.description !== void 0 ? { description: normalizedUpdates.description } : {},
+    ...normalizedUpdates.cron !== void 0 ? { cron: normalizedUpdates.cron } : {},
+    ...normalizedUpdates.enabled !== void 0 ? { enabled: normalizedUpdates.enabled } : {},
+    ...normalizedUpdates.deleteAfterRun !== void 0 ? { deleteAfterRun: normalizedUpdates.deleteAfterRun } : {},
+    ...normalizedUpdates.retry !== void 0 ? { retry: normalizedUpdates.retry ?? void 0 } : {},
+    ...normalizedUpdates.params !== void 0 ? { params: normalizedUpdates.params } : {},
+    ...normalizedUpdates.handler !== void 0 ? { handler: normalizedUpdates.handler ?? void 0 } : {}
+  };
+  setTask(taskId, updatedTask);
+  if (taskRepo2) {
+    const updateResult = await taskRepo2.updateTask(taskId, normalizedUpdates);
+    if (!updateResult.success) {
+      logger4.warn("Failed to update persisted task definition, rolling back in-memory update", { taskId, error: updateResult.error.message });
+      setTask(taskId, existingTask);
+      if (updates.cron !== void 0 && existingCron)
+        setCron(taskId, existingCron);
+      return err(
+        HaiSchedulerError.DB_SAVE_FAILED,
+        schedulerM("scheduler_dbSaveFailed", { params: { error: updateResult.error.message } }),
+        updateResult.error
+      );
+    }
+  }
+  return ok(void 0);
+}
+async function queryTaskLogs(logRepo2, options) {
+  if (!logRepo2) {
+    return err(
+      HaiSchedulerError.DB_SAVE_FAILED,
+      schedulerM("scheduler_dbNotInitialized")
+    );
+  }
+  return logRepo2.queryLogs(options);
+}
+var logger5 = core.logger.child({ module: "scheduler", scope: "runner" });
+var runningTasks = /* @__PURE__ */ new Set();
+var tickTimer = null;
+var lastTickMinute = -1;
+var currentNodeId = "";
+var currentLockTtlSec = 300;
+var currentTaskRepo = null;
+function configureLock(nodeId, lockTtlSec) {
+  currentNodeId = nodeId;
+  currentLockTtlSec = lockTtlSec;
+}
+function setTaskRepository(repo) {
+  currentTaskRepo = repo;
+}
+function isTaskRunning(taskId) {
+  return runningTasks.has(taskId);
+}
+function isTimerRunning() {
+  return tickTimer !== null;
+}
+function resetRunner() {
+  runningTasks.clear();
+  if (tickTimer) {
+    clearInterval(tickTimer);
+    tickTimer = null;
+  }
+  lastTickMinute = -1;
+  currentNodeId = "";
+  currentLockTtlSec = 300;
+  currentTaskRepo = null;
+}
+async function sleep(ms) {
+  if (ms <= 0)
+    return;
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveRetryBackoffMs(task, attempt) {
+  const backoff = task.retry?.backoffMs;
+  if (!backoff || backoff.length === 0)
+    return 0;
+  const index = Math.min(Math.max(attempt - 2, 0), backoff.length - 1);
+  return backoff[index] ?? 0;
+}
+function tick() {
+  const now = /* @__PURE__ */ new Date();
+  const currentMinute = Math.floor(now.getTime() / 6e4);
+  if (currentMinute === lastTickMinute)
+    return;
+  lastTickMinute = currentMinute;
+  for (const [taskId, task] of getTaskRegistry()) {
+    if (task.enabled === false)
+      continue;
+    const cron = getCron(taskId);
+    if (!cron || !cron.match(now))
+      continue;
+    if (runningTasks.has(taskId)) {
+      logger5.debug("Skipping task already running", { taskId, taskName: task.name });
+      continue;
+    }
+    void runTask(task, currentMinute, { type: "scheduled", source: null }).catch((error) => {
+      logger5.error("Unhandled task execution error", { taskId, error });
+    });
+  }
+}
+async function runTask(task, minuteTimestamp, trigger = { type: "manual", source: null }) {
+  const lockKey = minuteTimestamp !== void 0 ? `hai:scheduler:${task.id}:${minuteTimestamp}` : void 0;
+  if (cache.isInitialized && lockKey) {
+    const lockResult = await cache.lock.acquire(lockKey, { ttl: currentLockTtlSec, owner: currentNodeId });
+    if (!lockResult.success) {
+      logger5.warn("Failed to acquire distributed lock, interrupting task", { taskId: task.id, error: lockResult.error.message });
+      return interruptTask(
+        task,
+        trigger,
+        schedulerM("scheduler_lockAcquireFailed", { params: { taskId: task.id } }),
+        getHooks()
+      );
+    }
+    if (!lockResult.data) {
+      logger5.debug("Skipping task, another node holds the lock", { taskId: task.id, minuteTimestamp });
+      return interruptTask(
+        task,
+        trigger,
+        schedulerM("scheduler_lockAcquireFailed", { params: { taskId: task.id } }),
+        getHooks()
+      );
+    }
+  }
+  if (runningTasks.has(task.id)) {
+    return interruptTask(
+      task,
+      trigger,
+      schedulerM("scheduler_taskRunning", { params: { taskId: task.id } }),
+      getHooks()
+    );
+  }
+  runningTasks.add(task.id);
+  try {
+    const maxAttempts = Math.max(1, task.retry?.maxAttempts ?? 1);
+    let log = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      log = await executeTask(task, trigger, getHooks());
+      if (log.status !== "failed")
+        break;
+      if (attempt >= maxAttempts)
+        break;
+      const backoffMs = resolveRetryBackoffMs(task, attempt + 1);
+      logger5.warn("Retrying failed task execution", {
+        taskId: task.id,
+        attempt,
+        maxAttempts,
+        backoffMs
+      });
+      await sleep(backoffMs);
+    }
+    if (!log) {
+      return interruptTask(
+        task,
+        trigger,
+        schedulerM("scheduler_executionFailed", { params: { error: "Task execution produced no log" } }),
+        getHooks()
+      );
+    }
+    if (log.status === "failed")
+      logger5.warn("Task execution failed", { taskId: task.id, error: log.error });
+    else if (log.status === "interrupted")
+      logger5.debug("Task execution interrupted", { taskId: task.id, error: log.error });
+    else
+      logger5.debug("Task execution succeeded", { taskId: task.id, duration: log.duration });
+    if (task.deleteAfterRun === true) {
+      const unregisterResult = await unregisterTask(task.id, currentTaskRepo);
+      if (!unregisterResult.success) {
+        logger5.warn("Failed to auto-delete one-time task after run", {
+          taskId: task.id,
+          error: unregisterResult.error.message
+        });
+      } else {
+        logger5.info("Auto-deleted one-time task after run", { taskId: task.id });
+      }
+    }
+    return log;
+  } finally {
+    runningTasks.delete(task.id);
+  }
+}
+function startTimer(tickInterval) {
+  lastTickMinute = -1;
+  tickTimer = setInterval(() => tick(), tickInterval);
+}
+function stopTimer() {
+  if (!tickTimer)
+    return;
+  clearInterval(tickTimer);
+  tickTimer = null;
+}
+
+// src/scheduler-main.ts
+var logger6 = core.logger.child({ module: "scheduler", scope: "main" });
+var currentConfig = null;
+var initInProgress = false;
+var taskRepo = null;
+var logRepo = null;
+var notInitialized = core.module.createNotInitializedKit(
+  HaiSchedulerError.NOT_INITIALIZED,
+  () => schedulerM("scheduler_notInitialized")
+);
+async function initDatabase(parsed) {
+  if (!parsed.enableDb)
+    return parsed;
+  if (!reldb.isInitialized) {
+    logger6.error("enableDb is true but @h-ai/reldb is not initialized");
+    throw new Error(schedulerM("scheduler_reldbNotInitialized"));
+  }
+  taskRepo = new SchedulerTaskRepository(reldb);
+  logRepo = new SchedulerLogRepository(reldb);
+  setTaskRepository(taskRepo);
+  setLogRepository(logRepo, {
+    maxLogs: parsed.maxLogs,
+    retentionDays: parsed.retentionDays
+  });
+  const nodeId = parsed.nodeId ?? crypto.randomUUID();
+  const lockTtlSec = Math.ceil(parsed.lockExpireMs / 1e3);
+  configureLock(nodeId, lockTtlSec);
+  if (cache.isInitialized)
+    logger6.info("Distributed lock configured (cache-based)", { nodeId, lockTtlSec });
+  else
+    logger6.warn("Cache module not initialized, distributed lock will be enabled when cache becomes available");
+  return { ...parsed, nodeId };
+}
+function normalizeTriggerInput(options) {
+  return {
+    type: "manual",
+    source: options?.source ?? null
+  };
+}
+var scheduler = {
+  async init(config) {
+    if (initInProgress) {
+      logger6.warn("Scheduler init already in progress, skipping concurrent call");
+      return err(
+        HaiSchedulerError.INIT_FAILED,
+        schedulerM("scheduler_initFailed", { params: { error: "Concurrent initialization detected" } })
+      );
+    }
+    initInProgress = true;
+    try {
+      if (currentConfig) {
+        logger6.warn("Scheduler module is already initialized, reinitializing");
+        await scheduler.close();
+      }
+      logger6.info("Initializing scheduler module");
+      const { tasks = [], hooks = {}, ...configOptions } = config ?? {};
+      const parseResult = SchedulerConfigSchema.safeParse(configOptions);
+      if (!parseResult.success) {
+        logger6.error("Scheduler config validation failed", { error: parseResult.error.message });
+        return err(
+          HaiSchedulerError.CONFIG_ERROR,
+          schedulerM("scheduler_configError", { params: { error: parseResult.error.message } }),
+          parseResult.error
+        );
+      }
+      try {
+        currentConfig = await initDatabase(parseResult.data);
+        setHooks(hooks);
+        await loadPersistedTasks(taskRepo);
+        if (tasks.length > 0)
+          await loadConfigTasks(tasks);
+        logger6.info("Scheduler module initialized", { enableDb: currentConfig.enableDb, taskCount: getTaskRegistry().size });
+        return ok(void 0);
+      } catch (error) {
+        logger6.error("Scheduler initialization failed", { error });
+        await scheduler.close();
+        return err(
+          HaiSchedulerError.INIT_FAILED,
+          schedulerM("scheduler_initFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    } finally {
+      initInProgress = false;
+    }
+  },
+  async register(task) {
+    if (!currentConfig)
+      return notInitialized.result();
+    const registerResult = await registerTask(task, taskRepo);
+    if (registerResult.success) {
+      logger6.info("Task registered", { taskId: task.id, taskName: task.name, cron: task.cron });
+    }
+    return registerResult;
+  },
+  async unregister(taskId) {
+    if (!currentConfig)
+      return notInitialized.result();
+    const unregisterResult = await unregisterTask(taskId, taskRepo);
+    if (unregisterResult.success)
+      logger6.info("Task unregistered", { taskId });
+    return unregisterResult;
+  },
+  async updateTask(taskId, updates) {
+    if (!currentConfig)
+      return notInitialized.result();
+    const updateResult = await updateRegisteredTask(taskId, updates, taskRepo);
+    if (updateResult.success)
+      logger6.info("Task updated", { taskId, updates: Object.keys(updates) });
+    return updateResult;
+  },
+  start() {
+    if (!currentConfig)
+      return notInitialized.result();
+    if (isTimerRunning()) {
+      return err(
+        HaiSchedulerError.ALREADY_RUNNING,
+        schedulerM("scheduler_alreadyRunning")
+      );
+    }
+    startTimer(currentConfig.tickInterval);
+    logger6.info("Scheduler started", { tickInterval: currentConfig.tickInterval });
+    return ok(void 0);
+  },
+  stop() {
+    if (!currentConfig)
+      return notInitialized.result();
+    if (!isTimerRunning()) {
+      return err(
+        HaiSchedulerError.NOT_RUNNING,
+        schedulerM("scheduler_notRunning")
+      );
+    }
+    stopTimer();
+    logger6.info("Scheduler stopped");
+    return ok(void 0);
+  },
+  async trigger(taskId, options) {
+    if (!currentConfig)
+      return notInitialized.result();
+    const task = getTask(taskId);
+    if (!task) {
+      return err(
+        HaiSchedulerError.TASK_NOT_FOUND,
+        schedulerM("scheduler_taskNotFound", { params: { taskId } })
+      );
+    }
+    if (isTaskRunning(taskId)) {
+      return err(
+        HaiSchedulerError.EXECUTION_FAILED,
+        schedulerM("scheduler_taskRunning", { params: { taskId } })
+      );
+    }
+    const log = await runTask(task, void 0, normalizeTriggerInput(options));
+    return ok(log);
+  },
+  async getLogs(options) {
+    if (!currentConfig)
+      return notInitialized.result();
+    return queryTaskLogs(logRepo, options);
+  },
+  setHooks(hooks) {
+    if (!currentConfig)
+      return notInitialized.result();
+    setHooks(hooks);
+    return ok(void 0);
+  },
+  clearHooks() {
+    if (!currentConfig)
+      return notInitialized.result();
+    clearHooks();
+    return ok(void 0);
+  },
+  get tasks() {
+    return getTaskRegistry();
+  },
+  get config() {
+    return currentConfig;
+  },
+  get hooks() {
+    return getHooks();
+  },
+  get isInitialized() {
+    return currentConfig !== null;
+  },
+  get isRunning() {
+    return isTimerRunning();
+  },
+  async close() {
+    if (!currentConfig) {
+      logger6.info("Scheduler module already closed, skipping");
+      return;
+    }
+    logger6.info("Closing scheduler module");
+    stopTimer();
+    clearJsTaskHandlerCache();
+    resetTaskState();
+    resetRunner();
+    setLogRepository(null);
+    setTaskRepository(null);
+    currentConfig = null;
+    taskRepo = null;
+    logRepo = null;
+    logger6.info("Scheduler module closed");
+  }
+};
+
+export { HaiSchedulerError, SchedulerConfigSchema, scheduler };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map