discoclaw 0.1.0

package/dist/discord/actions.test.js

@@ -0,0 +1,522 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChannelType } from 'discord.js';
+import { parseDiscordActions, executeDiscordActions, discordActionsPromptSection, buildDisplayResultLines, buildAllResultLines } from './actions.js';
+import { TaskStore } from '../tasks/store.js';
+import { _resetDestructiveConfirmationForTest } from './destructive-confirmation.js';
+const ALL_FLAGS = {
+    channels: true,
+    messaging: false,
+    guild: false,
+    moderation: false,
+    polls: false,
+    tasks: false,
+    crons: false,
+    botProfile: false,
+    forge: false,
+    plan: false,
+    memory: false,
+    config: false,
+    defer: true,
+};
+// ---------------------------------------------------------------------------
+// parseDiscordActions
+// ---------------------------------------------------------------------------
+describe('parseDiscordActions', () => {
+    beforeEach(() => {
+        _resetDestructiveConfirmationForTest();
+    });
+    it('extracts a single action and strips it from text', () => {
+        const input = 'Here is the list:\n<discord-action>{"type":"channelList"}</discord-action>\nDone.';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'channelList' }]);
+        expect(cleanText).toBe('Here is the list:\n\nDone.');
+    });
+    it('extracts multiple actions', () => {
+        const input = '<discord-action>{"type":"channelCreate","name":"status","parent":"Dev"}</discord-action>' +
+            '<discord-action>{"type":"channelList"}</discord-action>';
+        const { actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(2);
+        expect(actions[0]).toEqual({ type: 'channelCreate', name: 'status', parent: 'Dev' });
+        expect(actions[1]).toEqual({ type: 'channelList' });
+    });
+    it('extracts defer actions when defer flag enabled', () => {
+        const input = '<discord-action>{"type":"defer","channel":"general","delaySeconds":300,"prompt":"check the forge"}</discord-action>';
+        const { actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'defer', channel: 'general', delaySeconds: 300, prompt: 'check the forge' }]);
+    });
+    it('skips malformed JSON gracefully', () => {
+        const input = '<discord-action>{bad json}</discord-action>Some text';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+        expect(cleanText).toBe('Some text');
+    });
+    it('skips unknown action types', () => {
+        const input = '<discord-action>{"type":"somethingWeird","id":"123"}</discord-action>';
+        const { actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+    });
+    it('skips disabled category action types', () => {
+        const input = '<discord-action>{"type":"channelCreate","name":"test"}</discord-action>';
+        const { actions } = parseDiscordActions(input, { ...ALL_FLAGS, channels: false });
+        expect(actions).toHaveLength(0);
+    });
+    it('skips defer actions when defer flag disabled', () => {
+        const input = '<discord-action>{"type":"defer","channel":"general","delaySeconds":60}</discord-action>';
+        const { actions } = parseDiscordActions(input, { ...ALL_FLAGS, defer: false });
+        expect(actions).toHaveLength(0);
+    });
+    it('returns original text when no actions present', () => {
+        const input = 'Just a normal message.';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+        expect(cleanText).toBe(input);
+    });
+    it('collapses blank lines left by multiple stripped action blocks', () => {
+        const block = '<discord-action>{"type":"channelList"}</discord-action>';
+        const input = `Here is the list:\n${block}\n${block}\n${block}\n${block}\n${block}\nDone.`;
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(5);
+        expect(cleanText).not.toMatch(/\n{3,}/);
+        expect(cleanText).toBe('Here is the list:\n\nDone.');
+    });
+    it('strips malformed action blocks with wrong closing tags', () => {
+        const input = 'Here is the bead:\n<discord-action>{"type":"channelList"}</parameter>\n</invoke>';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'channelList' }]);
+        expect(cleanText).toBe('Here is the bead:');
+    });
+    it('strips malformed action blocks with no closing tag', () => {
+        const input = 'Done.\n<discord-action>{"type":"channelList"}';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'channelList' }]);
+        expect(cleanText).toBe('Done.');
+    });
+    it('strips malformed action blocks with complex JSON payloads', () => {
+        const json = '{"type":"channelCreate","name":"test","parent":"Dev","topic":"A topic"}';
+        const input = `Creating channel.\n<discord-action>${json}</parameter>\n</invoke>\nExtra text.`;
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'channelCreate', name: 'test', parent: 'Dev', topic: 'A topic' }]);
+        expect(cleanText).toBe('Creating channel.\n\nExtra text.');
+    });
+    it('handles nested braces in JSON string values', () => {
+        const json = '{"type":"channelCreate","name":"test","topic":"Fix {braces} in output"}';
+        const input = `Text.\n<discord-action>${json}</parameter>\n</invoke>`;
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'channelCreate', name: 'test', topic: 'Fix {braces} in output' }]);
+        expect(cleanText).toBe('Text.');
+    });
+    it('handles two malformed action blocks in one response', () => {
+        const input = 'First.\n<discord-action>{"type":"channelList"}</parameter>\n</invoke>\n' +
+            'Second.\n<discord-action>{"type":"channelCreate","name":"x"}</parameter>';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(2);
+        expect(actions[0]).toEqual({ type: 'channelList' });
+        expect(actions[1]).toEqual({ type: 'channelCreate', name: 'x' });
+        expect(cleanText).toBe('First.\n\nSecond.');
+    });
+    it('preserves text after an unterminated malformed action block', () => {
+        const input = 'Before\n<discord-action>{"type":"channelList","x":"oops\nAfter text';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+        expect(cleanText).toBe('Before\n\nAfter text');
+    });
+    it('strips trailing XML tags after an unterminated malformed action block', () => {
+        const input = 'Before\n<discord-action>{"type":"channelList","x":"oops\n</parameter>\n</invoke>\nAfter';
+        const { cleanText, actions } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+        expect(cleanText).toBe('Before\n\nAfter');
+    });
+    it('returns empty strippedUnrecognizedTypes when all action types are recognized', () => {
+        const input = '<discord-action>{"type":"channelList"}</discord-action>';
+        const { strippedUnrecognizedTypes } = parseDiscordActions(input, ALL_FLAGS);
+        expect(strippedUnrecognizedTypes).toEqual([]);
+    });
+    it('collects unrecognized type names in strippedUnrecognizedTypes (first pass)', () => {
+        const input = '<discord-action>{"type":"somethingWeird","id":"123"}</discord-action>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+        expect(strippedUnrecognizedTypes).toEqual(['somethingWeird']);
+    });
+    it('collects flag-disabled type names in strippedUnrecognizedTypes (first pass)', () => {
+        const input = '<discord-action>{"type":"channelCreate","name":"test"}</discord-action>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, { ...ALL_FLAGS, channels: false });
+        expect(actions).toHaveLength(0);
+        expect(strippedUnrecognizedTypes).toEqual(['channelCreate']);
+    });
+    it('collects unrecognized type names in strippedUnrecognizedTypes (second pass / malformed block)', () => {
+        const input = '<discord-action>{"type":"unknownType","foo":"bar"}</parameter>\n</invoke>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toHaveLength(0);
+        expect(strippedUnrecognizedTypes).toEqual(['unknownType']);
+    });
+    it('collects multiple unrecognized types across both passes', () => {
+        const input = '<discord-action>{"type":"typeA"}</discord-action>' +
+            '<discord-action>{"type":"channelList"}</discord-action>' +
+            '<discord-action>{"type":"typeB"}</parameter>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([{ type: 'channelList' }]);
+        expect(strippedUnrecognizedTypes).toEqual(['typeA', 'typeB']);
+    });
+    it('accepts task action types when tasks flag is enabled', () => {
+        const input = '<discord-action>{"type":"taskList"}</discord-action>';
+        const { actions } = parseDiscordActions(input, { ...ALL_FLAGS, tasks: true });
+        expect(actions).toEqual([{ type: 'taskList' }]);
+    });
+    it('rewrites planClose to taskClose when plan actions are disabled and tasks are enabled', () => {
+        const input = '<discord-action>{"type":"planClose","planId":"dev-uqy"}</discord-action>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, { ...ALL_FLAGS, tasks: true, plan: false });
+        expect(actions).toEqual([{ type: 'taskClose', taskId: 'dev-uqy' }]);
+        expect(strippedUnrecognizedTypes).toEqual([]);
+    });
+    it('does not rewrite planClose when planId looks like a plan identifier', () => {
+        const input = '<discord-action>{"type":"planClose","planId":"plan-042"}</discord-action>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, { ...ALL_FLAGS, tasks: true, plan: false });
+        expect(actions).toEqual([]);
+        expect(strippedUnrecognizedTypes).toEqual(['planClose']);
+    });
+    it('does not rewrite planClose when plan actions are enabled', () => {
+        const input = '<discord-action>{"type":"planClose","planId":"dev-uqy"}</discord-action>';
+        const { actions } = parseDiscordActions(input, { ...ALL_FLAGS, tasks: true, plan: true });
+        expect(actions).toEqual([{ type: 'planClose', planId: 'dev-uqy' }]);
+    });
+    it('ignores action tags inside fenced code blocks', () => {
+        const input = 'Example only:\n```json\n<discord-action>{"type":"channelDelete","channelId":"ch1"}</discord-action>\n```\nNo action.';
+        const { actions, cleanText } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([]);
+        expect(cleanText).toContain('<discord-action>');
+    });
+    it('ignores action tags inside inline code spans', () => {
+        const input = 'Do not run `<discord-action>{"type":"channelDelete","channelId":"ch1"}</discord-action>` please.';
+        const { actions, cleanText } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([]);
+        expect(cleanText).toContain('<discord-action>');
+    });
+    it('ignores action tags inside indented code blocks', () => {
+        const input = 'Example only:\n' +
+            '    <discord-action>{"type":"channelDelete","channelId":"ch1"}</discord-action>\n' +
+            'No action.';
+        const { actions, cleanText } = parseDiscordActions(input, ALL_FLAGS);
+        expect(actions).toEqual([]);
+        expect(cleanText).toContain('<discord-action>');
+    });
+    it('parses forgeStatus when forge flag is enabled', () => {
+        const input = '<discord-action>{"type":"forgeStatus","forgeId":"forge-abc"}</discord-action>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, { ...ALL_FLAGS, forge: true });
+        expect(actions).toEqual([{ type: 'forgeStatus', forgeId: 'forge-abc' }]);
+        expect(strippedUnrecognizedTypes).toEqual([]);
+    });
+    it('strips forgeStatus when forge flag is disabled', () => {
+        const input = '<discord-action>{"type":"forgeStatus","forgeId":"forge-abc"}</discord-action>';
+        const { actions, strippedUnrecognizedTypes } = parseDiscordActions(input, { ...ALL_FLAGS, forge: false });
+        expect(actions).toHaveLength(0);
+        expect(strippedUnrecognizedTypes).toEqual(['forgeStatus']);
+    });
+});
+// ---------------------------------------------------------------------------
+// executeDiscordActions — mocked guild
+// ---------------------------------------------------------------------------
+function makeMockGuild(channels) {
+    const cache = new Map();
+    for (const ch of channels) {
+        cache.set(ch.id, {
+            id: ch.id,
+            name: ch.name,
+            type: ch.type,
+            parent: ch.parentName ? { name: ch.parentName } : null,
+        });
+    }
+    return {
+        channels: {
+            cache: {
+                find: (fn) => {
+                    for (const ch of cache.values()) {
+                        if (fn(ch))
+                            return ch;
+                    }
+                    return undefined;
+                },
+                values: () => cache.values(),
+                get size() { return cache.size; },
+            },
+            create: vi.fn(async (opts) => ({
+                name: opts.name,
+                id: 'new-id',
+            })),
+        },
+    };
+}
+function makeCtx(guild) {
+    return {
+        guild,
+        client: {},
+        channelId: 'test-channel',
+        messageId: 'test-message',
+    };
+}
+describe('executeDiscordActions', () => {
+    beforeEach(() => {
+        _resetDestructiveConfirmationForTest();
+    });
+    it('channelCreate succeeds with parent category', async () => {
+        const guild = makeMockGuild([
+            { id: 'cat1', name: 'Dev', type: ChannelType.GuildCategory },
+        ]);
+        const results = await executeDiscordActions([{ type: 'channelCreate', name: 'status', parent: 'Dev', topic: 'Status updates' }], makeCtx(guild));
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ ok: true, summary: 'Created #status under Dev' });
+        expect(guild.channels.create).toHaveBeenCalledWith({
+            name: 'status',
+            type: ChannelType.GuildText,
+            parent: 'cat1',
+            topic: 'Status updates',
+        });
+    });
+    it('channelCreate fails when parent category not found', async () => {
+        const guild = makeMockGuild([]);
+        const results = await executeDiscordActions([{ type: 'channelCreate', name: 'status', parent: 'NonExistent' }], makeCtx(guild));
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ ok: false, error: 'Category "NonExistent" not found' });
+    });
+    it('channelCreate without parent', async () => {
+        const guild = makeMockGuild([]);
+        const results = await executeDiscordActions([{ type: 'channelCreate', name: 'general' }], makeCtx(guild));
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ ok: true, summary: 'Created #general' });
+        expect(guild.channels.create).toHaveBeenCalledWith({
+            name: 'general',
+            type: ChannelType.GuildText,
+            parent: undefined,
+            topic: undefined,
+        });
+    });
+    it('channelList groups by category', async () => {
+        const guild = makeMockGuild([
+            { id: 'cat1', name: 'Dev', type: ChannelType.GuildCategory },
+            { id: 'ch1', name: 'general', type: ChannelType.GuildText, parentName: 'Dev' },
+            { id: 'ch2', name: 'random', type: ChannelType.GuildText },
+        ]);
+        const results = await executeDiscordActions([{ type: 'channelList' }], makeCtx(guild));
+        expect(results).toHaveLength(1);
+        expect(results[0].ok).toBe(true);
+        const summary = results[0].summary;
+        expect(summary).toContain('#random (id:ch2)');
+        expect(summary).toContain('Dev: #general (id:ch1)');
+    });
+    it('handles API errors gracefully', async () => {
+        const guild = makeMockGuild([]);
+        guild.channels.create = vi.fn(async () => {
+            throw new Error('Missing Permissions');
+        });
+        const results = await executeDiscordActions([{ type: 'channelCreate', name: 'test' }], makeCtx(guild));
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ ok: false, error: 'Missing Permissions' });
+    });
+    it('one failure does not block subsequent actions', async () => {
+        const guild = makeMockGuild([
+            { id: 'ch1', name: 'general', type: ChannelType.GuildText },
+        ]);
+        guild.channels.create = vi.fn(async () => {
+            throw new Error('Missing Permissions');
+        });
+        const results = await executeDiscordActions([
+            { type: 'channelCreate', name: 'test' },
+            { type: 'channelList' },
+        ], makeCtx(guild));
+        expect(results).toHaveLength(2);
+        expect(results[0].ok).toBe(false);
+        expect(results[1].ok).toBe(true);
+    });
+    it('executes task actions when taskCtx is provided', async () => {
+        const store = new TaskStore({ prefix: 'ws' });
+        store.create({ title: 'test task', priority: 2 });
+        const results = await executeDiscordActions([{ type: 'taskList', limit: 10 }], makeCtx(makeMockGuild([])), undefined, {
+            taskCtx: {
+                tasksCwd: '/tmp',
+                forumId: 'forum-1',
+                tagMap: {},
+                store,
+                runtime: {},
+                autoTag: false,
+                autoTagModel: 'fast',
+            },
+        });
+        expect(results).toHaveLength(1);
+        expect(results[0].ok).toBe(true);
+    });
+    it('blocks destructive actions without explicit confirmation bypass', async () => {
+        const guild = makeMockGuild([]);
+        const results = await executeDiscordActions([{ type: 'channelDelete', channelId: 'ch1' }], {
+            ...makeCtx(guild),
+            confirmation: {
+                mode: 'interactive',
+                sessionKey: 'discord:channel:chan',
+                userId: '123',
+            },
+        });
+        expect(results).toHaveLength(1);
+        expect(results[0].ok).toBe(false);
+        if (results[0].ok)
+            throw new Error('unexpected ok result');
+        expect(results[0].error).toContain('requires confirmation');
+        expect(results[0].error).toContain('!confirm');
+    });
+    it('allows destructive actions with bypassDestructive confirmation context', async () => {
+        const ban = vi.fn(async () => { });
+        const guild = {
+            members: {
+                fetch: vi.fn(async () => ({ displayName: 'User42', ban })),
+            },
+        };
+        const results = await executeDiscordActions([{ type: 'ban', userId: '42' }], {
+            guild,
+            client: {},
+            channelId: 'chan',
+            messageId: 'msg',
+            confirmation: {
+                mode: 'interactive',
+                sessionKey: 'discord:channel:chan',
+                userId: '123',
+                bypassDestructive: true,
+            },
+        });
+        expect(results).toEqual([{ ok: true, summary: 'Banned User42' }]);
+        expect(guild.members.fetch).toHaveBeenCalledWith('42');
+        expect(ban).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// buildDisplayResultLines / buildAllResultLines
+// ---------------------------------------------------------------------------
+describe('buildDisplayResultLines', () => {
+    it('filters successful sendMessage results', () => {
+        const actions = [{ type: 'sendMessage' }, { type: 'channelCreate' }];
+        const results = [
+            { ok: true, summary: 'Sent message to #general' },
+            { ok: true, summary: 'Created #status' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual(['Done: Created #status']);
+    });
+    it('keeps failed sendMessage results', () => {
+        const actions = [{ type: 'sendMessage' }];
+        const results = [
+            { ok: false, error: 'Missing Permissions' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual(['Failed: Missing Permissions']);
+    });
+    it('keeps non-sendMessage successes', () => {
+        const actions = [{ type: 'channelCreate' }, { type: 'react' }, { type: 'channelList' }];
+        const results = [
+            { ok: true, summary: 'Created #foo' },
+            { ok: true, summary: 'Reacted with ✅' },
+            { ok: true, summary: 'Listed 3 channels' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual([
+            'Done: Created #foo',
+            'Done: Reacted with ✅',
+            'Done: Listed 3 channels',
+        ]);
+    });
+    it('returns empty array when all actions are successful sendMessage', () => {
+        const actions = [{ type: 'sendMessage' }, { type: 'sendMessage' }];
+        const results = [
+            { ok: true, summary: 'Sent message to #general' },
+            { ok: true, summary: 'Sent message to #random' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual([]);
+    });
+    it('handles mixed actions correctly', () => {
+        const actions = [{ type: 'sendMessage' }, { type: 'channelCreate' }, { type: 'sendMessage' }];
+        const results = [
+            { ok: true, summary: 'Sent message to #general' },
+            { ok: true, summary: 'Created #status' },
+            { ok: false, error: 'Channel not found' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual([
+            'Done: Created #status',
+            'Failed: Channel not found',
+        ]);
+    });
+    it('filters successful sendFile results', () => {
+        const actions = [{ type: 'sendFile' }, { type: 'react' }];
+        const results = [
+            { ok: true, summary: 'Sent file "screenshot.png" to #general' },
+            { ok: true, summary: 'Reacted with 👍' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual(['Done: Reacted with 👍']);
+    });
+    it('keeps failed sendFile results', () => {
+        const actions = [{ type: 'sendFile' }];
+        const results = [
+            { ok: false, error: 'File not found: /tmp/missing.png' },
+        ];
+        const lines = buildDisplayResultLines(actions, results);
+        expect(lines).toEqual(['Failed: File not found: /tmp/missing.png']);
+    });
+});
+describe('buildAllResultLines', () => {
+    it('returns all result lines without filtering', () => {
+        const results = [
+            { ok: true, summary: 'Sent message to #general' },
+            { ok: true, summary: 'Created #status' },
+            { ok: false, error: 'Missing Permissions' },
+        ];
+        const lines = buildAllResultLines(results);
+        expect(lines).toEqual([
+            'Done: Sent message to #general',
+            'Done: Created #status',
+            'Failed: Missing Permissions',
+        ]);
+    });
+});
+describe('discordActionsPromptSection', () => {
+    it('always includes the standard guidance when actions are enabled', () => {
+        const flags = {
+            channels: false,
+            messaging: false,
+            guild: false,
+            moderation: false,
+            polls: false,
+            tasks: false,
+            crons: false,
+            botProfile: false,
+            forge: false,
+            plan: false,
+            memory: false,
+            config: false,
+            defer: false,
+        };
+        const prompt = discordActionsPromptSection(flags, 'ClawBot');
+        expect(prompt).toContain('Setting DISCOCLAW_DISCORD_ACTIONS=1 publishes this standard guidance');
+        expect(prompt).toContain('### Rules');
+    });
+    it('documents deferred self-invocation when defer actions are enabled', () => {
+        const flags = {
+            channels: false,
+            messaging: false,
+            guild: false,
+            moderation: false,
+            polls: false,
+            tasks: false,
+            crons: false,
+            botProfile: false,
+            forge: false,
+            plan: false,
+            memory: false,
+            config: false,
+            defer: true,
+        };
+        const prompt = discordActionsPromptSection(flags);
+        expect(prompt).toContain('### Deferred self-invocation');
+        expect(prompt).toContain('{"type":"defer","channel":"general","delaySeconds":600,"prompt":"Check on the forge run"}');
+        expect(prompt).toContain('without another user prompt');
+        expect(prompt).toContain('DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS');
+        expect(prompt).toContain('DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT');
+        expect(prompt).toContain('forces `defer` off');
+    });
+});

package/dist/discord/allowed-mentions.js

@@ -0,0 +1,3 @@
+// Centralize mention policy: Discoclaw should not ping users/roles/@everyone from model output.
+// If you need targeted mentions later, plumb an explicit allowlist into the send call.
+export const NO_MENTIONS = { parse: [] };

package/dist/discord/allowed-mentions.test.js

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { NO_MENTIONS } from './allowed-mentions.js';
+describe('NO_MENTIONS', () => {
+    it('has an empty parse array', () => {
+        expect(NO_MENTIONS.parse).toEqual([]);
+    });
+    it('is assignable to Discord.js MessageMentionOptions', () => {
+        // Compile-time check: if NO_MENTIONS breaks compat with discord.js, this fails to build.
+        const opts = NO_MENTIONS;
+        expect(opts.parse).toEqual([]);
+    });
+    it('is assignable to SendTarget allowedMentions', () => {
+        // Compile-time check: if NO_MENTIONS breaks compat with SendTarget, this fails to build.
+        const opts = NO_MENTIONS;
+        expect(opts.parse).toEqual([]);
+    });
+});

package/dist/discord/allowlist.js

@@ -0,0 +1,29 @@
+export function parseAllowUserIds(raw) {
+    const out = new Set();
+    for (const part of String(raw ?? '').split(/[,\s]+/g)) {
+        const v = part.trim();
+        if (!v)
+            continue;
+        if (/^\d+$/.test(v))
+            out.add(v);
+    }
+    return out;
+}
+export function parseAllowChannelIds(raw) {
+    // Same format as user IDs: comma/space-separated Discord snowflakes.
+    const out = new Set();
+    for (const part of String(raw ?? '').split(/[,\s]+/g)) {
+        const v = part.trim();
+        if (!v)
+            continue;
+        if (/^\d+$/.test(v))
+            out.add(v);
+    }
+    return out;
+}
+export function isAllowlisted(allow, userId) {
+    // Fail closed: if allowlist is empty, respond to nobody.
+    if (allow.size === 0)
+        return false;
+    return allow.has(userId);
+}

package/dist/discord/allowlist.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { isAllowlisted, parseAllowChannelIds, parseAllowUserIds } from './allowlist.js';
+describe('parseAllowUserIds', () => {
+    it('parses comma/space separated IDs', () => {
+        expect(parseAllowUserIds(' 123, 456 789 ')).toEqual(new Set(['123', '456', '789']));
+    });
+    it('drops non-numeric tokens', () => {
+        expect(parseAllowUserIds('abc 123 def')).toEqual(new Set(['123']));
+    });
+});
+describe('parseAllowChannelIds', () => {
+    it('parses comma/space separated IDs', () => {
+        expect(parseAllowChannelIds(' 1,2  3 ')).toEqual(new Set(['1', '2', '3']));
+    });
+});
+describe('isAllowlisted', () => {
+    it('fails closed when the allowlist is empty', () => {
+        expect(isAllowlisted(new Set(), '123')).toBe(false);
+    });
+    it('allows when userId is present', () => {
+        expect(isAllowlisted(new Set(['123']), '123')).toBe(true);
+        expect(isAllowlisted(new Set(['123']), '456')).toBe(false);
+    });
+});