@tinyclaw/plugin-channel-discord 1.0.1-dev.3f91a71

package/README.md

@@ -0,0 +1,28 @@
+# @tinyclaw/plugin-channel-discord
+
+Discord channel plugin for Tiny Claw. Connects a Discord bot to the agent, enabling conversations via Direct Messages and @mentions in guild channels.
+
+## Setup
+
+1. Create a Discord bot at <https://discord.com/developers/applications>
+2. Enable **Message Content Intent** under Privileged Gateway Intents
+3. Run Tiny Claw and ask it to pair the Discord channel
+4. Provide the bot token when prompted
+5. The agent auto-restarts and the bot connects automatically
+
+## How It Works
+
+- Listens for DMs and @mentions via discord.js
+- Routes messages through the agent loop as `discord:<user-id>`
+- Splits long responses to respect Discord's 2000-character limit
+
+## Pairing Tools
+
+| Tool | Description |
+|------|-------------|
+| `discord_pair` | Store a bot token and enable the plugin |
+| `discord_unpair` | Disable the plugin (token kept in secrets) |
+
+## License
+
+GPLv3

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Discord Channel Plugin
+ *
+ * Connects a Discord bot to the Tiny Claw agent.
+ * Responds to Direct Messages and @mentions in guild channels.
+ *
+ * Setup:
+ *   1. Create a Discord bot at https://discord.com/developers/applications
+ *   2. Enable: Message Content Intent (under Privileged Gateway Intents)
+ *   3. Run Tiny Claw and ask it to pair the Discord channel
+ *   4. Provide the bot token when prompted
+ *   5. Agent auto-restarts — the bot will connect automatically
+ *
+ * userId format: "discord:<discord-user-id>"
+ *   Prefixed to prevent collisions with web UI user IDs.
+ */
+import type { ChannelPlugin } from '@tinyclaw/types';
+declare const discordPlugin: ChannelPlugin;
+/** Split a string into chunks without cutting words at boundaries. */
+export declare function splitIntoChunks(text: string, maxLength: number): string[];
+export default discordPlugin;

package/dist/index.js

