clawdbot 2026.1.4-1

package/dist/signal/send.js

@@ -0,0 +1,91 @@
+import { loadConfig } from "../config/config.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { saveMediaBuffer } from "../media/store.js";
+import { loadWebMedia } from "../web/media.js";
+import { signalRpcRequest } from "./client.js";
+function resolveBaseUrl(explicit) {
+    const cfg = loadConfig();
+    const signalCfg = cfg.signal;
+    if (explicit?.trim())
+        return explicit.trim();
+    if (signalCfg?.httpUrl?.trim())
+        return signalCfg.httpUrl.trim();
+    const host = signalCfg?.httpHost?.trim() || "127.0.0.1";
+    const port = signalCfg?.httpPort ?? 8080;
+    return `http://${host}:${port}`;
+}
+function resolveAccount(explicit) {
+    const cfg = loadConfig();
+    const signalCfg = cfg.signal;
+    const account = explicit?.trim() || signalCfg?.account?.trim();
+    return account || undefined;
+}
+function parseTarget(raw) {
+    let value = raw.trim();
+    if (!value)
+        throw new Error("Signal recipient is required");
+    const lower = value.toLowerCase();
+    if (lower.startsWith("signal:")) {
+        value = value.slice("signal:".length).trim();
+    }
+    const normalized = value.toLowerCase();
+    if (normalized.startsWith("group:")) {
+        return { type: "group", groupId: value.slice("group:".length).trim() };
+    }
+    if (normalized.startsWith("username:")) {
+        return {
+            type: "username",
+            username: value.slice("username:".length).trim(),
+        };
+    }
+    if (normalized.startsWith("u:")) {
+        return { type: "username", username: value.trim() };
+    }
+    return { type: "recipient", recipient: value };
+}
+async function resolveAttachment(mediaUrl, maxBytes) {
+    const media = await loadWebMedia(mediaUrl, maxBytes);
+    const saved = await saveMediaBuffer(media.buffer, media.contentType ?? undefined, "outbound", maxBytes);
+    return { path: saved.path, contentType: saved.contentType };
+}
+export async function sendMessageSignal(to, text, opts = {}) {
+    const baseUrl = resolveBaseUrl(opts.baseUrl);
+    const account = resolveAccount(opts.account);
+    const target = parseTarget(to);
+    let message = text ?? "";
+    const maxBytes = opts.maxBytes ?? 8 * 1024 * 1024;
+    let attachments;
+    if (opts.mediaUrl?.trim()) {
+        const resolved = await resolveAttachment(opts.mediaUrl.trim(), maxBytes);
+        attachments = [resolved.path];
+        const kind = mediaKindFromMime(resolved.contentType ?? undefined);
+        if (!message && kind) {
+            // Avoid sending an empty body when only attachments exist.
+            message = kind === "image" ? "<media:image>" : `<media:${kind}>`;
+        }
+    }
+    if (!message.trim() && (!attachments || attachments.length === 0)) {
+        throw new Error("Signal send requires text or media");
+    }
+    const params = { message };
+    if (account)
+        params.account = account;
+    if (attachments && attachments.length > 0) {
+        params.attachments = attachments;
+    }
+    if (target.type === "recipient") {
+        params.recipient = [target.recipient];
+    }
+    else if (target.type === "group") {
+        params.groupId = target.groupId;
+    }
+    else if (target.type === "username") {
+        params.username = [target.username];
+    }
+    const result = await signalRpcRequest("send", params, { baseUrl, timeoutMs: opts.timeoutMs });
+    const timestamp = result?.timestamp;
+    return {
+        messageId: timestamp ? String(timestamp) : "unknown",
+        timestamp,
+    };
+}

package/dist/slack/actions.js

@@ -0,0 +1,97 @@
+import { WebClient } from "@slack/web-api";
+import { loadConfig } from "../config/config.js";
+import { sendMessageSlack } from "./send.js";
+import { resolveSlackBotToken } from "./token.js";
+function resolveToken(explicit) {
+    const cfgToken = loadConfig().slack?.botToken;
+    const token = resolveSlackBotToken(explicit ?? process.env.SLACK_BOT_TOKEN ?? cfgToken ?? undefined);
+    if (!token) {
+        throw new Error("SLACK_BOT_TOKEN or slack.botToken is required for Slack actions");
+    }
+    return token;
+}
+function normalizeEmoji(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("Emoji is required for Slack reactions");
+    }
+    return trimmed.replace(/^:+|:+$/g, "");
+}
+async function getClient(opts = {}) {
+    const token = resolveToken(opts.token);
+    return opts.client ?? new WebClient(token);
+}
+export async function reactSlackMessage(channelId, messageId, emoji, opts = {}) {
+    const client = await getClient(opts);
+    await client.reactions.add({
+        channel: channelId,
+        timestamp: messageId,
+        name: normalizeEmoji(emoji),
+    });
+}
+export async function listSlackReactions(channelId, messageId, opts = {}) {
+    const client = await getClient(opts);
+    const result = await client.reactions.get({
+        channel: channelId,
+        timestamp: messageId,
+        full: true,
+    });
+    const message = result.message;
+    return message?.reactions ?? [];
+}
+export async function sendSlackMessage(to, content, opts = {}) {
+    return await sendMessageSlack(to, content, {
+        token: opts.token,
+        mediaUrl: opts.mediaUrl,
+        client: opts.client,
+    });
+}
+export async function editSlackMessage(channelId, messageId, content, opts = {}) {
+    const client = await getClient(opts);
+    await client.chat.update({
+        channel: channelId,
+        ts: messageId,
+        text: content,
+    });
+}
+export async function deleteSlackMessage(channelId, messageId, opts = {}) {
+    const client = await getClient(opts);
+    await client.chat.delete({
+        channel: channelId,
+        ts: messageId,
+    });
+}
+export async function readSlackMessages(channelId, opts = {}) {
+    const client = await getClient(opts);
+    const result = await client.conversations.history({
+        channel: channelId,
+        limit: opts.limit,
+        latest: opts.before,
+        oldest: opts.after,
+    });
+    return {
+        messages: (result.messages ?? []),
+        hasMore: Boolean(result.has_more),
+    };
+}
+export async function getSlackMemberInfo(userId, opts = {}) {
+    const client = await getClient(opts);
+    return await client.users.info({ user: userId });
+}
+export async function listSlackEmojis(opts = {}) {
+    const client = await getClient(opts);
+    return await client.emoji.list();
+}
+export async function pinSlackMessage(channelId, messageId, opts = {}) {
+    const client = await getClient(opts);
+    await client.pins.add({ channel: channelId, timestamp: messageId });
+}
+export async function unpinSlackMessage(channelId, messageId, opts = {}) {
+    const client = await getClient(opts);
+    await client.pins.remove({ channel: channelId, timestamp: messageId });
+}
+export async function listSlackPins(channelId, opts = {}) {
+    const client = await getClient(opts);
+    const result = await client.pins.list({ channel: channelId });
+    return (result.items ?? []);
+}

package/dist/slack/index.js

@@ -0,0 +1,5 @@
+export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, listSlackEmojis, listSlackPins, listSlackReactions, pinSlackMessage, reactSlackMessage, readSlackMessages, sendSlackMessage, unpinSlackMessage, } from "./actions.js";
+export { monitorSlackProvider } from "./monitor.js";
+export { probeSlack } from "./probe.js";
+export { sendMessageSlack } from "./send.js";
+export { resolveSlackAppToken, resolveSlackBotToken } from "./token.js";