clawdbot 2026.1.4-1

package/dist/agents/tools/common.js

@@ -0,0 +1,88 @@
+import fs from "node:fs/promises";
+import { detectMime } from "../../media/mime.js";
+import { sanitizeToolResultImages } from "../tool-images.js";
+export function readStringParam(params, key, options = {}) {
+    const { required = false, trim = true, label = key } = options;
+    const raw = params[key];
+    if (typeof raw !== "string") {
+        if (required)
+            throw new Error(`${label} required`);
+        return undefined;
+    }
+    const value = trim ? raw.trim() : raw;
+    if (!value) {
+        if (required)
+            throw new Error(`${label} required`);
+        return undefined;
+    }
+    return value;
+}
+export function readStringArrayParam(params, key, options = {}) {
+    const { required = false, label = key } = options;
+    const raw = params[key];
+    if (Array.isArray(raw)) {
+        const values = raw
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        if (values.length === 0) {
+            if (required)
+                throw new Error(`${label} required`);
+            return undefined;
+        }
+        return values;
+    }
+    if (typeof raw === "string") {
+        const value = raw.trim();
+        if (!value) {
+            if (required)
+                throw new Error(`${label} required`);
+            return undefined;
+        }
+        return [value];
+    }
+    if (required)
+        throw new Error(`${label} required`);
+    return undefined;
+}
+export function jsonResult(payload) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(payload, null, 2),
+            },
+        ],
+        details: payload,
+    };
+}
+export async function imageResult(params) {
+    const content = [
+        {
+            type: "text",
+            text: params.extraText ?? `MEDIA:${params.path}`,
+        },
+        {
+            type: "image",
+            data: params.base64,
+            mimeType: params.mimeType,
+        },
+    ];
+    const result = {
+        content,
+        details: { path: params.path, ...params.details },
+    };
+    return await sanitizeToolResultImages(result, params.label);
+}
+export async function imageResultFromFile(params) {
+    const buf = await fs.readFile(params.path);
+    const mimeType = (await detectMime({ buffer: buf.slice(0, 256) })) ?? "image/png";
+    return await imageResult({
+        label: params.label,
+        path: params.path,
+        base64: buf.toString("base64"),
+        mimeType,
+        extraText: params.extraText,
+        details: params.details,
+    });
+}

package/dist/agents/tools/cron-tool.js

