@a2hmarket/a2hmarket 2026.3.19

package/src/service/lease-client.ts

@@ -0,0 +1,118 @@
+/**
+ * Lease control-plane client.
+ * Coordinates leader/follower role for multi-instance deployments of the same agentId.
+ * Mirrors the Go lease.Client in a2hmarket-cli/internal/lease/client.go.
+ */
+
+import { createHmac, randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join, dirname } from "node:path";
+import type { Credentials } from "../api-client.js";
+
+const PATH_ACQUIRE   = "/agent-service/api/v1/agent-runtime/lease/acquire";
+const PATH_HEARTBEAT = "/agent-service/api/v1/agent-runtime/lease/heartbeat";
+
+const INSTANCE_ID_PATH = join(homedir(), ".a2hmarket", "instance_id");
+
+export type LeaseRole = "leader" | "follower" | "standalone";
+
+export type AcquireResult = {
+  role: LeaseRole;
+  epoch: number;
+  leaseUntil: number;
+  leaderInstanceId?: string;
+};
+
+export type HeartbeatResult = {
+  ok: boolean;
+  reason?: string;
+  epoch: number;
+  leaseUntil: number;
+};
+
+// ─── Instance ID persistence ─────────────────────────────────────────────────
+
+/**
+ * Load the persistent instance ID from disk, or generate and save a new one.
+ * Instance ID is stable across gateway restarts on the same machine.
+ */
+export function loadOrCreateInstanceId(): string {
+  if (existsSync(INSTANCE_ID_PATH)) {
+    try {
+      const id = readFileSync(INSTANCE_ID_PATH, "utf-8").trim();
+      if (id) return id;
+    } catch {
+      // fall through to generate
+    }
+  }
+  const id = randomUUID().replace(/-/g, "").slice(0, 16);
+  mkdirSync(dirname(INSTANCE_ID_PATH), { recursive: true });
+  writeFileSync(INSTANCE_ID_PATH, id, "utf-8");
+  return id;
+}
+
+// ─── HTTP helpers ─────────────────────────────────────────────────────────────
+
+function buildHeaders(creds: Credentials, method: string, path: string): Record<string, string> {
+  const ts = String(Math.floor(Date.now() / 1000));
+  const payload = `${method}&${path}&${creds.agent_id}&${ts}`;
+  const sig = createHmac("sha256", creds.agent_key).update(payload).digest("hex");
+  return {
+    "Content-Type": "application/json",
+    "X-Agent-Id": creds.agent_id,
+    "X-Timestamp": ts,
+    "X-Agent-Signature": sig,
+  };
+}
+
+async function leasePost<T>(creds: Credentials, path: string, body: unknown): Promise<T> {
+  const url = `${creds.api_url}${path}`;
+  const headers = buildHeaders(creds, "POST", path);
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!resp.ok) {
+    throw new Error(`lease HTTP ${resp.status}`);
+  }
+  const wrapper = (await resp.json()) as { success: boolean; data?: T; error?: string };
+  if (!wrapper.success) {
+    throw new Error(`lease server error: ${wrapper.error ?? "unknown"}`);
+  }
+  return wrapper.data as T;
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Acquire (or forcefully take over) the leader lease for this instance.
+ * Pass forceTakeover=true to immediately displace any existing leader.
+ */
+export async function acquireLease(
+  creds: Credentials,
+  instanceId: string,
+  clientId: string,
+  forceTakeover: boolean,
+): Promise<AcquireResult> {
+  return leasePost<AcquireResult>(creds, PATH_ACQUIRE, {
+    instanceId,
+    clientId,
+    hostname: hostname(),
+    forceTakeover,
+  });
+}
+
+/**
+ * Send a heartbeat to renew the leader lease.
+ * Returns ok=false when the lease has been revoked (another instance took over).
+ */
+export async function sendHeartbeat(
+  creds: Credentials,
+  instanceId: string,
+  epoch: number,
+): Promise<HeartbeatResult> {
+  return leasePost<HeartbeatResult>(creds, PATH_HEARTBEAT, { instanceId, epoch });
+}

package/src/service/mqtt-listener.ts

