@openclaw-china/shared 0.1.29 → 0.1.31

package/src/policy/dm-policy.ts

@@ -1,82 +1,82 @@
-/**
- * DM 策略引擎
- *
- * 实现 open/pairing/allowlist 策略检查
- */
-
-/**
- * DM 策略类型
- * - open: 允许所有单聊消息
- * - pairing: 配对模式（允许所有，配对逻辑由上层处理）
- * - allowlist: 仅允许白名单中的发送者
- */
-export type DmPolicyType = "open" | "pairing" | "allowlist";
-
-/**
- * 策略检查结果
- */
-export interface PolicyCheckResult {
-  /** 是否允许处理该消息 */
-  allowed: boolean;
-  /** 拒绝原因（如果被拒绝） */
-  reason?: string;
-}
-
-/**
- * DM 策略检查参数
- */
-export interface DmPolicyCheckParams {
-  /** DM 策略类型 */
-  dmPolicy: DmPolicyType;
-  /** 发送者 ID */
-  senderId: string;
-  /** 白名单（allowlist 策略时使用） */
-  allowFrom?: string[];
-}
-
-/**
- * 检查单聊策略
- *
- * @param params 检查参数
- * @returns 策略检查结果
- *
- * @example
- * ```ts
- * // 开放策略
- * checkDmPolicy({ dmPolicy: "open", senderId: "user1" });
- * // => { allowed: true }
- *
- * // 白名单策略
- * checkDmPolicy({ dmPolicy: "allowlist", senderId: "user1", allowFrom: ["user1", "user2"] });
- * // => { allowed: true }
- *
- * checkDmPolicy({ dmPolicy: "allowlist", senderId: "user3", allowFrom: ["user1", "user2"] });
- * // => { allowed: false, reason: "sender user3 not in DM allowlist" }
- * ```
- */
-export function checkDmPolicy(params: DmPolicyCheckParams): PolicyCheckResult {
-  const { dmPolicy, senderId, allowFrom = [] } = params;
-
-  switch (dmPolicy) {
-    case "open":
-      // 开放策略：允许所有单聊消息
-      return { allowed: true };
-
-    case "pairing":
-      // 配对策略：允许所有单聊消息（配对逻辑由上层处理）
-      return { allowed: true };
-
-    case "allowlist":
-      // 白名单策略：仅允许 allowFrom 中的发送者
-      if (allowFrom.includes(senderId)) {
-        return { allowed: true };
-      }
-      return {
-        allowed: false,
-        reason: `sender ${senderId} not in DM allowlist`,
-      };
-
-    default:
-      return { allowed: true };
-  }
-}
+/**
+ * DM 策略引擎
+ *
+ * 实现 open/pairing/allowlist 策略检查
+ */
+
+/**
+ * DM 策略类型
+ * - open: 允许所有单聊消息
+ * - pairing: 配对模式（允许所有，配对逻辑由上层处理）
+ * - allowlist: 仅允许白名单中的发送者
+ */
+export type DmPolicyType = "open" | "pairing" | "allowlist";
+
+/**
+ * 策略检查结果
+ */
+export interface PolicyCheckResult {
+  /** 是否允许处理该消息 */
+  allowed: boolean;
+  /** 拒绝原因（如果被拒绝） */
+  reason?: string;
+}
+
+/**
+ * DM 策略检查参数
+ */
+export interface DmPolicyCheckParams {
+  /** DM 策略类型 */
+  dmPolicy: DmPolicyType;
+  /** 发送者 ID */
+  senderId: string;
+  /** 白名单（allowlist 策略时使用） */
+  allowFrom?: string[];
+}
+
+/**
+ * 检查单聊策略
+ *
+ * @param params 检查参数
+ * @returns 策略检查结果
+ *
+ * @example
+ * ```ts
+ * // 开放策略
+ * checkDmPolicy({ dmPolicy: "open", senderId: "user1" });
+ * // => { allowed: true }
+ *
+ * // 白名单策略
+ * checkDmPolicy({ dmPolicy: "allowlist", senderId: "user1", allowFrom: ["user1", "user2"] });
+ * // => { allowed: true }
+ *
+ * checkDmPolicy({ dmPolicy: "allowlist", senderId: "user3", allowFrom: ["user1", "user2"] });
+ * // => { allowed: false, reason: "sender user3 not in DM allowlist" }
+ * ```
+ */
+export function checkDmPolicy(params: DmPolicyCheckParams): PolicyCheckResult {
+  const { dmPolicy, senderId, allowFrom = [] } = params;
+
+  switch (dmPolicy) {
+    case "open":
+      // 开放策略：允许所有单聊消息
+      return { allowed: true };
+
+    case "pairing":
+      // 配对策略：允许所有单聊消息（配对逻辑由上层处理）
+      return { allowed: true };
+
+    case "allowlist":
+      // 白名单策略：仅允许 allowFrom 中的发送者
+      if (allowFrom.includes(senderId)) {
+        return { allowed: true };
+      }
+      return {
+        allowed: false,
+        reason: `sender ${senderId} not in DM allowlist`,
+      };
+
+    default:
+      return { allowed: true };
+  }
+}

