@meetquinn/animactl 0.1.2 → 0.1.3

package/dist/server/tests/default-skills.test.js

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, readlink, rm, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { ensureDefaultSkills } from '../agents/default-skills.js';
+test('ensureDefaultSkills installs find-skills into common skills and links Claude Code', async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), 'anima-default-skills-'));
+    try {
+        const result = await ensureDefaultSkills({ homeDir });
+        assert.deepEqual(result, {
+            claudeLinkInstalled: true,
+            commonSkillInstalled: true,
+        });
+        const skillPath = join(homeDir, '.agents', 'skills', 'find-skills', 'SKILL.md');
+        assert.match(await readFile(skillPath, 'utf8'), /name: find-skills/);
+        assert.equal(await readlink(join(homeDir, '.claude', 'skills', 'find-skills')), '../../.agents/skills/find-skills');
+    }
+    finally {
+        await rm(homeDir, { force: true, recursive: true });
+    }
+});
+test('ensureDefaultSkills preserves existing skill content and provider paths', async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), 'anima-default-skills-'));
+    try {
+        const commonSkillDir = join(homeDir, '.agents', 'skills', 'find-skills');
+        const claudeSkillDir = join(homeDir, '.claude', 'skills', 'find-skills');
+        await mkdir(commonSkillDir, { recursive: true });
+        await mkdir(claudeSkillDir, { recursive: true });
+        await writeFile(join(commonSkillDir, 'SKILL.md'), 'custom common skill\n', 'utf8');
+        await writeFile(join(claudeSkillDir, 'SKILL.md'), 'custom claude skill\n', 'utf8');
+        const result = await ensureDefaultSkills({ homeDir });
+        assert.deepEqual(result, {
+            claudeLinkInstalled: false,
+            commonSkillInstalled: false,
+        });
+        assert.equal(await readFile(join(commonSkillDir, 'SKILL.md'), 'utf8'), 'custom common skill\n');
+        assert.equal(await readFile(join(claudeSkillDir, 'SKILL.md'), 'utf8'), 'custom claude skill\n');
+    }
+    finally {
+        await rm(homeDir, { force: true, recursive: true });
+    }
+});
+test('ensureDefaultSkills repairs a broken Claude Code find-skills symlink', async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), 'anima-default-skills-'));
+    try {
+        const claudeSkillsDir = join(homeDir, '.claude', 'skills');
+        await mkdir(claudeSkillsDir, { recursive: true });
+        await symlink('../missing/find-skills', join(claudeSkillsDir, 'find-skills'), 'dir');
+        const result = await ensureDefaultSkills({ homeDir });
+        assert.equal(result.claudeLinkInstalled, true);
+        assert.equal(await readlink(join(claudeSkillsDir, 'find-skills')), '../../.agents/skills/find-skills');
+    }
+    finally {
+        await rm(homeDir, { force: true, recursive: true });
+    }
+});

package/dist/server/tests/helpers/inbox.d.ts

@@ -0,0 +1,10 @@
+import { type InboxItem } from '../../inbox/wake-queue.service.js';
+import type { RuntimeWorkerConfig, RuntimeItemContext } from '../../runtime/types.js';
+import type { ReminderInboxItem } from '../../../shared/inbox.js';
+export declare function ingestEvent(event: InboxItem, config: RuntimeWorkerConfig): Promise<RuntimeItemContext>;
+export declare function makeReminderInboxItem(opts: {
+    eventId?: string;
+    reminderId: string;
+    timestamp?: string;
+}): ReminderInboxItem;
+//# sourceMappingURL=inbox.d.ts.map

package/dist/server/tests/helpers/inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.d.ts","sourceRoot":"","sources":["../../../../server/tests/helpers/inbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAErF,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAsB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAG5G;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,iBAAiB,CAcpB"}

package/dist/server/tests/helpers/inbox.js

