@meet-im/meet 1.0.3

package/src/channel.ts

@@ -0,0 +1,403 @@
+import type {
+  ChannelPlugin,
+  ClawdbotConfig,
+  GroupToolPolicyConfig,
+} from "openclaw/plugin-sdk";
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  PAIRING_APPROVED_MESSAGE,
+} from "openclaw/plugin-sdk";
+import type { ResolvedMeetAccount, MeetConfig } from "./types.js";
+import {
+  resolveMeetAccount,
+  listMeetAccountIds,
+  resolveDefaultMeetAccountId,
+  isFlatAccountConfig,
+  getFlatAccountKey,
+} from "./accounts.js";
+import { meetOutbound } from "./outbound.js";
+import { probeMeet } from "./probe.js";
+import { resolveMeetGroupPolicy } from "./policy.js";
+import {
+  parseMeetTarget,
+  looksLikeMeetId,
+  formatMeetTarget,
+} from "./targets.js";
+import { sendMessageMeet } from "./send.js";
+
+const meta = {
+  id: "meet",
+  label: "Meet",
+  selectionLabel: "Meet IM",
+  docsPath: "/channels/meet",
+  docsLabel: "meet",
+  blurb: "Meet IM platform integration.",
+  aliases: [],
+  order: 80,
+};
+
+export const meetPlugin: ChannelPlugin<ResolvedMeetAccount> = {
+  id: "meet",
+  meta: {
+    ...meta,
+  },
+  pairing: {
+    idLabel: "meetUserId",
+    normalizeAllowEntry: (entry) => entry.replace(/^(meet|user):/i, ""),
+    notifyApproval: async ({ cfg, id }) => {
+      await sendMessageMeet({
+        cfg,
+        to: id,
+        text: PAIRING_APPROVED_MESSAGE,
+      });
+    },
+  },
+  capabilities: {
+    chatTypes: ["direct", "channel"],
+    polls: false,
+    threads: false,
+    media: true,
+    reactions: false,
+    edit: false,
+    reply: false,
+  },
+  agentPrompt: {
+    messageToolHints: () => [
+      "- Meet targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:<id>` or `channel:<id>`.",
+      "- Meet mentions: use `<@USER_ID>` to mention users, `<@-1>` to mention everyone. Examples: `<@553> hello` or `<@-1> important announcement`.",
+    ],
+  },
+  groups: {
+    resolveToolPolicy: ({
+      cfg,
+      accountId,
+      groupId,
+    }): GroupToolPolicyConfig | undefined => {
+      const account = resolveMeetAccount({ cfg, accountId });
+      const groupPolicy = resolveMeetGroupPolicy({
+        groupPolicy: account.config.groupPolicy,
+        groupAllowFrom: account.config.groupAllowFrom ?? [],
+        chatId: groupId ?? "",
+        groups: account.config.groups,
+      });
+      if (!groupPolicy.allowed) {
+        return { deny: ["*"] };
+      }
+      return undefined;
+    },
+  },
+  reload: { configPrefixes: ["channels.meet"] },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        apiEndpoint: { type: "string" },
+        apiToken: { type: "string" },
+        pollTimeout: { type: "integer", minimum: 1000, maximum: 300000 },
+        pollLimit: { type: "integer", minimum: 1, maximum: 1000 },
+        dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+        allowFrom: {
+          type: "array",
+          items: { oneOf: [{ type: "string" }, { type: "number" }] },
+        },
+        groupPolicy: {
+          type: "string",
+          enum: ["open", "allowlist", "disabled"],
+        },
+        groupAllowFrom: {
+          type: "array",
+          items: { oneOf: [{ type: "string" }, { type: "number" }] },
+        },
+        groups: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              enabled: { type: "boolean" },
+              name: { type: "string" },
+              requireMention: { type: "boolean" },
+              systemPrompt: { type: "string" },
+              users: {
+                type: "array",
+                items: { oneOf: [{ type: "string" }, { type: "number" }] },
+              },
+            },
+          },
+        },
+        requireMention: { type: "boolean" },
+        historyLimit: { type: "integer", minimum: 0 },
+        dmHistoryLimit: { type: "integer", minimum: 0 },
+        textChunkLimit: { type: "integer", minimum: 1 },
+        mediaMaxMb: { type: "number", minimum: 0 },
+        accounts: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              enabled: { type: "boolean" },
+              name: { type: "string" },
+              apiEndpoint: { type: "string" },
+              apiToken: { type: "string" },
+              pollTimeout: { type: "integer", minimum: 1000, maximum: 300000 },
+              pollLimit: { type: "integer", minimum: 1, maximum: 1000 },
+            },
+          },
+        },
+      },
+    },
+  },
+  config: {
+    listAccountIds: (cfg) => listMeetAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveMeetAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultMeetAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) => {
+      const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+
+      if (isDefault) {
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            meet: {
+              ...cfg.channels?.meet,
+              enabled,
+            },
+          },
+        };
+      }
+
+      if (isFlatAccountConfig(cfg, accountId)) {
+        const key = getFlatAccountKey(accountId);
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            [key]: {
+              ...(cfg.channels?.[key] as Record<string, unknown> | undefined),
+              enabled,
+            },
+          },
+        };
+      }
+
+      const meetCfg = cfg.channels?.meet as MeetConfig | undefined;
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          meet: {
+            ...meetCfg,
+            accounts: {
+              ...meetCfg?.accounts,
+              [accountId]: {
+                ...meetCfg?.accounts?.[accountId],
+                enabled,
+              },
+            },
+          },
+        },
+      };
+    },
+    deleteAccount: ({ cfg, accountId }) => {
+      const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+
+      if (isDefault) {
+        const next = { ...cfg } as ClawdbotConfig;
+        const nextChannels = { ...cfg.channels };
+        delete (nextChannels as Record<string, unknown>).meet;
+        if (Object.keys(nextChannels).length > 0) {
+          next.channels = nextChannels;
+        } else {
+          delete next.channels;
+        }
+        return next;
+      }
+
+      if (isFlatAccountConfig(cfg, accountId)) {
+        const key = getFlatAccountKey(accountId);
+        const next = { ...cfg } as ClawdbotConfig;
+        const nextChannels = { ...cfg.channels };
+        delete (nextChannels as Record<string, unknown>)[key];
+        if (Object.keys(nextChannels).length > 0) {
+          next.channels = nextChannels;
+        } else {
+          delete next.channels;
+        }
+        return next;
+      }
+
+      const meetCfg = cfg.channels?.meet as MeetConfig | undefined;
+      const accounts = { ...meetCfg?.accounts };
+      delete accounts[accountId];
+
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          meet: {
+            ...meetCfg,
+            accounts: Object.keys(accounts).length > 0 ? accounts : undefined,
+          },
+        },
+      };
+    },
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      name: account.name,
+      apiEndpoint: account.apiEndpoint,
+    }),
+    resolveAllowFrom: ({ cfg, accountId }) => {
+      const account = resolveMeetAccount({ cfg, accountId });
+      return (account.config?.allowFrom ?? [])
+        .map((entry) => String(entry).trim())
+        .filter(Boolean);
+    },
+    formatAllowFrom: ({ allowFrom }) =>
+      allowFrom
+        .map((entry) => String(entry).trim())
+        .filter(Boolean)
+        .map((entry) => entry.toLowerCase()),
+  },
+  security: {
+    collectWarnings: ({ cfg, accountId }) => {
+      const account = resolveMeetAccount({ cfg, accountId });
+      const meetCfg = account.config;
+      const defaultGroupPolicy = (
+        cfg.channels as Record<string, { groupPolicy?: string }> | undefined
+      )?.defaults?.groupPolicy;
+      const groupPolicy =
+        meetCfg?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+      if (groupPolicy !== "open") return [];
+      return [
+        `- Meet[${account.accountId}] groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.meet.groupPolicy="allowlist" + channels.meet.groupAllowFrom to restrict senders.`,
+      ];
+    },
+  },
+  setup: {
+    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+    applyAccountConfig: ({ cfg, accountId }) => {
+      const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+
+      if (isDefault) {
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            meet: {
+              ...cfg.channels?.meet,
+              enabled: true,
+            },
+          },
+        };
+      }
+
+      if (isFlatAccountConfig(cfg, accountId)) {
+        const key = getFlatAccountKey(accountId);
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            [key]: {
+              ...(cfg.channels?.[key] as Record<string, unknown> | undefined),
+              enabled: true,
+            },
+          },
+        };
+      }
+
+      const meetCfg = cfg.channels?.meet as MeetConfig | undefined;
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          meet: {
+            ...meetCfg,
+            accounts: {
+              ...meetCfg?.accounts,
+              [accountId]: {
+                ...meetCfg?.accounts?.[accountId],
+                enabled: true,
+              },
+            },
+          },
+        },
+      };
+    },
+  },
+  messaging: {
+    normalizeTarget: (raw: string) => {
+      const target = parseMeetTarget(raw);
+      return target ? formatMeetTarget(target) : raw;
+    },
+    targetResolver: {
+      looksLikeId: looksLikeMeetId,
+      hint: "<userId|user:<id>|channel:<id>>",
+    },
+  },
+  directory: {
+    self: async () => null,
+    listPeers: async () => [],
+    listGroups: async () => [],
+    listPeersLive: async () => [],
+    listGroupsLive: async () => [],
+  },
+  outbound: meetOutbound,
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+      port: null,
+    },
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      lastStartAt: snapshot.lastStartAt ?? null,
+      lastStopAt: snapshot.lastStopAt ?? null,
+      lastError: snapshot.lastError ?? null,
+      port: snapshot.port ?? null,
+      probe: snapshot.probe,
+      lastProbeAt: snapshot.lastProbeAt ?? null,
+    }),
+    probeAccount: async ({ account }) => {
+      return await probeMeet(account);
+    },
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      name: account.name,
+      apiEndpoint: account.apiEndpoint,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      port: runtime?.port ?? null,
+      probe,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { monitorMeetProvider } = await import("./monitor.js");
+      const account = resolveMeetAccount({
+        cfg: ctx.cfg,
+        accountId: ctx.accountId,
+      });
+      ctx.log?.info(`[${ctx.accountId}] starting`);
+      return monitorMeetProvider({
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        accountId: ctx.accountId,
+      });
+    },
+  },
+};

