@invago/mixin 1.0.9 → 1.0.10

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,5 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { uniqueConversationID } from "@mixin.dev/mixin-node-sdk";
 import {
   buildChannelConfigSchema,
   createDefaultChannelRuntimeState,
@@ -8,11 +9,14 @@ import {
 } 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, resolveDefaultAccountId, resolveMediaMaxMb } from "./config.js";
+import type { MixinAccountConfig } from "./config-schema.js";
 import { handleMixinMessage, type MixinInboundMessage } from "./inbound-handler.js";
+import { getMixpayStatusSnapshot, startMixpayWorker } from "./mixpay-worker.js";
 import { buildMixinOutboundPlanFromReplyPayload, executeMixinOutboundPlan } from "./outbound-plan.js";
-import { getMixinRuntime } from "./runtime.js";
+import { getMixinRuntime, setMixinBlazeSender } from "./runtime.js";
 import { getOutboxStatus, sendAudioMessage, sendFileMessage, sendTextMessage, startSendWorker } from "./send-service.js";
 import { buildMixinAccountSnapshot, buildMixinChannelSummary, resolveMixinStatusSnapshot } from "./status.js";
 
@@ -23,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) {
@@ -35,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(
@@ -279,7 +344,9 @@ export const mixinPlugin = {
 
       await startSendWorker(cfg, log);
       const outboxStatus = await getOutboxStatus().catch(() => null);
-      const statusSnapshot = resolveMixinStatusSnapshot(cfg, accountId, outboxStatus);
+      await startMixpayWorker(cfg, log);
+      const mixpayStatus = await getMixpayStatusSnapshot().catch(() => null);
+      const statusSnapshot = resolveMixinStatusSnapshot(cfg, accountId, outboxStatus, mixpayStatus);
       ctx.setStatus({
         accountId,
         ...statusSnapshot,
@@ -288,6 +355,7 @@ export const mixinPlugin = {
       let stopped = false;
       const stop = () => {
         stopped = true;
+        setMixinBlazeSender(accountId, null);
       };
       abortSignal?.addEventListener("abort", stop);
 
@@ -305,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) {
@@ -317,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 ?? "",

package/src/config-schema.ts

@@ -32,6 +32,21 @@ export const MixinConversationConfigSchema = z.object({
 
 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),
@@ -49,6 +64,7 @@ export const MixinAccountConfigSchema = z.object({
   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(),

package/src/config.ts

@@ -4,6 +4,7 @@ import {
   MixinConversationConfigSchema,
   type MixinAccountConfig,
   type MixinConversationConfig,
+  type MixinMixpayConfig,
 } from "./config-schema.js";
 
 type RawMixinConfig = Partial<MixinAccountConfig> & {
@@ -87,6 +88,10 @@ export function resolveMediaMaxMb(cfg: OpenClawConfig, accountId?: string): numb
   return getAccountConfig(cfg, accountId).mediaMaxMb;
 }
 
+export function getMixpayConfig(cfg: OpenClawConfig, accountId?: string): MixinMixpayConfig | undefined {
+  return getAccountConfig(cfg, accountId).mixpay;
+}
+
 function getRawAccountConfig(cfg: OpenClawConfig, accountId?: string): Partial<MixinAccountConfig> {
   const raw = getRawConfig(cfg);
   const resolvedAccountId = accountId ?? resolveDefaultAccountId(cfg);

package/src/crypto.ts

@@ -12,6 +12,11 @@ function aes256CbcDecrypt(key: Buffer, iv: Buffer, ciphertext: Buffer): Buffer {
   const final = Buffer.concat([decrypted, decipher.final()]);
   const padLen = final[final.length - 1];
   if (padLen > 0 && padLen <= 16) {
+    for (let i = final.length - padLen; i < final.length; i++) {
+      if (final[i] !== padLen) {
+        return final;
+      }
+    }
     return final.slice(0, final.length - padLen);
   }
   return final;