package/src/policy/group-policy.ts

@@ -1,93 +1,93 @@
-/**
- * 群组策略引擎
- *
- * 实现 open/allowlist/disabled 策略检查
- */
-
-import type { PolicyCheckResult } from "./dm-policy.js";
-
-/**
- * 群组策略类型
- * - open: 允许所有群聊消息
- * - allowlist: 仅允许白名单中的群组
- * - disabled: 禁用所有群聊消息
- */
-export type GroupPolicyType = "open" | "allowlist" | "disabled";
-
-/**
- * 群组策略检查参数
- */
-export interface GroupPolicyCheckParams {
-  /** 群组策略类型 */
-  groupPolicy: GroupPolicyType;
-  /** 会话 ID（群组 ID） */
-  conversationId: string;
-  /** 群组白名单（allowlist 策略时使用） */
-  groupAllowFrom?: string[];
-  /** 是否要求 @提及机器人 */
-  requireMention: boolean;
-  /** 是否 @提及了机器人 */
-  mentionedBot: boolean;
-}
-
-/**
- * 检查群聊策略
- *
- * @param params 检查参数
- * @returns 策略检查结果
- *
- * @example
- * ```ts
- * // 禁用策略
- * checkGroupPolicy({ groupPolicy: "disabled", conversationId: "g1", requireMention: false, mentionedBot: false });
- * // => { allowed: false, reason: "group messages disabled" }
- *
- * // 开放策略 + 要求 @提及
- * checkGroupPolicy({ groupPolicy: "open", conversationId: "g1", requireMention: true, mentionedBot: false });
- * // => { allowed: false, reason: "message did not mention bot" }
- *
- * // 白名单策略
- * checkGroupPolicy({ groupPolicy: "allowlist", conversationId: "g1", groupAllowFrom: ["g1"], requireMention: false, mentionedBot: false });
- * // => { allowed: true }
- * ```
- */
-export function checkGroupPolicy(params: GroupPolicyCheckParams): PolicyCheckResult {
-  const { groupPolicy, conversationId, groupAllowFrom = [], requireMention, mentionedBot } = params;
-
-  // 首先检查群聊策略
-  switch (groupPolicy) {
-    case "disabled":
-      // 禁用策略：拒绝所有群聊消息
-      return {
-        allowed: false,
-        reason: "group messages disabled",
-      };
-
-    case "allowlist":
-      // 白名单策略：仅允许 groupAllowFrom 中的群组
-      if (!groupAllowFrom.includes(conversationId)) {
-        return {
-          allowed: false,
-          reason: `group ${conversationId} not in allowlist`,
-        };
-      }
-      break;
-
-    case "open":
-      // 开放策略：允许所有群聊
-      break;
-
-    default:
-      break;
-  }
-
-  // 然后检查 @提及要求
-  if (requireMention && !mentionedBot) {
-    return {
-      allowed: false,
-      reason: "message did not mention bot",
-    };
-  }
-
-  return { allowed: true };
-}
+/**
+ * 群组策略引擎
+ *
+ * 实现 open/allowlist/disabled 策略检查
+ */
+
+import type { PolicyCheckResult } from "./dm-policy.js";
+
+/**
+ * 群组策略类型
+ * - open: 允许所有群聊消息
+ * - allowlist: 仅允许白名单中的群组
+ * - disabled: 禁用所有群聊消息
+ */
+export type GroupPolicyType = "open" | "allowlist" | "disabled";
+
+/**
+ * 群组策略检查参数
+ */
+export interface GroupPolicyCheckParams {
+  /** 群组策略类型 */
+  groupPolicy: GroupPolicyType;
+  /** 会话 ID（群组 ID） */
+  conversationId: string;
+  /** 群组白名单（allowlist 策略时使用） */
+  groupAllowFrom?: string[];
+  /** 是否要求 @提及机器人 */
+  requireMention: boolean;
+  /** 是否 @提及了机器人 */
+  mentionedBot: boolean;
+}
+
+/**
+ * 检查群聊策略
+ *
+ * @param params 检查参数
+ * @returns 策略检查结果
+ *
+ * @example
+ * ```ts
+ * // 禁用策略
+ * checkGroupPolicy({ groupPolicy: "disabled", conversationId: "g1", requireMention: false, mentionedBot: false });
+ * // => { allowed: false, reason: "group messages disabled" }
+ *
+ * // 开放策略 + 要求 @提及
+ * checkGroupPolicy({ groupPolicy: "open", conversationId: "g1", requireMention: true, mentionedBot: false });
+ * // => { allowed: false, reason: "message did not mention bot" }
+ *
+ * // 白名单策略
+ * checkGroupPolicy({ groupPolicy: "allowlist", conversationId: "g1", groupAllowFrom: ["g1"], requireMention: false, mentionedBot: false });
+ * // => { allowed: true }
+ * ```
+ */
+export function checkGroupPolicy(params: GroupPolicyCheckParams): PolicyCheckResult {
+  const { groupPolicy, conversationId, groupAllowFrom = [], requireMention, mentionedBot } = params;
+
+  // 首先检查群聊策略
+  switch (groupPolicy) {
+    case "disabled":
+      // 禁用策略：拒绝所有群聊消息
+      return {
+        allowed: false,
+        reason: "group messages disabled",
+      };
+
+    case "allowlist":
+      // 白名单策略：仅允许 groupAllowFrom 中的群组
+      if (!groupAllowFrom.includes(conversationId)) {
+        return {
+          allowed: false,
+          reason: `group ${conversationId} not in allowlist`,
+        };
+      }
+      break;
+
+    case "open":
+      // 开放策略：允许所有群聊
+      break;
+
+    default:
+      break;
+  }
+
+  // 然后检查 @提及要求
+  if (requireMention && !mentionedBot) {
+    return {
+      allowed: false,
+      reason: "message did not mention bot",
+    };
+  }
+
+  return { allowed: true };
+}

