@nextclaw/channel-plugin-feishu 0.2.29-beta.0 → 0.2.29-beta.1

package/dist/src/config-schema.d.ts

@@ -0,0 +1,357 @@
+import { z } from "zod";
+
+//#region src/config-schema.d.ts
+declare const FeishuConfigSchema: z.ZodObject<{
+  dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    open: "open";
+    pairing: "pairing";
+    allowlist: "allowlist";
+  }>>>;
+  reactionNotifications: z.ZodDefault<z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+    off: "off";
+    own: "own";
+    all: "all";
+  }>>>>;
+  groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    disabled: "disabled";
+    open: "open";
+    allowlist: "allowlist";
+  }>, z.ZodPipe<z.ZodLiteral<"allowall">, z.ZodTransform<"open", "allowall">>]>>>;
+  requireMention: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  groupSessionScope: z.ZodOptional<z.ZodEnum<{
+    group: "group";
+    group_sender: "group_sender";
+    group_topic: "group_topic";
+    group_topic_sender: "group_topic_sender";
+  }>>;
+  topicSessionMode: z.ZodOptional<z.ZodEnum<{
+    enabled: "enabled";
+    disabled: "disabled";
+  }>>;
+  dynamicAgentCreation: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    workspaceTemplate: z.ZodOptional<z.ZodString>;
+    agentDirTemplate: z.ZodOptional<z.ZodString>;
+    maxAgents: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  typingIndicator: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  resolveSenderNames: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+    groupSessionScope: z.ZodOptional<z.ZodEnum<{
+      group: "group";
+      group_sender: "group_sender";
+      group_topic: "group_topic";
+      group_topic_sender: "group_topic_sender";
+    }>>;
+    topicSessionMode: z.ZodOptional<z.ZodEnum<{
+      enabled: "enabled";
+      disabled: "disabled";
+    }>>;
+    webhookHost: z.ZodOptional<z.ZodString>;
+    webhookPort: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    markdown: z.ZodOptional<z.ZodObject<{
+      mode: z.ZodOptional<z.ZodEnum<{
+        native: "native";
+        escape: "escape";
+        strip: "strip";
+      }>>;
+      tableMode: z.ZodOptional<z.ZodEnum<{
+        native: "native";
+        ascii: "ascii";
+        simple: "simple";
+      }>>;
+    }, z.core.$strict>>;
+    configWrites: z.ZodOptional<z.ZodBoolean>;
+    dmPolicy: z.ZodOptional<z.ZodEnum<{
+      open: "open";
+      pairing: "pairing";
+      allowlist: "allowlist";
+    }>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    groupPolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+      disabled: "disabled";
+      open: "open";
+      allowlist: "allowlist";
+    }>, z.ZodPipe<z.ZodLiteral<"allowall">, z.ZodTransform<"open", "allowall">>]>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    groupSenderAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+      requireMention: z.ZodOptional<z.ZodBoolean>;
+      tools: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>;
+      skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      enabled: z.ZodOptional<z.ZodBoolean>;
+      allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+      systemPrompt: z.ZodOptional<z.ZodString>;
+      groupSessionScope: z.ZodOptional<z.ZodEnum<{
+        group: "group";
+        group_sender: "group_sender";
+        group_topic: "group_topic";
+        group_topic_sender: "group_topic_sender";
+      }>>;
+      topicSessionMode: z.ZodOptional<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+      }>>;
+      replyInThread: z.ZodOptional<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+      }>>;
+    }, z.core.$strict>>>>;
+    historyLimit: z.ZodOptional<z.ZodNumber>;
+    dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
+    dms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodOptional<z.ZodBoolean>;
+      systemPrompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    chunkMode: z.ZodOptional<z.ZodEnum<{
+      length: "length";
+      newline: "newline";
+    }>>;
+    blockStreamingCoalesce: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodOptional<z.ZodBoolean>;
+      minDelayMs: z.ZodOptional<z.ZodNumber>;
+      maxDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+    httpTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    heartbeat: z.ZodOptional<z.ZodObject<{
+      visibility: z.ZodOptional<z.ZodEnum<{
+        visible: "visible";
+        hidden: "hidden";
+      }>>;
+      intervalMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    renderMode: z.ZodOptional<z.ZodEnum<{
+      auto: "auto";
+      raw: "raw";
+      card: "card";
+    }>>;
+    streaming: z.ZodOptional<z.ZodBoolean>;
+    tools: z.ZodOptional<z.ZodObject<{
+      doc: z.ZodOptional<z.ZodBoolean>;
+      chat: z.ZodOptional<z.ZodBoolean>;
+      wiki: z.ZodOptional<z.ZodBoolean>;
+      drive: z.ZodOptional<z.ZodBoolean>;
+      perm: z.ZodOptional<z.ZodBoolean>;
+      scopes: z.ZodOptional<z.ZodBoolean>;
+      calendar: z.ZodOptional<z.ZodBoolean>;
+      task: z.ZodOptional<z.ZodBoolean>;
+      sheets: z.ZodOptional<z.ZodBoolean>;
+      oauth: z.ZodOptional<z.ZodBoolean>;
+      identity: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    replyInThread: z.ZodOptional<z.ZodEnum<{
+      enabled: "enabled";
+      disabled: "disabled";
+    }>>;
+    reactionNotifications: z.ZodOptional<z.ZodEnum<{
+      off: "off";
+      own: "own";
+      all: "all";
+    }>>;
+    typingIndicator: z.ZodOptional<z.ZodBoolean>;
+    resolveSenderNames: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodOptional<z.ZodString>;
+    appId: z.ZodOptional<z.ZodString>;
+    appSecret: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+      source: z.ZodLiteral<"env">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"file">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"exec">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>], "source">]>>;
+    encryptKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+      source: z.ZodLiteral<"env">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"file">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"exec">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>], "source">]>>;
+    verificationToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+      source: z.ZodLiteral<"env">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"file">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      source: z.ZodLiteral<"exec">;
+      provider: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strip>], "source">]>>;
+    domain: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+      feishu: "feishu";
+      lark: "lark";
+    }>, z.ZodString]>>;
+    connectionMode: z.ZodOptional<z.ZodEnum<{
+      websocket: "websocket";
+      webhook: "webhook";
+    }>>;
+    webhookPath: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>>>;
+  webhookHost: z.ZodOptional<z.ZodString>;
+  webhookPort: z.ZodOptional<z.ZodNumber>;
+  capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  markdown: z.ZodOptional<z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+      native: "native";
+      escape: "escape";
+      strip: "strip";
+    }>>;
+    tableMode: z.ZodOptional<z.ZodEnum<{
+      native: "native";
+      ascii: "ascii";
+      simple: "simple";
+    }>>;
+  }, z.core.$strict>>;
+  configWrites: z.ZodOptional<z.ZodBoolean>;
+  allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  groupSenderAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    tools: z.ZodOptional<z.ZodObject<{
+      allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    groupSessionScope: z.ZodOptional<z.ZodEnum<{
+      group: "group";
+      group_sender: "group_sender";
+      group_topic: "group_topic";
+      group_topic_sender: "group_topic_sender";
+    }>>;
+    topicSessionMode: z.ZodOptional<z.ZodEnum<{
+      enabled: "enabled";
+      disabled: "disabled";
+    }>>;
+    replyInThread: z.ZodOptional<z.ZodEnum<{
+      enabled: "enabled";
+      disabled: "disabled";
+    }>>;
+  }, z.core.$strict>>>>;
+  historyLimit: z.ZodOptional<z.ZodNumber>;
+  dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
+  dms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>>>;
+  textChunkLimit: z.ZodOptional<z.ZodNumber>;
+  chunkMode: z.ZodOptional<z.ZodEnum<{
+    length: "length";
+    newline: "newline";
+  }>>;
+  blockStreamingCoalesce: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    minDelayMs: z.ZodOptional<z.ZodNumber>;
+    maxDelayMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+  httpTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  heartbeat: z.ZodOptional<z.ZodObject<{
+    visibility: z.ZodOptional<z.ZodEnum<{
+      visible: "visible";
+      hidden: "hidden";
+    }>>;
+    intervalMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  renderMode: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    raw: "raw";
+    card: "card";
+  }>>;
+  streaming: z.ZodOptional<z.ZodBoolean>;
+  tools: z.ZodOptional<z.ZodObject<{
+    doc: z.ZodOptional<z.ZodBoolean>;
+    chat: z.ZodOptional<z.ZodBoolean>;
+    wiki: z.ZodOptional<z.ZodBoolean>;
+    drive: z.ZodOptional<z.ZodBoolean>;
+    perm: z.ZodOptional<z.ZodBoolean>;
+    scopes: z.ZodOptional<z.ZodBoolean>;
+    calendar: z.ZodOptional<z.ZodBoolean>;
+    task: z.ZodOptional<z.ZodBoolean>;
+    sheets: z.ZodOptional<z.ZodBoolean>;
+    oauth: z.ZodOptional<z.ZodBoolean>;
+    identity: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  replyInThread: z.ZodOptional<z.ZodEnum<{
+    enabled: "enabled";
+    disabled: "disabled";
+  }>>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  defaultAccount: z.ZodOptional<z.ZodString>;
+  appId: z.ZodOptional<z.ZodString>;
+  appSecret: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"env">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"file">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"exec">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>], "source">]>>;
+  encryptKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"env">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"file">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"exec">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>], "source">]>>;
+  verificationToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"env">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"file">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"exec">;
+    provider: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>], "source">]>>;
+  domain: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    feishu: "feishu";
+    lark: "lark";
+  }>, z.ZodString]>>>;
+  connectionMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    websocket: "websocket";
+    webhook: "webhook";
+  }>>>;
+  webhookPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strict>;
+//#endregion
+export { FeishuConfigSchema, z };

