@gakr-gakr/feishu 0.1.0

package/src/sequential-key.ts

@@ -0,0 +1,28 @@
+import {
+  isAbortRequestText,
+  isBtwRequestText,
+} from "autobot/plugin-sdk/command-primitives-runtime";
+import { parseFeishuMessageEvent, type FeishuMessageEvent } from "./bot.js";
+
+export function getFeishuSequentialKey(params: {
+  accountId: string;
+  event: FeishuMessageEvent;
+  botOpenId?: string;
+  botName?: string;
+}): string {
+  const { accountId, event, botOpenId, botName } = params;
+  const chatId = event.message.chat_id?.trim() || "unknown";
+  const baseKey = `feishu:${accountId}:${chatId}`;
+  const parsed = parseFeishuMessageEvent(event, botOpenId, botName);
+  const text = parsed.content.trim();
+
+  if (isAbortRequestText(text)) {
+    return `${baseKey}:control`;
+  }
+
+  if (isBtwRequestText(text)) {
+    return `${baseKey}:btw`;
+  }
+
+  return baseKey;
+}

package/src/sequential-queue.ts

@@ -0,0 +1,86 @@
+/**
+ * Per-key serial task queue for Feishu inbound message handling.
+ *
+ * Tasks enqueued under the same key run in FIFO order. Different keys run
+ * concurrently. This preserves the channel's same-chat ordering contract
+ * (see #64324) while letting cross-chat work proceed in parallel.
+ *
+ * `taskTimeoutMs` bounds how long the queue will block subsequent same-key
+ * tasks behind a single in-flight task. After the cap, the in-flight task
+ * is evicted from the blocking chain so newer messages for the same key
+ * can proceed. The original task is NOT aborted — it continues running in
+ * the background; it just stops starving the queue.
+ *
+ * Without this cap, a single hung dispatch (e.g. an agent call that never
+ * resolves) keeps later same-chat messages in `queued` state until the
+ * gateway is restarted. See #70133.
+ */
+
+const DEFAULT_TASK_TIMEOUT_MS = 5 * 60 * 1000;
+
+export interface SequentialQueueOptions {
+  /**
+   * Maximum time (ms) to block subsequent same-key tasks behind a single
+   * in-flight task. Pass 0 (or a non-finite value) to disable the cap and
+   * restore unbounded legacy behavior.
+   *
+   * Default: 5 minutes.
+   */
+  taskTimeoutMs?: number;
+
+  /**
+   * Optional callback fired when a task exceeds `taskTimeoutMs`. The task
+   * itself is not awaited further; this callback is the only signal the
+   * caller gets that the queue moved on without it.
+   */
+  onTaskTimeout?: (key: string, timeoutMs: number) => void;
+}
+
+export function createSequentialQueue(options: SequentialQueueOptions = {}) {
+  const queues = new Map<string, Promise<void>>();
+  const taskTimeoutMs = options.taskTimeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
+  const onTaskTimeout = options.onTaskTimeout;
+
+  return (key: string, task: () => Promise<void>): Promise<void> => {
+    const previous = queues.get(key) ?? Promise.resolve();
+    const wrapped = () => boundedRun(key, task, taskTimeoutMs, onTaskTimeout);
+    const next = previous.then(wrapped, wrapped);
+    queues.set(key, next);
+    const cleanup = () => {
+      if (queues.get(key) === next) {
+        queues.delete(key);
+      }
+    };
+    next.then(cleanup, cleanup);
+    return next;
+  };
+}
+
+async function boundedRun(
+  key: string,
+  task: () => Promise<void>,
+  timeoutMs: number,
+  onTaskTimeout: ((key: string, timeoutMs: number) => void) | undefined,
+): Promise<void> {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return task();
+  }
+  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<void>((resolve) => {
+    timeoutHandle = setTimeout(() => {
+      try {
+        onTaskTimeout?.(key, timeoutMs);
+      } catch {
+        // Swallow logging errors so they cannot poison the queue chain.
+      }
+      resolve();
+    }, timeoutMs);
+  });
+  try {
+    await Promise.race([task(), timeoutPromise]);
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+  }
+}

package/src/session-conversation.ts

