@aspalagin/openclaw-max 0.7.2

package/scripts/test-api.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * MAX Bot API — integration test script
+ *
+ * Usage:
+ *   MAX_BOT_TOKEN=xxx node scripts/test-api.mjs [chat_id]
+ *
+ * Checks:
+ *   1. GET /me         — bot is alive, prints name + user_id
+ *   2. GET /updates    — fetches recent updates (short poll, 3s)
+ *   3. POST /messages  — sends test message (if chat_id provided)
+ */
+
+const API = "https://platform-api.max.ru";
+const TOKEN = process.env.MAX_BOT_TOKEN;
+const CHAT_ID = process.argv[2] ? Number(process.argv[2]) : null;
+
+if (!TOKEN) {
+  console.error("❌ MAX_BOT_TOKEN is not set. Export it first:");
+  console.error("   export MAX_BOT_TOKEN=your_token_here");
+  process.exit(1);
+}
+
+const headers = {
+  Authorization: TOKEN,
+  Accept: "application/json",
+};
+
+// ─── Helpers ────────────────────────────────────────────────────
+
+async function apiGet(path) {
+  const url = `${API}${path}`;
+  console.log(`→ GET ${url}`);
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status}: ${body.slice(0, 300)}`);
+  }
+  return res.json();
+}
+
+async function apiPost(path, body) {
+  const url = `${API}${path}`;
+  console.log(`→ POST ${url}`);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status}: ${text.slice(0, 300)}`);
+  }
+  return res.json();
+}
+
+function ok(msg) {
+  console.log(`✅ ${msg}`);
+}
+
+function fail(msg) {
+  console.error(`❌ ${msg}`);
+}
+
+// ─── Test 1: GET /me ────────────────────────────────────────────
+
+async function testMe() {
+  console.log("\n── Test 1: GET /me ──");
+  try {
+    const me = await apiGet("/me");
+    ok(`Bot is alive!`);
+    console.log(`   user_id:    ${me.user_id}`);
+    console.log(`   name:       ${me.first_name ?? me.name ?? "–"}`);
+    console.log(`   username:   ${me.username ?? "–"}`);
+    console.log(`   is_bot:     ${me.is_bot}`);
+    return me;
+  } catch (err) {
+    fail(`GET /me failed: ${err.message}`);
+    return null;
+  }
+}
+
+// ─── Test 2: GET /updates ───────────────────────────────────────
+
+async function testUpdates() {
+  console.log("\n── Test 2: GET /updates (short poll, 3s) ──");
+  try {
+    const data = await apiGet("/updates?timeout=3&limit=5");
+    const count = data.updates?.length ?? 0;
+    ok(`Got ${count} update(s), marker=${data.marker ?? "null"}`);
+
+    if (count > 0) {
+      for (const u of data.updates) {
+        const type = u.update_type;
+        const ts = new Date(u.timestamp).toISOString();
+        let info = "";
+
+        if (type === "message_created" && u.message) {
+          const sender = u.message.sender;
+          const text = u.message.body?.text ?? "(no text)";
+          const sName = sender
+            ? `${sender.first_name ?? ""} ${sender.last_name ?? ""}`.trim()
+            : "unknown";
+          info = `from=${sName} (${sender?.user_id}): "${text.slice(0, 60)}"`;
+        } else if (type === "bot_started") {
+          info = `user=${u.user?.first_name} (${u.user?.user_id})`;
+        }
+
+        console.log(`   [${ts}] ${type} ${info}`);
+      }
+    }
+    return data;
+  } catch (err) {
+    fail(`GET /updates failed: ${err.message}`);
+    return null;
+  }
+}
+
+// ─── Test 3: POST /messages ─────────────────────────────────────
+
+async function testSendMessage(chatId) {
+  console.log(`\n── Test 3: POST /messages (chat_id=${chatId}) ──`);
+  try {
+    const now = new Date().toISOString();
+    const body = {
+      text: `🤖 Тестовое сообщение от MAX-бота.\nВремя: ${now}`,
+      format: "markdown",
+    };
+    const data = await apiPost(`/messages?chat_id=${chatId}`, body);
+    ok(`Message sent!`);
+    console.log(`   message_id: ${data.message?.body?.mid ?? JSON.stringify(data).slice(0, 100)}`);
+    return data;
+  } catch (err) {
+    fail(`POST /messages failed: ${err.message}`);
+    return null;
+  }
+}
+
+// ─── Main ───────────────────────────────────────────────────────
+
+async function main() {
+  console.log("═══ MAX Bot API Test ═══");
+  console.log(`Token: ${TOKEN.slice(0, 8)}...${TOKEN.slice(-4)}`);
+
+  const me = await testMe();
+  if (!me) {
+    console.error("\nBot unreachable. Check your token.");
+    process.exit(1);
+  }
+
+  await testUpdates();
+
+  if (CHAT_ID) {
+    await testSendMessage(CHAT_ID);
+  } else {
+    console.log("\n── Test 3: skipped (no chat_id) ──");
+    console.log("   To test sending, run:");
+    console.log(`   MAX_BOT_TOKEN=... node scripts/test-api.mjs <chat_id>`);
+    console.log("   (Write to the bot first, then grab chat_id from updates)");
+  }
+
+  console.log("\n═══ Done ═══");
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});

