@a2hmarket/a2hmarket 2026.3.19

package/src/api/inbox.ts

@@ -0,0 +1,221 @@
+/**
+ * In-memory inbox event queue.
+ * Replaces the SQLite message_event table from the Go implementation.
+ * Deduplicates by message_id; evicts oldest events when queue exceeds 1000 items.
+ */
+
+import type { Envelope } from "../a2a-protocol.js";
+
+export type InboxEvent = {
+  event_id: string;
+  peer_id: string;
+  message_id: string;
+  msg_ts: number;
+  preview: string;
+  state: "NEW" | "PUSHED" | "ACKED";
+  payload: Record<string, unknown>;
+  created_at: number;
+  seq: number;
+};
+
+export type InboxPullResult = {
+  consumer_id: string;
+  cursor: number;
+  events: InboxEvent[];
+  count: number;
+};
+
+const MAX_QUEUE_SIZE = 1000;
+
+// event_id → InboxEvent
+const eventMap = new Map<string, InboxEvent>();
+
+// message_id → event_id (for deduplication)
+const messageIdIndex = new Map<string, string>();
+
+// consumerId → Set<event_id> (acked events per consumer)
+const ackMap = new Map<string, Set<string>>();
+
+// Monotonically increasing sequence number; used for cursor-based pagination
+let globalSeq = 0;
+
+/**
+ * Ingest an envelope from MQTT into the memory queue.
+ * Returns the created InboxEvent, or null if it was a duplicate.
+ */
+export function ingestEvent(envelope: Envelope): InboxEvent | null {
+  // Deduplicate by message_id
+  if (messageIdIndex.has(envelope.message_id)) {
+    return null;
+  }
+
+  const seq = ++globalSeq;
+  const eventId = `ev_${seq}_${envelope.message_id}`;
+  const now = Date.now();
+
+  // Build a human-readable preview from the payload
+  const text =
+    (envelope.payload.text as string | undefined) ||
+    (envelope.payload.message as string | undefined) ||
+    (envelope.payload.content as string | undefined) ||
+    "";
+  const preview = text.slice(0, 200) || `[${envelope.message_type}]`;
+
+  const event: InboxEvent = {
+    event_id: eventId,
+    peer_id: envelope.sender_id,
+    message_id: envelope.message_id,
+    msg_ts: now,
+    preview,
+    state: "NEW",
+    payload: envelope.payload,
+    created_at: now,
+    seq,
+  };
+
+  eventMap.set(eventId, event);
+  messageIdIndex.set(envelope.message_id, eventId);
+
+  // Evict oldest events when over capacity
+  if (eventMap.size > MAX_QUEUE_SIZE) {
+    // Find the event with the smallest seq
+    let minSeq = Infinity;
+    let minEventId = "";
+    for (const [eid, ev] of eventMap) {
+      if (ev.seq < minSeq) {
+        minSeq = ev.seq;
+        minEventId = eid;
+      }
+    }
+    if (minEventId) {
+      const oldEv = eventMap.get(minEventId);
+      if (oldEv) {
+        messageIdIndex.delete(oldEv.message_id);
+      }
+      eventMap.delete(minEventId);
+    }
+  }
+
+  return event;
+}
+
+/**
+ * Pull events for a consumer starting after `cursor` (seq number).
+ * Optionally filter by peer_id.
+ * Only returns events not yet acked by this consumer.
+ */
+export function pullEvents(
+  consumerId: string,
+  cursor: number,
+  limit: number,
+  peerIdFilter?: string,
+): InboxPullResult {
+  const acked = ackMap.get(consumerId) ?? new Set<string>();
+
+  const matching: InboxEvent[] = [];
+  for (const ev of eventMap.values()) {
+    if (ev.seq <= cursor) continue;
+    if (acked.has(ev.event_id)) continue;
+    if (peerIdFilter && ev.peer_id !== peerIdFilter) continue;
+    matching.push(ev);
+  }
+
+  // Sort by seq ascending
+  matching.sort((a, b) => a.seq - b.seq);
+
+  const events = matching.slice(0, limit);
+  const newCursor = events.length > 0 ? events[events.length - 1].seq : cursor;
+
+  return {
+    consumer_id: consumerId,
+    cursor: newCursor,
+    events,
+    count: events.length,
+  };
+}
+
+/**
+ * Mark an event as acknowledged (read) by a consumer.
+ */
+export function ackEvent(
+  consumerId: string,
+  eventId: string,
+): { acked_at: number; inserted: boolean } {
+  if (!ackMap.has(consumerId)) {
+    ackMap.set(consumerId, new Set());
+  }
+  const acked = ackMap.get(consumerId)!;
+  const inserted = !acked.has(eventId);
+  acked.add(eventId);
+
+  // Update event state if it exists
+  const ev = eventMap.get(eventId);
+  if (ev && ev.state === "NEW") {
+    ev.state = "ACKED";
+  }
+
+  return { acked_at: Date.now(), inserted };
+}
+
+/**
+ * Return the number of unread (unacked) events for a consumer.
+ */
+export function peekUnread(consumerId: string): { unread: number } {
+  const acked = ackMap.get(consumerId) ?? new Set<string>();
+  let unread = 0;
+  for (const ev of eventMap.values()) {
+    if (!acked.has(ev.event_id)) {
+      unread++;
+    }
+  }
+  return { unread };
+}
+
+/**
+ * Return the total number of events in the queue.
+ */
+export function getQueueSize(): number {
+  return eventMap.size;
+}
+
+/**
+ * Return a single InboxEvent by event_id, or null if not found.
+ */
+export function getEvent(eventId: string): InboxEvent | null {
+  return eventMap.get(eventId) ?? null;
+}
+
+export type InboxHistoryResult = {
+  peer_id: string;
+  page: number;
+  limit: number;
+  total: number;
+  items: Array<InboxEvent & { direction: "recv" }>;
+};
+
+/**
+ * Return received messages from a specific peer, paginated.
+ * Note: only inbound (recv) messages are available in the in-memory queue.
+ * Outbound messages are not stored in the inbox queue.
+ */
+export function historyByPeer(
+  peerId: string,
+  page: number,
+  limit: number,
+): InboxHistoryResult {
+  const matching: Array<InboxEvent & { direction: "recv" }> = [];
+  for (const ev of eventMap.values()) {
+    if (ev.peer_id === peerId) {
+      matching.push({ ...ev, direction: "recv" });
+    }
+  }
+
+  // Sort by seq descending (newest first)
+  matching.sort((a, b) => b.seq - a.seq);
+
+  const total = matching.length;
+  const offset = (page - 1) * limit;
+  const items = matching.slice(offset, offset + limit);
+
+  return { peer_id: peerId, page, limit, total, items };
+}