package/src/client.ts

@@ -0,0 +1,63 @@
+import { MeetBot, POLLING } from "@meet-im/meet-bot-jssdk"
+import type { PollingOptions } from "@meet-im/meet-bot-jssdk"
+import type { ResolvedMeetAccount } from "./types.js"
+
+const botInstances = new Map<string, MeetBot>()
+
+export function createMeetClient(account: ResolvedMeetAccount): MeetBot {
+  const existing = botInstances.get(account.accountId)
+  if (existing) {
+    return existing
+  }
+
+  if (!account.apiToken) {
+    throw new Error(`Meet account "${account.accountId}" missing apiToken`)
+  }
+
+  const pollTimeoutMs = account.config.pollTimeout ?? 30000
+  const pollTimeoutSec = Math.floor(pollTimeoutMs / 1000)
+
+  const logLevel = account.config.logLevel ?? "silent"
+
+  const bot = new MeetBot({
+    token: account.apiToken,
+    baseUrl: account.apiEndpoint,
+    pollingLimit: account.config.pollLimit ?? POLLING.DEFAULT_LIMIT,
+    longPollingTimeout: pollTimeoutSec,
+    logLevel,
+    useV2: true,
+  })
+
+  botInstances.set(account.accountId, bot)
+  return bot
+}
+
+export function getPollingOptions(account: ResolvedMeetAccount): PollingOptions {
+  const pollTimeoutMs = account.config.pollTimeout ?? 30000
+  const pollTimeoutSec = Math.floor(pollTimeoutMs / 1000)
+
+  return {
+    timeout: pollTimeoutSec,
+    limit: account.config.pollLimit ?? POLLING.DEFAULT_LIMIT,
+    retryDelay: POLLING.DEFAULT_RETRY_DELAY,
+    maxRetries: 0,
+  }
+}
+
+export function getMeetClient(accountId: string): MeetBot | undefined {
+  return botInstances.get(accountId)
+}
+
+export function closeMeetClient(accountId: string): void {
+  const bot = botInstances.get(accountId)
+  if (bot) {
+    bot.stopPolling()
+    botInstances.delete(accountId)
+  }
+}
+
+export function closeAllMeetClients(): void {
+  for (const [accountId] of botInstances) {
+    closeMeetClient(accountId)
+  }
+}