package/src/policy/index.ts

@@ -1,2 +1,2 @@
-export * from "./dm-policy.js";
-export * from "./group-policy.js";
+export * from "./dm-policy.js";
+export * from "./group-policy.js";

package/src/types/common.ts

@@ -1,24 +1,24 @@
-// 共享类型定义
-
-export type DmPolicy = "open" | "pairing" | "allowlist";
-export type GroupPolicy = "open" | "allowlist" | "disabled";
-
-export interface ParsedMessage {
-  chatId: string;
-  messageId: string;
-  senderId: string;
-  senderName?: string;
-  chatType: "direct" | "group";
-  content: string;
-  contentType: string;
-  mentionedBot: boolean;
-  replyToMessageId?: string;
-  timestamp: number;
-}
-
-export interface HistoryEntry {
-  sender: string;
-  body: string;
-  timestamp: number;
-  messageId: string;
-}
+// 共享类型定义
+
+export type DmPolicy = "open" | "pairing" | "allowlist";
+export type GroupPolicy = "open" | "allowlist" | "disabled";
+
+export interface ParsedMessage {
+  chatId: string;
+  messageId: string;
+  senderId: string;
+  senderName?: string;
+  chatType: "direct" | "group";
+  content: string;
+  contentType: string;
+  mentionedBot: boolean;
+  replyToMessageId?: string;
+  timestamp: number;
+}
+
+export interface HistoryEntry {
+  sender: string;
+  body: string;
+  timestamp: number;
+  messageId: string;
+}

