@openclaw/feishu 2026.7.1 → 2026.7.2-beta.1

package/openclaw.plugin.json

@@ -345,6 +345,54 @@
           }
         ]
       },
+      "streaming": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "mode": {
+            "type": "string",
+            "enum": [
+              "off",
+              "partial"
+            ],
+            "description": "\"partial\" (default) enables streaming-card replies; \"off\" sends one final message."
+          },
+          "chunkMode": {
+            "type": "string",
+            "enum": [
+              "length",
+              "newline"
+            ]
+          },
+          "block": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": {
+                "type": "boolean"
+              },
+              "coalesce": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "minChars": {
+                    "type": "integer",
+                    "minimum": 1
+                  },
+                  "maxChars": {
+                    "type": "integer",
+                    "minimum": 1
+                  },
+                  "idleMs": {
+                    "type": "integer",
+                    "minimum": 0
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
       "account": {
         "type": "object",
         "additionalProperties": true,
@@ -398,10 +446,7 @@
             ]
           },
           "streaming": {
-            "type": "boolean"
-          },
-          "blockStreaming": {
-            "type": "boolean"
+            "$ref": "#/$defs/streaming"
           },
           "replyInThread": {
             "type": "string",
@@ -466,10 +511,7 @@
         ]
       },
       "streaming": {
-        "type": "boolean"
-      },
-      "blockStreaming": {
-        "type": "boolean"
+        "$ref": "#/$defs/streaming"
       },
       "replyInThread": {
         "type": "string",
@@ -829,7 +871,6 @@
             }
           },
           "groupPolicy": {
-            "default": "allowlist",
             "anyOf": [
               {
                 "type": "string",
@@ -839,7 +880,10 @@
                   "disabled"
                 ]
               },
-              {}
+              {
+                "type": "string",
+                "const": "allowall"
+              }
             ]
           },
           "groupAllowFrom": {
@@ -985,35 +1029,6 @@
             "exclusiveMinimum": 0,
             "maximum": 9007199254740991
           },
-          "chunkMode": {
-            "type": "string",
-            "enum": [
-              "length",
-              "newline"
-            ]
-          },
-          "blockStreaming": {
-            "type": "boolean"
-          },
-          "blockStreamingCoalesce": {
-            "type": "object",
-            "properties": {
-              "enabled": {
-                "type": "boolean"
-              },
-              "minDelayMs": {
-                "type": "integer",
-                "exclusiveMinimum": 0,
-                "maximum": 9007199254740991
-              },
-              "maxDelayMs": {
-                "type": "integer",
-                "exclusiveMinimum": 0,
-                "maximum": 9007199254740991
-              }
-            },
-            "additionalProperties": false
-          },
           "mediaMaxMb": {
             "type": "number",
             "exclusiveMinimum": 0
@@ -1050,7 +1065,54 @@
             ]
           },
           "streaming": {
-            "type": "boolean"
+            "type": "object",
+            "properties": {
+              "mode": {
+                "type": "string",
+                "enum": [
+                  "off",
+                  "partial"
+                ]
+              },
+              "chunkMode": {
+                "type": "string",
+                "enum": [
+                  "length",
+                  "newline"
+                ]
+              },
+              "block": {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean"
+                  },
+                  "coalesce": {
+                    "type": "object",
+                    "properties": {
+                      "minChars": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "maxChars": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "idleMs": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 9007199254740991
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "additionalProperties": false
           },
           "tools": {
             "type": "object",
@@ -1578,7 +1640,10 @@
                         "disabled"
                       ]
                     },
-                    {}
+                    {
+                      "type": "string",
+                      "const": "allowall"
+                    }
                   ]
                 },
                 "groupAllowFrom": {
@@ -1724,35 +1789,6 @@
                   "exclusiveMinimum": 0,
                   "maximum": 9007199254740991
                 },
