@meet-im/meet 3.4.5 → 3.5.0

package/dist/src/approval-native.d.ts

@@ -0,0 +1,30 @@
+import { type ChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import type { ChannelApprovalCapability } from "openclaw/plugin-sdk/channel-contract";
+import type { MeetExecApprovalConfig } from "./types.js";
+type MeetPendingPayload = {
+    text: string;
+};
+type MeetPreparedTarget = {
+    to: string;
+    threadId?: string;
+};
+type MeetPendingEntry = {
+    chatId: string;
+    messageId: string;
+};
+export declare const meetApprovalNativeRuntime: ChannelApprovalNativeRuntimeAdapter<MeetPendingPayload, MeetPreparedTarget, MeetPendingEntry, never, unknown>;
+export declare function createMeetNativeApprovalAdapter(configOverride?: MeetExecApprovalConfig | null): {
+    auth: {
+        authorizeActorAction?: ChannelApprovalCapability["authorizeActorAction"];
+        getActionAvailabilityState?: ChannelApprovalCapability["getActionAvailabilityState"];
+        getExecInitiatingSurfaceState?: ChannelApprovalCapability["getExecInitiatingSurfaceState"];
+        resolveApproveCommandBehavior?: ChannelApprovalCapability["resolveApproveCommandBehavior"];
+    };
+    delivery: ChannelApprovalCapability["delivery"];
+    nativeRuntime: ChannelApprovalCapability["nativeRuntime"];
+    render: ChannelApprovalCapability["render"];
+    native: ChannelApprovalCapability["native"];
+    describeExecApprovalSetup: ChannelApprovalCapability["describeExecApprovalSetup"];
+};
+export declare function getMeetApprovalCapability(): ChannelApprovalCapability;
+export {};

package/dist/src/approval-native.js

@@ -0,0 +1,235 @@
+import { createChannelApprovalNativeRuntimeAdapter, } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { buildChannelApprovalNativeTargetKey, resolveApprovalRequestSessionConversation, } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildExecApprovalPendingReplyPayload, } from "openclaw/plugin-sdk/approval-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { listMeetAccountIds, resolveMeetAccount } from "./accounts.js";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createApproverRestrictedNativeApprovalCapability, splitChannelApprovalCapability, } from "openclaw/plugin-sdk/approval-runtime";
+import { getMeetExecApprovalApprovers, isMeetExecApprovalApprover, isMeetExecApprovalClientEnabled, } from "./exec-approvals.js";
+import { sendMessageMeet } from "./send.js";
+function shouldHandleMeetApprovalRequest(_params) {
+    return true;
+}
+function extractMeetSessionKind(sessionKey) {
+    if (!sessionKey) {
+        return null;
+    }
+    const match = sessionKey.match(/meet:(channel|group|dm):/);
+    if (!match) {
+        return null;
+    }
+    return match[1];
+}
+function normalizeMeetOriginChannelId(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const prefixed = trimmed.match(/^(?:channel):(-?\d+)$/i);
+    if (prefixed) {
+        return prefixed[1];
+    }
+    return /^-?\d+$/.test(trimmed) ? trimmed : null;
+}
+function normalizeMeetThreadId(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? String(value) : undefined;
+    }
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return /^-?\d+$/.test(normalized) ? normalized : undefined;
+}
+function createMeetOriginTargetResolver(_configOverride) {
+    return createChannelNativeOriginTargetResolver({
+        channel: "meet",
+        shouldHandleRequest: ({ cfg, accountId, request }) => shouldHandleMeetApprovalRequest({
+            cfg,
+            accountId,
+            request,
+        }),
+        resolveTurnSourceTarget: (request) => {
+            const sessionConversation = resolveApprovalRequestSessionConversation({
+                request,
+                channel: "meet",
+                bundledFallback: false,
+            });
+            const sessionKind = extractMeetSessionKind(normalizeOptionalString(request.request.sessionKey) ?? null);
+            const turnSourceChannel = normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel);
+            const rawTurnSourceTo = normalizeOptionalString(request.request.turnSourceTo) ?? "";
+            const turnSourceTo = normalizeMeetOriginChannelId(rawTurnSourceTo);
+            const threadId = normalizeMeetThreadId(request.request.turnSourceThreadId) ??
+                normalizeMeetThreadId(sessionConversation?.threadId) ??
+                undefined;
+            const hasExplicitOriginTarget = /^(?:channel):/i.test(rawTurnSourceTo);
+            if (turnSourceChannel !== "meet" || !turnSourceTo || sessionKind === "dm") {
+                return null;
+            }
+            return hasExplicitOriginTarget || sessionKind === "channel" || sessionKind === "group"
+                ? { to: turnSourceTo, threadId }
+                : null;
+        },
+        resolveSessionTarget: (sessionTarget, request) => {
+            const sessionConversation = resolveApprovalRequestSessionConversation({
+                request,
+                channel: "meet",
+                bundledFallback: false,
+            });
+            const sessionKind = extractMeetSessionKind(request.request.sessionKey?.trim() || null);
+            if (sessionKind === "dm") {
+                return null;
+            }
+            const targetTo = normalizeMeetOriginChannelId(sessionTarget.to);
+            return targetTo
+                ? {
+                    to: targetTo,
+                    threadId: normalizeMeetThreadId(sessionTarget.threadId) ??
+                        normalizeMeetThreadId(sessionConversation?.threadId) ??
+                        undefined,
+                }
+                : null;
+        },
+        resolveFallbackTarget: (request) => {
+            const sessionConversation = resolveApprovalRequestSessionConversation({
+                request,
+                channel: "meet",
+                bundledFallback: false,
+            });
+            const sessionKind = extractMeetSessionKind(request.request.sessionKey?.trim() || null);
+            if (sessionKind === "dm") {
+                return null;
+            }
+            const fallbackChannelId = normalizeMeetOriginChannelId(sessionConversation?.id);
+            return fallbackChannelId
+                ? {
+                    to: fallbackChannelId,
+                    threadId: normalizeMeetThreadId(sessionConversation?.threadId) ?? undefined,
+                }
+                : null;
+        },
+    });
+}
+function createMeetApproverDmTargetResolver(configOverride) {
+    return createChannelApproverDmTargetResolver({
+        shouldHandleRequest: ({ cfg, accountId, request }) => shouldHandleMeetApprovalRequest({
+            cfg,
+            accountId,
+            request,
+        }),
+        resolveApprovers: ({ cfg, accountId }) => getMeetExecApprovalApprovers({ cfg, accountId, configOverride }),
+        mapApprover: (approver) => ({ to: `user:${approver}` }),
+    });
+}
+function buildMeetPendingPayload(params) {
+    if (params.view.approvalKind !== "exec") {
+        return {
+            text: params.view.title,
+        };
+    }
+    const payload = buildExecApprovalPendingReplyPayload({
+        approvalId: params.request.id,
+        approvalSlug: params.request.id.slice(0, 8),
+        approvalCommandId: params.request.id,
+        warningText: params.view.warningText ?? normalizeOptionalString(params.request.request.warningText) ?? undefined,
+        ask: params.view.ask ?? normalizeOptionalString(params.request.request.ask) ?? undefined,
+        agentId: params.view.agentId ?? normalizeOptionalString(params.request.request.agentId) ?? undefined,
+        allowedDecisions: params.view.actions.map((action) => action.decision),
+        command: params.view.commandText,
+        cwd: params.view.cwd ?? normalizeOptionalString(params.request.request.cwd) ?? undefined,
+        host: params.view.host === "node" ? "node" : "gateway",
+        nodeId: params.view.nodeId ?? normalizeOptionalString(params.request.request.nodeId) ?? undefined,
+        sessionKey: params.view.sessionKey ?? normalizeOptionalString(params.request.request.sessionKey) ?? undefined,
+        expiresAtMs: params.request.expiresAtMs,
+        nowMs: params.nowMs,
+    });
+    const reason = params.view.ask?.trim();
+    const text = reason ? `${reason}\n\n${payload.text ?? ""}` : (payload.text ?? "");
+    return {
+        text,
+    };
+}
+export const meetApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+    eventKinds: ["exec", "plugin"],
+    availability: {
+        isConfigured: ({ cfg, accountId }) => isMeetExecApprovalClientEnabled({ cfg, accountId }),
+        shouldHandle: ({ cfg, accountId, request }) => shouldHandleMeetApprovalRequest({
+            cfg,
+            accountId,
+            request,
+        }),
+    },
+    presentation: {
+        buildPendingPayload: ({ request, nowMs, view }) => buildMeetPendingPayload({
+            request: request,
+            nowMs,
+            view,
+        }),
+        buildResolvedResult: () => ({ kind: "leave" }),
+        buildExpiredResult: () => ({ kind: "leave" }),
+    },
+    transport: {
+        prepareTarget: ({ plannedTarget }) => ({
+            dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+            target: {
+                to: plannedTarget.surface === "approver-dm" && !/^user:/i.test(plannedTarget.target.to)
+                    ? `user:${plannedTarget.target.to}`
+                    : plannedTarget.target.to,
+                ...(plannedTarget.target.threadId != null
+                    ? { threadId: String(plannedTarget.target.threadId) }
+                    : {}),
+            },
+        }),
+        deliverPending: async ({ cfg, accountId, preparedTarget, pendingPayload }) => {
+            try {
+                const result = await sendMessageMeet({
+                    cfg: cfg,
+                    to: preparedTarget.to,
+                    text: pendingPayload.text,
+                    accountId: accountId ?? undefined,
+                    threadId: preparedTarget.threadId,
+                });
+                return {
+                    chatId: result.chatId,
+                    messageId: result.messageId,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+    },
+});
+function createMeetApprovalCapability(configOverride) {
+    return createApproverRestrictedNativeApprovalCapability({
+        channel: "meet",
+        channelLabel: "Meet",
+        describeExecApprovalSetup: ({ accountId, }) => {
+            const prefix = accountId && accountId !== "default"
+                ? `channels.meet.accounts.${accountId}`
+                : "channels.meet";
+            return `Approve it from the Web UI or terminal UI for now. Meet supports native exec approvals for this account. Configure \`${prefix}.execApprovals.approvers\` or \`commands.ownerAllowFrom\`; set \`${prefix}.execApprovals.enabled\` to \`auto\` or \`true\`.`;
+        },
+        listAccountIds: listMeetAccountIds,
+        hasApprovers: ({ cfg, accountId }) => getMeetExecApprovalApprovers({ cfg, accountId, configOverride }).length > 0,
+        isExecAuthorizedSender: ({ cfg, accountId, senderId }) => isMeetExecApprovalApprover({ cfg, accountId, senderId, configOverride }),
+        isNativeDeliveryEnabled: ({ cfg, accountId }) => isMeetExecApprovalClientEnabled({ cfg, accountId, configOverride }),
+        resolveNativeDeliveryMode: ({ cfg, accountId }) => configOverride?.target ??
+            resolveMeetAccount({ cfg, accountId }).config.execApprovals?.target ??
+            "dm",
+        resolveOriginTarget: createMeetOriginTargetResolver(configOverride),
+        resolveApproverDmTargets: createMeetApproverDmTargetResolver(configOverride),
+        notifyOriginWhenDmOnly: true,
+        nativeRuntime: meetApprovalNativeRuntime,
+    });
+}
+export function createMeetNativeApprovalAdapter(configOverride) {
+    return splitChannelApprovalCapability(createMeetApprovalCapability(configOverride));
+}
+let cachedMeetApprovalCapability;
+export function getMeetApprovalCapability() {
+    cachedMeetApprovalCapability ??= createMeetApprovalCapability();
+    return cachedMeetApprovalCapability;
+}

package/dist/src/channel.js

@@ -7,6 +7,7 @@ import { sendMessageMeet } from "./send.js";
 import { getMeetClient } from "./client.js";
 import { getAllCachedUsers, rememberMeetUser } from "./directory-cache.js";
 import { MeetPluginConfigSchema } from "./config-schema.js";
+import { getMeetApprovalCapability } from "./approval-native.js";
 const meta = {
     id: "meet",
     label: "Meet",
@@ -298,6 +299,7 @@ export const meetPlugin = {
         listGroupsLive: async () => [],
     },
     outbound: meetOutbound,
+    approvalCapability: getMeetApprovalCapability(),
     status: {
         defaultRuntime: {
             accountId: DEFAULT_ACCOUNT_ID,

package/dist/src/config-schema.d.ts

@@ -16,6 +16,17 @@ export declare const MeetGroupConfigSchema: z.ZodObject<{
         disabled: "disabled";
     }>>;
 }, z.core.$strip>;
+export declare const MeetExecApprovalConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    target: z.ZodOptional<z.ZodEnum<{
+        dm: "dm";
+        channel: "channel";
+        both: "both";
+    }>>;
+    agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare const MeetAccountConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
@@ -63,6 +74,17 @@ export declare const MeetAccountConfigSchema: z.ZodObject<{
             disabled: "disabled";
         }>>;
     }, z.core.$strip>>>;
+    execApprovals: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            dm: "dm";
+            channel: "channel";
+            both: "both";
+        }>>;
+        agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const MeetConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
@@ -163,6 +185,28 @@ export declare const MeetConfigSchema: z.ZodObject<{
                 disabled: "disabled";
             }>>;
         }, z.core.$strip>>>;
