@dhf-hermes/grix 0.1.0

package/shared/cli/actions.mjs

@@ -0,0 +1,339 @@
+import { resolveAibotOutboundTarget, resolveSilentUnsendPlan } from "./targets.mjs";
+
+function cleanText(value) {
+  return String(value ?? "").trim();
+}
+
+function cleanInt(value, fallback = undefined) {
+  const numeric = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function cleanBool(value, fallback = undefined) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  const normalized = cleanText(value).toLowerCase();
+  if (["true", "1", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["false", "0", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function cleanList(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => cleanText(item)).filter(Boolean);
+  }
+  return cleanText(value).split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+function extractCategoryList(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  const record = asRecord(data);
+  if (!record) {
+    return [];
+  }
+  for (const key of ["categories", "list", "items", "rows", "data"]) {
+    if (Array.isArray(record[key])) {
+      return record[key];
+    }
+  }
+  return [];
+}
+
+function extractAgentId(data) {
+  const record = asRecord(data) || {};
+  return cleanText(record.id || record.agent_id);
+}
+
+function extractCategoryId(data) {
+  const record = asRecord(data) || {};
+  return cleanText(record.id || record.category_id);
+}
+
+function findCategoryByName(data, name, parentId) {
+  return extractCategoryList(data).find((item) => {
+    const record = asRecord(item) || {};
+    return cleanText(record.name) === cleanText(name)
+      && cleanText(record.parent_id ?? record.parentId ?? "0") === cleanText(parentId || "0");
+  }) || null;
+}
+
+export async function runQuery(client, options) {
+  const action = cleanText(options.action);
+  const map = {
+    contact_search: "contact_search",
+    session_search: "session_search",
+    message_history: "message_history",
+    message_search: "message_search"
+  };
+  if (!map[action]) {
+    throw new Error(`Unsupported grix query action: ${action}`);
+  }
+  const params = {};
+  if (cleanText(options.id)) {
+    params.id = cleanText(options.id);
+  }
+  if (cleanText(options.keyword)) {
+    params.keyword = cleanText(options.keyword);
+  }
+  if (cleanText(options.sessionId)) {
+    params.session_id = cleanText(options.sessionId);
+  }
+  if (cleanText(options.beforeId)) {
+    params.before_id = cleanText(options.beforeId);
+  }
+  const limit = cleanInt(options.limit);
+  if (limit !== undefined) {
+    params.limit = limit;
+  }
+  const offset = cleanInt(options.offset);
+  if (offset !== undefined) {
+    params.offset = offset;
+  }
+  return {
+    ok: true,
+    accountId: options.accountId,
+    action,
+    data: await client.agentInvoke(map[action], params)
+  };
+}
+
+export async function runGroup(client, options) {
+  const action = cleanText(options.action);
+  const map = {
+    create: "group_create",
+    detail: "group_detail_read",
+    leave: "group_leave_self",
+    add_members: "group_member_add",
+    remove_members: "group_member_remove",
+    update_member_role: "group_member_role_update",
+    update_all_members_muted: "group_all_members_muted_update",
+    update_member_speaking: "group_member_speaking_update",
+    dissolve: "group_dissolve"
+  };
+  if (!map[action]) {
+    throw new Error(`Unsupported grix group action: ${action}`);
+  }
+  const params = {};
+  if (cleanText(options.name)) {
+    params.name = cleanText(options.name);
+  }
+  if (cleanText(options.sessionId)) {
+    params.session_id = cleanText(options.sessionId);
+  }
+  const memberIds = cleanList(options.memberIds);
+  if (memberIds.length > 0) {
+    params.member_ids = memberIds;
+  }
+  const memberTypes = cleanList(options.memberTypes).map((item) => Number.parseInt(item, 10)).filter((item) => Number.isFinite(item));
+  if (memberTypes.length > 0) {
+    params.member_types = memberTypes;
+  }
+  if (cleanText(options.memberId)) {
+    params.member_id = cleanText(options.memberId);
+  }
+  const memberType = cleanInt(options.memberType);
+  if (memberType !== undefined) {
+    params.member_type = memberType;
+  }
+  const role = cleanInt(options.role);
+  if (role !== undefined) {
+    params.role = role;
+  }
+  const allMembersMuted = cleanBool(options.allMembersMuted);
+  if (allMembersMuted !== undefined) {
+    params.all_members_muted = allMembersMuted;
+  }
+  const isSpeakMuted = cleanBool(options.isSpeakMuted);
+  if (isSpeakMuted !== undefined) {
+    params.is_speak_muted = isSpeakMuted;
+  }
+  const canSpeakWhenAllMuted = cleanBool(options.canSpeakWhenAllMuted);
+  if (canSpeakWhenAllMuted !== undefined) {
+    params.can_speak_when_all_muted = canSpeakWhenAllMuted;
+  }
+  return {
+    ok: true,
+    accountId: options.accountId,
+    action,
+    data: await client.agentInvoke(map[action], params)
+  };
+}
+
+async function listCategories(client) {
+  return client.agentInvoke("agent_category_list", {});
+}
+
+export async function runAdmin(client, options) {
+  const action = cleanText(options.action || "create_agent");
+  if (action === "list_categories") {
+    return {
+      ok: true,
+      accountId: options.accountId,
+      action,
+      data: await listCategories(client)
+    };
+  }
+  if (action === "create_category") {
+    return {
+      ok: true,
+      accountId: options.accountId,
+      action,
+      data: await client.agentInvoke("agent_category_create", {
+        name: cleanText(options.name),
+        parent_id: cleanText(options.parentId || options.parentCategoryId || "0"),
+        sort_order: cleanInt(options.sortOrder || options.categorySortOrder)
+      })
+    };
+  }
+  if (action === "update_category") {
+    return {
+      ok: true,
+      accountId: options.accountId,
+      action,
+      data: await client.agentInvoke("agent_category_update", {
+        category_id: cleanText(options.categoryId),
+        name: cleanText(options.name),
+        parent_id: cleanText(options.parentId || options.parentCategoryId || "0"),
+        sort_order: cleanInt(options.sortOrder || options.categorySortOrder)
+      })
+    };
+  }
+  if (action === "assign_category") {
+    return {
+      ok: true,
+      accountId: options.accountId,
+      action,
+      data: await client.agentInvoke("agent_category_assign", {
+        agent_id: cleanText(options.agentId),
+        category_id: cleanText(options.categoryId)
+      })
+    };
+  }
+  if (action !== "create_agent") {
+    throw new Error(`Unsupported grix admin action: ${action}`);
+  }
+
+  const createPayload = {
+    agent_name: cleanText(options.agentName),
+    introduction: cleanText(options.introduction) || undefined,
+    is_main: cleanBool(options.isMain, false) ?? false
+  };
+  const createdAgent = await client.agentInvoke("agent_api_create", createPayload);
+  const createdAgentId = extractAgentId(createdAgent);
+  let category = null;
+  let assignment = null;
+
+  const categoryId = cleanText(options.categoryId);
+  const categoryName = cleanText(options.categoryName);
+  if (categoryId && categoryName) {
+    throw new Error("create_agent cannot accept both categoryId and categoryName");
+  }
+
+  let resolvedCategoryId = categoryId;
+  if (!resolvedCategoryId && categoryName) {
+    const parentCategoryId = cleanText(options.parentCategoryId || "0");
+    const rawListData = await listCategories(client);
+    category = findCategoryByName(rawListData, categoryName, parentCategoryId);
+    if (!category) {
+      category = await client.agentInvoke("agent_category_create", {
+        name: categoryName,
+        parent_id: parentCategoryId,
+        sort_order: cleanInt(options.categorySortOrder)
+      });
+    }
+    resolvedCategoryId = extractCategoryId(category);
+  }
+
+  if (resolvedCategoryId && createdAgentId) {
+    assignment = await client.agentInvoke("agent_category_assign", {
+      agent_id: createdAgentId,
+      category_id: resolvedCategoryId
+    });
+  }
+
+  return {
+    ok: true,
+    accountId: options.accountId,
+    action,
+    createdAgent,
+    category,
+    assignment
+  };
+}
+
+export async function runUnsend(client, options) {
+  const plan = await resolveSilentUnsendPlan({
+    client,
+    accountId: options.accountId,
+    messageId: options.messageId,
+    targetSessionId: options.sessionId,
+    targetTo: options.to,
+    targetTopic: options.topic,
+    currentChannelId: options.currentChannelId,
+    currentMessageId: options.currentMessageId
+  });
+
+  const targetAck = await client.deleteMessage(plan.targetDelete.sessionId, plan.targetDelete.messageId);
+  let commandAck = null;
+  if (plan.commandDelete) {
+    commandAck = await client.deleteMessage(plan.commandDelete.sessionId, plan.commandDelete.messageId);
+  }
+
+  return {
+    ok: true,
+    accountId: options.accountId,
+    targetDelete: plan.targetDelete,
+    commandDelete: plan.commandDelete || null,
+    completionMessageId: plan.completionMessageId || null,
+    targetAck,
+    commandAck
+  };
+}
+
+export async function runSend(client, options) {
+  const message = String(options.message ?? "");
+  if (!message.trim()) {
+    throw new Error("message-send requires message");
+  }
+  const target = cleanText(options.to || options.target);
+  if (!target) {
+    throw new Error("message-send requires to/target");
+  }
+  const resolved = await resolveAibotOutboundTarget({
+    client,
+    accountId: options.accountId,
+    to: target
+  });
+  const ack = await client.sendText(
+    resolved.sessionId,
+    message,
+    {
+      threadId: cleanText(options.threadId) || resolved.threadId,
+      replyToMessageId: cleanText(options.replyToMessageId),
+      eventId: cleanText(options.eventId)
+    }
+  );
+  return {
+    ok: true,
+    accountId: options.accountId,
+    target,
+    resolvedTarget: resolved,
+    message,
+    ack
+  };
+}

package/shared/cli/aibot-client.mjs

@@ -0,0 +1,274 @@
+import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
+
+function nowMs() {
+  return Date.now();
+}
+
+function normalizeText(value) {
+  return String(value ?? "").trim();
+}
+
+function parseCode(payload) {
+  const code = Number(payload?.code ?? 0);
+  return Number.isFinite(code) ? code : 0;
+}
+
+function parseMessage(payload) {
+  return normalizeText(payload?.msg) || normalizeText(payload?.message) || "unknown error";
+}
+
+function packetError(packet) {
+  return new Error(`grix ${packet.cmd}: code=${parseCode(packet.payload)} msg=${parseMessage(packet.payload)}`);
+}
+
+function buildAuthPayload(config) {
+  return {
+    agent_id: config.agentId,
+    api_key: config.apiKey,
+    client: config.client,
+    client_type: config.clientType,
+    client_version: config.clientVersion,
+    protocol_version: "aibot-agent-api-v1",
+    contract_version: config.contractVersion ?? 1,
+    host_type: config.hostType || "hermes",
+    capabilities: config.capabilities || ["session_route", "thread_v1", "inbound_media_v1", "local_action_v1"],
+    local_actions: config.localActions || ["exec_approve", "exec_reject"]
+  };
+}
+
+export class AibotWsClient {
+  constructor(config) {
+    this.config = config;
+    this.ws = null;
+    this.seq = nowMs();
+    this.authed = false;
+    this.pending = new Map();
+  }
+
+  ensureReady(requireAuthed = true) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("grix websocket is not connected");
+    }
+    if (requireAuthed && !this.authed) {
+      throw new Error("grix websocket is not authenticated");
+    }
+  }
+
+  async connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.authed) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.config.endpoint, {
+        handshakeTimeout: this.config.connectTimeoutMs
+      });
+      this.ws = ws;
+
+      ws.on("open", () => resolve());
+      ws.on("error", (error) => reject(error));
+      ws.on("close", (_code, reason) => {
+        const message = normalizeText(reason) || "grix websocket closed";
+        this.rejectAll(new Error(message));
+        this.authed = false;
+      });
+      ws.on("message", (data) => {
+        void this.handleMessage(data);
+      });
+    });
+
+    const authPacket = await this.request(
+      "auth",
+      buildAuthPayload(this.config),
+      { expected: ["auth_ack"], timeoutMs: 10000, requireAuthed: false }
+    );
+    if (parseCode(authPacket.payload) !== 0) {
+      throw packetError(authPacket);
+    }
+    this.authed = true;
+  }
+
+  async disconnect(reason = "done") {
+    this.rejectAll(new Error(reason));
+    this.authed = false;
+    const ws = this.ws;
+    this.ws = null;
+    if (!ws) {
+      return;
+    }
+    await new Promise((resolve) => {
+      ws.once("close", () => resolve());
+      ws.close(1000, reason);
+      setTimeout(resolve, 500);
+    });
+  }
+
+  rejectAll(error) {
+    for (const { timer, reject } of this.pending.values()) {
+      clearTimeout(timer);
+      reject(error);
+    }
+    this.pending.clear();
+  }
+
+  nextSeq() {
+    this.seq += 1;
+    return this.seq;
+  }
+
+  sendPacket(cmd, payload, seq = 0) {
+    this.ensureReady(false);
+    this.ws.send(JSON.stringify({ cmd, seq, payload }));
+  }
+
+  request(cmd, payload, options = {}) {
+    this.ensureReady(options.requireAuthed !== false);
+    const seq = this.nextSeq();
+    const expected = new Set(options.expected || []);
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : (this.config.requestTimeoutMs || 20000);
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(seq);
+        reject(new Error(`${cmd} timeout`));
+      }, timeoutMs);
+      this.pending.set(seq, { expected, resolve, reject, timer });
+      this.sendPacket(cmd, payload, seq);
+    });
+  }
+
+  async handleMessage(data) {
+    const text = Buffer.isBuffer(data) ? data.toString("utf8") : String(data ?? "");
+    if (!text) {
+      return;
+    }
+    let packet;
+    try {
+      packet = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!packet || typeof packet !== "object") {
+      return;
+    }
+    if (packet.cmd === "ping") {
+      this.sendPacket("pong", { ts: nowMs() }, Number(packet.seq) > 0 ? Number(packet.seq) : 0);
+      return;
+    }
+    const seq = Number(packet.seq || 0);
+    const pending = this.pending.get(seq);
+    if (!pending) {
+      return;
+    }
+    if (!pending.expected.has(packet.cmd)) {
+      if (packet.cmd === "error") {
+        clearTimeout(pending.timer);
+        this.pending.delete(seq);
+        pending.reject(packetError(packet));
+      }
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(seq);
+    pending.resolve(packet);
+  }
+
+  async agentInvoke(action, params = {}, options = {}) {
+    const normalizedAction = normalizeText(action);
+    if (!normalizedAction) {
+      throw new Error("grix agent_invoke requires action");
+    }
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(1000, options.timeoutMs) : 15000;
+    const packet = await this.request(
+      "agent_invoke",
+      {
+        invoke_id: randomUUID(),
+        action: normalizedAction,
+        params,
+        timeout_ms: timeoutMs
+      },
+      { expected: ["agent_invoke_result"], timeoutMs }
+    );
+    if (parseCode(packet.payload) !== 0) {
+      throw packetError(packet);
+    }
+    return packet.payload?.data;
+  }
+
+  async sendText(sessionId, text, options = {}) {
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedText = String(text ?? "");
+    if (!normalizedSessionId) {
+      throw new Error("grix send_msg requires session_id");
+    }
+    if (!normalizedText.trim()) {
+      throw new Error("grix send_msg requires content");
+    }
+    const payload = {
+      session_id: normalizedSessionId,
+      msg_type: 1,
+      content: normalizedText
+    };
+    if (normalizeText(options.replyToMessageId)) {
+      payload.quoted_message_id = normalizeText(options.replyToMessageId);
+    }
+    if (normalizeText(options.threadId)) {
+      payload.thread_id = normalizeText(options.threadId);
+    }
+    if (normalizeText(options.eventId)) {
+      payload.event_id = normalizeText(options.eventId);
+    }
+    const packet = await this.request(
+      "send_msg",
+      payload,
+      { expected: ["send_ack", "send_nack", "error"], timeoutMs: options.timeoutMs }
+    );
+    if (packet.cmd !== "send_ack") {
+      throw packetError(packet);
+    }
+    return packet.payload;
+  }
+
+  async deleteMessage(sessionId, messageId, options = {}) {
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedMessageId = normalizeText(messageId);
+    if (!normalizedSessionId) {
+      throw new Error("grix delete_msg requires session_id");
+    }
+    if (!/^\d+$/.test(normalizedMessageId)) {
+      throw new Error("grix delete_msg requires numeric msg_id");
+    }
+    const packet = await this.request(
+      "delete_msg",
+      {
+        session_id: normalizedSessionId,
+        msg_id: normalizedMessageId
+      },
+      { expected: ["send_ack", "send_nack", "error"], timeoutMs: options.timeoutMs }
+    );
+    if (packet.cmd !== "send_ack") {
+      throw packetError(packet);
+    }
+    return packet.payload;
+  }
+
+  async resolveSessionRoute(channel, accountId, routeSessionKey, options = {}) {
+    const packet = await this.request(
+      "session_route_resolve",
+      {
+        channel: normalizeText(channel),
+        account_id: normalizeText(accountId),
+        route_session_key: normalizeText(routeSessionKey)
+      },
+      { expected: ["send_ack", "send_nack", "error"], timeoutMs: options.timeoutMs }
+    );
+    if (packet.cmd !== "send_ack") {
+      throw packetError(packet);
+    }
+    const sessionId = normalizeText(packet.payload?.session_id);
+    if (!sessionId) {
+      throw new Error("grix session_route_resolve ack missing session_id");
+    }
+    return packet.payload;
+  }
+}