package/src/api/order.ts

@@ -0,0 +1,69 @@
+/**
+ * Order API — create, query, and manage trade orders.
+ */
+
+import type { ApiClient } from "../api-client.js";
+
+export type OrderAction =
+  | "confirm"
+  | "reject"
+  | "cancel"
+  | "confirm-received"
+  | "confirm-service-completed";
+
+export async function orderCreate(
+  client: ApiClient,
+  opts: {
+    customerId: string;
+    title: string;
+    content: string;
+    price: number;
+    productId: string;
+    orderType: 2 | 3;
+  },
+): Promise<unknown> {
+  const creds = client.getCredentials();
+  return client.post<unknown>("/findu-trade/api/v1/orders/create", {
+    providerId: creds.agent_id,
+    customerId: opts.customerId,
+    title: opts.title,
+    content: opts.content,
+    price: opts.price,
+    productId: opts.productId,
+    orderType: opts.orderType,
+  });
+}
+
+export async function orderGet(
+  client: ApiClient,
+  orderId: string,
+): Promise<unknown> {
+  return client.get<unknown>(`/findu-trade/api/v1/orders/${orderId}/detail`);
+}
+
+export async function orderAction(
+  client: ApiClient,
+  orderId: string,
+  action: OrderAction,
+): Promise<unknown> {
+  return client.post<unknown>(
+    `/findu-trade/api/v1/orders/${orderId}/${action}`,
+    {},
+  );
+}
+
+export async function orderList(
+  client: ApiClient,
+  kind: "sales" | "purchase",
+  opts: { page?: number; pageSize?: number; status?: string },
+): Promise<unknown> {
+  const page = opts.page ?? 1;
+  const pageSize = opts.pageSize ?? 10;
+  const endpoint = kind === "sales" ? "sales-orders" : "purchase-orders";
+  const signPath = `/findu-trade/api/v1/orders/${endpoint}`;
+  let apiPath = `${signPath}?page=${page}&pageSize=${pageSize}`;
+  if (opts.status) {
+    apiPath += `&status=${encodeURIComponent(opts.status)}`;
+  }
+  return client.get<unknown>(apiPath, signPath);
+}

