@meetquinn/animactl 0.1.2 → 0.1.3

package/dist/server/tests/slack-files.test.js

@@ -0,0 +1,118 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { slackFileFromRaw } from '../slack/slack.helper.js';
+import { safeFilename } from '../storage/safe-filename.js';
+import { MANUAL_FETCH_BYTES, downloadSlackFile } from '../slack/slack-file.service.js';
+test('manual Slack file fetch allows large user-requested downloads', () => {
+    assert.ok(MANUAL_FETCH_BYTES >= 500 * 1024 * 1024);
+});
+test('slackFileFromRaw extracts known fields and prefers download URL', () => {
+    const file = slackFileFromRaw({
+        id: 'F1',
+        name: 'screenshot.png',
+        mimetype: 'image/png',
+        size: 1024,
+        url_private: 'https://files.slack.com/private',
+        url_private_download: 'https://files.slack.com/download',
+    });
+    assert.equal(file?.id, 'F1');
+    assert.equal(file?.name, 'screenshot.png');
+    assert.equal(file?.mimetype, 'image/png');
+    assert.equal(file?.sizeBytes, 1024);
+    assert.equal(file?.urlPrivate, 'https://files.slack.com/download');
+});
+test('safeFilename strips path separators and falls back to "file"', () => {
+    assert.equal(safeFilename('foo/bar.txt'), 'foo_bar.txt');
+    assert.equal(safeFilename(''), 'file');
+    assert.equal(safeFilename('   '), 'file');
+});
+test('downloadSlackFile writes the response body and honors Bearer auth + size cap', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-files-'));
+    try {
+        const destPath = join(dir, 'cache/F1/data.txt');
+        const seen = {};
+        const fetchImpl = (async (url, init) => {
+            seen.url = url;
+            seen.auth = init?.headers?.['Authorization'];
+            const body = Buffer.from('hello');
+            return new Response(body, { status: 200, headers: { 'content-length': String(body.length) } });
+        });
+        const result = await downloadSlackFile({
+            destPath,
+            fetchImpl,
+            maxBytes: 1024,
+            token: 'xoxb-token',
+            urlPrivate: 'https://files.slack.com/example',
+        });
+        assert.equal(result.sizeBytes, 5);
+        assert.equal(seen.url, 'https://files.slack.com/example');
+        assert.equal(seen.auth, 'Bearer xoxb-token');
+        assert.equal(await readFile(destPath, 'utf8'), 'hello');
+        const oversized = (async () => new Response(Buffer.from('xxxxxxxxxxxxx'), {
+            status: 200,
+            headers: { 'content-length': '13' },
+        }));
+        await assert.rejects(downloadSlackFile({
+            destPath: join(dir, 'cache/F2/data.txt'),
+            fetchImpl: oversized,
+            maxBytes: 4,
+            token: 't',
+            urlPrivate: 'https://x',
+        }), /too large/);
+        const failing = (async () => new Response('nope', {
+            status: 403,
+            statusText: 'Forbidden',
+        }));
+        await assert.rejects(downloadSlackFile({
+            destPath: join(dir, 'cache/F3/data.txt'),
+            fetchImpl: failing,
+            maxBytes: 1024,
+            token: 't',
+            urlPrivate: 'https://x',
+        }), /HTTP 403/);
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('downloadSlackFile rejects when streamed body exceeds maxBytes despite missing content-length', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-files-'));
+    try {
+        const fetchImpl = (async () => new Response(Buffer.from('x'.repeat(100)), { status: 200, headers: {} }));
+        await assert.rejects(downloadSlackFile({
+            destPath: join(dir, 'F1/data.bin'),
+            fetchImpl,
+            maxBytes: 10,
+            token: 't',
+            urlPrivate: 'https://x',
+        }), /too large/);
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+// Sanity-check that fixtures generated by Slack don't disappear when we round-trip them
+test('writeFile + downloadSlackFile roundtrip with a temp source url is consistent', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-files-'));
+    try {
+        const source = join(dir, 'source.txt');
+        await writeFile(source, 'roundtrip\n');
+        const fetchImpl = (async () => new Response(await readFile(source), { status: 200, headers: { 'content-length': '10' } }));
+        const destPath = join(dir, 'cache/F9/data.txt');
+        const result = await downloadSlackFile({
+            destPath,
+            fetchImpl,
+            maxBytes: 1024,
+            token: 't',
+            urlPrivate: 'https://x',
+        });
+        assert.equal(result.sizeBytes, 10);
+        assert.equal(await readFile(destPath, 'utf8'), 'roundtrip\n');
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});

package/dist/server/tests/slack-shortcuts.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=slack-shortcuts.test.d.ts.map

package/dist/server/tests/slack-shortcuts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-shortcuts.test.d.ts","sourceRoot":"","sources":["../../../server/tests/slack-shortcuts.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/slack-shortcuts.test.js

@@ -0,0 +1,310 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { WakeQueueService } from '../inbox/wake-queue.service.js';
+import { SlackShortcutService } from '../slack-interactions/shortcut.service.js';
+import { SLACK_STOP_CONFIRM_VIEW_CALLBACK_ID } from '../slack-interactions/shortcut-ids.js';
+import { SLACK_SHORTCUTS, ensureSlackShortcutManifest, hasCommandsScope, inspectSlackShortcutManifest, parseOauthScopesHeader, slackShortcutManifestUpdateYaml, } from '../slack/shortcuts.js';
+import { withAnimaHome } from './anima-home.js';
+test('shortcut manifest helper adds commands scope and required shortcuts idempotently', () => {
+    const manifest = {
+        display_information: { name: 'Iris' },
+        features: {
+            app_home: {
+                home_tab_enabled: false,
+                messages_tab_enabled: true,
+            },
+            shortcuts: [
+                {
+                    callback_id: 'existing.action',
+                    description: 'Keep me',
+                    name: 'Existing',
+                    type: 'message',
+                },
+                {
+                    callback_id: 'anima.stop',
+                    description: 'Old stop shortcut',
+                    name: 'Stop current turn',
+                    type: 'global',
+                },
+                {
+                    callback_id: 'anima.status',
+                    description: 'Old status shortcut',
+                    name: 'Show status',
+                    type: 'global',
+                },
+                {
+                    callback_id: 'anima.toggle_enabled',
+                    description: 'Old enable shortcut',
+                    name: 'Disable or enable',
+                    type: 'global',
+                },
+                {
+                    callback_id: 'anima.reminders',
+                    description: 'Old reminders shortcut',
+                    name: 'Show reminders',
+                    type: 'global',
+                },
+            ],
+        },
+        oauth_config: {
+            scopes: {
+                bot: ['chat:write', 'users:read'],
+            },
+        },
+    };
+    assert.deepEqual(inspectSlackShortcutManifest(manifest), {
+        commandsScope: false,
+        missingShortcutCallbackIds: SLACK_SHORTCUTS.map((shortcut) => shortcut.callback_id),
+        ready: false,
+    });
+    const first = ensureSlackShortcutManifest(manifest);
+    assert.equal(first.updated, true);
+    assert.deepEqual(first.status, {
+        commandsScope: true,
+        missingShortcutCallbackIds: [],
+        ready: true,
+    });
+    const features = first.manifest.features;
+    const shortcuts = features.shortcuts;
+    assert.equal(shortcuts.length, 1 + SLACK_SHORTCUTS.length);
+    assert.ok(shortcuts.some((shortcut) => shortcut.callback_id === 'existing.action'));
+    assert.ok(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.home' && shortcut.name === 'Home'));
+    assert.ok(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.hand_to_agent' && shortcut.type === 'message'));
+    assert.equal(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.reminders'), false);
+    assert.equal(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.status'), false);
+    assert.equal(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.stop'), false);
+    assert.equal(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.toggle_enabled'), false);
+    const scopes = first.manifest.oauth_config.scopes.bot;
+    assert.deepEqual(scopes, ['chat:write', 'commands', 'users:read']);
+    const second = ensureSlackShortcutManifest(first.manifest);
+    assert.equal(second.updated, false);
+    assert.deepEqual(second.manifest, first.manifest);
+});
+test('shortcut manifest helper corrects wrong shortcut type without byte-equality matching', () => {
+    const manifest = {
+        features: {
+            shortcuts: [
+                {
+                    callback_id: 'anima.hand_to_agent',
+                    description: 'Wrong type',
+                    name: 'Hand to agent',
+                    type: 'global',
+                },
+            ],
+        },
+        oauth_config: { scopes: { bot: ['commands'] } },
+    };
+    const before = inspectSlackShortcutManifest(manifest);
+    assert.equal(before.commandsScope, true);
+    assert.ok(before.missingShortcutCallbackIds.includes('anima.hand_to_agent'));
+    const updated = ensureSlackShortcutManifest(manifest);
+    const shortcuts = updated.manifest.features.shortcuts;
+    assert.ok(shortcuts.some((shortcut) => shortcut.callback_id === 'anima.hand_to_agent' && shortcut.type === 'message'));
+    assert.equal(updated.status.ready, true);
+});
+test('oauth scope header parser detects commands scope', () => {
+    assert.deepEqual(parseOauthScopesHeader('chat:write, commands,users:read'), ['chat:write', 'commands', 'users:read']);
+    assert.equal(hasCommandsScope(parseOauthScopesHeader('chat:write,users:read')), false);
+    assert.equal(hasCommandsScope(parseOauthScopesHeader('chat:write,commands')), true);
+});
+test('shortcut manifest update YAML describes the manual migration block', () => {
+    const yaml = slackShortcutManifestUpdateYaml();
+    assert.match(yaml, /oauth_config:\n  scopes:\n    bot:\n      - commands/);
+    assert.match(yaml, /callback_id: anima.home/);
+    assert.match(yaml, /callback_id: anima.hand_to_agent/);
+    assert.doesNotMatch(yaml, /callback_id: anima.reminders/);
+    assert.doesNotMatch(yaml, /callback_id: anima.status/);
+    assert.doesNotMatch(yaml, /callback_id: anima.stop/);
+    assert.doesNotMatch(yaml, /callback_id: anima.toggle_enabled/);
+});
+test('home shortcut opens the agent home modal without queueing agent work', async () => {
+    const client = fakeWebClient();
+    const activities = [];
+    const stopped = [];
+    const service = new SlackShortcutService({
+        activityRecorder: {
+            record: async (agentId, input) => {
+                activities.push({ agentId, input });
+                return { activityId: 'actv_test', createdAt: '2026-05-26T12:00:00.000Z', ...input };
+            },
+        },
+        agentService: fakeAgentService({ id: 'scout', displayName: 'Scout' }),
+        now: () => new Date('2026-05-26T12:10:00.000Z'),
+        reminderServiceForAgent: fakeReminderService([
+            {
+                nextDueAt: '2026-05-26T13:00:00.000Z',
+                reminderId: 'reminder-1',
+                title: 'Check build',
+            },
+        ]),
+        runtimeService: {
+            getStatus: async () => ({
+                agentId: 'scout',
+                currentItemId: 'item-123',
+                currentItemStartedAt: '2026-05-26T12:00:00.000Z',
+                itemCount: 3,
+                queueDepth: 2,
+            }),
+            stopCurrentItem: async (agentId) => {
+                stopped.push(agentId);
+            },
+        },
+    });
+    await service.handleShortcut({
+        agentId: 'scout',
+        body: { callback_id: 'anima.home', trigger_id: 'trigger-1', user: { id: 'U1' } },
+        client: client.client,
+    });
+    assert.equal(client.opened.length, 1);
+    const modal = client.opened[0]?.view;
+    assert.ok(modal);
+    assert.equal(modal.title.text, 'Home');
+    assert.equal(modal.callback_id, SLACK_STOP_CONFIRM_VIEW_CALLBACK_ID);
+    assert.equal(modal.submit?.text, 'Stop');
+    const modalText = modal.blocks.map((block) => 'text' in block ? block.text.text : '').join('\n');
+    assert.match(modalText, /\*Scout\*/);
+    assert.match(modalText, /\*Working\*/);
+    assert.match(modalText, /10m/);
+    assert.match(modalText, /Reminders/);
+    assert.match(modalText, /Check build/);
+    const resultView = await service.confirmStop({
+        agentId: 'scout',
+        userId: 'U1',
+        view: { private_metadata: modal.private_metadata },
+    });
+    assert.deepEqual(stopped, ['scout']);
+    assert.equal(resultView.title.text, 'Stop requested');
+    assert.deepEqual(activities.map((activity) => activity.input), [
+        {
+            payload: { itemId: 'item-123', outcome: 'stop_requested', userId: 'U1' },
+            type: 'anima.shortcut.stop',
+        },
+    ]);
+});
+test('home shortcut omits Stop when the agent is idle', async () => {
+    const client = fakeWebClient();
+    const service = new SlackShortcutService({
+        agentService: fakeAgentService({ id: 'scout', displayName: 'Scout' }),
+        reminderServiceForAgent: fakeReminderService([]),
+        runtimeService: {
+            getStatus: async () => ({
+                agentId: 'scout',
+                itemCount: 3,
+                queueDepth: 0,
+            }),
+            stopCurrentItem: async () => undefined,
+        },
+    });
+    await service.handleShortcut({
+        agentId: 'scout',
+        body: { callback_id: 'anima.home', trigger_id: 'trigger-1', user: { id: 'U1' } },
+        client: client.client,
+    });
+    const modal = client.opened[0]?.view;
+    assert.ok(modal);
+    assert.equal(modal.title.text, 'Home');
+    assert.equal(modal.callback_id, undefined);
+    assert.equal(modal.submit, undefined);
+    const modalText = modal.blocks.map((block) => 'text' in block ? block.text.text : '').join('\n');
+    assert.match(modalText, /\*Scout\*/);
+    assert.match(modalText, /\*Idle\*/);
+    assert.match(modalText, /None scheduled/);
+});
+test('message shortcut hands the source message to the agent thread and responds ephemerally', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-shortcuts-'));
+    await writeMinimalAgentConfig(stateDir, 'scout');
+    const fetchCalls = [];
+    const previousFetch = globalThis.fetch;
+    globalThis.fetch = (async (url, init) => {
+        fetchCalls.push({ body: init?.body, url: String(url) });
+        return new Response('{}', { status: 200 });
+    });
+    try {
+        await withAnimaHome(stateDir, async () => {
+            const service = new SlackShortcutService({
+                activityRecorder: {
+                    record: async (_agentId, input) => ({ activityId: 'actv_test', createdAt: '2026-05-26T12:00:00.000Z', ...input }),
+                },
+            });
+            await service.handMessageToAgent({
+                agentId: 'scout',
+                body: {
+                    callback_id: 'anima.hand_to_agent',
+                    channel: { id: 'C1', name: 'course-team' },
+                    message: { text: 'Please turn this into a task.', ts: '1779790000.123456', user: 'U_SOURCE' },
+                    response_url: 'https://hooks.slack.test/shortcut-response',
+                    team: { id: 'T1' },
+                    user: { id: 'U_HANDOFF' },
+                },
+            });
+            const item = await new WakeQueueService('scout').find('slack-shortcut-handoff:T1:C1:1779790000.123456');
+            assert.ok(item);
+            assert.equal(item.kind, 'slack');
+            assert.equal(item.channelId, 'C1');
+            assert.equal(item.threadTs, '1779790000.123456');
+            assert.equal(item.messageTs, '1779790000.123456');
+            assert.match(item.text, /<@U_HANDOFF> used the Slack message shortcut/);
+            assert.match(item.text, /Please turn this into a task\./);
+        });
+    }
+    finally {
+        globalThis.fetch = previousFetch;
+    }
+    assert.equal(fetchCalls.length, 1);
+    assert.equal(fetchCalls[0]?.url, 'https://hooks.slack.test/shortcut-response');
+    assert.match(String(fetchCalls[0]?.body), /Handed to the agent/);
+});
+function fakeWebClient() {
+    const opened = [];
+    return {
+        client: {
+            views: {
+                open: async (input) => {
+                    opened.push(input);
+                    return { ok: true };
+                },
+            },
+        },
+        opened,
+    };
+}
+function fakeAgentService(input) {
+    return {
+        serviceFor: () => ({
+            getConfig: async () => ({
+                enabled: true,
+                id: input.id,
+                profile: { displayName: input.displayName, role: '' },
+                provider: { kind: 'claude-code', model: 'sonnet' },
+                slack: { appToken: 'xapp-test', botToken: 'xoxb-test', connected: true, teamId: 'T1' },
+                homePath: `/tmp/${input.id}`,
+            }),
+        }),
+    };
+}
+function fakeReminderService(reminders) {
+    return () => ({
+        listReminders: async () => reminders.map((reminder) => ({
+            createdAt: '2026-05-26T12:00:00.000Z',
+            firedCount: 0,
+            instructions: '',
+            schedule: { kind: 'once' },
+            status: 'scheduled',
+            updatedAt: '2026-05-26T12:00:00.000Z',
+            ...reminder,
+        })),
+    });
+}
+async function writeMinimalAgentConfig(stateDir, agentId) {
+    await mkdir(join(stateDir, 'agents', agentId), { recursive: true });
+    await writeFile(join(stateDir, 'config.json'), '{}\n', 'utf8');
+    await writeFile(join(stateDir, 'agents', agentId, 'config.json'), JSON.stringify({
+        id: agentId,
+        profile: { displayName: 'Scout', role: '' },
+        provider: { kind: 'claude-code', model: 'sonnet' },
+        slack: { appToken: 'xapp-test', botToken: 'xoxb-test', teamId: 'T1' },
+    }, null, 2), 'utf8');
+}

package/dist/server/tests/slack.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=slack.test.d.ts.map

package/dist/server/tests/slack.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.test.d.ts","sourceRoot":"","sources":["../../../server/tests/slack.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/slack.test.js

@@ -0,0 +1,213 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { SlackProfileResolver } from '../inbox/slack-profiles.js';
+import { SlackWorkspaceDirectoryService } from '../slack/workspace-directory.service.js';
+import { resolveSlackChannelArgument } from '../tools/slack-channel-resolver.js';
+import { extractReadableSlackChannelMentions, extractReadableSlackUserMentions, extractReadableSlackUserIdMentions, extractSlackChannelMentionIds, extractSlackUserMentionIds, replaceReadableSlackChannelMentions, replaceReadableSlackUserIdMentions, replaceReadableSlackUserMentions, replaceSlackChannelMentions, replaceSlackUserMentions, } from '../slack/slack.helper.js';
+test('Slack text helpers extract and replace mentions', () => {
+    assert.deepEqual(extractSlackUserMentionIds('hi <@U123> and <@U456|legacy> and <@U123>'), ['U123', 'U456']);
+    assert.equal(replaceSlackUserMentions('hi <@U123> and <@U456|legacy> and <@U789>', new Map([['U123', '@alice'], ['U456', '@bob']])), 'hi @alice and @bob and @U789');
+    assert.deepEqual(extractSlackChannelMentionIds('see <#C123|product> and <#G456> and <#C123|product>'), ['C123', 'G456']);
+    assert.equal(replaceSlackChannelMentions('see <#C123|product> and <#G456>', new Map([['C123', '#support']])), 'see #support and #G456');
+});
+test('Slack text helpers convert readable mentions to Slack markup', () => {
+    assert.deepEqual(extractReadableSlackUserMentions('cc @alice, @bob.smith and <@U123>'), ['alice', 'bob.smith']);
+    assert.equal(replaceReadableSlackUserMentions('cc @alice, @unknown and <@U123>', new Map([['alice', 'U123']])), 'cc <@U123>, @unknown and <@U123>');
+    assert.deepEqual(extractReadableSlackUserMentions('试一下：@nora，中文里也能@alice'), ['nora', 'alice']);
+    assert.deepEqual(extractReadableSlackUserMentions('literal `@nora` stays plain'), []);
+    assert.equal(replaceReadableSlackUserMentions('试一下：@nora，中文里也能@alice；email a@b.com and <@U123>', new Map([['alice', 'U123'], ['nora', 'U456']])), '试一下：<@U456>，中文里也能<@U123>；email a@b.com and <@U123>');
+    assert.deepEqual(extractReadableSlackChannelMentions('see #product, #team-updates and <#C123>'), ['product', 'team-updates']);
+    assert.deepEqual(extractReadableSlackChannelMentions('options: #1 then #2, but #course-reports is a channel'), ['course-reports']);
+    assert.deepEqual(extractReadableSlackChannelMentions('看：#dev，中文里也能#product'), ['dev', 'product']);
+    assert.deepEqual(extractReadableSlackChannelMentions('literal `#dev` stays plain'), []);
+    assert.equal(replaceReadableSlackChannelMentions('see #product, #unknown and <#C123>', new Map([['product', 'C123']])), 'see <#C123>, #unknown and <#C123>');
+    assert.equal(replaceReadableSlackChannelMentions('看：#dev，中文里也能#product；url https://example.com/#section', new Map([['dev', 'C-dev'], ['product', 'C-product']])), '看：<#C-dev>，中文里也能<#C-product>；url https://example.com/#section');
+});
+test('Slack text helpers convert raw user ids outside code spans', () => {
+    assert.deepEqual(extractReadableSlackUserIdMentions('cc @U123 and `@U456` then ```\n@U789\n```'), ['U123']);
+    assert.equal(replaceReadableSlackUserIdMentions('cc @U123 and <@U456> but `@U789` and ```\n@U999\n```'), 'cc <@U123> and <@U456> but `@U789` and ```\n@U999\n```');
+    assert.equal(replaceReadableSlackUserMentions('cc `please @alice` and @alice', new Map([['alice', 'U123']])), 'cc `please @alice` and <@U123>');
+});
+test('Slack workspace directory resolves username and display name handles', async () => {
+    const client = fakeSlackApi({
+        users: {
+            list: async () => ({
+                members: [
+                    {
+                        id: 'U123',
+                        name: 'alice',
+                        profile: { display_name: 'alice', real_name: 'Alice Example' },
+                    },
+                ],
+                ok: true,
+            }),
+        },
+    });
+    const directory = new SlackWorkspaceDirectoryService({ client });
+    assert.equal((await directory.getUserByHandle('alice')).id, 'U123');
+    assert.equal((await directory.getUserByHandle('Alice Example')).id, 'U123');
+});
+test('Slack workspace directory caches user lists by team', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-directory-cache-'));
+    const previousHome = process.env.ANIMA_HOME;
+    process.env.ANIMA_HOME = stateDir;
+    try {
+        let calls = 0;
+        const client = fakeSlackApi({
+            users: {
+                list: async () => {
+                    calls += 1;
+                    return {
+                        members: [{ id: 'U123', name: 'alice', profile: { display_name: 'Alice' } }],
+                        ok: true,
+                    };
+                },
+            },
+        });
+        const directory = new SlackWorkspaceDirectoryService({ client, teamId: 'T123' });
+        assert.equal((await directory.getUserByHandle('alice')).id, 'U123');
+        assert.equal((await directory.getUserByHandle('alice')).id, 'U123');
+        assert.equal(calls, 1);
+    }
+    finally {
+        if (previousHome === undefined)
+            delete process.env.ANIMA_HOME;
+        else
+            process.env.ANIMA_HOME = previousHome;
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('Slack directory cache accepts user change events', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-directory-event-'));
+    const previousHome = process.env.ANIMA_HOME;
+    process.env.ANIMA_HOME = stateDir;
+    try {
+        const client = fakeSlackApi({
+            users: {
+                list: async () => {
+                    throw new Error('users.list should not be called for a fresh event cache hit');
+                },
+            },
+        });
+        const directory = new SlackWorkspaceDirectoryService({ client, teamId: 'T123' });
+        await directory.applyEvent({
+            team: 'T123',
+            type: 'user_change',
+            user: { id: 'U123', name: 'alice', profile: { display_name: 'Alice' } },
+        });
+        assert.equal((await directory.getUserByHandle('alice')).id, 'U123');
+    }
+    finally {
+        if (previousHome === undefined)
+            delete process.env.ANIMA_HOME;
+        else
+            process.env.ANIMA_HOME = previousHome;
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('Slack channel resolver treats raw channel ids as already resolved', async () => {
+    assert.deepEqual(await resolveSlackChannelArgument({ channel: 'C123ABC' }), { id: 'C123ABC' });
+});
+test('Slack channel resolver requires a WebClient for readable names', async () => {
+    await assert.rejects(() => resolveSlackChannelArgument({ channel: '#team' }), /Slack WebClient is required to resolve Slack channel name: #team\. Pass a channel ID or configure slack\.botToken\./);
+});
+test('Slack channel resolver resolves readable names through the workspace directory', async () => {
+    const client = fakeSlackApi({
+        conversations: {
+            list: async () => ({
+                channels: [{ id: 'C123', name: 'team', name_normalized: 'team' }],
+                ok: true,
+            }),
+        },
+    });
+    assert.deepEqual(await resolveSlackChannelArgument({ channel: '#team', client }), { id: 'C123', name: 'team' });
+});
+test('Slack channel resolver resolves DM handles through the workspace directory', async () => {
+    const client = fakeSlackApi({
+        users: {
+            list: async () => ({
+                members: [{ id: 'U123', name: 'alice', profile: { display_name: 'Alice' } }],
+                ok: true,
+            }),
+        },
+    });
+    assert.deepEqual(await resolveSlackChannelArgument({ channel: '@alice', client }), {
+        dmHandle: 'alice',
+        dmUserId: 'U123',
+        id: 'D123',
+    });
+});
+test('SlackProfileResolver caches Slack timezone metadata with the handle profile', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-profile-cache-'));
+    const previousHome = process.env.ANIMA_HOME;
+    process.env.ANIMA_HOME = stateDir;
+    let calls = 0;
+    try {
+        const client = fakeSlackApi({
+            users: {
+                info: async () => {
+                    calls += 1;
+                    return {
+                        ok: true,
+                        user: {
+                            id: 'U123',
+                            name: 'alice',
+                            profile: { display_name: 'Alice', real_name: 'Alice Lee' },
+                            tz: 'Asia/Shanghai',
+                            tz_label: 'China Standard Time',
+                            tz_offset: 28800,
+                        },
+                    };
+                },
+            },
+        });
+        const profiles = new SlackProfileResolver();
+        const profile = await profiles.user({ client, teamId: 'T123', userId: 'U123' });
+        const cached = await profiles.user({ client, teamId: 'T123', userId: 'U123' });
+        assert.equal(calls, 1);
+        assert.equal(cached, profile);
+        assert.deepEqual(profile?.timezone, {
+            label: 'China Standard Time',
+            name: 'Asia/Shanghai',
+            offsetSeconds: 28800,
+        });
+    }
+    finally {
+        if (previousHome === undefined)
+            delete process.env.ANIMA_HOME;
+        else
+            process.env.ANIMA_HOME = previousHome;
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('Slack workspace directory errors surface to callers', async () => {
+    const client = fakeSlackApi({
+        users: {
+            list: async () => {
+                throw new Error('not_in_channel');
+            },
+        },
+    });
+    await assert.rejects(() => new SlackWorkspaceDirectoryService({ client }).getUserByHandle('alice'), /not_in_channel/);
+});
+function fakeSlackApi(input = {}) {
+    return {
+        conversations: {
+            info: async () => ({ ok: true }),
+            list: async () => ({ channels: [], ok: true }),
+            open: async () => ({ channel: { id: 'D123' }, ok: true }),
+            ...input.conversations,
+        },
+        team: {
+            info: async () => ({ ok: true, team: {} }),
+        },
+        users: {
+            info: async () => ({ ok: true }),
+            list: async () => ({ members: [], ok: true }),
+            ...input.users,
+        },
+    };
+}

package/dist/server/tests/state-cache.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state-cache.test.d.ts.map

package/dist/server/tests/state-cache.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-cache.test.d.ts","sourceRoot":"","sources":["../../../server/tests/state-cache.test.ts"],"names":[],"mappings":""}