@@ -0,0 +1,42 @@
+import { buildFeishuConversationId, parseFeishuConversationId } from "./conversation-id.js";
+
+function resolveFeishuParentConversationCandidates(rawId: string): string[] {
+  const parsed = parseFeishuConversationId({ conversationId: rawId });
+  if (!parsed) {
+    return [];
+  }
+  switch (parsed.scope) {
+    case "group_topic_sender":
+      return [
+        buildFeishuConversationId({
+          chatId: parsed.chatId,
+          scope: "group_topic",
+          topicId: parsed.topicId,
+        }),
+        parsed.chatId,
+      ];
+    case "group_topic":
+    case "group_sender":
+      return [parsed.chatId];
+    case "group":
+    default:
+      return [];
+  }
+}
+
+export function resolveFeishuSessionConversation(params: {
+  kind: "group" | "channel";
+  rawId: string;
+}) {
+  const parsed = parseFeishuConversationId({ conversationId: params.rawId });
+  if (!parsed) {
+    return null;
+  }
+  return {
+    id: parsed.canonicalConversationId,
+    baseConversationId: parsed.chatId,
+    parentConversationCandidates: resolveFeishuParentConversationCandidates(
+      parsed.canonicalConversationId,
+    ),
+  };
+}

package/src/session-route.ts

@@ -0,0 +1,48 @@
+import {
+  buildChannelOutboundSessionRoute,
+  stripChannelTargetPrefix,
+  type ChannelOutboundSessionRouteParams,
+} from "autobot/plugin-sdk/channel-core";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+export function resolveFeishuOutboundSessionRoute(params: ChannelOutboundSessionRouteParams) {
+  let trimmed = stripChannelTargetPrefix(params.target, "feishu", "lark");
+  if (!trimmed) {
+    return null;
+  }
+
+  const lower = normalizeLowercaseStringOrEmpty(trimmed);
+  let isGroup = false;
+  let typeExplicit = false;
+
+  if (lower.startsWith("group:") || lower.startsWith("chat:") || lower.startsWith("channel:")) {
+    trimmed = trimmed.replace(/^(group|chat|channel):/i, "").trim();
+    isGroup = true;
+    typeExplicit = true;
+  } else if (lower.startsWith("user:") || lower.startsWith("dm:")) {
+    trimmed = trimmed.replace(/^(user|dm):/i, "").trim();
+    isGroup = false;
+    typeExplicit = true;
+  }
+
+  if (!typeExplicit) {
+    const idLower = normalizeLowercaseStringOrEmpty(trimmed);
+    if (idLower.startsWith("ou_") || idLower.startsWith("on_")) {
+      isGroup = false;
+    }
+  }
+
+  return buildChannelOutboundSessionRoute({
+    cfg: params.cfg,
+    agentId: params.agentId,
+    channel: "feishu",
+    accountId: params.accountId,
+    peer: {
+      kind: isGroup ? "group" : "direct",
+      id: trimmed,
+    },
+    chatType: isGroup ? "group" : "direct",
+    from: isGroup ? `feishu:group:${trimmed}` : `feishu:${trimmed}`,
+    to: trimmed,
+  });
+}

package/src/setup-core.ts

@@ -0,0 +1,51 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  type ChannelSetupAdapter,
+  type AutoBotConfig,
+} from "autobot/plugin-sdk/setup";
+import { resolveDefaultFeishuAccountId } from "./accounts.js";
+import type { FeishuConfig } from "./types.js";
+
+export function setFeishuNamedAccountEnabled(
+  cfg: AutoBotConfig,
+  accountId: string,
+  enabled: boolean,
+): AutoBotConfig {
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      feishu: {
+        ...feishuCfg,
+        accounts: {
+          ...feishuCfg?.accounts,
+          [accountId]: {
+            ...feishuCfg?.accounts?.[accountId],
+            enabled,
+          },
+        },
+      },
+    },
+  };
+}
+
+export const feishuSetupAdapter: ChannelSetupAdapter = {
+  resolveAccountId: ({ cfg, accountId }) => accountId?.trim() || resolveDefaultFeishuAccountId(cfg),
+  applyAccountConfig: ({ cfg, accountId }) => {
+    const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+    if (isDefault) {
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          feishu: {
+            ...cfg.channels?.feishu,
+            enabled: true,
+          },
+        },
+      };
+    }
+    return setFeishuNamedAccountEnabled(cfg, accountId, true);
+  },
+};