@meetquinn/animactl 0.1.2 → 0.1.3

package/dist/server/tests/state-cache.test.js

@@ -0,0 +1,184 @@
+import { mkdir, mkdtemp, readdir, 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 { JsonFile } from '../storage/json-file.js';
+import { JsonlAppendLog } from '../storage/jsonl-log.js';
+test('JsonFile cache invalidates when another writer changes the file on disk', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonfile-cache-'));
+    try {
+        const path = join(dir, 'value.json');
+        const reader = new JsonFile(path, () => ({ count: 0 }));
+        const writer = new JsonFile(path, () => ({ count: 0 }));
+        await writer.write({ count: 1 });
+        assert.deepEqual(await reader.read(), { count: 1 });
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        await writeFile(path, `${JSON.stringify({ count: 2 })}\n`, 'utf8');
+        assert.deepEqual(await reader.read(), { count: 2 }, 'reader should see the external write via stat invalidation');
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog cache invalidates when another writer appends to the file on disk', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-cache-'));
+    try {
+        const path = join(dir, 'log.jsonl');
+        const log = new JsonlAppendLog(path);
+        await log.append({ id: 'a' });
+        assert.deepEqual(await log.readAll(), [{ id: 'a' }]);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        await writeFile(path, `${JSON.stringify({ id: 'a' })}\n${JSON.stringify({ id: 'b' })}\n`, 'utf8');
+        assert.deepEqual(await log.readAll(), [{ id: 'a' }, { id: 'b' }], 'readAll should see the external append');
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog rotates active files and reads archives chronologically', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-rotate-'));
+    const realNow = Date.now;
+    try {
+        Date.now = () => 1;
+        const path = join(dir, 'activity.jsonl');
+        const archiveDir = join(dir, 'activity.archive');
+        const log = new JsonlAppendLog(path, { archiveDir, maxBytes: 1 });
+        await log.append({ id: 'a' });
+        await log.append({ id: 'b' });
+        await log.append({ id: 'c' });
+        const archives = await readdir(archiveDir);
+        assert.equal(archives.length, 2);
+        assert.deepEqual(await log.readAll(), [{ id: 'a' }, { id: 'b' }, { id: 'c' }]);
+        assert.deepEqual(await log.readTail(1), [{ id: 'c' }]);
+        assert.deepEqual(await log.readTail(2), [{ id: 'b' }, { id: 'c' }]);
+    }
+    finally {
+        Date.now = realNow;
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog keeps every archive by default (no maxArchives)', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-no-prune-'));
+    const realNow = Date.now;
+    try {
+        // Monotonic clock: each 10MB rotation gets a strictly greater stamp in
+        // production, so archive names sort chronologically. Mirror that here.
+        let now = 1;
+        Date.now = () => now++;
+        const path = join(dir, 'activity.jsonl');
+        const archiveDir = join(dir, 'activity.archive');
+        const log = new JsonlAppendLog(path, { archiveDir, maxBytes: 1 });
+        // 5 appends ⇒ 4 rotations ⇒ 4 archive segments, none pruned.
+        for (const id of ['a', 'b', 'c', 'd', 'e'])
+            await log.append({ id });
+        assert.equal((await readdir(archiveDir)).length, 4);
+        assert.deepEqual((await log.readAll()).map((r) => r.id), ['a', 'b', 'c', 'd', 'e']);
+    }
+    finally {
+        Date.now = realNow;
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog maxArchives prunes oldest segments past the cap', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-prune-'));
+    const realNow = Date.now;
+    try {
+        let now = 1;
+        Date.now = () => now++;
+        const path = join(dir, 'activity.jsonl');
+        const archiveDir = join(dir, 'activity.archive');
+        const log = new JsonlAppendLog(path, { archiveDir, maxBytes: 1, maxArchives: 2 });
+        // 5 appends ⇒ 4 rotations, but only the newest 2 archives survive.
+        for (const id of ['a', 'b', 'c', 'd', 'e'])
+            await log.append({ id });
+        assert.equal((await readdir(archiveDir)).length, 2, 'only maxArchives segments retained');
+        // a, b pruned; c, d archived; e active.
+        assert.deepEqual((await log.readAll()).map((r) => r.id), ['c', 'd', 'e']);
+    }
+    finally {
+        Date.now = realNow;
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog maxArchives prunes only its own segments in a shared archive dir', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-prune-scoped-'));
+    const realNow = Date.now;
+    try {
+        let now = 100;
+        Date.now = () => now++;
+        const archiveDir = join(dir, 'shared.archive');
+        // A foreign segment from another log living in the same archive dir.
+        await mkdir(archiveDir, { recursive: true });
+        const foreign = join(archiveDir, '0000000000001-other-000.jsonl');
+        await writeFile(foreign, `${JSON.stringify({ id: 'foreign' })}\n`, 'utf8');
+        const path = join(dir, 'activity.jsonl');
+        const log = new JsonlAppendLog(path, { archiveDir, maxBytes: 1, maxArchives: 1 });
+        for (const id of ['a', 'b', 'c'])
+            await log.append({ id });
+        const names = (await readdir(archiveDir)).sort();
+        // Foreign file untouched; only this log's own newest segment kept.
+        assert.ok(names.includes('0000000000001-other-000.jsonl'), 'foreign archive must survive');
+        const ownArchives = names.filter((n) => /-activity-\d{3}\.jsonl$/.test(n));
+        assert.equal(ownArchives.length, 1, 'only maxArchives of this log kept');
+    }
+    finally {
+        Date.now = realNow;
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog appendIf dedupes across rotated archives', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-rotate-dedupe-'));
+    try {
+        const path = join(dir, 'messages.jsonl');
+        const log = new JsonlAppendLog(path, {
+            archiveDir: join(dir, 'messages.archive'),
+            maxBytes: 1,
+        });
+        await log.append({ id: 'a' });
+        await log.append({ id: 'b' });
+        const result = await log.appendIf({ id: 'a' }, (records) => !records.some((record) => record.id === 'a'));
+        assert.equal(result.appended, false);
+        assert.deepEqual(await log.readAll(), [{ id: 'a' }, { id: 'b' }]);
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonlAppendLog appendIfRecent dedupes only within the recent tail window', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonl-recent-dedupe-'));
+    try {
+        const path = join(dir, 'messages.jsonl');
+        const log = new JsonlAppendLog(path, {
+            archiveDir: join(dir, 'messages.archive'),
+            maxBytes: 1,
+        });
+        await log.append({ id: 'old' });
+        await log.append({ id: 'recent' });
+        const oldDuplicate = await log.appendIfRecent({ id: 'old' }, (records) => !records.some((record) => record.id === 'old'), 1);
+        const recentDuplicate = await log.appendIfRecent({ id: 'recent' }, (records) => !records.some((record) => record.id === 'recent'), 10);
+        assert.equal(oldDuplicate.appended, true);
+        assert.equal(recentDuplicate.appended, false);
+        assert.deepEqual((await log.readAll()).map((record) => record.id), ['old', 'recent', 'old']);
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});
+test('JsonFile cache serves the warm value across two readers in the same process', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'anima-jsonfile-warm-'));
+    try {
+        const path = join(dir, 'cached.json');
+        const writer = new JsonFile(path, () => ({ n: 0 }));
+        const reader = new JsonFile(path, () => ({ n: 0 }));
+        await writer.write({ n: 42 });
+        const first = await reader.read();
+        const second = await reader.read();
+        assert.deepEqual(first, { n: 42 });
+        assert.deepEqual(second, { n: 42 });
+        assert.strictEqual(first, second, 'cached reads share a reference; callers must not mutate the returned value');
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+});

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

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

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

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

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

