skimpyclaw 0.3.14 → 0.4.0

package/dist/__tests__/cron-run.test.js

@@ -0,0 +1,250 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { runAgentTurnMock, sendActiveChannelProactiveMessageMock, sendToDiscordThreadMock, sendToDiscordThreadWithVoiceMock, parseAndSaveDigestMock, synthesizeSpeechMock, } = vi.hoisted(() => ({
+    runAgentTurnMock: vi.fn(),
+    sendActiveChannelProactiveMessageMock: vi.fn(async () => true),
+    sendToDiscordThreadMock: vi.fn(async () => false),
+    sendToDiscordThreadWithVoiceMock: vi.fn(async () => false),
+    parseAndSaveDigestMock: vi.fn(),
+    synthesizeSpeechMock: vi.fn(),
+}));
+vi.mock('../agent.js', () => ({
+    runAgentTurn: runAgentTurnMock,
+}));
+vi.mock('../channels.js', () => ({
+    sendActiveChannelProactiveMessage: sendActiveChannelProactiveMessageMock,
+    sendActiveChannelProactiveVoice: vi.fn(async () => false),
+    getActiveChannelId: () => 'telegram',
+}));
+vi.mock('../digests.js', () => ({
+    parseAndSaveDigest: parseAndSaveDigestMock,
+}));
+vi.mock('../channels/discord/index.js', () => ({
+    sendToDiscordThread: sendToDiscordThreadMock,
+    sendToDiscordThreadWithVoice: sendToDiscordThreadWithVoiceMock,
+}));
+vi.mock('../config.js', () => ({
+    getLogsDir: () => '/tmp',
+    getConfigPath: () => '/tmp/config.json',
+    loadConfig: vi.fn(),
+    resolveAllowedPaths: () => ['/tmp'],
+}));
+vi.mock('../audit.js', () => ({
+    startTrace: vi.fn(() => 'trace-1'),
+    addEvent: vi.fn(),
+    endTrace: vi.fn(),
+}));
+vi.mock('../voice.js', () => ({
+    synthesizeSpeech: synthesizeSpeechMock,
+}));
+vi.mock('../env-sanitizer.js', () => ({
+    sanitizeCronEnv: () => ({}),
+}));
+import { runCronJob } from '../cron.js';
+describe('runCronJob digest chat output', () => {
+    const config = {
+        agents: { default: 'default', list: { default: { model: 'claude-sonnet' } } },
+        channels: { active: 'telegram', telegram: { enabled: true, allowFrom: ['1'] }, discord: { enabled: false, allowFrom: [] } },
+        cron: {
+            jobs: [
+                {
+                    id: 'tech-digest',
+                    name: 'Tech Digest',
+                    schedule: { kind: 'cron', expr: '* * * * *', tz: 'UTC' },
+                    payload: { kind: 'agentTurn', message: 'digest please' },
+                },
+            ],
+        },
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('sends digest summary to chat when digest includes articles', async () => {
+        const digestText = '1. Story https://example.com/story';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [{ id: 'a1' }] });
+        await runCronJob('tech-digest', config);
+        expect(parseAndSaveDigestMock).toHaveBeenCalledWith('tech-digest', 'Tech Digest', digestText);
+        expect(sendActiveChannelProactiveMessageMock).toHaveBeenCalledWith(config, digestText);
+    });
+    it('does not send digest summary to chat when digest has no articles', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        await runCronJob('tech-digest', config);
+        expect(sendActiveChannelProactiveMessageMock).not.toHaveBeenCalledWith(config, digestText);
+    });
+    it('skips overlapping execution for the same job id', async () => {
+        let releaseFirstRun = () => { };
+        runAgentTurnMock.mockImplementation(() => new Promise(resolve => {
+            releaseFirstRun = () => resolve('1. Story https://example.com/story');
+        }));
+        parseAndSaveDigestMock.mockReturnValue({ summary: '1. Story https://example.com/story', articles: [{ id: 'a1' }] });
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const firstRun = runCronJob('tech-digest', config);
+        await Promise.resolve();
+        await runCronJob('tech-digest', config);
+        expect(runAgentTurnMock).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping overlapping run for job "tech-digest"'));
+        releaseFirstRun();
+        await firstRun;
+        warnSpy.mockRestore();
+    });
+    it('thread id set + successful send does not use active-channel send', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        sendToDiscordThreadMock.mockResolvedValue(true);
+        const threadConfig = {
+            ...config,
+            cron: {
+                jobs: [
+                    {
+                        id: 'tech-digest',
+                        name: 'Tech Digest',
+                        schedule: { kind: 'cron', expr: '* * * * *', tz: 'UTC' },
+                        payload: {
+                            kind: 'agentTurn',
+                            message: 'digest please',
+                            discordThreadId: '123456789012345678',
+                        },
+                    },
+                ],
+            },
+        };
+        await runCronJob('tech-digest', threadConfig);
+        expect(sendToDiscordThreadMock).toHaveBeenCalled();
+        expect(sendActiveChannelProactiveMessageMock).not.toHaveBeenCalled();
+    });
+    it('thread id set + failed send does not fall back to active channel', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        sendToDiscordThreadMock.mockResolvedValue(false);
+        const threadConfig = {
+            ...config,
+            cron: {
+                jobs: [
+                    {
+                        id: 'tech-digest',
+                        name: 'Tech Digest',
+                        schedule: { kind: 'cron', expr: '* * * * *', tz: 'UTC' },
+                        payload: {
+                            kind: 'agentTurn',
+                            message: 'digest please',
+                            discordThreadId: '123456789012345678',
+                        },
+                    },
+                ],
+            },
+        };
+        await runCronJob('tech-digest', threadConfig);
+        expect(sendToDiscordThreadMock).toHaveBeenCalled();
+        expect(sendActiveChannelProactiveMessageMock).not.toHaveBeenCalled();
+    });
+    it('falls back to active channel when discordThreadId is invalid', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        const threadConfig = {
+            ...config,
+            cron: {
+                jobs: [
+                    {
+                        id: 'tech-digest',
+                        name: 'Tech Digest',
+                        schedule: { kind: 'cron', expr: '* * * * *', tz: 'UTC' },
+                        payload: {
+                            kind: 'agentTurn',
+                            message: 'digest please',
+                            discordThreadId: 'not-a-thread-id',
+                        },
+                    },
+                ],
+            },
+        };
+        await runCronJob('tech-digest', threadConfig);
+        expect(sendToDiscordThreadMock).not.toHaveBeenCalled();
+        expect(sendActiveChannelProactiveMessageMock).toHaveBeenCalledWith(threadConfig, expect.stringContaining('Cron: Tech Digest'));
+    });
+    it('no thread id uses active-channel send', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        await runCronJob('tech-digest', config);
+        expect(sendToDiscordThreadMock).not.toHaveBeenCalled();
+        expect(sendActiveChannelProactiveMessageMock).toHaveBeenCalledWith(config, expect.stringContaining('Cron: Tech Digest'));
+    });
+    it('sends voice attachment to Discord thread when sendAsVoice is enabled', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        sendToDiscordThreadMock.mockResolvedValue(true); // Start notification succeeds
+        sendToDiscordThreadWithVoiceMock.mockResolvedValue(true); // Final notification with voice succeeds
+        synthesizeSpeechMock.mockResolvedValue({
+            buffer: new Uint8Array([1, 2, 3]),
+            format: 'mp3',
+            provider: 'test-provider',
+        });
+        const voiceConfig = {
+            ...config,
+            voice: {
+                provider: 'test-provider',
+                apiKey: 'test-key',
+            },
+            cron: {
+                jobs: [
+                    {
+                        id: 'tech-digest',
+                        name: 'Tech Digest',
+                        schedule: { kind: 'cron', expr: '* * * * *', tz: 'UTC' },
+                        payload: {
+                            kind: 'agentTurn',
+                            message: 'digest please',
+                            sendAsVoice: true,
+                            discordThreadId: '123456789012345678',
+                        },
+                    },
+                ],
+            },
+        };
+        await runCronJob('tech-digest', voiceConfig);
+        expect(synthesizeSpeechMock).toHaveBeenCalledWith(digestText, voiceConfig.voice);
+        expect(sendToDiscordThreadWithVoiceMock).toHaveBeenCalledWith('123456789012345678', expect.stringContaining('Cron: Tech Digest'), new Uint8Array([1, 2, 3]), 'mp3');
+        // Start notification goes to Discord thread, final notification goes to Discord thread with voice
+        expect(sendActiveChannelProactiveMessageMock).not.toHaveBeenCalled();
+    });
+    it('sends voice to active channel when Discord thread is not configured', async () => {
+        const digestText = 'No links today';
+        runAgentTurnMock.mockResolvedValue(digestText);
+        parseAndSaveDigestMock.mockReturnValue({ summary: digestText, articles: [] });
+        synthesizeSpeechMock.mockResolvedValue({
+            buffer: new Uint8Array([1, 2, 3]),
+            format: 'mp3',
+            provider: 'test-provider',
+        });
+        const voiceConfig = {
+            ...config,
+            voice: {
+                provider: 'test-provider',
+                apiKey: 'test-key',
+            },
+            cron: {
+                jobs: [
+                    {
+                        id: 'tech-digest',
+                        name: 'Tech Digest',
+                        schedule: { kind: 'cron', expr: '* * * * *', tz: 'UTC' },
+                        payload: {
+                            kind: 'agentTurn',
+                            message: 'digest please',
+                            sendAsVoice: true,
+                        },
+                    },
+                ],
+            },
+        };
+        await runCronJob('tech-digest', voiceConfig);
+        expect(synthesizeSpeechMock).toHaveBeenCalledWith(digestText, voiceConfig.voice);
+        expect(sendActiveChannelProactiveMessageMock).toHaveBeenCalled();
+    });
+});