package/src/config-schema.ts

@@ -0,0 +1,49 @@
+import { z } from "zod"
+
+export const MeetChannelConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  systemPrompt: z.string().optional(),
+  requireMention: z.boolean().optional(),
+})
+
+export const MeetGroupConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  name: z.string().optional(),
+  requireMention: z.boolean().optional(),
+  systemPrompt: z.string().optional(),
+  users: z.array(z.union([z.string(), z.number()])).optional(),
+})
+
+export const MeetAccountConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  name: z.string().optional(),
+  apiEndpoint: z.string().optional(),
+  token: z.string().optional(),
+  apiToken: z.string().optional(),
+  pollTimeout: z.number().min(1000).max(300000).optional(),
+  pollLimit: z.number().min(1).max(1000).optional(),
+  logLevel: z.enum(["silent", "info"]).optional(),
+})
+
+export const MeetConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  apiEndpoint: z.string().optional(),
+  token: z.string().optional(),
+  apiToken: z.string().optional(),
+  pollTimeout: z.number().min(1000).max(300000).optional().default(30000),
+  pollLimit: z.number().min(1).max(1000).optional().default(100),
+  logLevel: z.enum(["silent", "info"]).optional(),
+  dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional().default("pairing"),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional().default("allowlist"),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groups: z.record(z.string(), MeetGroupConfigSchema).optional(),
+  requireMention: z.boolean().optional().default(true),
+  systemPrompt: z.string().optional(),
+  channels: z.record(z.string(), MeetChannelConfigSchema).optional(),
+  historyLimit: z.number().min(0).optional(),
+  dmHistoryLimit: z.number().min(0).optional(),
+  textChunkLimit: z.number().min(1).optional(),
+  mediaMaxMb: z.number().min(0).optional().default(30),
+  accounts: z.record(z.string(), MeetAccountConfigSchema).optional(),
+})