package/scripts/test-send.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * MAX Bot API — send + edit + delete integration test
+ *
+ * Usage:
+ *   MAX_BOT_TOKEN=xxx node scripts/test-send.mjs <chat_id> [текст]
+ *
+ * Flow:
+ *   1. Send message to chat_id
+ *   2. Wait 3 seconds
+ *   3. Edit message (append " ✅ отредактировано")
+ *   4. Wait 3 seconds
+ *   5. Delete message
+ */
+
+const API = "https://platform-api.max.ru";
+const TOKEN = process.env.MAX_BOT_TOKEN;
+const CHAT_ID = process.argv[2];
+const TEXT = process.argv[3] || "🤖 Тестовое сообщение от MAX-бота";
+
+if (!TOKEN) {
+  console.error("❌ MAX_BOT_TOKEN is not set.");
+  console.error("   export MAX_BOT_TOKEN=your_token_here");
+  process.exit(1);
+}
+
+if (!CHAT_ID) {
+  console.error("❌ chat_id not provided.");
+  console.error("   Usage: MAX_BOT_TOKEN=xxx node scripts/test-send.mjs <chat_id> [текст]");
+  console.error("   Tip: get chat_id from `node scripts/test-api.mjs` updates");
+  process.exit(1);
+}
+
+const headers = {
+  Authorization: TOKEN,
+  "Content-Type": "application/json",
+  Accept: "application/json",
+};
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ─── Step 1: Send ───────────────────────────────────────────────
+
+async function sendMessage(chatId, text) {
+  console.log(`\n── Step 1: POST /messages (send) ──`);
+  console.log(`   chat_id: ${chatId}`);
+  console.log(`   text: "${text}"`);
+
+  const url = `${API}/messages?chat_id=${chatId}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ text }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Send failed: HTTP ${res.status} — ${body.slice(0, 300)}`);
+  }
+
+  const data = await res.json();
+  const mid = data.message?.body?.mid;
+
+  if (!mid) {
+    console.log("   Response:", JSON.stringify(data).slice(0, 200));
+    throw new Error("No message_id in response");
+  }
+
+  console.log(`   ✅ Sent! message_id: ${mid}`);
+  return mid;
+}
+
+// ─── Step 2: Edit ───────────────────────────────────────────────
+
+async function editMessage(messageId, newText) {
+  console.log(`\n── Step 3: PUT /messages (edit) ──`);
+  console.log(`   message_id: ${messageId}`);
+  console.log(`   new text: "${newText}"`);
+
+  const url = `${API}/messages?message_id=${messageId}`;
+  const res = await fetch(url, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({ text: newText }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Edit failed: HTTP ${res.status} — ${body.slice(0, 300)}`);
+  }
+
+  const data = await res.json();
+  if (data.success === false) {
+    throw new Error(`Edit failed: ${data.message || "unknown"}`);
+  }
+
+  console.log(`   ✅ Edited!`);
+}
+
+// ─── Step 3: Delete ─────────────────────────────────────────────
+
+async function deleteMessage(messageId) {
+  console.log(`\n── Step 5: DELETE /messages (delete) ──`);
+  console.log(`   message_id: ${messageId}`);
+
+  const url = `${API}/messages?message_id=${messageId}`;
+  const res = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      Authorization: TOKEN,
+      Accept: "application/json",
+    },
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Delete failed: HTTP ${res.status} — ${body.slice(0, 300)}`);
+  }
+
+  const data = await res.json();
+  if (data.success === false) {
+    throw new Error(`Delete failed: ${data.message || "unknown"}`);
+  }
+
+  console.log(`   ✅ Deleted!`);
+}
+
+// ─── Main ───────────────────────────────────────────────────────
+
+async function main() {
+  console.log("═══ MAX Bot API: Send → Edit → Delete Test ═══");
+  console.log(`Token: ${TOKEN.slice(0, 8)}...${TOKEN.slice(-4)}`);
+  console.log(`Chat:  ${CHAT_ID}`);
+
+  // Step 1: Send
+  const mid = await sendMessage(CHAT_ID, TEXT);
+
+  // Step 2: Wait
+  console.log(`\n── Step 2: Ожидание 3 сек... ──`);
+  await sleep(3000);
+
+  // Step 3: Edit
+  const editedText = `${TEXT} ✅ отредактировано`;
+  await editMessage(mid, editedText);
+
+  // Step 4: Wait
+  console.log(`\n── Step 4: Ожидание 3 сек... ──`);
+  await sleep(3000);
+
+  // Step 5: Delete
+  await deleteMessage(mid);
+
+  console.log("\n═══ All steps passed! ═══");
+}
+
+main().catch((err) => {
+  console.error(`\n❌ Fatal: ${err.message}`);
+  process.exit(1);
+});

