gewe-openclaw 2026.3.13 → 2026.3.23

package/src/directory-cache.ts

@@ -0,0 +1,164 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "./openclaw-compat.js";
+
+type NamedEntry = {
+  id: string;
+  name?: string;
+  lastSeenAt: number;
+};
+
+type AccountDirectoryCache = {
+  users: Map<string, NamedEntry>;
+  groups: Map<string, NamedEntry>;
+  groupMembers: Map<string, Map<string, NamedEntry>>;
+};
+
+const directoryCache = new Map<string, AccountDirectoryCache>();
+
+function resolveAccountCache(accountId?: string | null): AccountDirectoryCache {
+  const normalized = normalizeAccountId(accountId ?? DEFAULT_ACCOUNT_ID);
+  let existing = directoryCache.get(normalized);
+  if (!existing) {
+    existing = {
+      users: new Map(),
+      groups: new Map(),
+      groupMembers: new Map(),
+    };
+    directoryCache.set(normalized, existing);
+  }
+  return existing;
+}
+
+function upsertNamedEntry(
+  target: Map<string, NamedEntry>,
+  params: { id?: string | null; name?: string | null; lastSeenAt?: number },
+) {
+  const id = params.id?.trim();
+  if (!id) {
+    return;
+  }
+  const current = target.get(id);
+  const name = params.name?.trim() || current?.name;
+  target.set(id, {
+    id,
+    name: name || undefined,
+    lastSeenAt: params.lastSeenAt ?? Date.now(),
+  });
+}
+
+export function rememberGeweDirectoryObservation(params: {
+  accountId?: string | null;
+  senderId?: string | null;
+  senderName?: string | null;
+  groupId?: string | null;
+  groupName?: string | null;
+  timestamp?: number;
+}) {
+  const cache = resolveAccountCache(params.accountId);
+  const lastSeenAt = params.timestamp ?? Date.now();
+  upsertNamedEntry(cache.users, {
+    id: params.senderId,
+    name: params.senderName,
+    lastSeenAt,
+  });
+  upsertNamedEntry(cache.groups, {
+    id: params.groupId,
+    name: params.groupName,
+    lastSeenAt,
+  });
+}
+
+export function rememberGeweGroupMembers(params: {
+  accountId?: string | null;
+  groupId: string;
+  groupName?: string | null;
+  members: Array<{ id?: string | null; name?: string | null }>;
+  timestamp?: number;
+}) {
+  const cache = resolveAccountCache(params.accountId);
+  const lastSeenAt = params.timestamp ?? Date.now();
+  upsertNamedEntry(cache.groups, {
+    id: params.groupId,
+    name: params.groupName,
+    lastSeenAt,
+  });
+  const memberMap = new Map<string, NamedEntry>();
+  for (const member of params.members) {
+    const id = member.id?.trim();
+    if (!id) {
+      continue;
+    }
+    const name = member.name?.trim() || undefined;
+    memberMap.set(id, {
+      id,
+      name,
+      lastSeenAt,
+    });
+    upsertNamedEntry(cache.users, {
+      id,
+      name,
+      lastSeenAt,
+    });
+  }
+  cache.groupMembers.set(params.groupId, memberMap);
+}
+
+export function rememberGeweUsers(params: {
+  accountId?: string | null;
+  users: Array<{ id?: string | null; name?: string | null }>;
+  timestamp?: number;
+}) {
+  const cache = resolveAccountCache(params.accountId);
+  const lastSeenAt = params.timestamp ?? Date.now();
+  for (const user of params.users) {
+    upsertNamedEntry(cache.users, {
+      id: user.id,
+      name: user.name,
+      lastSeenAt,
+    });
+  }
+}
+
+export function listCachedGeweUsers(accountId?: string | null): NamedEntry[] {
+  return Array.from(resolveAccountCache(accountId).users.values());
+}
+
+export function listCachedGeweGroups(accountId?: string | null): NamedEntry[] {
+  return Array.from(resolveAccountCache(accountId).groups.values());
+}
+
+export function listCachedGeweGroupMembers(params: {
+  accountId?: string | null;
+  groupId: string;
+}): NamedEntry[] {
+  return Array.from(
+    resolveAccountCache(params.accountId).groupMembers.get(params.groupId)?.values() ?? [],
+  );
+}
+
+export function resolveCachedGeweName(params: {
+  accountId?: string | null;
+  id: string;
+  kind: "user" | "group";
+}): string | undefined {
+  const cache = resolveAccountCache(params.accountId);
+  return params.kind === "group"
+    ? cache.groups.get(params.id)?.name
+    : cache.users.get(params.id)?.name;
+}
+
+export function getGeweDirectoryCacheCounts(accountId?: string | null) {
+  const cache = resolveAccountCache(accountId);
+  const cachedGroupMemberCount = Array.from(cache.groupMembers.values()).reduce(
+    (sum, group) => sum + group.size,
+    0,
+  );
+  return {
+    cachedUsersCount: cache.users.size,
+    cachedGroupsCount: cache.groups.size,
+    cachedGroupMemberCount,
+  };
+}
+
+export function resetGeweDirectoryCacheForTests() {
+  directoryCache.clear();
+}

