@h-ai/reach 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,1324 @@
+import { z } from 'zod';
+import { core, err, ok } from '@h-ai/core';
+import { randomUUID, createHmac } from 'crypto';
+import { createRequire } from 'module';
+import { cache } from '@h-ai/cache';
+import { BaseReldbCrudRepository } from '@h-ai/reldb';
+
+// src/reach-config.ts
+
+// messages/en-US.json
+var en_US_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  reach_notInitialized: "Reach module not initialized, call reach.init() first",
+  reach_initFailed: "Reach module initialization failed: {error}",
+  reach_unsupportedType: "Unsupported reach type: {type}",
+  reach_sendFailed: "Send failed: {error}",
+  reach_templateNotFound: "Template not found: {template}",
+  reach_templateRenderFailed: "Template render failed: {error}",
+  reach_invalidRecipient: "Invalid recipient: {recipient}",
+  reach_providerNotFound: "Provider not found: {provider}",
+  reach_providerRequired: "No provider specified, set provider field in message or template",
+  reach_dndBlocked: "Message discarded by Do Not Disturb period",
+  reach_dndDeferred: "Message deferred by Do Not Disturb period, will be sent after DND ends",
+  reach_smsSendFailed: "SMS send failed: {error}",
+  reach_emailSendFailed: "Email send failed: {error}",
+  reach_apiSendFailed: "API callback send failed: {error}",
+  reach_configError: "Reach config validation failed: {error}",
+  reach_config_nameRequired: "Provider name is required",
+  reach_config_hostRequired: "SMTP host is required",
+  reach_config_fromRequired: "Sender address (from) is required",
+  reach_config_accessKeyIdRequired: "AccessKey ID is required",
+  reach_config_accessKeySecretRequired: "AccessKey Secret is required",
+  reach_config_signNameRequired: "SMS sign name is required",
+  reach_config_urlRequired: "Callback URL is required",
+  reach_config_dndTimeInvalid: "Invalid time format, must be HH:mm (24-hour)",
+  reach_config_templateNameRequired: "Template name is required",
+  reach_config_templateProviderRequired: "Template provider is required",
+  reach_config_templateBodyRequired: "Template body is required",
+  reach_config_providersRequired: "At least one provider is required",
+  reach_templateDbInitFailed: "Template database initialization failed: {error}",
+  reach_templateSaveFailed: "Template save failed: {error}",
+  reach_templateDeleteFailed: "Template delete failed: {error}"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  reach_notInitialized: "\u89E6\u8FBE\u6A21\u5757\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 reach.init()",
+  reach_initFailed: "\u89E6\u8FBE\u6A21\u5757\u521D\u59CB\u5316\u5931\u8D25: {error}",
+  reach_unsupportedType: "\u4E0D\u652F\u6301\u7684\u89E6\u8FBE\u7C7B\u578B: {type}",
+  reach_sendFailed: "\u53D1\u9001\u5931\u8D25: {error}",
+  reach_templateNotFound: "\u6A21\u677F\u672A\u627E\u5230: {template}",
+  reach_templateRenderFailed: "\u6A21\u677F\u6E32\u67D3\u5931\u8D25: {error}",
+  reach_invalidRecipient: "\u65E0\u6548\u7684\u63A5\u6536\u65B9: {recipient}",
+  reach_providerNotFound: "Provider \u672A\u627E\u5230: {provider}",
+  reach_providerRequired: "\u672A\u6307\u5B9A Provider\uFF0C\u8BF7\u5728\u6D88\u606F\u6216\u6A21\u677F\u4E2D\u8BBE\u7F6E provider \u5B57\u6BB5",
+  reach_dndBlocked: "\u5F53\u524D\u5904\u4E8E\u514D\u6253\u6270\u65F6\u6BB5\uFF0C\u6D88\u606F\u5DF2\u4E22\u5F03",
+  reach_dndDeferred: "\u5F53\u524D\u5904\u4E8E\u514D\u6253\u6270\u65F6\u6BB5\uFF0C\u6D88\u606F\u5DF2\u6682\u5B58\u5F85\u53D1\u9001",
+  reach_smsSendFailed: "\u77ED\u4FE1\u53D1\u9001\u5931\u8D25: {error}",
+  reach_emailSendFailed: "\u90AE\u4EF6\u53D1\u9001\u5931\u8D25: {error}",
+  reach_apiSendFailed: "API \u56DE\u8C03\u53D1\u9001\u5931\u8D25: {error}",
+  reach_configError: "\u89E6\u8FBE\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A{error}",
+  reach_config_nameRequired: "Provider \u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_hostRequired: "SMTP \u670D\u52A1\u5668\u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_fromRequired: "\u53D1\u4EF6\u4EBA\u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_accessKeyIdRequired: "AccessKey ID \u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_accessKeySecretRequired: "AccessKey Secret \u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_signNameRequired: "\u77ED\u4FE1\u7B7E\u540D\u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_urlRequired: "\u56DE\u8C03 URL \u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_dndTimeInvalid: "\u65F6\u95F4\u683C\u5F0F\u65E0\u6548\uFF0C\u987B\u4E3A HH:mm\uFF0824 \u5C0F\u65F6\u5236\uFF09",
+  reach_config_templateNameRequired: "\u6A21\u677F\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_templateProviderRequired: "\u6A21\u677F\u7ED1\u5B9A\u7684 Provider \u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_templateBodyRequired: "\u6A21\u677F\u6B63\u6587\u4E0D\u80FD\u4E3A\u7A7A",
+  reach_config_providersRequired: "\u81F3\u5C11\u9700\u8981\u914D\u7F6E\u4E00\u4E2A Provider",
+  reach_templateDbInitFailed: "\u6A21\u677F\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25: {error}",
+  reach_templateSaveFailed: "\u6A21\u677F\u4FDD\u5B58\u5931\u8D25: {error}",
+  reach_templateDeleteFailed: "\u6A21\u677F\u5220\u9664\u5931\u8D25: {error}"
+};
+
+// src/reach-i18n.ts
+var reachM = core.i18n.createMessageGetter({
+  "zh-CN": zh_CN_default,
+  "en-US": en_US_default
+});
+
+// src/reach-config.ts
+var ConsoleProviderConfigSchema = z.object({
+  /** Provider 唯一名称 */
+  name: z.string().min(1, reachM("reach_config_nameRequired")),
+  type: z.literal("console")
+});
+var SmtpProviderConfigSchema = z.object({
+  /** Provider 唯一名称 */
+  name: z.string().min(1, reachM("reach_config_nameRequired")),
+  type: z.literal("smtp"),
+  /** SMTP 服务器地址 */
+  host: z.string().min(1, reachM("reach_config_hostRequired")),
+  /** SMTP 端口（默认 465） */
+  port: z.number().int().min(1).max(65535).default(465),
+  /** 是否使用 TLS（默认 true） */
+  secure: z.boolean().default(true),
+  /** SMTP 认证用户名 */
+  user: z.string().optional(),
+  /** SMTP 认证密码 */
+  pass: z.string().optional(),
+  /** 发件人地址 */
+  from: z.string().min(1, reachM("reach_config_fromRequired"))
+});
+var AliyunSmsProviderConfigSchema = z.object({
+  /** Provider 唯一名称 */
+  name: z.string().min(1, reachM("reach_config_nameRequired")),
+  type: z.literal("aliyun-sms"),
+  /** 阿里云 AccessKey ID */
+  accessKeyId: z.string().min(1, reachM("reach_config_accessKeyIdRequired")),
+  /** 阿里云 AccessKey Secret */
+  accessKeySecret: z.string().min(1, reachM("reach_config_accessKeySecretRequired")),
+  /** 短信签名 */
+  signName: z.string().min(1, reachM("reach_config_signNameRequired")),
+  /** API 端点（默认 dysmsapi.aliyuncs.com） */
+  endpoint: z.string().default("dysmsapi.aliyuncs.com")
+});
+var ApiProviderConfigSchema = z.object({
+  /** Provider 唯一名称 */
+  name: z.string().min(1, reachM("reach_config_nameRequired")),
+  type: z.literal("api"),
+  /** 回调 URL */
+  url: z.string().min(1, reachM("reach_config_urlRequired")),
+  /** HTTP 方法（默认 POST） */
+  method: z.enum(["POST", "PUT"]).default("POST"),
+  /** 自定义请求头 */
+  headers: z.record(z.string(), z.string()).optional(),
+  /** 请求超时毫秒数（默认 10000） */
+  timeout: z.number().int().min(0).default(1e4)
+});
+var ProviderConfigSchema = z.discriminatedUnion("type", [
+  ConsoleProviderConfigSchema,
+  SmtpProviderConfigSchema,
+  AliyunSmsProviderConfigSchema,
+  ApiProviderConfigSchema
+]);
+var DndConfigSchema = z.object({
+  /** 是否启用免打扰（默认 false） */
+  enabled: z.boolean().default(false),
+  /** 免打扰策略：discard 丢弃 / delay 延时发送（默认 discard） */
+  strategy: z.enum(["discard", "delay"]).default("discard"),
+  /** 免打扰开始时间（HH:mm 格式） */
+  start: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, reachM("reach_config_dndTimeInvalid")).default("00:00"),
+  /** 免打扰结束时间（HH:mm 格式） */
+  end: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, reachM("reach_config_dndTimeInvalid")).default("00:00")
+});
+var TemplateConfigSchema = z.object({
+  /** 模板名称 */
+  name: z.string().min(1, reachM("reach_config_templateNameRequired")),
+  /** 绑定的 Provider 名称 */
+  provider: z.string().min(1, reachM("reach_config_templateProviderRequired")),
+  /** 邮件主题模板 */
+  subject: z.string().optional(),
+  /** 正文模板 */
+  body: z.string().min(1, reachM("reach_config_templateBodyRequired"))
+});
+var ReachConfigSchema = z.object({
+  /** Provider 配置列表 */
+  providers: z.array(ProviderConfigSchema).min(1, reachM("reach_config_providersRequired")),
+  /** 模板配置（通过配置文件注册） */
+  templates: z.array(TemplateConfigSchema).optional(),
+  /** 免打扰配置 */
+  dnd: DndConfigSchema.optional()
+});
+var ReachErrorInfo = {
+  SEND_FAILED: "001:500",
+  TEMPLATE_NOT_FOUND: "002:404",
+  TEMPLATE_RENDER_FAILED: "003:500",
+  INVALID_RECIPIENT: "004:400",
+  PROVIDER_NOT_FOUND: "005:500",
+  DND_BLOCKED: "006:403",
+  DND_DEFERRED: "007:202",
+  NOT_INITIALIZED: "010:500",
+  UNSUPPORTED_TYPE: "011:400",
+  CONFIG_ERROR: "012:500"
+};
+var HaiReachError = core.error.buildHaiErrorsDef("reach", ReachErrorInfo);
+
+// src/providers/reach-provider-aliyun-sms.ts
+var logger = core.logger.child({ module: "reach", scope: "provider-aliyun-sms" });
+function toReachError(error) {
+  return {
+    code: HaiReachError.SEND_FAILED.code,
+    message: reachM("reach_smsSendFailed", {
+      params: { error: error instanceof Error ? error.message : String(error) }
+    }),
+    cause: error
+  };
+}
+function percentEncode(str) {
+  return encodeURIComponent(str).replace(/\+/g, "%20").replace(/\*/g, "%2A").replace(/~/g, "%7E");
+}
+function signRequest(params, accessKeySecret, method) {
+  const sortedKeys = Object.keys(params).sort();
+  const canonicalQuery = sortedKeys.map((k) => `${percentEncode(k)}=${percentEncode(params[k])}`).join("&");
+  const stringToSign = `${method}&${percentEncode("/")}&${percentEncode(canonicalQuery)}`;
+  const hmac = createHmac("sha1", `${accessKeySecret}&`);
+  hmac.update(stringToSign);
+  return hmac.digest("base64");
+}
+function createAliyunSmsProvider() {
+  let smsConfig = null;
+  return {
+    name: "aliyun-sms",
+    async connect(config) {
+      if (config.type !== "aliyun-sms") {
+        return err(
+          HaiReachError.CONFIG_ERROR,
+          reachM("reach_unsupportedType", { params: { type: config.type } })
+        );
+      }
+      smsConfig = config;
+      logger.info("Aliyun SMS provider connected", { endpoint: config.endpoint });
+      return ok(void 0);
+    },
+    async close() {
+      smsConfig = null;
+      logger.info("Aliyun SMS provider disconnected");
+    },
+    isConnected() {
+      return smsConfig !== null;
+    },
+    async send(message) {
+      if (!smsConfig) {
+        return err(
+          HaiReachError.NOT_INITIALIZED,
+          reachM("reach_notInitialized")
+        );
+      }
+      const templateCode = message.extra?.templateCode;
+      logger.debug("Sending SMS", { to: message.to, templateCode });
+      try {
+        const params = {
+          AccessKeyId: smsConfig.accessKeyId,
+          Action: "SendSms",
+          Format: "JSON",
+          PhoneNumbers: message.to,
+          SignName: smsConfig.signName,
+          SignatureMethod: "HMAC-SHA1",
+          SignatureNonce: randomUUID(),
+          SignatureVersion: "1.0",
+          TemplateCode: templateCode ?? "",
+          Timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+          Version: "2017-05-25"
+        };
+        if (message.vars) {
+          params.TemplateParam = JSON.stringify(message.vars);
+        }
+        params.Signature = signRequest(params, smsConfig.accessKeySecret, "GET");
+        const queryString = Object.entries(params).map(([k, v]) => `${percentEncode(k)}=${percentEncode(v)}`).join("&");
+        const url = `https://${smsConfig.endpoint}/?${queryString}`;
+        const response = await fetch(url);
+        const body = await response.json();
+        if (body.Code !== "OK") {
+          logger.warn("SMS send returned non-OK status", { code: body.Code, message: body.Message });
+          return err(
+            HaiReachError.SEND_FAILED,
+            reachM("reach_smsSendFailed", { params: { error: body.Message } })
+          );
+        }
+        logger.info("SMS sent", { to: message.to, bizId: body.BizId });
+        return ok({ success: true, messageId: body.BizId });
+      } catch (error) {
+        logger.error("SMS send failed", { to: message.to, error });
+        return err(toReachError(error));
+      }
+    }
+  };
+}
+var logger2 = core.logger.child({ module: "reach", scope: "provider-api" });
+function toReachError2(error) {
+  return {
+    code: HaiReachError.SEND_FAILED.code,
+    message: reachM("reach_apiSendFailed", {
+      params: { error: error instanceof Error ? error.message : String(error) }
+    }),
+    cause: error
+  };
+}
+function createApiProvider() {
+  let apiConfig = null;
+  return {
+    name: "api",
+    async connect(config) {
+      if (config.type !== "api") {
+        return err(
+          HaiReachError.CONFIG_ERROR,
+          reachM("reach_unsupportedType", { params: { type: config.type } })
+        );
+      }
+      apiConfig = config;
+      logger2.info("API provider connected", { url: config.url, method: config.method });
+      return ok(void 0);
+    },
+    async close() {
+      apiConfig = null;
+      logger2.info("API provider disconnected");
+    },
+    isConnected() {
+      return apiConfig !== null;
+    },
+    async send(message) {
+      if (!apiConfig) {
+        return err(
+          HaiReachError.NOT_INITIALIZED,
+          reachM("reach_notInitialized")
+        );
+      }
+      logger2.debug("Sending via API callback", { url: apiConfig.url, to: message.to });
+      try {
+        const payload = {
+          to: message.to,
+          subject: message.subject,
+          body: message.body,
+          template: message.template,
+          vars: message.vars,
+          extra: message.extra
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), apiConfig.timeout);
+        try {
+          const response = await fetch(apiConfig.url, {
+            method: apiConfig.method,
+            headers: {
+              "Content-Type": "application/json",
+              ...apiConfig.headers
+            },
+            body: JSON.stringify(payload),
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const text = await response.text();
+            logger2.warn("API callback returned non-OK status", { status: response.status, body: text });
+            return err(
+              HaiReachError.SEND_FAILED,
+              reachM("reach_apiSendFailed", { params: { error: `HTTP ${response.status}: ${text}` } })
+            );
+          }
+          const result = await response.json();
+          logger2.info("API callback sent", { to: message.to, messageId: result.messageId });
+          return ok({ success: true, messageId: result.messageId });
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      } catch (error) {
+        logger2.error("API callback send failed", { to: message.to, error });
+        return err(toReachError2(error));
+      }
+    }
+  };
+}
+var logger3 = core.logger.child({ module: "reach", scope: "provider-console" });
+function createConsoleProvider() {
+  let connected = false;
+  return {
+    name: "console",
+    async connect(_config) {
+      connected = true;
+      logger3.info("Console provider connected");
+      return ok(void 0);
+    },
+    async close() {
+      connected = false;
+      logger3.info("Console provider disconnected");
+    },
+    isConnected() {
+      return connected;
+    },
+    async send(message) {
+      logger3.debug("Sending message via console", {
+        provider: message.provider,
+        to: message.to,
+        subject: message.subject,
+        body: message.body,
+        template: message.template,
+        vars: message.vars,
+        extra: message.extra
+      });
+      const messageId = `console-${Date.now()}`;
+      return ok({ success: true, messageId });
+    }
+  };
+}
+var logger4 = core.logger.child({ module: "reach", scope: "provider-smtp" });
+function toReachError3(error) {
+  return {
+    code: HaiReachError.SEND_FAILED.code,
+    message: reachM("reach_emailSendFailed", {
+      params: { error: error instanceof Error ? error.message : String(error) }
+    }),
+    cause: error
+  };
+}
+function createSmtpProvider() {
+  let transporter = null;
+  let smtpConfig = null;
+  return {
+    name: "smtp",
+    async connect(config) {
+      if (config.type !== "smtp") {
+        return err(
+          HaiReachError.CONFIG_ERROR,
+          reachM("reach_unsupportedType", { params: { type: config.type } })
+        );
+      }
+      try {
+        const require2 = createRequire(import.meta.url);
+        const nodemailer = require2("nodemailer");
+        smtpConfig = config;
+        transporter = nodemailer.createTransport({
+          host: config.host,
+          port: config.port,
+          secure: config.secure,
+          auth: config.user ? { user: config.user, pass: config.pass } : void 0
+        });
+        logger4.info("SMTP provider connected", { host: config.host, port: config.port });
+        return ok(void 0);
+      } catch (error) {
+        logger4.error("SMTP connection failed", { error });
+        return err(toReachError3(error));
+      }
+    },
+    async close() {
+      if (transporter && typeof transporter.close === "function") {
+        transporter.close();
+      }
+      transporter = null;
+      smtpConfig = null;
+      logger4.info("SMTP provider disconnected");
+    },
+    isConnected() {
+      return transporter !== null;
+    },
+    async send(message) {
+      if (!transporter || !smtpConfig) {
+        return err(
+          HaiReachError.NOT_INITIALIZED,
+          reachM("reach_notInitialized")
+        );
+      }
+      logger4.debug("Sending email", { to: message.to, subject: message.subject });
+      try {
+        const sendMail = transporter.sendMail.bind(transporter);
+        const info = await sendMail({
+          from: smtpConfig.from,
+          to: message.to,
+          subject: message.subject ?? "",
+          html: message.body ?? ""
+        });
+        logger4.info("Email sent", { to: message.to, messageId: info.messageId });
+        return ok({ success: true, messageId: info.messageId });
+      } catch (error) {
+        logger4.error("Email send failed", { to: message.to, error });
+        return err(toReachError3(error));
+      }
+    }
+  };
+}
+var logger5 = core.logger.child({ module: "reach", scope: "send" });
+var reachNodeId = `reach:${crypto.randomUUID()}`;
+function parseTimeToMinutes(time) {
+  const [h, m] = time.split(":").map(Number);
+  return h * 60 + m;
+}
+function isDndBlocked(dnd, now = /* @__PURE__ */ new Date()) {
+  if (!dnd?.enabled) {
+    return false;
+  }
+  const startMin = parseTimeToMinutes(dnd.start);
+  const endMin = parseTimeToMinutes(dnd.end);
+  const currentMin = now.getHours() * 60 + now.getMinutes();
+  if (startMin === endMin) {
+    return false;
+  }
+  if (startMin < endMin) {
+    return currentMin >= startMin && currentMin < endMin;
+  }
+  return currentMin >= startMin || currentMin < endMin;
+}
+function msUntilDndEnd(dnd, now = /* @__PURE__ */ new Date()) {
+  const endMin = parseTimeToMinutes(dnd.end);
+  const currentMin = now.getHours() * 60 + now.getMinutes();
+  const currentSec = now.getSeconds();
+  let diffMin = endMin - currentMin;
+  if (diffMin <= 0) {
+    diffMin += 24 * 60;
+  }
+  return diffMin * 60 * 1e3 - currentSec * 1e3;
+}
+async function preprocessMessage(message, templateRegistry2) {
+  if (!message.template) {
+    return ok(message);
+  }
+  const rendered = await templateRegistry2.render(message.template, message.vars ?? {});
+  if (!rendered.success) {
+    return rendered;
+  }
+  const template = await templateRegistry2.resolve(message.template);
+  const processed = {
+    ...message,
+    provider: message.provider || (template.success ? template.data.provider : "") || "",
+    subject: message.subject ?? rendered.data.subject,
+    body: message.body ?? rendered.data.body
+  };
+  return ok(processed);
+}
+async function saveSendRecord(repo, message, status, provider, messageId) {
+  if (!repo) {
+    return;
+  }
+  try {
+    await repo.create({
+      provider,
+      toAddr: message.to,
+      subject: message.subject ?? null,
+      body: message.body ?? null,
+      template: message.template ?? null,
+      varsJson: message.vars ? JSON.stringify(message.vars) : null,
+      extraJson: message.extra ? JSON.stringify(message.extra) : null,
+      status,
+      messageId: messageId ?? null,
+      createdAt: Date.now()
+    });
+  } catch {
+    logger5.debug("Send record not saved (db module unavailable)");
+  }
+}
+var dndTimer = null;
+var schedulerContext = null;
+function startDndScheduler(dndConfig2, providers2, repo) {
+  stopDndScheduler();
+  if (!dndConfig2.enabled || dndConfig2.strategy !== "delay") {
+    return;
+  }
+  schedulerContext = { dndConfig: dndConfig2, providers: providers2, repo };
+  if (!isDndBlocked(dndConfig2)) {
+    flushPendingMessages(providers2, repo).catch((error) => {
+      logger5.warn("Failed to flush pending messages on init", { error });
+    });
+    scheduleDndCheck();
+    return;
+  }
+  scheduleFlushAtDndEnd();
+}
+function scheduleFlushAtDndEnd() {
+  if (!schedulerContext)
+    return;
+  const { dndConfig: dndConfig2, providers: providers2, repo } = schedulerContext;
+  const delayMs = msUntilDndEnd(dndConfig2);
+  logger5.info("DND scheduler started", { delayMs, dndEnd: dndConfig2.end });
+  dndTimer = setTimeout(() => {
+    logger5.info("DND period ended, flushing pending messages");
+    flushPendingMessages(providers2, repo).catch((error) => {
+      logger5.error("Failed to flush pending messages", { error });
+    }).finally(() => {
+      scheduleDndCheck();
+    });
+  }, delayMs);
+}
+function scheduleDndCheck() {
+  if (!schedulerContext)
+    return;
+  const { dndConfig: dndConfig2 } = schedulerContext;
+  const CHECK_INTERVAL = 60 * 1e3;
+  dndTimer = setTimeout(() => {
+    if (!schedulerContext)
+      return;
+    if (isDndBlocked(dndConfig2)) {
+      scheduleFlushAtDndEnd();
+    } else {
+      scheduleDndCheck();
+    }
+  }, CHECK_INTERVAL);
+}
+function stopDndScheduler() {
+  if (dndTimer !== null) {
+    clearTimeout(dndTimer);
+    dndTimer = null;
+  }
+}
+function resetSendState() {
+  stopDndScheduler();
+  schedulerContext = null;
+}
+async function flushPendingMessages(providers2, repo) {
+  if (!repo) {
+    return;
+  }
+  const FLUSH_LOCK_KEY = "hai:reach:flush-pending";
+  const FLUSH_LOCK_TTL = 60;
+  let lockAcquired = false;
+  if (cache.isInitialized) {
+    const lockResult = await cache.lock.acquire(FLUSH_LOCK_KEY, { ttl: FLUSH_LOCK_TTL, owner: reachNodeId });
+    if (lockResult.success && !lockResult.data) {
+      logger5.info("Skipping flush, another node holds the lock");
+      return;
+    }
+    lockAcquired = lockResult.success && lockResult.data;
+  }
+  try {
+    const result = await repo.findPending();
+    if (!result.success || !result.data.length) {
+      return;
+    }
+    logger5.info("Flushing pending messages", { count: result.data.length });
+    for (const row of result.data) {
+      const provider = providers2.get(row.provider);
+      if (!provider) {
+        logger5.warn("Provider not found for pending message, skipping", { provider: row.provider, id: row.id });
+        continue;
+      }
+      let vars;
+      let extra;
+      try {
+        vars = row.varsJson ? JSON.parse(row.varsJson) : void 0;
+        extra = row.extraJson ? JSON.parse(row.extraJson) : void 0;
+      } catch {
+        logger5.warn("Failed to parse pending message JSON, skipping", { id: row.id });
+        continue;
+      }
+      const message = {
+        provider: row.provider,
+        to: row.toAddr,
+        subject: row.subject ?? void 0,
+        body: row.body ?? void 0,
+        template: row.template ?? void 0,
+        vars,
+        extra
+      };
+      const sendResult = await provider.send(message);
+      if (sendResult.success) {
+        await repo.markSent(row.id, sendResult.data.messageId);
+        logger5.info("Pending message sent", { id: row.id, to: row.toAddr, provider: row.provider });
+      } else {
+        logger5.warn("Pending message send failed", { id: row.id, to: row.toAddr, error: sendResult.error.code });
+      }
+    }
+  } finally {
+    if (lockAcquired) {
+      await cache.lock.release(FLUSH_LOCK_KEY, reachNodeId).catch((error) => {
+        logger5.warn("Failed to release flush lock", { error });
+      });
+    }
+  }
+}
+async function executeSend(message, providers2, templateRegistry2, dndConfig2, repo) {
+  if (!message.to) {
+    return err(
+      HaiReachError.INVALID_RECIPIENT,
+      reachM("reach_invalidRecipient", { params: { recipient: "" } })
+    );
+  }
+  const preprocessed = await preprocessMessage(message, templateRegistry2);
+  if (!preprocessed.success) {
+    return preprocessed;
+  }
+  const providerName = preprocessed.data.provider;
+  if (!providerName) {
+    return err(
+      HaiReachError.PROVIDER_NOT_FOUND,
+      reachM("reach_providerRequired")
+    );
+  }
+  if (!providers2.has(providerName)) {
+    return err(
+      HaiReachError.PROVIDER_NOT_FOUND,
+      reachM("reach_providerNotFound", { params: { provider: providerName } })
+    );
+  }
+  if (isDndBlocked(dndConfig2)) {
+    const strategy = dndConfig2?.strategy ?? "discard";
+    if (strategy === "delay") {
+      logger5.info("Message deferred by DND (delay strategy)", { provider: providerName, to: message.to });
+      try {
+        await saveSendRecord(repo ?? null, preprocessed.data, "pending", providerName);
+      } catch (error) {
+        logger5.warn("Failed to save deferred message to DB", { provider: providerName, to: message.to, error });
+        return err(
+          HaiReachError.SEND_FAILED,
+          reachM("reach_dndDeferred"),
+          error
+        );
+      }
+      return ok({ success: true, deferred: true });
+    }
+    logger5.info("Message blocked by DND (discard strategy)", { provider: providerName, to: message.to });
+    return err(
+      HaiReachError.DND_BLOCKED,
+      reachM("reach_dndBlocked")
+    );
+  }
+  const provider = providers2.get(providerName);
+  logger5.debug("Sending message", {
+    provider: providerName,
+    to: preprocessed.data.to,
+    template: message.template
+  });
+  const result = await provider.send(preprocessed.data);
+  if (!result.success) {
+    logger5.warn("Message send failed", {
+      provider: providerName,
+      to: message.to,
+      error: result.error.code
+    });
+    return result;
+  }
+  saveSendRecord(repo ?? null, preprocessed.data, "sent", providerName, result.data.messageId).catch((error) => {
+    logger5.warn("Failed to save send record", { provider: providerName, to: message.to, error });
+  });
+  return result;
+}
+function renderString(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    return Object.prototype.hasOwnProperty.call(vars, key) ? vars[key] : match;
+  });
+}
+function renderTemplate(template, vars) {
+  try {
+    const rendered = {
+      subject: template.subject ? renderString(template.subject, vars) : void 0,
+      body: renderString(template.body, vars)
+    };
+    return ok(rendered);
+  } catch (error) {
+    return err(
+      HaiReachError.TEMPLATE_RENDER_FAILED,
+      reachM("reach_templateRenderFailed", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+function noDbError(msgKey) {
+  return err(
+    HaiReachError.SEND_FAILED,
+    reachM(msgKey, { params: { error: "database not available" } })
+  );
+}
+function createTemplateRegistry(repo) {
+  return {
+    async resolve(name) {
+      if (!repo) {
+        return err(
+          HaiReachError.TEMPLATE_NOT_FOUND,
+          reachM("reach_templateNotFound", { params: { template: name } })
+        );
+      }
+      const dbResult = await repo.findByName(name);
+      if (!dbResult.success) {
+        return dbResult;
+      }
+      if (dbResult.data) {
+        return ok({
+          name: dbResult.data.name,
+          provider: dbResult.data.provider,
+          subject: dbResult.data.subject ?? void 0,
+          body: dbResult.data.body
+        });
+      }
+      return err(
+        HaiReachError.TEMPLATE_NOT_FOUND,
+        reachM("reach_templateNotFound", { params: { template: name } })
+      );
+    },
+    async save(template) {
+      if (!repo) {
+        return noDbError("reach_templateSaveFailed");
+      }
+      return repo.upsert(template);
+    },
+    async saveBatch(templates) {
+      if (!repo) {
+        return noDbError("reach_templateSaveFailed");
+      }
+      const results = await Promise.all(templates.map((t) => repo.upsert(t)));
+      const failed = results.find((r) => !r.success);
+      if (failed) {
+        return failed;
+      }
+      return ok(void 0);
+    },
+    async remove(name) {
+      if (!repo) {
+        return noDbError("reach_templateDeleteFailed");
+      }
+      return repo.deleteByName(name);
+    },
+    async list() {
+      if (!repo) {
+        return ok([]);
+      }
+      return repo.listTemplates();
+    },
+    async render(name, vars) {
+      const resolved = await this.resolve(name);
+      if (!resolved.success) {
+        return resolved;
+      }
+      return renderTemplate(resolved.data, vars);
+    }
+  };
+}
+var TABLE_NAME = "hai_reach_send_log";
+var SEND_LOG_FIELDS = [
+  {
+    fieldName: "id",
+    columnName: "id",
+    def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
+    select: true,
+    create: false,
+    update: false
+  },
+  {
+    fieldName: "provider",
+    columnName: "provider",
+    def: { type: "TEXT", notNull: true },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "toAddr",
+    columnName: "to_addr",
+    def: { type: "TEXT", notNull: true },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "subject",
+    columnName: "subject",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "body",
+    columnName: "body",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "template",
+    columnName: "template",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "varsJson",
+    columnName: "vars_json",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "extraJson",
+    columnName: "extra_json",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "status",
+    columnName: "status",
+    def: { type: "TEXT", notNull: true },
+    select: true,
+    create: true,
+    update: true
+  },
+  {
+    fieldName: "messageId",
+    columnName: "message_id",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: true
+  },
+  {
+    fieldName: "createdAt",
+    columnName: "created_at",
+    def: { type: "TIMESTAMP", notNull: true },
+    select: true,
+    create: true,
+    update: false
+  }
+];
+var sendLogRepoInstance = null;
+var sendLogRepoDbConfig = null;
+function resetSendLogRepoSingleton() {
+  sendLogRepoInstance = null;
+  sendLogRepoDbConfig = null;
+}
+async function createSendLogRepository(db) {
+  if (sendLogRepoInstance && sendLogRepoDbConfig === db.config)
+    return ok(sendLogRepoInstance);
+  const repo = new DbSendLogRepository(db);
+  const initResult = await repo.count();
+  if (!initResult.success) {
+    return err(
+      HaiReachError.SEND_FAILED,
+      reachM("reach_sendFailed", { params: { error: initResult.error.message } }),
+      initResult.error
+    );
+  }
+  sendLogRepoInstance = repo;
+  sendLogRepoDbConfig = db.config;
+  return ok(repo);
+}
+var DbSendLogRepository = class extends BaseReldbCrudRepository {
+  constructor(db) {
+    super(db, {
+      table: TABLE_NAME,
+      fields: SEND_LOG_FIELDS,
+      idColumn: "id",
+      idField: "id",
+      createTableIfNotExists: true
+    });
+  }
+  /** 获取所有待发送记录 */
+  async findPending(tx) {
+    const result = await this.findAll({ where: "status = ?", params: ["pending"], orderBy: "created_at ASC" }, tx);
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data);
+  }
+  /** 将记录标记为已发送 */
+  async markSent(id, messageId, tx) {
+    const result = await this.updateById(id, { status: "sent", messageId: messageId ?? null }, tx);
+    if (!result.success) {
+      return result;
+    }
+    return ok(void 0);
+  }
+};
+var TABLE_NAME2 = "hai_reach_template";
+var TEMPLATE_FIELDS = [
+  {
+    fieldName: "id",
+    columnName: "id",
+    def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
+    select: true,
+    create: false,
+    update: false
+  },
+  {
+    fieldName: "name",
+    columnName: "name",
+    def: { type: "TEXT", notNull: true, unique: true },
+    select: true,
+    create: true,
+    update: true
+  },
+  {
+    fieldName: "provider",
+    columnName: "provider",
+    def: { type: "TEXT", notNull: true },
+    select: true,
+    create: true,
+    update: true
+  },
+  {
+    fieldName: "subject",
+    columnName: "subject",
+    def: { type: "TEXT" },
+    select: true,
+    create: true,
+    update: true
+  },
+  {
+    fieldName: "body",
+    columnName: "body",
+    def: { type: "TEXT", notNull: true },
+    select: true,
+    create: true,
+    update: true
+  },
+  {
+    fieldName: "createdAt",
+    columnName: "created_at",
+    def: { type: "TIMESTAMP", notNull: true },
+    select: true,
+    create: true,
+    update: false
+  },
+  {
+    fieldName: "updatedAt",
+    columnName: "updated_at",
+    def: { type: "TIMESTAMP", notNull: true },
+    select: true,
+    create: true,
+    update: true
+  }
+];
+var templateRepoInstance = null;
+var templateRepoDbConfig = null;
+function resetTemplateRepoSingleton() {
+  templateRepoInstance = null;
+  templateRepoDbConfig = null;
+}
+async function createTemplateRepository(db) {
+  if (templateRepoInstance && templateRepoDbConfig === db.config)
+    return ok(templateRepoInstance);
+  const repo = new DbTemplateRepository(db);
+  const initResult = await repo.count();
+  if (!initResult.success) {
+    return err(
+      HaiReachError.SEND_FAILED,
+      reachM("reach_templateDbInitFailed", { params: { error: initResult.error.message } }),
+      initResult.error
+    );
+  }
+  templateRepoInstance = repo;
+  templateRepoDbConfig = db.config;
+  return ok(repo);
+}
+function toReachTemplate(stored) {
+  return {
+    name: stored.name,
+    provider: stored.provider,
+    subject: stored.subject ?? void 0,
+    body: stored.body
+  };
+}
+var DbTemplateRepository = class extends BaseReldbCrudRepository {
+  constructor(db) {
+    super(db, {
+      table: TABLE_NAME2,
+      fields: TEMPLATE_FIELDS,
+      idColumn: "id",
+      idField: "id",
+      createTableIfNotExists: true
+    });
+  }
+  /** 按名称查找模板 */
+  async findByName(name, tx) {
+    const result = await this.findAll({ where: "name = ?", params: [name], limit: 1 }, tx);
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data[0]);
+  }
+  /** 保存模板（存在则更新，不存在则插入） */
+  async upsert(template, tx) {
+    const existing = await this.findByName(template.name, tx);
+    if (!existing.success) {
+      return existing;
+    }
+    const now = Date.now();
+    if (existing.data) {
+      const updateResult = await this.updateById(
+        existing.data.id,
+        {
+          provider: template.provider,
+          subject: template.subject ?? null,
+          body: template.body,
+          updatedAt: now
+        },
+        tx
+      );
+      if (!updateResult.success) {
+        return updateResult;
+      }
+    } else {
+      const createResult = await this.create(
+        {
+          name: template.name,
+          provider: template.provider,
+          subject: template.subject ?? null,
+          body: template.body,
+          createdAt: now,
+          updatedAt: now
+        },
+        tx
+      );
+      if (!createResult.success) {
+        return createResult;
+      }
+    }
+    return ok(void 0);
+  }
+  /** 按名称删除模板 */
+  async deleteByName(name, tx) {
+    const existing = await this.findByName(name, tx);
+    if (!existing.success) {
+      return existing;
+    }
+    if (!existing.data) {
+      return ok(void 0);
+    }
+    const result = await this.deleteById(existing.data.id, tx);
+    if (!result.success) {
+      return result;
+    }
+    return ok(void 0);
+  }
+  /** 获取所有模板（转换为 ReachTemplate 格式） */
+  async listTemplates(tx) {
+    const result = await this.findAll({ orderBy: "name ASC" }, tx);
+    if (!result.success) {
+      return result;
+    }
+    return ok(result.data.map(toReachTemplate));
+  }
+};
+
+// src/reach-main.ts
+var logger6 = core.logger.child({ module: "reach", scope: "main" });
+var providers = /* @__PURE__ */ new Map();
+var currentConfig = null;
+var dndConfig;
+var templateRegistry = createTemplateRegistry();
+var sendLogRepo = null;
+var templateRepo = null;
+var initInProgress = false;
+function createProvider(config) {
+  switch (config.type) {
+    case "console":
+      return createConsoleProvider();
+    case "smtp":
+      return createSmtpProvider();
+    case "aliyun-sms":
+      return createAliyunSmsProvider();
+    case "api":
+      return createApiProvider();
+  }
+}
+async function tryGetDb() {
+  try {
+    const dbModuleName = "@h-ai/reldb";
+    const mod = await import(
+      /* @vite-ignore */
+      dbModuleName
+    );
+    if (!mod.reldb.isInitialized) {
+      return null;
+    }
+    return mod.reldb;
+  } catch {
+    return null;
+  }
+}
+async function tryInitSendLogRepo() {
+  try {
+    const db = await tryGetDb();
+    if (!db) {
+      return null;
+    }
+    const result = await createSendLogRepository(db);
+    if (!result.success) {
+      logger6.debug("Send log repository not initialized", { error: result.error.message });
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    logger6.debug("Send log repository not initialized", { error: error instanceof Error ? error.message : String(error) });
+    return null;
+  }
+}
+async function tryInitTemplateRepo() {
+  try {
+    const db = await tryGetDb();
+    if (!db) {
+      return null;
+    }
+    const result = await createTemplateRepository(db);
+    if (!result.success) {
+      logger6.debug("Template repository not initialized", { error: result.error.message });
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    logger6.debug("Template repository not initialized", { error: error instanceof Error ? error.message : String(error) });
+    return null;
+  }
+}
+var notInitialized = core.module.createNotInitializedKit(
+  HaiReachError.NOT_INITIALIZED,
+  () => reachM("reach_notInitialized")
+);
+async function doClose() {
+  if (providers.size === 0 && currentConfig === null) {
+    logger6.info("Reach module already closed, skipping");
+    return;
+  }
+  logger6.info("Closing reach module");
+  for (const [name, provider] of providers.entries()) {
+    try {
+      await provider.close();
+    } catch (error) {
+      logger6.error("Provider close failed", { name, error });
+    }
+  }
+  providers = /* @__PURE__ */ new Map();
+  currentConfig = null;
+  dndConfig = void 0;
+  templateRegistry = createTemplateRegistry();
+  sendLogRepo = null;
+  templateRepo = null;
+  resetSendLogRepoSingleton();
+  resetTemplateRepoSingleton();
+  resetSendState();
+  logger6.info("Reach module closed");
+}
+async function doInit(config) {
+  if (providers.size > 0) {
+    logger6.warn("Reach module is already initialized, reinitializing");
+    await doClose();
+  }
+  logger6.info("Initializing reach module");
+  const parseResult = ReachConfigSchema.safeParse(config);
+  if (!parseResult.success) {
+    logger6.error("Reach config validation failed", { error: parseResult.error.message });
+    return err(
+      HaiReachError.CONFIG_ERROR,
+      reachM("reach_configError", { params: { error: parseResult.error.message } }),
+      parseResult.error
+    );
+  }
+  const parsed = parseResult.data;
+  try {
+    const newProviders = /* @__PURE__ */ new Map();
+    for (const providerConfig of parsed.providers) {
+      const provider = createProvider(providerConfig);
+      const connectResult = await provider.connect(providerConfig);
+      if (!connectResult.success) {
+        logger6.error("Provider initialization failed", {
+          name: providerConfig.name,
+          type: providerConfig.type,
+          code: connectResult.error.code,
+          message: connectResult.error.message
+        });
+        logger6.info("Rolling back connected providers", { count: newProviders.size });
+        for (const [name, p] of newProviders.entries()) {
+          try {
+            await p.close();
+          } catch (rollbackError) {
+            logger6.error("Provider rollback close failed", { name, error: rollbackError });
+          }
+        }
+        return connectResult;
+      }
+      newProviders.set(providerConfig.name, provider);
+    }
+    providers = newProviders;
+    currentConfig = parsed;
+    dndConfig = parsed.dnd;
+    templateRepo = await tryInitTemplateRepo();
+    templateRegistry = createTemplateRegistry(templateRepo);
+    if (parsed.templates && templateRepo) {
+      const saveResult = await templateRegistry.saveBatch(parsed.templates);
+      if (!saveResult.success) {
+        logger6.warn("Failed to save config templates to database", { error: saveResult.error.message });
+      }
+    }
+    sendLogRepo = await tryInitSendLogRepo();
+    if (dndConfig) {
+      startDndScheduler(dndConfig, providers, sendLogRepo);
+    }
+    const providerNames = parsed.providers.map((p) => p.name);
+    logger6.info("Reach module initialized", { providers: providerNames });
+    return ok(void 0);
+  } catch (error) {
+    logger6.error("Reach module initialization failed", { error });
+    return err(
+      HaiReachError.CONFIG_ERROR,
+      reachM("reach_initFailed", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+var reach = {
+  async init(config) {
+    if (initInProgress) {
+      logger6.warn("Reach module init already in progress, skipping");
+      return err(
+        HaiReachError.CONFIG_ERROR,
+        reachM("reach_configError", { params: { error: "init already in progress" } })
+      );
+    }
+    initInProgress = true;
+    try {
+      return await doInit(config);
+    } finally {
+      initInProgress = false;
+    }
+  },
+  async send(message) {
+    if (providers.size === 0) {
+      return notInitialized.result();
+    }
+    return executeSend(message, providers, templateRegistry, dndConfig, sendLogRepo);
+  },
+  get template() {
+    return templateRegistry;
+  },
+  get config() {
+    return currentConfig;
+  },
+  get isInitialized() {
+    return providers.size > 0;
+  },
+  async close() {
+    await doClose();
+  }
+};
+
+export { AliyunSmsProviderConfigSchema, ApiProviderConfigSchema, ConsoleProviderConfigSchema, DndConfigSchema, HaiReachError, ProviderConfigSchema, ReachConfigSchema, SmtpProviderConfigSchema, TemplateConfigSchema, reach };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map