package/scripts/update-schema.mjs

@@ -0,0 +1,48 @@
+// Refresh the MAX Bot API schema snapshot used by schema-conformance.test.ts.
+//
+//   npm run schema:update            # latest commit of max-messenger/api-schema
+//   npm run schema:update -- <ref>   # a branch, tag or commit
+//
+// Clones the repository shallowly into a temp dir, writes
+// src/__fixtures__/max-schema-<info.version>.yaml with a source header and
+// removes older snapshots. Run `npm test` afterwards: a failing conformance
+// test means the plugin sends or expects something the new schema changed.
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { parse } from "yaml";
+
+const REPO = "https://github.com/max-messenger/api-schema";
+const ref = process.argv[2];
+const fixturesDir = new URL("../src/__fixtures__/", import.meta.url).pathname;
+const work = mkdtempSync(join(tmpdir(), "max-api-schema-"));
+const git = (...args) => execFileSync("git", args, { cwd: work, encoding: "utf8" }).trim();
+
+try {
+  git("init", "-q");
+  git("remote", "add", "origin", REPO);
+  git("fetch", "-q", "--depth", "1", "origin", ref ?? "HEAD");
+  git("checkout", "-q", "FETCH_HEAD");
+  const commit = git("rev-parse", "HEAD");
+  const date = git("show", "-s", "--format=%cd", "--date=format:%d.%m.%Y", "HEAD");
+  const yamlText = readFileSync(join(work, "schema.yaml"), "utf8");
+  const version = parse(yamlText)?.info?.version;
+  if (!version) throw new Error("schema.yaml has no info.version");
+
+  const target = `max-schema-${version}.yaml`;
+  const header = [
+    `# Snapshot of the MAX Bot API OpenAPI schema (info.version ${version}).`,
+    `# Source: ${REPO}/blob/${commit}/schema.yaml`,
+    `# Commit ${commit}, ${date}. Refresh with: npm run schema:update`,
+    "",
+  ].join("\n");
+  writeFileSync(join(fixturesDir, target), `${header}\n${yamlText}`);
+  for (const name of readdirSync(fixturesDir)) {
+    if (/^max-schema-.+\.yaml$/.test(name) && name !== target) unlinkSync(join(fixturesDir, name));
+  }
+  console.log(`src/__fixtures__/${target} ← ${commit.slice(0, 7)} (${date}); now run npm test`);
+} finally {
+  rmSync(work, { recursive: true, force: true });
+}

package/src/accounts.ts