package/dist/__tests__/cron.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseDualOutput, validatePrReviewOutput } from '../cron.js';
+import { isRetryableCronAgentError, parseDualOutput } from '../cron.js';
 describe('parseDualOutput', () => {
     it('returns full response as text when no delimiters present', () => {
         const response = 'Hello, this is a regular response with no delimiters.';
@@ -64,43 +64,6 @@ Voice content here
         expect(result.text).toBe(fullResponse);
     });
 });
-describe('validatePrReviewOutput', () => {
-    it('returns null for NO_CANDIDATES result', () => {
-        const output = 'No PRs found.\n[PR_REVIEW_RESULT: NO_CANDIDATES]';
-        expect(validatePrReviewOutput(output)).toBeNull();
-    });
-    it('returns null when candidates were reviewed with code_with_agent', () => {
-        const output = 'Reviewed 3 PRs.\n[PR_REVIEW_RESULT: CANDIDATES=3 CODE_AGENT_CALLS=3 BLOCKED=0]';
-        expect(validatePrReviewOutput(output)).toBeNull();
-    });
-    it('returns null when all candidates are blocked', () => {
-        const output = 'All blocked.\n[PR_REVIEW_RESULT: CANDIDATES=2 CODE_AGENT_CALLS=0 BLOCKED=2]';
-        expect(validatePrReviewOutput(output)).toBeNull();
-    });
-    it('returns alert when candidates exist but no code_with_agent calls', () => {
-        const output = 'Inline review.\n[PR_REVIEW_RESULT: CANDIDATES=3 CODE_AGENT_CALLS=0 BLOCKED=0]';
-        const result = validatePrReviewOutput(output);
-        expect(result).not.toBeNull();
-        expect(result).toContain('code_with_agent was never called');
-        expect(result).toContain('3 PR candidate');
-    });
-    it('returns alert when result line is missing entirely', () => {
-        const output = 'The agent just rambled about PRs without following the prompt.';
-        const result = validatePrReviewOutput(output);
-        expect(result).not.toBeNull();
-        expect(result).toContain('Missing [PR_REVIEW_RESULT]');
-    });
-    it('returns null when some candidates reviewed and some blocked', () => {
-        const output = '[PR_REVIEW_RESULT: CANDIDATES=4 CODE_AGENT_CALLS=2 BLOCKED=2]';
-        expect(validatePrReviewOutput(output)).toBeNull();
-    });
-    it('returns alert when partially blocked but zero calls', () => {
-        const output = '[PR_REVIEW_RESULT: CANDIDATES=3 CODE_AGENT_CALLS=0 BLOCKED=1]';
-        const result = validatePrReviewOutput(output);
-        expect(result).not.toBeNull();
-        expect(result).toContain('code_with_agent was never called');
-    });
-});
 describe('cron job tool injection', () => {
     it('isCronJob field exists on ExecuteToolContext', () => {
         // Verify the field is part of the type (compile-time check via assignment)
@@ -114,3 +77,14 @@ describe('cron job tool injection', () => {
         expect(ctx.isCronJob).toBeUndefined();
     });
 });
+describe('isRetryableCronAgentError', () => {
+    it('matches transient Codex and provider connectivity failures', () => {
+        expect(isRetryableCronAgentError(new Error('Codex API 503: upstream connect error'))).toBe(true);
+        expect(isRetryableCronAgentError(new Error('remote connection failure: Connection refused'))).toBe(true);
+        expect(isRetryableCronAgentError(new Error('529 {"type":"error","error":{"type":"overloaded_error"}}'))).toBe(true);
+    });
+    it('does not match normal validation errors', () => {
+        expect(isRetryableCronAgentError(new Error('Tool use loop reached maximum iterations'))).toBe(false);
+        expect(isRetryableCronAgentError(new Error('Invalid model selection'))).toBe(false);
+    });
+});

package/dist/__tests__/digests.test.js

@@ -0,0 +1,67 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+const testState = vi.hoisted(() => ({
+    logsDir: '',
+}));
+vi.mock('../config.js', () => ({
+    getLogsDir: () => testState.logsDir,
+}));
+import { saveDigest, getDigest, deleteDigest, getDigestsDir, parseAndSaveDigest } from '../digests.js';
+describe('digests index path resolution', () => {
+    beforeEach(() => {
+        testState.logsDir = fs.mkdtempSync(join(tmpdir(), 'skimpyclaw-digests-'));
+    });
+    afterEach(() => {
+        fs.rmSync(testState.logsDir, { recursive: true, force: true });
+    });
+    it('resolves get/delete by indexed path without scanning directories', () => {
+        const digest = {
+            id: 'tech-digest-deadbeef',
+            jobId: 'tech-digest',
+            jobName: 'Tech Digest',
+            createdAt: '2026-03-08T09:00:00.000Z',
+            articles: [{ id: 'a1', title: 'Story', source: 'Web', url: 'https://example.com' }],
+        };
+        saveDigest(digest);
+        const indexPath = join(getDigestsDir(), 'index.json');
+        const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+        expect(index[digest.id]).toEqual({ jobId: digest.jobId, date: '2026-03-08' });
+        const loaded = getDigest(digest.id);
+        expect(loaded?.id).toBe(digest.id);
+        const deleted = deleteDigest(digest.id);
+        expect(deleted).toBe(true);
+        expect(getDigest(digest.id)).toBeNull();
+    });
+    it('rejects invalid digest ids and stale index entries safely', () => {
+        expect(getDigest('../etc/passwd')).toBeNull();
+        expect(deleteDigest('../etc/passwd')).toBe(false);
+        const indexPath = join(getDigestsDir(), 'index.json');
+        fs.writeFileSync(indexPath, JSON.stringify({
+            'tech-digest-deadbeef': { jobId: '../escape', date: '2026-03-08' },
+        }), 'utf-8');
+        expect(getDigest('tech-digest-deadbeef')).toBeNull();
+        expect(deleteDigest('tech-digest-deadbeef')).toBe(false);
+    });
+    it('does not use markdown section headers as article titles', () => {
+        const digest = parseAndSaveDigest('news-digest', 'News Digest', [
+            '## World Headlines',
+            'https://example.com/world-one',
+            'https://example.com/world-two',
+        ].join('\n'));
+        expect(digest.articles).toHaveLength(2);
+        expect(digest.articles.map(a => a.title)).toEqual(['world one', 'world two']);
+    });
+    it('extracts titles from markdown links in digest output', () => {
+        const digest = parseAndSaveDigest('news-digest', 'News Digest', [
+            '# News Digest',
+            '',
+            '## US Headlines',
+            '1. [Direct article title](https://example.com/news/direct-article) *(Example News)*',
+        ].join('\n'));
+        expect(digest.articles).toHaveLength(1);
+        expect(digest.articles[0]?.title).toBe('Direct article title');
+        expect(digest.articles[0]?.url).toBe('https://example.com/news/direct-article');
+    });
+});

package/dist/__tests__/discord-attachments.test.js

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock pdf-parse before importing the module under test
+const mockGetText = vi.fn();
+const mockDestroy = vi.fn();
+vi.mock('pdf-parse', () => {
+    const MockPDFParse = vi.fn().mockImplementation(function () {
+        this.getText = mockGetText;
+        this.destroy = mockDestroy;
+    });
+    return { PDFParse: MockPDFParse };
+});
+// Mock global fetch
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+import { isDocumentAttachment, processAttachment, processAttachments, supportedExtensions, registerHandler, MAX_ATTACHMENT_BYTES, MAX_TEXT_CHARS, } from '../channels/discord/attachments.js';
+function fakeAttachment(overrides = {}) {
+    return {
+        name: 'test.txt',
+        url: 'https://cdn.discordapp.com/attachments/123/456/test.txt',
+        contentType: 'text/plain',
+        size: 100,
+        ...overrides,
+    };
+}
+function mockFetchOk(content) {
+    const buf = typeof content === 'string' ? Buffer.from(content) : content;
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        arrayBuffer: () => Promise.resolve(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)),
+    });
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+// ── isDocumentAttachment ──────────────────────────────────────────
+describe('isDocumentAttachment', () => {
+    it('returns true for .txt files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'notes.txt', contentType: 'text/plain' }))).toBe(true);
+    });
+    it('returns true for .pdf files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'report.pdf', contentType: 'application/pdf' }))).toBe(true);
+    });
+    it('returns true for .md files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'README.md', contentType: 'text/markdown' }))).toBe(true);
+    });
+    it('returns true for .json files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'data.json', contentType: 'application/json' }))).toBe(true);
+    });
+    it('returns true for source code files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'app.py', contentType: 'text/x-python' }))).toBe(true);
+        expect(isDocumentAttachment(fakeAttachment({ name: 'index.ts', contentType: 'text/typescript' }))).toBe(true);
+    });
+    it('returns false for image files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'photo.jpg', contentType: 'image/jpeg' }))).toBe(false);
+    });
+    it('returns false for audio files', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'voice.ogg', contentType: 'audio/ogg' }))).toBe(false);
+    });
+    it('returns false for unsupported types', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'archive.zip', contentType: 'application/zip' }))).toBe(false);
+    });
+    it('returns false for null content type with unsupported extension', () => {
+        expect(isDocumentAttachment(fakeAttachment({ name: 'file.xyz', contentType: null }))).toBe(false);
+    });
+});
+// ── processAttachment — text files ────────────────────────────────
+describe('processAttachment — text files', () => {
+    it('extracts text from a .txt attachment', async () => {
+        const att = fakeAttachment({ name: 'hello.txt', contentType: 'text/plain', size: 50 });
+        mockFetchOk('Hello, world!');
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(true);
+        expect(result.text).toBe('Hello, world!');
+        expect(result.filename).toBe('hello.txt');
+    });
+    it('extracts text from a .md attachment', async () => {
+        const att = fakeAttachment({ name: 'README.md', contentType: 'text/markdown', size: 30 });
+        mockFetchOk('# Title\n\nSome content');
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(true);
+        expect(result.text).toContain('# Title');
+    });
+    it('truncates text exceeding MAX_TEXT_CHARS', async () => {
+        const att = fakeAttachment({ name: 'big.txt', contentType: 'text/plain', size: 200 });
+        const bigText = 'A'.repeat(MAX_TEXT_CHARS + 500);
+        mockFetchOk(bigText);
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(true);
+        expect(result.text.length).toBeLessThan(bigText.length);
+        expect(result.text).toContain('[... truncated at');
+    });
+});
+// ── processAttachment — PDF files ─────────────────────────────────
+describe('processAttachment — PDF files', () => {
+    it('extracts text from a PDF', async () => {
+        const att = fakeAttachment({ name: 'report.pdf', contentType: 'application/pdf', size: 500 });
+        mockFetchOk(Buffer.from('fake pdf content'));
+        mockGetText.mockResolvedValueOnce({ text: 'Extracted PDF text', pages: [], total: 1 });
+        mockDestroy.mockResolvedValueOnce(undefined);
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(true);
+        expect(result.text).toBe('Extracted PDF text');
+    });
+    it('returns error for image-only PDF', async () => {
+        const att = fakeAttachment({ name: 'scan.pdf', contentType: 'application/pdf', size: 500 });
+        mockFetchOk(Buffer.from('fake'));
+        mockGetText.mockResolvedValueOnce({ text: '', pages: [], total: 1 });
+        mockDestroy.mockResolvedValueOnce(undefined);
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('no extractable text');
+    });
+    it('handles pdf-parse failure gracefully', async () => {
+        const att = fakeAttachment({ name: 'corrupt.pdf', contentType: 'application/pdf', size: 500 });
+        mockFetchOk(Buffer.from('not a real pdf'));
+        mockGetText.mockRejectedValueOnce(new Error('Invalid PDF structure'));
+        mockDestroy.mockResolvedValueOnce(undefined);
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Invalid PDF structure');
+    });
+});
+// ── processAttachment — validation ────────────────────────────────
+describe('processAttachment — validation', () => {
+    it('rejects files exceeding MAX_ATTACHMENT_BYTES', async () => {
+        const att = fakeAttachment({ name: 'huge.txt', contentType: 'text/plain', size: MAX_ATTACHMENT_BYTES + 1 });
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('too large');
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it('rejects unsupported file types', async () => {
+        const att = fakeAttachment({ name: 'archive.zip', contentType: 'application/zip', size: 100 });
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Unsupported file type');
+        expect(result.error).toContain('Supported extensions');
+    });
+    it('handles fetch failure gracefully', async () => {
+        const att = fakeAttachment({ name: 'file.txt', contentType: 'text/plain', size: 100 });
+        mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('HTTP 404');
+    });
+    it('handles network errors gracefully', async () => {
+        const att = fakeAttachment({ name: 'file.txt', contentType: 'text/plain', size: 100 });
+        mockFetch.mockRejectedValueOnce(new Error('Network timeout'));
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Network timeout');
+    });
+    it('handles missing filename gracefully', async () => {
+        const att = fakeAttachment({ name: undefined, contentType: 'text/plain', size: 100 });
+        const result = await processAttachment(att);
+        expect(result.filename).toBe('unknown');
+    });
+});
+// ── processAttachments (batch) ────────────────────────────────────
+describe('processAttachments', () => {
+    it('processes multiple attachments concurrently', async () => {
+        const att1 = fakeAttachment({ name: 'a.txt', contentType: 'text/plain', size: 10 });
+        const att2 = fakeAttachment({ name: 'b.txt', contentType: 'text/plain', size: 10 });
+        mockFetchOk('File A');
+        mockFetchOk('File B');
+        const results = await processAttachments([att1, att2]);
+        expect(results).toHaveLength(2);
+        expect(results[0].ok).toBe(true);
+        expect(results[0].text).toBe('File A');
+        expect(results[1].ok).toBe(true);
+        expect(results[1].text).toBe('File B');
+    });
+    it('returns mixed results when some fail', async () => {
+        const att1 = fakeAttachment({ name: 'ok.txt', contentType: 'text/plain', size: 10 });
+        const att2 = fakeAttachment({ name: 'huge.txt', contentType: 'text/plain', size: MAX_ATTACHMENT_BYTES + 1 });
+        mockFetchOk('Good file');
+        const results = await processAttachments([att1, att2]);
+        expect(results[0].ok).toBe(true);
+        expect(results[1].ok).toBe(false);
+        expect(results[1].error).toContain('too large');
+    });
+});
+// ── supportedExtensions ───────────────────────────────────────────
+describe('supportedExtensions', () => {
+    it('includes txt and pdf', () => {
+        const exts = supportedExtensions();
+        expect(exts).toContain('txt');
+        expect(exts).toContain('pdf');
+        expect(exts).toContain('md');
+    });
+    it('returns sorted list', () => {
+        const exts = supportedExtensions();
+        const sorted = [...exts].sort();
+        expect(exts).toEqual(sorted);
+    });
+});
+// ── registerHandler ───────────────────────────────────────────────
+describe('registerHandler', () => {
+    it('allows registering custom handlers', async () => {
+        registerHandler({
+            extensions: ['custom'],
+            mimeTypes: ['application/x-custom'],
+            extract: async (buffer) => `CUSTOM: ${buffer.toString('utf-8')}`,
+        });
+        const att = fakeAttachment({ name: 'data.custom', contentType: 'application/x-custom', size: 10 });
+        mockFetchOk('raw data');
+        const result = await processAttachment(att);
+        expect(result.ok).toBe(true);
+        expect(result.text).toBe('CUSTOM: raw data');
+    });
+});

package/dist/__tests__/discord-docs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/discord-docs.test.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+const repoRoot = process.cwd();
+function read(relativePath) {
+    return readFileSync(resolve(repoRoot, relativePath), 'utf8');
+}
+describe('discord documentation maintenance', () => {
+    it('keeps Discord process and changelog docs present and linked from README', () => {
+        const processDocPath = 'docs/guide/discord-updates.md';
+        const changelogPath = 'docs/guide/changelog.md';
+        expect(existsSync(resolve(repoRoot, processDocPath))).toBe(true);
+        expect(existsSync(resolve(repoRoot, changelogPath))).toBe(true);
+        const readme = read('README.md');
+        expect(readme).toContain(`[${processDocPath}](${processDocPath})`);
+        expect(readme).toContain(`[${changelogPath}](${changelogPath})`);
+    });
+    it('documents required Discord update recording steps', () => {
+        const processDoc = read('docs/guide/discord-updates.md');
+        const changelog = read('docs/guide/changelog.md');
+        expect(processDoc).toContain('## Required Documentation Updates');
+        expect(processDoc).toContain('docs/guide/changelog.md');
+        expect(processDoc).toContain('## Validation Checklist');
+        expect(changelog).toContain('## Unreleased');
+        expect(changelog).toContain('Discord:');
+    });
+});

package/dist/__tests__/discord-thread-agents.test.d.ts

@@ -0,0 +1 @@
+export {};