package/src/gewe-account-api.ts

@@ -0,0 +1,27 @@
+import { postGeweAccountJson } from "./api.js";
+import type { ResolvedGeweAccount } from "./types.js";
+
+export type GeweApiMethodParams<T extends Record<string, unknown>> = T & {
+  account: ResolvedGeweAccount;
+};
+
+export type GeweApiMethod<T extends Record<string, unknown>, R = unknown> = (
+  params: GeweApiMethodParams<T>,
+) => Promise<R | undefined>;
+
+export function createGeweAccountMethod<T extends Record<string, unknown>, R = unknown>(
+  path: string,
+): GeweApiMethod<T, R> {
+  return async (params) => {
+    const { account, ...body } = params;
+    return await postGeweAccountJson<R>({
+      account,
+      path,
+      context: path.split("/").pop() ?? path,
+      body,
+    });
+  };
+}
+
+export type GeweApiObject = Record<string, unknown>;
+export type GeweApiList = GeweApiObject[];

package/src/group-allowlist-tool.ts

@@ -0,0 +1,242 @@
+import type { AnyAgentTool, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { z } from "zod";
+
+import { resolveGeweAccount } from "./accounts.js";
+import { ensureGeweWriteSection } from "./config-edit.js";
+import { normalizeGeweBindingConversationId, inferCurrentGeweGroupId } from "./group-binding.js";
+import { normalizeAccountId, type OpenClawConfig } from "./openclaw-compat.js";
+import { readGeweAllowFromStore } from "./pairing-store.js";
+import type { GeweGroupConfig } from "./types.js";
+
+const GeweManageGroupAllowlistSchema = z
+  .object({
+    mode: z.enum(["inspect", "add", "remove", "replace", "clear"]).optional().default("inspect"),
+    groupId: z.string().optional(),
+    accountId: z.string().optional(),
+    entries: z.array(z.string()).optional(),
+  })
+  .strict();
+
+function jsonResult(details: Record<string, unknown>) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(details, null, 2) }],
+    details,
+  };
+}
+
+function dedupeEntries(values: readonly unknown[]): string[] {
+  const result: string[] = [];
+  const seen = new Set<string>();
+  for (const value of values) {
+    const normalized = String(value ?? "").trim();
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+
+function resolveToolConfig(ctx: OpenClawPluginToolContext, readConfig?: () => OpenClawConfig): OpenClawConfig {
+  return (readConfig?.() ?? (ctx.config as OpenClawConfig | undefined) ?? {}) as OpenClawConfig;
+}
+
+function resolveGroupId(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  ctx: OpenClawPluginToolContext;
+  rawGroupId?: string;
+}): string {
+  const explicit = params.rawGroupId?.trim();
+  if (explicit === "*") {
+    return "*";
+  }
+  const normalizedExplicit = normalizeGeweBindingConversationId(explicit);
+  if (normalizedExplicit) {
+    return normalizedExplicit;
+  }
+  const inferred = inferCurrentGeweGroupId({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    sessionKey: params.ctx.sessionKey,
+  });
+  if (!inferred) {
+    throw new Error(
+      "GeWe group allowlist management requires groupId, or a current GeWe group session that can infer one.",
+    );
+  }
+  return inferred;
+}
+
+function readOverrideEntries(accountConfig: Record<string, unknown>, groupId: string): string[] {
+  const groups =
+    accountConfig.groups && typeof accountConfig.groups === "object" && !Array.isArray(accountConfig.groups)
+      ? (accountConfig.groups as Record<string, GeweGroupConfig | undefined>)
+      : {};
+  const entries = groups[groupId]?.allowFrom ?? [];
+  return dedupeEntries(entries);
+}
+
+function resolveEffectiveEntries(params: {
+  accountConfig: Record<string, unknown>;
+  accountId: string;
+  groupId: string;
+  pairingEntries: string[];
+}): {
+  baseEntries: string[];
+  overrideEntries: string[];
+  effectiveEntries: string[];
+} {
+  const baseEntries = dedupeEntries((params.accountConfig.groupAllowFrom as unknown[]) ?? []);
+  const overrideEntries = readOverrideEntries(params.accountConfig, params.groupId);
+  return {
+    baseEntries,
+    overrideEntries,
+    effectiveEntries: dedupeEntries([...baseEntries, ...params.pairingEntries, ...overrideEntries]),
+  };
+}
+
+function mutateGroupAllowlist(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  groupId: string;
+  mode: "add" | "remove" | "replace" | "clear";
+  entries: string[];
+}) {
+  const write = ensureGeweWriteSection({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  const groups =
+    write.target.groups && typeof write.target.groups === "object" && !Array.isArray(write.target.groups)
+      ? (write.target.groups as Record<string, Record<string, unknown>>)
+      : {};
+  write.target.groups = groups;
+  const current = groups[params.groupId] ?? {};
+  const existing = dedupeEntries((current.allowFrom as unknown[]) ?? []);
+  let nextEntries = existing;
+
+  if (params.mode === "replace") {
+    nextEntries = dedupeEntries(params.entries);
+  } else if (params.mode === "clear") {
+    nextEntries = [];
+  } else {
+    const nextSet = new Set(existing);
+    for (const entry of params.entries) {
+      if (params.mode === "add") {
+        nextSet.add(entry);
+      } else {
+        nextSet.delete(entry);
+      }
+    }
+    nextEntries = Array.from(nextSet);
+  }
+
+  const nextGroup = { ...current };
+  if (nextEntries.length > 0) {
+    nextGroup.allowFrom = nextEntries;
+  } else {
+    delete nextGroup.allowFrom;
+  }
+  if (Object.keys(nextGroup).length > 0) {
+    groups[params.groupId] = nextGroup;
+  } else {
+    delete groups[params.groupId];
+  }
+  if (Object.keys(groups).length === 0) {
+    delete write.target.groups;
+  }
+  return {
+    nextCfg: write.nextCfg,
+    nextEntries,
+    pathLabel: `${write.pathPrefix}.groups.${params.groupId}.allowFrom`,
+  };
+}
+
+export function createGeweManageGroupAllowlistTool(
+  ctx: OpenClawPluginToolContext,
+  deps?: {
+    readConfig?: () => OpenClawConfig;
+    writeConfigFile?: (next: OpenClawConfig) => Promise<void>;
+  },
+): AnyAgentTool {
+  return {
+    name: "gewe_manage_group_allowlist",
+    label: "GeWe Manage Group Allowlist",
+    description:
+      "Inspect or edit a GeWe group's allowFrom override. Modes: inspect, add, remove, replace, clear.",
+    ownerOnly: true,
+    parameters: GeweManageGroupAllowlistSchema,
+    execute: async (_toolCallId, rawParams) => {
+      const params = GeweManageGroupAllowlistSchema.parse(rawParams ?? {});
+      const cfg = resolveToolConfig(ctx, deps?.readConfig);
+      const accountId = normalizeAccountId(params.accountId ?? ctx.agentAccountId ?? "default");
+      const groupId = resolveGroupId({
+        cfg,
+        accountId,
+        ctx,
+        rawGroupId: params.groupId,
+      });
+      const resolvedAccount = resolveGeweAccount({
+        cfg: cfg as never,
+        accountId,
+      });
+      const accountConfig = (
+        accountId === "default"
+          ? (cfg.channels?.["gewe-openclaw"] ?? {})
+          : ((cfg.channels?.["gewe-openclaw"] as { accounts?: Record<string, unknown> } | undefined)
+              ?.accounts?.[accountId] ?? {})
+      ) as Record<string, unknown>;
+
+      const pairingEntries = await readGeweAllowFromStore({ accountId });
+      const current = resolveEffectiveEntries({
+        accountConfig: resolvedAccount.config as Record<string, unknown>,
+        accountId,
+        groupId,
+        pairingEntries,
+      });
+
+      if (params.mode === "inspect") {
+        return jsonResult({
+          ok: true,
+          mode: params.mode,
+          accountId,
+          groupId,
+          groupPolicy: resolvedAccount.config.groupPolicy ?? "allowlist",
+          baseEntries: current.baseEntries,
+          pairingEntries,
+          overrideEntries: current.overrideEntries,
+          effectiveEntries: current.effectiveEntries,
+        });
+      }
+
+      if (!deps?.writeConfigFile) {
+        throw new Error("GeWe group allowlist management requires runtime config write support.");
+      }
+
+      const entries = dedupeEntries(params.entries ?? []);
+      if (params.mode !== "clear" && entries.length === 0) {
+        throw new Error(`GeWe ${params.mode} requires entries.`);
+      }
+
+      const mutated = mutateGroupAllowlist({
+        cfg,
+        accountId,
+        groupId,
+        mode: params.mode,
+        entries,
+      });
+      await deps.writeConfigFile(mutated.nextCfg);
+
+      return jsonResult({
+        ok: true,
+        mode: params.mode,
+        accountId,
+        groupId,
+        pathLabel: mutated.pathLabel,
+        overrideEntries: mutated.nextEntries,
+      });
+    },
+  };
+}

package/src/group-binding-tool.ts

@@ -0,0 +1,154 @@
+import type { AnyAgentTool, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { z } from "zod";
+
+import {
+  buildGeweDesiredBindingIdentity,
+  getGeweChatroomInfo,
+  getGeweProfile,
+  inferCurrentGeweGroupId,
+  modifyGeweChatroomRemark,
+  modifyGeweChatroomSelfNickname,
+  normalizeGeweBindingConversationId,
+  resolveExplicitGeweGroupBinding,
+  resolveGeweAccountForBindingTool,
+  resolveGeweAgentDisplayName,
+  resolveGeweBindingIdentityConfigForGroup,
+  resolveGeweCurrentSelfNickname,
+} from "./group-binding.js";
+import { normalizeAccountId, type OpenClawConfig } from "./openclaw-compat.js";
+
+const GeweSyncGroupBindingToolSchema = z
+  .object({
+    mode: z.enum(["inspect", "dry_run", "apply"]).optional().default("inspect"),
+    groupId: z.string().optional(),
+    accountId: z.string().optional(),
+    syncSelfNickname: z.boolean().optional(),
+    syncRemark: z.boolean().optional(),
+  })
+  .strict();
+
+function jsonResult(details: Record<string, unknown>) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(details, null, 2) }],
+    details,
+  };
+}
+
+export function createGeweSyncGroupBindingTool(ctx: OpenClawPluginToolContext): AnyAgentTool {
+  return {
+    name: "gewe_sync_group_binding",
+    label: "GeWe Sync Group Binding",
+    description:
+      "Inspect or manually sync a GeWe group binding identity. Modes: inspect, dry_run, apply.",
+    ownerOnly: true,
+    parameters: GeweSyncGroupBindingToolSchema,
+    execute: async (_toolCallId, rawParams) => {
+      const params = GeweSyncGroupBindingToolSchema.parse(rawParams ?? {});
+      const cfg = (ctx.config ?? {}) as OpenClawConfig;
+      const accountId = normalizeAccountId(params.accountId ?? ctx.agentAccountId ?? "default");
+      const explicitGroupId = normalizeGeweBindingConversationId(params.groupId);
+      const groupId =
+        explicitGroupId ??
+        inferCurrentGeweGroupId({
+          cfg,
+          accountId,
+          sessionKey: ctx.sessionKey,
+        });
+      if (!groupId) {
+        throw new Error(
+          "GeWe group binding sync requires groupId, or a current GeWe group session that can infer one.",
+        );
+      }
+
+      const binding = resolveExplicitGeweGroupBinding({
+        cfg,
+        accountId,
+        groupId,
+      });
+      if (!binding) {
+        throw new Error(
+          `GeWe group binding sync requires an explicit group binding for "${groupId}" on account "${accountId}".`,
+        );
+      }
+
+      const account = resolveGeweAccountForBindingTool({ cfg, accountId });
+      const identity = resolveGeweBindingIdentityConfigForGroup({
+        accountConfig: account.config,
+        groupId,
+      });
+      if (!identity.enabled) {
+        throw new Error(`GeWe bindingIdentity is disabled for "${groupId}".`);
+      }
+
+      const agentName = resolveGeweAgentDisplayName(cfg, binding.agentId);
+      const desired = buildGeweDesiredBindingIdentity({
+        identity,
+        agentId: binding.agentId,
+        agentName,
+      });
+      const profile = await getGeweProfile({ account });
+      const groupInfo = await getGeweChatroomInfo({ account, groupId });
+      const current = {
+        selfNickname: resolveGeweCurrentSelfNickname(groupInfo, profile.wxid),
+        remark: groupInfo.remark?.trim() || null,
+      };
+
+      const sync = {
+        selfNickname: params.syncSelfNickname ?? true,
+        remark: params.syncRemark ?? true,
+      };
+      const changes = {
+        selfNickname:
+          sync.selfNickname && (desired.selfNickname ?? null) !== (current.selfNickname ?? null),
+        remark: sync.remark && (desired.remark ?? null) !== (current.remark ?? null),
+      };
+      const applied = {
+        selfNickname: false,
+        remark: false,
+      };
+
+      if (params.mode === "apply") {
+        if (changes.selfNickname && desired.selfNickname) {
+          await modifyGeweChatroomSelfNickname({
+            account,
+            groupId,
+            nickName: desired.selfNickname,
+          });
+          applied.selfNickname = true;
+        }
+        if (changes.remark && desired.remark) {
+          await modifyGeweChatroomRemark({
+            account,
+            groupId,
+            remark: desired.remark,
+          });
+          applied.remark = true;
+        }
+      }
+
+      return jsonResult({
+        ok: true,
+        mode: params.mode,
+        accountId,
+        binding: {
+          kind: binding.kind,
+          groupId,
+          agentId: binding.agentId,
+          agentName,
+        },
+        sync,
+        current,
+        desired,
+        changes,
+        applied,
+        profile: {
+          wxid: profile.wxid,
+        },
+        chatroom: {
+          chatroomId: groupInfo.chatroomId,
+          nickName: groupInfo.nickName ?? null,
+        },
+      });
+    },
+  };
+}