@dhf-openclaw/grix 0.4.9 → 0.4.10

package/dist/index.js

@@ -5056,6 +5056,1278 @@ var aibotPlugin = {
   }
 };
 
+// src/admin/agent-api-actions.ts
+var AGENT_NAME_RE = /^[a-z][a-z0-9-]{2,31}$/;
+function readRawParam(params, key) {
+  if (Object.hasOwn(params, key)) {
+    return params[key];
+  }
+  return void 0;
+}
+function isPlainObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function readStringParam2(params, key) {
+  const raw = readRawParam(params, key);
+  if (typeof raw === "string") {
+    return raw.trim();
+  }
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return String(raw);
+  }
+  return "";
+}
+function readRequiredStringParam(params, key) {
+  const value = readStringParam2(params, key);
+  if (!value) {
+    throw new Error(`Grix action requires ${key}.`);
+  }
+  return value;
+}
+function readArrayParam(params, key) {
+  const raw = readRawParam(params, key);
+  if (raw == null) {
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error(`Grix action requires ${key} as array.`);
+  }
+  return raw;
+}
+function readNumericIDArray(params, key, required) {
+  const values = readArrayParam(params, key);
+  if (!values || values.length == 0) {
+    if (required) {
+      throw new Error(`Grix action requires non-empty ${key}.`);
+    }
+    return [];
+  }
+  const normalized = [];
+  for (const item of values) {
+    const value = typeof item === "string" ? item.trim() : typeof item === "number" && Number.isFinite(item) ? String(Math.trunc(item)) : "";
+    if (!/^\d+$/.test(value)) {
+      throw new Error(`Grix action ${key} must contain numeric IDs.`);
+    }
+    normalized.push(value);
+  }
+  return normalized;
+}
+function readIntArray(params, key) {
+  const values = readArrayParam(params, key);
+  if (!values || values.length == 0) {
+    return [];
+  }
+  const normalized = [];
+  for (const item of values) {
+    const num = typeof item === "number" ? item : Number(String(item ?? "").trim());
+    if (!Number.isInteger(num)) {
+      throw new Error(`Grix action ${key} must contain integers.`);
+    }
+    normalized.push(num);
+  }
+  return normalized;
+}
+function readOptionalInt(params, key) {
+  const raw = readRawParam(params, key);
+  if (raw == null) {
+    return void 0;
+  }
+  const num = typeof raw === "number" ? raw : Number(String(raw).trim());
+  if (!Number.isInteger(num)) {
+    throw new Error(`Grix action ${key} must be an integer.`);
+  }
+  return num;
+}
+function readRequiredInt(params, key) {
+  const value = readOptionalInt(params, key);
+  if (value == null) {
+    throw new Error(`Grix action requires ${key}.`);
+  }
+  return value;
+}
+function readOptionalBool(params, key) {
+  const raw = readRawParam(params, key);
+  if (raw == null) {
+    return void 0;
+  }
+  if (typeof raw === "boolean") {
+    return raw;
+  }
+  if (typeof raw === "number") {
+    if (raw === 1) return true;
+    if (raw === 0) return false;
+  }
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1") return true;
+    if (normalized === "false" || normalized === "0") return false;
+  }
+  throw new Error(`Grix action ${key} must be a boolean.`);
+}
+function readRequiredBool(params, key) {
+  const value = readOptionalBool(params, key);
+  if (value == null) {
+    throw new Error(`Grix action requires ${key}.`);
+  }
+  return value;
+}
+function normalizeStringList(raw, key, required) {
+  if (!Array.isArray(raw)) {
+    if (required) {
+      throw new Error(`Grix action requires ${key}.`);
+    }
+    return [];
+  }
+  if (required && raw.length === 0) {
+    throw new Error(`Grix action requires non-empty ${key}.`);
+  }
+  const normalized = [];
+  for (const value of raw) {
+    if (typeof value !== "string") {
+      throw new Error(`Grix action ${key} must contain strings.`);
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error(`Grix action ${key} must not contain empty strings.`);
+    }
+    normalized.push(trimmed);
+  }
+  return normalized;
+}
+function normalizeSchemaContribution(raw, key) {
+  if (!isPlainObject(raw)) {
+    throw new Error(`Grix action ${key} must be an object.`);
+  }
+  if (!isPlainObject(raw.properties)) {
+    throw new Error(`Grix action ${key}.properties must be an object.`);
+  }
+  const contribution = {
+    properties: raw.properties
+  };
+  if (Object.hasOwn(raw, "visibility")) {
+    const visibility = readStringParam2(raw, "visibility");
+    if (visibility !== "current-channel" && visibility !== "all-configured") {
+      throw new Error(
+        `Grix action ${key}.visibility must be current-channel or all-configured.`
+      );
+    }
+    contribution.visibility = visibility;
+  }
+  return contribution;
+}
+function readRequiredDescribeMessageTool(params) {
+  const raw = readRawParam(params, "describeMessageTool");
+  if (!isPlainObject(raw)) {
+    throw new Error("Grix action requires describeMessageTool as object.");
+  }
+  const actions = normalizeStringList(raw.actions, "describeMessageTool.actions", true);
+  const payload = { actions };
+  if (Object.hasOwn(raw, "capabilities")) {
+    payload.capabilities = normalizeStringList(
+      raw.capabilities,
+      "describeMessageTool.capabilities",
+      false
+    );
+  }
+  if (Object.hasOwn(raw, "schema")) {
+    const schema = raw.schema;
+    if (Array.isArray(schema)) {
+      if (schema.length === 0) {
+        throw new Error("Grix action describeMessageTool.schema must not be empty.");
+      }
+      payload.schema = schema.map(
+        (item, idx) => normalizeSchemaContribution(item, `describeMessageTool.schema[${idx}]`)
+      );
+    } else {
+      payload.schema = normalizeSchemaContribution(schema, "describeMessageTool.schema");
+    }
+  }
+  return payload;
+}
+function ensureMemberTypes(types) {
+  for (const memberType of types) {
+    if (memberType !== 1 && memberType !== 2) {
+      throw new Error("Grix action member_types only supports 1 (human) or 2 (agent).");
+    }
+  }
+}
+function ensureMemberType(memberType) {
+  if (memberType !== 1) {
+    throw new Error("Grix action member_type only supports 1 for role update.");
+  }
+}
+function ensureSpeakingMemberType(memberType) {
+  if (memberType !== 1 && memberType !== 2) {
+    throw new Error("Grix action member_type only supports 1 (human) or 2 (agent).");
+  }
+}
+function buildGroupCreateRequest(params) {
+  const name = readRequiredStringParam(params, "name");
+  const memberIDs = readNumericIDArray(params, "memberIds", false);
+  const memberTypes = readIntArray(params, "memberTypes");
+  if (memberTypes.length > 0) {
+    ensureMemberTypes(memberTypes);
+    if (memberIDs.length == 0 || memberTypes.length !== memberIDs.length) {
+      throw new Error("Grix action memberTypes length must match memberIds.");
+    }
+  }
+  const body = { name };
+  if (memberIDs.length > 0) {
+    body.member_ids = memberIDs;
+  }
+  if (memberTypes.length > 0) {
+    body.member_types = memberTypes;
+  }
+  return {
+    actionName: "group_create",
+    method: "POST",
+    path: "/sessions/create_group",
+    body
+  };
+}
+function buildGroupMemberAddRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  const memberIDs = readNumericIDArray(params, "memberIds", true);
+  const memberTypes = readIntArray(params, "memberTypes");
+  if (memberTypes.length > 0) {
+    ensureMemberTypes(memberTypes);
+    if (memberTypes.length !== memberIDs.length) {
+      throw new Error("Grix action memberTypes length must match memberIds.");
+    }
+  }
+  const body = {
+    session_id: sessionID,
+    member_ids: memberIDs
+  };
+  if (memberTypes.length > 0) {
+    body.member_types = memberTypes;
+  }
+  return {
+    actionName: "group_member_add",
+    method: "POST",
+    path: "/sessions/members/add",
+    body
+  };
+}
+function buildGroupMemberRemoveRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  const memberIDs = readNumericIDArray(params, "memberIds", true);
+  const memberTypes = readIntArray(params, "memberTypes");
+  if (memberTypes.length > 0) {
+    ensureMemberTypes(memberTypes);
+    if (memberTypes.length !== memberIDs.length) {
+      throw new Error("Grix action memberTypes length must match memberIds.");
+    }
+  }
+  const body = {
+    session_id: sessionID,
+    member_ids: memberIDs
+  };
+  if (memberTypes.length > 0) {
+    body.member_types = memberTypes;
+  }
+  return {
+    actionName: "group_member_remove",
+    method: "POST",
+    path: "/sessions/members/remove",
+    body
+  };
+}
+function buildGroupMemberRoleUpdateRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  const memberID = readRequiredStringParam(params, "memberId");
+  if (!/^\d+$/.test(memberID)) {
+    throw new Error("Grix action memberId must be numeric.");
+  }
+  const role = readRequiredInt(params, "role");
+  if (role !== 1 && role !== 2) {
+    throw new Error("Grix action role only supports 1 or 2.");
+  }
+  const memberType = readOptionalInt(params, "memberType") ?? 1;
+  ensureMemberType(memberType);
+  return {
+    actionName: "group_member_role_update",
+    method: "POST",
+    path: "/sessions/members/role",
+    body: {
+      session_id: sessionID,
+      member_id: memberID,
+      member_type: memberType,
+      role
+    }
+  };
+}
+function buildGroupDissolveRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  return {
+    actionName: "group_dissolve",
+    method: "POST",
+    path: "/sessions/dissolve",
+    body: {
+      session_id: sessionID
+    }
+  };
+}
+function buildGroupAllMembersMutedUpdateRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  const allMembersMuted = readRequiredBool(params, "allMembersMuted");
+  return {
+    actionName: "group_all_members_muted_update",
+    method: "POST",
+    path: "/sessions/speaking/all_muted",
+    body: {
+      session_id: sessionID,
+      all_members_muted: allMembersMuted
+    }
+  };
+}
+function buildGroupMemberSpeakingUpdateRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  const memberID = readRequiredStringParam(params, "memberId");
+  if (!/^\d+$/.test(memberID)) {
+    throw new Error("Grix action memberId must be numeric.");
+  }
+  const memberType = readOptionalInt(params, "memberType") ?? 1;
+  ensureSpeakingMemberType(memberType);
+  const isSpeakMuted = readOptionalBool(params, "isSpeakMuted");
+  const canSpeakWhenAllMuted = readOptionalBool(params, "canSpeakWhenAllMuted");
+  if (isSpeakMuted == null && canSpeakWhenAllMuted == null) {
+    throw new Error(
+      "Grix action update_member_speaking requires isSpeakMuted or canSpeakWhenAllMuted."
+    );
+  }
+  const body = {
+    session_id: sessionID,
+    member_id: memberID,
+    member_type: memberType
+  };
+  if (isSpeakMuted != null) {
+    body.is_speak_muted = isSpeakMuted;
+  }
+  if (canSpeakWhenAllMuted != null) {
+    body.can_speak_when_all_muted = canSpeakWhenAllMuted;
+  }
+  return {
+    actionName: "group_member_speaking_update",
+    method: "POST",
+    path: "/sessions/members/speaking",
+    body
+  };
+}
+function buildGroupDetailReadRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  return {
+    actionName: "group_detail_read",
+    method: "GET",
+    path: "/sessions/group/detail",
+    query: {
+      session_id: sessionID
+    }
+  };
+}
+function buildContactSearchRequest(params) {
+  const id = readRequiredStringParam(params, "id");
+  const limit = readOptionalInt(params, "limit");
+  const offset = readOptionalInt(params, "offset");
+  const query = {
+    id
+  };
+  if (limit != null) {
+    query.limit = String(limit);
+  }
+  if (offset != null) {
+    query.offset = String(offset);
+  }
+  return {
+    actionName: "contact_search",
+    method: "GET",
+    path: "/contacts/search",
+    query
+  };
+}
+function buildSessionSearchRequest(params) {
+  const id = readRequiredStringParam(params, "id");
+  const limit = readOptionalInt(params, "limit");
+  const offset = readOptionalInt(params, "offset");
+  const query = {
+    id
+  };
+  if (limit != null) {
+    query.limit = String(limit);
+  }
+  if (offset != null) {
+    query.offset = String(offset);
+  }
+  return {
+    actionName: "session_search",
+    method: "GET",
+    path: "/sessions/search",
+    query
+  };
+}
+function buildMessageHistoryRequest(params) {
+  const sessionID = readRequiredStringParam(params, "sessionId");
+  const beforeID = readStringParam2(params, "beforeId");
+  const limit = readOptionalInt(params, "limit");
+  const query = {
+    session_id: sessionID
+  };
+  if (beforeID) {
+    query.before_id = beforeID;
+  }
+  if (limit != null) {
+    query.limit = String(limit);
+  }
+  return {
+    actionName: "message_history",
+    method: "GET",
+    path: "/messages/history",
+    query
+  };
+}
+function buildAgentAPICreateRequest(params) {
+  const agentName = readRequiredStringParam(params, "agentName");
+  if (!AGENT_NAME_RE.test(agentName)) {
+    throw new Error("Grix action agentName must match ^[a-z][a-z0-9-]{2,31}$.");
+  }
+  const describeMessageTool = readRequiredDescribeMessageTool(params);
+  const avatarURL = readStringParam2(params, "avatarUrl");
+  const body = {
+    agent_name: agentName,
+    describe_message_tool: describeMessageTool
+  };
+  if (avatarURL) {
+    body.avatar_url = avatarURL;
+  }
+  return {
+    actionName: "agent_api_create",
+    method: "POST",
+    path: "/agents/create",
+    body
+  };
+}
+function buildAgentHTTPRequest(action, params) {
+  switch (action) {
+    case "contact_search":
+      return buildContactSearchRequest(params);
+    case "session_search":
+      return buildSessionSearchRequest(params);
+    case "message_history":
+      return buildMessageHistoryRequest(params);
+    case "group_create":
+      return buildGroupCreateRequest(params);
+    case "group_member_add":
+      return buildGroupMemberAddRequest(params);
+    case "group_member_remove":
+      return buildGroupMemberRemoveRequest(params);
+    case "group_member_role_update":
+      return buildGroupMemberRoleUpdateRequest(params);
+    case "group_all_members_muted_update":
+      return buildGroupAllMembersMutedUpdateRequest(params);
+    case "group_member_speaking_update":
+      return buildGroupMemberSpeakingUpdateRequest(params);
+    case "group_dissolve":
+      return buildGroupDissolveRequest(params);
+    case "group_detail_read":
+      return buildGroupDetailReadRequest(params);
+    case "agent_api_create":
+      return buildAgentAPICreateRequest(params);
+    default:
+      throw new Error(`Grix action ${action} is not supported.`);
+  }
+}
+
+// src/admin/agent-api-http.ts
+var DEFAULT_HTTP_TIMEOUT_MS = 15e3;
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveExplicitAgentAPIBase() {
+  const base = String(
+    process.env.GRIX_AGENT_API_BASE ?? process.env.AIBOT_AGENT_API_BASE ?? ""
+  ).trim();
+  if (!base) {
+    return "";
+  }
+  return trimTrailingSlash(base);
+}
+function deriveAgentAPIBaseFromWsUrl(wsUrl) {
+  const normalizedWsUrl = String(wsUrl ?? "").trim();
+  if (!normalizedWsUrl) {
+    throw new Error("Grix account wsUrl is missing");
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalizedWsUrl);
+  } catch {
+    throw new Error(`Grix wsUrl is invalid: ${normalizedWsUrl}`);
+  }
+  const protocol = parsed.protocol === "wss:" ? "https:" : parsed.protocol === "ws:" ? "http:" : "";
+  if (!protocol) {
+    throw new Error(`Grix wsUrl must start with ws:// or wss://: ${normalizedWsUrl}`);
+  }
+  const marker = "/v1/agent-api/ws";
+  const markerIndex = parsed.pathname.indexOf(marker);
+  const basePath = markerIndex >= 0 ? parsed.pathname.slice(0, markerIndex) : parsed.pathname;
+  return trimTrailingSlash(`${protocol}//${parsed.host}${basePath}`) + "/v1/agent-api";
+}
+function deriveLocalAgentAPIBaseFromWsUrl(wsUrl) {
+  const normalizedWsUrl = String(wsUrl ?? "").trim();
+  if (!normalizedWsUrl) {
+    return "";
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalizedWsUrl);
+  } catch {
+    return "";
+  }
+  const host = String(parsed.hostname ?? "").trim().toLowerCase();
+  const localHosts = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+  if (!localHosts.has(host)) {
+    return "";
+  }
+  const wsPort = Number(parsed.port || (parsed.protocol === "wss:" ? 443 : 80));
+  if (!Number.isFinite(wsPort) || wsPort <= 0) {
+    return "";
+  }
+  const apiPort = wsPort % 10 === 9 ? wsPort - 9 : 27180;
+  const protocol = parsed.protocol === "wss:" ? "https:" : "http:";
+  return trimTrailingSlash(`${protocol}//${parsed.hostname}:${apiPort}`) + "/v1/agent-api";
+}
+function resolveAgentAPIBase(account) {
+  const explicit = resolveExplicitAgentAPIBase();
+  if (explicit) {
+    return explicit;
+  }
+  const local = deriveLocalAgentAPIBaseFromWsUrl(account.wsUrl);
+  if (local) {
+    return local;
+  }
+  return deriveAgentAPIBaseFromWsUrl(account.wsUrl);
+}
+function buildRequestURL(base, path, query) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${trimTrailingSlash(base)}${normalizedPath}`);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      const normalizedValue = String(value ?? "").trim();
+      if (!normalizedValue) {
+        continue;
+      }
+      url.searchParams.set(key, normalizedValue);
+    }
+  }
+  return url.toString();
+}
+function normalizeStatusCode(raw) {
+  const n = Number(raw);
+  if (Number.isFinite(n)) {
+    return Math.floor(n);
+  }
+  return 0;
+}
+function normalizeBizCode(raw) {
+  const n = Number(raw);
+  if (Number.isFinite(n)) {
+    return Math.floor(n);
+  }
+  return -1;
+}
+function normalizeMessage(raw) {
+  const message = String(raw ?? "").trim();
+  if (!message) {
+    return "unknown error";
+  }
+  return message;
+}
+function extractNetworkErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message || String(error);
+  }
+  return String(error);
+}
+async function callAgentAPI(params) {
+  const base = resolveAgentAPIBase(params.account);
+  const url = buildRequestURL(base, params.path, params.query);
+  const timeoutMs = Number.isFinite(params.timeoutMs) ? Math.max(1e3, Math.floor(params.timeoutMs)) : DEFAULT_HTTP_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let resp;
+  try {
+    resp = await fetch(url, {
+      method: params.method,
+      headers: {
+        Authorization: `Bearer ${params.account.apiKey}`,
+        ...params.method === "POST" ? { "Content-Type": "application/json" } : {}
+      },
+      body: params.method === "POST" ? JSON.stringify(params.body ?? {}) : void 0,
+      signal: controller.signal
+    });
+  } catch (error) {
+    clearTimeout(timer);
+    throw new Error(
+      `Grix ${params.actionName} network error: ${extractNetworkErrorMessage(error)}`
+    );
+  }
+  clearTimeout(timer);
+  const status = normalizeStatusCode(resp.status);
+  const rawBody = await resp.text();
+  let envelope;
+  try {
+    envelope = JSON.parse(rawBody);
+  } catch {
+    throw new Error(
+      `Grix ${params.actionName} invalid response: status=${status} body=${rawBody.slice(0, 256)}`
+    );
+  }
+  const bizCode = normalizeBizCode(envelope.code);
+  if (!resp.ok || bizCode !== 0) {
+    const message = normalizeMessage(envelope.msg);
+    throw new Error(
+      `Grix ${params.actionName} failed: status=${status} code=${bizCode} msg=${message}`
+    );
+  }
+  return envelope.data;
+}
+
+// src/admin/accounts.ts
+var DEFAULT_ACCOUNT_ID2 = "default";
+function normalizeAccountId2(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || DEFAULT_ACCOUNT_ID2;
+}
+function normalizeOptionalAccountId2(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || void 0;
+}
+function rawGrixConfig(cfg) {
+  return cfg.channels?.grix ?? {};
+}
+function listConfiguredAccountIds2(cfg) {
+  const accounts = rawGrixConfig(cfg).accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+function normalizeNonEmpty2(value) {
+  return String(value ?? "").trim();
+}
+function appendAgentIdToWsUrl2(rawWsUrl, agentId) {
+  if (!rawWsUrl) {
+    return "";
+  }
+  const direct = rawWsUrl.replaceAll("{agent_id}", encodeURIComponent(agentId));
+  if (!agentId) {
+    return direct;
+  }
+  try {
+    const parsed = new URL(direct);
+    if (!parsed.searchParams.get("agent_id")) {
+      parsed.searchParams.set("agent_id", agentId);
+    }
+    return parsed.toString();
+  } catch {
+    if (direct.includes("agent_id=")) {
+      return direct;
+    }
+    return direct.includes("?") ? `${direct}&agent_id=${encodeURIComponent(agentId)}` : `${direct}?agent_id=${encodeURIComponent(agentId)}`;
+  }
+}
+function resolveWsUrl2(merged, agentId) {
+  const envWs = normalizeNonEmpty2(process.env.GRIX_WS_URL);
+  const cfgWs = normalizeNonEmpty2(merged.wsUrl);
+  const ws = cfgWs || envWs;
+  if (ws) {
+    return appendAgentIdToWsUrl2(ws, agentId);
+  }
+  if (!agentId) {
+    return "";
+  }
+  return `ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=${encodeURIComponent(agentId)}`;
+}
+function resolveMergedAccountConfig(cfg, accountId) {
+  const grixCfg = rawGrixConfig(cfg);
+  const { accounts: _ignoredAccounts, defaultAccount: _ignoredDefault, ...base } = grixCfg;
+  const account = grixCfg.accounts?.[accountId] ?? {};
+  return {
+    ...base,
+    ...account
+  };
+}
+function listGrixAccountIds(cfg) {
+  const ids = listConfiguredAccountIds2(cfg);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID2];
+  }
+  return ids.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultGrixAccountId(cfg) {
+  const grixCfg = rawGrixConfig(cfg);
+  const preferred = normalizeOptionalAccountId2(grixCfg.defaultAccount);
+  if (preferred && listGrixAccountIds(cfg).some((accountId) => normalizeAccountId2(accountId) === preferred)) {
+    return preferred;
+  }
+  const ids = listGrixAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID2)) {
+    return DEFAULT_ACCOUNT_ID2;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID2;
+}
+function resolveGrixAccount(params) {
+  const accountId = params.accountId == null || String(params.accountId).trim() === "" ? resolveDefaultGrixAccountId(params.cfg) : normalizeAccountId2(params.accountId);
+  const merged = resolveMergedAccountConfig(params.cfg, accountId);
+  const baseEnabled = rawGrixConfig(params.cfg).enabled !== false;
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const agentId = normalizeNonEmpty2(merged.agentId || process.env.GRIX_AGENT_ID);
+  const apiKey = normalizeNonEmpty2(merged.apiKey || process.env.GRIX_API_KEY);
+  const wsUrl = resolveWsUrl2(merged, agentId);
+  const configured = Boolean(wsUrl && agentId && apiKey);
+  return {
+    accountId,
+    name: normalizeNonEmpty2(merged.name) || void 0,
+    enabled,
+    configured,
+    wsUrl,
+    agentId,
+    apiKey,
+    config: merged
+  };
+}
+function summarizeGrixAccounts(cfg) {
+  return listGrixAccountIds(cfg).map((accountId) => {
+    const account = resolveGrixAccount({ cfg, accountId });
+    return {
+      accountId: account.accountId,
+      name: account.name ?? null,
+      enabled: account.enabled,
+      configured: account.configured,
+      wsUrl: account.wsUrl || null,
+      agentId: account.agentId || null
+    };
+  });
+}
+
+// src/admin/agent-admin-service.ts
+function buildChannelBootstrapCommand(params) {
+  return [
+    "openclaw channels add",
+    "--channel grix",
+    `--name ${JSON.stringify(params.channelName)}`,
+    `--http-url ${JSON.stringify(params.apiEndpoint)}`,
+    `--user-id ${JSON.stringify(params.agentId)}`,
+    `--token ${JSON.stringify(params.apiKeyPlaceholder)}`
+  ].join(" ");
+}
+function maskSecret(value) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.length <= 8) {
+    return "*".repeat(normalized.length);
+  }
+  return `${normalized.slice(0, 4)}...${normalized.slice(-4)}`;
+}
+function sanitizeCreatedAgentData(data) {
+  const payload = { ...data };
+  if ("api_key" in payload) {
+    payload.api_key = "<redacted>";
+  }
+  if (!payload.api_key_hint && typeof data.api_key === "string") {
+    payload.api_key_hint = maskSecret(String(data.api_key));
+  }
+  return payload;
+}
+async function createGrixApiAgent(params) {
+  const account = resolveGrixAccount({
+    cfg: params.cfg,
+    accountId: params.toolParams.accountId
+  });
+  if (!account.enabled) {
+    throw new Error(`Grix account "${account.accountId}" is disabled.`);
+  }
+  if (!account.configured) {
+    throw new Error(`Grix account "${account.accountId}" is not configured.`);
+  }
+  const request = buildAgentHTTPRequest("agent_api_create", params.toolParams);
+  const data = await callAgentAPI({
+    account,
+    actionName: request.actionName,
+    method: request.method,
+    path: request.path,
+    query: request.query,
+    body: request.body
+  });
+  const agentName = String(data.agent_name ?? params.toolParams.agentName ?? "").trim();
+  const apiEndpoint = String(data.api_endpoint ?? "").trim();
+  const agentId = String(data.id ?? "").trim();
+  const apiKey = String(data.api_key ?? "").trim();
+  const apiKeyHint = String(data.api_key_hint ?? "").trim() || maskSecret(apiKey);
+  return {
+    ok: true,
+    accountId: account.accountId,
+    action: "create_api_agent",
+    createdAgent: {
+      id: agentId,
+      agent_name: agentName,
+      provider_type: Number(data.provider_type ?? 0) || 0,
+      api_endpoint: apiEndpoint,
+      api_key: apiKey,
+      api_key_hint: apiKeyHint
+    },
+    data: sanitizeCreatedAgentData(data),
+    nextSteps: agentName && apiEndpoint && agentId && apiKey ? [
+      "Install and enable the channel plugin if it is not installed yet: `openclaw plugins install @dhf-openclaw/grix && openclaw plugins enable grix`.",
+      "Use the one-time `createdAgent.api_key` from this result as `<NEW_AGENT_API_KEY>` for the binding command, then stop sharing it in chat.",
+      `Bind the new API agent to OpenClaw with: \`${buildChannelBootstrapCommand({
+        channelName: `grix-${agentName}`,
+        apiEndpoint,
+        agentId,
+        apiKeyPlaceholder: "<NEW_AGENT_API_KEY>"
+      })}\``,
+      "Restart the gateway after adding the channel: `openclaw gateway restart`."
+    ] : []
+  };
+}
+function inspectGrixAdminConfig(cfg) {
+  return {
+    accounts: summarizeGrixAccounts(cfg),
+    defaultAccountId: resolveGrixAccount({ cfg }).accountId
+  };
+}
+
+// src/admin/json-result.ts
+function jsonToolResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload
+  };
+}
+
+// src/admin/agent-admin-tool.ts
+var GrixAgentAdminToolSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    accountId: { type: "string", minLength: 1 },
+    agentName: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]{2,31}$",
+      description: "Lowercase API agent name."
+    },
+    avatarUrl: { type: "string", minLength: 1 },
+    describeMessageTool: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        actions: {
+          type: "array",
+          minItems: 1,
+          items: { type: "string", minLength: 1 }
+        },
+        capabilities: {
+          type: "array",
+          items: { type: "string", minLength: 1 }
+        },
+        schema: {
+          oneOf: [
+            {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                properties: { type: "object" },
+                visibility: {
+                  type: "string",
+                  enum: ["current-channel", "all-configured"]
+                }
+              },
+              required: ["properties"]
+            },
+            {
+              type: "array",
+              minItems: 1,
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  properties: { type: "object" },
+                  visibility: {
+                    type: "string",
+                    enum: ["current-channel", "all-configured"]
+                  }
+                },
+                required: ["properties"]
+              }
+            }
+          ]
+        }
+      },
+      required: ["actions"]
+    }
+  },
+  required: ["agentName", "describeMessageTool"]
+};
+function createGrixAgentAdminTool(api) {
+  return {
+    name: "grix_agent_admin",
+    label: "Grix Agent Admin",
+    description: "Create Grix API agents with typed parameters. This tool does not modify local OpenClaw channel config.",
+    parameters: GrixAgentAdminToolSchema,
+    async execute(_toolCallId, params) {
+      try {
+        return jsonToolResult(
+          await createGrixApiAgent({
+            cfg: api.config,
+            toolParams: params
+          })
+        );
+      } catch (err) {
+        return jsonToolResult({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
+// src/admin/group-service.ts
+function mapGroupActionToRequestAction(action) {
+  switch (action) {
+    case "create":
+      return "group_create";
+    case "detail":
+      return "group_detail_read";
+    case "add_members":
+      return "group_member_add";
+    case "remove_members":
+      return "group_member_remove";
+    case "update_member_role":
+      return "group_member_role_update";
+    case "update_all_members_muted":
+      return "group_all_members_muted_update";
+    case "update_member_speaking":
+      return "group_member_speaking_update";
+    case "dissolve":
+      return "group_dissolve";
+    default:
+      action;
+      throw new Error(`Unsupported Grix group action: ${String(action)}`);
+  }
+}
+async function runGrixGroupAction(params) {
+  const account = resolveGrixAccount({
+    cfg: params.cfg,
+    accountId: params.toolParams.accountId
+  });
+  if (!account.enabled) {
+    throw new Error(`Grix account "${account.accountId}" is disabled.`);
+  }
+  if (!account.configured) {
+    throw new Error(`Grix account "${account.accountId}" is not configured.`);
+  }
+  const requestAction = mapGroupActionToRequestAction(params.toolParams.action);
+  const request = buildAgentHTTPRequest(requestAction, params.toolParams);
+  const data = await callAgentAPI({
+    account,
+    actionName: request.actionName,
+    method: request.method,
+    path: request.path,
+    query: request.query,
+    body: request.body
+  });
+  return {
+    ok: true,
+    accountId: account.accountId,
+    action: params.toolParams.action,
+    data
+  };
+}
+
+// src/admin/group-tool.ts
+var numericIdSchema = {
+  type: "string",
+  pattern: "^[0-9]+$"
+};
+var GrixGroupToolSchema = {
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "create" },
+        accountId: { type: "string", minLength: 1 },
+        name: { type: "string", minLength: 1 },
+        memberIds: { type: "array", items: numericIdSchema },
+        memberTypes: { type: "array", items: { type: "integer", enum: [1, 2] } }
+      },
+      required: ["action", "name"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "detail" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 }
+      },
+      required: ["action", "sessionId"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "add_members" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 },
+        memberIds: { type: "array", items: numericIdSchema, minItems: 1 },
+        memberTypes: { type: "array", items: { type: "integer", enum: [1, 2] } }
+      },
+      required: ["action", "sessionId", "memberIds"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "remove_members" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 },
+        memberIds: { type: "array", items: numericIdSchema, minItems: 1 },
+        memberTypes: { type: "array", items: { type: "integer", enum: [1, 2] } }
+      },
+      required: ["action", "sessionId", "memberIds"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "update_member_role" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 },
+        memberId: numericIdSchema,
+        memberType: { type: "integer", enum: [1] },
+        role: { type: "integer", enum: [1, 2] }
+      },
+      required: ["action", "sessionId", "memberId", "role"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "update_all_members_muted" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 },
+        allMembersMuted: { type: "boolean" }
+      },
+      required: ["action", "sessionId", "allMembersMuted"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "update_member_speaking" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 },
+        memberId: numericIdSchema,
+        memberType: { type: "integer", enum: [1, 2] },
+        isSpeakMuted: { type: "boolean" },
+        canSpeakWhenAllMuted: { type: "boolean" }
+      },
+      required: ["action", "sessionId", "memberId"],
+      anyOf: [
+        { required: ["isSpeakMuted"] },
+        { required: ["canSpeakWhenAllMuted"] }
+      ]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "dissolve" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 }
+      },
+      required: ["action", "sessionId"]
+    }
+  ]
+};
+function createGrixGroupTool(api) {
+  return {
+    name: "grix_group",
+    label: "Grix Group",
+    description: "Manage Grix groups through typed admin operations. This tool only handles group lifecycle and membership changes.",
+    parameters: GrixGroupToolSchema,
+    async execute(_toolCallId, params) {
+      try {
+        return jsonToolResult(
+          await runGrixGroupAction({
+            cfg: api.config,
+            toolParams: params
+          })
+        );
+      } catch (err) {
+        return jsonToolResult({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
+// src/admin/query-service.ts
+function mapQueryActionToRequestAction(action) {
+  switch (action) {
+    case "contact_search":
+      return "contact_search";
+    case "session_search":
+      return "session_search";
+    case "message_history":
+      return "message_history";
+    default:
+      action;
+      throw new Error(`Unsupported Grix query action: ${String(action)}`);
+  }
+}
+async function runGrixQueryAction(params) {
+  const account = resolveGrixAccount({
+    cfg: params.cfg,
+    accountId: params.toolParams.accountId
+  });
+  if (!account.enabled) {
+    throw new Error(`Grix account "${account.accountId}" is disabled.`);
+  }
+  if (!account.configured) {
+    throw new Error(`Grix account "${account.accountId}" is not configured.`);
+  }
+  const requestAction = mapQueryActionToRequestAction(params.toolParams.action);
+  const request = buildAgentHTTPRequest(requestAction, params.toolParams);
+  const data = await callAgentAPI({
+    account,
+    actionName: request.actionName,
+    method: request.method,
+    path: request.path,
+    query: request.query,
+    body: request.body
+  });
+  return {
+    ok: true,
+    accountId: account.accountId,
+    action: params.toolParams.action,
+    data
+  };
+}
+
+// src/admin/query-tool.ts
+var GrixQueryToolSchema = {
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "contact_search" },
+        accountId: { type: "string", minLength: 1 },
+        id: { type: "string", pattern: "^[0-9]+$" },
+        limit: { type: "integer", minimum: 1 },
+        offset: { type: "integer", minimum: 0 }
+      },
+      required: ["action", "id"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "session_search" },
+        accountId: { type: "string", minLength: 1 },
+        id: { type: "string", minLength: 1 },
+        limit: { type: "integer", minimum: 1 },
+        offset: { type: "integer", minimum: 0 }
+      },
+      required: ["action", "id"]
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        action: { const: "message_history" },
+        accountId: { type: "string", minLength: 1 },
+        sessionId: { type: "string", minLength: 1 },
+        beforeId: { type: "string", pattern: "^[0-9]+$" },
+        limit: { type: "integer", minimum: 1 }
+      },
+      required: ["action", "sessionId"]
+    }
+  ]
+};
+function createGrixQueryTool(api) {
+  return {
+    name: "grix_query",
+    label: "Grix Query",
+    description: "Search Grix contacts and sessions, or read session message history through typed query operations.",
+    parameters: GrixQueryToolSchema,
+    async execute(_toolCallId, params) {
+      try {
+        return jsonToolResult(
+          await runGrixQueryAction({
+            cfg: api.config,
+            toolParams: params
+          })
+        );
+      } catch (err) {
+        return jsonToolResult({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
+// src/admin/cli.ts
+function parseDescribeMessageToolJSON(value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("Invalid --describe-message-tool JSON.");
+  }
+  if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("--describe-message-tool must be a JSON object.");
+  }
+  const raw = parsed;
+  if (!Array.isArray(raw.actions) || raw.actions.length === 0) {
+    throw new Error("--describe-message-tool.actions must be a non-empty array.");
+  }
+  for (const action of raw.actions) {
+    if (typeof action !== "string" || !action.trim()) {
+      throw new Error("--describe-message-tool.actions must contain non-empty strings.");
+    }
+  }
+  return raw;
+}
+function registerGrixAdminCli(params) {
+  const root = params.program.command("grix").description("Grix operator utilities").addHelpText(
+    "after",
+    "\nThis CLI is for operator workflows. Agent tools stay scoped to typed remote admin actions only.\n"
+  );
+  root.command("doctor").description("Show the Grix accounts visible from the current OpenClaw config").action(() => {
+    console.log(JSON.stringify(inspectGrixAdminConfig(params.api.config), null, 2));
+  });
+  root.command("create-agent").description("Create a Grix API agent and print the exact next steps for channel binding").requiredOption("--agent-name <name>", "New API agent name").requiredOption(
+    "--describe-message-tool <json>",
+    "Message tool discovery JSON aligned with OpenClaw describeMessageTool",
+    parseDescribeMessageToolJSON
+  ).option("--account-id <id>", "Configured Grix account id").option("--avatar-url <url>", "Optional avatar URL").action(
+    async (options) => {
+      const result = await createGrixApiAgent({
+        cfg: params.api.config,
+        toolParams: options
+      });
+      console.log(JSON.stringify(result, null, 2));
+    }
+  );
+}
+
 // index.ts
 function emptyPluginConfigSchema() {
   return {
@@ -5087,11 +6359,17 @@ function emptyPluginConfigSchema() {
 var plugin = {
   id: "grix",
   name: "Grix OpenClaw",
-  description: "Connect OpenClaw to grix.dhf.pub for OpenClaw website management with mobile PWA support",
+  description: "Unified Grix plugin for OpenClaw channel transport, typed admin tools, and operator CLI",
   configSchema: emptyPluginConfigSchema(),
   register(api) {
     setAibotRuntime(api.runtime);
     api.registerChannel({ plugin: aibotPlugin });
+    api.registerTool(createGrixQueryTool(api), { optional: true });
+    api.registerTool(createGrixGroupTool(api), { optional: true });
+    api.registerTool(createGrixAgentAdminTool(api), { optional: true });
+    api.registerCli(({ program }) => registerGrixAdminCli({ api, program }), {
+      commands: ["grix"]
+    });
   }
 };
 var index_default = plugin;