@dhfpub/clawpool-openclaw-admin 0.2.2

package/dist/index.js

@@ -0,0 +1,1113 @@
+// index.ts
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/core";
+
+// src/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 readStringParam(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 = readStringParam(params, key);
+  if (!value) {
+    throw new Error(`Clawpool 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(`Clawpool 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(`Clawpool 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(`Clawpool 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(`Clawpool 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(`Clawpool action ${key} must be an integer.`);
+  }
+  return num;
+}
+function readRequiredInt(params, key) {
+  const value = readOptionalInt(params, key);
+  if (value == null) {
+    throw new Error(`Clawpool 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(`Clawpool action ${key} must be a boolean.`);
+}
+function readRequiredBool(params, key) {
+  const value = readOptionalBool(params, key);
+  if (value == null) {
+    throw new Error(`Clawpool action requires ${key}.`);
+  }
+  return value;
+}
+function ensureMemberTypes(types) {
+  for (const memberType of types) {
+    if (memberType !== 1 && memberType !== 2) {
+      throw new Error("Clawpool action member_types only supports 1 (human) or 2 (agent).");
+    }
+  }
+}
+function ensureMemberType(memberType) {
+  if (memberType !== 1) {
+    throw new Error("Clawpool action member_type only supports 1 for role update.");
+  }
+}
+function ensureSpeakingMemberType(memberType) {
+  if (memberType !== 1 && memberType !== 2) {
+    throw new Error("Clawpool 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("Clawpool 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("Clawpool 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("Clawpool 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("Clawpool action memberId must be numeric.");
+  }
+  const role = readRequiredInt(params, "role");
+  if (role !== 1 && role !== 2) {
+    throw new Error("Clawpool 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("Clawpool 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(
+      "Clawpool 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 = readStringParam(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("Clawpool action agentName must match ^[a-z][a-z0-9-]{2,31}$.");
+  }
+  const avatarURL = readStringParam(params, "avatarUrl");
+  const body = {
+    agent_name: agentName
+  };
+  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(`Clawpool action ${action} is not supported.`);
+  }
+}
+
+// src/agent-api-http.ts
+var DEFAULT_HTTP_TIMEOUT_MS = 15e3;
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveExplicitAgentAPIBase() {
+  const base = String(
+    process.env.CLAWPOOL_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("Clawpool account wsUrl is missing");
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalizedWsUrl);
+  } catch {
+    throw new Error(`Clawpool wsUrl is invalid: ${normalizedWsUrl}`);
+  }
+  const protocol = parsed.protocol === "wss:" ? "https:" : parsed.protocol === "ws:" ? "http:" : "";
+  if (!protocol) {
+    throw new Error(`Clawpool 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(
+      `Clawpool ${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(
+      `Clawpool ${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(
+      `Clawpool ${params.actionName} failed: status=${status} code=${bizCode} msg=${message}`
+    );
+  }
+  return envelope.data;
+}
+
+// src/accounts.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeAccountId(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || DEFAULT_ACCOUNT_ID;
+}
+function normalizeOptionalAccountId(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || void 0;
+}
+function rawClawpoolConfig(cfg) {
+  return cfg.channels?.clawpool ?? {};
+}
+function listConfiguredAccountIds(cfg) {
+  const accounts = rawClawpoolConfig(cfg).accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+function normalizeNonEmpty(value) {
+  return String(value ?? "").trim();
+}
+function appendAgentIdToWsUrl(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 resolveWsUrl(merged, agentId) {
+  const envWs = normalizeNonEmpty(process.env.CLAWPOOL_WS_URL);
+  const cfgWs = normalizeNonEmpty(merged.wsUrl);
+  const ws = cfgWs || envWs;
+  if (ws) {
+    return appendAgentIdToWsUrl(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 clawpoolCfg = rawClawpoolConfig(cfg);
+  const { accounts: _ignoredAccounts, defaultAccount: _ignoredDefault, ...base } = clawpoolCfg;
+  const account = clawpoolCfg.accounts?.[accountId] ?? {};
+  return {
+    ...base,
+    ...account
+  };
+}
+function listClawpoolAccountIds(cfg) {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultClawpoolAccountId(cfg) {
+  const clawpoolCfg = rawClawpoolConfig(cfg);
+  const preferred = normalizeOptionalAccountId(clawpoolCfg.defaultAccount);
+  if (preferred && listClawpoolAccountIds(cfg).some((accountId) => normalizeAccountId(accountId) === preferred)) {
+    return preferred;
+  }
+  const ids = listClawpoolAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveClawpoolAccount(params) {
+  const accountId = params.accountId == null || String(params.accountId).trim() === "" ? resolveDefaultClawpoolAccountId(params.cfg) : normalizeAccountId(params.accountId);
+  const merged = resolveMergedAccountConfig(params.cfg, accountId);
+  const baseEnabled = rawClawpoolConfig(params.cfg).enabled !== false;
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const agentId = normalizeNonEmpty(merged.agentId || process.env.CLAWPOOL_AGENT_ID);
+  const apiKey = normalizeNonEmpty(merged.apiKey || process.env.CLAWPOOL_API_KEY);
+  const wsUrl = resolveWsUrl(merged, agentId);
+  const configured = Boolean(wsUrl && agentId && apiKey);
+  return {
+    accountId,
+    name: normalizeNonEmpty(merged.name) || void 0,
+    enabled,
+    configured,
+    wsUrl,
+    agentId,
+    apiKey,
+    config: merged
+  };
+}
+function summarizeClawpoolAccounts(cfg) {
+  return listClawpoolAccountIds(cfg).map((accountId) => {
+    const account = resolveClawpoolAccount({ 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/agent-admin-service.ts
+function buildChannelBootstrapCommand(params) {
+  return [
+    "openclaw channels add",
+    "--channel clawpool",
+    `--name ${JSON.stringify(params.channelName)}`,
+    `--http-url ${JSON.stringify(params.apiEndpoint)}`,
+    `--user-id ${JSON.stringify(params.agentId)}`,
+    `--token ${JSON.stringify(params.apiKey)}`
+  ].join(" ");
+}
+async function createClawpoolApiAgent(params) {
+  const account = resolveClawpoolAccount({
+    cfg: params.cfg,
+    accountId: params.toolParams.accountId
+  });
+  if (!account.enabled) {
+    throw new Error(`Clawpool account "${account.accountId}" is disabled.`);
+  }
+  if (!account.configured) {
+    throw new Error(`Clawpool 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();
+  return {
+    ok: true,
+    accountId: account.accountId,
+    action: "create_api_agent",
+    data,
+    nextSteps: agentName && apiEndpoint && agentId && apiKey ? [
+      "Install and enable the channel plugin if it is not installed yet: `openclaw plugins install @dhfpub/clawpool-openclaw && openclaw plugins enable clawpool`.",
+      `Bind the new API agent to OpenClaw with: \`${buildChannelBootstrapCommand({
+        channelName: `clawpool-${agentName}`,
+        apiEndpoint,
+        agentId,
+        apiKey
+      })}\``,
+      "Restart the gateway after adding the channel: `openclaw gateway restart`."
+    ] : []
+  };
+}
+function inspectClawpoolAdminConfig(cfg) {
+  return {
+    accounts: summarizeClawpoolAccounts(cfg),
+    defaultAccountId: resolveClawpoolAccount({ cfg }).accountId
+  };
+}
+
+// src/cli.ts
+function registerClawpoolAdminCli(params) {
+  const root = params.program.command("clawpool-admin").description("Clawpool admin 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 Clawpool accounts visible from the current OpenClaw config").action(() => {
+    console.log(JSON.stringify(inspectClawpoolAdminConfig(params.api.config), null, 2));
+  });
+  root.command("create-agent").description("Create a Clawpool API agent and print the exact next steps for channel binding").requiredOption("--agent-name <name>", "New API agent name").option("--account-id <id>", "Configured Clawpool account id").option("--avatar-url <url>", "Optional avatar URL").action(
+    async (options) => {
+      const result = await createClawpoolApiAgent({
+        cfg: params.api.config,
+        toolParams: options
+      });
+      console.log(JSON.stringify(result, null, 2));
+    }
+  );
+}
+
+// src/json-result.ts
+function jsonToolResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload
+  };
+}
+
+// src/agent-admin-tool.ts
+var ClawpoolAgentAdminToolSchema = {
+  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 }
+  },
+  required: ["agentName"]
+};
+function createClawpoolAgentAdminTool(api) {
+  return {
+    name: "clawpool_agent_admin",
+    label: "Clawpool Agent Admin",
+    description: "Create Clawpool API agents with typed parameters. This tool does not modify local OpenClaw channel config.",
+    parameters: ClawpoolAgentAdminToolSchema,
+    async execute(_toolCallId, params) {
+      try {
+        return jsonToolResult(
+          await createClawpoolApiAgent({
+            cfg: api.config,
+            toolParams: params
+          })
+        );
+      } catch (err) {
+        return jsonToolResult({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
+// src/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 Clawpool group action: ${String(action)}`);
+  }
+}
+async function runClawpoolGroupAction(params) {
+  const account = resolveClawpoolAccount({
+    cfg: params.cfg,
+    accountId: params.toolParams.accountId
+  });
+  if (!account.enabled) {
+    throw new Error(`Clawpool account "${account.accountId}" is disabled.`);
+  }
+  if (!account.configured) {
+    throw new Error(`Clawpool 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/group-tool.ts
+var numericIdSchema = {
+  type: "string",
+  pattern: "^[0-9]+$"
+};
+var ClawpoolGroupToolSchema = {
+  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 createClawpoolGroupTool(api) {
+  return {
+    name: "clawpool_group",
+    label: "Clawpool Group",
+    description: "Manage Clawpool groups through typed admin operations. This tool only handles group lifecycle and membership changes.",
+    parameters: ClawpoolGroupToolSchema,
+    async execute(_toolCallId, params) {
+      try {
+        return jsonToolResult(
+          await runClawpoolGroupAction({
+            cfg: api.config,
+            toolParams: params
+          })
+        );
+      } catch (err) {
+        return jsonToolResult({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
+// src/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 Clawpool query action: ${String(action)}`);
+  }
+}
+async function runClawpoolQueryAction(params) {
+  const account = resolveClawpoolAccount({
+    cfg: params.cfg,
+    accountId: params.toolParams.accountId
+  });
+  if (!account.enabled) {
+    throw new Error(`Clawpool account "${account.accountId}" is disabled.`);
+  }
+  if (!account.configured) {
+    throw new Error(`Clawpool 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/query-tool.ts
+var ClawpoolQueryToolSchema = {
+  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 createClawpoolQueryTool(api) {
+  return {
+    name: "clawpool_query",
+    label: "Clawpool Query",
+    description: "Search Clawpool contacts and sessions, or read session message history through typed query operations.",
+    parameters: ClawpoolQueryToolSchema,
+    async execute(_toolCallId, params) {
+      try {
+        return jsonToolResult(
+          await runClawpoolQueryAction({
+            cfg: api.config,
+            toolParams: params
+          })
+        );
+      } catch (err) {
+        return jsonToolResult({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
+// index.ts
+var plugin = {
+  id: "clawpool-admin",
+  name: "Clawpool Admin",
+  description: "Typed optional admin tools and operator CLI for Clawpool",
+  configSchema: emptyPluginConfigSchema(),
+  register(api) {
+    api.registerTool(createClawpoolQueryTool(api), { optional: true });
+    api.registerTool(createClawpoolGroupTool(api), { optional: true });
+    api.registerTool(createClawpoolAgentAdminTool(api), { optional: true });
+    api.registerCli(({ program }) => registerClawpoolAdminCli({ api, program }), {
+      commands: ["clawpool-admin"]
+    });
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};