@invago/mixin 1.0.8 → 1.0.9

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 {
@@ -49,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;
 }

package/src/inbound-handler.ts

@@ -2,22 +2,17 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { MixinApi } from "@mixin.dev/mixin-node-sdk";
-import { buildAgentMediaPayload } from "openclaw/plugin-sdk";
+import { buildAgentMediaPayload, evaluateSenderGroupAccess, resolveDefaultGroupPolicy } from "openclaw/plugin-sdk";
 import type { AgentMediaPayload, OpenClawConfig } from "openclaw/plugin-sdk";
-import { getAccountConfig } from "./config.js";
+import { getAccountConfig, resolveConversationPolicy } from "./config.js";
 import type { MixinAccountConfig } from "./config-schema.js";
 import { decryptMixinMessage } from "./crypto.js";
 import { buildRequestConfig } from "./proxy.js";
-import { buildMixinReplyPlan } from "./reply-format.js";
+import { buildMixinOutboundPlanFromReplyText, executeMixinOutboundPlan } from "./outbound-plan.js";
 import { getMixinRuntime } from "./runtime.js";
 import {
-  sendAudioMessage,
   getOutboxStatus,
   purgePermanentInvalidOutboxEntries,
-  sendFileMessage,
-  sendButtonGroupMessage,
-  sendCardMessage,
-  sendPostMessage,
   sendTextMessage,
 } from "./send-service.js";
 
@@ -100,6 +95,14 @@ function buildClient(config: MixinAccountConfig) {
   });
 }
 
