@meet-im/meet 2.0.5 → 3.0.0-beta.0

package/src/channel.ts

@@ -1,396 +0,0 @@
-import type {
-  ChannelPlugin,
-  ClawdbotConfig,
-} from "openclaw/plugin-sdk";
-import type { GroupToolPolicyConfig } from "openclaw/plugin-sdk/channel-policy";
-import {
-  DEFAULT_ACCOUNT_ID,
-  normalizeAccountId,
-} from "openclaw/plugin-sdk/account-id";
-import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
-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 {
-  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`.",
-      "- Meet media: use `media` parameter to send images/files as attachments. DO NOT use Markdown image syntax like `![](path)` - Meet does not render it.",
-    ],
-  },
-  groups: {
-    resolveToolPolicy: ({
-      cfg: _cfg,
-      accountId: _accountId,
-      groupId: _groupId,
-    }): GroupToolPolicyConfig | undefined => {
-      // 群组访问控制在 bot.ts 中处理，这里只返回工具策略配置
-      // 不使用 { deny: ["*"] } 拒绝所有工具，否则会导致 tools: []
-      return undefined
-    },
-  },
-  reload: { configPrefixes: ["channels.meet"] },
-  configSchema: {
-    schema: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        enabled: { type: "boolean" },
-        defaultAccount: { type: "string" },
-        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");
-      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

@@ -1,63 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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(),
-  defaultAccount: z.string().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

@@ -1,198 +0,0 @@
-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>"
-}