@@ -0,0 +1,124 @@
+import { Type } from "@sinclair/typebox";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const CronToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("status"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("list"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        includeDisabled: Type.Optional(Type.Boolean()),
+    }),
+    Type.Object({
+        action: Type.Literal("add"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        job: Type.Object({}, { additionalProperties: true }),
+    }),
+    Type.Object({
+        action: Type.Literal("update"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        jobId: Type.String(),
+        patch: Type.Object({}, { additionalProperties: true }),
+    }),
+    Type.Object({
+        action: Type.Literal("remove"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        jobId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("run"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        jobId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("runs"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        jobId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("wake"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        text: Type.String(),
+        mode: Type.Optional(Type.Union([Type.Literal("now"), Type.Literal("next-heartbeat")])),
+    }),
+]);
+export function createCronTool() {
+    return {
+        label: "Cron",
+        name: "cron",
+        description: "Manage Gateway cron jobs (status/list/add/update/remove/run/runs) and send wake events.",
+        parameters: CronToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {
+                gatewayUrl: readStringParam(params, "gatewayUrl", { trim: false }),
+                gatewayToken: readStringParam(params, "gatewayToken", { trim: false }),
+                timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : undefined,
+            };
+            switch (action) {
+                case "status":
+                    return jsonResult(await callGatewayTool("cron.status", gatewayOpts, {}));
+                case "list":
+                    return jsonResult(await callGatewayTool("cron.list", gatewayOpts, {
+                        includeDisabled: Boolean(params.includeDisabled),
+                    }));
+                case "add": {
+                    if (!params.job || typeof params.job !== "object") {
+                        throw new Error("job required");
+                    }
+                    return jsonResult(await callGatewayTool("cron.add", gatewayOpts, params.job));
+                }
+                case "update": {
+                    const id = readStringParam(params, "jobId", { required: true });
+                    if (!params.patch || typeof params.patch !== "object") {
+                        throw new Error("patch required");
+                    }
+                    return jsonResult(await callGatewayTool("cron.update", gatewayOpts, {
+                        id,
+                        patch: params.patch,
+                    }));
+                }
+                case "remove": {
+                    const id = readStringParam(params, "jobId", { required: true });
+                    return jsonResult(await callGatewayTool("cron.remove", gatewayOpts, { id }));
+                }
+                case "run": {
+                    const id = readStringParam(params, "jobId", { required: true });
+                    return jsonResult(await callGatewayTool("cron.run", gatewayOpts, { id }));
+                }
+                case "runs": {
+                    const id = readStringParam(params, "jobId", { required: true });
+                    return jsonResult(await callGatewayTool("cron.runs", gatewayOpts, { id }));
+                }
+                case "wake": {
+                    const text = readStringParam(params, "text", { required: true });
+                    const mode = params.mode === "now" || params.mode === "next-heartbeat"
+                        ? params.mode
+                        : "next-heartbeat";
+                    return jsonResult(await callGatewayTool("wake", gatewayOpts, { mode, text }, { expectFinal: false }));
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        },
+    };
+}

package/dist/agents/tools/discord-actions-guild.js

@@ -0,0 +1,186 @@
+import { addRoleDiscord, createScheduledEventDiscord, fetchChannelInfoDiscord, fetchMemberInfoDiscord, fetchRoleInfoDiscord, fetchVoiceStatusDiscord, listGuildChannelsDiscord, listGuildEmojisDiscord, listScheduledEventsDiscord, removeRoleDiscord, uploadEmojiDiscord, uploadStickerDiscord, } from "../../discord/send.js";
+import { jsonResult, readStringArrayParam, readStringParam } from "./common.js";
+export async function handleDiscordGuildAction(action, params, isActionEnabled) {
+    switch (action) {
+        case "memberInfo": {
+            if (!isActionEnabled("memberInfo")) {
+                throw new Error("Discord member info is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const member = await fetchMemberInfoDiscord(guildId, userId);
+            return jsonResult({ ok: true, member });
+        }
+        case "roleInfo": {
+            if (!isActionEnabled("roleInfo")) {
+                throw new Error("Discord role info is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const roles = await fetchRoleInfoDiscord(guildId);
+            return jsonResult({ ok: true, roles });
+        }
+        case "emojiList": {
+            if (!isActionEnabled("reactions")) {
+                throw new Error("Discord reactions are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const emojis = await listGuildEmojisDiscord(guildId);
+            return jsonResult({ ok: true, emojis });
+        }
+        case "emojiUpload": {
+            if (!isActionEnabled("emojiUploads")) {
+                throw new Error("Discord emoji uploads are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const mediaUrl = readStringParam(params, "mediaUrl", {
+                required: true,
+            });
+            const roleIds = readStringArrayParam(params, "roleIds");
+            const emoji = await uploadEmojiDiscord({
+                guildId,
+                name,
+                mediaUrl,
+                roleIds: roleIds?.length ? roleIds : undefined,
+            });
+            return jsonResult({ ok: true, emoji });
+        }
+        case "stickerUpload": {
+            if (!isActionEnabled("stickerUploads")) {
+                throw new Error("Discord sticker uploads are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const description = readStringParam(params, "description", {
+                required: true,
+            });
+            const tags = readStringParam(params, "tags", { required: true });
+            const mediaUrl = readStringParam(params, "mediaUrl", {
+                required: true,
+            });
+            const sticker = await uploadStickerDiscord({
+                guildId,
+                name,
+                description,
+                tags,
+                mediaUrl,
+            });
+            return jsonResult({ ok: true, sticker });
+        }
+        case "roleAdd": {
+            if (!isActionEnabled("roles", false)) {
+                throw new Error("Discord role changes are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const roleId = readStringParam(params, "roleId", { required: true });
+            await addRoleDiscord({ guildId, userId, roleId });
+            return jsonResult({ ok: true });
+        }
+        case "roleRemove": {
+            if (!isActionEnabled("roles", false)) {
+                throw new Error("Discord role changes are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const roleId = readStringParam(params, "roleId", { required: true });
+            await removeRoleDiscord({ guildId, userId, roleId });
+            return jsonResult({ ok: true });
+        }
+        case "channelInfo": {
+            if (!isActionEnabled("channelInfo")) {
+                throw new Error("Discord channel info is disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const channel = await fetchChannelInfoDiscord(channelId);
+            return jsonResult({ ok: true, channel });
+        }
+        case "channelList": {
+            if (!isActionEnabled("channelInfo")) {
+                throw new Error("Discord channel info is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const channels = await listGuildChannelsDiscord(guildId);
+            return jsonResult({ ok: true, channels });
+        }
+        case "voiceStatus": {
+            if (!isActionEnabled("voiceStatus")) {
+                throw new Error("Discord voice status is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const voice = await fetchVoiceStatusDiscord(guildId, userId);
+            return jsonResult({ ok: true, voice });
+        }
+        case "eventList": {
+            if (!isActionEnabled("events")) {
+                throw new Error("Discord events are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const events = await listScheduledEventsDiscord(guildId);
+            return jsonResult({ ok: true, events });
+        }
+        case "eventCreate": {
+            if (!isActionEnabled("events")) {
+                throw new Error("Discord events are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const startTime = readStringParam(params, "startTime", {
+                required: true,
+            });
+            const endTime = readStringParam(params, "endTime");
+            const description = readStringParam(params, "description");
+            const channelId = readStringParam(params, "channelId");
+            const location = readStringParam(params, "location");
+            const entityTypeRaw = readStringParam(params, "entityType");
+            const entityType = entityTypeRaw === "stage" ? 1 : entityTypeRaw === "external" ? 3 : 2;
+            const payload = {
+                name,
+                description,
+                scheduled_start_time: startTime,
+                scheduled_end_time: endTime,
+                entity_type: entityType,
+                channel_id: channelId,
+                entity_metadata: entityType === 3 && location ? { location } : undefined,
+                privacy_level: 2,
+            };
+            const event = await createScheduledEventDiscord(guildId, payload);
+            return jsonResult({ ok: true, event });
+        }
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}

package/dist/agents/tools/discord-actions-messaging.js

@@ -0,0 +1,285 @@
+import { createThreadDiscord, deleteMessageDiscord, editMessageDiscord, fetchChannelPermissionsDiscord, fetchReactionsDiscord, listPinsDiscord, listThreadsDiscord, pinMessageDiscord, reactMessageDiscord, readMessagesDiscord, searchMessagesDiscord, sendMessageDiscord, sendPollDiscord, sendStickerDiscord, unpinMessageDiscord, } from "../../discord/send.js";
+import { jsonResult, readStringArrayParam, readStringParam } from "./common.js";
+export async function handleDiscordMessagingAction(action, params, isActionEnabled) {
+    switch (action) {
+        case "react": {
+            if (!isActionEnabled("reactions")) {
+                throw new Error("Discord reactions are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            const emoji = readStringParam(params, "emoji", { required: true });
+            await reactMessageDiscord(channelId, messageId, emoji);
+            return jsonResult({ ok: true });
+        }
+        case "reactions": {
+            if (!isActionEnabled("reactions")) {
+                throw new Error("Discord reactions are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            const limitRaw = params.limit;
+            const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw)
+                ? limitRaw
+                : undefined;
+            const reactions = await fetchReactionsDiscord(channelId, messageId, {
+                limit,
+            });
+            return jsonResult({ ok: true, reactions });
+        }
+        case "sticker": {
+            if (!isActionEnabled("stickers")) {
+                throw new Error("Discord stickers are disabled.");
+            }
+            const to = readStringParam(params, "to", { required: true });
+            const content = readStringParam(params, "content");
+            const stickerIds = readStringArrayParam(params, "stickerIds", {
+                required: true,
+                label: "stickerIds",
+            });
+            await sendStickerDiscord(to, stickerIds, { content });
+            return jsonResult({ ok: true });
+        }
+        case "poll": {
+            if (!isActionEnabled("polls")) {
+                throw new Error("Discord polls are disabled.");
+            }
+            const to = readStringParam(params, "to", { required: true });
+            const content = readStringParam(params, "content");
+            const question = readStringParam(params, "question", {
+                required: true,
+            });
+            const answers = readStringArrayParam(params, "answers", {
+                required: true,
+                label: "answers",
+            });
+            const allowMultiselectRaw = params.allowMultiselect;
+            const allowMultiselect = typeof allowMultiselectRaw === "boolean"
+                ? allowMultiselectRaw
+                : undefined;
+            const durationRaw = params.durationHours;
+            const durationHours = typeof durationRaw === "number" && Number.isFinite(durationRaw)
+                ? durationRaw
+                : undefined;
+            await sendPollDiscord(to, { question, answers, allowMultiselect, durationHours }, { content });
+            return jsonResult({ ok: true });
+        }
+        case "permissions": {
+            if (!isActionEnabled("permissions")) {
+                throw new Error("Discord permissions are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const permissions = await fetchChannelPermissionsDiscord(channelId);
+            return jsonResult({ ok: true, permissions });
+        }
+        case "readMessages": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message reads are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messages = await readMessagesDiscord(channelId, {
+                limit: typeof params.limit === "number" && Number.isFinite(params.limit)
+                    ? params.limit
+                    : undefined,
+                before: readStringParam(params, "before"),
+                after: readStringParam(params, "after"),
+                around: readStringParam(params, "around"),
+            });
+            return jsonResult({ ok: true, messages });
+        }
+        case "sendMessage": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message sends are disabled.");
+            }
+            const to = readStringParam(params, "to", { required: true });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const mediaUrl = readStringParam(params, "mediaUrl");
+            const replyTo = readStringParam(params, "replyTo");
+            const result = await sendMessageDiscord(to, content, {
+                mediaUrl,
+                replyTo,
+            });
+            return jsonResult({ ok: true, result });
+        }
+        case "editMessage": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message edits are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const message = await editMessageDiscord(channelId, messageId, {
+                content,
+            });
+            return jsonResult({ ok: true, message });
+        }
+        case "deleteMessage": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message deletes are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            await deleteMessageDiscord(channelId, messageId);
+            return jsonResult({ ok: true });
+        }
+        case "threadCreate": {
+            if (!isActionEnabled("threads")) {
+                throw new Error("Discord threads are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const messageId = readStringParam(params, "messageId");
+            const autoArchiveMinutesRaw = params.autoArchiveMinutes;
+            const autoArchiveMinutes = typeof autoArchiveMinutesRaw === "number" &&
+                Number.isFinite(autoArchiveMinutesRaw)
+                ? autoArchiveMinutesRaw
+                : undefined;
+            const thread = await createThreadDiscord(channelId, {
+                name,
+                messageId,
+                autoArchiveMinutes,
+            });
+            return jsonResult({ ok: true, thread });
+        }
+        case "threadList": {
+            if (!isActionEnabled("threads")) {
+                throw new Error("Discord threads are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const channelId = readStringParam(params, "channelId");
+            const includeArchived = typeof params.includeArchived === "boolean"
+                ? params.includeArchived
+                : undefined;
+            const before = readStringParam(params, "before");
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                ? params.limit
+                : undefined;
+            const threads = await listThreadsDiscord({
+                guildId,
+                channelId,
+                includeArchived,
+                before,
+                limit,
+            });
+            return jsonResult({ ok: true, threads });
+        }
+        case "threadReply": {
+            if (!isActionEnabled("threads")) {
+                throw new Error("Discord threads are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const mediaUrl = readStringParam(params, "mediaUrl");
+            const replyTo = readStringParam(params, "replyTo");
+            const result = await sendMessageDiscord(`channel:${channelId}`, content, {
+                mediaUrl,
+                replyTo,
+            });
+            return jsonResult({ ok: true, result });
+        }
+        case "pinMessage": {
+            if (!isActionEnabled("pins")) {
+                throw new Error("Discord pins are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            await pinMessageDiscord(channelId, messageId);
+            return jsonResult({ ok: true });
+        }
+        case "unpinMessage": {
+            if (!isActionEnabled("pins")) {
+                throw new Error("Discord pins are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            await unpinMessageDiscord(channelId, messageId);
+            return jsonResult({ ok: true });
+        }
+        case "listPins": {
+            if (!isActionEnabled("pins")) {
+                throw new Error("Discord pins are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const pins = await listPinsDiscord(channelId);
+            return jsonResult({ ok: true, pins });
+        }
+        case "searchMessages": {
+            if (!isActionEnabled("search")) {
+                throw new Error("Discord search is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const channelId = readStringParam(params, "channelId");
+            const channelIds = readStringArrayParam(params, "channelIds");
+            const authorId = readStringParam(params, "authorId");
+            const authorIds = readStringArrayParam(params, "authorIds");
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                ? params.limit
+                : undefined;
+            const channelIdList = [
+                ...(channelIds ?? []),
+                ...(channelId ? [channelId] : []),
+            ];
+            const authorIdList = [
+                ...(authorIds ?? []),
+                ...(authorId ? [authorId] : []),
+            ];
+            const results = await searchMessagesDiscord({
+                guildId,
+                content,
+                channelIds: channelIdList.length ? channelIdList : undefined,
+                authorIds: authorIdList.length ? authorIdList : undefined,
+                limit,
+            });
+            return jsonResult({ ok: true, results });
+        }
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}