package/dist/src/dedup.js

@@ -0,0 +1,126 @@
+import { createDedupeCache, createPersistentDedupe, readJsonFileWithFallback } from "./nextclaw-sdk/dedupe.js";
+import "./nextclaw-sdk/feishu.js";
+import path from "node:path";
+import os from "node:os";
+//#region src/dedup.ts
+const DEDUP_TTL_MS = 1440 * 60 * 1e3;
+const MEMORY_MAX_SIZE = 1e3;
+const FILE_MAX_ENTRIES = 1e4;
+const EVENT_DEDUP_TTL_MS = 300 * 1e3;
+const EVENT_MEMORY_MAX_SIZE = 2e3;
+const memoryDedupe = createDedupeCache({
+	ttlMs: DEDUP_TTL_MS,
+	maxSize: MEMORY_MAX_SIZE
+});
+const processingClaims = createDedupeCache({
+	ttlMs: EVENT_DEDUP_TTL_MS,
+	maxSize: EVENT_MEMORY_MAX_SIZE
+});
+function resolveStateDirFromEnv(env = process.env) {
+	const stateOverride = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+	if (stateOverride) return stateOverride;
+	if (env.VITEST || env.NODE_ENV === "test") return path.join(os.tmpdir(), ["openclaw-vitest", String(process.pid)].join("-"));
+	return path.join(os.homedir(), ".openclaw");
+}
+function resolveNamespaceFilePath(namespace) {
+	const safe = namespace.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return path.join(resolveStateDirFromEnv(), "feishu", "dedup", `${safe}.json`);
+}
+const persistentDedupe = createPersistentDedupe({
+	ttlMs: DEDUP_TTL_MS,
+	memoryMaxSize: MEMORY_MAX_SIZE,
+	fileMaxEntries: FILE_MAX_ENTRIES,
+	resolveFilePath: resolveNamespaceFilePath
+});
+function resolveEventDedupeKey(namespace, messageId) {
+	const trimmed = messageId?.trim();
+	if (!trimmed) return null;
+	return `${namespace}:${trimmed}`;
+}
+function normalizeMessageId(messageId) {
+	const trimmed = messageId?.trim();
+	return trimmed ? trimmed : null;
+}
+function resolveMemoryDedupeKey(namespace, messageId) {
+	const trimmed = normalizeMessageId(messageId);
+	if (!trimmed) return null;
+	return `${namespace}:${trimmed}`;
+}
+function tryBeginFeishuMessageProcessing(messageId, namespace = "global") {
+	return !processingClaims.check(resolveEventDedupeKey(namespace, messageId));
+}
+function releaseFeishuMessageProcessing(messageId, namespace = "global") {
+	processingClaims.delete(resolveEventDedupeKey(namespace, messageId));
+}
+async function finalizeFeishuMessageProcessing(params) {
+	const { messageId, namespace = "global", log, claimHeld = false } = params;
+	const normalizedMessageId = normalizeMessageId(messageId);
+	const memoryKey = resolveMemoryDedupeKey(namespace, messageId);
+	if (!memoryKey || !normalizedMessageId) return false;
+	if (!claimHeld && !tryBeginFeishuMessageProcessing(normalizedMessageId, namespace)) return false;
+	if (!tryRecordMessage(memoryKey)) {
+		releaseFeishuMessageProcessing(normalizedMessageId, namespace);
+		return false;
+	}
+	if (!await tryRecordMessagePersistent(normalizedMessageId, namespace, log)) {
+		releaseFeishuMessageProcessing(normalizedMessageId, namespace);
+		return false;
+	}
+	return true;
+}
+async function recordProcessedFeishuMessage(messageId, namespace = "global", log) {
+	const normalizedMessageId = normalizeMessageId(messageId);
+	const memoryKey = resolveMemoryDedupeKey(namespace, messageId);
+	if (!memoryKey || !normalizedMessageId) return false;
+	tryRecordMessage(memoryKey);
+	return await tryRecordMessagePersistent(normalizedMessageId, namespace, log);
+}
+async function hasProcessedFeishuMessage(messageId, namespace = "global", log) {
+	const normalizedMessageId = normalizeMessageId(messageId);
+	const memoryKey = resolveMemoryDedupeKey(namespace, messageId);
+	if (!memoryKey || !normalizedMessageId) return false;
+	if (hasRecordedMessage(memoryKey)) return true;
+	return hasRecordedMessagePersistent(normalizedMessageId, namespace, log);
+}
+/**
+* Synchronous dedup — memory only.
+* Kept for backward compatibility; prefer {@link tryRecordMessagePersistent}.
+*/
+function tryRecordMessage(messageId) {
+	return !memoryDedupe.check(messageId);
+}
+function hasRecordedMessage(messageId) {
+	const trimmed = messageId.trim();
+	if (!trimmed) return false;
+	return memoryDedupe.peek(trimmed);
+}
+async function tryRecordMessagePersistent(messageId, namespace = "global", log) {
+	return persistentDedupe.checkAndRecord(messageId, {
+		namespace,
+		onDiskError: (error) => {
+			log?.(`feishu-dedup: disk error, falling back to memory: ${String(error)}`);
+		}
+	});
+}
+async function hasRecordedMessagePersistent(messageId, namespace = "global", log) {
+	const trimmed = messageId.trim();
+	if (!trimmed) return false;
+	const now = Date.now();
+	const filePath = resolveNamespaceFilePath(namespace);
+	try {
+		const { value } = await readJsonFileWithFallback(filePath, {});
+		const seenAt = value[trimmed];
+		if (typeof seenAt !== "number" || !Number.isFinite(seenAt)) return false;
+		return DEDUP_TTL_MS <= 0 || now - seenAt < DEDUP_TTL_MS;
+	} catch (error) {
+		log?.(`feishu-dedup: persistent peek failed: ${String(error)}`);
+		return false;
+	}
+}
+async function warmupDedupFromDisk(namespace, log) {
+	return persistentDedupe.warmup(namespace, (error) => {
+		log?.(`feishu-dedup: warmup disk error: ${String(error)}`);
+	});
+}
+//#endregion
+export { finalizeFeishuMessageProcessing, hasProcessedFeishuMessage, recordProcessedFeishuMessage, releaseFeishuMessageProcessing, tryBeginFeishuMessageProcessing, tryRecordMessagePersistent, warmupDedupFromDisk };

