@rei-standard/amsg-server 1.1.0

package/dist/index.cjs

@@ -0,0 +1,980 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+var _chunkM2CNZRROcjs = require('./chunk-M2CNZRRO.cjs');
+
+// src/server/adapters/factory.js
+async function createAdapter(config) {
+  if (!config || !config.driver) {
+    throw new Error(
+      '[rei-standard-amsg-server] "driver" is required in the db config. Supported drivers: neon, pg'
+    );
+  }
+  if (!config.connectionString) {
+    throw new Error(
+      '[rei-standard-amsg-server] "connectionString" is required in the db config.'
+    );
+  }
+  switch (config.driver) {
+    case "neon": {
+      const { NeonAdapter } = await Promise.resolve().then(() => _interopRequireWildcard(require("./neon-FRQJDC3A.cjs")));
+      return new NeonAdapter(config.connectionString);
+    }
+    case "pg": {
+      const { PgAdapter } = await Promise.resolve().then(() => _interopRequireWildcard(require("./pg-PBITGIEU.cjs")));
+      return new PgAdapter(config.connectionString);
+    }
+    default:
+      throw new Error(
+        `[rei-standard-amsg-server] Unsupported driver "${config.driver}". Supported drivers: neon, pg`
+      );
+  }
+}
+
+// src/server/lib/request.js
+var REQUEST_ERRORS = {
+  INVALID_JSON: { code: "INVALID_JSON", message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u6709\u6548\u7684 JSON" },
+  INVALID_REQUEST_BODY: { code: "INVALID_REQUEST_BODY", message: "\u8BF7\u6C42\u4F53\u683C\u5F0F\u65E0\u6548" },
+  INVALID_ENCRYPTED_PAYLOAD: { code: "INVALID_ENCRYPTED_PAYLOAD", message: "\u52A0\u5BC6\u6570\u636E\u683C\u5F0F\u9519\u8BEF" }
+};
+function parseBodyAsObject(body, options = {}) {
+  const invalidJson = options.invalidJson || REQUEST_ERRORS.INVALID_JSON;
+  const invalidType = options.invalidType || REQUEST_ERRORS.INVALID_REQUEST_BODY;
+  let parsed = body;
+  if (typeof parsed === "string") {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch (e) {
+      return { ok: false, error: invalidJson };
+    }
+  }
+  if (!isPlainObject(parsed)) {
+    return { ok: false, error: invalidType };
+  }
+  return { ok: true, data: parsed };
+}
+function parseJsonBody(body) {
+  return parseBodyAsObject(body, {
+    invalidJson: REQUEST_ERRORS.INVALID_JSON,
+    invalidType: REQUEST_ERRORS.INVALID_REQUEST_BODY
+  });
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEncryptedEnvelope(payload) {
+  if (!isPlainObject(payload)) return false;
+  return typeof payload.iv === "string" && typeof payload.authTag === "string" && typeof payload.encryptedData === "string";
+}
+function parseEncryptedBody(body) {
+  const parsedBody = parseBodyAsObject(body, {
+    invalidJson: REQUEST_ERRORS.INVALID_ENCRYPTED_PAYLOAD,
+    invalidType: REQUEST_ERRORS.INVALID_ENCRYPTED_PAYLOAD
+  });
+  if (!parsedBody.ok) {
+    return parsedBody;
+  }
+  if (!isEncryptedEnvelope(parsedBody.data)) {
+    return { ok: false, error: REQUEST_ERRORS.INVALID_ENCRYPTED_PAYLOAD };
+  }
+  return parsedBody;
+}
+
+// src/server/handlers/init-database.js
+function createInitDatabaseHandler(ctx) {
+  async function GET(headers) {
+    if (!ctx.initSecret) {
+      return {
+        status: 500,
+        body: { success: false, error: { code: "INIT_SECRET_MISSING", message: "initSecret \u672A\u914D\u7F6E\uFF0C\u8BF7\u5728 createReiServer \u914D\u7F6E\u4E2D\u63D0\u4F9B initSecret" } }
+      };
+    }
+    const authHeader = (headers["authorization"] || "").trim();
+    const expectedAuth = `Bearer ${ctx.initSecret}`;
+    if (authHeader !== expectedAuth) {
+      return {
+        status: 401,
+        body: { success: false, error: { code: "UNAUTHORIZED", message: "\u9700\u8981\u8BA4\u8BC1\u3002\u8BF7\u5728\u8BF7\u6C42\u5934\u4E2D\u6DFB\u52A0: Authorization: Bearer {INIT_SECRET}" } }
+      };
+    }
+    const result = await ctx.db.initSchema();
+    const columnNames = result.columns.map((c) => c.name);
+    const missingColumns = _chunkM2CNZRROcjs.REQUIRED_COLUMNS.filter((col) => !columnNames.includes(col));
+    if (missingColumns.length > 0) {
+      console.warn("[init-database] \u26A0\uFE0F  Missing columns:", missingColumns);
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        message: "\u6570\u636E\u5E93\u521D\u59CB\u5316\u6210\u529F\uFF01\u5EFA\u8BAE\u7ACB\u5373\u5220\u9664\u6B64 API \u6587\u4EF6\u3002",
+        data: {
+          table: "scheduled_messages",
+          columnsCreated: result.columnsCreated,
+          indexesCreated: result.indexesCreated,
+          indexesFailed: result.indexesFailed,
+          details: { columns: result.columns, indexes: result.indexes },
+          nextSteps: [
+            "1. \u9A8C\u8BC1\u8868\u548C\u7D22\u5F15\u5DF2\u6B63\u786E\u521B\u5EFA",
+            "2. \u7ACB\u5373\u5220\u9664 /app/api/v1/init-database/route.js \u6587\u4EF6",
+            "3. \u4ECE .env \u4E2D\u5220\u9664 INIT_SECRET\uFF08\u53EF\u9009\uFF09",
+            "4. \u5F00\u59CB\u4F7F\u7528 ReiStandard API"
+          ]
+        }
+      }
+    };
+  }
+  async function POST(headers, body) {
+    if (!ctx.initSecret) {
+      return {
+        status: 500,
+        body: { success: false, error: { code: "INIT_SECRET_MISSING", message: "initSecret \u672A\u914D\u7F6E\uFF0C\u8BF7\u5728 createReiServer \u914D\u7F6E\u4E2D\u63D0\u4F9B initSecret" } }
+      };
+    }
+    const authHeader = (headers["authorization"] || "").trim();
+    const expectedAuth = `Bearer ${ctx.initSecret}`;
+    if (authHeader !== expectedAuth) {
+      return {
+        status: 401,
+        body: { success: false, error: { code: "UNAUTHORIZED", message: "\u9700\u8981\u8BA4\u8BC1" } }
+      };
+    }
+    const parsedBody = parseJsonBody(body);
+    if (!parsedBody.ok) {
+      return {
+        status: 400,
+        body: { success: false, error: parsedBody.error }
+      };
+    }
+    if (parsedBody.data.confirm !== "DELETE_ALL_DATA") {
+      return {
+        status: 400,
+        body: { success: false, error: { code: "CONFIRMATION_REQUIRED", message: '\u9700\u8981\u5728\u8BF7\u6C42\u4F53\u4E2D\u63D0\u4F9B\u786E\u8BA4\u53C2\u6570: { "confirm": "DELETE_ALL_DATA" }' } }
+      };
+    }
+    await ctx.db.dropSchema();
+    return GET(headers);
+  }
+  return { GET, POST };
+}
+
+// src/server/handlers/get-master-key.js
+function createGetMasterKeyHandler(ctx) {
+  async function GET(headers) {
+    const userId = headers["x-user-id"];
+    if (!userId) {
+      return {
+        status: 400,
+        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } }
+      };
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        data: {
+          masterKey: ctx.encryptionKey,
+          version: 1
+        }
+      }
+    };
+  }
+  return { GET };
+}
+
+// src/server/handlers/schedule-message.js
+var _crypto = require('crypto');
+
+// src/server/lib/encryption.js
+
+function deriveUserEncryptionKey(userId, masterKey) {
+  return _crypto.createHash.call(void 0, "sha256").update(masterKey + userId).digest("hex").slice(0, 64);
+}
+function decryptPayload(encryptedPayload, encryptionKey) {
+  const { iv, authTag, encryptedData } = encryptedPayload;
+  const decipher = _crypto.createDecipheriv.call(void 0, 
+    "aes-256-gcm",
+    Buffer.from(encryptionKey, "hex"),
+    Buffer.from(iv, "base64")
+  );
+  decipher.setAuthTag(Buffer.from(authTag, "base64"));
+  const decrypted = Buffer.concat([
+    decipher.update(Buffer.from(encryptedData, "base64")),
+    decipher.final()
+  ]);
+  return JSON.parse(decrypted.toString("utf8"));
+}
+function encryptPayload(payload, encryptionKey) {
+  const plaintext = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const iv = _crypto.randomBytes.call(void 0, 12);
+  const cipher = _crypto.createCipheriv.call(void 0, "aes-256-gcm", Buffer.from(encryptionKey, "hex"), iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    encryptedData: encrypted.toString("base64")
+  };
+}
+function encryptForStorage(text, encryptionKey) {
+  const iv = _crypto.randomBytes.call(void 0, 16);
+  const cipher = _crypto.createCipheriv.call(void 0, "aes-256-gcm", Buffer.from(encryptionKey, "hex"), iv);
+  const encrypted = cipher.update(text, "utf8", "hex") + cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+}
+function decryptFromStorage(encryptedText, encryptionKey) {
+  const [ivHex, authTagHex, encryptedDataHex] = encryptedText.split(":");
+  const decipher = _crypto.createDecipheriv.call(void 0, 
+    "aes-256-gcm",
+    Buffer.from(encryptionKey, "hex"),
+    Buffer.from(ivHex, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(authTagHex, "hex"));
+  return decipher.update(encryptedDataHex, "hex", "utf8") + decipher.final("utf8");
+}
+
+// src/server/lib/db-errors.js
+function isUniqueViolation(error) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  if (code === "23505") return true;
+  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
+  return message.includes("duplicate key") || message.includes("unique constraint");
+}
+
+// src/server/lib/validation.js
+function isValidISO8601(dateString) {
+  const date = new Date(dateString);
+  return date instanceof Date && !isNaN(date.getTime());
+}
+function isValidUrl(urlString) {
+  try {
+    new URL(urlString);
+    return true;
+  } catch (e2) {
+    return false;
+  }
+}
+function isValidUUID(uuid) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+}
+function validateScheduleMessagePayload(payload) {
+  if (!payload.contactName || typeof payload.contactName !== "string") {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: ["contactName"] } };
+  }
+  if (!payload.messageType || !["fixed", "prompted", "auto", "instant"].includes(payload.messageType)) {
+    return { valid: false, errorCode: "INVALID_MESSAGE_TYPE", errorMessage: "\u6D88\u606F\u7C7B\u578B\u65E0\u6548", details: { providedType: payload.messageType, allowedTypes: ["fixed", "prompted", "auto", "instant"] } };
+  }
+  if (!payload.firstSendTime || !isValidISO8601(payload.firstSendTime)) {
+    return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u683C\u5F0F\u65E0\u6548", details: { field: "firstSendTime" } };
+  }
+  if (payload.firstSendTime && new Date(payload.firstSendTime) <= /* @__PURE__ */ new Date()) {
+    return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u5FC5\u987B\u5728\u672A\u6765", details: { field: "firstSendTime", reason: "must be in the future" } };
+  }
+  if (!payload.pushSubscription || typeof payload.pushSubscription !== "object") {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: ["pushSubscription"] } };
+  }
+  if (payload.recurrenceType && !["none", "daily", "weekly"].includes(payload.recurrenceType)) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["recurrenceType"] } };
+  }
+  if (payload.messageType === "fixed") {
+    if (!payload.userMessage) {
+      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: ["userMessage (required for fixed type)"] } };
+    }
+  }
+  if (payload.messageType === "prompted" || payload.messageType === "auto") {
+    const missingAiFields = [];
+    if (!payload.completePrompt) missingAiFields.push("completePrompt");
+    if (!payload.apiUrl) missingAiFields.push("apiUrl");
+    if (!payload.apiKey) missingAiFields.push("apiKey");
+    if (!payload.primaryModel) missingAiFields.push("primaryModel");
+    if (missingAiFields.length > 0) {
+      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: missingAiFields } };
+    }
+  }
+  if (payload.messageType === "instant") {
+    if (payload.recurrenceType && payload.recurrenceType !== "none") {
+      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "instant \u7C7B\u578B\u7684 recurrenceType \u5FC5\u987B\u4E3A none", details: { invalidFields: ['recurrenceType (must be "none" for instant type)'] } };
+    }
+    const hasAiConfig = payload.completePrompt && payload.apiUrl && payload.apiKey && payload.primaryModel;
+    const hasUserMessage = payload.userMessage;
+    if (!hasAiConfig && !hasUserMessage) {
+      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "instant \u7C7B\u578B\u5FC5\u987B\u63D0\u4F9B userMessage \u6216\u5B8C\u6574\u7684 AI \u914D\u7F6E", details: { missingFields: ["userMessage or (completePrompt + apiUrl + apiKey + primaryModel)"] } };
+    }
+  }
+  if (payload.avatarUrl && !isValidUrl(payload.avatarUrl)) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["avatarUrl (invalid URL format)"] } };
+  }
+  if (payload.uuid && !isValidUUID(payload.uuid)) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["uuid (invalid UUID format)"] } };
+  }
+  if (payload.messageSubtype && !["chat", "forum", "moment"].includes(payload.messageSubtype)) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["messageSubtype"] } };
+  }
+  return { valid: true };
+}
+
+// src/server/lib/message-processor.js
+
+async function processSingleMessage(task, ctx) {
+  try {
+    const userKey = deriveUserEncryptionKey(task.user_id, ctx.encryptionKey);
+    const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+    let messageContent;
+    if (decryptedPayload.messageType === "fixed") {
+      messageContent = decryptedPayload.userMessage;
+    } else if (decryptedPayload.messageType === "instant") {
+      if (decryptedPayload.completePrompt && decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel) {
+        messageContent = await _callAI(decryptedPayload);
+      } else if (decryptedPayload.userMessage) {
+        messageContent = decryptedPayload.userMessage;
+      } else {
+        throw new Error("Invalid instant message: no content source available");
+      }
+    } else if (decryptedPayload.messageType === "prompted" || decryptedPayload.messageType === "auto") {
+      messageContent = await _callAI(decryptedPayload);
+    } else {
+      throw new Error("Invalid message configuration: no content source available");
+    }
+    const sentences = messageContent.split(/([。！？!?]+)/).reduce((acc, part, i, arr) => {
+      if (i % 2 === 0 && part.trim()) {
+        const punctuation = arr[i + 1] || "";
+        acc.push(part.trim() + punctuation);
+      }
+      return acc;
+    }, []).filter((s) => s.length > 0);
+    const messages = sentences.length > 0 ? sentences : [messageContent];
+    if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
+      throw new Error("VAPID configuration missing - push notifications cannot be sent");
+    }
+    const pushSubscription = decryptedPayload.pushSubscription;
+    for (let i = 0; i < messages.length; i++) {
+      const notificationPayload = {
+        title: `\u6765\u81EA ${decryptedPayload.contactName}`,
+        message: messages[i],
+        contactName: decryptedPayload.contactName,
+        messageId: `msg_${_crypto.randomUUID.call(void 0, )}_${task.id || "instant"}_${i}`,
+        messageIndex: i + 1,
+        totalMessages: messages.length,
+        messageType: decryptedPayload.messageType,
+        messageSubtype: decryptedPayload.messageSubtype || "chat",
+        taskId: task.id || null,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source: decryptedPayload.messageType === "instant" ? "instant" : "scheduled",
+        avatarUrl: decryptedPayload.avatarUrl || null,
+        metadata: decryptedPayload.metadata || {}
+      };
+      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(notificationPayload));
+      if (i < messages.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+      }
+    }
+    return { success: true, messagesSent: messages.length };
+  } catch (error) {
+    return { success: false, messagesSent: 0, error: error.message };
+  }
+}
+async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId) {
+  let retryCount = 0;
+  while (retryCount <= maxRetries) {
+    let task;
+    try {
+      task = userId ? await ctx.db.getTaskByUuid(uuid, userId) : await ctx.db.getTaskByUuidOnly(uuid);
+    } catch (error) {
+      if (retryCount < maxRetries) {
+        retryCount++;
+        await new Promise((resolve) => setTimeout(resolve, 1e3 * retryCount));
+        continue;
+      }
+      return {
+        success: false,
+        error: { code: "INTERNAL_ERROR", message: error.message, retriesAttempted: retryCount }
+      };
+    }
+    if (!task) {
+      return { success: false, error: { code: "TASK_NOT_FOUND", message: "\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u5904\u7406" } };
+    }
+    const result = await processSingleMessage(task, ctx);
+    if (!result.success) {
+      if (retryCount < maxRetries) {
+        retryCount++;
+        await new Promise((resolve) => setTimeout(resolve, 1e3 * retryCount));
+        continue;
+      }
+      try {
+        await ctx.db.updateTaskById(task.id, { status: "failed", retry_count: retryCount });
+      } catch (_updateError) {
+      }
+      return {
+        success: false,
+        error: { code: "PROCESSING_ERROR", message: result.error, retriesAttempted: retryCount }
+      };
+    }
+    try {
+      await ctx.db.deleteTaskById(task.id);
+    } catch (error) {
+      try {
+        await ctx.db.updateTaskById(task.id, { status: "sent", retry_count: 0 });
+      } catch (_markSentError) {
+      }
+      return {
+        success: false,
+        error: {
+          code: "POST_SEND_CLEANUP_FAILED",
+          message: "\u6D88\u606F\u5DF2\u53D1\u9001\uFF0C\u4F46\u4EFB\u52A1\u6E05\u7406\u5931\u8D25",
+          details: { error: error.message }
+        }
+      };
+    }
+    return { success: true, messagesSent: result.messagesSent, retriesUsed: retryCount };
+  }
+}
+async function _callAI(payload) {
+  const aiResponse = await fetch(payload.apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${payload.apiKey}`
+    },
+    body: JSON.stringify({
+      model: payload.primaryModel,
+      messages: [{ role: "user", content: payload.completePrompt }],
+      max_tokens: 500,
+      temperature: 0.8
+    }),
+    signal: AbortSignal.timeout(3e5)
+  });
+  if (!aiResponse.ok) {
+    throw new Error(`AI API error: ${aiResponse.status} ${aiResponse.statusText}`);
+  }
+  const aiData = await aiResponse.json();
+  return aiData.choices[0].message.content.trim();
+}
+
+// src/server/handlers/schedule-message.js
+function createScheduleMessageHandler(ctx) {
+  async function POST(headers, body) {
+    const isEncrypted = headers["x-payload-encrypted"] === "true";
+    const encryptionVersion = headers["x-encryption-version"];
+    const userId = headers["x-user-id"];
+    if (!isEncrypted) {
+      return { status: 400, body: { success: false, error: { code: "ENCRYPTION_REQUIRED", message: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6" } } };
+    }
+    if (!userId) {
+      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
+    }
+    if (encryptionVersion !== "1") {
+      return { status: 400, body: { success: false, error: { code: "UNSUPPORTED_ENCRYPTION_VERSION", message: "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301" } } };
+    }
+    const parsedBody = parseEncryptedBody(body);
+    if (!parsedBody.ok) {
+      return { status: 400, body: { success: false, error: parsedBody.error } };
+    }
+    const encryptedBody = parsedBody.data;
+    let payload;
+    try {
+      const userKey2 = deriveUserEncryptionKey(userId, ctx.encryptionKey);
+      payload = decryptPayload(encryptedBody, userKey2);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return { status: 400, body: { success: false, error: { code: "INVALID_PAYLOAD_FORMAT", message: "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u4E0D\u662F\u6709\u6548 JSON" } } };
+      }
+      const message = typeof error.message === "string" ? error.message : "";
+      if (message.includes("auth") || message.includes("Unsupported state")) {
+        return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
+      }
+      return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
+    }
+    if (!isPlainObject(payload)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_PAYLOAD_FORMAT", message: "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u5FC5\u987B\u662F JSON \u5BF9\u8C61" } } };
+    }
+    const validationResult = validateScheduleMessagePayload(payload);
+    if (!validationResult.valid) {
+      return { status: 400, body: { success: false, error: { code: validationResult.errorCode, message: validationResult.errorMessage, details: validationResult.details } } };
+    }
+    const taskUuid = payload.uuid || _crypto.randomUUID.call(void 0, );
+    const userKey = deriveUserEncryptionKey(userId, ctx.encryptionKey);
+    const fullTaskData = {
+      contactName: payload.contactName,
+      avatarUrl: payload.avatarUrl || null,
+      messageType: payload.messageType,
+      messageSubtype: payload.messageSubtype || "chat",
+      userMessage: payload.userMessage || null,
+      firstSendTime: payload.firstSendTime,
+      recurrenceType: payload.recurrenceType || "none",
+      apiUrl: payload.apiUrl || null,
+      apiKey: payload.apiKey || null,
+      primaryModel: payload.primaryModel || null,
+      completePrompt: payload.completePrompt || null,
+      pushSubscription: payload.pushSubscription,
+      metadata: payload.metadata || {}
+    };
+    const encryptedPayload = encryptForStorage(JSON.stringify(fullTaskData), userKey);
+    if (payload.messageType === "instant") {
+      if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
+        return {
+          status: 500,
+          body: {
+            success: false,
+            error: {
+              code: "VAPID_CONFIG_ERROR",
+              message: "VAPID \u914D\u7F6E\u7F3A\u5931\uFF0C\u65E0\u6CD5\u53D1\u9001\u5373\u65F6\u6D88\u606F",
+              details: {
+                missingKeys: [
+                  !ctx.vapid.email && "VAPID_EMAIL",
+                  !ctx.vapid.publicKey && "NEXT_PUBLIC_VAPID_PUBLIC_KEY",
+                  !ctx.vapid.privateKey && "VAPID_PRIVATE_KEY"
+                ].filter(Boolean)
+              }
+            }
+          }
+        };
+      }
+    }
+    let dbResult;
+    try {
+      dbResult = await ctx.db.createTask({
+        user_id: userId,
+        uuid: taskUuid,
+        encrypted_payload: encryptedPayload,
+        next_send_at: payload.firstSendTime,
+        message_type: payload.messageType
+      });
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        return {
+          status: 409,
+          body: {
+            success: false,
+            error: {
+              code: "TASK_UUID_CONFLICT",
+              message: "\u4EFB\u52A1 UUID \u5DF2\u5B58\u5728\uFF0C\u8BF7\u4F7F\u7528\u65B0\u7684 uuid \u91CD\u65B0\u63D0\u4EA4"
+            }
+          }
+        };
+      }
+      throw error;
+    }
+    if (!dbResult) {
+      return { status: 500, body: { success: false, error: { code: "TASK_CREATE_FAILED", message: "\u521B\u5EFA\u4EFB\u52A1\u5931\u8D25" } } };
+    }
+    if (payload.messageType === "instant") {
+      try {
+        const sendResult = await processMessagesByUuid(taskUuid, ctx, 2, userId);
+        if (!sendResult.success) {
+          return { status: 500, body: { success: false, error: { code: "MESSAGE_SEND_FAILED", message: "\u6D88\u606F\u53D1\u9001\u5931\u8D25", details: sendResult.error } } };
+        }
+        return {
+          status: 200,
+          body: {
+            success: true,
+            data: {
+              uuid: taskUuid,
+              contactName: payload.contactName,
+              messagesSent: sendResult.messagesSent,
+              sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+              status: "sent",
+              retriesUsed: sendResult.retriesUsed || 0
+            }
+          }
+        };
+      } catch (error) {
+        return { status: 500, body: { success: false, error: { code: "MESSAGE_SEND_FAILED", message: "\u6D88\u606F\u53D1\u9001\u5931\u8D25", details: { error: error.message } } } };
+      }
+    }
+    return {
+      status: 201,
+      body: {
+        success: true,
+        data: {
+          id: dbResult.id,
+          uuid: dbResult.uuid,
+          contactName: payload.contactName,
+          nextSendAt: dbResult.next_send_at,
+          status: dbResult.status,
+          createdAt: dbResult.created_at
+        }
+      }
+    };
+  }
+  return { POST };
+}
+
+// src/server/handlers/send-notifications.js
+function createSendNotificationsHandler(ctx) {
+  async function POST(headers) {
+    if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
+      return {
+        status: 500,
+        body: {
+          success: false,
+          error: {
+            code: "VAPID_CONFIG_ERROR",
+            message: "VAPID \u914D\u7F6E\u7F3A\u5931\uFF0C\u65E0\u6CD5\u53D1\u9001\u63A8\u9001\u901A\u77E5",
+            details: {
+              missingKeys: [
+                !ctx.vapid.email && "VAPID_EMAIL",
+                !ctx.vapid.publicKey && "NEXT_PUBLIC_VAPID_PUBLIC_KEY",
+                !ctx.vapid.privateKey && "VAPID_PRIVATE_KEY"
+              ].filter(Boolean)
+            }
+          }
+        }
+      };
+    }
+    const authHeader = (headers["authorization"] || "").trim();
+    const expectedAuth = `Bearer ${ctx.cronSecret}`;
+    if (authHeader !== expectedAuth) {
+      return { status: 401, body: { success: false, error: { code: "UNAUTHORIZED", message: "Cron Secret \u9A8C\u8BC1\u5931\u8D25" } } };
+    }
+    const startTime = Date.now();
+    const tasks = await ctx.db.getPendingTasks(50);
+    const MAX_CONCURRENT = 8;
+    const results = {
+      totalTasks: tasks.length,
+      successCount: 0,
+      failedCount: 0,
+      deletedOnceOffTasks: 0,
+      updatedRecurringTasks: 0,
+      failedTasks: []
+    };
+    async function handleDeliveryFailure(task, reason) {
+      results.failedCount++;
+      try {
+        if (task.retry_count >= 3) {
+          await ctx.db.updateTaskById(task.id, { status: "failed" });
+          results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count, status: "permanently_failed" });
+        } else {
+          const nextRetryTime = new Date(Date.now() + (task.retry_count + 1) * 2 * 60 * 1e3);
+          await ctx.db.updateTaskById(task.id, { next_send_at: nextRetryTime.toISOString(), retry_count: task.retry_count + 1 });
+          results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count + 1, nextRetryAt: nextRetryTime.toISOString() });
+        }
+      } catch (updateError) {
+        results.failedTasks.push({
+          taskId: task.id,
+          reason,
+          status: "retry_update_failed",
+          updateError: updateError.message
+        });
+      }
+    }
+    async function handlePostSendPersistenceFailure(task, reason) {
+      results.failedCount++;
+      let markedSent = false;
+      try {
+        await ctx.db.updateTaskById(task.id, { status: "sent", retry_count: 0 });
+        markedSent = true;
+      } catch (_markSentError) {
+        markedSent = false;
+      }
+      results.failedTasks.push({
+        taskId: task.id,
+        reason,
+        status: markedSent ? "post_send_cleanup_failed_marked_sent" : "post_send_cleanup_failed",
+        messageDelivered: true
+      });
+    }
+    async function processTask(task) {
+      let sendResult;
+      try {
+        sendResult = await processSingleMessage(task, ctx);
+      } catch (error) {
+        await handleDeliveryFailure(task, error.message || "\u6D88\u606F\u53D1\u9001\u5931\u8D25");
+        return;
+      }
+      if (!sendResult.success) {
+        await handleDeliveryFailure(task, sendResult.error || "\u6D88\u606F\u53D1\u9001\u5931\u8D25");
+        return;
+      }
+      try {
+        const userKey = deriveUserEncryptionKey(task.user_id, ctx.encryptionKey);
+        const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+        if (decryptedPayload.recurrenceType === "none") {
+          await ctx.db.deleteTaskById(task.id);
+          results.deletedOnceOffTasks++;
+        } else {
+          let nextSendAt;
+          const currentSendAt = new Date(task.next_send_at);
+          if (decryptedPayload.recurrenceType === "daily") {
+            nextSendAt = new Date(currentSendAt.getTime() + 24 * 60 * 60 * 1e3);
+          } else if (decryptedPayload.recurrenceType === "weekly") {
+            nextSendAt = new Date(currentSendAt.getTime() + 7 * 24 * 60 * 60 * 1e3);
+          }
+          await ctx.db.updateTaskById(task.id, { next_send_at: nextSendAt.toISOString(), retry_count: 0 });
+          results.updatedRecurringTasks++;
+        }
+        results.successCount++;
+      } catch (error) {
+        await handlePostSendPersistenceFailure(task, error.message || "\u53D1\u9001\u540E\u72B6\u6001\u66F4\u65B0\u5931\u8D25");
+      }
+    }
+    const taskQueue = [...tasks];
+    const processing = [];
+    while (taskQueue.length > 0 || processing.length > 0) {
+      while (processing.length < MAX_CONCURRENT && taskQueue.length > 0) {
+        const task = taskQueue.shift();
+        const promise = processTask(task);
+        processing.push(promise);
+        promise.finally(() => {
+          const index = processing.indexOf(promise);
+          if (index > -1) processing.splice(index, 1);
+        });
+      }
+      if (processing.length > 0) {
+        await Promise.race(processing);
+      }
+    }
+    await ctx.db.cleanupOldTasks(7);
+    const executionTime = Date.now() - startTime;
+    return {
+      status: 200,
+      body: {
+        success: true,
+        data: {
+          totalTasks: results.totalTasks,
+          successCount: results.successCount,
+          failedCount: results.failedCount,
+          processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          executionTime,
+          details: {
+            deletedOnceOffTasks: results.deletedOnceOffTasks,
+            updatedRecurringTasks: results.updatedRecurringTasks,
+            failedTasks: results.failedTasks
+          }
+        }
+      }
+    };
+  }
+  return { POST };
+}
+
+// src/server/handlers/update-message.js
+function createUpdateMessageHandler(ctx) {
+  async function PUT(url, headers, body) {
+    const u = new URL(url, "https://dummy");
+    const taskUuid = u.searchParams.get("id");
+    if (!taskUuid) {
+      return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
+    }
+    const userId = headers["x-user-id"];
+    if (!userId) {
+      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
+    }
+    const isEncrypted = headers["x-payload-encrypted"] === "true";
+    const encryptionVersion = headers["x-encryption-version"];
+    if (!isEncrypted) {
+      return { status: 400, body: { success: false, error: { code: "ENCRYPTION_REQUIRED", message: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6" } } };
+    }
+    if (encryptionVersion !== "1") {
+      return { status: 400, body: { success: false, error: { code: "UNSUPPORTED_ENCRYPTION_VERSION", message: "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301" } } };
+    }
+    const parsedBody = parseEncryptedBody(body);
+    if (!parsedBody.ok) {
+      return { status: 400, body: { success: false, error: parsedBody.error } };
+    }
+    const encryptedBody = parsedBody.data;
+    const userKey = deriveUserEncryptionKey(userId, ctx.encryptionKey);
+    let updates;
+    try {
+      updates = decryptPayload(encryptedBody, userKey);
+    } catch (_error) {
+      return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
+    }
+    if (!isPlainObject(updates)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF" } } };
+    }
+    if (updates.nextSendAt && !isValidISO8601(updates.nextSendAt)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["nextSendAt"] } } } };
+    }
+    if (updates.recurrenceType && !["none", "daily", "weekly"].includes(updates.recurrenceType)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["recurrenceType"] } } } };
+    }
+    const existingTask = await ctx.db.getTaskByUuid(taskUuid, userId);
+    if (!existingTask) {
+      const taskStatus = await ctx.db.getTaskStatus(taskUuid, userId);
+      if (!taskStatus) {
+        return { status: 404, body: { success: false, error: { code: "TASK_NOT_FOUND", message: "\u6307\u5B9A\u7684\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u5220\u9664" } } };
+      }
+      return { status: 409, body: { success: false, error: { code: "TASK_ALREADY_COMPLETED", message: "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u6216\u5DF2\u5931\u8D25\uFF0C\u65E0\u6CD5\u66F4\u65B0" } } };
+    }
+    const existingData = JSON.parse(decryptFromStorage(existingTask.encrypted_payload, userKey));
+    const updatedData = {
+      ...existingData,
+      ...updates.completePrompt && { completePrompt: updates.completePrompt },
+      ...updates.userMessage && { userMessage: updates.userMessage },
+      ...updates.recurrenceType && { recurrenceType: updates.recurrenceType },
+      ...updates.avatarUrl && { avatarUrl: updates.avatarUrl },
+      ...updates.metadata && { metadata: updates.metadata }
+    };
+    const encryptedPayload = encryptForStorage(JSON.stringify(updatedData), userKey);
+    const extraFields = updates.nextSendAt ? { next_send_at: updates.nextSendAt } : void 0;
+    const result = await ctx.db.updateTaskByUuid(taskUuid, userId, encryptedPayload, extraFields);
+    if (!result) {
+      return { status: 409, body: { success: false, error: { code: "UPDATE_CONFLICT", message: "\u4EFB\u52A1\u66F4\u65B0\u5931\u8D25\uFF0C\u4EFB\u52A1\u53EF\u80FD\u5DF2\u88AB\u4FEE\u6539\u6216\u5220\u9664" } } };
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        data: {
+          uuid: taskUuid,
+          updatedFields: Object.keys(updates),
+          updatedAt: result.updated_at
+        }
+      }
+    };
+  }
+  return { PUT };
+}
+
+// src/server/handlers/cancel-message.js
+function createCancelMessageHandler(ctx) {
+  async function DELETE(url, headers) {
+    const u = new URL(url, "https://dummy");
+    const taskUuid = u.searchParams.get("id");
+    if (!taskUuid) {
+      return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
+    }
+    const userId = headers["x-user-id"];
+    if (!userId) {
+      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
+    }
+    const deleted = await ctx.db.deleteTaskByUuid(taskUuid, userId);
+    if (!deleted) {
+      return {
+        status: 404,
+        body: { success: false, error: { code: "TASK_NOT_FOUND", message: "\u6307\u5B9A\u7684\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u5220\u9664" } }
+      };
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        data: { uuid: taskUuid, message: "\u4EFB\u52A1\u5DF2\u6210\u529F\u53D6\u6D88", deletedAt: (/* @__PURE__ */ new Date()).toISOString() }
+      }
+    };
+  }
+  return { DELETE };
+}
+
+// src/server/handlers/messages.js
+function createMessagesHandler(ctx) {
+  async function GET(url, headers) {
+    const userId = headers["x-user-id"];
+    if (!userId) {
+      return {
+        status: 400,
+        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u5FC5\u987B\u63D0\u4F9B X-User-Id \u8BF7\u6C42\u5934" } }
+      };
+    }
+    const u = new URL(url, "https://dummy");
+    const status = u.searchParams.get("status") || "all";
+    const limit = Math.min(parseInt(u.searchParams.get("limit") || "20", 10), 100);
+    const offset = parseInt(u.searchParams.get("offset") || "0", 10);
+    if (isNaN(limit) || limit < 1) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_PARAMETERS", message: "limit \u53C2\u6570\u65E0\u6548\uFF0C\u5FC5\u987B\u4E3A\u6B63\u6574\u6570" } } };
+    }
+    if (isNaN(offset) || offset < 0) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_PARAMETERS", message: "offset \u53C2\u6570\u65E0\u6548\uFF0C\u5FC5\u987B\u4E3A\u975E\u8D1F\u6574\u6570" } } };
+    }
+    const { tasks, total } = await ctx.db.listTasks(userId, { status, limit, offset });
+    const userKey = deriveUserEncryptionKey(userId, ctx.encryptionKey);
+    const decryptedTasks = tasks.map((task) => {
+      const decrypted = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+      return {
+        id: task.id,
+        uuid: task.uuid,
+        contactName: decrypted.contactName,
+        messageType: task.message_type,
+        messageSubtype: decrypted.messageSubtype,
+        nextSendAt: task.next_send_at,
+        recurrenceType: decrypted.recurrenceType,
+        status: task.status,
+        retryCount: task.retry_count,
+        createdAt: task.created_at,
+        updatedAt: task.updated_at
+      };
+    });
+    const responsePayload = {
+      tasks: decryptedTasks,
+      pagination: { total, limit, offset, hasMore: offset + limit < total }
+    };
+    const encryptedResponse = encryptPayload(responsePayload, userKey);
+    return {
+      status: 200,
+      body: {
+        success: true,
+        encrypted: true,
+        version: 1,
+        data: encryptedResponse
+      }
+    };
+  }
+  return { GET };
+}
+
+// src/server/index.js
+function normalizeVapidSubject(email) {
+  const trimmedEmail = String(email || "").trim();
+  if (!trimmedEmail) return "";
+  return /^mailto:/i.test(trimmedEmail) ? trimmedEmail : `mailto:${trimmedEmail}`;
+}
+async function createReiServer(config) {
+  if (!config) throw new Error("[rei-standard-amsg-server] config is required");
+  if (!config.encryptionKey) throw new Error("[rei-standard-amsg-server] encryptionKey is required");
+  const adapter = await createAdapter(config.db);
+  let webpushModule;
+  try {
+    const webpushImport = await Promise.resolve().then(() => _interopRequireWildcard(require("web-push")));
+    webpushModule = webpushImport.default || webpushImport;
+  } catch (_err) {
+    throw new Error(
+      "[rei-standard-amsg-server] web-push is required. Install it with: npm install web-push"
+    );
+  }
+  const vapid = config.vapid || {};
+  if (vapid.email && vapid.publicKey && vapid.privateKey) {
+    webpushModule.setVapidDetails(
+      normalizeVapidSubject(vapid.email),
+      vapid.publicKey,
+      vapid.privateKey
+    );
+  }
+  const ctx = {
+    db: adapter,
+    encryptionKey: config.encryptionKey,
+    cronSecret: config.cronSecret || "",
+    initSecret: config.initSecret || "",
+    vapid: {
+      email: vapid.email || "",
+      publicKey: vapid.publicKey || "",
+      privateKey: vapid.privateKey || ""
+    },
+    webpush: webpushModule
+  };
+  return {
+    handlers: {
+      initDatabase: createInitDatabaseHandler(ctx),
+      getMasterKey: createGetMasterKeyHandler(ctx),
+      scheduleMessage: createScheduleMessageHandler(ctx),
+      sendNotifications: createSendNotificationsHandler(ctx),
+      updateMessage: createUpdateMessageHandler(ctx),
+      cancelMessage: createCancelMessageHandler(ctx),
+      messages: createMessagesHandler(ctx)
+    },
+    adapter
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.createAdapter = createAdapter; exports.createReiServer = createReiServer; exports.decryptFromStorage = decryptFromStorage; exports.decryptPayload = decryptPayload; exports.deriveUserEncryptionKey = deriveUserEncryptionKey; exports.encryptForStorage = encryptForStorage; exports.isValidISO8601 = isValidISO8601; exports.isValidUUID = isValidUUID; exports.isValidUrl = isValidUrl; exports.validateScheduleMessagePayload = validateScheduleMessagePayload;