+        execApprovals: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+            approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            target: z.ZodOptional<z.ZodEnum<{
+                dm: "dm";
+                channel: "channel";
+                both: "both";
+            }>>;
+            agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    execApprovals: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            dm: "dm";
+            channel: "channel";
+            both: "both";
+        }>>;
+        agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const MeetPluginConfigSchema: import("openclaw/plugin-sdk").ChannelConfigSchema;

package/dist/src/config-schema.js

@@ -13,6 +13,13 @@ export const MeetGroupConfigSchema = z.object({
     users: z.array(z.union([z.string(), z.number()])).optional(),
     groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional(),
 });
+export const MeetExecApprovalConfigSchema = z.object({
+    enabled: z.union([z.boolean(), z.literal("auto")]).optional(),
+    approvers: z.array(z.union([z.string(), z.number()])).optional(),
+    target: z.enum(["dm", "channel", "both"]).optional(),
+    agentFilter: z.array(z.string()).optional(),
+    sessionFilter: z.array(z.string()).optional(),
+});
 export const MeetAccountConfigSchema = z.object({
     enabled: z.boolean().optional(),
     name: z.string().optional(),
@@ -34,6 +41,7 @@ export const MeetAccountConfigSchema = z.object({
     mediaMaxMb: z.number().min(0).optional(),
     typingMode: z.enum(["none", "instant", "message"]).optional(),
     groups: z.record(z.string(), MeetGroupConfigSchema).optional(),
+    execApprovals: MeetExecApprovalConfigSchema.optional(),
 });
 export const MeetConfigSchema = z.object({
     enabled: z.boolean().optional(),
@@ -58,5 +66,6 @@ export const MeetConfigSchema = z.object({
     mediaMaxMb: z.number().min(0).optional(),
     typingMode: z.enum(["none", "instant", "message"]).optional(),
     accounts: z.record(z.string(), MeetAccountConfigSchema).optional(),
+    execApprovals: MeetExecApprovalConfigSchema.optional(),
 });
 export const MeetPluginConfigSchema = buildChannelConfigSchema(MeetConfigSchema);

package/dist/src/exec-approvals.d.ts

@@ -0,0 +1,26 @@
+import type { ChannelOutboundPayloadHint } from "openclaw/plugin-sdk/channel-contract";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import type { ReplyPayload } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import type { MeetExecApprovalConfig } from "./types.js";
+export declare function getMeetExecApprovalApprovers(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    configOverride?: MeetExecApprovalConfig | null;
+}): string[];
+export declare function isMeetExecApprovalClientEnabled(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    configOverride?: MeetExecApprovalConfig | null;
+}): boolean;
+export declare function isMeetExecApprovalApprover(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    senderId?: string | null;
+    configOverride?: MeetExecApprovalConfig | null;
+}): boolean;
+export declare function shouldSuppressLocalMeetExecApprovalPrompt(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    payload: ReplyPayload;
+    hint?: ChannelOutboundPayloadHint;
+}): boolean;