@@ -0,0 +1,21 @@
+import { WakeQueueService } from '../../inbox/wake-queue.service.js';
+import { runtimeContextForItemId } from '../../runtime/context.js';
+export async function ingestEvent(event, config) {
+    const result = await new WakeQueueService(config.agentId).enqueue(event);
+    return runtimeContextForItemId(result.item.id, config);
+}
+export function makeReminderInboxItem(opts) {
+    const receivedAt = opts.timestamp ?? new Date().toISOString();
+    return {
+        id: opts.eventId ?? `evt_reminder_${opts.reminderId}`,
+        kind: 'reminder',
+        receivedAt,
+        handling: {
+            createdAt: receivedAt,
+            queuedAt: receivedAt,
+            status: 'queued',
+            updatedAt: receivedAt,
+        },
+        reminderId: opts.reminderId,
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { SlackEvent } from '../../inbox/slack-events.js';
+export declare function makeSlackEvent(input: {
+    channelId: string;
+    teamId: string;
+    text: string;
+    userId: string;
+    eventId?: string;
+    ts?: string;
+    timestamp?: string;
+} & Partial<SlackEvent>): SlackEvent;
+//# sourceMappingURL=slack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../../server/tests/helpers/slack.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,wBAAgB,cAAc,CAC5B,KAAK,EAAE;IACL,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,UAAU,CAAC,GACtB,UAAU,CAmBZ"}

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

@@ -0,0 +1,17 @@
+import { makeId } from '../../ids.js';
+export function makeSlackEvent(input) {
+    const ts = input.ts ?? `${Date.now() / 1000}`;
+    const now = input.timestamp ?? new Date().toISOString();
+    return {
+        id: input.eventId ?? input.id ?? makeId('evt'),
+        kind: 'slack',
+        receivedAt: input.receivedAt ?? now,
+        handling: input.handling ?? { createdAt: now, queuedAt: now, status: 'queued', updatedAt: now },
+        teamId: input.teamId,
+        channelId: input.channelId,
+        messageTs: ts,
+        actor: { userId: input.userId, ...(input.actor ?? {}) },
+        text: input.text,
+        ...Object.fromEntries(Object.entries(input).filter(([key]) => !['id', 'eventId', 'kind', 'receivedAt', 'handling', 'teamId', 'channelId', 'messageTs', 'actor', 'text', 'userId', 'ts', 'timestamp'].includes(key))),
+    };
+}

package/dist/server/tests/helpers/state.d.ts

@@ -0,0 +1,19 @@
+import { type InboxItem } from '../../inbox/wake-queue.service.js';
+import type { Reminder } from '../../../shared/reminder.js';
+import { type Session } from '../../storage/schema/session.store.js';
+import { type SubscriptionRecord } from '../../storage/schema/subscription.store.js';
+import type { Activity } from '../../../shared/activity.js';
+export interface TestState {
+    activities: Record<string, Activity>;
+    events: Record<string, InboxItem>;
+    subscriptions: Record<string, SubscriptionRecord>;
+    reminders: Record<string, Reminder>;
+    items: Record<string, InboxItem>;
+    sessions: Record<string, Session>;
+}
+type ActivityState = Pick<TestState, 'activities'>;
+export declare function loadState(): Promise<TestState>;
+export declare function loadAgentState(agentId: string): Promise<TestState>;
+export declare function allActivities(state: ActivityState): Activity[];
+export {};
+//# sourceMappingURL=state.d.ts.map

package/dist/server/tests/helpers/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../server/tests/helpers/state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAGrF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAG5D,OAAO,EAAgB,KAAK,OAAO,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AACxG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAClD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,KAAK,aAAa,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AAEnD,wBAAsB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,CAKpD;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAIxE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,QAAQ,EAAE,CAE9D"}

package/dist/server/tests/helpers/state.js

@@ -0,0 +1,69 @@
+import { readdir } from 'node:fs/promises';
+import { WakeQueueService } from '../../inbox/wake-queue.service.js';
+import { reminderServiceForAgent } from '../../reminders/reminder.service.js';
+import { isMissingFile } from '../../storage/json-file.js';
+import { activityServiceForAgent } from '../../activities/activity.service.js';
+import { agentsDir } from '../../storage/schema/agent.store.js';
+import { SessionStore } from '../../storage/schema/session.store.js';
+import { SubscriptionStore } from '../../storage/schema/subscription.store.js';
+export async function loadState() {
+    const state = emptyState();
+    const agentIds = await listAgentIds();
+    await Promise.all(agentIds.map((agentId) => hydrateAgentState(agentId, state)));
+    return state;
+}
+export async function loadAgentState(agentId) {
+    const state = emptyState();
+    await hydrateAgentState(agentId, state);
+    return state;
+}
+export function allActivities(state) {
+    return Object.values(state.activities).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+async function hydrateAgentState(agentId, state) {
+    const queue = new WakeQueueService(agentId);
+    const [session, events, subscriptions, reminders, items, activities] = await Promise.all([
+        readSession(agentId),
+        queue.list(),
+        new SubscriptionStore(agentId).list(),
+        reminderServiceForAgent(agentId).listAllReminders(),
+        queue.list(),
+        activityServiceForAgent(agentId).readAll(),
+    ]);
+    if (session)
+        state.sessions[agentId] = session;
+    for (const event of events)
+        state.events[event.id] = event;
+    for (const subscription of subscriptions)
+        state.subscriptions[subscription.subscriptionId] = subscription;
+    for (const reminder of reminders)
+        state.reminders[reminder.reminderId] = reminder;
+    for (const item of items)
+        state.items[item.id] = item;
+    for (const activity of activities)
+        state.activities[activity.activityId] = activity;
+}
+async function readSession(agentId) {
+    return new SessionStore(agentId).read();
+}
+async function listAgentIds() {
+    try {
+        const entries = await readdir(agentsDir(), { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return [];
+        throw error;
+    }
+}
+function emptyState() {
+    return {
+        activities: {},
+        events: {},
+        subscriptions: {},
+        reminders: {},
+        items: {},
+        sessions: {},
+    };
+}

package/dist/server/tests/inbox-slack-events.test.d.ts

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

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

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

package/dist/server/tests/inbox-slack-events.test.js

@@ -0,0 +1,271 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { isRoutableSlackMessage, isUserAuthoredSlackMessage, normalizeSlackMessage } from '../inbox/slack-events.js';
+import { slackSurfaceForEvent } from '../inbox/slack-events.js';
+test('normalizes Slack DM messages into private primary-session events', () => {
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'Ev123', team_id: 'T123' },
+        event: {
+            channel: 'D123',
+            channel_type: 'im',
+            text: 'Can you remember this privately?',
+            ts: '1770000010.000001',
+            type: 'message',
+            user: 'U123',
+        },
+    });
+    const surface = slackSurfaceForEvent(event);
+    assert.equal(event.id, 'slack:T123:D123:1770000010.000001');
+    assert.equal(surface.id, 'slack:T123:D123');
+    assert.equal(surface.teamId, 'T123');
+    assert.equal(surface.channelId, 'D123');
+    assert.equal(surface.kind, 'dm');
+    assert.equal(surface.visibility, 'private');
+    assert.equal(event.messageTs, '1770000010.000001');
+});
+test('normalizes Slack thread messages with reply routing metadata', () => {
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'Ev456', team_id: 'T123' },
+        channelName: 'product',
+        event: {
+            channel: 'C123',
+            channel_type: 'channel',
+            text: 'Can you summarize here?',
+            thread_ts: '1770000000.000001',
+            ts: '1770000020.000001',
+            type: 'message',
+            user: 'U123',
+        },
+    });
+    const surface = slackSurfaceForEvent(event);
+    assert.equal(surface.kind, 'thread');
+    assert.equal(surface.channelName, 'product');
+    assert.equal(surface.threadTs, '1770000000.000001');
+    assert.equal(surface.visibility, 'public');
+});
+test('normalizes Slack app mention events as addressed channel messages', () => {
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'Ev789', team_id: 'T123' },
+        event: {
+            channel: 'C123',
+            text: '<@U999> can you help here?',
+            ts: '1770000030.000001',
+            type: 'app_mention',
+            user: 'U123',
+        },
+    });
+    const surface = slackSurfaceForEvent(event);
+    assert.equal(event.id, 'slack:T123:C123:1770000030.000001');
+    assert.equal(surface.kind, 'channel');
+    assert.equal(surface.visibility, 'public');
+    assert.equal(surface.id, 'slack:T123:C123');
+});
+test('normalizes resolved Slack mention text', () => {
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'EvMentionText', team_id: 'T123' },
+        event: {
+            channel: 'C123',
+            text: '<@U999> please ask <@U123> in <#C456|product>',
+            ts: '1770000031.000001',
+            type: 'app_mention',
+            user: 'U123',
+        },
+        text: '@anima please ask @alice in #product',
+    });
+    assert.equal(event.text, '@anima please ask @alice in #product');
+});
+test('uses Slack message ts as the stable event id across message and app_mention deliveries', () => {
+    const message = normalizeSlackMessage({
+        envelope: { event_id: 'EvMessage', team_id: 'T123' },
+        event: {
+            channel: 'C123',
+            channel_type: 'channel',
+            text: '<@U999> can you help here?',
+            ts: '1770000030.000001',
+            type: 'message',
+            user: 'U123',
+        },
+    });
+    const mention = normalizeSlackMessage({
+        envelope: { event_id: 'EvMention', team_id: 'T123' },
+        event: {
+            channel: 'C123',
+            text: '<@U999> can you help here?',
+            ts: '1770000030.000001',
+            type: 'app_mention',
+            user: 'U123',
+        },
+    });
+    assert.equal(message.id, mention.id);
+    assert.equal(message.id, 'slack:T123:C123:1770000030.000001');
+});
+test('normalizes optional Slack user profile metadata into actor context', () => {
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'EvProfile', team_id: 'T123' },
+        event: {
+            channel: 'D123',
+            channel_type: 'im',
+            text: 'Do you know my name?',
+            ts: '1770000040.000001',
+            type: 'message',
+            user: 'U123',
+        },
+        userProfile: {
+            displayName: 'Alice',
+            handle: 'alice',
+            realName: 'Alice Lee',
+        },
+    });
+    assert.equal(event.actor?.userId, 'U123');
+    assert.equal(event.actor?.displayName, 'Alice');
+    assert.equal(event.actor?.handle, 'alice');
+    assert.equal(event.actor?.realName, 'Alice Lee');
+});
+test('routes non-self bot-authored channel messages for subscription-window checks', () => {
+    assert.equal(isUserAuthoredSlackMessage({
+        bot_id: 'B123',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: 'bot text',
+        ts: '1770000020.000001',
+        type: 'message',
+        user: 'U123',
+    }), false);
+    assert.equal(isRoutableSlackMessage({
+        bot_id: 'B123',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: 'bot text',
+        ts: '1770000020.000001',
+        type: 'message',
+        user: 'U123',
+    }), true);
+    assert.equal(isRoutableSlackMessage({
+        bot_id: 'B999',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: 'self echo',
+        ts: '1770000021.000001',
+        type: 'message',
+        user: 'U999',
+    }), true);
+});
+test('filters unsupported subtype messages before runtime ingestion', () => {
+    assert.equal(isUserAuthoredSlackMessage({
+        channel: 'C123',
+        channel_type: 'channel',
+        subtype: 'message_changed',
+        text: 'edited text',
+        ts: '1770000020.000001',
+        type: 'message',
+        user: 'U123',
+    }), false);
+    assert.equal(isRoutableSlackMessage({
+        channel: 'C123',
+        channel_type: 'channel',
+        subtype: 'message_changed',
+        text: 'edited text',
+        ts: '1770000020.000001',
+        type: 'message',
+        user: 'U123',
+    }), false);
+});
+test('routes bot-authored messages that explicitly mention this bot', () => {
+    assert.equal(isRoutableSlackMessage({
+        bot_id: 'B123',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: '<@U999> can you review this?',
+        thread_ts: '1770000010.000001',
+        ts: '1770000020.000001',
+        type: 'message',
+        user: 'U123',
+    }), true);
+    assert.equal(isRoutableSlackMessage({
+        bot_id: 'B999',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: '<@U999> self echo',
+        thread_ts: '1770000010.000001',
+        ts: '1770000021.000001',
+        type: 'message',
+        user: 'U999',
+    }), true);
+});
+test('routes file-only messages (empty text, files present) and normalizes file metadata', () => {
+    const rawEvent = {
+        channel: 'D123',
+        channel_type: 'im',
+        files: [
+            {
+                id: 'F-screenshot',
+                mimetype: 'image/png',
+                name: 'screenshot.png',
+                size: 2048,
+                url_private: 'https://files.slack.com/private',
+                url_private_download: 'https://files.slack.com/download',
+            },
+        ],
+        subtype: 'file_share',
+        text: '',
+        ts: '1770000050.000001',
+        type: 'message',
+        user: 'U123',
+    };
+    assert.equal(isUserAuthoredSlackMessage(rawEvent), true);
+    assert.equal(isRoutableSlackMessage(rawEvent), true);
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'EvFile', team_id: 'T123' },
+        event: rawEvent,
+    });
+    assert.equal(slackSurfaceForEvent(event).kind, 'dm');
+    assert.equal(event.files?.length, 1);
+    assert.equal(event.files?.[0]?.id, 'F-screenshot');
+    assert.equal(event.files?.[0]?.mimetype, 'image/png');
+    assert.equal(event.files?.[0]?.sizeBytes, 2048);
+});
+test('normalizeSlackMessage prefers explicitly enriched files over raw event files', () => {
+    const event = normalizeSlackMessage({
+        envelope: { event_id: 'EvFileEnriched', team_id: 'T123' },
+        event: {
+            channel: 'C123',
+            channel_type: 'channel',
+            files: [{ id: 'F-raw', mimetype: 'image/png', name: 'raw.png', size: 1 }],
+            text: 'see attached',
+            ts: '1770000060.000001',
+            type: 'message',
+            user: 'U123',
+        },
+        files: [{
+                id: 'F-enriched',
+                mimetype: 'image/png',
+                name: 'enriched.png',
+                sizeBytes: 4096,
+            }],
+    });
+    assert.equal(event.files?.length, 1);
+    assert.equal(event.files?.[0]?.id, 'F-enriched');
+    assert.equal(Object.hasOwn(event.files?.[0] ?? {}, 'localPath'), false);
+});
+test('routes non-self bot-authored thread messages for subscription-window checks', () => {
+    assert.equal(isRoutableSlackMessage({
+        bot_id: 'B123',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: 'continuing in the active thread',
+        thread_ts: '1770000010.000001',
+        ts: '1770000020.000001',
+        type: 'message',
+        user: 'U123',
+    }), true);
+    assert.equal(isRoutableSlackMessage({
+        bot_id: 'B999',
+        channel: 'C123',
+        channel_type: 'channel',
+        text: 'self echo in thread',
+        thread_ts: '1770000010.000001',
+        ts: '1770000021.000001',
+        type: 'message',
+        user: 'U999',
+    }), true);
+});

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

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

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

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

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