package/tsconfig.json

@@ -1,8 +1,8 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
-}
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -1,8 +1,8 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    include: ["src/**/*.test.ts"],
-    globals: false,
-  },
-});
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/*.test.ts"],
+    globals: false,
+  },
+});

package/src/media/media-io.test.ts

@@ -1,180 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import * as fs from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import {
-  FileSizeLimitError,
-  MediaTimeoutError,
-  cleanupFileSafe,
-  downloadToTempFile,
-  finalizeInboundMediaFile,
-  pruneInboundMediaDir,
-} from "./media-io.js";
-
-const tempDirs: string[] = [];
-
-async function createTempDir(prefix: string): Promise<string> {
-  const dir = await fsPromises.mkdtemp(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(async () => {
-  for (const dir of tempDirs.splice(0, tempDirs.length)) {
-    await fsPromises.rm(dir, { recursive: true, force: true });
-  }
-});
-
-describe("downloadToTempFile", () => {
-  it("downloads HTTP response and stores a temp file", async () => {
-    const dir = await createTempDir("shared-media-io-");
-    const body = Buffer.from("hello-media", "utf8");
-    const fetchFn: typeof globalThis.fetch = async () =>
-      new Response(body, {
-        status: 200,
-        headers: {
-          "content-type": "image/png",
-          "content-length": String(body.length),
-        },
-      });
-
-    const result = await downloadToTempFile("https://example.com/a.png", {
-      fetch: fetchFn,
-      tempDir: dir,
-      tempPrefix: "dingtalk-file",
-    });
-
-    expect(result.path.startsWith(dir)).toBe(true);
-    expect(result.fileName.endsWith(".png")).toBe(true);
-    expect(result.size).toBe(body.length);
-    expect(result.contentType).toBe("image/png");
-
-    const saved = await fsPromises.readFile(result.path);
-    expect(saved.equals(body)).toBe(true);
-  });
-
-  it("throws FileSizeLimitError when Content-Length exceeds maxSize", async () => {
-    const fetchFn: typeof globalThis.fetch = async () =>
-      new Response("too-large", {
-        status: 200,
-        headers: {
-          "content-type": "application/octet-stream",
-          "content-length": "1024",
-        },
-      });
-
-    await expect(
-      downloadToTempFile("https://example.com/too-large.bin", {
-        fetch: fetchFn,
-        maxSize: 100,
-      })
-    ).rejects.toBeInstanceOf(FileSizeLimitError);
-  });
-
-  it("throws MediaTimeoutError on timeout", async () => {
-    const fetchFn: typeof globalThis.fetch = async (_url, init) =>
-      await new Promise<Response>((_resolve, reject) => {
-        const signal = init?.signal;
-        signal?.addEventListener("abort", () => {
-          const err = new Error("aborted");
-          (err as Error & { name: string }).name = "AbortError";
-          reject(err);
-        });
-      });
-
-    await expect(
-      downloadToTempFile("https://example.com/slow.bin", {
-        fetch: fetchFn,
-        timeout: 10,
-      })
-    ).rejects.toBeInstanceOf(MediaTimeoutError);
-  });
-});
-
-describe("cleanupFileSafe", () => {
-  it("removes file and ignores missing file", async () => {
-    const dir = await createTempDir("shared-media-clean-");
-    const filePath = path.join(dir, "a.txt");
-    await fsPromises.writeFile(filePath, "x", "utf8");
-    expect(fs.existsSync(filePath)).toBe(true);
-
-    await cleanupFileSafe(filePath);
-    expect(fs.existsSync(filePath)).toBe(false);
-
-    await expect(cleanupFileSafe(filePath)).resolves.toBeUndefined();
-    await expect(cleanupFileSafe(undefined)).resolves.toBeUndefined();
-  });
-});
-
-describe("inbound media retention", () => {
-  it("finalizes temp media into inbound/YYYY-MM-DD", async () => {
-    const tempDir = await createTempDir("shared-media-temp-");
-    const inboundDir = await createTempDir("shared-media-inbound-");
-    const sourcePath = path.join(tempDir, "img-1.jpg");
-    await fsPromises.writeFile(sourcePath, "abc", "utf8");
-
-    const finalPath = await finalizeInboundMediaFile({
-      filePath: sourcePath,
-      tempDir,
-      inboundDir,
-    });
-
-    expect(finalPath.startsWith(inboundDir)).toBe(true);
-    expect(fs.existsSync(finalPath)).toBe(true);
-    expect(fs.existsSync(sourcePath)).toBe(false);
-  });
-
-  it("does not move files outside tempDir", async () => {
-    const tempDir = await createTempDir("shared-media-temp-");
-    const inboundDir = await createTempDir("shared-media-inbound-");
-    const outsideDir = await createTempDir("shared-media-outside-");
-    const sourcePath = path.join(outsideDir, "a.txt");
-    await fsPromises.writeFile(sourcePath, "x", "utf8");
-
-    const finalPath = await finalizeInboundMediaFile({
-      filePath: sourcePath,
-      tempDir,
-      inboundDir,
-    });
-
-    expect(finalPath).toBe(sourcePath);
-    expect(fs.existsSync(sourcePath)).toBe(true);
-  });
-
-  it("prunes only expired files in date dirs and keeps recent files", async () => {
-    const inboundDir = await createTempDir("shared-media-prune-");
-    const oldDir = path.join(inboundDir, "2024-01-01");
-    const newDir = path.join(inboundDir, "2024-01-02");
-    await fsPromises.mkdir(oldDir, { recursive: true });
-    await fsPromises.mkdir(newDir, { recursive: true });
-
-    const oldFile = path.join(oldDir, "old.jpg");
-    const newFile = path.join(newDir, "new.jpg");
-    const nestedDir = path.join(oldDir, "nested");
-    const nestedFile = path.join(nestedDir, "nested.jpg");
-    await fsPromises.writeFile(oldFile, "old", "utf8");
-    await fsPromises.writeFile(newFile, "new", "utf8");
-    await fsPromises.mkdir(nestedDir, { recursive: true });
-    await fsPromises.writeFile(nestedFile, "nested", "utf8");
-
-    const oldTs = new Date("2024-01-01T00:00:00.000Z");
-    const newTs = new Date("2024-01-02T00:00:00.000Z");
-    await fsPromises.utimes(oldDir, oldTs, oldTs);
-    await fsPromises.utimes(oldFile, oldTs, oldTs);
-    await fsPromises.utimes(newDir, newTs, newTs);
-    await fsPromises.utimes(newFile, newTs, newTs);
-
-    const nowMs = new Date("2024-01-03T00:00:00.000Z").getTime();
-    await pruneInboundMediaDir({
-      inboundDir,
-      keepDays: 1,
-      nowMs,
-    });
-
-    expect(fs.existsSync(oldFile)).toBe(false);
-    expect(fs.existsSync(newFile)).toBe(true);
-    expect(fs.existsSync(nestedFile)).toBe(true);
-    expect(fs.existsSync(oldDir)).toBe(true);
-  });
-});