@invago/mixin 1.0.8 → 1.0.10

package/src/reply-format.ts

@@ -1,3 +1,4 @@
+import type { MixinCollectRequest } from "./mixpay-worker.js";
 import type { MixinAudio, MixinButton, MixinCard, MixinFile } from "./send-service.js";
 
 type LinkItem = {
@@ -10,14 +11,19 @@ export type MixinReplyPlan =
   | { kind: "post"; text: string }
   | { kind: "file"; file: MixinFile }
   | { kind: "audio"; audio: MixinAudio }
+  | { kind: "collect"; collect: MixinCollectRequest }
   | { kind: "buttons"; intro?: string; buttons: MixinButton[] }
   | { kind: "card"; card: MixinCard };
 
+export type MixinReplyPlanResolution =
+  | { matchedTemplate: false; plan: MixinReplyPlan | null }
+  | { matchedTemplate: true; plan: MixinReplyPlan | null; error?: string };
+
 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|file|audio)\s*\n([\s\S]*?)\n```$/i;
+const TEMPLATE_REGEX = /^```mixin-(text|post|buttons|card|file|audio|collect)\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))}...`;
@@ -166,40 +172,89 @@ function parseAudioTemplate(body: string): MixinReplyPlan | null {
   };
 }
 
-function parseExplicitTemplate(text: string): MixinReplyPlan | null {
+function parseCollectTemplate(body: string): MixinReplyPlan | null {
+  const parsed = parseJsonTemplate<{
+    amount?: unknown;
+    assetId?: unknown;
+    quoteAssetId?: unknown;
+    settlementAssetId?: unknown;
+    memo?: unknown;
+    orderId?: unknown;
+    expireMinutes?: unknown;
+  }>(body);
+  if (!parsed) {
+    return null;
+  }
+
+  const amount = typeof parsed.amount === "string"
+    ? normalizeWhitespace(parsed.amount)
+    : typeof parsed.amount === "number"
+      ? String(parsed.amount)
+      : "";
+  const assetId = typeof parsed.assetId === "string"
+    ? normalizeWhitespace(parsed.assetId)
+    : typeof parsed.quoteAssetId === "string"
+      ? normalizeWhitespace(parsed.quoteAssetId)
+      : "";
+  if (!amount) {
+    return null;
+  }
+
+  return {
+    kind: "collect",
+    collect: {
+      amount,
+      assetId: assetId || undefined,
+      settlementAssetId: typeof parsed.settlementAssetId === "string"
+        ? normalizeWhitespace(parsed.settlementAssetId)
+        : undefined,
+      memo: typeof parsed.memo === "string" ? normalizeWhitespace(parsed.memo) : undefined,
+      orderId: typeof parsed.orderId === "string" ? normalizeWhitespace(parsed.orderId) : undefined,
+      expireMinutes: typeof parsed.expireMinutes === "number" && Number.isFinite(parsed.expireMinutes)
+        ? parsed.expireMinutes
+        : undefined,
+    },
+  };
+}
+
+function parseExplicitTemplate(text: string): MixinReplyPlanResolution {
   const match = text.match(TEMPLATE_REGEX);
   if (!match) {
-    return null;
+    return { matchedTemplate: false, plan: null };
   }
 
   const templateType = (match[1] ?? "").toLowerCase();
   const body = match[2] ?? "";
 
   if (templateType === "text") {
-    return parseTextTemplate(body);
+    return { matchedTemplate: true, plan: parseTextTemplate(body), error: "Invalid mixin-text template body" };
   }
 
   if (templateType === "post") {
-    return parsePostTemplate(body);
+    return { matchedTemplate: true, plan: parsePostTemplate(body), error: "Invalid mixin-post template body" };
   }
 
   if (templateType === "buttons") {
-    return parseButtonsTemplate(body);
+    return { matchedTemplate: true, plan: parseButtonsTemplate(body), error: "Invalid mixin-buttons template JSON" };
   }
 
   if (templateType === "card") {
-    return parseCardTemplate(body);
+    return { matchedTemplate: true, plan: parseCardTemplate(body), error: "Invalid mixin-card template JSON" };
   }
 
   if (templateType === "file") {
-    return parseFileTemplate(body);
+    return { matchedTemplate: true, plan: parseFileTemplate(body), error: "Invalid mixin-file template JSON" };
   }
 
   if (templateType === "audio") {
-    return parseAudioTemplate(body);
+    return { matchedTemplate: true, plan: parseAudioTemplate(body), error: "Invalid mixin-audio template JSON" };
   }
 
-  return null;
+  if (templateType === "collect") {
+    return { matchedTemplate: true, plan: parseCollectTemplate(body), error: "Invalid mixin-collect template JSON" };
+  }
+
+  return { matchedTemplate: true, plan: null, error: "Unknown Mixin template type" };
 }
 
 function toPlainText(text: string): string {
@@ -288,21 +343,21 @@ function isLongStructuredText(text: string): boolean {
   );
 }
 
-export function buildMixinReplyPlan(text: string): MixinReplyPlan | null {
+export function resolveMixinReplyPlan(text: string): MixinReplyPlanResolution {
   const normalized = normalizeWhitespace(text);
   if (!normalized) {
-    return null;
+    return { matchedTemplate: false, plan: null };
   }
 
   const explicit = parseExplicitTemplate(normalized);
-  if (explicit) {
+  if (explicit.matchedTemplate) {
     return explicit;
   }
 
   const links = extractLinks(normalized);
 
   if (isLongStructuredText(normalized)) {
-    return { kind: "post", text: normalized };
+    return { matchedTemplate: false, plan: { kind: "post", text: normalized } };
   }
 
   if (links.length >= 2 && links.length <= MAX_BUTTONS) {
@@ -310,9 +365,12 @@ export function buildMixinReplyPlan(text: string): MixinReplyPlan | null {
       normalized.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "").replace(/https?:\/\/[^\s)]+/g, ""),
     );
     return {
-      kind: "buttons",
-      intro: intro || undefined,
-      buttons: buildButtons(links),
+      matchedTemplate: false,
+      plan: {
+        kind: "buttons",
+        intro: intro || undefined,
+        buttons: buildButtons(links),
+      },
     };
   }
 
@@ -320,15 +378,22 @@ export function buildMixinReplyPlan(text: string): MixinReplyPlan | null {
     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,
+      matchedTemplate: false,
+      plan: {
+        kind: "card",
+        card: {
+          title,
+          description,
+          action: links[0].url,
+          shareable: true,
+        },
       },
     };
   }
 
-  return { kind: "text", text: toPlainText(normalized) };
+  return { matchedTemplate: false, plan: { kind: "text", text: toPlainText(normalized) } };
+}
+
+export function buildMixinReplyPlan(text: string): MixinReplyPlan | null {
+  return resolveMixinReplyPlan(text).plan;
 }

package/src/runtime.ts

@@ -1,6 +1,17 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { MixinSupportedMessageCategory } from "./send-service.js";
 
 let runtime: PluginRuntime | null = null;
+const blazeSenders = new Map<string, MixinBlazeSender>();
+
+export type MixinBlazeOutboundMessage = {
+  conversationId: string;
+  messageId: string;
+  category: MixinSupportedMessageCategory;
+  dataBase64: string;
+};
+
+export type MixinBlazeSender = (message: MixinBlazeOutboundMessage) => Promise<void>;
 
 export function setMixinRuntime(next: PluginRuntime): void {
   runtime = next;
@@ -10,3 +21,18 @@ export function getMixinRuntime(): PluginRuntime {
   if (!runtime) throw new Error("Mixin runtime not initialized");
   return runtime;
 }
+
+export function setMixinBlazeSender(accountId: string, sender: MixinBlazeSender | null): void {
+  if (!accountId.trim()) {
+    return;
+  }
+  if (sender) {
+    blazeSenders.set(accountId, sender);
+    return;
+  }
+  blazeSenders.delete(accountId);
+}
+
+export function getMixinBlazeSender(accountId: string): MixinBlazeSender | null {
+  return blazeSenders.get(accountId) ?? null;
+}

package/src/send-service.ts

@@ -2,12 +2,10 @@ import crypto from "crypto";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
 import os from "os";
 import path from "path";
-import { MixinApi } from "@mixin.dev/mixin-node-sdk";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import type { MixinAccountConfig } from "./config-schema.js";
 import { getAccountConfig } from "./config.js";
-import { buildRequestConfig } from "./proxy.js";
-import { getMixinRuntime } from "./runtime.js";
+import { getMixinBlazeSender, getMixinRuntime } from "./runtime.js";
+import { buildClient, sleep, type SendLog } from "./shared.js";
 
 const BASE_DELAY = 1000;
 const MAX_DELAY = 60_000;
@@ -15,12 +13,6 @@ const MULTIPLIER = 1.5;
 const MAX_ERROR_LENGTH = 500;
 const MAX_OUTBOX_FILE_BYTES = 10 * 1024 * 1024;
 
-type SendLog = {
-  info: (msg: string) => void;
-  error: (msg: string, err?: unknown) => void;
-  warn: (msg: string) => void;
-};
-
 export type MixinSupportedMessageCategory =
   | "PLAIN_TEXT"
   | "PLAIN_POST"
@@ -139,22 +131,6 @@ const state: {
   wakeResolver: null,
 };
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function buildClient(config: MixinAccountConfig) {
-  return MixinApi({
-    keystore: {
-      app_id: config.appId!,
-      session_id: config.sessionId!,
-      server_public_key: config.serverPublicKey!,
-      session_private_key: config.sessionPrivateKey!,
-    },
-    requestConfig: buildRequestConfig(config.proxy),
-  });
-}
-
 function guessMimeType(fileName: string): string {
   const ext = path.extname(fileName).toLowerCase();
   switch (ext) {
@@ -230,6 +206,17 @@ function resolveOutboxPaths(): {
   };
 }
 
+export function getOutboxPathsSnapshot(): {
+  outboxDir: string;
+  outboxFile: string;
+} {
+  const { outboxDir, outboxFile } = resolveOutboxPaths();
+  return {
+    outboxDir,
+    outboxFile,
+  };
+}
+
 function normalizeErrorMessage(message: string): string {
   if (message.length <= MAX_ERROR_LENGTH) {
     return message;
@@ -266,7 +253,7 @@ function normalizeEntry(entry: OutboxEntry): OutboxEntry {
   };
 }
 
-function isStructuredBody(body: string): body is string {
+function isStructuredBody(body: string): boolean {
   return body.trim().startsWith("{");
 }
 
@@ -464,6 +451,23 @@ async function attemptSend(entry: OutboxEntry): Promise<void> {
   }
 
   const dataBase64 = Buffer.from(payloadBody).toString("base64");
+  if (!entry.recipientId) {
+    const blazeSender = getMixinBlazeSender(entry.accountId);
+    if (!blazeSender) {
+      throw new Error("group send failed: blaze sender unavailable");
+    }
+    state.log.info(
+      `[mixin] attempt send: transport=blaze, jobId=${entry.jobId}, messageId=${entry.messageId}, conversation=${entry.conversationId}, recipient=none, category=${entry.category}`,
+    );
+    await blazeSender({
+      conversationId: entry.conversationId,
+      messageId: entry.messageId,
+      category: entry.category,
+      dataBase64,
+    });
+    return;
+  }
+
   const messagePayload: {
     conversation_id: string;
     message_id: string;
@@ -481,6 +485,10 @@ async function attemptSend(entry: OutboxEntry): Promise<void> {
     messagePayload.recipient_id = entry.recipientId;
   }
 
+  state.log.info(
+    `[mixin] attempt send: transport=rest, jobId=${entry.jobId}, messageId=${entry.messageId}, conversation=${entry.conversationId}, recipient=${messagePayload.recipient_id ?? "none"}, category=${entry.category}`,
+  );
+
   await client.message.sendOne(messagePayload);
 }
 

package/src/shared.ts

@@ -0,0 +1,25 @@
+import { MixinApi } from "@mixin.dev/mixin-node-sdk";
+import type { MixinAccountConfig } from "./config-schema.js";
+import { buildRequestConfig } from "./proxy.js";
+
+export type SendLog = {
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string, err?: unknown) => void;
+};
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function buildClient(config: MixinAccountConfig) {
+  return MixinApi({
+    keystore: {
+      app_id: config.appId!,
+      session_id: config.sessionId!,
+      server_public_key: config.serverPublicKey!,
+      session_private_key: config.sessionPrivateKey!,
+    },
+    requestConfig: buildRequestConfig(config.proxy),
+  });
+}

package/src/status.ts

@@ -0,0 +1,114 @@
+import { buildBaseAccountStatusSnapshot, buildBaseChannelStatusSummary } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getAccountConfig, resolveDefaultAccountId } from "./config.js";
+import { getOutboxPathsSnapshot, type OutboxStatus } from "./send-service.js";
+import type { getMixpayStatusSnapshot } from "./mixpay-worker.js";
+
+type RuntimeLifecycleSnapshot = {
+  running?: boolean | null;
+  lastStartAt?: number | null;
+  lastStopAt?: number | null;
+  lastError?: string | null;
+  lastInboundAt?: number | null;
+  lastOutboundAt?: number | null;
+};
+
+type MixinChannelStatusSnapshot = {
+  configured?: boolean | null;
+  running?: boolean | null;
+  lastStartAt?: number | null;
+  lastStopAt?: number | null;
+  lastError?: string | null;
+  defaultAccountId?: string | null;
+  outboxDir?: string | null;
+  outboxFile?: string | null;
+  outboxPending?: number | null;
+  mediaMaxMb?: number | null;
+  mixpayPendingOrders?: number | null;
+  mixpayStoreDir?: string | null;
+  mixpayStoreFile?: string | null;
+};
+
+type MixinStatusAccount = {
+  accountId: string;
+  name?: string;
+  enabled?: boolean;
+  configured?: boolean;
+  config: {
+    requireMentionInGroup?: boolean;
+    mediaBypassMentionInGroup?: boolean;
+    mediaMaxMb?: number;
+    audioAutoDetectDuration?: boolean;
+    audioSendAsVoiceByDefault?: boolean;
+    audioRequireFfprobe?: boolean;
+  };
+};
+
+export function resolveMixinStatusSnapshot(
+  cfg: OpenClawConfig,
+  accountId?: string,
+  outboxStatus?: OutboxStatus | null,
+  mixpayStatus?: Awaited<ReturnType<typeof getMixpayStatusSnapshot>> | null,
+): {
+  defaultAccountId: string;
+  outboxDir: string;
+  outboxFile: string;
+  outboxPending: number;
+  mediaMaxMb: number | null;
+  mixpayPendingOrders: number;
+  mixpayStoreDir: string | null;
+  mixpayStoreFile: string | null;
+} {
+  const defaultAccountId = resolveDefaultAccountId(cfg);
+  const resolvedAccountId = accountId ?? defaultAccountId;
+  const accountConfig = getAccountConfig(cfg, resolvedAccountId);
+  const { outboxDir, outboxFile } = getOutboxPathsSnapshot();
+  return {
+    defaultAccountId,
+    outboxDir,
+    outboxFile,
+    outboxPending: outboxStatus?.totalPending ?? 0,
+    mediaMaxMb: accountConfig.mediaMaxMb ?? null,
+    mixpayPendingOrders: mixpayStatus?.pendingOrders ?? 0,
+    mixpayStoreDir: mixpayStatus?.storeDir ?? null,
+    mixpayStoreFile: mixpayStatus?.storeFile ?? null,
+  };
+}
+
+export function buildMixinChannelSummary(params: {
+  snapshot: MixinChannelStatusSnapshot;
+}) {
+  const { snapshot } = params;
+  return {
+    ...buildBaseChannelStatusSummary(snapshot),
+    defaultAccountId: snapshot.defaultAccountId ?? null,
+    outboxDir: snapshot.outboxDir ?? null,
+    outboxFile: snapshot.outboxFile ?? null,
+    outboxPending: snapshot.outboxPending ?? 0,
+    mediaMaxMb: snapshot.mediaMaxMb ?? null,
+    mixpayPendingOrders: snapshot.mixpayPendingOrders ?? 0,
+    mixpayStoreDir: snapshot.mixpayStoreDir ?? null,
+    mixpayStoreFile: snapshot.mixpayStoreFile ?? null,
+  };
+}
+
+export function buildMixinAccountSnapshot(params: {
+  account: MixinStatusAccount;
+  runtime?: RuntimeLifecycleSnapshot | null;
+  probe?: unknown;
+  defaultAccountId?: string | null;
+  outboxPending?: number | null;
+}) {
+  const { account, runtime, probe, defaultAccountId, outboxPending } = params;
+  return {
+    ...buildBaseAccountStatusSnapshot({ account, runtime, probe }),
+    defaultAccountId: defaultAccountId ?? null,
+    outboxPending: outboxPending ?? 0,
+    requireMentionInGroup: account.config.requireMentionInGroup ?? true,
+    mediaBypassMentionInGroup: account.config.mediaBypassMentionInGroup ?? true,
+    mediaMaxMb: account.config.mediaMaxMb ?? null,
+    audioAutoDetectDuration: account.config.audioAutoDetectDuration ?? true,
+    audioSendAsVoiceByDefault: account.config.audioSendAsVoiceByDefault ?? true,
+    audioRequireFfprobe: account.config.audioRequireFfprobe ?? false,
+  };
+}

package/src/decrypt.ts

@@ -1,126 +0,0 @@
-import crypto from 'crypto';
-
-/**
- * 将 Mixin 的 Ed25519 seed 转换为 Curve25519 私钥，并与对端公钥协商出共享密钥
- * @param seedHex 64 字符的 Hex 字符串，对应 session_private_key
- * @param peerPublicKey 32 字节的对端 Curve25519 公钥
- */
-export function x25519KeyAgreement(seedHex: string, peerPublicKey: Buffer): Buffer {
-  // 1. 将 64 字符的 Hex 转换为 32 字节的 seed
-  const seedBytes = Buffer.from(seedHex, 'hex');
-  if (seedBytes.length !== 32) {
-    throw new Error('Invalid Ed25519 seed length, expected 32 bytes.');
-  }
-
-  // 2. SHA-512 散列
-  const hash = crypto.createHash('sha512').update(seedBytes).digest();
-  
-  // 3. 提取前 32 字节并进行 Curve25519 位截断 (Clamping)
-  const privateKeyX25519 = Buffer.from(hash.slice(0, 32));
-  privateKeyX25519[0] &= 248;
-  privateKeyX25519[31] &= 127;
-  privateKeyX25519[31] |= 64;
-
-  const ecdh = crypto.createECDH('x25519');
-  ecdh.setPrivateKey(privateKeyX25519);
-  
-  return ecdh.computeSecret(peerPublicKey);
-}
-
-/**
- * 解密 Mixin ENCRYPTED_TEXT 消息 (对应 Go SDK DecryptMessageData)
- * @param data Base64 编码的加密数据
- * @param sessionId 机器人的 session_id
- * @param privateKey 机器人的 ed25519 私钥（hex 格式，实为 seed）
- * @returns 解密后的明文，失败返回 null
- */
-export function decryptMessageData(
-  data: string,
-  sessionId: string,
-  privateKey: string
-): string | null {
-  try {
-    // 1. Base64 解码，处理可能的 URL-safe Base64
-    let base64 = data.replace(/-/g, '+').replace(/_/g, '/');
-    while (base64.length % 4) {
-      base64 += '=';
-    }
-    const encryptedBytes = Buffer.from(base64, 'base64');
-
-    // 验证最小长度: version(1) + sessionCount(2) + senderPubKey(32) + nonce(12)
-    if (encryptedBytes.length < 1 + 2 + 32 + 12) {
-      console.error('[mixin decrypt] data too short:', encryptedBytes.length);
-      return null;
-    }
-
-    // 解析消息结构
-    const version = encryptedBytes[0];
-    if (version !== 1) {
-      console.error('[mixin decrypt] unsupported version:', version);
-      return null;
-    }
-
-    const sessionCount = encryptedBytes.readUInt16LE(1);
-    let offset = 3;
-
-    // 2. 提取发送者公钥 (已经是 Curve25519)
-    const senderPublicKey = encryptedBytes.slice(offset, offset + 32);
-    offset += 32;
-
-    // 查找匹配的 session
-    const sessionIdBuffer = Buffer.from(sessionId.replace(/-/g, ''), 'hex');
-
-    let sessionData: Buffer | null = null;
-    for (let i = 0; i < sessionCount; i++) {
-      const sessionIdInMsg = encryptedBytes.slice(offset, offset + 16);
-
-      if (sessionIdInMsg.equals(sessionIdBuffer)) {
-        sessionData = encryptedBytes.slice(offset + 16, offset + 64);
-        break; // 暂不中断读取，只取我们自己的 session 块
-      }
-      offset += 64;
-    }
-
-    if (!sessionData) {
-      console.error('[mixin decrypt] session not found');
-      return null;
-    }
-
-    // 3. 计算 Shared Secret
-    const sharedSecret = x25519KeyAgreement(privateKey, senderPublicKey);
-    
-    // 4. 解密 Message Key (AES-256-CBC)
-    // sessionData 的前 16 字节为 IV，后 32 字节为加密后的 key
-    const sessionIv = sessionData.slice(0, 16);
-    const encryptedKey = sessionData.slice(16, 48);
-    
-    const decipherKey = crypto.createDecipheriv('aes-256-cbc', sharedSecret, sessionIv);
-    // Mixin SDK 这里加了 padding 处理。如果后续失败，尝试 decipherKey.setAutoPadding(false);
-    const rawMessageKey = Buffer.concat([decipherKey.update(encryptedKey), decipherKey.final()]);
-    
-    // 取前 16 字节！
-    const messageKey = rawMessageKey.slice(0, 16);
-
-    // 5. 获取 Nonce 和 密文
-    const prefixSize = 3 + 32 + sessionCount * 64;
-    const nonce = encryptedBytes.slice(prefixSize, prefixSize + 12); // 注意这里是 12 字节!!!
-    const encryptedText = encryptedBytes.slice(prefixSize + 12);
-
-    // 6. 解密消息体 (AES-128-GCM)
-    // 对于 GCM，还需要分离出 authentication tag (后 16 字节)
-    const tag = encryptedText.slice(-16);
-    const ciphertext = encryptedText.slice(0, -16);
-
-    const decipherGcm = crypto.createDecipheriv('aes-128-gcm', messageKey, nonce);
-    decipherGcm.setAuthTag(tag);
-    
-    let decryptedText = decipherGcm.update(ciphertext);
-    decryptedText = Buffer.concat([decryptedText, decipherGcm.final()]);
-
-    return decryptedText.toString('utf8');
-
-  } catch (error) {
-    console.error('[mixin decrypt] error:', error);
-    return null;
-  }
-}