@@ -0,0 +1,144 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { WakeQueueService } from '../inbox/wake-queue.service.js';
+import { WakeQueueStore } from '../storage/schema/wake-queue.store.js';
+import { makeSlackEvent } from './helpers/slack.js';
+import { withAnimaHome } from './anima-home.js';
+import { loadState } from './helpers/state.js';
+function memoryWakeQueueStore(initial = {}) {
+    let state = { ...initial };
+    return {
+        async read() {
+            return state;
+        },
+        async write(value) {
+            state = value;
+        },
+    };
+}
+test('wake queue store ignores duplicate Slack message deliveries', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-queued-dedupe-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            const queue = new WakeQueueService('scout');
+            const first = await queue.enqueue(makeSlackEvent({
+                channelId: 'C-product',
+                eventId: 'slack:T-demo:C-product:1770000010.000001',
+                teamId: 'T-demo',
+                text: '<@U999> remember bagels',
+                ts: '1770000010.000001',
+                userId: 'U1',
+            }));
+            const second = await queue.enqueue(makeSlackEvent({
+                channelId: 'C-product',
+                eventId: 'slack:T-demo:C-product:1770000010.000001',
+                teamId: 'T-demo',
+                text: '<@U999> remember bagels',
+                ts: '1770000010.000001',
+                userId: 'U1',
+            }));
+            assert.equal(first.queued, true);
+            assert.equal(second.duplicate, true);
+            assert.equal(second.item.id, first.item.id);
+            assert.deepEqual((await queue.listRunnable()).map((item) => item.id), [first.item.id]);
+            const state = await loadState();
+            assert.equal(Object.keys(state.events).length, 1);
+            assert.equal(Object.keys(state.items).length, 1);
+            assert.equal(state.items[first.item.id]?.id, 'slack:T-demo:C-product:1770000010.000001');
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('wake queue store can use an injected file persistence', async () => {
+    const queue = new WakeQueueService('scout', new WakeQueueStore('scout', memoryWakeQueueStore()), { recordInboxItem: async () => undefined });
+    const event = makeSlackEvent({
+        channelId: 'D-user',
+        eventId: 'evt-injected-store',
+        teamId: 'T-demo',
+        text: 'queued without filesystem store',
+        ts: '1770000010.000001',
+        userId: 'U1',
+    });
+    const decision = await queue.enqueue(event);
+    assert.equal(decision.queued, true);
+    const claimed = await queue.claimNext('worker-1');
+    assert.equal(claimed?.id, event.id);
+    assert.equal(claimed?.handling.status, 'running');
+    await queue.complete(event.id);
+    const completed = await queue.find(event.id);
+    assert.equal(completed?.handling.status, 'completed');
+    assert.deepEqual((await queue.list()).map((item) => item.id), [event.id]);
+});
+test('wake queue enqueue does not fail when message ledger write fails', async () => {
+    const warnings = [];
+    const queue = new WakeQueueService('scout', new WakeQueueStore('scout', memoryWakeQueueStore()), { recordInboxItem: async () => { throw new Error('ledger down'); } }, { warn: (message) => warnings.push(message) });
+    const event = makeSlackEvent({
+        channelId: 'D-user',
+        eventId: 'evt-ledger-failure',
+        teamId: 'T-demo',
+        text: 'queued even when ledger is down',
+        ts: '1770000011.000001',
+        userId: 'U1',
+    });
+    const decision = await queue.enqueue(event);
+    assert.equal(decision.queued, true);
+    assert.deepEqual((await queue.list()).map((item) => item.id), [event.id]);
+    assert.match(warnings[0] ?? '', /ledger down/);
+});
+test('wake queue retention waits for legacy message backfill before pruning settled items', async () => {
+    let legacyBackfilled = false;
+    const oldSettled = makeSlackEvent({
+        channelId: 'D-user',
+        eventId: 'evt-old-settled',
+        handling: {
+            completedAt: '2000-01-01T00:00:00.000Z',
+            createdAt: '2000-01-01T00:00:00.000Z',
+            queuedAt: '2000-01-01T00:00:00.000Z',
+            status: 'completed',
+            updatedAt: '2000-01-01T00:00:00.000Z',
+        },
+        teamId: 'T-demo',
+        text: 'old completed message',
+        ts: '946684800.000001',
+        userId: 'U1',
+    });
+    const oldQueued = makeSlackEvent({
+        channelId: 'D-user',
+        eventId: 'evt-old-queued',
+        handling: {
+            createdAt: '2000-01-01T00:00:00.000Z',
+            queuedAt: '2000-01-01T00:00:00.000Z',
+            status: 'queued',
+            updatedAt: '2000-01-01T00:00:00.000Z',
+        },
+        teamId: 'T-demo',
+        text: 'old queued message',
+        ts: '946684801.000001',
+        userId: 'U1',
+    });
+    const queue = new WakeQueueService('scout', new WakeQueueStore('scout', memoryWakeQueueStore({
+        [oldSettled.id]: oldSettled,
+        [oldQueued.id]: oldQueued,
+    })), {
+        legacyBackfilled: async () => legacyBackfilled,
+        recordInboxItem: async () => undefined,
+    });
+    const event = makeSlackEvent({
+        channelId: 'D-user',
+        eventId: 'evt-new',
+        teamId: 'T-demo',
+        text: 'new message',
+        ts: '1770000012.000001',
+        userId: 'U1',
+    });
+    await queue.enqueue(event);
+    assert.deepEqual((await queue.list()).map((item) => item.id), [oldSettled.id, oldQueued.id, event.id]);
+    legacyBackfilled = true;
+    await queue.complete(event.id);
+    assert.deepEqual((await queue.list()).map((item) => item.id), [oldQueued.id, event.id]);
+});

package/dist/server/tests/interactive-ask.test.d.ts

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

package/dist/server/tests/interactive-ask.test.d.ts.map

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