@invago/mixin 1.0.8 → 1.0.10

package/package.json

@@ -1 +1,79 @@
-{"name":"@invago/mixin","version":"1.0.8","description":"Mixin Messenger channel plugin for OpenClaw","type":"module","main":"index.ts","scripts":{"dev":"nodemon --exec \"node --import jiti/register index.ts\" --ext ts","lint":"eslint src/**/*.ts index.ts","typecheck":"tsc --noEmit"},"peerDependencies":{"openclaw":">=2026.2.0"},"dependencies":{"@mixin.dev/mixin-node-sdk":"^7.4.1","@noble/curves":"^2.0.1","@noble/hashes":"^2.0.1","axios":"^1.6.0","express":"^5.2.1","proxy-agent":"^6.5.0","ws":"^8.18.3","zod":"^4.3.6"},"devDependencies":{"@eslint/js":"^10.0.1","@types/node":"^20.0.0","eslint":"^10.0.3","globals":"^17.4.0","jiti":"^1.21.0","nodemon":"^3.0.0","typescript":"^5.3.0","typescript-eslint":"^8.56.1"},"keywords":["openclaw","mixin","messenger","plugin","channel"],"author":"invagao","license":"MIT","repository":{"type":"git","url":"git+https://github.com/invago/mixinclaw.git"},"openclaw":{"extensions":["./index.ts"],"channel":{"id":"mixin","label":"Mixin Messenger","selectionLabel":"Mixin Messenger (Blaze WebSocket)","docsPath":"/channels/mixin","order":70,"aliases":["mixin-messenger","mixin"],"quickstartAllowFrom":true},"install":{"npmSpec":"@invago/mixin","localPath":"extensions/mixin"}}}
+{
+  "name": "@invago/mixin",
+  "version": "1.0.10",
+  "description": "Mixin Messenger channel plugin for OpenClaw",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "dev": "nodemon --exec \"node --import jiti/register index.ts\" --ext ts",
+    "lint": "eslint src/**/*.ts index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.2.0"
+  },
+  "dependencies": {
+    "@mixin.dev/mixin-node-sdk": "^7.4.1",
+    "@noble/curves": "^2.0.1",
+    "@noble/hashes": "^2.0.1",
+    "axios": "^1.13.6",
+    "express": "^5.2.1",
+    "jiti": "^1.21.0",
+    "proxy-agent": "^6.5.0",
+    "ws": "^8.18.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^20.0.0",
+    "eslint": "^10.0.3",
+    "globals": "^17.4.0",
+    "nodemon": "^3.0.0",
+    "typescript": "^5.3.0",
+    "typescript-eslint": "^8.56.1"
+  },
+  "keywords": [
+    "openclaw",
+    "mixin",
+    "messenger",
+    "plugin",
+    "channel"
+  ],
+  "author": "invagao",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/invago/mixinclaw.git"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "mixin",
+      "label": "Mixin Messenger",
+      "selectionLabel": "Mixin Messenger (Blaze WebSocket)",
+      "docsPath": "/channels/mixin",
+      "order": 70,
+      "aliases": [
+        "mixin-messenger",
+        "mixin"
+      ],
+      "quickstartAllowFrom": true
+    },
+    "install": {
+      "npmSpec": "@invago/mixin",
+      "localPath": "extensions/mixin"
+    }
+  },
+  "files": [
+    "README.md",
+    "README.zh-CN.md",
+    "index.ts",
+    "openclaw.plugin.json",
+    "package.json",
+    "src/",
+    "tsconfig.json",
+    "eslint.config.mjs"
+  ]
+}

package/src/blaze-service.ts

@@ -9,12 +9,8 @@ import WebSocket from "ws";
 import crypto from "crypto";
 import type { MixinAccountConfig } from "./config-schema.js";
 import { createProxyAgent } from "./proxy.js";