package/dist/src/exec-approvals.js

@@ -0,0 +1,71 @@
+import { resolveMeetAccount } from "./accounts.js";
+import { getExecApprovalReplyMetadata, isChannelExecApprovalClientEnabledFromConfig, matchesApprovalRequestFilters, resolveApprovalApprovers, } from "openclaw/plugin-sdk/approval-runtime";
+function normalizeMeetApproverId(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // Meet 用户ID是数字
+    if (/^-?\d+$/.test(trimmed)) {
+        return trimmed;
+    }
+    // 支持 user:ID 格式
+    const match = trimmed.match(/^user:(-?\d+)$/i);
+    return match ? match[1] : undefined;
+}
+function resolveMeetOwnerApprovers(cfg) {
+    const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+    if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) {
+        return [];
+    }
+    return resolveApprovalApprovers({
+        explicit: ownerAllowFrom,
+        normalizeApprover: (value) => normalizeMeetApproverId(String(value)),
+    });
+}
+export function getMeetExecApprovalApprovers(params) {
+    return resolveApprovalApprovers({
+        explicit: params.configOverride?.approvers ??
+            resolveMeetAccount(params).config.execApprovals?.approvers ??
+            resolveMeetOwnerApprovers(params.cfg),
+        normalizeApprover: (value) => normalizeMeetApproverId(String(value)),
+    });
+}
+export function isMeetExecApprovalClientEnabled(params) {
+    const config = params.configOverride ?? resolveMeetAccount(params).config.execApprovals;
+    return isChannelExecApprovalClientEnabledFromConfig({
+        enabled: config?.enabled,
+        approverCount: getMeetExecApprovalApprovers({
+            cfg: params.cfg,
+            accountId: params.accountId,
+            configOverride: params.configOverride,
+        }).length,
+    });
+}
+export function isMeetExecApprovalApprover(params) {
+    const senderId = params.senderId?.trim();
+    if (!senderId) {
+        return false;
+    }
+    return getMeetExecApprovalApprovers({
+        cfg: params.cfg,
+        accountId: params.accountId,
+        configOverride: params.configOverride,
+    }).includes(senderId);
+}
+export function shouldSuppressLocalMeetExecApprovalPrompt(params) {
+    const metadata = getExecApprovalReplyMetadata(params.payload);
+    const config = resolveMeetAccount(params).config.execApprovals;
+    return (params.hint?.kind === "approval-pending" &&
+        params.hint.nativeRouteActive === true &&
+        isMeetExecApprovalClientEnabled(params) &&
+        metadata !== null &&
+        matchesApprovalRequestFilters({
+            request: {
+                agentId: metadata.agentId,
+                sessionKey: metadata.sessionKey,
+            },
+            agentFilter: config?.agentFilter,
+            sessionFilter: config?.sessionFilter,
+        }));
+}