@@ -0,0 +1,129 @@
+/**
+ * Discord Channel Plugin
+ *
+ * Connects a Discord bot to the Tiny Claw agent.
+ * Responds to Direct Messages and @mentions in guild channels.
+ *
+ * Setup:
+ *   1. Create a Discord bot at https://discord.com/developers/applications
+ *   2. Enable: Message Content Intent (under Privileged Gateway Intents)
+ *   3. Run Tiny Claw and ask it to pair the Discord channel
+ *   4. Provide the bot token when prompted
+ *   5. Agent auto-restarts — the bot will connect automatically
+ *
+ * userId format: "discord:<discord-user-id>"
+ *   Prefixed to prevent collisions with web UI user IDs.
+ */
+import { Client, GatewayIntentBits, Partials, Events, } from 'discord.js';
+import { logger } from '@tinyclaw/logger';
+import { createDiscordPairingTools, DISCORD_TOKEN_SECRET_KEY, DISCORD_ENABLED_CONFIG_KEY, } from './pairing.js';
+let client = null;
+const discordPlugin = {
+    id: '@tinyclaw/plugin-channel-discord',
+    name: 'Discord',
+    description: 'Connect Tiny Claw to a Discord bot',
+    type: 'channel',
+    version: '0.1.0',
+    getPairingTools(secrets, configManager) {
+        return createDiscordPairingTools(secrets, configManager);
+    },
+    async start(context) {
+        const isEnabled = context.configManager.get(DISCORD_ENABLED_CONFIG_KEY);
+        if (!isEnabled) {
+            logger.info('Discord plugin: not enabled — run pairing to enable');
+            return;
+        }
+        const token = await context.secrets.retrieve(DISCORD_TOKEN_SECRET_KEY);
+        if (!token) {
+            logger.warn('Discord plugin: enabled but no token found — re-pair to fix');
+            return;
+        }
+        client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.MessageContent,
+                GatewayIntentBits.DirectMessages,
+            ],
+            partials: [Partials.Channel],
+        });
+        client.once(Events.ClientReady, (readyClient) => {
+            logger.info(`Discord bot ready: ${readyClient.user.tag}`);
+        });
+        client.on(Events.MessageCreate, async (msg) => {
+            // Ignore messages from bots (including self)
+            if (msg.author.bot)
+                return;
+            const isDM = msg.channel.isDMBased();
+            const isMention = client?.user
+                ? msg.mentions.users.has(client.user.id)
+                : false;
+            // Only respond to DMs or @mentions
+            if (!isDM && !isMention)
+                return;
+            // Strip @mention tokens from guild messages
+            const rawContent = msg.content
+                .replace(/<@!?[\d]+>/g, '')
+                .trim();
+            if (!rawContent)
+                return;
+            // Prefix userId to isolate Discord sessions from web UI sessions
+            const userId = `discord:${msg.author.id}`;
+            try {
+                if ('sendTyping' in msg.channel) {
+                    await msg.channel.sendTyping();
+                }
+                const response = await context.enqueue(userId, rawContent);
+                // Discord has a 2000-character message limit
+                if (response.length <= 2000) {
+                    await msg.reply(response);
+                }
+                else {
+                    const chunks = splitIntoChunks(response, 1900);
+                    for (const chunk of chunks) {
+                        if ('send' in msg.channel) {
+                            await msg.channel.send(chunk);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger.error('Discord plugin: error handling message', err);
+                try {
+                    await msg.reply('Sorry, I ran into an error. Please try again.');
+                }
+                catch {
+                    // If replying also fails, just log it
+                }
+            }
+        });
+        await client.login(token);
+        logger.info('Discord bot connected');
+    },
+    async stop() {
+        if (client) {
+            client.destroy();
+            client = null;
+            logger.info('Discord bot disconnected');
+        }
+    },
+};
+/** Split a string into chunks without cutting words at boundaries. */
+export function splitIntoChunks(text, maxLength) {
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > maxLength) {
+        let splitAt = remaining.lastIndexOf('\n', maxLength);
+        if (splitAt === -1)
+            splitAt = remaining.lastIndexOf(' ', maxLength);
+        if (splitAt === -1)
+            splitAt = maxLength;
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    if (remaining.length > 0) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}
+export default discordPlugin;

package/dist/pairing.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Discord Pairing Tools
+ *
+ * Two tools that implement the Discord bot pairing flow:
+ *
+ * 1. discord_pair — Store the bot token and enable the plugin
+ * 2. discord_unpair — Remove from enabled plugins and disable
+ *
+ * These tools are injected into the agent's tool list at boot so the agent
+ * can invoke them conversationally when a user asks to connect Discord.
+ */
+import type { Tool, SecretsManagerInterface, ConfigManagerInterface } from '@tinyclaw/types';
+/** Secret key for the Discord bot token. */
+export declare const DISCORD_TOKEN_SECRET_KEY: string;
+/** Config key for the enabled flag. */
+export declare const DISCORD_ENABLED_CONFIG_KEY = "channels.discord.enabled";
+/** The plugin's package ID. */
+export declare const DISCORD_PLUGIN_ID = "@tinyclaw/plugin-channel-discord";
+export declare function createDiscordPairingTools(secrets: SecretsManagerInterface, configManager: ConfigManagerInterface): Tool[];

package/dist/pairing.js

@@ -0,0 +1,91 @@
+/**
+ * Discord Pairing Tools
+ *
+ * Two tools that implement the Discord bot pairing flow:
+ *
+ * 1. discord_pair — Store the bot token and enable the plugin
+ * 2. discord_unpair — Remove from enabled plugins and disable
+ *
+ * These tools are injected into the agent's tool list at boot so the agent
+ * can invoke them conversationally when a user asks to connect Discord.
+ */
+import { buildChannelKeyName } from '@tinyclaw/types';
+/** Secret key for the Discord bot token. */
+export const DISCORD_TOKEN_SECRET_KEY = buildChannelKeyName('discord');
+/** Config key for the enabled flag. */
+export const DISCORD_ENABLED_CONFIG_KEY = 'channels.discord.enabled';
+/** The plugin's package ID. */
+export const DISCORD_PLUGIN_ID = '@tinyclaw/plugin-channel-discord';
+export function createDiscordPairingTools(secrets, configManager) {
+    return [
+        {
+            name: 'discord_pair',
+            description: 'Pair Tiny Claw with a Discord bot. ' +
+                'Stores the bot token securely and enables the Discord channel plugin. ' +
+                'After pairing, call tinyclaw_restart to connect the bot. ' +
+                'To get a token: go to https://discord.com/developers/applications, ' +
+                'create an application, add a Bot, copy the token, and enable ' +
+                '"Message Content Intent" under Privileged Gateway Intents.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    token: {
+                        type: 'string',
+                        description: 'Discord bot token',
+                    },
+                },
+                required: ['token'],
+            },
+            async execute(args) {
+                const token = args.token;
+                if (!token || token.trim() === '') {
+                    return 'Error: token must be a non-empty string.';
+                }
+                try {
+                    // 1. Store token in secrets engine
+                    await secrets.store(DISCORD_TOKEN_SECRET_KEY, token.trim());
+                    // 2. Enable channel in config
+                    configManager.set(DISCORD_ENABLED_CONFIG_KEY, true);
+                    configManager.set('channels.discord.tokenRef', DISCORD_TOKEN_SECRET_KEY);
+                    // 3. Add plugin to enabled list (deduplicated)
+                    const current = configManager.get('plugins.enabled') ?? [];
+                    if (!current.includes(DISCORD_PLUGIN_ID)) {
+                        configManager.set('plugins.enabled', [...current, DISCORD_PLUGIN_ID]);
+                    }
+                    return ('Discord bot paired successfully! ' +
+                        'Token stored securely and plugin enabled. ' +
+                        'Use the tinyclaw_restart tool now to connect the bot. ' +
+                        'Make sure "Message Content Intent" is enabled in the Discord Developer Portal.');
+                }
+                catch (err) {
+                    return `Error pairing Discord: ${err.message}`;
+                }
+            },
+        },
+        {
+            name: 'discord_unpair',
+            description: 'Disconnect the Discord bot and disable the Discord channel plugin. ' +
+                'The bot token is kept in secrets for safety. Call tinyclaw_restart after.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+            async execute() {
+                try {
+                    // Disable in config
+                    configManager.set(DISCORD_ENABLED_CONFIG_KEY, false);
+                    // Remove from plugins.enabled
+                    const current = configManager.get('plugins.enabled') ?? [];
+                    configManager.set('plugins.enabled', current.filter((id) => id !== DISCORD_PLUGIN_ID));
+                    return ('Discord plugin disabled. ' +
+                        'Use the tinyclaw_restart tool now to apply the changes. ' +
+                        'The bot token is still stored in secrets — use list_secrets to manage it.');
+                }
+                catch (err) {
+                    return `Error unpairing Discord: ${err.message}`;
+                }
+            },
+        },
+    ];
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@tinyclaw/plugin-channel-discord",
+  "version": "1.0.1-dev.3f91a71",
+  "description": "Discord channel plugin for Tiny Claw",
+  "license": "GPL-3.0",
+  "author": "Waren Gonzaga",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/warengonzaga/tinyclaw.git",
+    "directory": "plugins/channel/plugin-channel-discord"
+  },
+  "homepage": "https://github.com/warengonzaga/tinyclaw/tree/main/plugins/channel/plugin-channel-discord#readme",
+  "bugs": {
+    "url": "https://github.com/warengonzaga/tinyclaw/issues"
+  },
+  "keywords": [
+    "tinyclaw",
+    "plugin",
+    "channel",
+    "discord"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@tinyclaw/logger": "workspace:*",
+    "@tinyclaw/types": "workspace:*",
+    "discord.js": "^14.0.0"
+  }
+}