eve-lark 0.1.0

package/dist/index.js

@@ -0,0 +1,1075 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/channel.ts
+import {
+  defineChannel,
+  POST
+} from "eve/channels";
+
+// src/errors.ts
+var LarkChannelError = class extends Error {
+  static {
+    __name(this, "LarkChannelError");
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var LarkConfigError = class extends LarkChannelError {
+  static {
+    __name(this, "LarkConfigError");
+  }
+};
+var LarkSignatureError = class extends LarkChannelError {
+  static {
+    __name(this, "LarkSignatureError");
+  }
+};
+var LarkDecryptError = class extends LarkChannelError {
+  static {
+    __name(this, "LarkDecryptError");
+  }
+};
+var LarkApiError = class extends LarkChannelError {
+  static {
+    __name(this, "LarkApiError");
+  }
+  code;
+  body;
+  status;
+  constructor(message, opts) {
+    super(message, { cause: opts?.cause });
+    this.code = opts?.code;
+    this.body = opts?.body;
+    this.status = opts?.status;
+  }
+};
+
+// src/lark-client.ts
+var TOKEN_INVALID_CODES = /* @__PURE__ */ new Set([99991663, 99991664, 99991661]);
+var LarkClient = class {
+  static {
+    __name(this, "LarkClient");
+  }
+  options;
+  token = null;
+  refreshPromise = null;
+  constructor(options) {
+    this.options = options;
+  }
+  async getTenantAccessToken() {
+    if (this.token && Date.now() + this.options.tokenRefreshBufferMs < this.token.expiresAt) {
+      return this.token.value;
+    }
+    if (this.refreshPromise) return this.refreshPromise;
+    this.refreshPromise = this.#refresh();
+    try {
+      return await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async #refresh() {
+    const body = {
+      app_id: this.options.appId,
+      app_secret: this.options.appSecret
+    };
+    const res = await this.options.fetch(
+      `${this.options.baseUrl}/open-apis/auth/v3/tenant_access_token/internal`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(this.options.requestTimeoutMs)
+      }
+    );
+    if (!res.ok) {
+      throw new LarkApiError(
+        `eve-lark: token refresh failed (HTTP ${res.status})`,
+        { status: res.status }
+      );
+    }
+    const json = await res.json();
+    if (json.code !== 0 || !json.tenant_access_token) {
+      throw new LarkApiError(
+        `eve-lark: token refresh returned code=${json.code ?? "?"} msg=${json.msg ?? "?"}`,
+        { body: json, code: json.code }
+      );
+    }
+    const expireSec = typeof json.expire === "number" ? json.expire : 7200;
+    this.token = {
+      value: json.tenant_access_token,
+      expiresAt: Date.now() + expireSec * 1e3
+    };
+    return this.token.value;
+  }
+  async sendText(args) {
+    const content = JSON.stringify({ text: args.content });
+    return this.#sendMessage({
+      receive_id: args.chatId,
+      msg_type: "text",
+      content,
+      root_id: args.rootId,
+      parent_id: args.parentId
+    });
+  }
+  async sendCard(args) {
+    const content = JSON.stringify(args.card);
+    return this.#sendMessage({
+      receive_id: args.chatId,
+      msg_type: "interactive",
+      content,
+      root_id: args.rootId,
+      parent_id: args.parentId
+    });
+  }
+  async #sendMessage(body) {
+    const payload = Object.fromEntries(
+      Object.entries(body).filter(([, v]) => v !== void 0)
+    );
+    const json = await this.#request("POST", "/open-apis/im/v1/messages?receive_id_type=chat_id", payload);
+    const messageId = json.data?.message_id;
+    if (!messageId) {
+      throw new LarkApiError("eve-lark: send missing message_id in response", {
+        body: json
+      });
+    }
+    return { messageId };
+  }
+  async patchCard(args) {
+    await this.#request(
+      "PATCH",
+      `/open-apis/im/v1/messages/${encodeURIComponent(args.messageId)}`,
+      { content: JSON.stringify(args.card) }
+    );
+  }
+  async downloadResource(args) {
+    const path = `/open-apis/im/v1/messages/${encodeURIComponent(args.messageId)}/resources/${encodeURIComponent(args.fileKey)}?type=${args.type}`;
+    const token = await this.getTenantAccessToken();
+    const res = await this.options.fetch(`${this.options.baseUrl}${path}`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(this.options.requestTimeoutMs)
+    });
+    if (!res.ok) {
+      throw new LarkApiError(
+        `eve-lark: downloadResource HTTP ${res.status}`,
+        { status: res.status }
+      );
+    }
+    return Buffer.from(await res.arrayBuffer());
+  }
+  async addReaction(args) {
+    const path = `/open-apis/im/v1/messages/${encodeURIComponent(args.messageId)}/reactions`;
+    const json = await this.#request("POST", path, {
+      reaction_type: { emoji_type: args.emojiType }
+    });
+    const reactionId = json.data?.reaction_id;
+    if (!reactionId) {
+      throw new LarkApiError("eve-lark: addReaction missing reaction_id", {
+        body: json
+      });
+    }
+    return { reactionId };
+  }
+  async removeReaction(args) {
+    const path = `/open-apis/im/v1/messages/${encodeURIComponent(args.messageId)}/reactions/${encodeURIComponent(args.reactionId)}`;
+    await this.#request("DELETE", path, void 0);
+  }
+  /**
+   * Central request wrapper with auth, retry, and Feishu error decoding.
+   *
+   * Retries on 429 (honoring Retry-After), 5xx (exponential backoff + jitter),
+   * and token-invalid responses (one refresh + one retry). Other 4xx throws
+   * LarkApiError with the Feishu code/msg from the body.
+   */
+  async #request(method, path, body) {
+    const url = `${this.options.baseUrl}${path}`;
+    let token = await this.getTenantAccessToken();
+    let tokenRefreshed = false;
+    for (let attempt = 0; attempt <= this.options.maxRetries; attempt++) {
+      const res = await this.options.fetch(url, {
+        method,
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: AbortSignal.timeout(this.options.requestTimeoutMs)
+      });
+      const result = await this.#consumeResponse(res);
+      const status = result.status;
+      if (status >= 200 && status < 300) {
+        const jsonBody = result.body;
+        if (jsonBody && typeof jsonBody.code === "number" && jsonBody.code !== 0) {
+          if (TOKEN_INVALID_CODES.has(jsonBody.code) && !tokenRefreshed) {
+            this.token = null;
+            token = await this.getTenantAccessToken();
+            tokenRefreshed = true;
+            attempt -= 1;
+            continue;
+          }
+          throw new LarkApiError(
+            `eve-lark: ${method} ${path} failed code=${jsonBody.code} msg=${jsonBody.msg ?? "?"}`,
+            { code: jsonBody.code, body: jsonBody, status }
+          );
+        }
+        return result.body;
+      }
+      if (status === 401 && !tokenRefreshed) {
+        this.token = null;
+        token = await this.getTenantAccessToken();
+        tokenRefreshed = true;
+        attempt -= 1;
+        continue;
+      }
+      const retryable = status === 429 || status >= 500 && status < 600;
+      if (retryable && attempt < this.options.maxRetries) {
+        const delayMs = this.#computeBackoff(status, result.retryAfter, attempt);
+        await sleep(delayMs);
+        continue;
+      }
+      const bodyObj = result.body;
+      const code = bodyObj?.code;
+      const msg = bodyObj?.msg;
+      const detail = msg ? ` code=${code ?? "?"} msg=${msg}` : "";
+      throw new LarkApiError(
+        `eve-lark: ${method} ${path} failed HTTP ${status}${detail}`,
+        { status, body: bodyObj, code }
+      );
+    }
+    throw new LarkApiError(`eve-lark: ${method} ${path} exhausted retries`);
+  }
+  async #consumeResponse(res) {
+    const retryAfterRaw = res.headers.get("retry-after");
+    const retryAfter = retryAfterRaw ? parseRetryAfter(retryAfterRaw) : null;
+    const text = await res.text();
+    if (!text) {
+      return { status: res.status, body: void 0, retryAfter };
+    }
+    try {
+      return { status: res.status, body: JSON.parse(text), retryAfter };
+    } catch {
+      return { status: res.status, body: { raw: text }, retryAfter };
+    }
+  }
+  #computeBackoff(status, retryAfter, attempt) {
+    if (status === 429 && retryAfter !== null) {
+      return Math.min(retryAfter * 1e3, 1e4);
+    }
+    const base = 300 * Math.pow(2, attempt);
+    const jitter = base * 0.2 * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(base + jitter));
+  }
+};
+function parseRetryAfter(raw) {
+  const sec = Number(raw);
+  if (Number.isFinite(sec) && sec >= 0) return sec;
+  const date = Date.parse(raw);
+  if (Number.isFinite(date)) return Math.max(0, (date - Date.now()) / 1e3);
+  return null;
+}
+__name(parseRetryAfter, "parseRetryAfter");
+function sleep(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+
+// src/dedup.ts
+var DedupMap = class {
+  static {
+    __name(this, "DedupMap");
+  }
+  entries = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxEntries;
+  insertsSinceSweep = 0;
+  constructor(ttlMs, maxEntries) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+  }
+  has(key) {
+    const at = this.entries.get(key);
+    if (at === void 0) return false;
+    if (Date.now() - at > this.ttlMs) {
+      this.entries.delete(key);
+      return false;
+    }
+    return true;
+  }
+  set(key) {
+    this.maybeSweep();
+    this.entries.delete(key);
+    this.entries.set(key, Date.now());
+    while (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey === void 0) break;
+      this.entries.delete(oldestKey);
+    }
+  }
+  /**
+   * Walk the insertion-ordered map from the front and drop expired entries.
+   * Stops at the first non-expired entry since events arrive roughly in time
+   * order. Called on every set, so cost is amortized.
+   */
+  maybeSweep() {
+    this.insertsSinceSweep += 1;
+    if (this.insertsSinceSweep < 64 && this.entries.size < this.maxEntries) {
+      return;
+    }
+    this.insertsSinceSweep = 0;
+    const now = Date.now();
+    for (const [key, at] of this.entries) {
+      if (now - at <= this.ttlMs) break;
+      this.entries.delete(key);
+    }
+  }
+};
+
+// src/crypto.ts
+import { createDecipheriv, createHash, timingSafeEqual } from "crypto";
+function verifySignature(opts) {
+  const expected = opts.signatureHeader.replace(/^sha256=/, "");
+  const computed = createHash("sha256").update(opts.timestamp + opts.nonce + opts.encryptKey).update(opts.rawBody).digest("hex");
+  const a = Buffer.from(computed, "hex");
+  const b = Buffer.from(expected, "hex");
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+__name(verifySignature, "verifySignature");
+function decryptPayload(encryptB64, encryptKey) {
+  const key = createHash("sha256").update(encryptKey).digest();
+  const buf = Buffer.from(encryptB64, "base64");
+  if (buf.length < 32) {
+    throw new LarkDecryptError(
+      `eve-lark: ciphertext too short (${buf.length} bytes; need >= 32 for IV + one block)`
+    );
+  }
+  if ((buf.length - 16) % 16 !== 0) {
+    throw new LarkDecryptError(
+      `eve-lark: ciphertext length ${buf.length} is not 16 + N*16`
+    );
+  }
+  const iv = buf.subarray(0, 16);
+  const ct = buf.subarray(16);
+  const dec = createDecipheriv("aes-256-cbc", key, iv);
+  try {
+    return Buffer.concat([dec.update(ct), dec.final()]);
+  } catch (e) {
+    throw new LarkDecryptError("eve-lark: AES decrypt failed (bad padding or wrong key)", {
+      cause: e
+    });
+  }
+}
+__name(decryptPayload, "decryptPayload");
+
+// src/parse.ts
+var MIME_BY_EXT = {
+  pdf: "application/pdf",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  csv: "text/csv",
+  txt: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  htm: "text/html",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  mp4: "video/mp4",
+  mov: "video/quicktime"
+};
+function mimeFromExt(filename) {
+  if (!filename) return "application/octet-stream";
+  const dot = filename.lastIndexOf(".");
+  if (dot < 0) return "application/octet-stream";
+  return MIME_BY_EXT[filename.slice(dot + 1).toLowerCase()] ?? "application/octet-stream";
+}
+__name(mimeFromExt, "mimeFromExt");
+function mentionFromRaw(m, botOpenId) {
+  const isOpenIdOfBot = !!botOpenId && !!m.id.open_id && m.id.open_id === botOpenId;
+  const isAll = !!m.id.open_id && m.id.open_id === "all";
+  return {
+    key: m.key,
+    id: {
+      openId: m.id.open_id,
+      userId: m.id.user_id,
+      unionId: m.id.union_id
+    },
+    name: m.name,
+    idType: m.id_type ?? "open_id",
+    isOpenIdOfBot,
+    isAll
+  };
+}
+__name(mentionFromRaw, "mentionFromRaw");
+function stripBotMentions(text, mentions) {
+  let out = text;
+  for (const m of mentions) {
+    if (!m.key) continue;
+    if (m.isOpenIdOfBot) {
+      out = out.split(m.key).join("");
+    } else if (m.isAll) {
+      out = out.split(m.key).join("@all");
+    } else {
+      out = out.split(m.key).join(`@${m.name}`);
+    }
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+__name(stripBotMentions, "stripBotMentions");
+function parseContent(messageType, rawContent) {
+  if (!rawContent) return { text: "", files: [] };
+  let content;
+  try {
+    content = JSON.parse(rawContent);
+  } catch {
+    return { text: "", files: [] };
+  }
+  switch (messageType) {
+    case "text": {
+      const text = typeof content.text === "string" ? content.text : "";
+      return { text, files: [] };
+    }
+    case "image": {
+      const imageKey = typeof content.image_key === "string" ? content.image_key : "";
+      if (!imageKey) return { text: "", files: [] };
+      return {
+        text: "",
+        files: [{ fileKey: imageKey, mediaType: "image/png", kind: "image" }]
+      };
+    }
+    case "file": {
+      const fileKey = typeof content.file_key === "string" ? content.file_key : "";
+      if (!fileKey) return { text: "", files: [] };
+      const fileName = typeof content.file_name === "string" ? content.file_name : void 0;
+      return {
+        text: "",
+        files: [{ fileKey, mediaType: mimeFromExt(fileName), kind: "file" }]
+      };
+    }
+    case "post": {
+      const locale = content.zh_cn ?? content.en_us ?? content.ja_jp ?? null;
+      if (!locale?.content) return { text: "", files: [] };
+      const text = locale.content.flatMap(
+        (line) => (line ?? []).filter((node) => {
+          if (typeof node !== "object" || node === null) return false;
+          const tag = node.tag;
+          const text2 = node.text;
+          return tag === "text" && typeof text2 === "string";
+        }).map((node) => node.text)
+      ).join(" ");
+      return { text, files: [] };
+    }
+    default:
+      return { text: "", files: [] };
+  }
+}
+__name(parseContent, "parseContent");
+function parseInbound(event, botOpenId) {
+  const messageType = event.message.message_type;
+  const parsed = parseContent(messageType, event.message.content);
+  const rawMentions = event.message.mentions ?? [];
+  const mentions = rawMentions.map((m) => mentionFromRaw(m, botOpenId));
+  const senderOpenId = event.sender.sender_id.open_id ?? event.sender.sender_id.user_id ?? event.sender.sender_id.union_id ?? "";
+  const text = messageType === "text" ? stripBotMentions(parsed.text, mentions) : parsed.text;
+  const chatType = event.chat_type === "group" ? "group" : "p2p";
+  const senderType = event.sender.sender_type === "app" ? "app" : "user";
+  return {
+    text,
+    files: parsed.files,
+    chatId: event.message.chat_id,
+    rootId: event.message.root_id ?? null,
+    parentId: event.message.parent_id ?? null,
+    messageId: event.message.message_id,
+    senderOpenId,
+    senderType,
+    chatType,
+    mentions
+  };
+}
+__name(parseInbound, "parseInbound");
+
+// src/card.ts
+var BASE_CONFIG = {
+  wide_screen_mode: true,
+  update_multi: true
+};
+function buildTextCard(text) {
+  return {
+    config: { ...BASE_CONFIG },
+    elements: [{ tag: "markdown", content: text }]
+  };
+}
+__name(buildTextCard, "buildTextCard");
+function buildStreamingCard(opts) {
+  const lines = [];
+  if (opts.status) {
+    lines.push(`<font color='grey'>${opts.status}</font>`);
+  }
+  lines.push(opts.buffer.length > 0 ? opts.buffer : "_\u2026_");
+  return {
+    config: { ...BASE_CONFIG },
+    elements: [{ tag: "markdown", content: lines.join("\n\n") }]
+  };
+}
+__name(buildStreamingCard, "buildStreamingCard");
+function buildErrorCard(message) {
+  return {
+    config: { ...BASE_CONFIG },
+    elements: [
+      { tag: "markdown", content: `<font color='red'>\u26A0 ${message}</font>` }
+    ]
+  };
+}
+__name(buildErrorCard, "buildErrorCard");
+
+// src/streaming-controller.ts
+var StreamingCardController = class {
+  static {
+    __name(this, "StreamingCardController");
+  }
+  deps;
+  client;
+  state = "idle";
+  buffer = "";
+  status;
+  messageId;
+  fallbackToText = false;
+  createTimer = null;
+  patchInFlight = null;
+  patchScheduled = false;
+  lastPatchAt = 0;
+  constructor(client, deps) {
+    this.client = client;
+    this.deps = deps;
+  }
+  appendDelta(text) {
+    if (this.state === "completed" || this.state === "aborted") return;
+    this.buffer += text;
+    if (this.state === "idle") {
+      this.scheduleCreate();
+    } else if (this.state === "streaming") {
+      this.schedulePatch();
+    }
+  }
+  setStatus(status) {
+    if (this.state === "completed" || this.state === "aborted") return;
+    this.status = status;
+    if (this.state === "streaming") {
+      this.schedulePatch();
+    }
+  }
+  async finalize(fullText) {
+    if (this.state === "completed" || this.state === "aborted") return;
+    this.cancelCreateTimer();
+    this.buffer = fullText;
+    if (this.fallbackToText) {
+      await this.client.sendText({
+        chatId: this.deps.chatId,
+        content: fullText,
+        rootId: this.deps.rootId,
+        parentId: this.deps.parentId
+      });
+      this.state = "completed";
+      return;
+    }
+    if (this.messageId === void 0) {
+      try {
+        const res = await this.client.sendCard({
+          chatId: this.deps.chatId,
+          card: buildTextCard(fullText),
+          rootId: this.deps.rootId,
+          parentId: this.deps.parentId
+        });
+        this.messageId = res.messageId;
+        this.state = "completed";
+      } catch {
+        this.fallbackToText = true;
+        await this.client.sendText({
+          chatId: this.deps.chatId,
+          content: fullText,
+          rootId: this.deps.rootId,
+          parentId: this.deps.parentId
+        });
+        this.state = "completed";
+      }
+      return;
+    }
+    if (this.patchInFlight) {
+      try {
+        await this.patchInFlight;
+      } catch {
+      }
+    }
+    await this.client.patchCard({
+      messageId: this.messageId,
+      card: buildStreamingCard({ buffer: fullText, status: void 0 })
+    });
+    this.state = "completed";
+  }
+  async abort(error) {
+    if (this.state === "completed" || this.state === "aborted") return;
+    this.cancelCreateTimer();
+    if (this.messageId === void 0) {
+      this.fallbackToText = true;
+      this.state = "aborted";
+      return;
+    }
+    try {
+      await this.client.patchCard({
+        messageId: this.messageId,
+        card: buildErrorCard(error)
+      });
+    } finally {
+      this.state = "aborted";
+    }
+  }
+  async ensureFinalized() {
+    if (this.state !== "completed" && this.state !== "aborted") {
+      await this.finalize(this.buffer);
+    }
+  }
+  isStreaming() {
+    return this.state === "streaming" || this.state === "creating";
+  }
+  isCompleted() {
+    return this.state === "completed" || this.state === "aborted";
+  }
+  scheduleCreate() {
+    if (this.createTimer) return;
+    this.state = "creating";
+    this.createTimer = setTimeout(() => {
+      this.createTimer = null;
+      void this.doCreate();
+    }, this.deps.createThresholdMs);
+  }
+  cancelCreateTimer() {
+    if (this.createTimer) {
+      clearTimeout(this.createTimer);
+      this.createTimer = null;
+    }
+  }
+  async doCreate() {
+    if (this.state !== "creating") return;
+    try {
+      const res = await this.client.sendCard({
+        chatId: this.deps.chatId,
+        card: buildStreamingCard({ buffer: this.buffer, status: this.status }),
+        rootId: this.deps.rootId,
+        parentId: this.deps.parentId
+      });
+      this.messageId = res.messageId;
+      this.state = "streaming";
+      this.lastPatchAt = Date.now();
+    } catch {
+      this.fallbackToText = true;
+      this.state = "streaming";
+    }
+  }
+  schedulePatch() {
+    if (this.patchScheduled) return;
+    this.patchScheduled = true;
+    const elapsed = Date.now() - this.lastPatchAt;
+    const wait = Math.max(0, this.deps.patchIntervalMs - elapsed);
+    setTimeout(() => {
+      this.patchScheduled = false;
+      void this.maybeFlushPatch();
+    }, wait);
+  }
+  async maybeFlushPatch() {
+    if (this.state !== "streaming") return;
+    if (this.patchInFlight) return;
+    if (this.messageId === void 0) return;
+    const card = buildStreamingCard({ buffer: this.buffer, status: this.status });
+    this.patchInFlight = this.client.patchCard({ messageId: this.messageId, card }).catch(() => {
+    }).finally(() => {
+      this.patchInFlight = null;
+      this.lastPatchAt = Date.now();
+    });
+    await this.patchInFlight;
+  }
+};
+
+// src/options.ts
+var DEFAULTS = {
+  baseUrl: "https://open.feishu.cn",
+  webhookPath: "/lark/webhook",
+  replyMode: "streaming",
+  streamPatchIntervalMs: 1e3,
+  streamCreateThresholdMs: 400,
+  dedupTtlMs: 30 * 60 * 1e3,
+  dedupMaxEntries: 5e3,
+  requestTimeoutMs: 15e3,
+  maxRetries: 2,
+  tokenRefreshBufferMs: 5 * 60 * 1e3,
+  signatureSkewMs: 5 * 60 * 1e3,
+  ackReaction: "TYPING"
+};
+var ENV_KEYS = {
+  appId: "LARK_APP_ID",
+  appSecret: "LARK_APP_SECRET",
+  verificationToken: "LARK_VERIFICATION_TOKEN",
+  encryptKey: "LARK_ENCRYPT_KEY",
+  baseUrl: "LARK_BASE_URL",
+  botOpenId: "LARK_BOT_OPEN_ID"
+};
+function defaultEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+__name(defaultEnv, "defaultEnv");
+function pick(input, envValue) {
+  return input ?? envValue;
+}
+__name(pick, "pick");
+function resolveOptions(options, env = defaultEnv()) {
+  const appId = pick(options.appId, env[ENV_KEYS.appId]);
+  const appSecret = pick(options.appSecret, env[ENV_KEYS.appSecret]);
+  const verificationToken = pick(
+    options.verificationToken,
+    env[ENV_KEYS.verificationToken]
+  );
+  if (!appId) {
+    throw new LarkConfigError(
+      `eve-lark: appId is required (option \`appId\` or env \`${ENV_KEYS.appId}\`)`
+    );
+  }
+  if (!appSecret) {
+    throw new LarkConfigError(
+      `eve-lark: appSecret is required (option \`appSecret\` or env \`${ENV_KEYS.appSecret}\`)`
+    );
+  }
+  if (!verificationToken) {
+    throw new LarkConfigError(
+      `eve-lark: verificationToken is required (option \`verificationToken\` or env \`${ENV_KEYS.verificationToken}\`)`
+    );
+  }
+  const rawBaseUrl = pick(options.baseUrl, env[ENV_KEYS.baseUrl]) ?? DEFAULTS.baseUrl;
+  const baseUrl = rawBaseUrl.replace(/\/+$/, "");
+  return {
+    appId,
+    appSecret,
+    verificationToken,
+    encryptKey: pick(options.encryptKey, env[ENV_KEYS.encryptKey]),
+    baseUrl,
+    botOpenId: pick(options.botOpenId, env[ENV_KEYS.botOpenId]),
+    webhookPath: options.webhookPath ?? DEFAULTS.webhookPath,
+    replyMode: options.replyMode ?? DEFAULTS.replyMode,
+    streamPatchIntervalMs: options.streamPatchIntervalMs ?? DEFAULTS.streamPatchIntervalMs,
+    streamCreateThresholdMs: options.streamCreateThresholdMs ?? DEFAULTS.streamCreateThresholdMs,
+    dedupTtlMs: options.dedupTtlMs ?? DEFAULTS.dedupTtlMs,
+    dedupMaxEntries: options.dedupMaxEntries ?? DEFAULTS.dedupMaxEntries,
+    requestTimeoutMs: options.requestTimeoutMs ?? DEFAULTS.requestTimeoutMs,
+    maxRetries: options.maxRetries ?? DEFAULTS.maxRetries,
+    tokenRefreshBufferMs: options.tokenRefreshBufferMs ?? DEFAULTS.tokenRefreshBufferMs,
+    signatureSkewMs: options.signatureSkewMs ?? DEFAULTS.signatureSkewMs,
+    fetch: options.fetch ?? globalThis.fetch,
+    ackReaction: options.ackReaction ?? DEFAULTS.ackReaction
+  };
+}
+__name(resolveOptions, "resolveOptions");
+
+// src/channel.ts
+function larkContinuationToken(chatId, rootMessageId) {
+  return `${chatId}:${rootMessageId ?? "_"}`;
+}
+__name(larkContinuationToken, "larkContinuationToken");
+function metaFromCtx(ctx) {
+  const attrs = ctx.session?.auth?.initiator?.attributes ?? {};
+  if (typeof attrs.chatId !== "string" || !attrs.chatId) return null;
+  return {
+    chatId: attrs.chatId,
+    rootId: typeof attrs.rootMessageId === "string" ? attrs.rootMessageId : void 0,
+    parentId: typeof attrs.parentId === "string" ? attrs.parentId : void 0
+  };
+}
+__name(metaFromCtx, "metaFromCtx");
+function ackOk() {
+  return Response.json({ code: 0 });
+}
+__name(ackOk, "ackOk");
+function pickAckEmoji(reaction) {
+  if (typeof reaction === "string") return reaction;
+  if (Array.isArray(reaction)) {
+    if (reaction.length === 0) return false;
+    const idx = Math.floor(Math.random() * reaction.length);
+    return reaction[idx] ?? false;
+  }
+  return false;
+}
+__name(pickAckEmoji, "pickAckEmoji");
+function resourceUrl(options, file, messageId) {
+  const type = file.kind === "image" ? "image" : "file";
+  return `${options.baseUrl}/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/resources/${encodeURIComponent(file.fileKey)}?type=${type}`;
+}
+__name(resourceUrl, "resourceUrl");
+function buildUserContent(text, files, options, messageId) {
+  const parts = [];
+  if (text.length > 0) parts.push({ type: "text", text });
+  for (const f of files) {
+    parts.push({
+      type: "file",
+      data: new URL(resourceUrl(options, f, messageId)),
+      mediaType: f.mediaType
+    });
+  }
+  return parts;
+}
+__name(buildUserContent, "buildUserContent");
+function createLarkChannel(optionsInput) {
+  const options = resolveOptions(optionsInput);
+  const client = new LarkClient(options);
+  const dedup = new DedupMap(options.dedupTtlMs, options.dedupMaxEntries);
+  const controllers = /* @__PURE__ */ new Map();
+  const sessionMeta = /* @__PURE__ */ new Map();
+  function getController(sessionId, meta) {
+    let ctrl = controllers.get(sessionId);
+    if (!ctrl) {
+      ctrl = new StreamingCardController(client, {
+        chatId: meta.chatId,
+        rootId: meta.rootId,
+        parentId: meta.parentId,
+        patchIntervalMs: options.streamPatchIntervalMs,
+        createThresholdMs: options.streamCreateThresholdMs
+      });
+      controllers.set(sessionId, ctrl);
+    }
+    return ctrl;
+  }
+  __name(getController, "getController");
+  function lookupMeta(sessionId) {
+    return sessionMeta.get(sessionId);
+  }
+  __name(lookupMeta, "lookupMeta");
+  function dropController(sessionId) {
+    controllers.delete(sessionId);
+    sessionMeta.delete(sessionId);
+  }
+  __name(dropController, "dropController");
+  const webhookHandler = /* @__PURE__ */ __name(async (req, helpers) => {
+    const rawBody = Buffer.from(await req.arrayBuffer());
+    const tsHeader = req.headers.get("x-lark-request-timestamp") ?? "";
+    const ts = Number(tsHeader);
+    if (tsHeader && Number.isFinite(ts) && ts > 0 && Math.abs(Date.now() / 1e3 - ts) > options.signatureSkewMs / 1e3) {
+      return new Response("request timestamp out of skew window", { status: 408 });
+    }
+    let workingBody = rawBody;
+    if (options.encryptKey) {
+      const nonce = req.headers.get("x-lark-request-nonce") ?? "";
+      const sigHeader = req.headers.get("x-lark-signature");
+      if (!sigHeader) return new Response("missing signature", { status: 401 });
+      const ok = verifySignature({
+        timestamp: tsHeader,
+        nonce,
+        encryptKey: options.encryptKey,
+        rawBody,
+        signatureHeader: sigHeader
+      });
+      if (!ok) return new Response("bad signature", { status: 401 });
+      try {
+        const envelope = JSON.parse(rawBody.toString("utf8"));
+        if (envelope.encrypt) {
+          workingBody = decryptPayload(envelope.encrypt, options.encryptKey);
+        }
+      } catch {
+        return new Response("decrypt failed", { status: 400 });
+      }
+    }
+    let body;
+    try {
+      body = JSON.parse(workingBody.toString("utf8"));
+    } catch {
+      return new Response("invalid json", { status: 400 });
+    }
+    if (body.type === "url_verification") {
+      return Response.json({ challenge: body.challenge ?? "" });
+    }
+    if (body.schema !== "2.0") {
+      return ackOk();
+    }
+    if (body.header?.token !== options.verificationToken) {
+      return new Response("verification token mismatch", { status: 401 });
+    }
+    const dedupKey = body.header?.event_id ?? body.event?.message?.message_id;
+    if (dedupKey) {
+      if (dedup.has(dedupKey)) return ackOk();
+      dedup.set(dedupKey);
+    }
+    if (body.header?.event_type !== "im.message.receive_v1") {
+      return ackOk();
+    }
+    if (!body.event) return ackOk();
+    const parsed = parseInbound(body.event, options.botOpenId);
+    if (parsed.senderType === "app") {
+      return ackOk();
+    }
+    if (parsed.text === "" && parsed.files.length === 0) {
+      return ackOk();
+    }
+    const userContent = buildUserContent(parsed.text, parsed.files, options, parsed.messageId);
+    const continuationToken = larkContinuationToken(parsed.chatId, parsed.parentId ?? parsed.rootId);
+    const auth = {
+      authenticator: "lark",
+      principalType: "user",
+      principalId: parsed.senderOpenId,
+      attributes: {
+        chatId: parsed.chatId,
+        rootMessageId: parsed.rootId,
+        messageId: parsed.messageId,
+        chatType: parsed.chatType
+      }
+    };
+    const session = await helpers.send(userContent, {
+      auth,
+      continuationToken
+    });
+    sessionMeta.set(session.id, {
+      chatId: parsed.chatId,
+      rootId: parsed.rootId ?? void 0,
+      parentId: parsed.parentId ?? void 0
+    });
+    console.log("[eve-lark] session registered", session.id, "chat:", parsed.chatId);
+    const emoji = pickAckEmoji(options.ackReaction);
+    if (emoji) {
+      helpers.waitUntil(
+        client.addReaction({ messageId: parsed.messageId, emojiType: emoji }).catch((e) => {
+          console.warn("[eve-lark] ack reaction failed", e);
+        })
+      );
+    }
+    return ackOk();
+  }, "webhookHandler");
+  return defineChannel({
+    routes: [POST(options.webhookPath, webhookHandler)],
+    fetchFile: /* @__PURE__ */ __name(async (url) => {
+      if (!url.startsWith(options.baseUrl)) return null;
+      const m = url.match(/\/messages\/([^/]+)\/resources\/([^?]+)\?type=(image|file)/);
+      if (!m || !m[1] || !m[2] || !m[3]) return null;
+      return client.downloadResource({
+        messageId: m[1],
+        fileKey: m[2],
+        type: m[3]
+      });
+    }, "fetchFile"),
+    events: {
+      // Streaming delta — patch the card.
+      "message.appended"(data, _channel, ctx) {
+        console.log("[eve-lark] message.appended", ctx.session.id);
+        if (options.replyMode !== "streaming") return;
+        const sessionId = ctx.session.id;
+        const meta = metaFromCtx(ctx);
+        if (!meta) {
+          console.log("[eve-lark] message.appended: no meta for", sessionId);
+          return;
+        }
+        const d = data;
+        const ctrl = getController(sessionId, meta);
+        if (typeof d.messageDelta === "string") {
+          ctrl.appendDelta(d.messageDelta);
+        }
+      },
+      // Terminal — finalize the card OR deliver a fresh one in static mode.
+      async "message.completed"(data, _channel, ctx) {
+        console.log("[eve-lark] message.completed", ctx.session.id);
+        const sessionId = ctx.session.id;
+        const meta = metaFromCtx(ctx);
+        if (!meta) {
+          console.log("[eve-lark] message.completed: no meta for", sessionId);
+          return;
+        }
+        const d = data;
+        const text = typeof d.message === "string" ? d.message : "";
+        if (options.replyMode === "streaming") {
+          const ctrl = getController(sessionId, meta);
+          try {
+            await ctrl.finalize(text);
+            console.log("[eve-lark] finalize done for", sessionId);
+          } catch (e) {
+            console.log("[eve-lark] finalize failed for", sessionId, e);
+          }
+          dropController(sessionId);
+          return;
+        }
+        try {
+          await client.sendCard({
+            chatId: meta.chatId,
+            card: buildTextCard(text),
+            rootId: meta.rootId,
+            parentId: meta.parentId
+          });
+          console.log("[eve-lark] static sendCard done for", sessionId);
+        } catch (e) {
+          console.log("[eve-lark] static sendCard failed:", e);
+          await client.sendText({
+            chatId: meta.chatId,
+            content: text,
+            rootId: meta.rootId,
+            parentId: meta.parentId
+          });
+        }
+        dropController(sessionId);
+      },
+      async "turn.failed"(data, _channel, ctx) {
+        console.log("[eve-lark] turn.failed", ctx?.session?.id);
+        const sessionId = ctx?.session?.id;
+        if (!sessionId) return;
+        const meta = metaFromCtx(ctx);
+        if (!meta) return;
+        const d = data;
+        const errMsg = typeof d === "object" && d !== null && "error" in d ? typeof d.error === "string" ? d.error : d.error?.message ?? "turn failed" : "turn failed";
+        if (options.replyMode === "streaming") {
+          const ctrl = controllers.get(sessionId);
+          if (ctrl) {
+            try {
+              await ctrl.abort(errMsg);
+            } catch {
+            }
+          }
+        }
+        dropController(sessionId);
+      },
+      async "session.failed"(data, _channel) {
+        const d = data;
+        const errMsg = d?.error?.message ?? "session failed";
+        for (const [, ctrl] of controllers) {
+          try {
+            await ctrl.abort(errMsg);
+          } catch {
+          }
+        }
+        controllers.clear();
+        sessionMeta.clear();
+      }
+    }
+  });
+}
+__name(createLarkChannel, "createLarkChannel");
+export {
+  LarkApiError,
+  LarkChannelError,
+  LarkClient,
+  LarkConfigError,
+  LarkDecryptError,
+  LarkSignatureError,
+  createLarkChannel,
+  larkContinuationToken
+};
+//# sourceMappingURL=index.js.map