package/dist/src/generated/plugin-build-meta.d.ts

@@ -1,2 +1,2 @@
-export declare const MEET_PLUGIN_VERSION = "3.4.5";
+export declare const MEET_PLUGIN_VERSION = "3.5.0";
 export declare const MEET_OPENCLAW_VERSION = "2026.5.18";

package/dist/src/generated/plugin-build-meta.js

@@ -1,2 +1,2 @@
-export const MEET_PLUGIN_VERSION = "3.4.5";
+export const MEET_PLUGIN_VERSION = "3.5.0";
 export const MEET_OPENCLAW_VERSION = "2026.5.18";

package/dist/src/outbound.js

@@ -1,5 +1,6 @@
 import { getMeetRuntime } from "./runtime.js";
 import { sendMessageMeet, sendMediaMeet } from "./send.js";
+import { shouldSuppressLocalMeetExecApprovalPrompt } from "./exec-approvals.js";
 export const meetOutbound = {
     deliveryMode: "direct",
     chunker: (text, limit) => {
@@ -31,4 +32,12 @@ export const meetOutbound = {
         });
         return { channel: "meet", messageId: result.messageId, chatId: result.chatId };
     },
+    shouldSuppressLocalPayloadPrompt: (params) => {
+        return shouldSuppressLocalMeetExecApprovalPrompt({
+            cfg: params.cfg,
+            accountId: params.accountId,
+            payload: params.payload,
+            hint: params.hint,
+        });
+    },
 };