package/dist/src/device-flow.js

@@ -0,0 +1,109 @@
+import { feishuFetch } from "./feishu-fetch.js";
+//#region src/device-flow.ts
+function resolveOAuthEndpoints(domain) {
+	if (!domain || domain === "feishu") return {
+		deviceAuthorization: "https://accounts.feishu.cn/oauth/v1/device_authorization",
+		token: "https://open.feishu.cn/open-apis/authen/v2/oauth/token"
+	};
+	if (domain === "lark") return {
+		deviceAuthorization: "https://accounts.larksuite.com/oauth/v1/device_authorization",
+		token: "https://open.larksuite.com/open-apis/authen/v2/oauth/token"
+	};
+	const base = domain.replace(/\/+$/, "");
+	let accountsBase = base;
+	try {
+		const parsed = new URL(base);
+		if (parsed.hostname.startsWith("open.")) accountsBase = `${parsed.protocol}//${parsed.hostname.replace(/^open\./, "accounts.")}`;
+	} catch {}
+	return {
+		deviceAuthorization: `${accountsBase}/oauth/v1/device_authorization`,
+		token: `${base}/open-apis/authen/v2/oauth/token`
+	};
+}
+async function requestDeviceAuthorization(params) {
+	const endpoints = resolveOAuthEndpoints(params.domain);
+	let scope = params.scope?.trim() ?? "";
+	if (!scope.includes("offline_access")) scope = scope ? `${scope} offline_access` : "offline_access";
+	const basicAuth = Buffer.from(`${params.appId}:${params.appSecret}`).toString("base64");
+	const body = new URLSearchParams();
+	body.set("client_id", params.appId);
+	body.set("scope", scope);
+	const response = await feishuFetch(endpoints.deviceAuthorization, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			Authorization: `Basic ${basicAuth}`
+		},
+		body: body.toString()
+	});
+	const data = await response.json();
+	if (!response.ok || data.error) throw new Error(String(data.error_description ?? data.error ?? `HTTP ${response.status}`));
+	return {
+		deviceCode: String(data.device_code ?? ""),
+		userCode: String(data.user_code ?? ""),
+		verificationUri: String(data.verification_uri ?? ""),
+		verificationUriComplete: String(data.verification_uri_complete ?? data.verification_uri ?? ""),
+		expiresIn: Number(data.expires_in ?? 240),
+		interval: Number(data.interval ?? 5)
+	};
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(new DOMException("Aborted", "AbortError"));
+		}, { once: true });
+	});
+}
+async function pollDeviceToken(params) {
+	const endpoints = resolveOAuthEndpoints(params.domain);
+	const deadline = Date.now() + params.expiresIn * 1e3;
+	let interval = params.interval;
+	while (Date.now() < deadline) {
+		if (params.signal?.aborted) return {
+			ok: false,
+			error: "expired_token",
+			message: "Polling was cancelled"
+		};
+		await sleep(interval * 1e3, params.signal);
+		const data = await (await feishuFetch(endpoints.token, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+				device_code: params.deviceCode,
+				client_id: params.appId,
+				client_secret: params.appSecret
+			}).toString()
+		})).json();
+		const error = typeof data.error === "string" ? data.error : void 0;
+		if (!error && data.access_token) return {
+			ok: true,
+			token: {
+				accessToken: String(data.access_token),
+				refreshToken: String(data.refresh_token ?? ""),
+				expiresIn: Number(data.expires_in ?? 7200),
+				refreshExpiresIn: Number(data.refresh_token_expires_in ?? data.expires_in ?? 7200),
+				scope: String(data.scope ?? "")
+			}
+		};
+		if (error === "authorization_pending") continue;
+		if (error === "slow_down") {
+			interval = Math.min(interval + 5, 60);
+			continue;
+		}
+		if (error === "access_denied" || error === "expired_token") return {
+			ok: false,
+			error,
+			message: String(data.error_description ?? error)
+		};
+	}
+	return {
+		ok: false,
+		error: "expired_token",
+		message: "Device authorization expired before approval finished."
+	};
+}
+//#endregion
+export { pollDeviceToken, requestDeviceAuthorization, resolveOAuthEndpoints };

