@aspalagin/openclaw-max 0.7.2

package/dist/src/accounts.js

@@ -0,0 +1,148 @@
+/**
+ * MAX account resolution — reads config and produces a resolved account object.
+ */
+import { lstatSync, readFileSync } from 'node:fs';
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from 'openclaw/plugin-sdk/core';
+/**
+ * Get the MAX channel section from config.
+ */
+function getMaxSection(cfg) {
+    return cfg.channels?.max;
+}
+/** Read a secret from a regular (non-symlink) file; "" when missing or unreadable. */
+export function readSecretFile(filePath) {
+    return readTokenFile(filePath);
+}
+function readTokenFile(tokenFile) {
+    const filePath = tokenFile?.trim();
+    if (!filePath)
+        return '';
+    try {
+        const stat = lstatSync(filePath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return '';
+        return readFileSync(filePath, 'utf8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * List all MAX account IDs from config.
+ */
+export function listMaxAccountIds(cfg) {
+    const section = getMaxSection(cfg);
+    if (!section)
+        return [];
+    const ids = [];
+    // Check for default account (top-level botToken)
+    const hasDefault = section.botToken || section.tokenFile || process.env.MAX_BOT_TOKEN;
+    if (hasDefault)
+        ids.push(DEFAULT_ACCOUNT_ID);
+    // Check for named accounts
+    const accounts = section.accounts;
+    if (accounts) {
+        for (const key of Object.keys(accounts)) {
+            const normalized = normalizeAccountId(key);
+            if (normalized !== DEFAULT_ACCOUNT_ID && !ids.includes(normalized)) {
+                ids.push(normalized);
+            }
+        }
+    }
+    // If section exists but no token sources found, still return default
+    if (ids.length === 0 && section.enabled !== false) {
+        ids.push(DEFAULT_ACCOUNT_ID);
+    }
+    return ids;
+}
+/**
+ * Resolve the default account ID.
+ */
+export function resolveDefaultMaxAccountId(_cfg) {
+    return DEFAULT_ACCOUNT_ID;
+}
+/**
+ * Resolve a single MAX account from config.
+ */
+export function resolveMaxAccount(params) {
+    const { cfg, accountId: rawId } = params;
+    const accountId = rawId ? normalizeAccountId(rawId) : DEFAULT_ACCOUNT_ID;
+    const section = getMaxSection(cfg) ?? {};
+    const accounts = section.accounts;
+    let accountConfig;
+    let token = '';
+    let tokenSource = 'none';
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        // Default account: top-level config
+        accountConfig = {
+            enabled: section.enabled !== false,
+            botToken: section.botToken,
+            tokenFile: section.tokenFile,
+            name: section.name,
+            dmPolicy: section.dmPolicy,
+            allowFrom: section.allowFrom,
+            groups: section.groups,
+            groupPolicy: section.groupPolicy,
+            groupAllowFrom: section.groupAllowFrom,
+            transport: section.transport,
+            webhookUrl: section.webhookUrl,
+            webhookSecret: section.webhookSecret,
+            webhookSecretFile: section.webhookSecretFile,
+            webhookPath: section.webhookPath,
+            mediaMaxMb: section.mediaMaxMb,
+            streamMode: section.streamMode,
+            markSeen: section.markSeen,
+        };
+        if (accountConfig.botToken?.trim()) {
+            token = accountConfig.botToken.trim();
+            tokenSource = 'config';
+        }
+        else if (accountConfig.tokenFile?.trim()) {
+            token = readTokenFile(accountConfig.tokenFile);
+            tokenSource = token ? 'file' : 'none';
+        }
+        if (!token && process.env.MAX_BOT_TOKEN?.trim()) {
+            token = process.env.MAX_BOT_TOKEN.trim();
+            tokenSource = 'env';
+        }
+    }
+    else {
+        // Named account
+        const raw = accounts?.[accountId] ?? {};
+        accountConfig = {
+            enabled: raw.enabled !== false,
+            botToken: raw.botToken,
+            tokenFile: raw.tokenFile,
+            name: raw.name,
+            dmPolicy: raw.dmPolicy,
+            allowFrom: raw.allowFrom,
+            groups: raw.groups,
+            groupPolicy: raw.groupPolicy,
+            groupAllowFrom: raw.groupAllowFrom,
+            transport: raw.transport,
+            webhookUrl: raw.webhookUrl,
+            webhookSecret: raw.webhookSecret,
+            webhookSecretFile: raw.webhookSecretFile,
+            webhookPath: raw.webhookPath,
+            mediaMaxMb: raw.mediaMaxMb,
+            streamMode: raw.streamMode,
+            markSeen: raw.markSeen,
+        };
+        if (accountConfig.botToken?.trim()) {
+            token = accountConfig.botToken.trim();
+            tokenSource = 'config';
+        }
+        else if (accountConfig.tokenFile?.trim()) {
+            token = readTokenFile(accountConfig.tokenFile);
+            tokenSource = token ? 'file' : 'none';
+        }
+    }
+    return {
+        accountId,
+        name: accountConfig.name,
+        enabled: accountConfig.enabled ?? true,
+        token,
+        tokenSource,
+        config: accountConfig,
+    };
+}

package/dist/src/actions.js

@@ -0,0 +1,421 @@
+/**
+ * MAX channel message actions adapter — implements message tool actions
+ */
+import { normalizeMessagePresentation } from 'openclaw/plugin-sdk/interactive-runtime';
+import { readStringParam } from 'openclaw/plugin-sdk/param-readers';
+import { jsonResult } from 'openclaw/plugin-sdk/tool-results';
+import { listMaxAccountIds, resolveMaxAccount } from './accounts.js';
+import { materializeMaxPresentation, MAX_TEXT_LIMIT, readMaxDeliveryPin } from './presentation.js';
+import { getMaxRuntime } from './runtime.js';
+import { deleteMaxMessage, editMaxMessage, pinMaxMessage, readMaxChannelButtons, readMaxSendButtons, sendMaxContact, sendMaxLocation, sendMaxMediaGroup, sendMaxMediaMessage, sendMaxMessage, sendMaxSticker, unpinMaxMessage, } from './send.js';
+import { getLastStickerCode } from './sticker-cache.js';
+const providerId = 'max';
+const mediaSourceKeys = ['media', 'filePath', 'path', 'fileUrl', 'url', 'buffer', 'image'];
+function listEnabledAccounts(cfg) {
+    return listMaxAccountIds(cfg)
+        .map((accountId) => resolveMaxAccount({ cfg, accountId }))
+        .filter((account) => account.enabled && account.token);
+}
+function readTargetParam(params, required = true) {
+    return (readStringParam(params, 'to') ??
+        readStringParam(params, 'target') ??
+        readStringParam(params, 'chatId') ??
+        readStringParam(params, 'channelId', { required }));
+}
+/**
+ * Media sources in order: the direct media field first, then every
+ * structured `attachments[]` item (one source per item). Duplicates dropped.
+ */
+function readMediaSources(params) {
+    const sources = [];
+    const add = (value) => {
+        if (value && !sources.includes(value))
+            sources.push(value);
+    };
+    for (const key of mediaSourceKeys) {
+        const value = readStringParam(params, key, { trim: false });
+        if (value) {
+            add(value);
+            break;
+        }
+    }
+    if (Array.isArray(params.attachments)) {
+        for (const item of params.attachments) {
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                continue;
+            const attachment = item;
+            for (const key of mediaSourceKeys) {
+                const value = typeof attachment[key] === 'string' ? attachment[key] : undefined;
+                if (value) {
+                    add(value);
+                    break;
+                }
+            }
+        }
+    }
+    return sources;
+}
+/**
+ * Send one or more media sources: one goes as a single message, several as
+ * albums (up to 12 images/videos per message, audio/files one by one, order
+ * kept). Returns every sent message id; the first one carries the caption.
+ */
+async function sendMaxMediaSources(to, caption, sources, opts) {
+    if (sources.length === 1) {
+        const result = await sendMaxMediaMessage(to, caption, sources[0], opts);
+        return {
+            messageId: result.messageId,
+            messageIds: result.messageId ? [result.messageId] : [],
+            chatType: result.raw.message?.recipient?.chat_type,
+        };
+    }
+    // A failed group must not hide the ones already sent (a retry by the agent
+    // would duplicate them): report partial failures, throw only when none went.
+    const errors = [];
+    let firstError;
+    const { messageIds } = await sendMaxMediaGroup(to, caption, sources, {
+        ...opts,
+        onError: (err, failed) => {
+            firstError ??= err;
+            errors.push(`${failed.join(', ')}: ${String(err)}`);
+        },
+    });
+    if (messageIds.length === 0 && firstError !== undefined)
+        throw firstError;
+    return {
+        messageId: messageIds[0] ?? '',
+        messageIds,
+        ...(errors.length ? { mediaErrors: errors } : {}),
+    };
+}
+/** messageIds / mediaErrors for a multi-message media send. */
+function mediaResultExtra(result) {
+    return {
+        ...(result.messageIds.length > 1 ? { messageIds: result.messageIds } : {}),
+        ...(result.mediaErrors ? { mediaErrors: result.mediaErrors } : {}),
+    };
+}
+/**
+ * Coordinates from `latitude`+`longitude` (both required) or a
+ * `location: "LAT,LNG"` / "LAT LNG" string; undefined when absent or not
+ * numeric.
+ */
+function readLocationParams(params) {
+    let lat;
+    let lng;
+    if (params.latitude != null && params.longitude != null) {
+        lat = parseFloat(String(params.latitude));
+        lng = parseFloat(String(params.longitude));
+    }
+    else {
+        const locationStr = readStringParam(params, 'location');
+        const m = locationStr?.match(/(-?\d+\.?\d*)[,\s]+(-?\d+\.?\d*)/);
+        if (m) {
+            lat = parseFloat(m[1]);
+            lng = parseFloat(m[2]);
+        }
+    }
+    if (lat == null || lng == null || isNaN(lat) || isNaN(lng))
+        return undefined;
+    return { latitude: lat, longitude: lng };
+}
+/** Contact card fields: contactId (MAX user id) and vcfPhone/phone next to the given name. */
+function readContactParams(params, name) {
+    const contactId = params.contactId != null ? Number(params.contactId) : undefined;
+    const vcfPhone = readStringParam(params, 'vcfPhone') ?? readStringParam(params, 'phone');
+    return {
+        name,
+        contactId: contactId && !isNaN(contactId) ? contactId : undefined,
+        vcfPhone: vcfPhone ?? undefined,
+    };
+}
+export const maxMessageActions = {
+    describeMessageTool: ({ cfg }) => {
+        const accounts = listEnabledAccounts(cfg);
+        if (accounts.length === 0) {
+            return null;
+        }
+        return {
+            actions: ['send', 'edit', 'delete', 'sticker', 'sendAttachment', 'pin', 'unpin'],
+            // presentation → inline keyboard + MAX markdown (presentation.ts);
+            // delivery-pin → PUT /chats/{chatId}/pin on the sent message.
+            capabilities: ['presentation', 'delivery-pin'],
+        };
+    },
+    extractToolSend: ({ args }) => {
+        // Extract routing info for ALL actions (send, edit, delete, sticker)
+        // Core uses extractToolSend for routing all message tool actions to plugin
+        let to = typeof args.target === 'string'
+            ? args.target
+            : typeof args.to === 'string'
+                ? args.to
+                : typeof args.chatId === 'string'
+                    ? args.chatId
+                    : typeof args.channelId === 'string'
+                        ? args.channelId
+                        : undefined;
+        if (!to) {
+            // For edit/delete, target may not be present — use a placeholder
+            // so core still routes to this plugin's handleAction
+            to = typeof args.messageId === 'string' ? '__message_action__' : undefined;
+        }
+        if (!to) {
+            return null;
+        }
+        // Strip provider prefix (e.g. "max:188862440" → "188862440")
+        if (to.startsWith('max:'))
+            to = to.slice(4);
+        const accountId = typeof args.accountId === 'string' ? args.accountId.trim() : undefined;
+        return { to, accountId };
+    },
+    handleAction: async ({ action, params, cfg, accountId }) => {
+        const account = resolveMaxAccount({
+            cfg,
+            accountId,
+        });
+        if (!account.token) {
+            throw new Error('MAX bot token not configured');
+        }
+        // Strip provider prefix from target (e.g. "max:188862440" → "188862440")
+        const stripPrefix = (val) => {
+            if (!val)
+                return val;
+            return val.startsWith('max:') ? val.slice(4) : val;
+        };
+        if (action === 'send') {
+            const to = stripPrefix(readTargetParam(params));
+            const presentation = normalizeMessagePresentation(params.presentation);
+            const pin = readMaxDeliveryPin(params.delivery, params.pin);
+            const content = readStringParam(params, 'message', {
+                required: !presentation,
+                allowEmpty: true,
+            }) ?? '';
+            // Pin the sent message when delivery.pin (or pin=true) was requested.
+            // Optional pin failures degrade; a required one fails the action.
+            // Dialogs cannot pin: that is reported as pinned:false with pinSkipped.
+            const withPin = async (messageId, chatType, extra = {}) => {
+                if (!pin || !messageId)
+                    return jsonResult({ ok: true, to, messageId, ...extra });
+                try {
+                    const pinned = await pinMaxMessage(to, messageId, {
+                        token: account.token,
+                        pinNotify: pin.notify === true,
+                        chatType,
+                    });
+                    if (!pinned.pinned) {
+                        return jsonResult({
+                            ok: true,
+                            to,
+                            messageId,
+                            ...extra,
+                            pinned: false,
+                            pinSkipped: pinned.reason,
+                        });
+                    }
+                    return jsonResult({ ok: true, to, messageId, ...extra, pinned: true });
+                }
+                catch (err) {
+                    if (pin.required)
+                        throw err;
+                    return jsonResult({
+                        ok: true,
+                        to,
+                        messageId,
+                        ...extra,
+                        pinned: false,
+                        pinError: String(err),
+                    });
+                }
+            };
+            // Core normally renders presentation through the outbound adapter; this
+            // path covers direct plugin dispatch with the same render policy.
+            if (presentation) {
+                const rendered = await materializeMaxPresentation({ text: content, presentation });
+                const renderedButtons = readMaxChannelButtons(rendered.channelData);
+                const text = rendered.text ?? '';
+                const chunks = text.length > MAX_TEXT_LIMIT
+                    ? getMaxRuntime().channel.text.chunkMarkdownText(text, MAX_TEXT_LIMIT)
+                    : [text];
+                let firstMessageId = '';
+                let firstChatType;
+                for (let index = 0; index < chunks.length; index += 1) {
+                    const sent = await sendMaxMessage(to, chunks[index], {
+                        token: account.token,
+                        replyToMessageId: index === 0 ? (readStringParam(params, 'replyTo') ?? undefined) : undefined,
+                        format: 'markdown',
+                        buttons: index === chunks.length - 1 ? renderedButtons : undefined,
+                    });
+                    if (index === 0) {
+                        firstMessageId = sent.messageId;
+                        firstChatType = sent.raw.message?.recipient?.chat_type;
+                    }
+                }
+                return withPin(firstMessageId, firstChatType);
+            }
+            const replyTo = readStringParam(params, 'replyTo');
+            const stickerId = readStringParam(params, 'stickerId');
+            // Inline keyboard buttons: [[{text, type?, payload?|callback_data?, url?, webApp?}]]
+            // type: callback (default) | link | message | clipboard | open_app | request_contact | request_geo_location
+            const buttons = readMaxSendButtons(params.buttons);
+            // Sticker sending (by sticker code)
+            if (stickerId) {
+                // stickerId can be a single id or comma-separated
+                const codes = Array.isArray(params.stickerId)
+                    ? params.stickerId
+                    : [stickerId];
+                const firstCode = codes[0];
+                if (firstCode) {
+                    const result = await sendMaxSticker(to, firstCode, {
+                        token: account.token,
+                        replyToMessageId: replyTo ?? undefined,
+                    });
+                    return withPin(result.messageId, result.raw.message?.recipient?.chat_type);
+                }
+            }
+            // Location sending: coordinates from latitude/longitude or location="LAT,LNG"
+            const location = readLocationParams(params);
+            if (location) {
+                const result = await sendMaxLocation(to, location, content || undefined, {
+                    token: account.token,
+                    replyToMessageId: replyTo ?? undefined,
+                    format: 'markdown',
+                });
+                return withPin(result.messageId, result.raw.message?.recipient?.chat_type);
+            }
+            // Contact sending: if contactName param exists
+            const contactName = readStringParam(params, 'contactName');
+            if (contactName) {
+                const result = await sendMaxContact(to, readContactParams(params, contactName), {
+                    token: account.token,
+                    replyToMessageId: replyTo ?? undefined,
+                });
+                return withPin(result.messageId, result.raw.message?.recipient?.chat_type);
+            }
+            // Media: direct media fields and every structured attachments[] item.
+            const mediaSources = readMediaSources(params);
+            if (mediaSources.length) {
+                // Local path or URL: https image links go by URL, other remote media
+                // is downloaded to a temp file and uploaded.
+                const result = await sendMaxMediaSources(to, content, mediaSources, {
+                    token: account.token,
+                    replyToMessageId: replyTo ?? undefined,
+                    format: 'markdown',
+                    mediaMaxBytes: (account.config.mediaMaxMb ?? 20) * 1024 * 1024,
+                });
+                return withPin(result.messageId, result.chatType, mediaResultExtra(result));
+            }
+            const result = await sendMaxMessage(to, content, {
+                token: account.token,
+                replyToMessageId: replyTo ?? undefined,
+                format: 'markdown',
+                buttons,
+            });
+            return withPin(result.messageId, result.raw.message?.recipient?.chat_type);
+        }
+        if (action === 'edit') {
+            const messageId = readStringParam(params, 'messageId', { required: true });
+            const text = readStringParam(params, 'message', {
+                required: true,
+                allowEmpty: true,
+            });
+            await editMaxMessage(messageId, text, {
+                token: account.token,
+                format: 'markdown',
+            });
+            return jsonResult({ ok: true, messageId });
+        }
+        if (action === 'delete') {
+            const messageId = readStringParam(params, 'messageId', { required: true });
+            await deleteMaxMessage(messageId, {
+                token: account.token,
+            });
+            return jsonResult({ ok: true, messageId });
+        }
+        if (action === 'pin') {
+            const to = stripPrefix(readTargetParam(params));
+            const messageId = readStringParam(params, 'messageId', { required: true });
+            const notifyParam = params.notify;
+            const pinned = await pinMaxMessage(to, messageId, {
+                token: account.token,
+                pinNotify: typeof notifyParam === 'boolean' ? notifyParam : undefined,
+            });
+            if (!pinned.pinned) {
+                return jsonResult({ ok: true, to, messageId, pinned: false, reason: pinned.reason });
+            }
+            return jsonResult({ ok: true, to, messageId, pinned: true });
+        }
+        if (action === 'unpin') {
+            const to = stripPrefix(readTargetParam(params));
+            await unpinMaxMessage(to, { token: account.token });
+            return jsonResult({ ok: true, to, pinned: false });
+        }
+        if (action === 'sticker') {
+            const to = stripPrefix(readTargetParam(params));
+            // stickerId may come as string or string[] from message tool schema
+            const rawStickerId = params.stickerId;
+            let stickerCode = Array.isArray(rawStickerId)
+                ? rawStickerId[0]?.trim()
+                : (readStringParam(params, 'stickerId') ?? readStringParam(params, 'fileId'));
+            // Auto-fill from last received sticker if not provided
+            if (!stickerCode) {
+                stickerCode = getLastStickerCode(to) ?? getLastStickerCode() ?? undefined;
+            }
+            if (!stickerCode) {
+                throw new Error('stickerId is required. Send a sticker first, then ask to send it back.');
+            }
+            const replyTo = readStringParam(params, 'replyTo');
+            const result = await sendMaxSticker(to, stickerCode, {
+                token: account.token,
+                replyToMessageId: replyTo ?? undefined,
+            });
+            return jsonResult({ ok: true, to, messageId: result.messageId });
+        }
+        if (action === 'sendAttachment') {
+            const to = stripPrefix(readTargetParam(params));
+            const replyTo = readStringParam(params, 'replyTo');
+            const caption = readStringParam(params, 'message') ?? readStringParam(params, 'caption') ?? '';
+            const attachType = readStringParam(params, 'type') ?? readStringParam(params, 'attachmentType') ?? '';
+            const mediaSources = readMediaSources(params);
+            if (mediaSources.length) {
+                const result = await sendMaxMediaSources(to, caption, mediaSources, {
+                    token: account.token,
+                    replyToMessageId: replyTo ?? undefined,
+                    format: 'markdown',
+                    mediaMaxBytes: (account.config.mediaMaxMb ?? 20) * 1024 * 1024,
+                });
+                return jsonResult({
+                    ok: true,
+                    to,
+                    messageId: result.messageId,
+                    ...mediaResultExtra(result),
+                });
+            }
+            // Location attachment
+            if (attachType === 'location' ||
+                params.latitude != null ||
+                params.longitude != null ||
+                readStringParam(params, 'location')) {
+                const location = readLocationParams(params);
+                if (location) {
+                    const result = await sendMaxLocation(to, location, caption || undefined, {
+                        token: account.token,
+                        replyToMessageId: replyTo ?? undefined,
+                    });
+                    return jsonResult({ ok: true, to, messageId: result.messageId });
+                }
+                throw new Error("Invalid location: provide latitude/longitude or location='LAT,LNG'");
+            }
+            // Contact attachment
+            if (attachType === 'contact' || readStringParam(params, 'contactName')) {
+                const contactName = readStringParam(params, 'contactName') ?? readStringParam(params, 'name') ?? 'Unknown';
+                const result = await sendMaxContact(to, readContactParams(params, contactName), {
+                    token: account.token,
+                    replyToMessageId: replyTo ?? undefined,
+                });
+                return jsonResult({ ok: true, to, messageId: result.messageId });
+            }
+            throw new Error("sendAttachment: unknown type. Use media/filePath for files, or type='location' / type='contact'");
+        }
+        throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+    },
+};