-
-type SendLog = {
-  info: (msg: string) => void;
-  error: (msg: string, err?: unknown) => void;
-  warn: (msg: string) => void;
-};
+import type { MixinBlazeOutboundMessage } from "./runtime.js";
+import type { SendLog } from "./shared.js";
 
 function buildKeystore(config: MixinAccountConfig) {
   return {
@@ -50,8 +46,9 @@ export async function runBlazeLoop(params: {
   handler: BlazeHandler;
   log: SendLog;
   abortSignal?: AbortSignal;
+  onSenderReady?: ((sender: ((message: MixinBlazeOutboundMessage) => Promise<void>) | null) => void) | undefined;
 }): Promise<void> {
-  const { config, options, handler, log, abortSignal } = params;
+  const { config, options, handler, log, abortSignal, onSenderReady } = params;
   const keystore = buildKeystore(config);
   const jwtToken = signAccessToken("GET", "/", "", crypto.randomUUID(), keystore) || "";
   const agent = createProxyAgent(config.proxy);
@@ -67,6 +64,7 @@ export async function runBlazeLoop(params: {
         clearTimeout(pingTimeout);
         pingTimeout = null;
       }
+      onSenderReady?.(null);
       abortSignal?.removeEventListener("abort", onAbort);
     };
 
@@ -118,6 +116,25 @@ export async function runBlazeLoop(params: {
     ws.on("open", () => {
       opened = true;
       heartbeat();
+      onSenderReady?.(async (message) => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+          throw new Error("blaze sender unavailable: socket not open");
+        }
+        const ok = await sendRaw(ws, {
+          id: crypto.randomUUID(),
+          action: "CREATE_MESSAGE",
+          params: {
+            conversation_id: message.conversationId,
+            status: "SENT",
+            message_id: message.messageId,
+            category: message.category,
+            data: message.dataBase64,
+          },
+        });
+        if (!ok) {
+          throw new Error("blaze sender timeout");
+        }
+      });
       void sendRaw(ws!, {
         id: crypto.randomUUID(),
         action: "LIST_PENDING_MESSAGES",

package/src/channel.ts

@@ -1,13 +1,24 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { buildChannelConfigSchema, formatPairingApproveHint } from "openclaw/plugin-sdk";
+import { uniqueConversationID } from "@mixin.dev/mixin-node-sdk";
+import {
+  buildChannelConfigSchema,
+  createDefaultChannelRuntimeState,
+  formatPairingApproveHint,
+  resolveChannelMediaMaxBytes,
+} from "openclaw/plugin-sdk";
 import type { ChannelGatewayContext, OpenClawConfig, ReplyPayload } from "openclaw/plugin-sdk";
 import { runBlazeLoop } from "./blaze-service.js";
+import { buildClient, sleep } from "./shared.js";
 import { MixinConfigSchema } from "./config-schema.js";
-import { describeAccount, isConfigured, listAccountIds, resolveAccount } from "./config.js";
+import { describeAccount, isConfigured, listAccountIds, resolveAccount, resolveDefaultAccountId, resolveMediaMaxMb } from "./config.js";
+import type { MixinAccountConfig } from "./config-schema.js";
 import { handleMixinMessage, type MixinInboundMessage } from "./inbound-handler.js";
-import { getMixinRuntime } from "./runtime.js";
-import { sendAudioMessage, sendFileMessage, sendTextMessage, startSendWorker } from "./send-service.js";
+import { getMixpayStatusSnapshot, startMixpayWorker } from "./mixpay-worker.js";
+import { buildMixinOutboundPlanFromReplyPayload, executeMixinOutboundPlan } from "./outbound-plan.js";
+import { getMixinRuntime, setMixinBlazeSender } from "./runtime.js";
+import { getOutboxStatus, sendAudioMessage, sendFileMessage, sendTextMessage, startSendWorker } from "./send-service.js";
+import { buildMixinAccountSnapshot, buildMixinChannelSummary, resolveMixinStatusSnapshot } from "./status.js";
 
 type ResolvedMixinAccount = ReturnType<typeof resolveAccount>;
 
@@ -16,10 +27,12 @@ const MAX_DELAY = 3000;
 const MULTIPLIER = 1.5;
 const MEDIA_MAX_BYTES = 30 * 1024 * 1024;
 const execFileAsync = promisify(execFile);
+const CONVERSATION_CATEGORY_CACHE_TTL_MS = 5 * 60 * 1000;
 
-async function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
+const conversationCategoryCache = new Map<string, {
+  category: "CONTACT" | "GROUP";
+  expiresAt: number;
+}>();
 
 function maskKey(key: string): string {
   if (!key || key.length < 8) {
@@ -28,6 +41,65 @@ function maskKey(key: string): string {
   return key.slice(0, 4) + "****" + key.slice(-4);
 }
 
+async function resolveIsDirectMessage(params: {
+  config: MixinAccountConfig;
+  conversationId?: string;
+  userId?: string;
+  log: {
+    info: (m: string) => void;
+    warn: (m: string) => void;
+  };
+}): Promise<boolean> {
+  const conversationId = params.conversationId?.trim();
+  if (!conversationId) {
+    return true;
+  }
+
+  const cached = conversationCategoryCache.get(conversationId);
+  if (cached && cached.expiresAt > Date.now()) {
+    params.log.info(`[mixin] conversation category resolved from cache: conversationId=${conversationId}, category=${cached.category}`);
+    return cached.category !== "GROUP";
+  }
+
+  const now = Date.now();
+  for (const [key, entry] of conversationCategoryCache) {
+    if (entry.expiresAt <= now) {
+      conversationCategoryCache.delete(key);
+    }
+  }
+
+  try {
+    const client = buildClient(params.config);
+    const conversation = await client.conversation.fetch(conversationId);
+    const category = conversation.category === "GROUP" ? "GROUP" : "CONTACT";
+    conversationCategoryCache.set(conversationId, {
+      category,
+      expiresAt: Date.now() + CONVERSATION_CATEGORY_CACHE_TTL_MS,
+    });
+    params.log.info(`[mixin] conversation category resolved: conversationId=${conversationId}, category=${category}`);
+    return category !== "GROUP";
+  } catch (err) {
+    const userId = params.userId?.trim();
+    if (userId && params.config.appId) {
+      const directConversationId = uniqueConversationID(params.config.appId, userId);
+      if (directConversationId === conversationId) {
+        params.log.info(
+          `[mixin] conversation category inferred locally: conversationId=${conversationId}, category=CONTACT`,
+        );
+        conversationCategoryCache.set(conversationId, {
+          category: "CONTACT",
+          expiresAt: Date.now() + CONVERSATION_CATEGORY_CACHE_TTL_MS,
+        });
+        return true;
+      }
+    }
+    params.log.warn(
+      `[mixin] failed to resolve conversation category: conversationId=${conversationId}, error=${err instanceof Error ? err.message : String(err)}`,
+    );
+    return false;
+  }
+}
+
 async function resolveAudioDurationSeconds(filePath: string): Promise<number | null> {
   try {
     const { stdout } = await execFileAsync(
@@ -53,11 +125,12 @@ async function resolveAudioDurationSeconds(filePath: string): Promise<number | n
   }
 }
 
-function resolvePayloadMediaUrls(payload: ReplyPayload): string[] {
-  if (payload.mediaUrls && payload.mediaUrls.length > 0) {
-    return payload.mediaUrls;
-  }
-  return payload.mediaUrl ? [payload.mediaUrl] : [];
+function resolveMixinMediaMaxBytes(cfg: OpenClawConfig, accountId?: string | null): number {
+  return resolveChannelMediaMaxBytes({
+    cfg,
+    resolveChannelLimitMb: ({ cfg, accountId }) => resolveMediaMaxMb(cfg, accountId),
+    accountId,
+  }) ?? MEDIA_MAX_BYTES;
 }
 
 async function deliverOutboundMixinPayload(params: {
@@ -68,33 +141,28 @@ async function deliverOutboundMixinPayload(params: {
   mediaLocalRoots?: readonly string[];
   accountId?: string | null;
 }): Promise<{ channel: "mixin"; messageId: string }> {
-  const accountId = params.accountId ?? "default";
-  let lastMessageId = params.to;
-
-  if (params.text?.trim()) {
-    const textResult = await sendTextMessage(params.cfg, accountId, params.to, undefined, params.text);
-    if (!textResult.ok) {
-      throw new Error(textResult.error ?? "mixin outbound text send failed");
-    }
-    lastMessageId = textResult.messageId ?? lastMessageId;
-  }
-
+  const accountId = params.accountId ?? resolveDefaultAccountId(params.cfg);
+  const account = resolveAccount(params.cfg, accountId);
+  const mediaMaxBytes = resolveMixinMediaMaxBytes(params.cfg, accountId);
   const runtime = getMixinRuntime();
-  for (const mediaUrl of params.mediaUrls ?? []) {
+
+  const sendMediaUrl = async (mediaUrl: string): Promise<string | undefined> => {
     const loaded = await runtime.media.loadWebMedia(mediaUrl, {
-      maxBytes: MEDIA_MAX_BYTES,
+      maxBytes: mediaMaxBytes,
       localRoots: params.mediaLocalRoots,
     });
     const saved = await runtime.channel.media.saveMediaBuffer(
       loaded.buffer,
       loaded.contentType,
       "mixin",
-      MEDIA_MAX_BYTES,
+      mediaMaxBytes,
       loaded.fileName,
     );
 
-    if (loaded.kind === "audio") {
-      const duration = await resolveAudioDurationSeconds(saved.path);
+    if (loaded.kind === "audio" && account.config.audioSendAsVoiceByDefault !== false) {
+      const duration = account.config.audioAutoDetectDuration === false
+        ? null
+        : await resolveAudioDurationSeconds(saved.path);
       if (duration !== null) {
         const audioResult = await sendAudioMessage(
           params.cfg,
@@ -110,8 +178,10 @@ async function deliverOutboundMixinPayload(params: {
         if (!audioResult.ok) {
           throw new Error(audioResult.error ?? "mixin outbound audio send failed");
         }
-        lastMessageId = audioResult.messageId ?? lastMessageId;
-        continue;
+        return audioResult.messageId;
+      }
+      if (account.config.audioRequireFfprobe) {
+        throw new Error("ffprobe is required to send mediaUrl audio as Mixin voice");
       }
     }
 
@@ -129,10 +199,27 @@ async function deliverOutboundMixinPayload(params: {
     if (!fileResult.ok) {
       throw new Error(fileResult.error ?? "mixin outbound file send failed");
     }
-    lastMessageId = fileResult.messageId ?? lastMessageId;
+    return fileResult.messageId;
+  };
+
+  const payloadPlan = buildMixinOutboundPlanFromReplyPayload({
+    text: params.text,
+    mediaUrl: params.mediaUrls?.[0],
+    mediaUrls: params.mediaUrls,
+  } as ReplyPayload);
+  for (const warning of payloadPlan.warnings) {
+    console.warn(`[mixin] outbound plan warning: ${warning}`);
   }
 
-  return { channel: "mixin", messageId: lastMessageId };
+  const lastMessageId = await executeMixinOutboundPlan({
+    cfg: params.cfg,
+    accountId,
+    conversationId: params.to,
+    steps: payloadPlan.steps,
+    sendMediaUrl,
+  });
+
+  return { channel: "mixin", messageId: lastMessageId ?? params.to };
 }
 
 export const mixinPlugin = {
@@ -162,7 +249,7 @@ export const mixinPlugin = {
     listAccountIds,
     resolveAccount: (cfg: OpenClawConfig, accountId?: string | null) =>
       resolveAccount(cfg, accountId ?? undefined),
-    defaultAccountId: () => "default",
+    defaultAccountId: (cfg: OpenClawConfig) => resolveDefaultAccountId(cfg),
   },
 
   pairing: {
@@ -192,6 +279,7 @@ export const mixinPlugin = {
 
   outbound: {
     deliveryMode: "direct" as const,
+    textChunkLimit: 4000,
     sendPayload: async (ctx: {
       cfg: OpenClawConfig;
       to: string;
@@ -203,7 +291,11 @@ export const mixinPlugin = {
         cfg: ctx.cfg,
         to: ctx.to,
         text: ctx.payload.text,
-        mediaUrls: resolvePayloadMediaUrls(ctx.payload),
+        mediaUrls: ctx.payload.mediaUrls && ctx.payload.mediaUrls.length > 0
+          ? ctx.payload.mediaUrls
+          : ctx.payload.mediaUrl
+            ? [ctx.payload.mediaUrl]
+            : [],
         mediaLocalRoots: ctx.mediaLocalRoots,
         accountId: ctx.accountId,
       }),
@@ -214,7 +306,7 @@ export const mixinPlugin = {
       text: string;
       accountId?: string | null;
     }) => {
-      const id = ctx.accountId ?? "default";
+      const id = ctx.accountId ?? resolveDefaultAccountId(ctx.cfg);
       const result = await sendTextMessage(ctx.cfg, id, ctx.to, undefined, ctx.text);
       if (result.ok) {
         return { channel: "mixin", messageId: result.messageId ?? ctx.to };
@@ -251,10 +343,19 @@ export const mixinPlugin = {
       const config = account.config;
 
       await startSendWorker(cfg, log);
+      const outboxStatus = await getOutboxStatus().catch(() => null);
+      await startMixpayWorker(cfg, log);
+      const mixpayStatus = await getMixpayStatusSnapshot().catch(() => null);
+      const statusSnapshot = resolveMixinStatusSnapshot(cfg, accountId, outboxStatus, mixpayStatus);
+      ctx.setStatus({
+        accountId,
+        ...statusSnapshot,
+      });
 
       let stopped = false;
       const stop = () => {
         stopped = true;
+        setMixinBlazeSender(accountId, null);
       };
       abortSignal?.addEventListener("abort", stop);
 
@@ -272,6 +373,9 @@ export const mixinPlugin = {
               options: { parse: false, syncAck: true },
               log,
               abortSignal,
+              onSenderReady: (sender) => {
+                setMixinBlazeSender(accountId, sender);
+              },
               handler: {
                 onMessage: async (rawMsg: any) => {
                   if (stopped) {
@@ -284,9 +388,15 @@ export const mixinPlugin = {
                     return;
                   }
 
-                  const isDirect = rawMsg.conversation_id === undefined
-                    ? true
-                    : !rawMsg.representative_id;
+                  const isDirect = await resolveIsDirectMessage({
+                    config,
+                    conversationId: rawMsg.conversation_id,
+                    userId: rawMsg.user_id,
+                    log,
+                  });
+                  log.info(
+                    `[mixin] inbound route context: messageId=${rawMsg.message_id}, conversationId=${rawMsg.conversation_id ?? ""}, userId=${rawMsg.user_id}, isDirect=${isDirect}`,
+                  );
 
                   const msg: MixinInboundMessage = {
                     conversationId: rawMsg.conversation_id ?? "",
@@ -340,10 +450,43 @@ export const mixinPlugin = {
   },
 
   status: {
-    defaultRuntime: {
-      accountId: "default",
-      running: false,
-      status: "stopped" as const,
+    defaultRuntime: createDefaultChannelRuntimeState("default"),
+    buildChannelSummary: (params: {
+      snapshot: {
+        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;
+      };
+    }) => buildMixinChannelSummary({ snapshot: params.snapshot }),
+    buildAccountSnapshot: (params: {
+      account: ResolvedMixinAccount;
+      runtime?: {
+        running?: boolean | null;
+        lastStartAt?: number | null;
+        lastStopAt?: number | null;
+        lastError?: string | null;
+        lastInboundAt?: number | null;
+        lastOutboundAt?: number | null;
+      } | null;
+      probe?: unknown;
+      cfg: OpenClawConfig;
+    }) => {
+      const { account, runtime, probe, cfg } = params;
+      const statusSnapshot = resolveMixinStatusSnapshot(cfg, account.accountId);
+      return buildMixinAccountSnapshot({
+        account,
+        runtime,
+        probe,
+        defaultAccountId: statusSnapshot.defaultAccountId,
+        outboxPending: statusSnapshot.outboxPending,
+      });
     },
   },
 };

package/src/config-schema.ts

@@ -1,4 +1,4 @@
-import { DmPolicySchema } from "openclaw/plugin-sdk";
+import { DmPolicySchema, GroupPolicySchema } from "openclaw/plugin-sdk";
 import { z } from "zod";
 
 export const MixinProxyConfigSchema = z.object({
@@ -22,6 +22,31 @@ export const MixinProxyConfigSchema = z.object({
 
 export type MixinProxyConfig = z.infer<typeof MixinProxyConfigSchema>;
 
+export const MixinConversationConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  requireMention: z.boolean().optional(),
+  allowFrom: z.array(z.string()).optional(),
+  mediaBypassMention: z.boolean().optional(),
+  groupPolicy: GroupPolicySchema.optional(),
+});
+
+export type MixinConversationConfig = z.infer<typeof MixinConversationConfigSchema>;
+
+export const MixinMixpayConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  apiBaseUrl: z.string().optional(),
+  payeeId: z.string().optional(),
+  defaultQuoteAssetId: z.string().optional(),
+  defaultSettlementAssetId: z.string().optional(),
+  expireMinutes: z.number().positive().optional().default(15),
+  pollIntervalSec: z.number().positive().optional().default(30),
+  allowedCreators: z.array(z.string()).optional().default([]),
+  notifyOnPending: z.boolean().optional().default(false),
+  notifyOnPaidLess: z.boolean().optional().default(true),
+});
+
+export type MixinMixpayConfig = z.infer<typeof MixinMixpayConfigSchema>;
+
 export const MixinAccountConfigSchema = z.object({
   name: z.string().optional(),
   enabled: z.boolean().optional().default(true),
@@ -31,7 +56,16 @@ export const MixinAccountConfigSchema = z.object({
   sessionPrivateKey: z.string().optional(),
   dmPolicy: DmPolicySchema.optional().default("pairing"),
   allowFrom: z.array(z.string()).optional().default([]),
+  groupPolicy: GroupPolicySchema.optional(),
+  groupAllowFrom: z.array(z.string()).optional(),
   requireMentionInGroup: z.boolean().optional().default(true),
+  mediaBypassMentionInGroup: z.boolean().optional().default(true),
+  mediaMaxMb: z.number().positive().optional(),
+  audioAutoDetectDuration: z.boolean().optional().default(true),
+  audioSendAsVoiceByDefault: z.boolean().optional().default(true),
+  audioRequireFfprobe: z.boolean().optional().default(false),
+  mixpay: MixinMixpayConfigSchema.optional(),
+  conversations: z.record(z.string(), MixinConversationConfigSchema.optional()).optional(),
   debug: z.boolean().optional().default(false),
   proxy: MixinProxyConfigSchema.optional(),
 });
@@ -39,6 +73,7 @@ export const MixinAccountConfigSchema = z.object({
 export type MixinAccountConfig = z.infer<typeof MixinAccountConfigSchema>;
 
 export const MixinConfigSchema: z.ZodTypeAny = MixinAccountConfigSchema.extend({
+  defaultAccount: z.string().optional(),
   accounts: z.record(z.string(), MixinAccountConfigSchema.optional()).optional(),
 });