@invago/mixin 1.0.7 → 1.0.9

package/src/channel.ts

@@ -1,16 +1,28 @@
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk";
-import type { ChannelGatewayContext, OpenClawConfig } from "openclaw/plugin-sdk";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+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 { MixinConfigSchema } from "./config-schema.js";
-import { describeAccount, isConfigured, listAccountIds, resolveAccount } from "./config.js";
+import { describeAccount, isConfigured, listAccountIds, resolveAccount, resolveDefaultAccountId, resolveMediaMaxMb } from "./config.js";
 import { handleMixinMessage, type MixinInboundMessage } from "./inbound-handler.js";
-import { sendTextMessage, startSendWorker } from "./send-service.js";
+import { buildMixinOutboundPlanFromReplyPayload, executeMixinOutboundPlan } from "./outbound-plan.js";
+import { getMixinRuntime } 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>;
 
 const BASE_DELAY = 1000;
 const MAX_DELAY = 3000;
 const MULTIPLIER = 1.5;
+const MEDIA_MAX_BYTES = 30 * 1024 * 1024;
+const execFileAsync = promisify(execFile);
 
 async function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -23,6 +35,128 @@ function maskKey(key: string): string {
   return key.slice(0, 4) + "****" + key.slice(-4);
 }
 
+async function resolveAudioDurationSeconds(filePath: string): Promise<number | null> {
+  try {
+    const { stdout } = await execFileAsync(
+      process.platform === "win32" ? "ffprobe.exe" : "ffprobe",
+      [
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        filePath,
+      ],
+      { timeout: 15_000, windowsHide: true },
+    );
+    const seconds = Number.parseFloat(stdout.trim());
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+      return null;
+    }
+    return Math.max(1, Math.ceil(seconds));
+  } catch {
+    return null;
+  }
+}
+
+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: {
+  cfg: OpenClawConfig;
+  to: string;
+  text?: string;
+  mediaUrls?: string[];
+  mediaLocalRoots?: readonly string[];
+  accountId?: string | null;
+}): Promise<{ channel: "mixin"; messageId: string }> {
+  const accountId = params.accountId ?? resolveDefaultAccountId(params.cfg);
+  const account = resolveAccount(params.cfg, accountId);
+  const mediaMaxBytes = resolveMixinMediaMaxBytes(params.cfg, accountId);
+  const runtime = getMixinRuntime();
+
+  const sendMediaUrl = async (mediaUrl: string): Promise<string | undefined> => {
+    const loaded = await runtime.media.loadWebMedia(mediaUrl, {
+      maxBytes: mediaMaxBytes,
+      localRoots: params.mediaLocalRoots,
+    });
+    const saved = await runtime.channel.media.saveMediaBuffer(
+      loaded.buffer,
+      loaded.contentType,
+      "mixin",
+      mediaMaxBytes,
+      loaded.fileName,
+    );
+
+    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,
+          accountId,
+          params.to,
+          undefined,
+          {
+            filePath: saved.path,
+            mimeType: saved.contentType ?? loaded.contentType,
+            duration,
+          },
+        );
+        if (!audioResult.ok) {
+          throw new Error(audioResult.error ?? "mixin outbound audio send failed");
+        }
+        return audioResult.messageId;
+      }
+      if (account.config.audioRequireFfprobe) {
+        throw new Error("ffprobe is required to send mediaUrl audio as Mixin voice");
+      }
+    }
+
+    const fileResult = await sendFileMessage(
+      params.cfg,
+      accountId,
+      params.to,
+      undefined,
+      {
+        filePath: saved.path,
+        fileName: loaded.fileName,
+        mimeType: saved.contentType ?? loaded.contentType,
+      },
+    );
+    if (!fileResult.ok) {
+      throw new Error(fileResult.error ?? "mixin outbound file send failed");
+    }
+    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}`);
+  }
+
+  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 = {
   id: "mixin",
 
@@ -41,7 +175,7 @@ export const mixinPlugin = {
     chatTypes: ["direct", "group"] as Array<"direct" | "group">,
     reactions: false,
     threads: false,
-    media: false,
+    media: true,
     nativeCommands: false,
     blockStreaming: false,
   },
@@ -50,27 +184,56 @@ export const mixinPlugin = {
     listAccountIds,
     resolveAccount: (cfg: OpenClawConfig, accountId?: string | null) =>
       resolveAccount(cfg, accountId ?? undefined),
-    defaultAccountId: () => "default",
+    defaultAccountId: (cfg: OpenClawConfig) => resolveDefaultAccountId(cfg),
+  },
+
+  pairing: {
+    idLabel: "Mixin UUID",
+    normalizeAllowEntry: (entry: string) => entry.trim().toLowerCase(),
   },
 
   security: {
     resolveDmPolicy: ({ account, accountId }: { account: ResolvedMixinAccount; accountId?: string | null }) => {
       const allowFrom = account.config.allowFrom ?? [];
       const basePath = accountId && accountId !== "default" ? `.accounts.${accountId}` : "";
+      const policy = account.config.dmPolicy ?? "pairing";
 
       return {
-        policy: "allowlist" as const,
+        policy,
         allowFrom,
+        policyPath: `channels.mixin${basePath}.dmPolicy`,
         allowFromPath: `channels.mixin${basePath}.allowFrom`,
-        approveHint: allowFrom.length > 0
-          ? `已配置白名单用户数 ${allowFrom.length}，将用户的 Mixin UUID 添加到 allowFrom 列表即可授权`
-          : "将用户的 Mixin UUID 添加到 allowFrom 列表即可授权",
+        approveHint: policy === "pairing"
+          ? formatPairingApproveHint("mixin")
+          : allowFrom.length > 0
+            ? `已配置白名单用户数 ${allowFrom.length}，将用户的 Mixin UUID 添加到 allowFrom 列表即可授权`
+            : "将用户的 Mixin UUID 添加到 allowFrom 列表即可授权",
       };
     },
   },
 
   outbound: {
     deliveryMode: "direct" as const,
+    textChunkLimit: 4000,
+    sendPayload: async (ctx: {
+      cfg: OpenClawConfig;
+      to: string;
+      payload: ReplyPayload;
+      mediaLocalRoots?: readonly string[];
+      accountId?: string | null;
+    }) =>
+      deliverOutboundMixinPayload({
+        cfg: ctx.cfg,
+        to: ctx.to,
+        text: ctx.payload.text,
+        mediaUrls: ctx.payload.mediaUrls && ctx.payload.mediaUrls.length > 0
+          ? ctx.payload.mediaUrls
+          : ctx.payload.mediaUrl
+            ? [ctx.payload.mediaUrl]
+            : [],
+        mediaLocalRoots: ctx.mediaLocalRoots,
+        accountId: ctx.accountId,
+      }),
 
     sendText: async (ctx: {
       cfg: OpenClawConfig;
@@ -78,13 +241,29 @@ 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 };
       }
       throw new Error(result.error ?? "sendText failed");
     },
+    sendMedia: async (ctx: {
+      cfg: OpenClawConfig;
+      to: string;
+      text: string;
+      mediaUrl?: string;
+      mediaLocalRoots?: readonly string[];
+      accountId?: string | null;
+    }) =>
+      deliverOutboundMixinPayload({
+        cfg: ctx.cfg,
+        to: ctx.to,
+        text: ctx.text,
+        mediaUrls: ctx.mediaUrl ? [ctx.mediaUrl] : [],
+        mediaLocalRoots: ctx.mediaLocalRoots,
+        accountId: ctx.accountId,
+      }),
   },
 
   gateway: {
@@ -99,6 +278,12 @@ export const mixinPlugin = {
       const config = account.config;
 
       await startSendWorker(cfg, log);
+      const outboxStatus = await getOutboxStatus().catch(() => null);
+      const statusSnapshot = resolveMixinStatusSnapshot(cfg, accountId, outboxStatus);
+      ctx.setStatus({
+        accountId,
+        ...statusSnapshot,
+      });
 
       let stopped = false;
       const stop = () => {
@@ -188,10 +373,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,3 +1,4 @@
+import { DmPolicySchema, GroupPolicySchema } from "openclaw/plugin-sdk";
 import { z } from "zod";
 
 export const MixinProxyConfigSchema = z.object({
@@ -21,6 +22,16 @@ 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 MixinAccountConfigSchema = z.object({
   name: z.string().optional(),
   enabled: z.boolean().optional().default(true),
@@ -28,8 +39,17 @@ export const MixinAccountConfigSchema = z.object({
   sessionId: z.string().optional(),
   serverPublicKey: z.string().optional(),
   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),
+  conversations: z.record(z.string(), MixinConversationConfigSchema.optional()).optional(),
   debug: z.boolean().optional().default(false),
   proxy: MixinProxyConfigSchema.optional(),
 });
@@ -37,6 +57,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(),
 });
 

package/src/config.ts

@@ -1,26 +1,60 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { MixinAccountConfigSchema, type MixinAccountConfig, type MixinConfig } from "./config-schema.js";
+import {
+  MixinAccountConfigSchema,
+  MixinConversationConfigSchema,
+  type MixinAccountConfig,
+  type MixinConversationConfig,
+} from "./config-schema.js";
 
-function getRawConfig(cfg: OpenClawConfig): any {
-  return (cfg.channels as Record<string, unknown>)?.mixin ?? {};
+type RawMixinConfig = Partial<MixinAccountConfig> & {
+  defaultAccount?: string;
+  accounts?: Record<string, Partial<MixinAccountConfig> | undefined>;
+};
+
+function getRawConfig(cfg: OpenClawConfig): RawMixinConfig {
+  return ((cfg.channels as Record<string, unknown>)?.mixin ?? {}) as RawMixinConfig;
 }
 
-export function listAccountIds(cfg: OpenClawConfig): string[] {
+function hasTopLevelAccountConfig(raw: RawMixinConfig): boolean {
+  return Boolean(raw.appId || raw.sessionId || raw.serverPublicKey || raw.sessionPrivateKey || raw.name);
+}
+
+export function resolveDefaultAccountId(cfg: OpenClawConfig): string {
   const raw = getRawConfig(cfg);
+  const configuredDefault = raw.defaultAccount?.trim();
+  if (configuredDefault && raw.accounts?.[configuredDefault]) {
+    return configuredDefault;
+  }
+  if (configuredDefault === "default") {
+    return "default";
+  }
   if (raw.accounts && Object.keys(raw.accounts).length > 0) {
-    return Object.keys(raw.accounts);
+    if (hasTopLevelAccountConfig(raw)) {
+      return "default";
+    }
+    return Object.keys(raw.accounts)[0] ?? "default";
   }
-  return ["default"];
+  return "default";
+}
+
+export function listAccountIds(cfg: OpenClawConfig): string[] {
+  const raw = getRawConfig(cfg);
+  const accountIds = raw.accounts ? Object.keys(raw.accounts) : [];
+  if (hasTopLevelAccountConfig(raw) || accountIds.length === 0) {
+    return ["default", ...accountIds.filter((accountId) => accountId !== "default")];
+  }
+  return accountIds;
 }
 
 export function getAccountConfig(cfg: OpenClawConfig, accountId?: string): MixinAccountConfig {
   const raw = getRawConfig(cfg);
+  const resolvedAccountId = accountId ?? resolveDefaultAccountId(cfg);
   let accountRaw: Partial<MixinAccountConfig>;
 
-  if (accountId && accountId !== "default" && raw.accounts?.[accountId]) {
-    accountRaw = raw.accounts[accountId] as Partial<MixinAccountConfig>;
+  if (resolvedAccountId !== "default" && raw.accounts?.[resolvedAccountId]) {
+    accountRaw = raw.accounts[resolvedAccountId] as Partial<MixinAccountConfig>;
   } else {
-    accountRaw = raw as MixinConfig as Partial<MixinAccountConfig>;
+    accountRaw = raw;
   }
 
   const result = MixinAccountConfigSchema.safeParse(accountRaw);
@@ -29,7 +63,7 @@ export function getAccountConfig(cfg: OpenClawConfig, accountId?: string): Mixin
 }
 
 export function resolveAccount(cfg: OpenClawConfig, accountId?: string) {
-  const id = accountId ?? "default";
+  const id = accountId ?? resolveDefaultAccountId(cfg);
   const config = getAccountConfig(cfg, id);
   const configured = Boolean(config.appId && config.sessionId && config.serverPublicKey && config.sessionPrivateKey);
   return {
@@ -41,6 +75,7 @@ export function resolveAccount(cfg: OpenClawConfig, accountId?: string) {
     sessionId: config.sessionId,
     serverPublicKey: config.serverPublicKey,
     sessionPrivateKey: config.sessionPrivateKey,
+    dmPolicy: config.dmPolicy,
     allowFrom: config.allowFrom,
     requireMentionInGroup: config.requireMentionInGroup,
     debug: config.debug,
@@ -48,6 +83,60 @@ export function resolveAccount(cfg: OpenClawConfig, accountId?: string) {
   };
 }
 
+export function resolveMediaMaxMb(cfg: OpenClawConfig, accountId?: string): number | undefined {
+  return getAccountConfig(cfg, accountId).mediaMaxMb;
+}
+
+function getRawAccountConfig(cfg: OpenClawConfig, accountId?: string): Partial<MixinAccountConfig> {
+  const raw = getRawConfig(cfg);
+  const resolvedAccountId = accountId ?? resolveDefaultAccountId(cfg);
+  if (resolvedAccountId !== "default" && raw.accounts?.[resolvedAccountId]) {
+    return raw.accounts[resolvedAccountId] as Partial<MixinAccountConfig>;
+  }
+  return raw;
+}
+
+export function getConversationConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+  conversationId: string,
+): {
+  exists: boolean;
+  config: MixinConversationConfig;
+} {
+  const accountRaw = getRawAccountConfig(cfg, accountId);
+  const conversationRaw = accountRaw.conversations?.[conversationId] as Partial<MixinConversationConfig> | undefined;
+  const result = MixinConversationConfigSchema.safeParse(conversationRaw ?? {});
+  return {
+    exists: Boolean(conversationRaw),
+    config: result.success ? result.data : MixinConversationConfigSchema.parse({}),
+  };
+}
+
+export function resolveConversationPolicy(
+  cfg: OpenClawConfig,
+  accountId: string,
+  conversationId: string,
+): {
+  enabled: boolean;
+  requireMention: boolean;
+  mediaBypassMention: boolean;
+  groupPolicy: MixinAccountConfig["groupPolicy"];
+  groupAllowFrom: string[];
+  hasConversationOverride: boolean;
+} {
+  const accountConfig = getAccountConfig(cfg, accountId);
+  const conversation = getConversationConfig(cfg, accountId, conversationId);
+  return {
+    enabled: conversation.config.enabled !== false,
+    requireMention: conversation.config.requireMention ?? accountConfig.requireMentionInGroup,
+    mediaBypassMention: conversation.config.mediaBypassMention ?? accountConfig.mediaBypassMentionInGroup,
+    groupPolicy: conversation.config.groupPolicy ?? accountConfig.groupPolicy,
+    groupAllowFrom: conversation.config.allowFrom ?? accountConfig.groupAllowFrom ?? [],
+    hasConversationOverride: conversation.exists,
+  };
+}
+
 export function isConfigured(account: ReturnType<typeof resolveAccount>): boolean {
   return account.configured;
 }