-                "chunkMode": {
-                  "type": "string",
-                  "enum": [
-                    "length",
-                    "newline"
-                  ]
-                },
-                "blockStreaming": {
-                  "type": "boolean"
-                },
-                "blockStreamingCoalesce": {
-                  "type": "object",
-                  "properties": {
-                    "enabled": {
-                      "type": "boolean"
-                    },
-                    "minDelayMs": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
-                    },
-                    "maxDelayMs": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
-                    }
-                  },
-                  "additionalProperties": false
-                },
                 "mediaMaxMb": {
                   "type": "number",
                   "exclusiveMinimum": 0
@@ -1789,7 +1825,54 @@
                   ]
                 },
                 "streaming": {
-                  "type": "boolean"
+                  "type": "object",
+                  "properties": {
+                    "mode": {
+                      "type": "string",
+                      "enum": [
+                        "off",
+                        "partial"
+                      ]
+                    },
+                    "chunkMode": {
+                      "type": "string",
+                      "enum": [
+                        "length",
+                        "newline"
+                      ]
+                    },
+                    "block": {
+                      "type": "object",
+                      "properties": {
+                        "enabled": {
+                          "type": "boolean"
+                        },
+                        "coalesce": {
+                          "type": "object",
+                          "properties": {
+                            "minChars": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "maximum": 9007199254740991
+                            },
+                            "maxChars": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "maximum": 9007199254740991
+                            },
+                            "idleMs": {
+                              "type": "integer",
+                              "minimum": 0,
+                              "maximum": 9007199254740991
+                            }
+                          },
+                          "additionalProperties": false
+                        }
+                      },
+                      "additionalProperties": false
+                    }
+                  },
+                  "additionalProperties": false
                 },
                 "tools": {
                   "type": "object",
@@ -1952,16 +2035,6 @@
             }
           }
         },