package/src/media.ts

@@ -0,0 +1,198 @@
+import type { MeetMediaAttachment } from "./types.js"
+import { getMeetClient } from "./client.js"
+import { getMeetRuntime } from "./runtime.js"
+
+let _debugLog: ((msg: string) => void) | null = null
+let _debugError: ((msg: string) => void) | null = null
+
+export function setMediaDebugLogger(log: (msg: string) => void, error: (msg: string) => void): void {
+  _debugLog = log
+  _debugError = error
+}
+
+function log(msg: string): void {
+  if (_debugLog) _debugLog(msg)
+}
+
+function logError(msg: string): void {
+  if (_debugError) _debugError(msg)
+}
+
+/**
+ * 获取文件下载 URL
+ */
+export async function getFileAccessUrl(params: {
+  accountId: string
+  sessionInfo: {
+    firstId: number
+    secondId: number
+    sessionType: number
+    companyId?: number
+  }
+  seqId: number
+  fileId: string | number
+  ossProcess?: string
+}): Promise<string | null> {
+  const { accountId, sessionInfo, seqId, fileId, ossProcess } = params
+  const bot = getMeetClient(accountId)
+  if (!bot) {
+    logError(`[meet] getFileAccessUrl: bot client not found for account=${accountId}`)
+    return null
+  }
+
+  try {
+    log(`[meet] getFileAccessUrl: calling getAccessURL fileId=${fileId} seqId=${seqId} companyId=${sessionInfo.companyId}`)
+    const result = await bot.getAccessURL({
+      firstId: sessionInfo.firstId,
+      secondId: sessionInfo.secondId,
+      sessionType: sessionInfo.sessionType,
+      seqId,
+      fileId: Number(fileId),
+      companyId: sessionInfo.companyId,
+      "x-oss-process": ossProcess,
+    })
+    log(`[meet] getFileAccessUrl: got URL ${result.fileUrl?.slice(0, 80)}...`)
+    return result.fileUrl
+  } catch (err) {
+    logError(`[meet] getFileAccessUrl: getAccessURL failed: ${String(err)}`)
+    return null
+  }
+}
+
+/**
+ * 媒体信息（下载并保存后的结果）
+ */
+export type ResolvedMedia = {
+  path: string
+  contentType?: string
+  placeholder: string
+  url?: string
+}
+
+/**
+ * 下载媒体文件到本地 media store
+ * 与 Discord 保持一致的处理流程
+ */
+export async function downloadAndSaveMedia(params: {
+  accountId: string
+  attachment: MeetMediaAttachment
+  sessionInfo: {
+    firstId: number
+    secondId: number
+    sessionType: number
+    companyId?: number
+  }
+  seqId: number
+  maxBytes?: number
+}): Promise<ResolvedMedia | null> {
+  const { accountId, attachment, sessionInfo, seqId, maxBytes } = params
+  const runtime = getMeetRuntime()
+
+  log(`[meet] downloadAndSaveMedia: fileId=${attachment.fileId} fileName=${attachment.fileName} fileUrl=${attachment.fileUrl?.slice(0, 60)}...`)
+
+  // 确定下载 URL
+  let url: string
+  // fileUrl 可能是完整 URL 或相对路径，只有完整 URL 才能直接使用
+  if (attachment.fileUrl && /^https?:\/\//i.test(attachment.fileUrl)) {
+    url = attachment.fileUrl
+    log(`[meet] downloadAndSaveMedia: using complete fileUrl`)
+  } else {
+    log(`[meet] downloadAndSaveMedia: fileUrl is not complete URL, calling getFileAccessUrl`)
+    const accessUrl = await getFileAccessUrl({
+      accountId,
+      sessionInfo,
+      seqId,
+      fileId: attachment.fileId,
+    })
+    if (!accessUrl) {
+      logError(`[meet] downloadAndSaveMedia: getFileAccessUrl returned null`)
+      return null
+    }
+    url = accessUrl
+  }
+
+  try {
+    // 下载媒体
+    log(`[meet] downloadAndSaveMedia: fetching remote media from ${url.slice(0, 80)}...`)
+    const fetched = await runtime.channel.media.fetchRemoteMedia({
+      url,
+      filePathHint: attachment.fileName,
+      maxBytes,
+    })
+    log(`[meet] downloadAndSaveMedia: fetched ${fetched.buffer.length} bytes, contentType=${fetched.contentType}`)
+
+    // 保存到本地 media store
+    const saved = await runtime.channel.media.saveMediaBuffer(
+      fetched.buffer,
+      fetched.contentType,
+      "inbound",
+      maxBytes,
+      attachment.fileName,
+    )
+    log(`[meet] downloadAndSaveMedia: saved to ${saved.path}`)
+
+    const typeLabel = inferMediaType(fetched.contentType)
+
+    return {
+      path: saved.path,
+      contentType: saved.contentType,
+      placeholder: `[${typeLabel}: ${attachment.fileName || "文件"}]`,
+      url,
+    }
+  } catch (err) {
+    logError(`[meet] downloadAndSaveMedia: download/save failed: ${String(err)}`)
+    // 下载失败时，返回 URL 作为 fallback
+    const typeLabel = inferMediaType(attachment.mimeType)
+    return {
+      path: url,
+      contentType: attachment.mimeType,
+      placeholder: `[${typeLabel}: ${attachment.fileName || "文件"}]`,
+      url,
+    }
+  }
+}
+
+/**
+ * 批量处理媒体附件
+ */
+export async function resolveMediaAttachments(params: {
+  accountId: string
+  attachments: MeetMediaAttachment[]
+  sessionInfo: {
+    firstId: number
+    secondId: number
+    sessionType: number
+    companyId?: number
+  }
+  seqId: number
+  maxBytes?: number
+}): Promise<ResolvedMedia[]> {
+  const results: ResolvedMedia[] = []
+
+  for (const attachment of params.attachments) {
+    const resolved = await downloadAndSaveMedia({
+      accountId: params.accountId,
+      attachment,
+      sessionInfo: params.sessionInfo,
+      seqId: params.seqId,
+      maxBytes: params.maxBytes,
+    })
+    if (resolved) {
+      results.push(resolved)
+    }
+  }
+
+  return results
+}
+
+/**
+ * 根据 MIME 类型推断媒体类型标签
+ * 与 Discord 保持一致的格式
+ */
+function inferMediaType(mimeType?: string): string {
+  if (!mimeType) return "<media:document>"
+  if (mimeType.startsWith("image/")) return "<media:image>"
+  if (mimeType.startsWith("video/")) return "<media:video>"
+  if (mimeType.startsWith("audio/")) return "<media:audio>"
+  return "<media:document>"
+}