@rei-standard/amsg-server 2.5.3 → 2.6.0-next.1

package/dist/chunk-6WA3XDPP.mjs

@@ -0,0 +1,1826 @@
+// src/server/lib/validation.js
+import { validateAvatarUrl } from "@rei-standard/amsg-shared";
+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 {
+    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 isValidUUIDv4(uuid) {
+  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidV4Regex.test(uuid);
+}
+var VALID_LLM_MESSAGE_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool"]);
+var SPLIT_PATTERN_MAX_LENGTH = 200;
+var SPLIT_PATTERN_MAX_ITEMS = 10;
+function validateSplitPattern(value) {
+  if (value === void 0 || value === null) return null;
+  const isArray = Array.isArray(value);
+  const items = isArray ? value : [value];
+  if (isArray && items.length === 0) return null;
+  if (items.length > SPLIT_PATTERN_MAX_ITEMS) {
+    return `splitPattern \u6570\u7EC4\u6700\u591A ${SPLIT_PATTERN_MAX_ITEMS} \u9879`;
+  }
+  for (let i = 0; i < items.length; i++) {
+    const s = items[i];
+    const label = isArray ? `splitPattern[${i}]` : "splitPattern";
+    if (typeof s !== "string") return `${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`;
+    if (s.length > SPLIT_PATTERN_MAX_LENGTH) {
+      return `${label} \u4E0D\u80FD\u8D85\u8FC7 ${SPLIT_PATTERN_MAX_LENGTH} \u5B57\u7B26`;
+    }
+    try {
+      new RegExp(s);
+    } catch (_) {
+      return `${label} \u4E0D\u662F\u6709\u6548\u6B63\u5219\u8868\u8FBE\u5F0F`;
+    }
+  }
+  return null;
+}
+function validateLlmMessagesArray(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return "messages must be a non-empty array";
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (!m || typeof m !== "object" || Array.isArray(m)) {
+      return `messages[${i}] must be an object`;
+    }
+    if (!VALID_LLM_MESSAGE_ROLES.has(m.role)) {
+      return `messages[${i}].role must be one of system / user / assistant / tool`;
+    }
+    if (typeof m.content === "string") {
+      if (!m.content) return `messages[${i}].content must be a non-empty string`;
+    } else if (Array.isArray(m.content)) {
+      if (m.content.length === 0) return `messages[${i}].content array must be non-empty`;
+    } else {
+      return `messages[${i}].content must be a non-empty string or a non-empty array`;
+    }
+  }
+  return null;
+}
+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.maxTokens !== void 0 && payload.maxTokens !== null && (!Number.isInteger(payload.maxTokens) || payload.maxTokens <= 0)) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["maxTokens"] } };
+  }
+  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)"] } };
+    }
+  }
+  const promptCheck = (() => {
+    const hasCompletePrompt = payload.completePrompt !== void 0 && payload.completePrompt !== null && payload.completePrompt !== "";
+    const hasMessages = payload.messages !== void 0 && payload.messages !== null;
+    if (hasCompletePrompt && hasMessages) {
+      return {
+        error: { code: "INVALID_PARAMETERS", message: "exactly one of `completePrompt` or `messages` must be provided\uFF08\u4E24\u8005\u4E0D\u80FD\u540C\u65F6\u51FA\u73B0\uFF09", details: { invalidFields: ["completePrompt", "messages"] } },
+        hasCompletePrompt: true,
+        hasMessages: true
+      };
+    }
+    if (hasMessages) {
+      const err = validateLlmMessagesArray(payload.messages);
+      if (err) {
+        return {
+          error: { code: "INVALID_PARAMETERS", message: err, details: { invalidFields: ["messages"] } },
+          hasCompletePrompt: false,
+          hasMessages: true
+        };
+      }
+    }
+    return { error: null, hasCompletePrompt, hasMessages };
+  })();
+  if (promptCheck.error) {
+    return { valid: false, errorCode: promptCheck.error.code, errorMessage: promptCheck.error.message, details: promptCheck.error.details };
+  }
+  const hasPrompt = promptCheck.hasCompletePrompt || promptCheck.hasMessages;
+  if (payload.messageType === "prompted" || payload.messageType === "auto") {
+    const missingAiFields = [];
+    if (!hasPrompt) missingAiFields.push("completePrompt or messages");
+    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 = hasPrompt && 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 | messages) + apiUrl + apiKey + primaryModel)"] } };
+    }
+  }
+  if (payload.temperature !== void 0 && payload.temperature !== null && (typeof payload.temperature !== "number" || !Number.isFinite(payload.temperature))) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["temperature (must be a finite number)"] } };
+  }
+  const avatarErr = validateAvatarUrl(payload.avatarUrl);
+  if (avatarErr) {
+    console.warn("[amsg-server] avatarUrl \u4E0D\u5408\u6CD5\uFF0C\u5DF2\u7F6E\u7A7A\uFF1A", avatarErr);
+    payload.avatarUrl = null;
+  }
+  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 !== void 0 && payload.messageSubtype !== null && typeof payload.messageSubtype !== "string") {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["messageSubtype"] } };
+  }
+  const splitErr = validateSplitPattern(payload.splitPattern);
+  if (splitErr) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: splitErr, details: { invalidFields: ["splitPattern"] } };
+  }
+  return { valid: true };
+}
+
+// src/server/lib/encryption.js
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
+function deriveUserEncryptionKey(userId, masterKey) {
+  return createHash("sha256").update(masterKey + userId).digest("hex").slice(0, 64);
+}
+function decryptPayload(encryptedPayload, encryptionKey) {
+  const { iv, authTag, encryptedData } = encryptedPayload;
+  const decipher = createDecipheriv(
+    "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 = randomBytes(12);
+  const cipher = createCipheriv("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 = randomBytes(16);
+  const cipher = createCipheriv("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 = createDecipheriv(
+    "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/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 {
+      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;
+}
+function getHeader(headers = {}, name) {
+  if (!headers || typeof headers !== "object") {
+    return "";
+  }
+  const lowerName = String(name || "").toLowerCase();
+  if (!lowerName) return "";
+  for (const [key, value] of Object.entries(headers)) {
+    if (String(key).toLowerCase() === lowerName) {
+      return String(value || "").trim();
+    }
+  }
+  return "";
+}
+
+// src/server/handlers/get-user-key.js
+function createGetUserKeyHandler(ctx) {
+  async function GET(url, headers) {
+    const effectiveHeaders = headers || url || {};
+    const tenantResult = await ctx.tenantManager.resolveTenant(effectiveHeaders);
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const { masterKey } = tenantResult.context;
+    const userId = getHeader(effectiveHeaders, "x-user-id");
+    if (!userId) {
+      return {
+        status: 400,
+        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } }
+      };
+    }
+    if (!isValidUUIDv4(userId)) {
+      return {
+        status: 400,
+        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
+      };
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        data: {
+          userKey: deriveUserEncryptionKey(userId, masterKey),
+          version: 1
+        }
+      }
+    };
+  }
+  return { GET };
+}
+
+// src/server/handlers/schedule-message.js
+import { randomUUID as randomUUID2 } from "crypto";
+
+// 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/message-processor.js
+import { randomUUID } from "crypto";
+import {
+  buildContentPush,
+  buildReasoningPush,
+  readReasoningContent,
+  stripReasoningTags
+} from "@rei-standard/amsg-shared";
+var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
+var SLEEP_BETWEEN_MESSAGES_MS = 1500;
+function splitOnceByRegex(chunk, regex) {
+  const out = chunk.split(regex).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);
+  return out.length > 0 ? out : [chunk];
+}
+function splitMessageIntoSentences(messageContent, splitPattern = null) {
+  const sources = splitPattern == null ? null : Array.isArray(splitPattern) ? splitPattern : [splitPattern];
+  const regexes = sources && sources.length > 0 ? sources.map((s) => new RegExp(s)) : [DEFAULT_SPLIT_REGEX];
+  let chunks = [messageContent];
+  for (const regex of regexes) {
+    chunks = chunks.flatMap((c) => splitOnceByRegex(c, regex));
+  }
+  return chunks.length > 0 ? chunks : [messageContent];
+}
+async function processSingleMessage(task, ctx, providedMasterKey) {
+  try {
+    const masterKey = providedMasterKey || ctx.masterKey;
+    if (!masterKey) {
+      return { success: false, messagesSent: 0, error: "TENANT_MASTER_KEY_MISSING" };
+    }
+    const userKey = deriveUserEncryptionKey(task.user_id, masterKey);
+    const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+    let messageContent;
+    let llmResponse = null;
+    if (decryptedPayload.messageType === "fixed") {
+      messageContent = decryptedPayload.userMessage;
+    } else if (decryptedPayload.messageType === "instant") {
+      const hasPrompt = !!decryptedPayload.completePrompt || Array.isArray(decryptedPayload.messages) && decryptedPayload.messages.length > 0;
+      if (hasPrompt && decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel) {
+        const aiResult = await _callAI(decryptedPayload);
+        messageContent = aiResult.content;
+        llmResponse = aiResult.response;
+      } 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") {
+      const aiResult = await _callAI(decryptedPayload);
+      messageContent = aiResult.content;
+      llmResponse = aiResult.response;
+    } else {
+      throw new Error("Invalid message configuration: no content source available");
+    }
+    const reasoning = readReasoningContent(llmResponse);
+    if (reasoning) {
+      messageContent = stripReasoningTags(messageContent);
+    }
+    const messages = splitMessageIntoSentences(messageContent, decryptedPayload.splitPattern ?? null);
+    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;
+    const sessionId = task.id != null ? `sess_task_${task.id}` : `sess_${randomUUID()}`;
+    const source = decryptedPayload.messageType === "instant" ? "instant" : "scheduled";
+    const messageSubtype = decryptedPayload.messageSubtype || "chat";
+    const avatarUrl = decryptedPayload.avatarUrl || null;
+    const metadata = decryptedPayload.metadata || {};
+    const messageIdBase = task.id != null ? `msg_task_${task.id}` : `msg_${randomUUID()}_instant`;
+    if (reasoning) {
+      const reasoningPush = buildReasoningPush({
+        messageType: decryptedPayload.messageType,
+        source,
+        messageId: `${messageIdBase}_reasoning`,
+        sessionId,
+        reasoningContent: reasoning,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        title: `\u6765\u81EA ${decryptedPayload.contactName}`,
+        contactName: decryptedPayload.contactName,
+        avatarUrl,
+        messageSubtype,
+        metadata
+      });
+      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(reasoningPush));
+      await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS));
+    }
+    for (let i = 0; i < messages.length; i++) {
+      const contentPush = buildContentPush({
+        messageType: decryptedPayload.messageType,
+        source,
+        messageId: `${messageIdBase}_${i}`,
+        sessionId,
+        message: messages[i],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        title: `\u6765\u81EA ${decryptedPayload.contactName}`,
+        contactName: decryptedPayload.contactName,
+        avatarUrl,
+        messageSubtype,
+        messageIndex: i + 1,
+        totalMessages: messages.length,
+        taskId: task.id || null,
+        metadata
+      });
+      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(contentPush));
+      if (i < messages.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS));
+      }
+    }
+    return { success: true, messagesSent: messages.length };
+  } catch (error) {
+    return { success: false, messagesSent: 0, error: error.message };
+  }
+}
+async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, providedMasterKey) {
+  let retryCount = 0;
+  const masterKey = providedMasterKey || ctx.masterKey;
+  if (!masterKey) {
+    return {
+      success: false,
+      error: { code: "TENANT_MASTER_KEY_MISSING", message: "\u79DF\u6237\u4E3B\u5BC6\u94A5\u4E0D\u5B58\u5728\u6216\u914D\u7F6E\u5F02\u5E38" }
+    };
+  }
+  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, masterKey);
+    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 normalizedApiUrl = normalizeAiApiUrl(payload.apiUrl);
+  const requestBody = buildAiRequestBody(payload);
+  const aiResponse = await fetch(normalizedApiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${payload.apiKey}`
+    },
+    body: JSON.stringify(requestBody),
+    signal: AbortSignal.timeout(3e5)
+  });
+  if (!aiResponse.ok) {
+    if (aiResponse.status === 405) {
+      throw new Error(
+        `AI API error: 405 Method Not Allowed. apiUrl must point to a full chat endpoint (for example: /chat/completions). Received: ${normalizedApiUrl}`
+      );
+    }
+    throw new Error(
+      `AI API error: ${aiResponse.status} ${aiResponse.statusText || "Unknown Error"}. Request URL: ${normalizedApiUrl}`
+    );
+  }
+  const aiData = await aiResponse.json();
+  const content = aiData?.choices?.[0]?.message?.content;
+  if (typeof content !== "string" || !content.trim()) {
+    throw new Error("AI API error: response missing choices[0].message.content");
+  }
+  return { response: aiData, content: content.trim() };
+}
+function buildAiRequestBody(payload) {
+  const llmMessages = Array.isArray(payload.messages) && payload.messages.length > 0 ? payload.messages : [{ role: "user", content: payload.completePrompt }];
+  const requestBody = {
+    model: payload.primaryModel,
+    messages: llmMessages
+  };
+  if (payload.temperature !== void 0 && payload.temperature !== null) {
+    requestBody.temperature = payload.temperature;
+  } else if (!Array.isArray(payload.messages)) {
+    requestBody.temperature = 0.8;
+  }
+  if (payload.maxTokens === void 0 || payload.maxTokens === null) {
+    return requestBody;
+  }
+  if (!Number.isInteger(payload.maxTokens) || payload.maxTokens <= 0) {
+    throw new Error("Invalid maxTokens: maxTokens must be a positive integer when provided.");
+  }
+  requestBody.max_tokens = payload.maxTokens;
+  return requestBody;
+}
+function normalizeAiApiUrl(apiUrl) {
+  if (typeof apiUrl !== "string" || !apiUrl.trim()) {
+    throw new Error(
+      "Invalid apiUrl: apiUrl is required. Please provide a chat endpoint URL (for example: https://api.openai.com or https://api.openai.com/v1/chat/completions)."
+    );
+  }
+  const trimmedApiUrl = apiUrl.trim();
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(trimmedApiUrl);
+  } catch {
+    throw new Error(
+      `Invalid apiUrl: "${apiUrl}". Please provide a valid absolute URL.`
+    );
+  }
+  let path = parsedUrl.pathname.replace(/\/+$/, "") || "/";
+  if (/\/chat\/completions$/.test(path)) {
+  } else if (path === "/") {
+    path = "/v1/chat/completions";
+  } else if (/\/v\d+$/.test(path)) {
+    path = `${path}/chat/completions`;
+  }
+  parsedUrl.pathname = path;
+  return parsedUrl.toString();
+}
+
+// src/server/handlers/schedule-message.js
+function createScheduleMessageHandler(ctx) {
+  async function POST(headers, body) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const tenantCtx = tenantResult.context;
+    const db = tenantCtx.db;
+    const masterKey = tenantCtx.masterKey;
+    const isEncrypted = getHeader(headers, "x-payload-encrypted") === "true";
+    const encryptionVersion = getHeader(headers, "x-encryption-version");
+    const userId = getHeader(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 (!isValidUUIDv4(userId)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
+    }
+    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, masterKey);
+      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 || randomUUID2();
+    const userKey = deriveUserEncryptionKey(userId, masterKey);
+    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,
+      // Prompt is one-of: legacy completePrompt (string) OR messages (OpenAI-
+      // style array). Validation has already enforced exactly-one-of, so
+      // exactly one of these will be non-null when an AI config is provided.
+      completePrompt: payload.completePrompt || null,
+      messages: Array.isArray(payload.messages) ? payload.messages : null,
+      maxTokens: payload.maxTokens ?? null,
+      temperature: payload.temperature ?? null,
+      // 0.6.0+: optional caller-provided regex (string or string[]) used by
+      // the message processor to chunk LLM output into individual pushes.
+      // null → processor falls back to the default /([。！？!?]+)/ regex.
+      splitPattern: payload.splitPattern ?? 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 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,
+          db,
+          masterKey
+        }, 2, userId, masterKey);
+        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/lib/run-tick.js
+async function runScheduledTick(ctx) {
+  const db = ctx.db;
+  const masterKey = ctx.masterKey;
+  const startTime = Date.now();
+  const tasks = await 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 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 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 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, db, masterKey }, masterKey);
+    } 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, masterKey);
+      const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+      if (decryptedPayload.recurrenceType === "none") {
+        await 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 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 db.cleanupOldTasks(7);
+  const executionTime = Date.now() - startTime;
+  return {
+    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
+    }
+  };
+}
+
+// src/server/handlers/update-message.js
+function createUpdateMessageHandler(ctx) {
+  async function PUT(url, headers, body) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers, { url });
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const tenantCtx = tenantResult.context;
+    const db = tenantCtx.db;
+    const masterKey = tenantCtx.masterKey;
+    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 = getHeader(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" } } };
+    }
+    if (!isValidUUIDv4(userId)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
+    }
+    const isEncrypted = getHeader(headers, "x-payload-encrypted") === "true";
+    const encryptionVersion = getHeader(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, masterKey);
+    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"] } } } };
+    }
+    if (Object.prototype.hasOwnProperty.call(updates, "maxTokens") && updates.maxTokens !== null && (!Number.isInteger(updates.maxTokens) || updates.maxTokens <= 0)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["maxTokens"] } } } };
+    }
+    if (updates.completePrompt && updates.messages !== void 0 && updates.messages !== null) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "completePrompt \u4E0E messages \u4E0D\u80FD\u540C\u65F6\u66F4\u65B0\uFF08\u4E8C\u9009\u4E00\uFF09", details: { invalidFields: ["completePrompt", "messages"] } } } };
+    }
+    if (updates.messages !== void 0 && updates.messages !== null) {
+      const msgErr = validateLlmMessagesArray(updates.messages);
+      if (msgErr) {
+        return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: msgErr, details: { invalidFields: ["messages"] } } } };
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(updates, "temperature") && updates.temperature !== null && (typeof updates.temperature !== "number" || !Number.isFinite(updates.temperature))) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["temperature"] } } } };
+    }
+    if (Object.prototype.hasOwnProperty.call(updates, "splitPattern")) {
+      const splitErr = validateSplitPattern(updates.splitPattern);
+      if (splitErr) {
+        return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: splitErr, details: { invalidFields: ["splitPattern"] } } } };
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(updates, "avatarUrl")) {
+      const avatarErr = validateAvatarUrl(updates.avatarUrl);
+      if (avatarErr) {
+        console.warn("[amsg-server] update-message avatarUrl \u4E0D\u5408\u6CD5\uFF0C\u5DF2\u5FFD\u7565\uFF1A", avatarErr);
+        delete updates.avatarUrl;
+      }
+    }
+    const existingTask = await db.getTaskByUuid(taskUuid, userId);
+    if (!existingTask) {
+      const taskStatus = await 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 promptUpdates = {};
+    if (updates.completePrompt) {
+      promptUpdates.completePrompt = updates.completePrompt;
+      promptUpdates.messages = null;
+    } else if (updates.messages !== void 0 && updates.messages !== null) {
+      promptUpdates.messages = updates.messages;
+      promptUpdates.completePrompt = null;
+    }
+    const updatedData = {
+      ...existingData,
+      ...promptUpdates,
+      ...updates.userMessage && { userMessage: updates.userMessage },
+      ...updates.recurrenceType && { recurrenceType: updates.recurrenceType },
+      ...updates.avatarUrl && { avatarUrl: updates.avatarUrl },
+      ...updates.metadata && { metadata: updates.metadata },
+      ...Object.prototype.hasOwnProperty.call(updates, "maxTokens") && { maxTokens: updates.maxTokens ?? null },
+      ...Object.prototype.hasOwnProperty.call(updates, "temperature") && { temperature: updates.temperature ?? null },
+      // splitPattern: hasOwnProperty so that explicit `null` (= revert to
+      // default) doesn't get swallowed by truthy-spread the way the optional
+      // string fields above are.
+      ...Object.prototype.hasOwnProperty.call(updates, "splitPattern") && { splitPattern: updates.splitPattern ?? null }
+    };
+    const encryptedPayload = encryptForStorage(JSON.stringify(updatedData), userKey);
+    const extraFields = updates.nextSendAt ? { next_send_at: updates.nextSendAt } : void 0;
+    const result = await 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 tenantResult = await ctx.tenantManager.resolveTenant(headers, { url });
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const db = tenantResult.context.db;
+    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 = getHeader(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" } } };
+    }
+    if (!isValidUUIDv4(userId)) {
+      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
+    }
+    const deleted = await 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 tenantResult = await ctx.tenantManager.resolveTenant(headers, { url });
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const tenantCtx = tenantResult.context;
+    const db = tenantCtx.db;
+    const masterKey = tenantCtx.masterKey;
+    const userId = getHeader(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" } }
+      };
+    }
+    if (!isValidUUIDv4(userId)) {
+      return {
+        status: 400,
+        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
+      };
+    }
+    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 db.listTasks(userId, { status, limit, offset });
+    const userKey = deriveUserEncryptionKey(userId, masterKey);
+    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/adapters/schema.sqlite.js
+var SQLITE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS scheduled_messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id TEXT NOT NULL,
+    uuid TEXT,
+    encrypted_payload TEXT NOT NULL,
+    message_type TEXT NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),
+    next_send_at TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+    retry_count INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )
+`;
+var SQLITE_INDEXES = [
+  {
+    name: "idx_pending_tasks_optimized",
+    sql: `CREATE INDEX IF NOT EXISTS idx_pending_tasks_optimized
+          ON scheduled_messages (status, next_send_at, id, retry_count)
+          WHERE status = 'pending'`,
+    description: "Main query index (Cron Job finds pending tasks)",
+    critical: false
+  },
+  {
+    name: "idx_cleanup_completed",
+    sql: `CREATE INDEX IF NOT EXISTS idx_cleanup_completed
+          ON scheduled_messages (status, updated_at)
+          WHERE status IN ('sent', 'failed')`,
+    description: "Cleanup query index",
+    critical: false
+  },
+  {
+    name: "idx_failed_retry",
+    sql: `CREATE INDEX IF NOT EXISTS idx_failed_retry
+          ON scheduled_messages (status, retry_count, next_send_at)
+          WHERE status = 'failed' AND retry_count < 3`,
+    description: "Failed retry index",
+    critical: false
+  },
+  {
+    name: "idx_user_id",
+    sql: `CREATE INDEX IF NOT EXISTS idx_user_id
+          ON scheduled_messages (user_id)`,
+    description: "User task query index",
+    critical: false
+  },
+  {
+    name: "uidx_uuid",
+    sql: `CREATE UNIQUE INDEX IF NOT EXISTS uidx_uuid
+          ON scheduled_messages (uuid)
+          WHERE uuid IS NOT NULL`,
+    description: "UUID uniqueness guard",
+    critical: true
+  }
+];
+
+// src/server/adapters/d1.js
+var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
+  "user_id",
+  "uuid",
+  "encrypted_payload",
+  "message_type",
+  "next_send_at",
+  "status",
+  "retry_count",
+  "created_at",
+  "updated_at"
+]);
+var D1Adapter = class {
+  /** @param {{ prepare: (sql: string) => any }} db - Cloudflare D1 binding */
+  constructor(db) {
+    this._db = db;
+  }
+  /** @private */
+  _now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /** @private */
+  _iso(value) {
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) {
+      throw new Error(`[amsg-server D1] invalid timestamp: ${value}`);
+    }
+    return d.toISOString();
+  }
+  async initSchema() {
+    await this._db.prepare(SQLITE_TABLE_SQL).run();
+    const indexResults = [];
+    for (const index of SQLITE_INDEXES) {
+      try {
+        await this._db.prepare(index.sql).run();
+        indexResults.push({ name: index.name, status: "success", description: index.description, critical: !!index.critical });
+      } catch (error) {
+        indexResults.push({ name: index.name, status: "failed", description: index.description, critical: !!index.critical, error: error.message });
+      }
+    }
+    const criticalFailures = indexResults.filter((i) => i.critical && i.status === "failed");
+    if (criticalFailures.length > 0) {
+      const names = criticalFailures.map((i) => i.name).join(", ");
+      throw new Error(
+        `Critical index creation failed (${names}). Please remove duplicate UUID rows and run initSchema again.`
+      );
+    }
+    return {
+      columnsCreated: 10,
+      indexesCreated: indexResults.filter((r) => r.status === "success").length,
+      indexesFailed: indexResults.filter((r) => r.status === "failed").length,
+      columns: [],
+      indexes: indexResults
+    };
+  }
+  async dropSchema() {
+    await this._db.prepare("DROP TABLE IF EXISTS scheduled_messages").run();
+  }
+  async createTask(params) {
+    const now = this._now();
+    const nextSendAt = this._iso(params.next_send_at);
+    const res = await this._db.prepare(
+      `INSERT INTO scheduled_messages
+        (user_id, uuid, encrypted_payload, next_send_at, message_type, status, retry_count, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'pending', 0, ?, ?)`
+    ).bind(params.user_id, params.uuid, params.encrypted_payload, nextSendAt, params.message_type, now, now).run();
+    const id = res.meta.last_row_id;
+    return this._db.prepare(
+      `SELECT id, uuid, next_send_at, status, created_at FROM scheduled_messages WHERE id = ?`
+    ).bind(id).first();
+  }
+  async getTaskByUuid(uuid, userId) {
+    return this._db.prepare(
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+       FROM scheduled_messages
+       WHERE uuid = ? AND user_id = ? AND status = 'pending'
+       LIMIT 1`
+    ).bind(uuid, userId).first();
+  }
+  async getTaskByUuidOnly(uuid) {
+    return this._db.prepare(
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+       FROM scheduled_messages
+       WHERE uuid = ? AND status = 'pending'
+       LIMIT 1`
+    ).bind(uuid).first();
+  }
+  async updateTaskById(taskId, updates) {
+    const sets = [];
+    const values = [];
+    for (const [key, value] of Object.entries(updates)) {
+      if (!UPDATABLE_COLUMNS.has(key)) {
+        throw new Error(`[amsg-server D1] rejected unknown update column: ${key}`);
+      }
+      sets.push(`${key} = ?`);
+      values.push(key === "next_send_at" ? this._iso(value) : value);
+    }
+    if (!Object.prototype.hasOwnProperty.call(updates, "updated_at")) {
+      sets.push("updated_at = ?");
+      values.push(this._now());
+    }
+    values.push(taskId);
+    await this._db.prepare(
+      `UPDATE scheduled_messages SET ${sets.join(", ")} WHERE id = ?`
+    ).bind(...values).run();
+    return this._db.prepare("SELECT * FROM scheduled_messages WHERE id = ?").bind(taskId).first();
+  }
+  async updateTaskByUuid(uuid, userId, encryptedPayload, extraFields) {
+    const now = this._now();
+    const sets = ["encrypted_payload = ?", "updated_at = ?"];
+    const values = [encryptedPayload, now];
+    if (extraFields) {
+      for (const [key, value] of Object.entries(extraFields)) {
+        if (!UPDATABLE_COLUMNS.has(key)) {
+          throw new Error(`[amsg-server D1] rejected unknown update column: ${key}`);
+        }
+        sets.push(`${key} = ?`);
+        values.push(key === "next_send_at" ? this._iso(value) : value);
+      }
+    }
+    values.push(uuid, userId);
+    const res = await this._db.prepare(
+      `UPDATE scheduled_messages SET ${sets.join(", ")}
+       WHERE uuid = ? AND user_id = ? AND status = 'pending'`
+    ).bind(...values).run();
+    if (!res.meta.changes) return null;
+    return { uuid, updated_at: now };
+  }
+  async deleteTaskById(taskId) {
+    const res = await this._db.prepare("DELETE FROM scheduled_messages WHERE id = ?").bind(taskId).run();
+    return res.meta.changes > 0;
+  }
+  async deleteTaskByUuid(uuid, userId) {
+    const res = await this._db.prepare(
+      "DELETE FROM scheduled_messages WHERE uuid = ? AND user_id = ?"
+    ).bind(uuid, userId).run();
+    return res.meta.changes > 0;
+  }
+  async getPendingTasks(limit = 50) {
+    const res = await this._db.prepare(
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+       FROM scheduled_messages
+       WHERE status = 'pending' AND next_send_at <= ?
+       ORDER BY next_send_at ASC
+       LIMIT ?`
+    ).bind(this._now(), limit).all();
+    return res.results || [];
+  }
+  async listTasks(userId, opts = {}) {
+    const { status = "all", limit = 20, offset = 0 } = opts;
+    const conditions = ["user_id = ?"];
+    const params = [userId];
+    if (status !== "all") {
+      conditions.push("status = ?");
+      params.push(status);
+    }
+    const where = conditions.join(" AND ");
+    const countRow = await this._db.prepare(
+      `SELECT COUNT(*) as count FROM scheduled_messages WHERE ${where}`
+    ).bind(...params).first();
+    const total = Number(countRow.count) || 0;
+    const res = await this._db.prepare(
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+       FROM scheduled_messages
+       WHERE ${where}
+       ORDER BY next_send_at ASC
+       LIMIT ? OFFSET ?`
+    ).bind(...params, limit, offset).all();
+    return { tasks: res.results || [], total };
+  }
+  async cleanupOldTasks(days = 7) {
+    const safeDays = Math.max(1, Math.floor(Number(days)));
+    const cutoff = new Date(Date.now() - safeDays * 24 * 60 * 60 * 1e3).toISOString();
+    const res = await this._db.prepare(
+      `DELETE FROM scheduled_messages
+       WHERE status IN ('sent', 'failed') AND updated_at < ?`
+    ).bind(cutoff).run();
+    return res.meta.changes || 0;
+  }
+  async getTaskStatus(uuid, userId) {
+    const row = await this._db.prepare(
+      "SELECT status FROM scheduled_messages WHERE uuid = ? AND user_id = ? LIMIT 1"
+    ).bind(uuid, userId).first();
+    return row ? row.status : null;
+  }
+};
+function createD1Adapter(db) {
+  if (!db || typeof db.prepare !== "function") {
+    throw new Error("[amsg-server] createD1Adapter requires a D1 database binding (env.DB)");
+  }
+  return new D1Adapter(db);
+}
+
+// src/server/lib/constant-time.js
+async function constantTimeEqual(a, b) {
+  const enc = new TextEncoder();
+  const keyBytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    keyBytes,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const da = new Uint8Array(await globalThis.crypto.subtle.sign("HMAC", key, enc.encode(String(a))));
+  const db = new Uint8Array(await globalThis.crypto.subtle.sign("HMAC", key, enc.encode(String(b))));
+  let diff = 0;
+  for (let i = 0; i < da.length; i++) {
+    diff |= da[i] ^ db[i];
+  }
+  return diff === 0;
+}
+
+// src/server/tenant/single-user-context.js
+function createSingleUserContextManager({ db, masterKey, serverToken } = {}) {
+  if (!db) throw new Error("[amsg-server single-user] db (adapter) is required");
+  if (!masterKey) throw new Error("[amsg-server single-user] masterKey is required");
+  const token = String(serverToken || "").trim();
+  async function isAuthorized(headers) {
+    if (!token) return true;
+    const provided = getHeader(headers, "x-client-token");
+    if (!provided) return false;
+    return constantTimeEqual(provided, token);
+  }
+  async function resolveTenant(headers) {
+    if (!await isAuthorized(headers)) {
+      return {
+        ok: false,
+        error: {
+          status: 401,
+          body: { success: false, error: { code: "INVALID_CLIENT_TOKEN", message: "\u5171\u4EAB\u5BC6\u94A5\u65E0\u6548\u6216\u7F3A\u5931" } }
+        }
+      };
+    }
+    return {
+      ok: true,
+      context: { tenantId: "single", tokenType: "tenant", db, masterKey }
+    };
+  }
+  async function initializeTenant() {
+    const schema = await db.initSchema();
+    return { tenantId: "single", schema };
+  }
+  return { resolveTenant, initializeTenant };
+}
+
+// src/server/handlers/single-user-init.js
+function createSingleUserInitHandler(ctx) {
+  async function POST(headers) {
+    const auth = await ctx.tenantManager.resolveTenant(headers || {});
+    if (!auth.ok) {
+      return auth.error;
+    }
+    try {
+      const result = await ctx.tenantManager.initializeTenant();
+      return {
+        status: 200,
+        body: { success: true, data: { tenantId: result.tenantId, schema: result.schema } }
+      };
+    } catch (error) {
+      return {
+        status: 500,
+        body: { success: false, error: { code: "INIT_FAILED", message: error.message } }
+      };
+    }
+  }
+  return { POST };
+}
+
+// src/server/handlers/vapid-public-key.js
+function createVapidPublicKeyHandler(ctx) {
+  async function GET(url, headers) {
+    const effectiveHeaders = headers || url || {};
+    const tenantResult = await ctx.tenantManager.resolveTenant(effectiveHeaders);
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const publicKey = ctx.vapid && ctx.vapid.publicKey;
+    if (!publicKey) {
+      return {
+        status: 503,
+        body: {
+          success: false,
+          error: {
+            code: "VAPID_NOT_CONFIGURED",
+            message: "VAPID \u516C\u94A5\u672A\u914D\u7F6E\uFF1A\u8BF7\u4E3A\u672C Worker \u8BBE\u7F6E VAPID_PUBLIC_KEY"
+          }
+        }
+      };
+    }
+    return {
+      status: 200,
+      body: { success: true, publicKey }
+    };
+  }
+  return { GET };
+}
+
+// src/server/single-user.js
+function createSingleUserServer(config) {
+  if (!config || !config.db) throw new Error("[amsg-server single-user] config.db is required");
+  if (!config.masterKey) throw new Error("[amsg-server single-user] config.masterKey is required");
+  const vapid = config.vapid || {};
+  const tenantManager = createSingleUserContextManager({
+    db: config.db,
+    masterKey: config.masterKey,
+    serverToken: config.serverToken
+  });
+  const ctx = {
+    vapid: {
+      email: vapid.email || "",
+      publicKey: vapid.publicKey || "",
+      privateKey: vapid.privateKey || ""
+    },
+    webpush: config.webpush || null,
+    tenantManager
+  };
+  return {
+    ctx,
+    handlers: {
+      init: createSingleUserInitHandler(ctx),
+      getUserKey: createGetUserKeyHandler(ctx),
+      scheduleMessage: createScheduleMessageHandler(ctx),
+      updateMessage: createUpdateMessageHandler(ctx),
+      cancelMessage: createCancelMessageHandler(ctx),
+      messages: createMessagesHandler(ctx),
+      vapidPublicKey: createVapidPublicKeyHandler(ctx)
+    }
+  };
+}
+
+// src/server/lib/webcrypto-utils.js
+import { toUint8, concatBytes, base64UrlToBytes } from "@rei-standard/amsg-shared";
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
+function utf8(str) {
+  return TEXT_ENCODER.encode(String(str));
+}
+function bytesToBase64Url(buf) {
+  const bytes = toUint8(buf);
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) {
+    bin += String.fromCharCode(bytes[i]);
+  }
+  const b64 = typeof btoa === "function" ? btoa(bin) : Buffer.from(bin, "binary").toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function jsonToBase64Url(value) {
+  return bytesToBase64Url(utf8(JSON.stringify(value)));
+}
+function randomBytes2(n) {
+  const out = new Uint8Array(n);
+  globalThis.crypto.getRandomValues(out);
+  return out;
+}
+
+// src/server/lib/webpush-webcrypto.js
+import { normalizeVapidSubject } from "@rei-standard/amsg-shared";
+var KEY_INFO_PREFIX = utf8("WebPush: info\0");
+var CEK_INFO = utf8("Content-Encoding: aes128gcm\0");
+var NONCE_INFO = utf8("Content-Encoding: nonce\0");
+var VAPID_DEFAULT_TTL = 60;
+var VAPID_TOKEN_LIFETIME = 12 * 3600;
+var RECORD_SIZE = 4096;
+async function sendWebPush({ subscription, payload, vapid, ttl, fetch: fetchImpl }) {
+  if (!subscription || typeof subscription.endpoint !== "string") {
+    throw new Error("sendWebPush: invalid subscription");
+  }
+  if (typeof payload !== "string") {
+    throw new Error("sendWebPush: payload must be a string");
+  }
+  if (!vapid || !vapid.email || !vapid.publicKey || !vapid.privateKey) {
+    throw new Error("VAPID_CONFIG_MISSING");
+  }
+  const subscriptionKeys = subscription.keys || {};
+  if (typeof subscriptionKeys.p256dh !== "string" || typeof subscriptionKeys.auth !== "string") {
+    throw new Error("sendWebPush: subscription.keys.p256dh and .auth are required");
+  }
+  const encryptedBody = await encryptPushPayload({
+    plaintext: utf8(payload),
+    uaPublicKey: base64UrlToBytes(subscriptionKeys.p256dh),
+    authSecret: base64UrlToBytes(subscriptionKeys.auth)
+  });
+  const jwt = await buildVapidJwt({
+    audience: originOf(subscription.endpoint),
+    subject: normalizeVapidSubject(vapid.email),
+    publicKey: vapid.publicKey,
+    privateKey: vapid.privateKey
+  });
+  const fetchFn = fetchImpl || globalThis.fetch;
+  if (typeof fetchFn !== "function") {
+    throw new Error("sendWebPush: no fetch implementation available");
+  }
+  const res = await fetchFn(subscription.endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/octet-stream",
+      "Content-Encoding": "aes128gcm",
+      "TTL": String(Number.isFinite(ttl) ? ttl : VAPID_DEFAULT_TTL),
+      "Authorization": `vapid t=${jwt}, k=${vapid.publicKey}`
+    },
+    body: encryptedBody
+  });
+  if (!res.ok) {
+    const text = await safeReadText(res);
+    const err = new Error(
+      `Web Push delivery failed: ${res.status} ${res.statusText || ""}${text ? ` \u2014 ${text}` : ""}`
+    );
+    err.code = "PUSH_SEND_FAILED";
+    err.statusCode = res.status;
+    throw err;
+  }
+  return {
+    statusCode: res.status,
+    body: await safeReadText(res),
+    headers: res.headers
+  };
+}
+async function encryptPushPayload({ plaintext, uaPublicKey, authSecret }) {
+  const asKeyPair = await globalThis.crypto.subtle.generateKey(
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    ["deriveBits"]
+  );
+  const asPublicRaw = new Uint8Array(
+    await globalThis.crypto.subtle.exportKey("raw", asKeyPair.publicKey)
+  );
+  const uaPublicCryptoKey = await globalThis.crypto.subtle.importKey(
+    "raw",
+    uaPublicKey,
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  const ecdhSecret = new Uint8Array(
+    await globalThis.crypto.subtle.deriveBits(
+      { name: "ECDH", public: uaPublicCryptoKey },
+      asKeyPair.privateKey,
+      256
+    )
+  );
+  const keyInfo = concatBytes(KEY_INFO_PREFIX, uaPublicKey, asPublicRaw);
+  const ikm = await hkdfSha256(authSecret, ecdhSecret, keyInfo, 32);
+  const salt = randomBytes2(16);
+  const cekBytes = await hkdfSha256(salt, ikm, CEK_INFO, 16);
+  const cek = await globalThis.crypto.subtle.importKey(
+    "raw",
+    cekBytes,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt"]
+  );
+  const nonce = await hkdfSha256(salt, ikm, NONCE_INFO, 12);
+  const padded = concatBytes(plaintext, new Uint8Array([2]));
+  const ciphertext = new Uint8Array(
+    await globalThis.crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, cek, padded)
+  );
+  const header = new Uint8Array(16 + 4 + 1 + asPublicRaw.byteLength);
+  header.set(salt, 0);
+  writeUint32BE(header, 16, RECORD_SIZE);
+  header[20] = asPublicRaw.byteLength;
+  header.set(asPublicRaw, 21);
+  return concatBytes(header, ciphertext);
+}
+async function hkdfSha256(salt, ikm, info, length) {
+  const baseKey = await globalThis.crypto.subtle.importKey(
+    "raw",
+    toUint8(ikm),
+    { name: "HKDF" },
+    false,
+    ["deriveBits"]
+  );
+  const bits = await globalThis.crypto.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: toUint8(salt),
+      info: toUint8(info)
+    },
+    baseKey,
+    length * 8
+  );
+  return new Uint8Array(bits);
+}
+async function buildVapidJwt({ audience, subject, publicKey, privateKey }) {
+  const header = jsonToBase64Url({ typ: "JWT", alg: "ES256" });
+  const payload = jsonToBase64Url({
+    aud: audience,
+    exp: Math.floor(Date.now() / 1e3) + VAPID_TOKEN_LIFETIME,
+    sub: subject
+  });
+  const signingInput = utf8(`${header}.${payload}`);
+  const pubBytes = base64UrlToBytes(publicKey);
+  const privBytes = base64UrlToBytes(privateKey);
+  if (pubBytes.length !== 65 || pubBytes[0] !== 4) {
+    throw new Error("VAPID publicKey must be a 65-byte uncompressed P-256 point (base64url).");
+  }
+  if (privBytes.length !== 32) {
+    throw new Error("VAPID privateKey must be a 32-byte scalar (base64url).");
+  }
+  const jwk = {
+    kty: "EC",
+    crv: "P-256",
+    d: bytesToBase64Url(privBytes),
+    x: bytesToBase64Url(pubBytes.subarray(1, 33)),
+    y: bytesToBase64Url(pubBytes.subarray(33, 65)),
+    ext: true
+  };
+  const key = await globalThis.crypto.subtle.importKey(
+    "jwk",
+    jwk,
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await globalThis.crypto.subtle.sign(
+    { name: "ECDSA", hash: "SHA-256" },
+    key,
+    signingInput
+  );
+  return `${header}.${payload}.${bytesToBase64Url(sig)}`;
+}
+function originOf(endpoint) {
+  return new URL(endpoint).origin;
+}
+function writeUint32BE(buf, offset, value) {
+  buf[offset] = value >>> 24 & 255;
+  buf[offset + 1] = value >>> 16 & 255;
+  buf[offset + 2] = value >>> 8 & 255;
+  buf[offset + 3] = value & 255;
+}
+async function safeReadText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+var SCHEDULED_DEFAULT_TTL = 2419200;
+function createWebCryptoWebPush(vapid = {}, { ttl = SCHEDULED_DEFAULT_TTL } = {}) {
+  return {
+    async sendNotification(subscription, payload) {
+      return sendWebPush({
+        subscription,
+        payload,
+        ttl,
+        vapid: {
+          email: vapid.email,
+          publicKey: vapid.publicKey,
+          privateKey: vapid.privateKey
+        },
+        fetch: globalThis.fetch
+      });
+    }
+  };
+}
+
+// src/server/cloudflare/single-user-worker.js
+function headersToObject(h) {
+  const out = {};
+  for (const [k, v] of h) out[k] = v;
+  return out;
+}
+function jsonResponse(status, body, extraHeaders) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8", ...extraHeaders || {} }
+  });
+}
+var CORS_ALLOW_HEADERS = "Content-Type, X-User-Id, X-Payload-Encrypted, X-Encryption-Version, X-Response-Encrypted, X-Client-Token";
+var CORS_ALLOW_METHODS = "GET, POST, PUT, DELETE, OPTIONS";
+function corsHeadersFor(cors, requestOrigin) {
+  if (!cors || cors.origin == null) return null;
+  const allowOrigin = typeof cors.origin === "function" ? cors.origin(requestOrigin) || null : cors.origin;
+  if (!allowOrigin) return null;
+  const headers = {
+    "Access-Control-Allow-Origin": allowOrigin,
+    "Access-Control-Allow-Methods": CORS_ALLOW_METHODS,
+    "Access-Control-Allow-Headers": cors.allowHeaders || CORS_ALLOW_HEADERS,
+    "Access-Control-Max-Age": String(cors.maxAge ?? 86400)
+  };
+  if (allowOrigin !== "*") headers["Vary"] = "Origin";
+  return headers;
+}
+function createSingleUserCloudflareWorker(buildConfig) {
+  async function resolveConfig(env) {
+    const cfg = await buildConfig(env);
+    if (!cfg.db) cfg.db = createD1Adapter(env.DB);
+    return cfg;
+  }
+  async function fetch2(request, env) {
+    try {
+      const cfg = await resolveConfig(env);
+      const cors = corsHeadersFor(cfg.cors, request.headers.get("origin") || "");
+      const method = request.method.toUpperCase();
+      if (method === "OPTIONS") {
+        return cors ? new Response(null, { status: 204, headers: cors }) : jsonResponse(404, { success: false, error: { code: "NOT_FOUND", message: "Unknown route" } });
+      }
+      const server = createSingleUserServer(cfg);
+      const url = request.url;
+      const pathname = new URL(url).pathname.replace(/\/+$/, "") || "/";
+      const headers = headersToObject(request.headers);
+      let result;
+      if (method === "POST" && pathname.endsWith("/init-tenant")) {
+        result = await server.handlers.init.POST(headers, await request.text());
+      } else if (method === "GET" && pathname.endsWith("/get-user-key")) {
+        result = await server.handlers.getUserKey.GET(url, headers);
+      } else if (method === "POST" && pathname.endsWith("/schedule-message")) {
+        result = await server.handlers.scheduleMessage.POST(headers, await request.text());
+      } else if (method === "GET" && pathname.endsWith("/messages")) {
+        result = await server.handlers.messages.GET(url, headers);
+      } else if (method === "PUT" && pathname.endsWith("/update-message")) {
+        result = await server.handlers.updateMessage.PUT(url, headers, await request.text());
+      } else if (method === "DELETE" && pathname.endsWith("/cancel-message")) {
+        result = await server.handlers.cancelMessage.DELETE(url, headers);
+      } else if (method === "GET" && pathname.endsWith("/vapid-public-key")) {
+        result = await server.handlers.vapidPublicKey.GET(url, headers);
+      } else {
+        result = { status: 404, body: { success: false, error: { code: "NOT_FOUND", message: "Unknown route" } } };
+      }
+      return jsonResponse(result.status, result.body, cors);
+    } catch (error) {
+      console.error("[amsg single-user] fetch() unhandled error:", error && error.message);
+      return jsonResponse(500, { success: false, error: { code: "INTERNAL_ERROR", message: "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF" } });
+    }
+  }
+  async function scheduled(event, env) {
+    const cfg = await resolveConfig(env);
+    const vapid = cfg.vapid || {};
+    if (!cfg.webpush || !vapid.email || !vapid.publicKey || !vapid.privateKey) {
+      console.error("[amsg single-user] scheduled(): VAPID/webpush not configured; skipping tick");
+      return;
+    }
+    try {
+      await runScheduledTick({ db: cfg.db, masterKey: cfg.masterKey, vapid, webpush: cfg.webpush });
+    } catch (error) {
+      console.error("[amsg single-user] scheduled(): tick failed:", error && error.message);
+    }
+  }
+  return { fetch: fetch2, scheduled };
+}
+
+export {
+  validateAvatarUrl,
+  isValidISO8601,
+  isValidUrl,
+  isValidUUID,
+  isValidUUIDv4,
+  validateSplitPattern,
+  validateLlmMessagesArray,
+  validateScheduleMessagePayload,
+  parseJsonBody,
+  getHeader,
+  deriveUserEncryptionKey,
+  decryptPayload,
+  encryptForStorage,
+  decryptFromStorage,
+  createGetUserKeyHandler,
+  createScheduleMessageHandler,
+  runScheduledTick,
+  createUpdateMessageHandler,
+  createCancelMessageHandler,
+  createMessagesHandler,
+  createD1Adapter,
+  createSingleUserServer,
+  createWebCryptoWebPush,
+  createSingleUserCloudflareWorker
+};