package/dist/src/directory.js

@@ -0,0 +1,101 @@
+import { listDirectoryGroupEntriesFromMapKeysAndAllowFrom, listDirectoryUserEntriesFromAllowFromAndMapKeys } from "./nextclaw-sdk/core-channel.js";
+import { resolveFeishuAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { normalizeFeishuTarget } from "./targets.js";
+//#region src/directory.ts
+function toFeishuDirectoryPeers(ids) {
+	return ids.map((id) => ({
+		kind: "user",
+		id
+	}));
+}
+function toFeishuDirectoryGroups(ids) {
+	return ids.map((id) => ({
+		kind: "group",
+		id
+	}));
+}
+async function listFeishuDirectoryPeers(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return toFeishuDirectoryPeers(listDirectoryUserEntriesFromAllowFromAndMapKeys({
+		allowFrom: account.config.allowFrom,
+		map: account.config.dms,
+		query: params.query,
+		limit: params.limit,
+		normalizeAllowFromId: (entry) => normalizeFeishuTarget(entry) ?? entry,
+		normalizeMapKeyId: (entry) => normalizeFeishuTarget(entry) ?? entry
+	}).map((entry) => entry.id));
+}
+async function listFeishuDirectoryGroups(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return toFeishuDirectoryGroups(listDirectoryGroupEntriesFromMapKeysAndAllowFrom({
+		groups: account.config.groups,
+		allowFrom: account.config.groupAllowFrom,
+		query: params.query,
+		limit: params.limit
+	}).map((entry) => entry.id));
+}
+async function listFeishuDirectoryPeersLive(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.configured) return listFeishuDirectoryPeers(params);
+	try {
+		const client = createFeishuClient(account);
+		const peers = [];
+		const limit = params.limit ?? 50;
+		const response = await client.contact.user.list({ params: { page_size: Math.min(limit, 50) } });
+		if (response.code === 0 && response.data?.items) for (const user of response.data.items) {
+			if (user.open_id) {
+				const q = params.query?.trim().toLowerCase() || "";
+				const name = user.name || "";
+				if (!q || user.open_id.toLowerCase().includes(q) || name.toLowerCase().includes(q)) peers.push({
+					kind: "user",
+					id: user.open_id,
+					name: name || void 0
+				});
+			}
+			if (peers.length >= limit) break;
+		}
+		return peers;
+	} catch {
+		return listFeishuDirectoryPeers(params);
+	}
+}
+async function listFeishuDirectoryGroupsLive(params) {
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.configured) return listFeishuDirectoryGroups(params);
+	try {
+		const client = createFeishuClient(account);
+		const groups = [];
+		const limit = params.limit ?? 50;
+		const response = await client.im.chat.list({ params: { page_size: Math.min(limit, 100) } });
+		if (response.code === 0 && response.data?.items) for (const chat of response.data.items) {
+			if (chat.chat_id) {
+				const q = params.query?.trim().toLowerCase() || "";
+				const name = chat.name || "";
+				if (!q || chat.chat_id.toLowerCase().includes(q) || name.toLowerCase().includes(q)) groups.push({
+					kind: "group",
+					id: chat.chat_id,
+					name: name || void 0
+				});
+			}
+			if (groups.length >= limit) break;
+		}
+		return groups;
+	} catch {
+		return listFeishuDirectoryGroups(params);
+	}
+}
+//#endregion
+export { listFeishuDirectoryGroups, listFeishuDirectoryGroupsLive, listFeishuDirectoryPeers, listFeishuDirectoryPeersLive };