@@ -0,0 +1,193 @@
+/**
+ * MAX account resolution — reads config and produces a resolved account object.
+ */
+
+import { lstatSync, readFileSync } from 'node:fs';
+
+import type { OpenClawConfig } from 'openclaw/plugin-sdk/core';
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from 'openclaw/plugin-sdk/core';
+
+export interface MaxAccountConfig {
+  enabled?: boolean;
+  botToken?: string;
+  tokenFile?: string;
+  name?: string;
+  dmPolicy?: string;
+  allowFrom?: Array<string | number>;
+  groups?: Record<string, { requireMention?: boolean; [key: string]: unknown }>;
+  groupPolicy?: string;
+  groupAllowFrom?: Array<string | number>;
+  /** Update transport; default: "webhook" when webhookUrl is set, otherwise "polling" */
+  transport?: 'polling' | 'webhook';
+  webhookUrl?: string;
+  webhookSecret?: string;
+  /** File holding the webhook secret (like tokenFile) */
+  webhookSecretFile?: string;
+  webhookPath?: string;
+  mediaMaxMb?: number;
+  streamMode?: 'off' | 'partial' | 'block';
+  /** Send mark_seen read receipts on inbound messages (default true) */
+  markSeen?: boolean;
+}
+
+export interface ResolvedMaxAccount {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  token: string;
+  tokenSource: 'config' | 'env' | 'file' | 'none';
+  config: MaxAccountConfig;
+}
+
+/**
+ * Get the MAX channel section from config.
+ */
+function getMaxSection(cfg: OpenClawConfig): Record<string, unknown> | undefined {
+  return (cfg.channels as Record<string, unknown>)?.max as Record<string, unknown> | undefined;
+}
+
+/** Read a secret from a regular (non-symlink) file; "" when missing or unreadable. */
+export function readSecretFile(filePath?: string): string {
+  return readTokenFile(filePath);
+}
+
+function readTokenFile(tokenFile?: string): string {
+  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: OpenClawConfig): string[] {
+  const section = getMaxSection(cfg);
+  if (!section) return [];
+
+  const ids: string[] = [];
+  // 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 as Record<string, unknown> | undefined;
+  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: OpenClawConfig): string {
+  return DEFAULT_ACCOUNT_ID;
+}
+
+/**
+ * Resolve a single MAX account from config.
+ */
+export function resolveMaxAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedMaxAccount {
+  const { cfg, accountId: rawId } = params;
+  const accountId = rawId ? normalizeAccountId(rawId) : DEFAULT_ACCOUNT_ID;
+  const section = getMaxSection(cfg) ?? {};
+  const accounts = section.accounts as Record<string, Record<string, unknown>> | undefined;
+
+  let accountConfig: MaxAccountConfig;
+  let token = '';
+  let tokenSource: ResolvedMaxAccount['tokenSource'] = 'none';
+
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    // Default account: top-level config
+    accountConfig = {
+      enabled: section.enabled !== false,
+      botToken: section.botToken as string | undefined,
+      tokenFile: section.tokenFile as string | undefined,
+      name: section.name as string | undefined,
+      dmPolicy: section.dmPolicy as string | undefined,
+      allowFrom: section.allowFrom as Array<string | number> | undefined,
+      groups: section.groups as MaxAccountConfig['groups'],
+      groupPolicy: section.groupPolicy as string | undefined,
+      groupAllowFrom: section.groupAllowFrom as Array<string | number> | undefined,
+      transport: section.transport as MaxAccountConfig['transport'],
+      webhookUrl: section.webhookUrl as string | undefined,
+      webhookSecret: section.webhookSecret as string | undefined,
+      webhookSecretFile: section.webhookSecretFile as string | undefined,
+      webhookPath: section.webhookPath as string | undefined,
+      mediaMaxMb: section.mediaMaxMb as number | undefined,
+      streamMode: section.streamMode as MaxAccountConfig['streamMode'],
+      markSeen: section.markSeen as boolean | undefined,
+    };
+
+    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 as string | undefined,
+      tokenFile: raw.tokenFile as string | undefined,
+      name: raw.name as string | undefined,
+      dmPolicy: raw.dmPolicy as string | undefined,
+      allowFrom: raw.allowFrom as Array<string | number> | undefined,
+      groups: raw.groups as MaxAccountConfig['groups'],
+      groupPolicy: raw.groupPolicy as string | undefined,
+      groupAllowFrom: raw.groupAllowFrom as Array<string | number> | undefined,
+      transport: raw.transport as MaxAccountConfig['transport'],
+      webhookUrl: raw.webhookUrl as string | undefined,
+      webhookSecret: raw.webhookSecret as string | undefined,
+      webhookSecretFile: raw.webhookSecretFile as string | undefined,
+      webhookPath: raw.webhookPath as string | undefined,
+      mediaMaxMb: raw.mediaMaxMb as number | undefined,
+      streamMode: raw.streamMode as MaxAccountConfig['streamMode'],
+      markSeen: raw.markSeen as boolean | undefined,
+    };
+
+    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,
+  };
+}