package/dist/src/send.d.ts

@@ -20,6 +20,7 @@ export type SendMessageMeetOpts = {
     to: string;
     text: string;
     accountId?: string;
+    threadId?: string;
     replyToMessageId?: string;
     atIds?: number[];
     /** Optional runtime for consistent logging. If not provided, falls back to console. */

package/dist/src/send.js

@@ -123,7 +123,7 @@ export function mergeAtIds(explicitAtIds, extractedAtIds) {
     return [...new Set([...(explicitAtIds ?? []), ...(extractedAtIds ?? [])])];
 }
 export async function sendMessageMeet(opts) {
-    const { cfg, to, text, accountId, atIds: explicitAtIds, runtime } = opts;
+    const { cfg, to, text, accountId, threadId, atIds: explicitAtIds, runtime } = opts;
     const log = runtime?.log ?? console.log;
     const logError = runtime?.error ?? console.error;
     const account = resolveMeetAccount({ cfg, accountId });
@@ -170,8 +170,14 @@ export async function sendMessageMeet(opts) {
     const finalAtIds = mergeAtIds(explicitAtIds, extractedAtIds);
     log(`send message to=${to} atIds=${finalAtIds.join(",") || "none"}`);
     const sessionInfo = parseTargetToSessionInfo(to, Number(botUserId));
+    const finalSessionInfo = threadId && sessionInfo.sessionType === 3
+        ? {
+            ...sessionInfo,
+            threadId: Number(threadId),
+        }
+        : sessionInfo;
     try {
-        const result = await bot.sendMessage(sessionInfo, {
+        const result = await bot.sendMessage(finalSessionInfo, {
             content: cleanText,
             atIds: finalAtIds,
         });

package/dist/src/types.d.ts

@@ -1,10 +1,11 @@
 import type { SessionInfo, AttachmentInfo, UploadProgress } from "@meet-im/meet-bot-jssdk";
 import type { z } from "zod";
-import { MeetConfigSchema, MeetAccountConfigSchema, MeetChannelConfigSchema, MeetGroupConfigSchema } from "./config-schema.js";
+import { MeetConfigSchema, MeetAccountConfigSchema, MeetChannelConfigSchema, MeetGroupConfigSchema, MeetExecApprovalConfigSchema } from "./config-schema.js";
 export type MeetConfig = z.infer<typeof MeetConfigSchema>;
 export type MeetAccountConfig = z.infer<typeof MeetAccountConfigSchema>;
 export type MeetChannelConfig = z.infer<typeof MeetChannelConfigSchema>;
 export type MeetGroupConfig = z.infer<typeof MeetGroupConfigSchema>;
+export type MeetExecApprovalConfig = z.infer<typeof MeetExecApprovalConfigSchema>;
 export type { AttachmentInfo, UploadProgress };
 export type ResolvedMeetAccount = {
     accountId: string;

package/openclaw.plugin.json

@@ -28,6 +28,22 @@
             "type": "array",
             "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
           },
+          "execApprovals": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": {
+                "anyOf": [{ "type": "boolean" }, { "type": "string", "const": "auto" }]
+              },
+              "approvers": {
+                "type": "array",
+                "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+              },
+              "target": { "type": "string", "enum": ["dm", "channel", "both"] },
+              "agentFilter": { "type": "array", "items": { "type": "string" } },
+              "sessionFilter": { "type": "array", "items": { "type": "string" } }
+            }
+          },
           "requireMention": { "type": "boolean" },
           "systemPrompt": { "type": "string" },
           "channels": {
@@ -88,6 +104,22 @@
                   "type": "array",
                   "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
                 },
+                "execApprovals": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "enabled": {
+                      "anyOf": [{ "type": "boolean" }, { "type": "string", "const": "auto" }]
+                    },
+                    "approvers": {
+                      "type": "array",
+                      "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+                    },
+                    "target": { "type": "string", "enum": ["dm", "channel", "both"] },
+                    "agentFilter": { "type": "array", "items": { "type": "string" } },
+                    "sessionFilter": { "type": "array", "items": { "type": "string" } }
+                  }
+                },
                 "requireMention": { "type": "boolean" },
                 "systemPrompt": { "type": "string" },
                 "historyLimit": { "type": "number", "minimum": 0 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meet-im/meet",
-  "version": "3.4.5",
+  "version": "3.5.0",
   "type": "module",
   "description": "OpenClaw Meet channel plugin",
   "scripts": {