367 lines
14 KiB
TypeScript
367 lines
14 KiB
TypeScript
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
|
|
import { evaluateDecision, type ChannelPolicy, type Decision, type WhisperGateConfig } from "./rules.js";
|
|
|
|
type DiscordControlAction = "channel-private-create" | "channel-private-update" | "member-list";
|
|
|
|
type DecisionRecord = {
|
|
decision: Decision;
|
|
createdAt: number;
|
|
};
|
|
|
|
type PolicyState = {
|
|
filePath: string;
|
|
channelPolicies: Record<string, ChannelPolicy>;
|
|
};
|
|
|
|
const sessionDecision = new Map<string, DecisionRecord>();
|
|
const MAX_SESSION_DECISIONS = 2000;
|
|
const DECISION_TTL_MS = 5 * 60 * 1000;
|
|
const END_MARKER_INSTRUCTION = "你的这次发言必须以🔚作为结尾。";
|
|
|
|
const policyState: PolicyState = {
|
|
filePath: "",
|
|
channelPolicies: {},
|
|
};
|
|
|
|
function normalizeChannel(ctx: Record<string, unknown>): string {
|
|
const candidates = [ctx.commandSource, ctx.messageProvider, ctx.channelId, ctx.channel];
|
|
for (const c of candidates) {
|
|
if (typeof c === "string" && c.trim()) return c.trim().toLowerCase();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function normalizeSender(event: Record<string, unknown>, ctx: Record<string, unknown>): string | undefined {
|
|
const direct = [ctx.senderId, ctx.from, event.from];
|
|
for (const v of direct) {
|
|
if (typeof v === "string" && v.trim()) return v.trim();
|
|
}
|
|
|
|
const meta = (event.metadata || ctx.metadata) as Record<string, unknown> | undefined;
|
|
if (!meta) return undefined;
|
|
const metaCandidates = [meta.senderId, meta.sender_id, meta.userId, meta.user_id];
|
|
for (const v of metaCandidates) {
|
|
if (typeof v === "string" && v.trim()) return v.trim();
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
function pruneDecisionMap(now = Date.now()) {
|
|
for (const [k, v] of sessionDecision.entries()) {
|
|
if (now - v.createdAt > DECISION_TTL_MS) sessionDecision.delete(k);
|
|
}
|
|
|
|
if (sessionDecision.size <= MAX_SESSION_DECISIONS) return;
|
|
const keys = sessionDecision.keys();
|
|
while (sessionDecision.size > MAX_SESSION_DECISIONS) {
|
|
const k = keys.next();
|
|
if (k.done) break;
|
|
sessionDecision.delete(k.value);
|
|
}
|
|
}
|
|
|
|
function shouldInjectEndMarker(reason: string): boolean {
|
|
return reason.startsWith("end_symbol:");
|
|
}
|
|
|
|
function getLivePluginConfig(api: OpenClawPluginApi, fallback: WhisperGateConfig): WhisperGateConfig {
|
|
const root = (api.config as Record<string, unknown>) || {};
|
|
const plugins = (root.plugins as Record<string, unknown>) || {};
|
|
const entries = (plugins.entries as Record<string, unknown>) || {};
|
|
const entry = (entries.whispergate as Record<string, unknown>) || {};
|
|
const cfg = (entry.config as Record<string, unknown>) || {};
|
|
if (Object.keys(cfg).length > 0) return cfg as unknown as WhisperGateConfig;
|
|
return fallback;
|
|
}
|
|
|
|
function resolvePoliciesPath(api: OpenClawPluginApi, config: WhisperGateConfig): string {
|
|
return api.resolvePath(config.channelPoliciesFile || "~/.openclaw/whispergate-channel-policies.json");
|
|
}
|
|
|
|
function ensurePolicyStateLoaded(api: OpenClawPluginApi, config: WhisperGateConfig) {
|
|
if (policyState.filePath) return;
|
|
const filePath = resolvePoliciesPath(api, config);
|
|
policyState.filePath = filePath;
|
|
|
|
try {
|
|
if (!fs.existsSync(filePath)) {
|
|
fs.mkdirSync(path.dirname(filePath), { recursive: true });
|
|
fs.writeFileSync(filePath, "{}\n", "utf8");
|
|
policyState.channelPolicies = {};
|
|
return;
|
|
}
|
|
|
|
const raw = fs.readFileSync(filePath, "utf8");
|
|
const parsed = JSON.parse(raw) as Record<string, ChannelPolicy>;
|
|
policyState.channelPolicies = parsed && typeof parsed === "object" ? parsed : {};
|
|
} catch (err) {
|
|
api.logger.warn(`whispergate: failed init policy file ${filePath}: ${String(err)}`);
|
|
policyState.channelPolicies = {};
|
|
}
|
|
}
|
|
|
|
function persistPolicies(api: OpenClawPluginApi): void {
|
|
const filePath = policyState.filePath;
|
|
if (!filePath) throw new Error("policy file path not initialized");
|
|
const before = JSON.stringify(policyState.channelPolicies, null, 2) + "\n";
|
|
const tmp = `${filePath}.tmp`;
|
|
fs.mkdirSync(path.dirname(filePath), { recursive: true });
|
|
fs.writeFileSync(tmp, before, "utf8");
|
|
fs.renameSync(tmp, filePath);
|
|
api.logger.info(`whispergate: policy file persisted: ${filePath}`);
|
|
}
|
|
|
|
function pickDefined(input: Record<string, unknown>) {
|
|
const out: Record<string, unknown> = {};
|
|
for (const [k, v] of Object.entries(input)) {
|
|
if (v !== undefined) out[k] = v;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
export default {
|
|
id: "whispergate",
|
|
name: "WhisperGate",
|
|
register(api: OpenClawPluginApi) {
|
|
const baseConfig = (api.pluginConfig || {}) as WhisperGateConfig & {
|
|
enableDiscordControlTool?: boolean;
|
|
discordControlApiBaseUrl?: string;
|
|
discordControlApiToken?: string;
|
|
discordControlCallerId?: string;
|
|
enableWhispergatePolicyTool?: boolean;
|
|
};
|
|
|
|
const liveAtRegister = getLivePluginConfig(api, baseConfig as WhisperGateConfig);
|
|
ensurePolicyStateLoaded(api, liveAtRegister);
|
|
|
|
if (baseConfig.enableDiscordControlTool !== false) {
|
|
api.registerTool(
|
|
{
|
|
name: "discord_control",
|
|
description: "Discord admin extension actions: private channel create/update and member list.",
|
|
parameters: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
action: {
|
|
type: "string",
|
|
enum: ["channel-private-create", "channel-private-update", "member-list"],
|
|
},
|
|
guildId: { type: "string" },
|
|
name: { type: "string" },
|
|
type: { type: "number" },
|
|
parentId: { type: "string" },
|
|
topic: { type: "string" },
|
|
position: { type: "number" },
|
|
nsfw: { type: "boolean" },
|
|
allowedUserIds: { type: "array", items: { type: "string" } },
|
|
allowedRoleIds: { type: "array", items: { type: "string" } },
|
|
allowMask: { type: "string" },
|
|
denyEveryoneMask: { type: "string" },
|
|
channelId: { type: "string" },
|
|
mode: { type: "string", enum: ["merge", "replace"] },
|
|
addUserIds: { type: "array", items: { type: "string" } },
|
|
addRoleIds: { type: "array", items: { type: "string" } },
|
|
removeTargetIds: { type: "array", items: { type: "string" } },
|
|
denyMask: { type: "string" },
|
|
limit: { type: "number" },
|
|
after: { type: "string" },
|
|
fields: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
|
|
dryRun: { type: "boolean" },
|
|
},
|
|
required: ["action", "guildId"],
|
|
},
|
|
async execute(_id: string, params: Record<string, unknown>) {
|
|
const action = String(params.action || "") as DiscordControlAction;
|
|
const live = getLivePluginConfig(api, baseConfig as WhisperGateConfig) as WhisperGateConfig & {
|
|
discordControlApiBaseUrl?: string;
|
|
discordControlApiToken?: string;
|
|
discordControlCallerId?: string;
|
|
};
|
|
const baseUrl = (live.discordControlApiBaseUrl || "http://127.0.0.1:8790").replace(/\/$/, "");
|
|
const body = pickDefined({ ...params, action });
|
|
|
|
const headers: Record<string, string> = { "Content-Type": "application/json" };
|
|
if (live.discordControlApiToken) headers.Authorization = `Bearer ${live.discordControlApiToken}`;
|
|
if (live.discordControlCallerId) headers["X-OpenClaw-Caller-Id"] = live.discordControlCallerId;
|
|
|
|
const r = await fetch(`${baseUrl}/v1/discord/action`, {
|
|
method: "POST",
|
|
headers,
|
|
body: JSON.stringify(body),
|
|
});
|
|
const text = await r.text();
|
|
|
|
if (!r.ok) {
|
|
return {
|
|
content: [{ type: "text", text: `discord_control failed (${r.status}): ${text}` }],
|
|
isError: true,
|
|
};
|
|
}
|
|
|
|
return { content: [{ type: "text", text }] };
|
|
},
|
|
},
|
|
{ optional: true },
|
|
);
|
|
}
|
|
|
|
if (baseConfig.enableWhispergatePolicyTool !== false) {
|
|
api.registerTool(
|
|
{
|
|
name: "whispergate_policy",
|
|
description: "Manage WhisperGate in-memory channel policies and persist to file.",
|
|
parameters: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
action: {
|
|
type: "string",
|
|
enum: ["get", "set-channel", "delete-channel"],
|
|
},
|
|
channelId: { type: "string" },
|
|
listMode: { type: "string", enum: ["human-list", "agent-list"] },
|
|
humanList: { type: "array", items: { type: "string" } },
|
|
agentList: { type: "array", items: { type: "string" } },
|
|
endSymbols: { type: "array", items: { type: "string" } },
|
|
},
|
|
required: ["action"],
|
|
},
|
|
async execute(_id: string, params: Record<string, unknown>) {
|
|
const live = getLivePluginConfig(api, baseConfig as WhisperGateConfig);
|
|
ensurePolicyStateLoaded(api, live);
|
|
const action = String(params.action || "");
|
|
|
|
if (action === "get") {
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: JSON.stringify({ file: policyState.filePath, policies: policyState.channelPolicies }, null, 2),
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
if (action === "set-channel") {
|
|
const channelId = String(params.channelId || "").trim();
|
|
if (!channelId) return { content: [{ type: "text", text: "channelId is required" }], isError: true };
|
|
|
|
const prev = JSON.parse(JSON.stringify(policyState.channelPolicies));
|
|
try {
|
|
const next: ChannelPolicy = {
|
|
listMode: (params.listMode as "human-list" | "agent-list" | undefined) || undefined,
|
|
humanList: Array.isArray(params.humanList) ? (params.humanList as string[]) : undefined,
|
|
agentList: Array.isArray(params.agentList) ? (params.agentList as string[]) : undefined,
|
|
endSymbols: Array.isArray(params.endSymbols) ? (params.endSymbols as string[]) : undefined,
|
|
};
|
|
policyState.channelPolicies[channelId] = pickDefined(next as unknown as Record<string, unknown>) as ChannelPolicy;
|
|
persistPolicies(api);
|
|
return { content: [{ type: "text", text: JSON.stringify({ ok: true, channelId, policy: policyState.channelPolicies[channelId] }) }] };
|
|
} catch (err) {
|
|
policyState.channelPolicies = prev;
|
|
return { content: [{ type: "text", text: `persist failed: ${String(err)}` }], isError: true };
|
|
}
|
|
}
|
|
|
|
if (action === "delete-channel") {
|
|
const channelId = String(params.channelId || "").trim();
|
|
if (!channelId) return { content: [{ type: "text", text: "channelId is required" }], isError: true };
|
|
const prev = JSON.parse(JSON.stringify(policyState.channelPolicies));
|
|
try {
|
|
delete policyState.channelPolicies[channelId];
|
|
persistPolicies(api);
|
|
return { content: [{ type: "text", text: JSON.stringify({ ok: true, channelId, deleted: true }) }] };
|
|
} catch (err) {
|
|
policyState.channelPolicies = prev;
|
|
return { content: [{ type: "text", text: `persist failed: ${String(err)}` }], isError: true };
|
|
}
|
|
}
|
|
|
|
return { content: [{ type: "text", text: `unsupported action: ${action}` }], isError: true };
|
|
},
|
|
},
|
|
{ optional: true },
|
|
);
|
|
}
|
|
|
|
api.on("message_received", async (event, ctx) => {
|
|
try {
|
|
const c = (ctx || {}) as Record<string, unknown>;
|
|
const e = (event || {}) as Record<string, unknown>;
|
|
const sessionKey = typeof c.sessionKey === "string" ? c.sessionKey : undefined;
|
|
if (!sessionKey) return;
|
|
|
|
const senderId = normalizeSender(e, c);
|
|
const content = typeof e.content === "string" ? e.content : "";
|
|
const channel = normalizeChannel(c);
|
|
const channelId = typeof c.channelId === "string" ? c.channelId : undefined;
|
|
|
|
const live = getLivePluginConfig(api, baseConfig as WhisperGateConfig);
|
|
ensurePolicyStateLoaded(api, live);
|
|
const decision = evaluateDecision({
|
|
config: live,
|
|
channel,
|
|
channelId,
|
|
channelPolicies: policyState.channelPolicies,
|
|
senderId,
|
|
content,
|
|
});
|
|
sessionDecision.set(sessionKey, { decision, createdAt: Date.now() });
|
|
pruneDecisionMap();
|
|
api.logger.debug?.(
|
|
`whispergate: session=${sessionKey} sender=${senderId ?? "unknown"} channel=${channel || "unknown"} decision=${decision.reason}`,
|
|
);
|
|
} catch (err) {
|
|
api.logger.warn(`whispergate: message hook failed: ${String(err)}`);
|
|
}
|
|
});
|
|
|
|
api.on("before_model_resolve", async (_event, ctx) => {
|
|
const key = ctx.sessionKey;
|
|
if (!key) return;
|
|
|
|
const rec = sessionDecision.get(key);
|
|
if (!rec) return;
|
|
if (Date.now() - rec.createdAt > DECISION_TTL_MS) {
|
|
sessionDecision.delete(key);
|
|
return;
|
|
}
|
|
|
|
if (!rec.decision.shouldUseNoReply) return;
|
|
|
|
sessionDecision.delete(key);
|
|
const live = getLivePluginConfig(api, baseConfig as WhisperGateConfig);
|
|
api.logger.info(
|
|
`whispergate: override model for session=${key}, provider=${live.noReplyProvider}, model=${live.noReplyModel}, reason=${rec.decision.reason}`,
|
|
);
|
|
|
|
return {
|
|
providerOverride: live.noReplyProvider,
|
|
modelOverride: live.noReplyModel,
|
|
};
|
|
});
|
|
|
|
api.on("before_prompt_build", async (_event, ctx) => {
|
|
const key = ctx.sessionKey;
|
|
if (!key) return;
|
|
const rec = sessionDecision.get(key);
|
|
if (!rec) return;
|
|
|
|
if (Date.now() - rec.createdAt > DECISION_TTL_MS) {
|
|
sessionDecision.delete(key);
|
|
return;
|
|
}
|
|
|
|
sessionDecision.delete(key);
|
|
if (!shouldInjectEndMarker(rec.decision.reason)) return;
|
|
|
|
api.logger.info(`whispergate: prepend end marker instruction for session=${key}, reason=${rec.decision.reason}`);
|
|
return { prependContext: END_MARKER_INSTRUCTION };
|
|
});
|
|
},
|
|
};
|