@@ -0,0 +1,419 @@
+/**
+ * MQTT Listener Service — persistent MQTT connection for receiving A2A messages.
+ * Replaces the Go binary listener daemon with an in-process openclaw service.
+ *
+ * Leader election:
+ *   On startup, acquires the leader lease with forceTakeover=true so the newest
+ *   instance always wins.  The displaced leader detects revocation on its next
+ *   heartbeat and stops reconnecting.
+ *
+ *   role=leader   → clientId GID_agent@@@{agentId}, clean:false, subscribes
+ *   role=follower → clientId GID_agent@@@{agentId}_rt_{instanceId}, no subscribe
+ *   standalone    → control plane unreachable; behave as leader (best-effort)
+ */
+
+import mqtt from "mqtt";
+import type { MqttClient } from "mqtt";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { readCredentials } from "../credentials.js";
+import type { Credentials } from "../api-client.js";
+import { fetchMqttToken } from "../api-client.js";
+import { parseEnvelope } from "../a2a-protocol.js";
+import type { Envelope } from "../a2a-protocol.js";
+import { ingestEvent } from "../api/inbox.js";
+import { getCachedSessionKey, hasChannelSession } from "../session-cache.js";
+import {
+  loadOrCreateInstanceId,
+  acquireLease,
+  sendHeartbeat,
+  type LeaseRole,
+} from "./lease-client.js";
+
+// Reconnect delay sequence (seconds)
+const RECONNECT_DELAYS = [1, 2, 4, 8, 16, 30];
+
+const HEARTBEAT_INTERVAL_MS = 15_000;
+const FOLLOWER_POLL_INTERVAL_MS = 20_000;
+
+// Module-level singleton client; shared with send.ts via getMqttClient()
+let _client: MqttClient | null = null;
+let _connected = false;
+let _sessionPresent = false;
+let _reconnectAttempts = 0;
+
+// Set to true when stop() is called to prevent scheduled reconnects
+let _stopped = false;
+
+// Lease state
+let _role: LeaseRole = "standalone";
+let _leaseEpoch = 0;
+let _instanceId = "";
+let _heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+let _followerPollTimer: ReturnType<typeof setInterval> | null = null;
+
+export function getMqttClient(): MqttClient | null {
+  return _client;
+}
+
+export function getListenerStatus(): {
+  connected: boolean;
+  sessionPresent: boolean;
+  reconnectAttempts: number;
+  role: LeaseRole;
+  instanceId: string;
+} {
+  return {
+    connected: _connected,
+    sessionPresent: _sessionPresent,
+    reconnectAttempts: _reconnectAttempts,
+    role: _role,
+    instanceId: _instanceId,
+  };
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function clearTimers(): void {
+  if (_heartbeatTimer) { clearInterval(_heartbeatTimer); _heartbeatTimer = null; }
+  if (_followerPollTimer) { clearInterval(_followerPollTimer); _followerPollTimer = null; }
+}
+
+// ─── Incoming message handler ─────────────────────────────────────────────────
+
+async function handleIncomingMessage(
+  rawPayload: string,
+  creds: Credentials,
+  api: OpenClawPluginApi,
+  logger: { info: (msg: string) => void; warn: (msg: string) => void },
+): Promise<void> {
+  const envelope: Envelope | null = parseEnvelope(rawPayload);
+  if (!envelope) {
+    logger.warn("a2hmarket-mqtt-listener: failed to parse envelope");
+    return;
+  }
+
+  if (envelope.protocol !== "a2hmarket-a2a") return;
+  if (!envelope.message_id || !envelope.sender_id) return;
+
+  const event = ingestEvent(envelope);
+  if (!event) {
+    logger.info(`a2hmarket-mqtt-listener: duplicate message ${envelope.message_id}`);
+    return;
+  }
+
+  logger.info(
+    `a2hmarket-mqtt-listener: received event_id=${event.event_id} from ${envelope.sender_id}`,
+  );
+
+  const sessionKey = getCachedSessionKey();
+  const preview = event.preview || "(no preview)";
+  // Be explicit: tell the AI which tool to call and with what args, so it
+  // doesn't fall back to trying CLI commands.
+  const message = [
+    `[A2HMarket 新消息到达]`,
+    `来自: ${envelope.sender_id}`,
+    `event_id: ${event.event_id}`,
+    `摘要: ${preview}`,
+    ``,
+    `请立即执行：`,
+    `1. 调用 inbox_pull 工具读取完整消息内容`,
+    `2. 调用 inbox_ack 工具确认消息（传入 eventId: "${event.event_id}"）`,
+    `3. 根据消息内容决定是否需要用 send_message 工具回复对方`,
+  ].join("\n");
+
+  if (!api.runtime?.subagent?.run) {
+    logger.warn(`a2hmarket-mqtt-listener: subagent.run unavailable (openclaw version too old), event_id=${event.event_id} queued in inbox`);
+    return;
+  }
+
+  // Only use deliver:true when a specific channel session (e.g. Feishu) is active.
+  // With the fallback "agent:main:main" session, deliver:true causes a Feishu error
+  // ("requires target") because openclaw doesn't know which user to push to.
+  // The subagent still runs and processes the message either way.
+  const deliver = hasChannelSession();
+
+  try {
+    await api.runtime.subagent.run({
+      sessionKey,
+      message,
+      deliver,
+      idempotencyKey: `a2hmarket-mqtt:${event.event_id}`,
+    });
+    logger.info(`a2hmarket-mqtt-listener: delivered event_id=${event.event_id}`);
+  } catch (err) {
+    logger.warn(`a2hmarket-mqtt-listener: subagent.run failed: ${String(err)}`);
+  }
+}
+
+// ─── Reconnect scheduler ──────────────────────────────────────────────────────
+
+async function scheduleReconnect(
+  api: OpenClawPluginApi,
+  logger: { info: (msg: string) => void; warn: (msg: string) => void },
+  attempt: number,
+): Promise<void> {
+  if (_stopped) return;
+
+  const delaySeconds = RECONNECT_DELAYS[Math.min(attempt, RECONNECT_DELAYS.length - 1)];
+  logger.info(
+    `a2hmarket-mqtt-listener: reconnecting in ${delaySeconds}s (attempt ${attempt + 1})`,
+  );
+  await sleep(delaySeconds * 1000);
+
+  if (_stopped) return;
+
+  const creds = readCredentials();
+  if (!creds) {
+    logger.warn("a2hmarket-mqtt-listener: no credentials on reconnect, giving up");
+    return;
+  }
+
+  try {
+    await connectAndSubscribe(creds, api, logger, attempt + 1);
+  } catch (err) {
+    logger.warn(
+      `a2hmarket-mqtt-listener: reconnect attempt ${attempt + 1} failed: ${String(err)}`,
+    );
+    scheduleReconnect(api, logger, attempt + 1).catch(() => undefined);
+  }
+}
+
+// ─── MQTT connect ─────────────────────────────────────────────────────────────
+
+async function connectAndSubscribe(
+  creds: Credentials,
+  api: OpenClawPluginApi,
+  logger: { info: (msg: string) => void; warn: (msg: string) => void },
+  attempt = 0,
+): Promise<void> {
+  // clientId depends on role:
+  //   leader/standalone → base clientId (persistent session, receives messages)
+  //   follower          → instance-unique suffix (no session conflict, no subscribe)
+  const isFollower = _role === "follower";
+  const clientId = isFollower
+    ? `GID_agent@@@${creds.agent_id}_rt_${_instanceId}`
+    : `GID_agent@@@${creds.agent_id}`;
+
+  // Pass the actual clientId so the token matches the connection clientId.
+  // Broker validates token.clientId == connection clientId; mismatch causes disconnect.
+  const token = await fetchMqttToken(creds, clientId);
+  const incomingTopic = `P2P_TOPIC/p2p/GID_agent@@@${creds.agent_id}`;
+
+  // Clean up any existing client
+  if (_client) {
+    try { _client.end(true); } catch { /* ignore */ }
+    _client = null;
+    _connected = false;
+  }
+
+  _reconnectAttempts = attempt;
+
+  const brokerUrl = `mqtts://${token.instance_id}.mqtt.aliyuncs.com:8883`;
+
+  const client = mqtt.connect(brokerUrl, {
+    clientId,
+    username: token.username,
+    password: token.password,
+    clean: isFollower,      // followers use clean session; leader uses persistent
+    keepalive: 60,   // broker keepalive; token.clientId must match connection clientId
+    connectTimeout: 15000,
+    reconnectPeriod: 0,     // manual reconnect
+    rejectUnauthorized: false,
+  });
+
+  _client = client;
+
+  client.on("connect", (connack) => {
+    _connected = true;
+    _sessionPresent = connack.sessionPresent ?? false;
+    _reconnectAttempts = 0;
+
+    if (!isFollower) {
+      logger.info(
+        `a2hmarket-mqtt-listener: connected role=${_role} (sessionPresent=${_sessionPresent}), subscribing to ${incomingTopic}`,
+      );
+      client.subscribe(incomingTopic, { qos: 1 }, (err) => {
+        if (err) {
+          logger.warn(`a2hmarket-mqtt-listener: subscribe error: ${err.message}`);
+        } else {
+          logger.info(`a2hmarket-mqtt-listener: subscribed to ${incomingTopic}`);
+        }
+      });
+    } else {
+      logger.info(
+        `a2hmarket-mqtt-listener: connected role=follower (standby, not subscribing)`,
+      );
+    }
+  });
+
+  client.on("message", (_topic, payload) => {
+    handleIncomingMessage(payload.toString(), creds, api, logger).catch((err) => {
+      logger.warn(`a2hmarket-mqtt-listener: message handler error: ${String(err)}`);
+    });
+  });
+
+  client.on("close", () => {
+    _connected = false;
+    if (!_stopped) {
+      logger.info("a2hmarket-mqtt-listener: connection closed, scheduling reconnect");
+      scheduleReconnect(api, logger, _reconnectAttempts).catch(() => undefined);
+    }
+  });
+
+  client.on("error", (err) => {
+    logger.warn(`a2hmarket-mqtt-listener: error: ${err.message}`);
+  });
+}
+
+// ─── Heartbeat loop (leader only) ────────────────────────────────────────────
+
+function startHeartbeat(
+  creds: Credentials,
+  api: OpenClawPluginApi,
+  logger: { info: (msg: string) => void; warn: (msg: string) => void },
+): void {
+  clearTimers();
+  _heartbeatTimer = setInterval(async () => {
+    if (_stopped || _role !== "leader") return;
+    try {
+      const result = await sendHeartbeat(creds, _instanceId, _leaseEpoch);
+      if (!result.ok) {
+        // Lease revoked — another instance took over. Stop gracefully.
+        logger.warn(
+          `a2hmarket-mqtt-listener: lease revoked (reason=${result.reason ?? "unknown"}), stepping down`,
+        );
+        _stopped = true;
+        clearTimers();
+        if (_client) {
+          _client.unsubscribe(`P2P_TOPIC/p2p/GID_agent@@@${creds.agent_id}`);
+          _client.end(true);
+          _client = null;
+          _connected = false;
+        }
+        return;
+      }
+      _leaseEpoch = result.epoch;
+    } catch (err) {
+      logger.warn(`a2hmarket-mqtt-listener: heartbeat failed: ${String(err)}`);
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+}
+
+// ─── Follower poll loop ───────────────────────────────────────────────────────
+
+function startFollowerPoll(
+  creds: Credentials,
+  api: OpenClawPluginApi,
+  logger: { info: (msg: string) => void; warn: (msg: string) => void },
+): void {
+  clearTimers();
+  const clientId = `GID_agent@@@${creds.agent_id}_rt_${_instanceId}`;
+  _followerPollTimer = setInterval(async () => {
+    if (_stopped || _role !== "follower") return;
+    try {
+      const result = await acquireLease(creds, _instanceId, clientId, false);
+      if (result.role === "leader") {
+        logger.info(
+          `a2hmarket-mqtt-listener: promoted to leader (epoch=${result.epoch}), reconnecting`,
+        );
+        clearTimers();
+        _role = "leader";
+        _leaseEpoch = result.epoch;
+        // Reconnect with base clientId + subscribe
+        connectAndSubscribe(creds, api, logger, 0).catch((err) => {
+          logger.warn(`a2hmarket-mqtt-listener: reconnect after promotion failed: ${String(err)}`);
+        });
+        startHeartbeat(creds, api, logger);
+      }
+    } catch (err) {
+      logger.warn(`a2hmarket-mqtt-listener: follower poll failed: ${String(err)}`);
+    }
+  }, FOLLOWER_POLL_INTERVAL_MS);
+}
+
+// ─── Publish helper (used by send.ts) ────────────────────────────────────────
+
+export async function publishMessage(
+  targetAgentId: string,
+  envelope: Envelope,
+): Promise<void> {
+  if (!_client?.connected) {
+    throw new Error("mqtt-listener: not connected");
+  }
+  const topic = `P2P_TOPIC/p2p/GID_agent@@@${targetAgentId}`;
+  const payload = JSON.stringify(envelope);
+  await new Promise<void>((resolve, reject) => {
+    _client!.publish(topic, payload, { qos: 1 }, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+
+// ─── Service registration ─────────────────────────────────────────────────────
+
+export function registerMqttListenerService(api: OpenClawPluginApi): void {
+  api.registerService({
+    id: "a2hmarket-mqtt-listener",
+
+    start: (ctx) => {
+      const logger = ctx.logger ?? api.logger;
+      _stopped = false;
+      clearTimers();
+
+      const creds = readCredentials();
+      if (!creds) {
+        logger.warn("a2hmarket-mqtt-listener: no credentials found, skipping MQTT connection");
+        return;
+      }
+
+      _instanceId = loadOrCreateInstanceId();
+      const baseClientId = `GID_agent@@@${creds.agent_id}`;
+
+      logger.info(`a2hmarket-mqtt-listener: service started, instanceId=${_instanceId}`);
+
+      // Acquire lease with forceTakeover=true: new instance always displaces the old one.
+      acquireLease(creds, _instanceId, baseClientId, true)
+        .then((result) => {
+          _role = result.role;
+          _leaseEpoch = result.epoch;
+          logger.info(
+            `a2hmarket-mqtt-listener: lease acquired role=${_role} epoch=${_leaseEpoch}`,
+          );
+
+          return connectAndSubscribe(creds, api, logger, 0).then(() => {
+            if (_role === "leader") {
+              startHeartbeat(creds, api, logger);
+            } else if (_role === "follower") {
+              startFollowerPoll(creds, api, logger);
+            }
+          });
+        })
+        .catch((err) => {
+          // Control plane unreachable — fall back to standalone (connect as leader, no heartbeat).
+          logger.warn(
+            `a2hmarket-mqtt-listener: lease acquire failed (standalone mode): ${String(err)}`,
+          );
+          _role = "standalone";
+          connectAndSubscribe(creds, api, logger, 0).catch((connectErr) => {
+            logger.warn(`a2hmarket-mqtt-listener: initial connect failed: ${String(connectErr)}`);
+            scheduleReconnect(api, logger, 0).catch(() => undefined);
+          });
+        });
+    },
+
+    stop: (ctx) => {
+      _stopped = true;
+      clearTimers();
+      const logger = ctx.logger ?? api.logger;
+      if (_client) {
+        _client.end(true);
+        _client = null;
+        _connected = false;
+      }
+      logger.info("a2hmarket-mqtt-listener: service stopped");
+    },
+  });
+}

package/src/session-cache.ts

@@ -0,0 +1,73 @@
+/**
+ * In-process cache for the most recently active openclaw session key.
+ * Used by the MQTT listener to route push notifications to the correct session.
+ *
+ * On first call, bootstraps from sessions.json so gateway restarts don't lose
+ * the last active session (Feishu, webchat, or any other channel).
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const FALLBACK_SESSION_KEY = "agent:main:main";
+const SESSIONS_PATH = join(homedir(), ".openclaw", "agents", "main", "sessions", "sessions.json");
+
+// Patterns that identify channel sessions (non-webchat, non-generic)
+const CHANNEL_KEY_PATTERNS = [":feishu:", ":discord:", ":slack:", ":telegram:"];
+
+function isChannelKey(key: string): boolean {
+  return CHANNEL_KEY_PATTERNS.some((p) => key.includes(p));
+}
+
+/**
+ * Read sessions.json and return the most recently updated session key.
+ * Returns null if the file doesn't exist or is empty.
+ */
+function loadMostRecentSession(): string | null {
+  try {
+    if (!existsSync(SESSIONS_PATH)) return null;
+    const raw = readFileSync(SESSIONS_PATH, "utf-8");
+    const store = JSON.parse(raw) as Record<string, { updatedAt?: number }>;
+    let bestKey: string | null = null;
+    let bestTime = 0;
+    for (const [key, meta] of Object.entries(store)) {
+      const t = meta?.updatedAt ?? 0;
+      if (t > bestTime) {
+        bestTime = t;
+        bestKey = key;
+      }
+    }
+    return bestKey;
+  } catch {
+    return null;
+  }
+}
+
+let cachedSessionKey: string | null = null;
+let bootstrapped = false;
+
+function bootstrap(): void {
+  if (bootstrapped) return;
+  bootstrapped = true;
+  const key = loadMostRecentSession();
+  if (key) cachedSessionKey = key;
+}
+
+/** Update the cached session key to the most recently active session. */
+export function setCachedSessionKey(key: string): void {
+  if (!key?.trim()) return;
+  cachedSessionKey = key.trim();
+}
+
+/** Returns the most recently active session key, or the fallback. */
+export function getCachedSessionKey(): string {
+  bootstrap();
+  return cachedSessionKey ?? FALLBACK_SESSION_KEY;
+}
+
+/** Returns true if the current session is a specific channel (Feishu, Discord, etc.). */
+export function hasChannelSession(): boolean {
+  bootstrap();
+  return !!cachedSessionKey && isChannelKey(cachedSessionKey);
+}

package/src/tools/index.ts

@@ -0,0 +1,14 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { registerInboxTools } from "./tool-inbox.js";
+import { registerOrderTools } from "./tool-order.js";
+import { registerProfileTool } from "./tool-profile.js";
+import { registerSendTool } from "./tool-send.js";
+import { registerWorksTools } from "./tool-works.js";
+
+export function registerAllTools(api: OpenClawPluginApi): void {
+  registerInboxTools(api);
+  registerSendTool(api);
+  registerWorksTools(api);
+  registerOrderTools(api);
+  registerProfileTool(api);
+}