iopenclawwx 0.0.1

package/README.md

@@ -0,0 +1,12 @@
+# iopenclawwx
+
+```bash
+openclaw plugins install iopenclawwx
+cd ~/.openclaw/extensions/iopenclawwx
+npm run config-init  # 输入你的 API Key
+openclaw gateway restart
+```
+
+## 小程序码
+
+![iOpenClaw 小程序码](https://github.com/lovezm/chatlog/blob/main/gh_498442564d0d_430.jpg?raw=true)

package/index.ts

@@ -0,0 +1,59 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { relayChannelPlugin } from "./src/channel.js";
+import { setRelayRuntime } from "./src/runtime.js";
+import { PLUGIN_ID, PLUGIN_VERSION } from "./src/constants.js";
+
+const plugin = {
+  id: PLUGIN_ID,
+  name: "iOpenClaw Relay",
+  description: "OpenClaw relay channel plugin for iOpenClaw",
+  version: PLUGIN_VERSION,
+  configSchema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      defaults: {
+        type: "object",
+        properties: {
+          relayBaseUrl: { type: "string" },
+          pollIntervalMs: { type: "number", minimum: 500, maximum: 60000 },
+          heartbeatIntervalMs: { type: "number", minimum: 5000, maximum: 120000 },
+          sessionKey: { type: "string" },
+          debug: { type: "boolean" },
+        }
+      },
+      accounts: {
+        type: "object",
+        additionalProperties: {
+          type: "object",
+          properties: {
+            apiKey: { type: "string" },
+            relayBaseUrl: { type: "string" },
+            sessionKey: { type: "string" },
+            pollIntervalMs: { type: "number", minimum: 500, maximum: 60000 },
+            heartbeatIntervalMs: { type: "number", minimum: 5000, maximum: 120000 },
+            debug: { type: "boolean" },
+            enabled: { type: "boolean" },
+          },
+          required: ["apiKey"]
+        }
+      },
+      apiKey: { type: "string" },
+      relayBaseUrl: { type: "string" },
+      sessionKey: { type: "string" },
+      pollIntervalMs: { type: "number", minimum: 500, maximum: 60000 },
+      heartbeatIntervalMs: { type: "number", minimum: 5000, maximum: 120000 },
+      debug: { type: "boolean" }
+    },
+    required: []
+  },
+  reload: {
+    configPrefixes: ["plugins.entries.iopenclawwx"]
+  },
+  register(api: OpenClawPluginApi) {
+    setRelayRuntime(api.runtime);
+    api.registerChannel({ plugin: relayChannelPlugin });
+  }
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,121 @@
+{
+  "id": "iopenclawwx",
+  "name": "iOpenClaw Relay",
+  "description": "Channel plugin for iOpenClaw relay service",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "index.ts",
+  "license": "MIT",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "defaults": {
+        "type": "object",
+        "properties": {
+          "relayBaseUrl": {
+            "type": "string",
+            "default": "https://pay.9yo.cc/api/relay"
+          },
+          "pollIntervalMs": {
+            "type": "number",
+            "default": 2500,
+            "minimum": 500,
+            "maximum": 60000
+          },
+          "heartbeatIntervalMs": {
+            "type": "number",
+            "default": 20000,
+            "minimum": 5000,
+            "maximum": 120000
+          },
+          "sessionKey": {
+            "type": "string",
+            "default": "agent:main:main"
+          },
+          "debug": {
+            "type": "boolean",
+            "default": false
+          }
+        }
+      },
+      "accounts": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "properties": {
+            "apiKey": {
+              "type": "string",
+              "description": "API Key from iOpenClaw miniapp About page"
+            },
+            "relayBaseUrl": {
+              "type": "string",
+              "description": "Relay API base URL"
+            },
+            "sessionKey": {
+              "type": "string",
+              "description": "OpenClaw session key, format agent:<agentId>:<rest>"
+            },
+            "pollIntervalMs": {
+              "type": "number",
+              "minimum": 500,
+              "maximum": 60000
+            },
+            "heartbeatIntervalMs": {
+              "type": "number",
+              "minimum": 5000,
+              "maximum": 120000
+            },
+            "debug": {
+              "type": "boolean"
+            },
+            "enabled": {
+              "type": "boolean",
+              "default": true
+            }
+          },
+          "required": ["apiKey"]
+        }
+      },
+      "apiKey": {
+        "type": "string"
+      },
+      "relayBaseUrl": {
+        "type": "string"
+      },
+      "sessionKey": {
+        "type": "string"
+      },
+      "pollIntervalMs": {
+        "type": "number",
+        "minimum": 500,
+        "maximum": 60000
+      },
+      "heartbeatIntervalMs": {
+        "type": "number",
+        "minimum": 5000,
+        "maximum": 120000
+      },
+      "debug": {
+        "type": "boolean"
+      }
+    },
+    "required": []
+  },
+  "openclaw": {
+    "channel": {
+      "id": "iopenclawwx",
+      "label": "iOpenClaw Relay",
+      "selectionLabel": "iOpenClaw Relay",
+      "blurb": "Relay channel for iOpenClaw mini program",
+      "docsPath": "/channels/iopenclawwx",
+      "docsLabel": "iopenclawwx",
+      "systemImage": "message"
+    },
+    "install": {
+      "npmSpec": "iopenclawwx",
+      "localPath": "extensions/iopenclawwx",
+      "defaultChoice": "local"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "iopenclawwx",
+  "version": "0.0.1",
+  "description": "OpenClaw channel plugin for iOpenClaw relay",
+  "type": "module",
+  "main": "index.ts",
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "src/**/*.ts",
+    "scripts/**/*.js",
+    "openclaw.plugin.json",
+    "README.md",
+    "gh_498442564d0d_430.jpg",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "config-init": "node scripts/config-init.js",
+    "build": "tsc",
+    "pack": "npm pack --dry-run"
+  },
+  "devDependencies": {
+    "openclaw": "workspace:*",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/scripts/config-init.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PLUGIN_ID = 'iopenclawwx';
+const HOME = process.env.HOME || process.env.USERPROFILE || '/root';
+const CONFIG_FILE = path.join(HOME, '.openclaw', 'openclaw.json');
+const MANIFEST_FILE = path.join(__dirname, '..', 'openclaw.plugin.json');
+
+const FALLBACK_DEFAULTS = {
+  relayBaseUrl: 'https://pay.9yo.cc/api/relay',
+  pollIntervalMs: 2500,
+  heartbeatIntervalMs: 20000,
+  sessionKey: 'agent:main:main',
+  debug: false,
+};
+
+function color(text, code) {
+  return process.stdout.isTTY ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+
+function info(msg) { console.log(color(`ℹ ${msg}`, 34)); }
+function ok(msg) { console.log(color(`✅ ${msg}`, 32)); }
+function warn(msg) { console.log(color(`⚠ ${msg}`, 33)); }
+function err(msg) { console.log(color(`❌ ${msg}`, 31)); }
+
+function createRL() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function ask(rl, q) {
+  return new Promise((resolve) => rl.question(q, (ans) => resolve((ans || '').trim())));
+}
+
+function readJson(file) {
+  try {
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, data) {
+  const dir = path.dirname(file);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+function loadManifestDefaults() {
+  const manifest = readJson(MANIFEST_FILE);
+  if (!manifest) return { ...FALLBACK_DEFAULTS };
+
+  const props =
+    manifest?.configSchema?.properties?.defaults?.properties ||
+    manifest?.configSchema?.properties?.config?.properties?.defaults?.properties ||
+    {};
+  return {
+    relayBaseUrl: props?.relayBaseUrl?.default || FALLBACK_DEFAULTS.relayBaseUrl,
+    pollIntervalMs: props?.pollIntervalMs?.default || FALLBACK_DEFAULTS.pollIntervalMs,
+    heartbeatIntervalMs: props?.heartbeatIntervalMs?.default || FALLBACK_DEFAULTS.heartbeatIntervalMs,
+    sessionKey: props?.sessionKey?.default || FALLBACK_DEFAULTS.sessionKey,
+    debug: props?.debug?.default ?? FALLBACK_DEFAULTS.debug,
+  };
+}
+
+function normalizeUrl(url) {
+  return String(url || '').trim().replace(/\/$/, '');
+}
+
+function validateApiKey(apiKey) {
+  const v = String(apiKey || '').trim();
+  if (!v) return { valid: false, message: 'API Key 不能为空' };
+  const parts = v.split(':');
+  if (parts.length !== 2) return { valid: false, message: 'API Key 格式应为 bot_xxx:secret' };
+  if (!parts[0] || !parts[1]) return { valid: false, message: 'API Key 缺少 bot_id 或 secret' };
+  if (parts[1].length < 16) return { valid: false, message: 'secret 过短，可能复制不完整' };
+  return { valid: true };
+}
+
+function getCurrentConfig(config) {
+  const entry = config?.plugins?.entries?.[PLUGIN_ID];
+  if (!entry || typeof entry !== 'object') return null;
+  const pluginConfig = entry.config && typeof entry.config === 'object' ? entry.config : {};
+  const defaults = pluginConfig.defaults && typeof pluginConfig.defaults === 'object' ? pluginConfig.defaults : {};
+  const defaultAccount = pluginConfig.accounts?.default && typeof pluginConfig.accounts.default === 'object'
+    ? pluginConfig.accounts.default
+    : {};
+
+  return {
+    relayBaseUrl: normalizeUrl(defaultAccount.relayBaseUrl || defaults.relayBaseUrl),
+    apiKey: String(defaultAccount.apiKey || '').trim(),
+    sessionKey: String(defaultAccount.sessionKey || defaults.sessionKey || '').trim(),
+    pollIntervalMs: Number(defaultAccount.pollIntervalMs || defaults.pollIntervalMs || 0),
+    heartbeatIntervalMs: Number(defaultAccount.heartbeatIntervalMs || defaults.heartbeatIntervalMs || 0),
+    debug: Boolean(defaultAccount.debug ?? defaults.debug),
+  };
+}
+
+function setPluginConfig(config, value) {
+  if (!config.plugins) config.plugins = {};
+  if (!config.plugins.entries) config.plugins.entries = {};
+
+  config.plugins.entries[PLUGIN_ID] = {
+    enabled: true,
+    config: {
+      defaults: {
+        relayBaseUrl: value.relayBaseUrl,
+        pollIntervalMs: value.pollIntervalMs,
+        heartbeatIntervalMs: value.heartbeatIntervalMs,
+        debug: value.debug,
+      },
+      accounts: {
+        default: {
+          apiKey: value.apiKey,
+          relayBaseUrl: value.relayBaseUrl,
+          sessionKey: value.sessionKey,
+        },
+      },
+    },
+  };
+
+  return config;
+}
+
+async function main() {
+  console.log('');
+  console.log(color('════════════════════════════════════════', 1));
+  console.log(color('  iOpenClaw WX 配置初始化', 1));
+  console.log(color('════════════════════════════════════════', 1));
+
+  const defaults = loadManifestDefaults();
+  const currentConfigFile = readJson(CONFIG_FILE) || {};
+  const current = getCurrentConfig(currentConfigFile) || {};
+
+  const rl = createRL();
+
+  try {
+    const currentApiMasked = current.apiKey
+      ? `${current.apiKey.slice(0, 12)}...${current.apiKey.slice(-6)}`
+      : '';
+
+    if (currentApiMasked) {
+      info(`当前 API Key: ${currentApiMasked}`);
+      const keep = (await ask(rl, '是否保留当前 API Key？(Y/n): ')).toLowerCase();
+      if (keep === 'y' || keep === 'yes' || keep === '') {
+        const nextConfig = setPluginConfig(currentConfigFile, {
+          relayBaseUrl: normalizeUrl(current.relayBaseUrl || defaults.relayBaseUrl),
+          apiKey: current.apiKey,
+          sessionKey: current.sessionKey || defaults.sessionKey,
+          pollIntervalMs: current.pollIntervalMs || defaults.pollIntervalMs,
+          heartbeatIntervalMs: current.heartbeatIntervalMs || defaults.heartbeatIntervalMs,
+          debug: typeof current.debug === 'boolean' ? current.debug : defaults.debug,
+        });
+        writeJson(CONFIG_FILE, nextConfig);
+        ok(`已写入配置: ${CONFIG_FILE}`);
+        console.log('');
+        info('下一步执行: openclaw gateway restart');
+        return;
+      }
+    }
+
+    let apiKey = '';
+    while (!apiKey) {
+      const input = await ask(rl, 'API Key（bot_xxx:secret）: ');
+      const validation = validateApiKey(input);
+      if (!validation.valid) {
+        warn(validation.message);
+        continue;
+      }
+      apiKey = input.trim();
+    }
+
+    const nextConfig = setPluginConfig(currentConfigFile, {
+      relayBaseUrl: normalizeUrl(current.relayBaseUrl || defaults.relayBaseUrl),
+      apiKey,
+      sessionKey: current.sessionKey || defaults.sessionKey,
+      pollIntervalMs: current.pollIntervalMs || defaults.pollIntervalMs,
+      heartbeatIntervalMs: current.heartbeatIntervalMs || defaults.heartbeatIntervalMs,
+      debug: typeof current.debug === 'boolean' ? current.debug : defaults.debug,
+    });
+
+    writeJson(CONFIG_FILE, nextConfig);
+
+    ok(`已写入配置: ${CONFIG_FILE}`);
+    console.log('');
+    info('下一步执行: openclaw gateway restart');
+  } catch (error) {
+    err(`配置失败: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  } finally {
+    rl.close();
+  }
+}
+
+main();

package/src/channel.ts

@@ -0,0 +1,198 @@
+import type {
+  ChannelPlugin,
+  ChannelConfig,
+  ChannelInbound,
+  ChannelOutbound,
+  ChannelStatus,
+  ChannelGateway,
+  ChannelMeta,
+} from "openclaw/plugin-sdk";
+import {
+  getPluginConfig,
+  isConfigValid,
+  listAccountIds,
+  isAccountEnabled,
+  validatePluginConfig,
+  type PluginConfig,
+} from "./config.js";
+import { CHANNEL_ID } from "./constants.js";
+import { getRelayRuntime } from "./runtime.js";
+import { resolveSession } from "./session.js";
+import { startPollingService, runPollingCleanup } from "./polling.js";
+
+interface RelayAccount {
+  accountId: string;
+  enabled: boolean;
+  config: PluginConfig;
+}
+
+type LoggerLike = {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+  error?: (msg: string) => void;
+};
+
+const meta: ChannelMeta = {
+  label: "iOpenClaw Relay",
+  selectionLabel: "iOpenClaw Relay",
+  blurb: "Relay bridge for iOpenClaw mini program",
+};
+
+const capabilities = {
+  chatTypes: ["direct"],
+  reactions: false,
+  threads: false,
+  media: false,
+  nativeCommands: true,
+  blockStreaming: true,
+};
+
+function normalizeTarget(raw: string): string | undefined {
+  const v = raw.trim();
+  if (!v) return undefined;
+  if (v.startsWith(`${CHANNEL_ID}:`)) {
+    return v.slice(CHANNEL_ID.length + 1) || undefined;
+  }
+  return v;
+}
+
+function looksLikeTargetId(raw: string): boolean {
+  const v = raw.trim();
+  if (!v) return false;
+  return v.startsWith(`${CHANNEL_ID}:`) || /^[a-zA-Z0-9:_-]{3,}$/.test(v);
+}
+
+const config: ChannelConfig<RelayAccount> = {
+  listAccountIds: (cfg: unknown) => listAccountIds(cfg as any),
+  resolveAccount: (cfg: unknown, accountId: string) => {
+    const resolved = accountId || "default";
+    return {
+      accountId: resolved,
+      enabled: isAccountEnabled(cfg as any, resolved),
+      config: getPluginConfig(cfg as any, resolved),
+    };
+  },
+  isConfigured: (account: RelayAccount) => isConfigValid(account.config),
+  describeAccount: (account: RelayAccount) => ({
+    accountId: account.accountId,
+    enabled: account.enabled,
+    configured: Boolean(account.config.apiKey?.trim()),
+    relayBaseUrl: account.config.relayBaseUrl,
+  }),
+};
+
+const inbound: ChannelInbound<RelayAccount> = {
+  receiveMessage: async (ctx: any) => {
+    const runtime = getRelayRuntime();
+    const cfg = runtime.config?.loadConfig?.();
+    const accountId = ctx.accountId || "default";
+    const session = resolveSession({ cfg, accountId });
+
+    const body = String(ctx?.message?.content || ctx?.message?.text || "").trim();
+    const result = await runtime.gateway.call("chat.send", {
+      sessionKey: session.sessionKey,
+      message: body,
+    });
+
+    return {
+      channel: CHANNEL_ID,
+      messageId: result?.messageId || String(Date.now()),
+    };
+  },
+};
+
+const outbound: ChannelOutbound<RelayAccount> = {
+  deliveryMode: "direct",
+  resolveTarget: ({ to, allowFrom }: { to?: string; allowFrom?: unknown[] }) => {
+    const trimmed = to?.trim() || "";
+    if (trimmed) {
+      return { ok: true, to: normalizeTarget(trimmed) || trimmed };
+    }
+
+    if (allowFrom && allowFrom.length > 0) {
+      const from = String(allowFrom[0] || "").trim();
+      if (from) {
+        return { ok: true, to: normalizeTarget(from) || from };
+      }
+    }
+
+    return {
+      ok: false,
+      error: new Error(`Target is required. Use format: ${CHANNEL_ID}:<target>`),
+    };
+  },
+  sendText: async (_ctx: any) => {
+    throw new Error("Direct outbound sendText is not supported in relay mode. Use inbound dispatch flow.");
+  },
+  sendMedia: async (_ctx: any) => {
+    throw new Error("Direct outbound sendMedia is not supported in relay mode.");
+  },
+};
+
+const status: ChannelStatus<RelayAccount, { ok: boolean }> = {
+  defaultRuntime: {
+    accountId: "default",
+    running: false,
+    lastStartAt: null,
+    lastStopAt: null,
+    lastError: null,
+  },
+  buildChannelSummary: ({ snapshot }: any) => ({
+    configured: snapshot?.configured ?? false,
+    running: snapshot?.running ?? false,
+    lastStartAt: snapshot?.lastStartAt ?? null,
+    lastStopAt: snapshot?.lastStopAt ?? null,
+    lastError: snapshot?.lastError ?? null,
+  }),
+  buildAccountSnapshot: ({ account, runtime }: any) => ({
+    accountId: account.accountId,
+    enabled: account.enabled,
+    configured: Boolean(account.config.apiKey?.trim()),
+    relayBaseUrl: account.config.relayBaseUrl,
+    running: runtime?.running ?? false,
+    lastStartAt: runtime?.lastStartAt ?? null,
+    lastStopAt: runtime?.lastStopAt ?? null,
+    lastError: runtime?.lastError ?? null,
+  }),
+};
+
+const gateway: ChannelGateway<RelayAccount> = {
+  startAccount: async (ctx: { account: RelayAccount; cfg?: unknown; log?: LoggerLike; abortSignal?: AbortSignal }) => {
+    const validation = validatePluginConfig(ctx.cfg as any);
+    if (!validation.ok) {
+      throw new Error(validation.errors.join("; "));
+    }
+
+    if (!ctx.account.config.apiKey?.trim()) {
+      throw new Error("API Key not configured");
+    }
+
+    return await startPollingService(ctx as any);
+  },
+  stopAccount: async (ctx: { account: RelayAccount; log?: LoggerLike }) => {
+    runPollingCleanup(ctx.account.accountId);
+    ctx.log?.info?.(`[${ctx.account.accountId}] relay account stopped`);
+    return {
+      running: false,
+      lastStopAt: Date.now(),
+    };
+  },
+};
+
+export const relayChannelPlugin: ChannelPlugin<RelayAccount, { ok: boolean }> = {
+  id: CHANNEL_ID,
+  meta,
+  capabilities,
+  config,
+  inbound,
+  outbound,
+  status,
+  gateway,
+  messaging: {
+    normalizeTarget,
+    targetResolver: {
+      looksLikeId: looksLikeTargetId,
+      hint: `<target> or ${CHANNEL_ID}:<target>`,
+    },
+  },
+};

package/src/config.ts

@@ -0,0 +1,148 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_CONFIG, PLUGIN_ID } from "./constants.js";
+
+export interface PluginConfig {
+  relayBaseUrl: string;
+  apiKey?: string;
+  pollIntervalMs: number;
+  heartbeatIntervalMs: number;
+  sessionKey: string;
+  debug: boolean;
+}
+
+type AccountConfig = {
+  relayBaseUrl?: string;
+  apiKey?: string;
+  pollIntervalMs?: number;
+  heartbeatIntervalMs?: number;
+  sessionKey?: string;
+  debug?: boolean;
+  enabled?: boolean;
+};
+
+type DefaultsConfig = {
+  relayBaseUrl?: string;
+  pollIntervalMs?: number;
+  heartbeatIntervalMs?: number;
+  sessionKey?: string;
+  debug?: boolean;
+};
+
+function asRecord(value: unknown): Record<string, any> {
+  return value && typeof value === "object" ? (value as Record<string, any>) : {};
+}
+
+function getPluginEntry(cfg?: OpenClawConfig): Record<string, any> {
+  return asRecord(cfg?.plugins?.entries?.[PLUGIN_ID]);
+}
+
+function getRawConfig(cfg?: OpenClawConfig): Record<string, any> {
+  return asRecord(getPluginEntry(cfg).config);
+}
+
+function getDefaults(cfg?: OpenClawConfig): DefaultsConfig {
+  return asRecord(getRawConfig(cfg).defaults) as DefaultsConfig;
+}
+
+function getAccounts(cfg?: OpenClawConfig): Record<string, AccountConfig> {
+  const raw = getRawConfig(cfg);
+  const accounts = asRecord(raw.accounts) as Record<string, AccountConfig>;
+  if (Object.keys(accounts).length > 0) {
+    return accounts;
+  }
+
+  // Compatible with simple single-account config shape
+  if (typeof raw.apiKey === "string" && raw.apiKey.trim()) {
+    return {
+      default: {
+        apiKey: raw.apiKey.trim(),
+        relayBaseUrl: typeof raw.relayBaseUrl === "string" ? raw.relayBaseUrl.trim() : undefined,
+        pollIntervalMs: typeof raw.pollIntervalMs === "number" ? raw.pollIntervalMs : undefined,
+        heartbeatIntervalMs: typeof raw.heartbeatIntervalMs === "number" ? raw.heartbeatIntervalMs : undefined,
+        sessionKey: typeof raw.sessionKey === "string" ? raw.sessionKey : undefined,
+        debug: typeof raw.debug === "boolean" ? raw.debug : undefined,
+        enabled: true,
+      }
+    };
+  }
+
+  return {};
+}
+
+export function listAccountIds(cfg?: OpenClawConfig): string[] {
+  const accounts = getAccounts(cfg);
+  const ids = Object.entries(accounts)
+    .filter(([, account]) => account?.enabled !== false)
+    .map(([id]) => id);
+  return ids.length > 0 ? ids : ["default"];
+}
+
+export function isAccountEnabled(cfg?: OpenClawConfig, accountId = "default"): boolean {
+  const account = getAccounts(cfg)[accountId];
+  if (!account) {
+    return accountId === "default";
+  }
+  return account.enabled !== false;
+}
+
+export function getPluginConfig(cfg?: OpenClawConfig, accountId = "default"): PluginConfig {
+  const defaults = getDefaults(cfg);
+  const account = getAccounts(cfg)[accountId] || {};
+
+  const relayBaseUrl = (account.relayBaseUrl || defaults.relayBaseUrl || DEFAULT_CONFIG.relayBaseUrl).replace(/\/$/, "");
+  const pollIntervalMs = account.pollIntervalMs ?? defaults.pollIntervalMs ?? DEFAULT_CONFIG.pollIntervalMs;
+  const heartbeatIntervalMs = account.heartbeatIntervalMs ?? defaults.heartbeatIntervalMs ?? DEFAULT_CONFIG.heartbeatIntervalMs;
+  const sessionKey = account.sessionKey || defaults.sessionKey || DEFAULT_CONFIG.sessionKey;
+  const debug = account.debug ?? defaults.debug ?? DEFAULT_CONFIG.debug;
+
+  return {
+    relayBaseUrl,
+    apiKey: account.apiKey,
+    pollIntervalMs: Math.min(Math.max(pollIntervalMs, 500), 60000),
+    heartbeatIntervalMs: Math.min(Math.max(heartbeatIntervalMs, 5000), 120000),
+    sessionKey,
+    debug,
+  };
+}
+
+function isValidSessionKeyFormat(key?: string): boolean {
+  const raw = String(key || "").trim();
+  if (!raw) return false;
+  const parts = raw.split(":").filter(Boolean);
+  if (parts.length < 3) return false;
+  return parts[0]?.toLowerCase() === "agent" && !!parts[1]?.trim() && !!parts.slice(2).join(":").trim();
+}
+
+export function validatePluginConfig(cfg?: OpenClawConfig): { ok: true } | { ok: false; errors: string[] } {
+  const errors: string[] = [];
+  const accounts = getAccounts(cfg);
+
+  if (Object.keys(accounts).length === 0) {
+    errors.push("At least one account is required: config.accounts.default.apiKey");
+    return { ok: false, errors };
+  }
+
+  for (const [id, account] of Object.entries(accounts)) {
+    if (account?.enabled === false) continue;
+    if (!account?.apiKey?.trim()) {
+      errors.push(`accounts.${id}.apiKey is required`);
+    }
+    const poll = account?.pollIntervalMs;
+    if (typeof poll === "number" && (poll < 500 || poll > 60000)) {
+      errors.push(`accounts.${id}.pollIntervalMs must be 500-60000`);
+    }
+    const hb = account?.heartbeatIntervalMs;
+    if (typeof hb === "number" && (hb < 5000 || hb > 120000)) {
+      errors.push(`accounts.${id}.heartbeatIntervalMs must be 5000-120000`);
+    }
+    if (account?.sessionKey && !isValidSessionKeyFormat(account.sessionKey)) {
+      errors.push(`accounts.${id}.sessionKey must match agent:<agentId>:<rest>`);
+    }
+  }
+
+  return errors.length > 0 ? { ok: false, errors } : { ok: true };
+}
+
+export function isConfigValid(config: PluginConfig): boolean {
+  return !!config.apiKey?.trim();
+}

package/src/constants.ts

@@ -0,0 +1,11 @@
+export const PLUGIN_VERSION = "0.0.1";
+export const PLUGIN_ID = "iopenclawwx";
+export const CHANNEL_ID = "iopenclawwx";
+
+export const DEFAULT_CONFIG = {
+  relayBaseUrl: "https://pay.9yo.cc/api/relay",
+  pollIntervalMs: 2500,
+  heartbeatIntervalMs: 20000,
+  sessionKey: "agent:main:main",
+  debug: false,
+} as const;

package/src/message-injector.ts

@@ -0,0 +1,150 @@
+import { getRelayRuntime } from "./runtime.js";
+import { resolveSession } from "./session.js";
+import { CHANNEL_ID } from "./constants.js";
+import { relayPushReply } from "./relay-api.js";
+
+export interface InjectMessage {
+  id: number;
+  content: string;
+}
+
+export interface InjectConfig {
+  accountId: string;
+  relayBaseUrl: string;
+  apiKey: string;
+}
+
+function extractReplyText(payload: unknown): string {
+  if (typeof payload === "string") {
+    return payload.trim();
+  }
+
+  if (payload && typeof payload === "object") {
+    const row = payload as Record<string, unknown>;
+    if (typeof row.text === "string") return row.text.trim();
+    if (typeof row.content === "string") return row.content.trim();
+    if (typeof row.message === "string") return row.message.trim();
+  }
+
+  try {
+    return JSON.stringify(payload);
+  } catch {
+    return "";
+  }
+}
+
+export async function injectRelayMessage(
+  message: InjectMessage,
+  config: InjectConfig,
+  log?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+  },
+): Promise<void> {
+  const runtime = getRelayRuntime();
+  const cfg = runtime.config?.loadConfig ? runtime.config.loadConfig() : undefined;
+
+  if (!runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+    throw new Error("dispatchReplyWithBufferedBlockDispatcher is unavailable");
+  }
+
+  const session = resolveSession({
+    cfg,
+    accountId: config.accountId,
+  });
+
+  const body = String(message.content || "").trim() || " ";
+  const fromId = `${config.accountId}:miniapp`;
+
+  const msgContext = runtime.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: body,
+    RawBody: body,
+    CommandBody: body,
+    BodyForCommands: body,
+    From: `${CHANNEL_ID}:${fromId}`,
+    To: `${CHANNEL_ID}:${fromId}`,
+    SessionKey: session.sessionKey,
+    AccountId: config.accountId,
+    MessageSid: String(message.id),
+    Surface: CHANNEL_ID,
+    Provider: CHANNEL_ID,
+    ChatType: "direct",
+    Timestamp: Date.now(),
+    OriginatingChannel: CHANNEL_ID,
+    OriginatingTo: `${CHANNEL_ID}:${fromId}`,
+    CommandSource: "text",
+    CommandAuthorized: true,
+  });
+
+  const storePath = runtime.channel?.session?.resolveStorePath
+    ? runtime.channel.session.resolveStorePath(cfg?.session?.store, { agentId: session.agentId })
+    : undefined;
+
+  if (runtime.channel?.session?.recordInboundSession && storePath) {
+    try {
+      await runtime.channel.session.recordInboundSession({
+        storePath,
+        sessionKey: msgContext.SessionKey ?? session.sessionKey,
+        ctx: msgContext,
+        updateLastRoute: {
+          sessionKey: session.mainSessionKey,
+          channel: CHANNEL_ID,
+          to: fromId,
+          accountId: config.accountId,
+        },
+      });
+    } catch (error) {
+      log?.warn?.(`[${config.accountId}] record inbound session failed: ${error}`);
+    }
+  }
+
+  let replied = false;
+  let firstReplyId = true;
+
+  await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: msgContext,
+    cfg,
+    dispatcherOptions: {
+      deliver: async (payload: unknown, info: unknown) => {
+        const kind = info && typeof info === "object" && "kind" in (info as Record<string, unknown>)
+          ? String((info as Record<string, unknown>).kind || "")
+          : "";
+
+        if (kind !== "final") {
+          return;
+        }
+
+        const text = extractReplyText(payload);
+        if (!text) {
+          return;
+        }
+
+        await relayPushReply({
+          relayBaseUrl: config.relayBaseUrl,
+          apiKey: config.apiKey,
+          replyToMessageId: firstReplyId ? Number(message.id) : Number(message.id),
+          content: text,
+        });
+        firstReplyId = false;
+        replied = true;
+      },
+      onError: (error: unknown, info: unknown) => {
+        const kind = info && typeof info === "object" && "kind" in (info as Record<string, unknown>)
+          ? String((info as Record<string, unknown>).kind || "unknown")
+          : "unknown";
+        log?.error?.(`[${config.accountId}] reply dispatch error (${kind}): ${error}`);
+      },
+    },
+  });
+
+  if (!replied) {
+    await relayPushReply({
+      relayBaseUrl: config.relayBaseUrl,
+      apiKey: config.apiKey,
+      replyToMessageId: Number(message.id),
+      content: "已收到消息，但模型返回为空。",
+    });
+  }
+}

package/src/polling.ts

@@ -0,0 +1,140 @@
+import type { GatewayStartContext } from "openclaw/plugin-sdk";
+import { injectRelayMessage } from "./message-injector.js";
+import { relayHeartbeat, relayPullPending, relayPushReply } from "./relay-api.js";
+import { DEFAULT_CONFIG } from "./constants.js";
+
+const activeCleanupByAccount = new Map<string, () => void>();
+
+function computeRetryDelay(failures: number): number {
+  const base = Math.min(30000, 1000 * 2 ** Math.max(0, failures - 1));
+  const jitter = Math.round(base * 0.2 * Math.random());
+  return Math.max(1000, base + jitter);
+}
+
+export async function startPollingService(ctx: GatewayStartContext) {
+  const { account, abortSignal, log } = ctx;
+  const config = account.config || {};
+
+  const accountId = account.accountId || "default";
+  const relayBaseUrl = String(config.relayBaseUrl || DEFAULT_CONFIG.relayBaseUrl).replace(/\/$/, "");
+  const apiKey = String(config.apiKey || "").trim();
+  const pollIntervalMs = Number(config.pollIntervalMs || DEFAULT_CONFIG.pollIntervalMs);
+  const heartbeatIntervalMs = Number(config.heartbeatIntervalMs || DEFAULT_CONFIG.heartbeatIntervalMs);
+  const debug = Boolean(config.debug);
+
+  if (!apiKey) {
+    throw new Error("API Key not configured");
+  }
+
+  const previous = activeCleanupByAccount.get(accountId);
+  if (previous) {
+    previous();
+    activeCleanupByAccount.delete(accountId);
+  }
+
+  let stopped = false;
+  let pollTimer: ReturnType<typeof setTimeout> | null = null;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  let consecutiveFailures = 0;
+
+  const cleanup = () => {
+    stopped = true;
+    if (pollTimer) {
+      clearTimeout(pollTimer);
+      pollTimer = null;
+    }
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    activeCleanupByAccount.delete(accountId);
+  };
+
+  const scheduleNext = (delayMs: number) => {
+    if (stopped || abortSignal?.aborted) {
+      return;
+    }
+    pollTimer = setTimeout(poll, delayMs);
+  };
+
+  const runHeartbeat = async () => {
+    try {
+      await relayHeartbeat(relayBaseUrl, apiKey);
+    } catch (error) {
+      log?.warn?.(`[${accountId}] heartbeat failed: ${error}`);
+    }
+  };
+
+  const poll = async () => {
+    if (stopped || abortSignal?.aborted) {
+      return;
+    }
+
+    try {
+      const items = await relayPullPending(relayBaseUrl, apiKey, 10);
+      if (debug && items.length > 0) {
+        log?.info?.(`[${accountId}] pulled ${items.length} message(s)`);
+      }
+
+      for (const row of items) {
+        try {
+          await injectRelayMessage(
+            {
+              id: Number(row.id),
+              content: String(row.content || ""),
+            },
+            {
+              accountId,
+              relayBaseUrl,
+              apiKey,
+            },
+            log,
+          );
+        } catch (error) {
+          log?.error?.(`[${accountId}] inject message failed #${row.id}: ${error}`);
+          await relayPushReply({
+            relayBaseUrl,
+            apiKey,
+            replyToMessageId: Number(row.id),
+            content: `机器人处理失败：${error instanceof Error ? error.message : String(error)}`,
+          }).catch(() => {});
+        }
+      }
+
+      consecutiveFailures = 0;
+      scheduleNext(pollIntervalMs);
+    } catch (error) {
+      consecutiveFailures += 1;
+      const retry = computeRetryDelay(consecutiveFailures);
+      log?.warn?.(`[${accountId}] poll failed: ${error}; retry in ${retry}ms`);
+      scheduleNext(retry);
+    }
+  };
+
+  activeCleanupByAccount.set(accountId, cleanup);
+
+  await runHeartbeat();
+  heartbeatTimer = setInterval(runHeartbeat, heartbeatIntervalMs);
+  poll();
+
+  return {
+    running: true,
+    lastStartAt: Date.now(),
+    cleanup,
+  };
+}
+
+export function runPollingCleanup(accountId?: string): void {
+  if (accountId) {
+    const cleanup = activeCleanupByAccount.get(accountId);
+    if (cleanup) {
+      cleanup();
+    }
+    return;
+  }
+
+  for (const cleanup of activeCleanupByAccount.values()) {
+    cleanup();
+  }
+  activeCleanupByAccount.clear();
+}

package/src/relay-api.ts

@@ -0,0 +1,75 @@
+export interface RelayPendingMessage {
+  id: number;
+  content: string;
+  created_at?: string;
+}
+
+async function relayRequest<T>(params: {
+  relayBaseUrl: string;
+  path: string;
+  apiKey: string;
+  method?: "GET" | "POST";
+  body?: Record<string, unknown>;
+}): Promise<T> {
+  const { relayBaseUrl, path, apiKey, method = "GET", body } = params;
+
+  const response = await fetch(`${relayBaseUrl}${path}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-KEY": apiKey,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok || !data.success) {
+    throw new Error(data.message || `Relay request failed: ${response.status}`);
+  }
+
+  return (data.data || {}) as T;
+}
+
+export async function relayHeartbeat(relayBaseUrl: string, apiKey: string): Promise<void> {
+  await relayRequest({
+    relayBaseUrl,
+    path: "/plugin_heartbeat.php",
+    apiKey,
+    method: "POST",
+    body: {},
+  });
+}
+
+export async function relayPullPending(
+  relayBaseUrl: string,
+  apiKey: string,
+  limit = 10,
+): Promise<RelayPendingMessage[]> {
+  const safeLimit = Math.min(Math.max(limit, 1), 30);
+  const data = await relayRequest<{ items?: RelayPendingMessage[] }>({
+    relayBaseUrl,
+    path: `/plugin_pull.php?limit=${safeLimit}`,
+    apiKey,
+    method: "GET",
+  });
+
+  return Array.isArray(data.items) ? data.items : [];
+}
+
+export async function relayPushReply(params: {
+  relayBaseUrl: string;
+  apiKey: string;
+  replyToMessageId: number;
+  content: string;
+}): Promise<void> {
+  await relayRequest({
+    relayBaseUrl: params.relayBaseUrl,
+    path: "/plugin_reply.php",
+    apiKey: params.apiKey,
+    method: "POST",
+    body: {
+      reply_to_message_id: params.replyToMessageId,
+      content: params.content,
+    },
+  });
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setRelayRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getRelayRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("Relay runtime not initialized");
+  }
+  return runtime;
+}

package/src/session.ts

@@ -0,0 +1,42 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_CONFIG } from "./constants.js";
+import { getPluginConfig } from "./config.js";
+
+export interface SessionResult {
+  sessionKey: string;
+  mainSessionKey: string;
+  agentId: string;
+}
+
+function isValidSessionKeyFormat(key: string): boolean {
+  const raw = String(key || "").trim();
+  if (!raw) return false;
+  const parts = raw.split(":").filter(Boolean);
+  if (parts.length < 3) return false;
+  if (parts[0]?.toLowerCase() !== "agent") return false;
+  if (!parts[1]?.trim()) return false;
+  return !!parts.slice(2).join(":").trim();
+}
+
+function parseAgentIdFromSessionKey(sessionKey: string): string {
+  const parts = sessionKey.trim().split(":");
+  if (parts.length >= 2 && parts[0]?.toLowerCase() === "agent") {
+    return parts[1]?.trim() || "main";
+  }
+  return "main";
+}
+
+export function resolveSession(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+}): SessionResult {
+  const pluginConfig = getPluginConfig(params.cfg, params.accountId);
+  const raw = (pluginConfig.sessionKey || "").trim();
+  const sessionKey = isValidSessionKeyFormat(raw) ? raw : DEFAULT_CONFIG.sessionKey;
+
+  return {
+    sessionKey,
+    mainSessionKey: sessionKey,
+    agentId: parseAgentIdFromSessionKey(sessionKey),
+  };
+}

package/src/types/openclaw-plugin-sdk.d.ts

@@ -0,0 +1,14 @@
+declare module "openclaw/plugin-sdk" {
+  export type OpenClawConfig = any;
+  export type PluginRuntime = any;
+  export type OpenClawPluginApi = any;
+  export type GatewayStartContext = any;
+
+  export type ChannelPlugin<TAccount = any, TProbe = any> = any;
+  export type ChannelConfig<TAccount = any> = any;
+  export type ChannelInbound<TAccount = any> = any;
+  export type ChannelOutbound<TAccount = any> = any;
+  export type ChannelStatus<TAccount = any, TProbe = any> = any;
+  export type ChannelGateway<TAccount = any> = any;
+  export type ChannelMeta = any;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "openclaw/plugin-sdk": [
+        "src/types/openclaw-plugin-sdk.d.ts"
+      ]
+    }
+  },
+  "include": [
+    "index.ts",
+    "src/**/*.ts"
+  ]
+}