-        "required": [
-          "domain",
-          "connectionMode",
-          "webhookPath",
-          "dmPolicy",
-          "groupPolicy",
-          "reactionNotifications",
-          "typingIndicator",
-          "resolveSenderNames"
-        ],
         "additionalProperties": false
       },
       "label": "Feishu",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/feishu",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.1",
   "description": "OpenClaw Feishu/Lark channel plugin for chats and workplace tools (community maintained by @m1heng).",
   "repository": {
     "type": "git",
@@ -9,11 +9,14 @@
   "type": "module",
   "dependencies": {
     "@larksuiteoapi/node-sdk": "1.68.0",
+    "mdast-util-from-markdown": "2.0.3",
+    "mdast-util-gfm-table": "2.0.0",
+    "micromark-extension-gfm-table": "2.1.1",
     "typebox": "1.3.3",
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.7.1"
+    "openclaw": ">=2026.7.2-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -25,9 +28,6 @@
       "./index.ts"
     ],
     "setupEntry": "./dist/setup-entry.js",
-    "setupFeatures": {
-      "legacyStateMigrations": true
-    },
     "channel": {
       "id": "feishu",
       "label": "Feishu",
@@ -47,10 +47,10 @@
       "minHostVersion": ">=2026.5.29"
     },
     "compat": {
-      "pluginApi": ">=2026.7.1"
+      "pluginApi": ">=2026.7.2-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.7.1"
+      "openclawVersion": "2026.7.2-beta.1"
     },
     "release": {
       "publishToClawHub": true,
@@ -70,6 +70,9 @@
   ],
   "bundledDependencies": [
     "@larksuiteoapi/node-sdk",
+    "mdast-util-from-markdown",
+    "mdast-util-gfm-table",
+    "micromark-extension-gfm-table",
     "typebox",
     "zod"
   ]

package/skills/feishu-drive/SKILL.md

@@ -48,7 +48,9 @@ root-list cursors are not forwarded.
 { "action": "info", "file_token": "ABC123", "type": "docx" }
 ```
 
-Searches for the file in the root directory. Note: file must be in root or use `list` to browse folders first.
+Looks up file metadata directly by token and type, regardless of which shared folder contains it.
+Shortcuts are the exception: Feishu's metadata API does not support the `shortcut` type, so shortcut
+info retains the root-directory lookup behavior.
 
 `type`: `doc`, `docx`, `sheet`, `bitable`, `folder`, `file`, `mindnote`, `shortcut`
 
@@ -101,7 +103,8 @@ channels:
 ## Permissions
 
 - `drive:drive` - Full access (create, move, delete)
-- `drive:drive:readonly` - Read only (list, info)
+- `drive:drive:readonly` - Read only (list and root-level info fallback)
+- `drive:drive.metadata:readonly` - Direct `info` lookup outside the root (not needed with `drive:drive`)
 
 ## Known Limitations
 

package/dist/legacy-state-migrations-api.js

@@ -1,73 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash } from "node:crypto";
-//#region extensions/feishu/src/dedup-migrations.ts
-const DEDUP_TTL_MS = 1440 * 60 * 1e3;
-const STORE_MAX_ENTRIES = 1e4;
-function safeNamespaceFromFileName(fileName) {
-	if (!fileName.endsWith(".json")) return null;
-	const namespace = fileName.slice(0, -5).trim();
-	return namespace ? namespace : null;
-}
-function readLegacyDedupeData(filePath) {
-	try {
-		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-		const out = {};
-		for (const [messageId, seenAt] of Object.entries(parsed)) if (typeof seenAt === "number" && Number.isFinite(seenAt) && seenAt > 0) out[messageId] = seenAt;
-		return out;
-	} catch {
-		return {};
-	}
-}
-function dedupeStoreKey(namespace, messageId) {
-	return createHash("sha256").update(`${namespace}\0${messageId}`, "utf8").digest("hex").slice(0, 32);
-}
-function remainingTtlMs(seenAt, now) {
-	return Math.max(1, DEDUP_TTL_MS - (now - seenAt));
-}
-function buildMigrationEntries(namespace, sourcePath, now) {
-	return Object.entries(readLegacyDedupeData(sourcePath)).flatMap(([messageId, seenAt]) => {
-		if (now - seenAt >= DEDUP_TTL_MS) return [];
-		return [{
-			key: dedupeStoreKey(namespace, messageId),
-			value: {
-				namespace,
-				messageId,
-				seenAt
-			},
-			ttlMs: remainingTtlMs(seenAt, now)
-		}];
-	});
-}
-const detectFeishuLegacyStateMigrations = ({ stateDir }) => {
-	const dedupDir = path.join(stateDir, "feishu", "dedup");
-	let entries;
-	try {
-		entries = fs.readdirSync(dedupDir, { withFileTypes: true });
-	} catch {
-		return [];
-	}
-	const now = Date.now();
-	return entries.flatMap((entry) => {
-		if (!entry.isFile()) return [];
-		const namespace = safeNamespaceFromFileName(entry.name);
-		if (!namespace) return [];
-		const sourcePath = path.join(dedupDir, entry.name);
-		if (buildMigrationEntries(namespace, sourcePath, now).length === 0) return [];
-		return [{
-			kind: "plugin-state-import",
-			label: `Feishu ${namespace} dedupe`,
-			sourcePath,
-			targetPath: `plugin state:dedup.${namespace}`,
-			pluginId: "feishu",
-			namespace: `dedup.${namespace}`,
-			maxEntries: STORE_MAX_ENTRIES,
-			scopeKey: "",
-			cleanupSource: "rename",
-			readEntries: () => buildMigrationEntries(namespace, sourcePath, now)
-		}];
-	});
-};
-//#endregion
-export { detectFeishuLegacyStateMigrations };

package/dist/monitor.state-DAHbcR2N.js

@@ -1,173 +0,0 @@
-import { t as probeFeishu } from "./probe-Dxyo9zlw.js";
-import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { WEBHOOK_ANOMALY_COUNTER_DEFAULTS, WEBHOOK_RATE_LIMIT_DEFAULTS, createFixedWindowRateLimiter, createWebhookAnomalyTracker } from "openclaw/plugin-sdk/webhook-ingress";
-//#region extensions/feishu/src/monitor.startup.ts
-const FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS = 3e4;
-const FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV = "OPENCLAW_FEISHU_STARTUP_PROBE_TIMEOUT_MS";
-function resolveStartupProbeTimeoutMs(env = process.env) {
-	const raw = env[FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV];
-	if (raw) {
-		const parsed = parseStrictPositiveInteger(raw);
-		if (parsed !== void 0) return parsed;
-		console.warn(`[feishu] ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV}="${raw}" is invalid; using default ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS}ms`);
-	}
-	return FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS;
-}
-const FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS = resolveStartupProbeTimeoutMs();
-function isTimeoutErrorMessage(message) {
-	const lower = normalizeLowercaseStringOrEmpty(message);
-	return lower.includes("timeout") || lower.includes("timed out");
-}
-function isAbortErrorMessage(message) {
-	return normalizeLowercaseStringOrEmpty(message).includes("aborted");
-}
-async function fetchBotIdentityForMonitor(account, options = {}) {
-	if (options.abortSignal?.aborted) return {};
-	const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
-	const result = await probeFeishu(account, {
-		timeoutMs,
-		abortSignal: options.abortSignal
-	});
-	if (result.ok) return {
-		botOpenId: result.botOpenId,
-		botName: result.botName
-	};
-	const probeError = result.error ?? void 0;
-	if (options.abortSignal?.aborted || isAbortErrorMessage(probeError)) return {};
-	if (isTimeoutErrorMessage(probeError)) (options.runtime?.error ?? console.error)(`feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`);
-	return {};
-}
-//#endregion
-//#region extensions/feishu/src/monitor.state.ts
-const wsClients = /* @__PURE__ */ new Map();
-const httpServers = /* @__PURE__ */ new Map();
-const botOpenIds = /* @__PURE__ */ new Map();
-const botNames = /* @__PURE__ */ new Map();
-const botIdentityRevisions = /* @__PURE__ */ new Map();
-const FEISHU_WEBHOOK_MAX_BODY_BYTES = 64 * 1024;
-const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 5e3;
-const FEISHU_HTTP_SERVER_CLOSE_TIMEOUT_MS = 5e3;
-const FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS = {
-	windowMs: 6e4,
-	maxRequests: 120,
-	maxTrackedKeys: 4096
-};
-const FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS = {
-	maxTrackedKeys: 4096,
-	ttlMs: 360 * 6e4,
-	logEvery: 25
-};
-function coercePositiveInt(value, fallback) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-	const normalized = Math.floor(value);
-	return normalized > 0 ? normalized : fallback;
-}
-function resolveFeishuWebhookRateLimitDefaultsForTest(defaults) {
-	const resolved = defaults;
-	return {
-		windowMs: coercePositiveInt(resolved?.windowMs, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.windowMs),
-		maxRequests: coercePositiveInt(resolved?.maxRequests, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxRequests),
-		maxTrackedKeys: coercePositiveInt(resolved?.maxTrackedKeys, FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxTrackedKeys)
-	};
-}
-function resolveFeishuWebhookAnomalyDefaultsForTest(defaults) {
-	const resolved = defaults;
-	return {
-		maxTrackedKeys: coercePositiveInt(resolved?.maxTrackedKeys, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.maxTrackedKeys),
-		ttlMs: coercePositiveInt(resolved?.ttlMs, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.ttlMs),
-		logEvery: coercePositiveInt(resolved?.logEvery, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.logEvery)
-	};
-}
-const feishuWebhookRateLimitDefaults = resolveFeishuWebhookRateLimitDefaultsForTest(WEBHOOK_RATE_LIMIT_DEFAULTS);
-const feishuWebhookAnomalyDefaults = resolveFeishuWebhookAnomalyDefaultsForTest(WEBHOOK_ANOMALY_COUNTER_DEFAULTS);
-const feishuWebhookRateLimiter = createFixedWindowRateLimiter({
-	windowMs: feishuWebhookRateLimitDefaults.windowMs,
-	maxRequests: feishuWebhookRateLimitDefaults.maxRequests,
-	maxTrackedKeys: feishuWebhookRateLimitDefaults.maxTrackedKeys
-});
-const feishuWebhookAnomalyTracker = createWebhookAnomalyTracker({
-	maxTrackedKeys: feishuWebhookAnomalyDefaults.maxTrackedKeys,
-	ttlMs: feishuWebhookAnomalyDefaults.ttlMs,
-	logEvery: feishuWebhookAnomalyDefaults.logEvery
-});
-function readBotIdentityRevision(accountId) {
-	return botIdentityRevisions.get(accountId) ?? 0;
-}
-function bumpBotIdentityRevision(accountId) {
-	botIdentityRevisions.set(accountId, readBotIdentityRevision(accountId) + 1);
-}
-function captureBotIdentitySnapshot(accountId) {
-	return { revision: readBotIdentityRevision(accountId) };
-}
-function clearFeishuBotIdentityStateIfUnchanged(accountId, snapshot) {
-	if (readBotIdentityRevision(accountId) !== snapshot.revision) return;
-	botOpenIds.delete(accountId);
-	botNames.delete(accountId);
-	bumpBotIdentityRevision(accountId);
-}
-function setFeishuBotIdentityState(accountId, identity) {
-	botOpenIds.set(accountId, identity.botOpenId);
-	if (identity.botName) botNames.set(accountId, identity.botName);
-	else botNames.delete(accountId);
-	bumpBotIdentityRevision(accountId);
-}
-function clearFeishuBotIdentityState(accountId) {
-	botOpenIds.delete(accountId);
-	botNames.delete(accountId);
-	bumpBotIdentityRevision(accountId);
-}
-function isServerNotRunningError(error) {
-	return error.code === "ERR_SERVER_NOT_RUNNING";
-}
-async function closeFeishuHttpServer(server) {
-	await new Promise((resolve, reject) => {
-		let settled = false;
-		const settle = (err) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(fallbackTimer);
-			if (!err || isServerNotRunningError(err)) {
-				resolve();
-				return;
-			}
-			reject(err);
-		};
-		const fallbackTimer = setTimeout(() => {
-			try {
-				server.closeAllConnections();
-				settle();
-			} catch (err) {
-				settle(err instanceof Error ? err : new Error(String(err)));
-			}
-		}, FEISHU_HTTP_SERVER_CLOSE_TIMEOUT_MS);
-		try {
-			server.close((err) => {
-				settle(err);
-			});
-		} catch (err) {
-			settle(err instanceof Error ? err : new Error(String(err)));
-		}
-	});
-}
-async function closeTrackedFeishuHttpServer(accountId, server) {
-	const identitySnapshot = captureBotIdentitySnapshot(accountId);
-	try {
-		await closeFeishuHttpServer(server);
-	} finally {
-		if (httpServers.get(accountId) === server) {
-			httpServers.delete(accountId);
-			clearFeishuBotIdentityStateIfUnchanged(accountId, identitySnapshot);
-		}
-	}
-}
-function recordWebhookStatus(runtime, accountId, path, statusCode) {
-	feishuWebhookAnomalyTracker.record({
-		key: `${accountId}:${path}:${statusCode}`,
-		statusCode,
-		log: runtime?.log ?? console.log,
-		message: (count) => `feishu[${accountId}]: webhook anomaly path=${path} status=${statusCode} count=${count}`
-	});
-}
-//#endregion
-export { clearFeishuBotIdentityState as a, httpServers as c, wsClients as d, fetchBotIdentityForMonitor as f, botOpenIds as i, recordWebhookStatus as l, FEISHU_WEBHOOK_MAX_BODY_BYTES as n, closeTrackedFeishuHttpServer as o, botNames as r, feishuWebhookRateLimiter as s, FEISHU_WEBHOOK_BODY_TIMEOUT_MS as t, setFeishuBotIdentityState as u };