234 lines
10 KiB
TypeScript
234 lines
10 KiB
TypeScript
import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
|
|
import type { DirigentConfig } from "../rules.js";
|
|
|
|
type DiscordControlAction = "channel-private-create" | "channel-private-update";
|
|
|
|
type ToolDeps = {
|
|
api: OpenClawPluginApi;
|
|
baseConfig: DirigentConfig;
|
|
pickDefined: (obj: Record<string, unknown>) => Record<string, unknown>;
|
|
discussionService?: {
|
|
initDiscussion: (params: {
|
|
discussionChannelId: string;
|
|
originChannelId: string;
|
|
initiatorAgentId: string;
|
|
initiatorSessionId: string;
|
|
initiatorWorkspaceRoot?: string;
|
|
discussGuide: string;
|
|
}) => Promise<unknown>;
|
|
handleCallback: (params: {
|
|
channelId: string;
|
|
summaryPath: string;
|
|
callerAgentId?: string;
|
|
callerSessionKey?: string;
|
|
}) => Promise<unknown>;
|
|
};
|
|
};
|
|
|
|
function parseAccountToken(api: OpenClawPluginApi, accountId?: string): { accountId: string; token: string } | null {
|
|
const root = (api.config as Record<string, unknown>) || {};
|
|
const channels = (root.channels as Record<string, unknown>) || {};
|
|
const discord = (channels.discord as Record<string, unknown>) || {};
|
|
const accounts = (discord.accounts as Record<string, Record<string, unknown>>) || {};
|
|
|
|
if (accountId && accounts[accountId] && typeof accounts[accountId].token === "string") {
|
|
return { accountId, token: accounts[accountId].token as string };
|
|
}
|
|
for (const [aid, rec] of Object.entries(accounts)) {
|
|
if (typeof rec?.token === "string" && rec.token) return { accountId: aid, token: rec.token };
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function discordRequest(token: string, method: string, path: string, body?: unknown): Promise<{ ok: boolean; status: number; text: string; json: any }> {
|
|
const r = await fetch(`https://discord.com/api/v10${path}`, {
|
|
method,
|
|
headers: {
|
|
Authorization: `Bot ${token}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: body === undefined ? undefined : JSON.stringify(body),
|
|
});
|
|
const text = await r.text();
|
|
let json: any = null;
|
|
try { json = text ? JSON.parse(text) : null; } catch { json = null; }
|
|
return { ok: r.ok, status: r.status, text, json };
|
|
}
|
|
|
|
function roleOrMemberType(v: unknown): number {
|
|
if (typeof v === "number") return v;
|
|
if (typeof v === "string" && v.toLowerCase() === "member") return 1;
|
|
return 0;
|
|
}
|
|
|
|
export function registerDirigentTools(deps: ToolDeps): void {
|
|
const { api, baseConfig, pickDefined, discussionService } = deps;
|
|
|
|
async function executeDiscordAction(action: DiscordControlAction, params: Record<string, unknown>) {
|
|
const live = baseConfig as DirigentConfig & {
|
|
enableDiscordControlTool?: boolean;
|
|
discordControlAccountId?: string;
|
|
};
|
|
if (live.enableDiscordControlTool === false) {
|
|
return { content: [{ type: "text", text: "discord actions disabled by config" }], isError: true };
|
|
}
|
|
|
|
const selected = parseAccountToken(api, (params.accountId as string | undefined) || live.discordControlAccountId);
|
|
if (!selected) {
|
|
return { content: [{ type: "text", text: "no Discord bot token found in channels.discord.accounts" }], isError: true };
|
|
}
|
|
const token = selected.token;
|
|
|
|
if (action === "channel-private-create") {
|
|
const guildId = String(params.guildId || "").trim();
|
|
const name = String(params.name || "").trim();
|
|
if (!guildId || !name) return { content: [{ type: "text", text: "guildId and name are required" }], isError: true };
|
|
|
|
const callbackChannelId = typeof params.callbackChannelId === "string" ? params.callbackChannelId.trim() : "";
|
|
const discussGuide = typeof params.discussGuide === "string" ? params.discussGuide.trim() : "";
|
|
if (callbackChannelId && !discussGuide) {
|
|
return { content: [{ type: "text", text: "discussGuide is required when callbackChannelId is provided" }], isError: true };
|
|
}
|
|
|
|
const allowedUserIds = Array.isArray(params.allowedUserIds) ? params.allowedUserIds.map(String) : [];
|
|
const allowedRoleIds = Array.isArray(params.allowedRoleIds) ? params.allowedRoleIds.map(String) : [];
|
|
const allowMask = String(params.allowMask || "1024");
|
|
const denyEveryoneMask = String(params.denyEveryoneMask || "1024");
|
|
|
|
const overwrites: any[] = [
|
|
{ id: guildId, type: 0, allow: "0", deny: denyEveryoneMask },
|
|
...allowedRoleIds.map((id) => ({ id, type: 0, allow: allowMask, deny: "0" })),
|
|
...allowedUserIds.map((id) => ({ id, type: 1, allow: allowMask, deny: "0" })),
|
|
];
|
|
|
|
const body = pickDefined({
|
|
name,
|
|
type: typeof params.type === "number" ? params.type : 0,
|
|
parent_id: params.parentId,
|
|
topic: params.topic,
|
|
position: params.position,
|
|
nsfw: params.nsfw,
|
|
permission_overwrites: overwrites,
|
|
});
|
|
|
|
const resp = await discordRequest(token, "POST", `/guilds/${guildId}/channels`, body);
|
|
if (!resp.ok) return { content: [{ type: "text", text: `discord action failed (${resp.status}): ${resp.text}` }], isError: true };
|
|
|
|
if (callbackChannelId && discussGuide && discussionService) {
|
|
await discussionService.initDiscussion({
|
|
discussionChannelId: String(resp.json?.id || ""),
|
|
originChannelId: callbackChannelId,
|
|
initiatorAgentId: String((params.__agentId as string | undefined) || ""),
|
|
initiatorSessionId: String((params.__sessionKey as string | undefined) || ""),
|
|
initiatorWorkspaceRoot: typeof params.__workspaceRoot === "string" ? params.__workspaceRoot : undefined,
|
|
discussGuide,
|
|
});
|
|
}
|
|
|
|
return { content: [{ type: "text", text: JSON.stringify({ ok: true, accountId: selected.accountId, channel: resp.json, discussionMode: !!callbackChannelId }, null, 2) }] };
|
|
}
|
|
|
|
const channelId = String(params.channelId || "").trim();
|
|
if (!channelId) return { content: [{ type: "text", text: "channelId is required" }], isError: true };
|
|
|
|
const mode = String(params.mode || "merge").toLowerCase() === "replace" ? "replace" : "merge";
|
|
const addUserIds = Array.isArray(params.addUserIds) ? params.addUserIds.map(String) : [];
|
|
const addRoleIds = Array.isArray(params.addRoleIds) ? params.addRoleIds.map(String) : [];
|
|
const removeTargetIds = Array.isArray(params.removeTargetIds) ? params.removeTargetIds.map(String) : [];
|
|
const allowMask = String(params.allowMask || "1024");
|
|
const denyMask = String(params.denyMask || "0");
|
|
|
|
const ch = await discordRequest(token, "GET", `/channels/${channelId}`);
|
|
if (!ch.ok) return { content: [{ type: "text", text: `discord action failed (${ch.status}): ${ch.text}` }], isError: true };
|
|
|
|
const current = Array.isArray(ch.json?.permission_overwrites) ? [...ch.json.permission_overwrites] : [];
|
|
const guildId = String(ch.json?.guild_id || "");
|
|
const everyone = current.find((x: any) => String(x?.id || "") === guildId && roleOrMemberType(x?.type) === 0);
|
|
|
|
let next: any[] = mode === "replace" ? (everyone ? [everyone] : []) : current.filter((x: any) => !removeTargetIds.includes(String(x?.id || "")));
|
|
for (const id of addRoleIds) {
|
|
next = next.filter((x: any) => String(x?.id || "") !== id);
|
|
next.push({ id, type: 0, allow: allowMask, deny: denyMask });
|
|
}
|
|
for (const id of addUserIds) {
|
|
next = next.filter((x: any) => String(x?.id || "") !== id);
|
|
next.push({ id, type: 1, allow: allowMask, deny: denyMask });
|
|
}
|
|
|
|
const resp = await discordRequest(token, "PATCH", `/channels/${channelId}`, { permission_overwrites: next });
|
|
if (!resp.ok) return { content: [{ type: "text", text: `discord action failed (${resp.status}): ${resp.text}` }], isError: true };
|
|
return { content: [{ type: "text", text: JSON.stringify({ ok: true, accountId: selected.accountId, channel: resp.json }, null, 2) }] };
|
|
}
|
|
|
|
api.registerTool({
|
|
name: "dirigent_discord_control",
|
|
description: "Create/update Discord private channels using the configured Discord bot token",
|
|
parameters: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
action: { type: "string", enum: ["channel-private-create", "channel-private-update"] },
|
|
accountId: { type: "string" },
|
|
guildId: { type: "string" },
|
|
channelId: { 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" },
|
|
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" },
|
|
callbackChannelId: { type: "string" },
|
|
discussGuide: { type: "string" },
|
|
},
|
|
required: ["action"],
|
|
},
|
|
handler: async (params, ctx) => {
|
|
const nextParams = {
|
|
...(params as Record<string, unknown>),
|
|
__agentId: ctx?.agentId,
|
|
__sessionKey: ctx?.sessionKey,
|
|
__workspaceRoot: ctx?.workspaceRoot,
|
|
};
|
|
return executeDiscordAction(params.action as DiscordControlAction, nextParams);
|
|
},
|
|
});
|
|
|
|
api.registerTool({
|
|
name: "discuss-callback",
|
|
description: "Close a discussion channel and notify the origin work channel with the discussion summary path",
|
|
parameters: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
properties: {
|
|
summaryPath: { type: "string" },
|
|
},
|
|
required: ["summaryPath"],
|
|
},
|
|
handler: async (params, ctx) => {
|
|
if (!discussionService) {
|
|
return { content: [{ type: "text", text: "discussion service is not available" }], isError: true };
|
|
}
|
|
try {
|
|
const result = await discussionService.handleCallback({
|
|
channelId: String(ctx?.channelId || ""),
|
|
summaryPath: String((params as Record<string, unknown>).summaryPath || ""),
|
|
callerAgentId: ctx?.agentId,
|
|
callerSessionKey: ctx?.sessionKey,
|
|
});
|
|
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
|
|
} catch (error) {
|
|
return { content: [{ type: "text", text: `discuss-callback failed: ${String(error)}` }], isError: true };
|
|
}
|
|
},
|
|
});
|
|
}
|