@invago/mixin 1.0.7

package/src/inbound-handler.ts

@@ -0,0 +1,336 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getMixinRuntime } from "./runtime.js";
+import {
+  getOutboxStatus,
+  purgePermanentInvalidOutboxEntries,
+  sendButtonGroupMessage,
+  sendCardMessage,
+  sendPostMessage,
+  sendTextMessage,
+} from "./send-service.js";
+import { getAccountConfig } from "./config.js";
+import type { MixinAccountConfig } from "./config-schema.js";
+
+import { decryptMixinMessage } from "./crypto.js";
+import { buildMixinReplyPlan } from "./reply-format.js";
+
+export interface MixinInboundMessage {
+  conversationId: string;
+  userId: string;
+  messageId: string;
+  category: string;
+  data: string;
+  createdAt: string;
+  publicKey?: string;
+}
+
+const processedMessages = new Set<string>();
+const MAX_DEDUP_SIZE = 2000;
+const unauthNotifiedUsers = new Map<string, number>();
+const UNAUTH_NOTIFY_INTERVAL = 20 * 60 * 1000;
+const MAX_UNAUTH_NOTIFY_USERS = 1000;
+
+function isProcessed(messageId: string): boolean {
+  return processedMessages.has(messageId);
+}
+
+function markProcessed(messageId: string): void {
+  if (processedMessages.size >= MAX_DEDUP_SIZE) {
+    const first = processedMessages.values().next().value;
+    if (first) processedMessages.delete(first);
+  }
+  processedMessages.add(messageId);
+}
+
+function pruneUnauthNotifiedUsers(now: number): void {
+  for (const [userId, lastNotified] of unauthNotifiedUsers) {
+    if (now - lastNotified > UNAUTH_NOTIFY_INTERVAL) {
+      unauthNotifiedUsers.delete(userId);
+    }
+  }
+
+  while (unauthNotifiedUsers.size >= MAX_UNAUTH_NOTIFY_USERS) {
+    const first = unauthNotifiedUsers.keys().next().value;
+    if (!first) {
+      break;
+    }
+    unauthNotifiedUsers.delete(first);
+  }
+}
+
+function decodeContent(category: string, data: string): string {
+  if (category.startsWith("PLAIN_TEXT") || category.startsWith("PLAIN_POST")) {
+    try {
+      return Buffer.from(data, "base64").toString("utf-8");
+    } catch {
+      return data;
+    }
+  }
+  return `[${category}]`;
+}
+
+function shouldPassGroupFilter(config: MixinAccountConfig, text: string): boolean {
+  if (!config.requireMentionInGroup) return true;
+  const lower = text.toLowerCase();
+  return (
+    lower.includes("?") ||
+    lower.includes("？") ||
+    /帮|请|分析|总结|help/i.test(lower)
+  );
+}
+
+function isOutboxCommand(text: string): boolean {
+  return text.trim().toLowerCase().startsWith("/mixin-outbox");
+}
+
+function isOutboxPurgeInvalidCommand(text: string): boolean {
+  return text.trim().toLowerCase() === "/mixin-outbox purge-invalid";
+}
+
+function formatOutboxStatus(status: Awaited<ReturnType<typeof getOutboxStatus>>): string {
+  const lines = [
+    `Outbox pending: ${status.totalPending}`,
+    `Oldest pending: ${status.oldestPendingAt ?? "N/A"}`,
+    `Next attempt: ${status.nextAttemptAt ?? "N/A"}`,
+    `Latest error: ${status.latestError ?? "N/A"}`,
+  ];
+
+  if (status.pendingByAccount.length > 0) {
+    lines.push("By account:");
+    for (const item of status.pendingByAccount) {
+      lines.push(`- ${item.accountId}: ${item.pending}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+async function deliverMixinReply(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  conversationId: string;
+  recipientId?: string;
+  text: string;
+  log: { info: (m: string) => void; warn: (m: string) => void; error: (m: string, e?: unknown) => void };
+}): Promise<void> {
+  const { cfg, accountId, conversationId, recipientId, text, log } = params;
+  const plan = buildMixinReplyPlan(text);
+
+  if (!plan) {
+    return;
+  }
+
+  if (plan.kind === "text") {
+    await sendTextMessage(cfg, accountId, conversationId, recipientId, plan.text, log);
+    return;
+  }
+
+  if (plan.kind === "post") {
+    await sendPostMessage(cfg, accountId, conversationId, recipientId, plan.text, log);
+    return;
+  }
+
+  if (plan.kind === "buttons") {
+    if (plan.intro) {
+      await sendTextMessage(cfg, accountId, conversationId, recipientId, plan.intro, log);
+    }
+    await sendButtonGroupMessage(cfg, accountId, conversationId, recipientId, plan.buttons, log);
+    return;
+  }
+
+  await sendCardMessage(cfg, accountId, conversationId, recipientId, plan.card, log);
+}
+
+export async function handleMixinMessage(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  msg: MixinInboundMessage;
+  isDirect: boolean;
+  log: { info: (m: string) => void; warn: (m: string) => void; error: (m: string, e?: unknown) => void };
+}): Promise<void> {
+  const { cfg, accountId, msg, isDirect, log } = params;
+  const rt = getMixinRuntime();
+
+// 立即检查是否已处理，防止并发
+   if (isProcessed(msg.messageId)) return;
+
+   const config = getAccountConfig(cfg, accountId);
+   
+   // 处理加密消息
+   if (msg.category === "ENCRYPTED_TEXT" || msg.category === "ENCRYPTED_POST") {
+     log.info(`[mixin] decrypting encrypted message ${msg.messageId}, category=${msg.category}`);
+     try {
+       const decrypted = decryptMixinMessage(
+         msg.data,
+         config.sessionPrivateKey!,
+         config.sessionId!
+       );
+        if (decrypted) {
+          log.info(`[mixin] decryption successful: messageId=${msg.messageId}, length=${decrypted.length}`);
+          msg.data = Buffer.from(decrypted).toString("base64");
+          msg.category = "PLAIN_TEXT";
+       } else {
+         log.error(`[mixin] decryption failed for ${msg.messageId}`);
+         markProcessed(msg.messageId);
+         return;
+       }
+     } catch (err) {
+       log.error(`[mixin] decryption exception for ${msg.messageId}`, err);
+       markProcessed(msg.messageId);
+       return;
+     }
+   }
+
+   // 检查是否是文本消息
+   if (!msg.category.startsWith("PLAIN_TEXT") && !msg.category.startsWith("PLAIN_POST")) {
+     log.info(`[mixin] skip non-text message: ${msg.category}`);
+     return;
+   }
+
+   const text = decodeContent(msg.category, msg.data).trim();
+   log.info(`[mixin] decoded text: messageId=${msg.messageId}, category=${msg.category}, length=${text.length}`);
+
+  if (!text) return;
+
+  // 群组消息过滤：只有包含关键词的消息才会被处理
+  if (!isDirect && !shouldPassGroupFilter(config, text)) {
+    log.info(`[mixin] group message filtered: ${msg.messageId}`);
+    return;
+  }
+
+// allowlist 检查：只处理白名单中的用户
+if (!config.allowFrom.includes(msg.userId)) {
+       log.warn(`[mixin] user ${msg.userId} not in allowlist`);
+       markProcessed(msg.messageId);
+       
+       // 只在首次消息时回复，20分钟内不重复回复
+       const now = Date.now();
+       const lastNotified = unauthNotifiedUsers.get(msg.userId) ?? 0;
+       
+        if (lastNotified === 0 || now - lastNotified > UNAUTH_NOTIFY_INTERVAL) {
+          pruneUnauthNotifiedUsers(now);
+          unauthNotifiedUsers.set(msg.userId, now);
+         const msgBody = `⚠️ 请等待管理员认证\n\n您的 Mixin UUID: ${msg.userId}\n\n请将此UUID添加到 allowFrom 列表中完成认证`;
+          sendTextMessage(cfg, accountId, msg.conversationId, msg.userId, msgBody, log).catch(() => {});
+       }
+       
+       return;
+     }
+
+  // 标记为已处理
+  markProcessed(msg.messageId);
+
+  if (isOutboxCommand(text)) {
+    if (isOutboxPurgeInvalidCommand(text)) {
+      const result = await purgePermanentInvalidOutboxEntries();
+      const recipientId = isDirect ? msg.userId : undefined;
+      const replyText = result.removed > 0
+        ? `Removed ${result.removed} invalid outbox entr${result.removed === 1 ? "y" : "ies"}.\n${result.removedJobIds.map((jobId) => `- ${jobId}`).join("\n")}`
+        : "No invalid outbox entries found.";
+      await sendTextMessage(cfg, accountId, msg.conversationId, recipientId, replyText, log);
+      return;
+    }
+
+    const status = await getOutboxStatus();
+    const replyText = formatOutboxStatus(status);
+    const recipientId = isDirect ? msg.userId : undefined;
+    await sendTextMessage(cfg, accountId, msg.conversationId, recipientId, replyText, log);
+    return;
+  }
+
+   // 解析消息路由
+   const peerId = isDirect ? msg.userId : msg.conversationId;
+   log.info(`[mixin] resolving route: channel=mixin, accountId=${accountId}, peer.kind=${isDirect ? "direct" : "group"}, peer.id=${peerId}`);
+   
+   const route = rt.channel.routing.resolveAgentRoute({
+     cfg,
+     channel: "mixin",
+     accountId,
+     peer: {
+       kind: isDirect ? "direct" : "group",
+       id: peerId,
+     },
+   });
+   
+   log.info(`[mixin] route result: ${route ? "FOUND" : "NULL"} - agentId=${route?.agentId ?? "N/A"}`);
+
+   if (!route) {
+     log.warn(`[mixin] no agent route for ${msg.userId} (peerId: ${peerId})`);
+     return;
+   }
+
+   // 创建上下文
+   const shouldComputeCommandAuthorized = rt.channel.commands.shouldComputeCommandAuthorized(
+     text,
+     cfg,
+   );
+
+   const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+   const commandAllowFrom = config.allowFrom;
+
+   const senderAllowedForCommands = useAccessGroups
+     ? config.allowFrom.includes(msg.userId)
+     : true;
+
+   const commandAuthorized = shouldComputeCommandAuthorized
+     ? rt.channel.commands.resolveCommandAuthorizedFromAuthorizers({
+         useAccessGroups,
+         authorizers: [
+           {
+             configured: commandAllowFrom.length > 0,
+             allowed: senderAllowedForCommands,
+           },
+         ],
+       })
+     : undefined;
+
+   const ctx = rt.channel.reply.finalizeInboundContext({
+     Body: text,
+     RawBody: text,
+     CommandBody: text,
+     From: isDirect ? msg.userId : msg.conversationId,
+     SessionKey: route.sessionKey,
+     AccountId: accountId,
+     ChatType: isDirect ? "direct" : "group",
+     Provider: "mixin",
+     Surface: "mixin",
+     MessageSid: msg.messageId,
+     CommandAuthorized: commandAuthorized,
+   });
+
+    // 记录会话
+    const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
+      agentId: route.agentId,
+    });
+    await rt.channel.session.recordInboundSession({
+      storePath,
+     sessionKey: route.sessionKey,
+     ctx,
+     onRecordError: (err: unknown) => {
+       log.error("[mixin] session record error", err);
+     },
+   });
+
+  // 分发消息
+  log.info(`[mixin] dispatching ${msg.messageId} from ${msg.userId}`);
+
+  await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx,
+    cfg,
+    dispatcherOptions: {
+       deliver: async (payload) => {
+         const replyText = payload.text ?? "";
+         if (!replyText) return;
+         const recipientId = isDirect ? msg.userId : undefined;
+         await deliverMixinReply({
+           cfg,
+           accountId,
+           conversationId: msg.conversationId,
+           recipientId,
+           text: replyText,
+           log,
+         });
+       },
+    },
+  });
+}

package/src/proxy.ts

@@ -0,0 +1,42 @@
+import type { RequestConfig } from "@mixin.dev/mixin-node-sdk";
+import { ProxyAgent } from "proxy-agent";
+import type { Agent } from "http";
+import type { MixinProxyConfig } from "./config-schema.js";
+
+export function buildProxyUrl(proxy?: MixinProxyConfig): string | undefined {
+  if (!proxy?.enabled || !proxy.url) {
+    return undefined;
+  }
+
+  const url = new URL(proxy.url);
+  if (proxy.username) {
+    url.username = proxy.username;
+  }
+  if (proxy.password) {
+    url.password = proxy.password;
+  }
+  return url.toString();
+}
+
+export function createProxyAgent(proxy?: MixinProxyConfig): Agent | undefined {
+  const proxyUrl = buildProxyUrl(proxy);
+  if (!proxyUrl) {
+    return undefined;
+  }
+  return new ProxyAgent({
+    getProxyForUrl: () => proxyUrl,
+  }) as Agent;
+}
+
+export function buildRequestConfig(proxy?: MixinProxyConfig): RequestConfig | undefined {
+  const agent = createProxyAgent(proxy);
+  if (!agent) {
+    return undefined;
+  }
+
+  return {
+    proxy: false,
+    httpAgent: agent,
+    httpsAgent: agent,
+  };
+}

package/src/reply-format.ts

@@ -0,0 +1,281 @@
+import type { MixinButton, MixinCard } from "./send-service.js";
+
+type LinkItem = {
+  label: string;
+  url: string;
+};
+
+export type MixinReplyPlan =
+  | { kind: "text"; text: string }
+  | { kind: "post"; text: string }
+  | { kind: "buttons"; intro?: string; buttons: MixinButton[] }
+  | { kind: "card"; card: MixinCard };
+
+const MAX_BUTTONS = 6;
+const MAX_BUTTON_LABEL = 36;
+const MAX_CARD_TITLE = 36;
+const MAX_CARD_DESCRIPTION = 120;
+const TEMPLATE_REGEX = /^```mixin-(text|post|buttons|card)\s*\n([\s\S]*?)\n```$/i;
+
+function truncate(value: string, limit: number): string {
+  return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 3))}...`;
+}
+
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n").trim();
+}
+
+function isValidHttpUrl(value: string | undefined): value is string {
+  if (!value) {
+    return false;
+  }
+
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function parseJsonTemplate<T>(body: string): T | null {
+  try {
+    return JSON.parse(body) as T;
+  } catch {
+    return null;
+  }
+}
+
+function parseTextTemplate(body: string): MixinReplyPlan | null {
+  const text = normalizeWhitespace(body);
+  return text ? { kind: "text", text } : null;
+}
+
+function parsePostTemplate(body: string): MixinReplyPlan | null {
+  const text = normalizeWhitespace(body);
+  return text ? { kind: "post", text } : null;
+}
+
+function parseButtonsTemplate(body: string): MixinReplyPlan | null {
+  const parsed = parseJsonTemplate<{ intro?: string; buttons?: MixinButton[] } | MixinButton[]>(body);
+  if (!parsed) {
+    return null;
+  }
+
+  const intro = Array.isArray(parsed) ? undefined : typeof parsed.intro === "string" ? normalizeWhitespace(parsed.intro) : undefined;
+  const buttons = (Array.isArray(parsed) ? parsed : parsed.buttons ?? [])
+    .filter((button) => typeof button?.label === "string" && isValidHttpUrl(button?.action))
+    .slice(0, MAX_BUTTONS)
+    .map((button) => ({
+      label: truncate(normalizeWhitespace(button.label), MAX_BUTTON_LABEL),
+      color: button.color,
+      action: button.action,
+    }));
+
+  if (buttons.length === 0) {
+    return null;
+  }
+
+  return { kind: "buttons", intro: intro || undefined, buttons };
+}
+
+function parseCardTemplate(body: string): MixinReplyPlan | null {
+  const parsed = parseJsonTemplate<MixinCard>(body);
+  if (!parsed) {
+    return null;
+  }
+
+  const title = typeof parsed.title === "string" ? truncate(normalizeWhitespace(parsed.title), MAX_CARD_TITLE) : "";
+  const description = typeof parsed.description === "string"
+    ? truncate(normalizeWhitespace(parsed.description), MAX_CARD_DESCRIPTION)
+    : "";
+  const action = isValidHttpUrl(parsed.action) ? parsed.action : undefined;
+  const actions = Array.isArray(parsed.actions)
+    ? parsed.actions
+      .filter((button) => typeof button?.label === "string" && isValidHttpUrl(button?.action))
+      .slice(0, MAX_BUTTONS)
+      .map((button) => ({
+        label: truncate(normalizeWhitespace(button.label), MAX_BUTTON_LABEL),
+        color: button.color,
+        action: button.action,
+      }))
+    : undefined;
+  const coverUrl = isValidHttpUrl(parsed.coverUrl) ? parsed.coverUrl : undefined;
+  const iconUrl = isValidHttpUrl(parsed.iconUrl) ? parsed.iconUrl : undefined;
+
+  if (!title || !description) {
+    return null;
+  }
+
+  return {
+    kind: "card",
+    card: {
+      title,
+      description,
+      action,
+      actions,
+      coverUrl,
+      iconUrl,
+      shareable: parsed.shareable,
+    },
+  };
+}
+
+function parseExplicitTemplate(text: string): MixinReplyPlan | null {
+  const match = text.match(TEMPLATE_REGEX);
+  if (!match) {
+    return null;
+  }
+
+  const templateType = (match[1] ?? "").toLowerCase();
+  const body = match[2] ?? "";
+
+  if (templateType === "text") {
+    return parseTextTemplate(body);
+  }
+
+  if (templateType === "post") {
+    return parsePostTemplate(body);
+  }
+
+  if (templateType === "buttons") {
+    return parseButtonsTemplate(body);
+  }
+
+  if (templateType === "card") {
+    return parseCardTemplate(body);
+  }
+
+  return null;
+}
+
+function toPlainText(text: string): string {
+  return normalizeWhitespace(
+    text
+      .replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "$1: $2")
+      .replace(/!\[([^\]]*)\]\((https?:\/\/[^)\s]+)\)/g, "$1")
+      .replace(/`{1,3}([^`]+)`{1,3}/g, "$1")
+      .replace(/^#{1,6}\s+/gm, "")
+      .replace(/^\s*[-*+]\s+/gm, "- "),
+  );
+}
+
+function extractLinks(text: string): LinkItem[] {
+  const links: LinkItem[] = [];
+  const seen = new Set<string>();
+  const markdownRegex = /\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g;
+  const plainUrlRegex = /(^|[\s(])(https?:\/\/[^\s)]+)/g;
+
+  for (const match of text.matchAll(markdownRegex)) {
+    const label = normalizeWhitespace(match[1] ?? "");
+    const url = match[2] ?? "";
+    if (!label || !url || seen.has(url)) {
+      continue;
+    }
+    seen.add(url);
+    links.push({ label, url });
+  }
+
+  for (const match of text.matchAll(plainUrlRegex)) {
+    const url = match[2] ?? "";
+    if (!url || seen.has(url)) {
+      continue;
+    }
+    seen.add(url);
+    try {
+      const parsed = new URL(url);
+      links.push({ label: parsed.hostname, url });
+    } catch {
+      continue;
+    }
+  }
+
+  return links;
+}
+
+function buildButtons(links: LinkItem[]): MixinButton[] {
+  return links.slice(0, MAX_BUTTONS).map((link, index) => ({
+    label: truncate(link.label || `Link ${index + 1}`, MAX_BUTTON_LABEL),
+    color: index === 0 ? "#0A84FF" : undefined,
+    action: link.url,
+  }));
+}
+
+function detectTitle(text: string, fallback: string): string {
+  const lines = normalizeWhitespace(text).split("\n").map((line) => line.trim()).filter(Boolean);
+  const candidate = lines[0]?.replace(/^#{1,6}\s+/, "") ?? fallback;
+  return truncate(candidate, MAX_CARD_TITLE);
+}
+
+function detectCardDescription(text: string, title: string): string {
+  const plain = toPlainText(text)
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => line !== title);
+  return truncate(plain.join(" "), MAX_CARD_DESCRIPTION);
+}
+
+function isLongStructuredText(text: string): boolean {
+  const normalized = normalizeWhitespace(text);
+  const lines = normalized.split("\n").filter((line) => line.trim().length > 0);
+  const hasCodeBlock = /```[\s\S]*?```/.test(normalized);
+  const hasMarkdownTable =
+    /^\|.+\|$/m.test(normalized) ||
+    /^\s*\|?[-: ]+\|[-|: ]+\|/m.test(normalized);
+
+  return (
+    hasCodeBlock ||
+    hasMarkdownTable ||
+    normalized.length > 420 ||
+    lines.length > 8 ||
+    /^#{1,6}\s/m.test(normalized) ||
+    /^\s*[-*+]\s/m.test(normalized) ||
+    /^\d+\.\s/m.test(normalized)
+  );
+}
+
+export function buildMixinReplyPlan(text: string): MixinReplyPlan | null {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return null;
+  }
+
+  const explicit = parseExplicitTemplate(normalized);
+  if (explicit) {
+    return explicit;
+  }
+
+  const links = extractLinks(normalized);
+
+  if (isLongStructuredText(normalized)) {
+    return { kind: "post", text: normalized };
+  }
+
+  if (links.length >= 2 && links.length <= MAX_BUTTONS) {
+    const intro = toPlainText(
+      normalized.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "").replace(/https?:\/\/[^\s)]+/g, ""),
+    );
+    return {
+      kind: "buttons",
+      intro: intro || undefined,
+      buttons: buildButtons(links),
+    };
+  }
+
+  if (links.length === 1) {
+    const title = detectTitle(normalized, links[0].label);
+    const description = detectCardDescription(normalized, title) || truncate(links[0].url, MAX_CARD_DESCRIPTION);
+    return {
+      kind: "card",
+      card: {
+        title,
+        description,
+        action: links[0].url,
+        shareable: true,
+      },
+    };
+  }
+
+  return { kind: "text", text: toPlainText(normalized) };
+}

package/src/runtime.ts

@@ -0,0 +1,12 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setMixinRuntime(next: PluginRuntime): void {
+  runtime = next;
+}
+
+export function getMixinRuntime(): PluginRuntime {
+  if (!runtime) throw new Error("Mixin runtime not initialized");
+  return runtime;
+}