package/src/api/profile.ts

@@ -0,0 +1,27 @@
+/**
+ * Profile API — get and update agent profile.
+ */
+
+import type { ApiClient } from "../api-client.js";
+
+export type ProfileData = {
+  nickname: string;
+  avatarUrl: string;
+  bio: string;
+  abilities: unknown;
+  realnameStatus: unknown;
+  paymentQrcodeUrl: string;
+};
+
+export async function profileGet(client: ApiClient): Promise<ProfileData> {
+  return client.get<ProfileData>("/findu-user/api/v1/user/profile/public");
+}
+
+export async function profileSetPaymentQrcode(
+  client: ApiClient,
+  url: string,
+): Promise<unknown> {
+  return client.post<unknown>("/findu-user/api/v1/user/profile/change-requests", {
+    paymentQrcodeUrl: url,
+  });
+}

package/src/api/send.ts

@@ -0,0 +1,134 @@
+/**
+ * Send A2A messages via MQTT.
+ * Reuses the persistent listener connection when available,
+ * falling back to a short-lived _pub_ connection otherwise.
+ */
+
+import mqtt from "mqtt";
+import type { Credentials } from "../api-client.js";
+import { buildEnvelope, signEnvelope } from "../a2a-protocol.js";
+import type { Envelope } from "../a2a-protocol.js";
+import { fetchMqttToken } from "../api-client.js";
+import { getMqttClient } from "../service/mqtt-listener.js";
+
+export type SendOptions = {
+  targetAgentId: string;
+  text?: string;
+  payloadJson?: Record<string, unknown>;
+  messageType?: string;
+  attachmentLocalPath?: string; // local file path (OSS upload first)
+  attachmentUrl?: string;       // direct external URL
+  paymentQr?: string;
+};
+
+export type SendResult = {
+  message_id: string;
+  target_id: string;
+  type: string;
+};
+
+/**
+ * Build the message payload from send options.
+ */
+function buildPayload(opts: SendOptions): Record<string, unknown> {
+  if (opts.payloadJson) {
+    return opts.payloadJson;
+  }
+  const p: Record<string, unknown> = {};
+  if (opts.text) p.text = opts.text;
+  if (opts.attachmentUrl) p.attachmentUrl = opts.attachmentUrl;
+  if (opts.paymentQr) p.paymentQr = opts.paymentQr;
+  return p;
+}
+
+/**
+ * Publish a signed envelope to MQTT using a short-lived _pub_ connection.
+ * Used when the persistent listener is not connected.
+ */
+async function publishWithPubConnection(
+  creds: Credentials,
+  targetAgentId: string,
+  envelope: Envelope,
+): Promise<void> {
+  const token = await fetchMqttToken(creds);
+  const random8 = Math.floor(Math.random() * 0xffffffff)
+    .toString(16)
+    .padStart(8, "0");
+  const clientId = `GID_agent@@@${creds.agent_id}_pub_${random8}`;
+  const topic = `P2P_TOPIC/p2p/GID_agent@@@${targetAgentId}`;
+  const payload = JSON.stringify(envelope);
+
+  const brokerUrl = `mqtts://${token.instance_id}.mqtt.aliyuncs.com:8883`;
+  await new Promise<void>((resolve, reject) => {
+    const client = mqtt.connect(brokerUrl, {
+      clientId,
+      username: token.username,
+      password: token.password,
+      clean: true,          // one-shot sender uses clean session
+      keepalive: 60,
+      connectTimeout: 15000,
+      reconnectPeriod: 0,
+      rejectUnauthorized: false,
+    });
+
+    const timeout = setTimeout(() => {
+      client.end(true);
+      reject(new Error("MQTT publish timeout (15s)"));
+    }, 15000);
+
+    client.once("connect", () => {
+      client.publish(topic, payload, { qos: 1 }, (err) => {
+        clearTimeout(timeout);
+        client.end(false);
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+
+    client.once("error", (err) => {
+      clearTimeout(timeout);
+      client.end(true);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Send an A2A message to another agent.
+ * Tries to reuse the persistent MQTT listener connection first;
+ * falls back to a short-lived _pub_ connection if not connected.
+ */
+export async function sendMessage(
+  creds: Credentials,
+  opts: SendOptions,
+): Promise<SendResult> {
+  const payload = buildPayload(opts);
+  const messageType = opts.messageType ?? "chat.request";
+
+  // Build and sign the envelope
+  const unsigned = buildEnvelope(creds.agent_id, opts.targetAgentId, messageType, payload);
+  const envelope = signEnvelope(creds.agent_key, unsigned);
+
+  const topic = `P2P_TOPIC/p2p/GID_agent@@@${opts.targetAgentId}`;
+  const payloadStr = JSON.stringify(envelope);
+
+  // Try to reuse the persistent listener connection
+  const existingClient = getMqttClient();
+  if (existingClient?.connected) {
+    await new Promise<void>((resolve, reject) => {
+      existingClient.publish(topic, payloadStr, { qos: 1 }, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  } else {
+    // Fall back to a short-lived pub connection
+    await publishWithPubConnection(creds, opts.targetAgentId, envelope);
+  }
+
+  return {
+    message_id: envelope.message_id,
+    target_id: opts.targetAgentId,
+    type: messageType,
+  };
+}

package/src/api/works.ts

@@ -0,0 +1,82 @@
+/**
+ * Works API — search, publish, list, and delete works posts.
+ */
+
+import type { ApiClient } from "../api-client.js";
+
+export async function worksSearch(
+  client: ApiClient,
+  opts: {
+    keyword?: string;
+    agentId?: string;
+    type?: 2 | 3;
+    pageNum?: number;
+    pageSize?: number;
+  },
+): Promise<unknown> {
+  return client.post<unknown>(
+    "/findu-match/api/v1/inner/match/works_search",
+    {
+      serviceInfo: opts.keyword ?? "",
+      pageNum: opts.pageNum ?? 0,
+      pageSize: opts.pageSize ?? 10,
+      type: opts.type ?? 3,
+      agentId: opts.agentId ?? "",
+    },
+  );
+}
+
+export async function worksPublish(
+  client: ApiClient,
+  opts: {
+    type: 2 | 3;
+    title: string;
+    content: string;
+    expectedPrice?: string;
+    serviceMethod?: string;
+    serviceLocation?: string;
+    pictures?: string[];
+    worksId?: string;
+  },
+): Promise<unknown> {
+  const body: Record<string, unknown> = {
+    type: opts.type,
+    title: opts.title,
+    content: opts.content,
+    extendInfo: {
+      pois: [],
+      expectedPrice: opts.expectedPrice ?? "",
+      serviceMethod: opts.serviceMethod ?? "online",
+      serviceLocation: opts.serviceLocation ?? "",
+    },
+    pictures: opts.pictures ?? [],
+  };
+  if (opts.worksId) {
+    body.worksId = opts.worksId;
+  }
+  return client.post<unknown>("/findu-user/api/v1/user/works/change-requests", body);
+}
+
+export async function worksList(
+  client: ApiClient,
+  opts: {
+    type?: 2 | 3;
+    pageNum?: number;
+    pageSize?: number;
+  },
+): Promise<unknown> {
+  const pageNum = opts.pageNum ?? 1;
+  const pageSize = opts.pageSize ?? 10;
+  const type = opts.type ?? 3;
+  // signPath must NOT include query string
+  const signPath = "/findu-user/api/v1/user/works/public";
+  const apiPath = `${signPath}?pageNum=${pageNum}&pageSize=${pageSize}&type=${type}`;
+  return client.get<unknown>(apiPath, signPath);
+}
+
+export async function worksDelete(
+  client: ApiClient,
+  worksId: string,
+): Promise<unknown> {
+  return client.delete<unknown>(`/findu-user/api/v1/user/works/${worksId}`);
+}