+function resolveInboundMediaMaxBytes(config: MixinAccountConfig): number {
+  const mediaMaxMb = config.mediaMaxMb;
+  if (typeof mediaMaxMb === "number" && Number.isFinite(mediaMaxMb) && mediaMaxMb > 0) {
+    return Math.max(1, Math.floor(mediaMaxMb * 1024 * 1024));
+  }
+  return INBOUND_MEDIA_MAX_BYTES;
+}
+
 function parseInboundAttachmentRequest(category: string, data: string): MixinAttachmentRequest | null {
   if (category !== "PLAIN_DATA" && category !== "PLAIN_AUDIO") {
     return null;
@@ -165,17 +168,18 @@ async function resolveInboundAttachment(params: {
 
   try {
     const client = buildClient(params.config);
+    const maxBytes = resolveInboundMediaMaxBytes(params.config);
     const attachment = await client.attachment.fetch(payload.attachmentId);
     const fetched = await params.rt.channel.media.fetchRemoteMedia({
       url: attachment.view_url,
       filePathHint: payload.fileName,
-      maxBytes: INBOUND_MEDIA_MAX_BYTES,
+      maxBytes,
     });
     const saved = await params.rt.channel.media.saveMediaBuffer(
       fetched.buffer,
       payload.mimeType ?? fetched.contentType,
       "mixin",
-      INBOUND_MEDIA_MAX_BYTES,
+      maxBytes,
       payload.fileName ?? fetched.fileName,
     );
 
@@ -236,6 +240,10 @@ function normalizeAllowEntry(entry: string): string {
   return entry.trim().toLowerCase();
 }
 
+function normalizeAllowEntries(entries: string[] | undefined): string[] {
+  return (entries ?? []).map(normalizeAllowEntry).filter(Boolean);
+}
+
 function resolveMixinAllowFromPaths(
   rt: ReturnType<typeof getMixinRuntime>,
   accountId: string,
@@ -290,41 +298,21 @@ async function deliverMixinReply(params: {
   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) {
+  const plan = buildMixinOutboundPlanFromReplyText(text);
+  if (plan.steps.length === 0) {
     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 === "file") {
-    await sendFileMessage(cfg, accountId, conversationId, recipientId, plan.file, log);
-    return;
-  }
-
-  if (plan.kind === "audio") {
-    await sendAudioMessage(cfg, accountId, conversationId, recipientId, plan.audio, 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;
+  for (const warning of plan.warnings) {
+    log.warn(`[mixin] outbound plan warning: ${warning}`);
   }
-
-  await sendCardMessage(cfg, accountId, conversationId, recipientId, plan.card, log);
+  await executeMixinOutboundPlan({
+    cfg,
+    accountId,
+    conversationId,
+    recipientId,
+    steps: plan.steps,
+    log,
+  });
 }
 
 async function handleUnauthorizedDirectMessage(params: {
@@ -386,6 +374,46 @@ async function handleUnauthorizedDirectMessage(params: {
   }
 }
 
+function evaluateMixinGroupAccess(params: {
+  cfg: OpenClawConfig;
+  config: MixinAccountConfig;
+  accountId: string;
+  conversationId: string;
+  senderId: string;
+}): {
+  allowed: boolean;
+  reason: string;
+  groupPolicy: "open" | "disabled" | "allowlist";
+  groupAllowFrom: string[];
+} {
+  const conversationPolicy = resolveConversationPolicy(params.cfg, params.accountId, params.conversationId);
+  if (!conversationPolicy.enabled) {
+    return {
+      allowed: false,
+      reason: "conversation disabled",
+      groupPolicy: "disabled",
+      groupAllowFrom: normalizeAllowEntries(conversationPolicy.groupAllowFrom),
+    };
+  }
+
+  const normalizedGroupAllowFrom = normalizeAllowEntries(conversationPolicy.groupAllowFrom);
+  const decision = evaluateSenderGroupAccess({
+    providerConfigPresent: true,
+    configuredGroupPolicy: conversationPolicy.groupPolicy,
+    defaultGroupPolicy: resolveDefaultGroupPolicy(params.cfg),
+    groupAllowFrom: normalizedGroupAllowFrom,
+    senderId: normalizeAllowEntry(params.senderId),
+    isSenderAllowed: (senderId, allowFrom) => allowFrom.includes(normalizeAllowEntry(senderId)),
+  });
+
+  return {
+    allowed: decision.allowed,
+    reason: decision.reason,
+    groupPolicy: decision.groupPolicy,
+    groupAllowFrom: normalizedGroupAllowFrom,
+  };
+}
+
 export async function handleMixinMessage(params: {
   cfg: OpenClawConfig;
   accountId: string;
@@ -446,7 +474,19 @@ export async function handleMixinMessage(params: {
     return;
   }
 
-  if (!isDirect && !isAttachmentMessage && !shouldPassGroupFilter(config, text)) {
+  const conversationPolicy = isDirect
+    ? null
+    : resolveConversationPolicy(cfg, accountId, msg.conversationId);
+
+  if (
+    !isDirect &&
+    conversationPolicy &&
+    !(isAttachmentMessage && conversationPolicy.mediaBypassMention) &&
+    !shouldPassGroupFilter({
+      ...config,
+      requireMentionInGroup: conversationPolicy.requireMention,
+    }, text)
+  ) {
     log.info(`[mixin] group message filtered: ${msg.messageId}`);
     return;
   }
@@ -454,10 +494,27 @@ export async function handleMixinMessage(params: {
   const effectiveAllowFrom = await readEffectiveAllowFrom(rt, accountId, config.allowFrom, log);
   const normalizedUserId = normalizeAllowEntry(msg.userId);
   const dmPolicy = config.dmPolicy ?? "pairing";
-  const isAuthorized = dmPolicy === "open" || effectiveAllowFrom.has(normalizedUserId);
+  const groupAccess = isDirect
+    ? null
+    : evaluateMixinGroupAccess({
+      cfg,
+      config,
+      accountId,
+      conversationId: msg.conversationId,
+      senderId: msg.userId,
+    });
+  const isAuthorized = isDirect
+    ? dmPolicy === "open" || effectiveAllowFrom.has(normalizedUserId)
+    : groupAccess?.allowed === true;
 
   if (!isAuthorized) {
-    log.warn(`[mixin] user ${msg.userId} not authorized (dmPolicy=${dmPolicy})`);
+    if (isDirect) {
+      log.warn(`[mixin] user ${msg.userId} not authorized (dmPolicy=${dmPolicy})`);
+    } else {
+      log.warn(
+        `[mixin] group sender ${msg.userId} blocked: conversationId=${msg.conversationId}, groupPolicy=${groupAccess?.groupPolicy ?? "unknown"}, reason=${groupAccess?.reason ?? "unknown"}`,
+      );
+    }
     markProcessed(msg.messageId);
     if (isDirect) {
       await handleUnauthorizedDirectMessage({ rt, cfg, accountId, config, msg, log });
@@ -507,14 +564,18 @@ export async function handleMixinMessage(params: {
 
   const shouldComputeCommandAuthorized = rt.channel.commands.shouldComputeCommandAuthorized(text, cfg);
   const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-  const senderAllowedForCommands = useAccessGroups ? effectiveAllowFrom.has(normalizedUserId) : true;
+  const senderAllowedForCommands = useAccessGroups
+    ? isDirect
+      ? effectiveAllowFrom.has(normalizedUserId)
+      : groupAccess?.allowed === true
+    : true;
 
   const commandAuthorized = shouldComputeCommandAuthorized
     ? rt.channel.commands.resolveCommandAuthorizedFromAuthorizers({
         useAccessGroups,
         authorizers: [
           {
-            configured: effectiveAllowFrom.size > 0,
+            configured: isDirect ? effectiveAllowFrom.size > 0 : (groupAccess?.groupAllowFrom.length ?? 0) > 0,
             allowed: senderAllowedForCommands,
           },
         ],

package/src/outbound-plan.ts

@@ -0,0 +1,197 @@
+import type { ReplyPayload } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { buildMixinReplyPlan, resolveMixinReplyPlan } from "./reply-format.js";
+import {
+  sendAudioMessage,
+  sendButtonGroupMessage,
+  sendCardMessage,
+  sendFileMessage,
+  sendPostMessage,
+  sendTextMessage,
+} from "./send-service.js";
+
+type SendLog = {
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string, err?: unknown) => void;
+};
+
+export type MixinOutboundStep =
+  | { kind: "text"; text: string }
+  | { kind: "post"; text: string }
+  | { kind: "file"; file: Parameters<typeof sendFileMessage>[4] }
+  | { kind: "audio"; audio: Parameters<typeof sendAudioMessage>[4] }
+  | { kind: "buttons"; intro?: string; buttons: Parameters<typeof sendButtonGroupMessage>[4] }
+  | { kind: "card"; card: Parameters<typeof sendCardMessage>[4] }
+  | { kind: "media-url"; mediaUrl: string };
+
+export type MixinOutboundPlan = {
+  steps: MixinOutboundStep[];
+  warnings: string[];
+};
+
+function appendReplyTextPlan(
+  steps: MixinOutboundStep[],
+  warnings: string[],
+  text: string,
+  options?: {
+    allowAttachmentTemplates?: boolean;
+  },
+): void {
+  const resolution = resolveMixinReplyPlan(text);
+  if (resolution.matchedTemplate && !resolution.plan) {
+    steps.push({
+      kind: "text",
+      text: `Mixin template error: ${resolution.error ?? "invalid template"}`,
+    });
+    return;
+  }
+
+  const plan = resolution.plan ?? buildMixinReplyPlan(text);
+  if (!plan) {
+    return;
+  }
+
+  if ((plan.kind === "file" || plan.kind === "audio") && options?.allowAttachmentTemplates === false) {
+    warnings.push(`ignored ${plan.kind} template because native media payload already contains media`);
+    steps.push({
+      kind: "text",
+      text: `Mixin template warning: ${plan.kind} template was ignored because mediaUrl/mediaUrls is already present.`,
+    });
+    return;
+  }
+
+  if (plan.kind === "text") {
+    steps.push({ kind: "text", text: plan.text });
+    return;
+  }
+  if (plan.kind === "post") {
+    steps.push({ kind: "post", text: plan.text });
+    return;
+  }
+  if (plan.kind === "file") {
+    steps.push({ kind: "file", file: plan.file });
+    return;
+  }
+  if (plan.kind === "audio") {
+    steps.push({ kind: "audio", audio: plan.audio });
+    return;
+  }
+  if (plan.kind === "buttons") {
+    steps.push({ kind: "buttons", intro: plan.intro, buttons: plan.buttons });
+    return;
+  }
+  steps.push({ kind: "card", card: plan.card });
+}
+
+export function buildMixinOutboundPlanFromReplyText(text: string): MixinOutboundPlan {
+  const steps: MixinOutboundStep[] = [];
+  const warnings: string[] = [];
+  appendReplyTextPlan(steps, warnings, text, { allowAttachmentTemplates: true });
+  return { steps, warnings };
+}
+
+export function buildMixinOutboundPlanFromReplyPayload(payload: ReplyPayload): MixinOutboundPlan {
+  const steps: MixinOutboundStep[] = [];
+  const warnings: string[] = [];
+  const mediaUrls = payload.mediaUrls && payload.mediaUrls.length > 0
+    ? payload.mediaUrls
+    : payload.mediaUrl
+      ? [payload.mediaUrl]
+      : [];
+
+  if (payload.text?.trim()) {
+    appendReplyTextPlan(steps, warnings, payload.text, {
+      allowAttachmentTemplates: mediaUrls.length === 0,
+    });
+  }
+
+  for (const mediaUrl of mediaUrls) {
+    steps.push({ kind: "media-url", mediaUrl });
+  }
+
+  return { steps, warnings };
+}
+
+export async function executeMixinOutboundPlan(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  conversationId: string;
+  recipientId?: string;
+  steps: MixinOutboundStep[];
+  log?: SendLog;
+  sendMediaUrl?: (mediaUrl: string) => Promise<string | undefined>;
+}): Promise<string | undefined> {
+  const { cfg, accountId, conversationId, recipientId, steps, log, sendMediaUrl } = params;
+  let lastMessageId: string | undefined;
+
+  for (const step of steps) {
+    if (step.kind === "text") {
+      const result = await sendTextMessage(cfg, accountId, conversationId, recipientId, step.text, log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound text send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
+    if (step.kind === "post") {
+      const result = await sendPostMessage(cfg, accountId, conversationId, recipientId, step.text, log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound post send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
+    if (step.kind === "file") {
+      const result = await sendFileMessage(cfg, accountId, conversationId, recipientId, step.file, log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound file send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
+    if (step.kind === "audio") {
+      const result = await sendAudioMessage(cfg, accountId, conversationId, recipientId, step.audio, log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound audio send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
+    if (step.kind === "buttons") {
+      if (step.intro) {
+        const introResult = await sendTextMessage(cfg, accountId, conversationId, recipientId, step.intro, log);
+        if (!introResult.ok) {
+          throw new Error(introResult.error ?? "mixin outbound intro send failed");
+        }
+        lastMessageId = introResult.messageId ?? lastMessageId;
+      }
+      const result = await sendButtonGroupMessage(cfg, accountId, conversationId, recipientId, step.buttons, log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound buttons send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
+    if (step.kind === "card") {
+      const result = await sendCardMessage(cfg, accountId, conversationId, recipientId, step.card, log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound card send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
+    if (!sendMediaUrl) {
+      throw new Error("mixin outbound mediaUrl handler not configured");
+    }
+    lastMessageId = await sendMediaUrl(step.mediaUrl) ?? lastMessageId;
+  }
+
+  return lastMessageId;
+}