@aspalagin/openclaw-max 0.7.2

package/dist/src/presentation.js

@@ -0,0 +1,374 @@
+/**
+ * MessagePresentation → MAX message (text in MAX markdown + inline_keyboard).
+ *
+ * Contract: docs/plugins/message-presentation.md. Core adapts a presentation to
+ * `MAX_PRESENTATION_CAPABILITIES` and calls `renderMaxPresentation`; the result
+ * is an ordinary payload with `channelData.max.buttons`, sent by sendPayload.
+ * Channel-local funnels (agent replies, the message tool) go through the same
+ * `renderPresentationForDelivery` so they behave identically.
+ *
+ * Presentation actions become transport-private callback payloads (≤1024
+ * bytes) that `decodeMaxPresentationCallback` maps back on `message_callback`:
+ * - command  → the command text itself ("/status"): it re-enters as a user
+ *              message and takes core's native command path;
+ * - callback → "mxcb1:<value>": opaque, delivered to the agent as
+ *              "callback_data: <value>" and never parsed as a slash command;
+ * - approval → "mxa1:<e|p|s>:<o|a|d>:<approvalId>": resolved through the
+ *              canonical approval service (approval-gateway-runtime);
+ * - question → "mxq1:<questionId>:<optionValue>": resolved through
+ *              question-gateway-runtime;
+ * - url / URL-backed web-app → a MAX `link` button.
+ */
+import { renderMessagePresentationFallbackText, renderPresentationForDelivery, resolveMessagePresentationButtonAction, resolveMessagePresentationOptionAction, } from 'openclaw/plugin-sdk/interactive-runtime';
+/** MAX Bot API limits (schema.yaml: Button.text, CallbackButton.payload, InlineKeyboard). */
+export const MAX_BUTTON_TEXT_LIMIT = 128;
+export const MAX_CALLBACK_PAYLOAD_BYTES = 1024;
+export const MAX_KEYBOARD_ROWS = 30;
+export const MAX_KEYBOARD_BUTTONS = 210;
+export const MAX_LINK_URL_LENGTH = 2048;
+export const MAX_TEXT_LIMIT = 4000;
+/** Buttons per row we render: within MAX's 7 (3 for link/open_app/request_*). */
+const BUTTONS_PER_ROW = 3;
+const SELECT_OPTIONS_PER_ROW = 2;
+export const MAX_PRESENTATION_CAPABILITIES = {
+    supported: true,
+    buttons: true,
+    selects: true,
+    context: true,
+    divider: true,
+    // Rendered as monospace text blocks (MAX has no native charts/tables).
+    charts: true,
+    tables: true,
+    limits: {
+        actions: {
+            maxActions: MAX_KEYBOARD_BUTTONS,
+            maxActionsPerRow: BUTTONS_PER_ROW,
+            maxRows: MAX_KEYBOARD_ROWS,
+            maxLabelLength: MAX_BUTTON_TEXT_LIMIT,
+            // Leave room for the private envelope prefix inside the 1024-byte payload.
+            maxValueBytes: 960,
+            supportsStyles: false,
+            supportsDisabled: false,
+        },
+        selects: {
+            maxOptions: 20,
+            maxLabelLength: MAX_BUTTON_TEXT_LIMIT,
+            maxValueBytes: 960,
+        },
+        text: {
+            maxLength: MAX_TEXT_LIMIT,
+            encoding: 'characters',
+            markdownDialect: 'markdown',
+        },
+    },
+};
+// ── Callback envelopes ──
+const CALLBACK_PREFIX = 'mxcb1:';
+const APPROVAL_PREFIX = 'mxa1:';
+const QUESTION_PREFIX = 'mxq1:';
+const APPROVAL_KIND_CODES = {
+    exec: 'e',
+    plugin: 'p',
+    'system-agent': 's',
+};
+const APPROVAL_DECISION_CODES = {
+    'allow-once': 'o',
+    'allow-always': 'a',
+    deny: 'd',
+};
+function fitsPayload(payload) {
+    return payload.length > 0 && Buffer.byteLength(payload, 'utf8') <= MAX_CALLBACK_PAYLOAD_BYTES;
+}
+/** Decode a payload produced by this renderer; null for anything else (legacy buttons). */
+export function decodeMaxPresentationCallback(payload) {
+    if (!payload)
+        return null;
+    if (payload.startsWith(CALLBACK_PREFIX)) {
+        const value = payload.slice(CALLBACK_PREFIX.length);
+        return value ? { kind: 'callback', value } : null;
+    }
+    if (payload.startsWith(APPROVAL_PREFIX)) {
+        const match = /^mxa1:([eps]):([oad]):(.+)$/su.exec(payload);
+        if (!match)
+            return null;
+        const approvalKind = Object.keys(APPROVAL_KIND_CODES).find((kind) => APPROVAL_KIND_CODES[kind] === match[1]);
+        const decision = Object.keys(APPROVAL_DECISION_CODES).find((code) => APPROVAL_DECISION_CODES[code] === match[2]);
+        return approvalKind && decision
+            ? { kind: 'approval', approvalKind, decision, approvalId: match[3] }
+            : null;
+    }
+    if (payload.startsWith(QUESTION_PREFIX)) {
+        const rest = payload.slice(QUESTION_PREFIX.length);
+        const separator = rest.indexOf(':');
+        if (separator <= 0 || separator === rest.length - 1)
+            return null;
+        return {
+            kind: 'question',
+            questionId: rest.slice(0, separator),
+            optionValue: rest.slice(separator + 1),
+        };
+    }
+    return null;
+}
+function clipLabel(label) {
+    const chars = Array.from(label.trim());
+    return chars.length <= MAX_BUTTON_TEXT_LIMIT
+        ? chars.join('')
+        : `${chars.slice(0, MAX_BUTTON_TEXT_LIMIT - 1).join('')}…`;
+}
+function callbackButton(label, payload) {
+    return fitsPayload(payload)
+        ? { button: { text: clipLabel(label), type: 'callback', payload } }
+        : { dropped: label };
+}
+function linkButton(label, url) {
+    const trimmed = url.trim();
+    if (!/^https?:\/\//iu.test(trimmed) || trimmed.length > MAX_LINK_URL_LENGTH)
+        return { dropped: label };
+    return { button: { text: clipLabel(label), type: 'link', url: trimmed } };
+}
+function commandPayload(command) {
+    const trimmed = command.trim();
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+function toControl(button) {
+    const label = button.label;
+    const action = resolveMessagePresentationButtonAction(button);
+    if (!action || button.disabled)
+        return { dropped: label };
+    switch (action.type) {
+        case 'url':
+            return linkButton(label, action.url);
+        case 'web-app':
+            // MAX open_app addresses a bot's mini app by name, not by URL.
+            return action.url ? linkButton(label, action.url) : { dropped: label };
+        case 'command':
+            return action.command.trim()
+                ? callbackButton(label, commandPayload(action.command))
+                : { dropped: label };
+        case 'callback':
+            return callbackButton(label, `${CALLBACK_PREFIX}${action.value}`);
+        case 'approval': {
+            const kind = APPROVAL_KIND_CODES[action.approvalKind];
+            const decision = APPROVAL_DECISION_CODES[action.decision];
+            if (!kind || !decision || !action.approvalId)
+                return { dropped: label };
+            return callbackButton(label, `${APPROVAL_PREFIX}${kind}:${decision}:${action.approvalId}`);
+        }
+        case 'question':
+            // custom-input needs a free-text composer target MAX cannot address; the
+            // producer states the text route in the message, so the control is omitted.
+            if ('intent' in action || action.questionId.includes(':'))
+                return { dropped: label };
+            return callbackButton(label, `${QUESTION_PREFIX}${action.questionId}:${action.optionValue}`);
+        default:
+            return { dropped: label };
+    }
+}
+function toOptionControl(option) {
+    const action = resolveMessagePresentationOptionAction(option);
+    if (!action)
+        return { dropped: option.label };
+    return action.type === 'command'
+        ? callbackButton(option.label, commandPayload(action.command))
+        : callbackButton(option.label, `${CALLBACK_PREFIX}${action.value}`);
+}
+// ── Text ──
+const TONE_PREFIX = {
+    info: 'ℹ️',
+    success: '✅',
+    warning: '⚠️',
+    danger: '⛔',
+};
+function collapse(value) {
+    return String(value).replace(/\s+/gu, ' ').replace(/`/gu, "'").trim();
+}
+function monospaceTable(headers, rows) {
+    const widths = headers.map((header, column) => Math.max(Array.from(header).length, ...rows.map((row) => Array.from(row[column] ?? '').length)));
+    const pad = (cells) => cells
+        .map((cell, column) => cell + ' '.repeat(Math.max(0, widths[column] - Array.from(cell).length)))
+        .join(' | ')
+        .trimEnd();
+    const lines = [
+        pad(headers),
+        widths.map((width) => '-'.repeat(Math.max(1, width))).join('-+-'),
+        ...rows.map(pad),
+    ];
+    return ['```', ...lines, '```'].join('\n');
+}
+function renderDataBlock(block) {
+    if (block.type === 'table') {
+        return [
+            `**${collapse(block.caption)}**`,
+            monospaceTable(block.headers.map(collapse), block.rows.map((row) => row.map(collapse))),
+        ].join('\n');
+    }
+    if (block.chartType === 'pie') {
+        const total = block.segments.reduce((sum, segment) => sum + segment.value, 0);
+        const rows = block.segments.map((segment) => [
+            collapse(segment.label),
+            collapse(segment.value),
+            total > 0 ? `${((segment.value / total) * 100).toFixed(1)}%` : '',
+        ]);
+        return [`**${collapse(block.title)}** (pie)`, monospaceTable(['', '', '%'], rows)].join('\n');
+    }
+    const headers = [
+        collapse(block.xLabel ?? ''),
+        ...block.series.map((series) => collapse(series.name)),
+    ];
+    const rows = block.categories.map((category, index) => [
+        collapse(category),
+        ...block.series.map((series) => collapse(series.values[index] ?? '')),
+    ]);
+    const axis = block.yLabel ? `, ${collapse(block.yLabel)}` : '';
+    return [
+        `**${collapse(block.title)}** (${block.chartType}${axis})`,
+        monospaceTable(headers, rows),
+    ].join('\n');
+}
+function renderContext(text) {
+    const trimmed = text.trim();
+    return /[_*\n]/u.test(trimmed) ? trimmed : `_${trimmed}_`;
+}
+function chunk(items, size) {
+    const rows = [];
+    for (let index = 0; index < items.length; index += size)
+        rows.push(items.slice(index, index + size));
+    return rows;
+}
+/** Pure mapping of an (already adapted) presentation to MAX text + keyboard rows. */
+export function renderMaxPresentationParts(params) {
+    const { presentation } = params;
+    const baseText = params.text?.trim() ?? '';
+    const parts = [];
+    const title = presentation.title?.trim();
+    if (title && !baseText.startsWith(title)) {
+        const tone = presentation.tone ? TONE_PREFIX[presentation.tone] : undefined;
+        parts.push(tone ? `${tone} **${title}**` : `**${title}**`);
+    }
+    if (baseText)
+        parts.push(baseText);
+    const rows = [];
+    const dropped = [];
+    let buttonCount = 0;
+    const pushRows = (candidates) => {
+        for (const row of candidates) {
+            const room = Math.min(row.length, MAX_KEYBOARD_BUTTONS - buttonCount);
+            if (rows.length >= MAX_KEYBOARD_ROWS || room <= 0) {
+                dropped.push(...row.map((button) => button.text));
+                continue;
+            }
+            rows.push(row.slice(0, room));
+            dropped.push(...row.slice(room).map((button) => button.text));
+            buttonCount += room;
+        }
+    };
+    for (const block of presentation.blocks) {
+        switch (block.type) {
+            case 'text':
+                if (block.text.trim())
+                    parts.push(block.text.trim());
+                break;
+            case 'context':
+                if (block.text.trim())
+                    parts.push(renderContext(block.text));
+                break;
+            case 'divider':
+                parts.push('———');
+                break;
+            case 'table':
+            case 'chart':
+                parts.push(renderDataBlock(block));
+                break;
+            case 'buttons': {
+                const buttons = [];
+                for (const control of block.buttons.map(toControl)) {
+                    if ('button' in control)
+                        buttons.push(control.button);
+                    else
+                        dropped.push(control.dropped);
+                }
+                pushRows(chunk(buttons, BUTTONS_PER_ROW));
+                break;
+            }
+            case 'select': {
+                const options = [];
+                for (const control of block.options.map(toOptionControl)) {
+                    if ('button' in control)
+                        options.push(control.button);
+                    else
+                        dropped.push(control.dropped);
+                }
+                pushRows(chunk(options, SELECT_OPTIONS_PER_ROW));
+                break;
+            }
+        }
+    }
+    if (dropped.length > 0) {
+        // Label-only fallback, as core renders controls a channel cannot carry.
+        const fallback = renderMessagePresentationFallbackText({
+            presentation: {
+                blocks: [
+                    { type: 'buttons', buttons: dropped.map((label) => ({ label, value: 'unavailable' })) },
+                ],
+            },
+        });
+        if (fallback)
+            parts.push(fallback);
+    }
+    return { text: parts.join('\n\n'), buttons: rows };
+}
+function readChannelDataMax(channelData) {
+    if (!channelData || typeof channelData !== 'object' || Array.isArray(channelData))
+        return {};
+    const max = channelData.max;
+    return max && typeof max === 'object' && !Array.isArray(max)
+        ? max
+        : {};
+}
+/** `renderPresentation` for the outbound adapter: presentation → channelData.max.buttons. */
+export function renderMaxPresentation(payload, presentation) {
+    const rendered = renderMaxPresentationParts({ presentation, text: payload.text });
+    const existingMax = readChannelDataMax(payload.channelData);
+    const existingButtons = Array.isArray(existingMax.buttons)
+        ? existingMax.buttons
+        : [];
+    const buttons = [...existingButtons, ...rendered.buttons];
+    const rest = { ...payload };
+    delete rest.presentation;
+    return {
+        ...rest,
+        text: rendered.text,
+        ...(buttons.length > 0 || payload.channelData
+            ? {
+                channelData: {
+                    ...(payload.channelData ?? {}),
+                    max: { ...existingMax, ...(buttons.length > 0 ? { buttons } : {}) },
+                },
+            }
+            : {}),
+    };
+}
+/** Same adaptation + render + fallback policy core applies on its outbound path. */
+export async function materializeMaxPresentation(payload) {
+    if (!payload.presentation)
+        return payload;
+    return renderPresentationForDelivery({
+        presentationCapabilities: MAX_PRESENTATION_CAPABILITIES,
+        renderPresentation: (adapted) => renderMaxPresentation(adapted, adapted.presentation),
+    }, payload);
+}
+/** Normalize `delivery.pin` (true | {enabled, notify, required}) or the tool's `pin: true`. */
+export function readMaxDeliveryPin(delivery, pinFlag) {
+    const raw = delivery && typeof delivery === 'object' && !Array.isArray(delivery)
+        ? delivery.pin
+        : undefined;
+    if (raw === true)
+        return { enabled: true };
+    if (raw && typeof raw === 'object' && raw.enabled) {
+        return { enabled: true, notify: raw.notify === true, required: raw.required === true };
+    }
+    if (pinFlag === true)
+        return { enabled: true };
+    return undefined;
+}

package/dist/src/runtime.js

@@ -0,0 +1,36 @@
+let runtime = null;
+export function setMaxRuntime(next) {
+    runtime = next;
+}
+export function getMaxRuntime() {
+    if (!runtime) {
+        throw new Error('MAX runtime not initialized');
+    }
+    return runtime;
+}
+/** Read the current config snapshot through the plugin runtime, on any supported OpenClaw version. */
+export async function loadMaxConfig() {
+    const config = getMaxRuntime().config;
+    if (typeof config.current === 'function') {
+        return config.current();
+    }
+    const legacy = config;
+    if (typeof legacy.loadConfig === 'function') {
+        return await legacy.loadConfig();
+    }
+    throw new Error('MAX runtime config API unavailable: neither config.current() nor config.loadConfig()');
+}
+/** Persist a full config replacement through the plugin runtime, on any supported OpenClaw version. */
+export async function writeMaxConfig(nextConfig) {
+    const config = getMaxRuntime().config;
+    if (typeof config.replaceConfigFile === 'function') {
+        await config.replaceConfigFile({ nextConfig, afterWrite: { mode: 'auto' } });
+        return;
+    }
+    const legacy = config;
+    if (typeof legacy.writeConfigFile === 'function') {
+        await legacy.writeConfigFile(nextConfig);
+        return;
+    }
+    throw new Error('MAX runtime config API unavailable: neither config.replaceConfigFile() nor config.writeConfigFile()');
+}

package/dist/src/russian-trusted-ca.js

@@ -0,0 +1,84 @@
+/**
+ * Russian Trusted Root/Sub CA (Минцифры РФ) — required for TLS to platform-api2.max.ru.
+ *
+ * Source: https://gu-st.ru/content/lending/russian_trusted_root_ca_pem.crt
+ *         https://gu-st.ru/content/lending/russian_trusted_sub_ca_pem.crt
+ * Root CA valid until 2032-02-27, Sub CA until 2027-03-06.
+ * These are used ONLY for MAX API connections (per-dispatcher ca), never installed process-wide.
+ */
+export const RUSSIAN_TRUSTED_ROOT_CA = `
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`;
+export const RUSSIAN_TRUSTED_SUB_CA = `
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`;