@aspalagin/openclaw-max 0.7.2

package/src/presentation.ts

@@ -0,0 +1,452 @@
+/**
+ * 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 type { ChannelOutboundAdapter } from 'openclaw/plugin-sdk/channel-contract';
+import type { ReplyPayload } from 'openclaw/plugin-sdk/core';
+import {
+  type MessagePresentation,
+  type MessagePresentationBlock,
+  type MessagePresentationButton,
+  type MessagePresentationOption,
+  renderMessagePresentationFallbackText,
+  renderPresentationForDelivery,
+  type ReplyPayloadDelivery,
+  resolveMessagePresentationButtonAction,
+  resolveMessagePresentationOptionAction,
+} from 'openclaw/plugin-sdk/interactive-runtime';
+
+import type { MaxSendButton } from './send.js';
+
+type ChannelPresentationCapabilities = NonNullable<
+  ChannelOutboundAdapter['presentationCapabilities']
+>;
+
+/** 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: ChannelPresentationCapabilities = {
+  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:';
+
+type ApprovalKind = 'exec' | 'plugin' | 'system-agent';
+type ApprovalDecision = 'allow-once' | 'allow-always' | 'deny';
+
+const APPROVAL_KIND_CODES: Record<ApprovalKind, string> = {
+  exec: 'e',
+  plugin: 'p',
+  'system-agent': 's',
+};
+const APPROVAL_DECISION_CODES: Record<ApprovalDecision, string> = {
+  'allow-once': 'o',
+  'allow-always': 'a',
+  deny: 'd',
+};
+
+export type MaxPresentationCallback =
+  | { kind: 'callback'; value: string }
+  | { kind: 'approval'; approvalId: string; approvalKind: ApprovalKind; decision: ApprovalDecision }
+  | { kind: 'question'; questionId: string; optionValue: string };
+
+function fitsPayload(payload: string): boolean {
+  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: string | undefined | null,
+): MaxPresentationCallback | null {
+  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) as ApprovalKind[]).find(
+      (kind) => APPROVAL_KIND_CODES[kind] === match[1],
+    );
+    const decision = (Object.keys(APPROVAL_DECISION_CODES) as ApprovalDecision[]).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;
+}
+
+// ── Controls ──
+
+type ControlResult = { button: MaxSendButton } | { dropped: string };
+
+function clipLabel(label: string): string {
+  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: string, payload: string): ControlResult {
+  return fitsPayload(payload)
+    ? { button: { text: clipLabel(label), type: 'callback', payload } }
+    : { dropped: label };
+}
+
+function linkButton(label: string, url: string): ControlResult {
+  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: string): string {
+  const trimmed = command.trim();
+  return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+
+function toControl(button: MessagePresentationButton): ControlResult {
+  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 as ApprovalKind];
+      const decision = APPROVAL_DECISION_CODES[action.decision as ApprovalDecision];
+      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: MessagePresentationOption): ControlResult {
+  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: Record<string, string> = {
+  info: 'ℹ️',
+  success: '✅',
+  warning: '⚠️',
+  danger: '⛔',
+};
+
+function collapse(value: string | number): string {
+  return String(value).replace(/\s+/gu, ' ').replace(/`/gu, "'").trim();
+}
+
+function monospaceTable(headers: string[], rows: string[][]): string {
+  const widths = headers.map((header, column) =>
+    Math.max(Array.from(header).length, ...rows.map((row) => Array.from(row[column] ?? '').length)),
+  );
+  const pad = (cells: string[]) =>
+    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: Extract<MessagePresentationBlock, { type: 'table' | 'chart' }>,
+): string {
+  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: string): string {
+  const trimmed = text.trim();
+  return /[_*\n]/u.test(trimmed) ? trimmed : `_${trimmed}_`;
+}
+
+function chunk<T>(items: T[], size: number): T[][] {
+  const rows: T[][] = [];
+  for (let index = 0; index < items.length; index += size)
+    rows.push(items.slice(index, index + size));
+  return rows;
+}
+
+export type MaxRenderedPresentation = {
+  text: string;
+  buttons: MaxSendButton[][];
+};
+
+/** Pure mapping of an (already adapted) presentation to MAX text + keyboard rows. */
+export function renderMaxPresentationParts(params: {
+  presentation: MessagePresentation;
+  text?: string | null;
+}): MaxRenderedPresentation {
+  const { presentation } = params;
+  const baseText = params.text?.trim() ?? '';
+  const parts: string[] = [];
+
+  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: MaxSendButton[][] = [];
+  const dropped: string[] = [];
+  let buttonCount = 0;
+  const pushRows = (candidates: MaxSendButton[][]) => {
+    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: MaxSendButton[] = [];
+        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: MaxSendButton[] = [];
+        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: unknown): Record<string, unknown> {
+  if (!channelData || typeof channelData !== 'object' || Array.isArray(channelData)) return {};
+  const max = (channelData as Record<string, unknown>).max;
+  return max && typeof max === 'object' && !Array.isArray(max)
+    ? (max as Record<string, unknown>)
+    : {};
+}
+
+/** `renderPresentation` for the outbound adapter: presentation → channelData.max.buttons. */
+export function renderMaxPresentation(
+  payload: ReplyPayload,
+  presentation: MessagePresentation,
+): ReplyPayload {
+  const rendered = renderMaxPresentationParts({ presentation, text: payload.text });
+  const existingMax = readChannelDataMax(payload.channelData);
+  const existingButtons = Array.isArray(existingMax.buttons)
+    ? (existingMax.buttons as MaxSendButton[][])
+    : [];
+  const buttons = [...existingButtons, ...rendered.buttons];
+  const rest: ReplyPayload = { ...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: ReplyPayload): Promise<ReplyPayload> {
+  if (!payload.presentation) return payload;
+  return renderPresentationForDelivery(
+    {
+      presentationCapabilities: MAX_PRESENTATION_CAPABILITIES,
+      renderPresentation: (adapted) => renderMaxPresentation(adapted, adapted.presentation),
+    },
+    payload,
+  );
+}
+
+export type MaxDeliveryPin = { enabled: boolean; notify?: boolean; required?: boolean };
+
+/** Normalize `delivery.pin` (true | {enabled, notify, required}) or the tool's `pin: true`. */
+export function readMaxDeliveryPin(
+  delivery: unknown,
+  pinFlag?: unknown,
+): MaxDeliveryPin | undefined {
+  const raw =
+    delivery && typeof delivery === 'object' && !Array.isArray(delivery)
+      ? (delivery as ReplyPayloadDelivery).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/src/runtime.ts

@@ -0,0 +1,56 @@
+import type { OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk/core';
+
+let runtime: PluginRuntime | null = null;
+
+export function setMaxRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getMaxRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error('MAX runtime not initialized');
+  }
+  return runtime;
+}
+
+/**
+ * Legacy runtime config API (OpenClaw < 2026.9.3).
+ * Since 2026.9.3 `loadConfig`/`writeConfigFile` are removed from PluginRuntime;
+ * the runtime exposes `config.current()` and transactional `replaceConfigFile`/`mutateConfigFile`.
+ */
+type LegacyMaxRuntimeConfigApi = {
+  loadConfig?: () => Promise<OpenClawConfig> | OpenClawConfig;
+  writeConfigFile?: (cfg: OpenClawConfig) => Promise<unknown> | unknown;
+};
+
+/** Read the current config snapshot through the plugin runtime, on any supported OpenClaw version. */
+export async function loadMaxConfig(): Promise<OpenClawConfig> {
+  const config = getMaxRuntime().config;
+  if (typeof config.current === 'function') {
+    return config.current() as OpenClawConfig;
+  }
+  const legacy = config as unknown as LegacyMaxRuntimeConfigApi;
+  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: OpenClawConfig): Promise<void> {
+  const config = getMaxRuntime().config;
+  if (typeof config.replaceConfigFile === 'function') {
+    await config.replaceConfigFile({ nextConfig, afterWrite: { mode: 'auto' } });
+    return;
+  }
+  const legacy = config as unknown as LegacyMaxRuntimeConfigApi;
+  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/src/russian-trusted-ca.ts

@@ -0,0 +1,86 @@
+/**
+ * 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-----`;