@@ -0,0 +1,292 @@
+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 { attentionMapForSubscriptions, ensureThreadSubscriptionForSentMessage, muteSubscriptionForAgent, recordChannelPost, shouldReply, slackRuntimeDecision, } from '../inbox/slack-subscription.service.js';
+import { withAnimaHome } from './anima-home.js';
+import { loadState } from './helpers/state.js';
+test('Slack routing replies to DMs without mention', () => {
+    assert.equal(shouldReply({
+        channel: 'D123',
+        channel_type: 'im',
+        text: 'Can you help?',
+        ts: '1770000010.000001',
+        type: 'message',
+        user: 'U123',
+    }), true);
+});
+test('Slack routing replies to explicit channel mentions', () => {
+    assert.equal(shouldReply({
+        channel: 'C123',
+        channel_type: 'channel',
+        text: '<@U999> summarize this',
+        ts: '1770000010.000001',
+        type: 'app_mention',
+        user: 'U123',
+    }), true);
+});
+test('member channel top-level messages wake unless muted', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-channel-follow-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            const topLevel = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'top-level member-channel message',
+                ts: '1770000011.000001',
+                type: 'message',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 2_000 });
+            assert.equal(topLevel.shouldStartRuntime, true);
+            assert.equal(topLevel.reason, 'channel_follow');
+            assert.equal(topLevel.subscription?.kind, 'channel');
+            assert.equal(topLevel.subscription?.status, 'following');
+            await muteSubscriptionForAgent({
+                agentId: 'scout',
+                channelId: 'C123',
+                nowMs: 3_000,
+            });
+            const muted = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'muted top-level message',
+                ts: '1770000012.000001',
+                type: 'message',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 4_000 });
+            assert.equal(muted.shouldStartRuntime, false);
+            assert.equal(muted.reason, 'muted');
+            const mention = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: '<@U999> muted channel pierce',
+                ts: '1770000013.000001',
+                type: 'app_mention',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 5_000 });
+            assert.equal(mention.shouldStartRuntime, true);
+            assert.equal(mention.reason, 'mention');
+            const stillMuted = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'still muted without mention',
+                ts: '1770000014.000001',
+                type: 'message',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 6_000 });
+            assert.equal(stillMuted.shouldStartRuntime, false);
+            assert.equal(stillMuted.reason, 'muted');
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('thread follows are permanent and mute is revived by mention', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-thread-follow-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            const mention = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: '<@U999> help here',
+                thread_ts: '1770000010.000001',
+                ts: '1770000011.000001',
+                type: 'app_mention',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 1_000 });
+            assert.equal(mention.shouldStartRuntime, true);
+            assert.equal(mention.reason, 'mention');
+            assert.equal(mention.subscription?.kind, 'thread');
+            const muchLater = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'follow-up weeks later',
+                thread_ts: '1770000010.000001',
+                ts: '1770000012.000001',
+                type: 'message',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 30 * 24 * 60 * 60 * 1000 });
+            assert.equal(muchLater.shouldStartRuntime, true);
+            assert.equal(muchLater.reason, 'thread_follow');
+            await muteSubscriptionForAgent({
+                agentId: 'scout',
+                channelId: 'C123',
+                threadTs: '1770000010.000001',
+                nowMs: 30 * 24 * 60 * 60 * 1000 + 1,
+            });
+            const muted = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'muted thread follow-up',
+                thread_ts: '1770000010.000001',
+                ts: '1770000013.000001',
+                type: 'message',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 30 * 24 * 60 * 60 * 1000 + 2 });
+            assert.equal(muted.shouldStartRuntime, false);
+            assert.equal(muted.reason, 'muted');
+            const revived = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: '<@U999> come back',
+                thread_ts: '1770000010.000001',
+                ts: '1770000014.000001',
+                type: 'app_mention',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 30 * 24 * 60 * 60 * 1000 + 3 });
+            assert.equal(revived.shouldStartRuntime, true);
+            assert.equal(revived.reason, 'mention');
+            assert.equal(revived.subscription?.status, 'following');
+            const state = await loadState();
+            const thread = Object.values(state.subscriptions).find((subscription) => subscription.kind === 'thread' && subscription.threadTs === '1770000010.000001');
+            assert.equal(thread?.mutedAt, undefined);
+            assert.equal('expiresAt' in (thread ?? {}), false);
+            assert.equal('remainingMessages' in (thread ?? {}), false);
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('sent messages follow only threads, not whole channels', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-sent-thread-follow-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            const sentSubscription = await ensureThreadSubscriptionForSentMessage({
+                agentId: 'scout',
+                channelId: 'C123',
+                messageTs: '1770000020.000001',
+                nowMs: 1_000,
+            });
+            assert.equal(sentSubscription?.kind, 'thread');
+            assert.equal(sentSubscription?.threadTs, '1770000020.000001');
+            const state = await loadState();
+            assert.equal(Object.values(state.subscriptions).some((subscription) => subscription.kind === 'channel'), false);
+            const reply = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'replying in the agent-started thread',
+                thread_ts: '1770000020.000001',
+                ts: '1770000021.000001',
+                type: 'message',
+                user: 'U456',
+            }, { agentId: 'scout', nowMs: 2_000 });
+            assert.equal(reply.shouldStartRuntime, true);
+            assert.equal(reply.reason, 'thread_follow');
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('sent replies also follow their own message thread root', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-sent-reply-thread-follow-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            const sentSubscription = await ensureThreadSubscriptionForSentMessage({
+                agentId: 'scout',
+                channelId: 'C123',
+                messageTs: '1770000020.000123',
+                nowMs: 1_000,
+                threadTs: '1770000010.000001',
+            });
+            assert.equal(sentSubscription?.kind, 'thread');
+            assert.equal(sentSubscription?.threadTs, '1770000010.000001');
+            const state = await loadState();
+            assert.equal(Object.values(state.subscriptions).some((subscription) => subscription.kind === 'channel'), false);
+            assert.ok(Object.values(state.subscriptions).some((subscription) => subscription.kind === 'thread' && subscription.threadTs === '1770000010.000001'));
+            assert.ok(Object.values(state.subscriptions).some((subscription) => subscription.kind === 'thread' && subscription.threadTs === '1770000020.000123'));
+            const replyToSentReply = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'replying to the agent reply as its own thread',
+                thread_ts: '1770000020.000123',
+                ts: '1770000021.000001',
+                type: 'message',
+                user: 'U456',
+            }, { agentId: 'scout', nowMs: 2_000 });
+            assert.equal(replyToSentReply.shouldStartRuntime, true);
+            assert.equal(replyToSentReply.reason, 'thread_follow');
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('attention nudge suggests muting after repeated wakes without posting', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-attention-nudge-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            let last;
+            for (let i = 0; i < 6; i += 1) {
+                last = await slackRuntimeDecision({
+                    channel: 'C123',
+                    channel_type: 'channel',
+                    text: `wake ${i}`,
+                    ts: `17700000${10 + i}.000001`,
+                    type: 'message',
+                    user: 'U123',
+                }, { agentId: 'scout', nowMs: 1_000 + i });
+            }
+            assert.equal(last?.shouldStartRuntime, true);
+            assert.match(last?.attentionSuggestion ?? '', /anima subscription mute --channel C123/);
+            await recordChannelPost({ agentId: 'scout', channelId: 'C123', nowMs: 2_000 });
+            const afterPost = await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: 'after post',
+                ts: '1770000020.000001',
+                type: 'message',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: 2_001 });
+            assert.equal(afterPost.attentionSuggestion, undefined);
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});
+test('attention map shows member channels, muted threads, and quiet thread tails', async () => {
+    const stateDir = await mkdtemp(join(tmpdir(), 'anima-slack-attention-map-test-'));
+    try {
+        await withAnimaHome(stateDir, async () => {
+            await slackRuntimeDecision({
+                channel: 'C123',
+                channel_type: 'channel',
+                text: '<@U999> recent',
+                thread_ts: '1770000010.000001',
+                ts: '1770000011.000001',
+                type: 'app_mention',
+                user: 'U123',
+            }, { agentId: 'scout', nowMs: Date.UTC(2026, 0, 10) });
+            await ensureThreadSubscriptionForSentMessage({
+                agentId: 'scout',
+                channelId: 'C123',
+                messageTs: '1770000001.000001',
+                nowMs: Date.UTC(2025, 0, 1),
+            });
+            await muteSubscriptionForAgent({
+                agentId: 'scout',
+                channelId: 'C456',
+                threadTs: '1770000030.000001',
+                nowMs: Date.UTC(2026, 0, 11),
+            });
+            const subscriptions = Object.values((await loadState()).subscriptions);
+            const map = attentionMapForSubscriptions({
+                memberChannels: [{ id: 'C123', name: 'team' }, { id: 'C999', name: 'support' }],
+                nowMs: Date.UTC(2026, 0, 12),
+                subscriptions,
+            });
+            assert.deepEqual(map.channels.map((channel) => `${channel.channelId}:${channel.status}`).sort(), ['C999:following', 'C123:following'].sort());
+            assert.equal(map.activeThreads.length, 1);
+            assert.equal(map.mutedThreads.length, 1);
+            assert.equal(map.quietThreadCount, 1);
+            assert.equal(map.quietThreads.length, 0);
+        });
+    }
+    finally {
+        await rm(stateDir, { force: true, recursive: true });
+    }
+});

package/dist/server/tests/system-service.test.d.ts

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

package/dist/server/tests/system-service.test.d.ts.map

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

package/dist/server/tests/system-service.test.js

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { docsUrl } from '../services/system.service.js';
+test('docsUrl uses public docs by default and accepts an explicit override', () => {
+    const previous = process.env.ANIMA_DOCS_URL;
+    try {
+        delete process.env.ANIMA_DOCS_URL;
+        assert.equal(docsUrl('dev'), 'http://127.0.0.1:14175/');
+        assert.equal(docsUrl('canary'), 'https://anima.meetquinn.ai/');
+        assert.equal(docsUrl('stable'), 'https://anima.meetquinn.ai/');
+        process.env.ANIMA_DOCS_URL = 'http://127.0.0.1:14175/';
+        assert.equal(docsUrl('stable'), 'http://127.0.0.1:14175/');
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.ANIMA_DOCS_URL;
+        else
+            process.env.ANIMA_DOCS_URL = previous;
+    }
+});

package/dist/server/tests/url-routes.test.d.ts

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

package/dist/server/tests/url-routes.test.d.ts.map

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