package/shared/cli/card-links.mjs

@@ -0,0 +1,90 @@
+function cleanText(value) {
+  return String(value ?? "").trim();
+}
+
+function encodeValue(value) {
+  return encodeURIComponent(cleanText(value));
+}
+
+function buildLink(label, url) {
+  return `[${cleanText(label)}](${url})`;
+}
+
+export function buildConversationCard(params) {
+  const sessionId = cleanText(params.sessionId);
+  const sessionType = cleanText(params.sessionType);
+  const title = cleanText(params.title);
+  if (!sessionId || !sessionType || !title) {
+    throw new Error("conversation card requires sessionId, sessionType, and title");
+  }
+  const query = new URLSearchParams({
+    session_id: sessionId,
+    session_type: sessionType,
+    title,
+  });
+  const peerId = cleanText(params.peerId);
+  if (peerId) {
+    query.set("peer_id", peerId);
+  }
+  return buildLink(cleanText(params.label) || "打开会话", `grix://card/conversation?${query.toString()}`);
+}
+
+export function buildUserProfileCard(params) {
+  const userId = cleanText(params.userId);
+  const nickname = cleanText(params.nickname);
+  if (!userId || !nickname) {
+    throw new Error("user profile card requires userId and nickname");
+  }
+  const query = new URLSearchParams({
+    user_id: userId,
+    peer_type: cleanText(params.peerType) || "2",
+    nickname,
+  });
+  const avatarUrl = cleanText(params.avatarUrl);
+  if (avatarUrl) {
+    query.set("avatar_url", avatarUrl);
+  }
+  return buildLink(cleanText(params.label) || "查看 Agent 资料", `grix://card/user_profile?${query.toString()}`);
+}
+
+export function buildEggStatusCard(params) {
+  const installId = cleanText(params.installId);
+  const status = cleanText(params.status);
+  const step = cleanText(params.step);
+  const summary = cleanText(params.summary);
+  if (!installId || !status || !step || !summary) {
+    throw new Error("egg status card requires installId, status, step, and summary");
+  }
+  const query = new URLSearchParams({
+    install_id: installId,
+    status,
+    step,
+    summary,
+  });
+  const targetAgentId = cleanText(params.targetAgentId);
+  if (targetAgentId) {
+    query.set("target_agent_id", targetAgentId);
+  }
+  const errorCode = cleanText(params.errorCode);
+  if (errorCode) {
+    query.set("error_code", errorCode);
+  }
+  const errorMessage = cleanText(params.errorMessage);
+  if (errorMessage) {
+    query.set("error_msg", errorMessage);
+  }
+  return buildLink(cleanText(params.label) || "安装状态", `grix://card/egg_install_status?${query.toString()}`);
+}
+
+export function dispatchCardBuilder(kind, params) {
+  if (kind === "conversation") {
+    return buildConversationCard(params);
+  }
+  if (kind === "user-profile") {
+    return buildUserProfileCard(params);
+  }
+  if (kind === "egg-status") {
+    return buildEggStatusCard(params);
+  }
+  throw new Error(`Unsupported card kind: ${kind}`);
+}