discoclaw 0.1.0

package/dist/discord/status-channel.test.js

@@ -0,0 +1,282 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createStatusPoster, sanitizeErrorMessage, sanitizePhaseError } from './status-channel.js';
+function mockChannel() {
+    return { send: vi.fn().mockResolvedValue(undefined) };
+}
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+function sentContent(ch, callIndex = 0) {
+    const arg = ch.send.mock.calls[callIndex][0];
+    return arg.content;
+}
+describe('createStatusPoster', () => {
+    it('online() sends a plain text Bot Online message', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.online();
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Bot Online**');
+        expect(msg).toContain('connected and ready');
+    });
+    it('online() suppresses mentions via NO_MENTIONS', async () => {
+        const ch = mockChannel();
+        await createStatusPoster(ch).online();
+        const arg = ch.send.mock.calls[0][0];
+        expect(arg.allowedMentions).toEqual({ parse: [] });
+    });
+    it('offline() sends a plain text Bot Offline message', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.offline();
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Bot Offline**');
+        expect(msg).toContain('shutting down');
+    });
+    it('runtimeError() sends plain text with session and channel context', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.runtimeError({ sessionKey: 'dm:123', channelName: 'general' }, 'timeout');
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Runtime Error**');
+        expect(msg).toContain('dm:123');
+        expect(msg).toContain('general');
+        expect(msg).toContain('timeout');
+    });
+    it('handlerError() sends plain text with error content', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.handlerError({ sessionKey: 'g:1:c:2' }, new Error('boom'));
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Handler Failure**');
+        expect(msg).toContain('boom');
+    });
+    it('handlerError() sanitizes messages containing prompt content', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        const leakyErr = new Error('Command was killed with SIGKILL (Forced termination): claude -p "You are a helpful assistant..."');
+        await poster.handlerError({ sessionKey: 'g:1:c:2' }, leakyErr);
+        const msg = sentContent(ch);
+        expect(msg).not.toContain('claude -p');
+        expect(msg).toContain('SIGKILL');
+    });
+    it('actionFailed() sends plain text with action type and error', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.actionFailed('channelCreate', 'Missing perms');
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Action Failed**');
+        expect(msg).toContain('channelCreate');
+        expect(msg).toContain('Missing perms');
+    });
+    it('taskSyncComplete() sends plain text with non-zero fields only', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.taskSyncComplete({
+            threadsCreated: 1, emojisUpdated: 0, starterMessagesUpdated: 2, threadsArchived: 3, statusesUpdated: 0, tagsUpdated: 0, warnings: 0,
+        });
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Task Sync Complete**');
+        expect(msg).toContain('Created: 1');
+        expect(msg).toContain('Starters Updated: 2');
+        expect(msg).toContain('Archived: 3');
+        expect(msg).not.toContain('Names Updated');
+        expect(msg).not.toContain('Statuses Fixed');
+        expect(msg).not.toContain('Warnings');
+    });
+    it('taskSyncComplete() includes warnings when > 0', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.taskSyncComplete({
+            threadsCreated: 0, emojisUpdated: 0, starterMessagesUpdated: 0, threadsArchived: 0, statusesUpdated: 0, tagsUpdated: 0, warnings: 2,
+        });
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('**Task Sync Complete**');
+        expect(msg).toContain('Warnings: 2');
+    });
+    it('taskSyncComplete() includes all non-zero counters and warnings together', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.taskSyncComplete({
+            threadsCreated: 2, emojisUpdated: 0, starterMessagesUpdated: 0, threadsArchived: 1, statusesUpdated: 0, tagsUpdated: 0, warnings: 1,
+        });
+        expect(ch.send).toHaveBeenCalledOnce();
+        const msg = sentContent(ch);
+        expect(msg).toContain('Created: 2');
+        expect(msg).toContain('Archived: 1');
+        expect(msg).toContain('Warnings: 1');
+    });
+    it('taskSyncComplete() is silent when all counters and warnings are zero', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.taskSyncComplete({
+            threadsCreated: 0, emojisUpdated: 0, starterMessagesUpdated: 0, threadsArchived: 0, statusesUpdated: 0, tagsUpdated: 0, warnings: 0,
+        });
+        expect(ch.send).not.toHaveBeenCalled();
+    });
+    it('runtimeError() sanitizes messages containing prompt content', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        const leakyMsg = 'Command was killed with SIGKILL (Forced termination): claude -p "You are a helpful assistant called Weston..."';
+        await poster.runtimeError({ sessionKey: 'dm:123' }, leakyMsg);
+        const msg = sentContent(ch);
+        expect(msg).toContain('Command was killed with SIGKILL (Forced termination)');
+        expect(msg).not.toContain('claude -p');
+    });
+    it('does not throw when channel.send fails', async () => {
+        const ch = { send: vi.fn().mockRejectedValue(new Error('network')) };
+        const log = mockLog();
+        const poster = createStatusPoster(ch, { log });
+        await expect(poster.online()).resolves.toBeUndefined();
+        expect(log.warn).toHaveBeenCalledOnce();
+    });
+});
+describe('bootReport', () => {
+    const baseData = {
+        startupType: 'first-boot',
+        tasksEnabled: false,
+        forumResolved: false,
+        cronsEnabled: false,
+        memoryEpisodicOn: false,
+        memorySemanticOn: false,
+        memoryWorkingOn: false,
+        actionCategoriesEnabled: [],
+    };
+    it('includes Credentials line when credentialReport is provided', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData, credentialReport: 'discord-token: ok, openai-key: skip' });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Credentials · discord-token: ok, openai-key: skip');
+    });
+    it('omits Credentials line when credentialReport is absent', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData });
+        const msg = sentContent(ch);
+        expect(msg).not.toContain('Credentials');
+    });
+    it('includes FAIL in the Credentials line when a check failed', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({
+            ...baseData,
+            credentialReport: 'discord-token: FAIL (invalid or revoked token (401)), openai-key: skip',
+        });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Credentials · discord-token: FAIL (invalid or revoked token (401)), openai-key: skip');
+    });
+    it('formats Permissions as "ok (tier)" when permissionsStatus is ok', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData, permissionsStatus: 'ok', permissionsTier: 'full' });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Permissions · ok (full)');
+    });
+    it('formats Permissions as "missing" when permissionsStatus is missing', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData, permissionsStatus: 'missing' });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Permissions · missing');
+    });
+    it('formats Permissions as "INVALID (reason)" when permissionsStatus is invalid with reason', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData, permissionsStatus: 'invalid', permissionsReason: 'invalid tier: "godmode"' });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Permissions · INVALID (invalid tier: "godmode")');
+    });
+    it('formats Permissions as "INVALID" without parentheses when no reason is provided', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData, permissionsStatus: 'invalid' });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Permissions · INVALID');
+        expect(msg).not.toContain('(undefined');
+    });
+    it('falls back to tier label when permissionsStatus is absent', async () => {
+        const ch = mockChannel();
+        const poster = createStatusPoster(ch);
+        await poster.bootReport({ ...baseData, permissionsTier: 'standard' });
+        const msg = sentContent(ch);
+        expect(msg).toContain('Permissions · standard');
+    });
+});
+describe('sanitizeErrorMessage', () => {
+    it('passes through short clean messages unchanged', () => {
+        expect(sanitizeErrorMessage('timeout')).toBe('timeout');
+    });
+    it('returns "(no message)" for empty/falsy input', () => {
+        expect(sanitizeErrorMessage('')).toBe('(no message)');
+    });
+    it('strips prompt after "Command was killed with SIGKILL": claude -p ...', () => {
+        const msg = 'Command was killed with SIGKILL (Forced termination): claude -p "You are a helpful..."';
+        expect(sanitizeErrorMessage(msg)).toBe('Command was killed with SIGKILL (Forced termination)');
+    });
+    it('strips prompt after "Command failed with exit code 1": claude -p ...', () => {
+        const msg = 'Command failed with exit code 1: claude -p "big prompt here..."';
+        expect(sanitizeErrorMessage(msg)).toBe('Command failed with exit code 1');
+    });
+    it('strips content when "claude -p" appears mid-message without colon-space separator', () => {
+        const msg = 'Something went wrong while running claude -p "giant prompt"';
+        expect(sanitizeErrorMessage(msg)).toBe('Something went wrong while running');
+    });
+    it('strips prompt with absolute binary path and positional arg (double quotes)', () => {
+        const msg = 'Command was killed with SIGKILL (Forced termination): /usr/local/bin/claude --tools bash -- "You are a helpful assistant..."';
+        expect(sanitizeErrorMessage(msg)).toBe('Command was killed with SIGKILL (Forced termination)');
+    });
+    it('strips prompt with absolute binary path and positional arg (single quotes)', () => {
+        // execa formats args with single quotes in shortMessage
+        const msg = "Command was killed with SIGKILL (Forced termination): /usr/local/bin/claude --tools bash -- 'You are a helpful assistant...'";
+        expect(sanitizeErrorMessage(msg)).toBe('Command was killed with SIGKILL (Forced termination)');
+    });
+    it('strips single-quoted positional prompt when binary name is not "claude"', () => {
+        const msg = "Command was killed with SIGKILL (Forced termination): /opt/mybin --tools bash -- 'You are a helpful assistant...'";
+        expect(sanitizeErrorMessage(msg)).not.toContain('You are a helpful');
+    });
+    it('truncates long messages to 500 chars', () => {
+        const long = 'x'.repeat(1000);
+        expect(sanitizeErrorMessage(long).length).toBe(500);
+    });
+});
+describe('sanitizePhaseError', () => {
+    it('formats timeout using ms from error string when no timeoutMs provided', () => {
+        const raw = 'Process timed out after 120000ms';
+        expect(sanitizePhaseError('3', raw)).toBe('Phase **3** timed out after 2 minutes');
+    });
+    it('uses provided timeoutMs over value in error string', () => {
+        const raw = 'Process timed out after 60000ms';
+        expect(sanitizePhaseError('2', raw, 300000)).toBe('Phase **2** timed out after 5 minutes');
+    });
+    it('uses singular "minute" when timeout is exactly 1 minute', () => {
+        const raw = 'timed out after 60000ms';
+        expect(sanitizePhaseError('1', raw)).toBe('Phase **1** timed out after 1 minute');
+    });
+    it('falls back to seconds when timeout is under 1 minute', () => {
+        const raw = 'timed out after 30000ms';
+        expect(sanitizePhaseError('1', raw)).toBe('Phase **1** timed out after 30 seconds');
+    });
+    it('wraps non-timeout errors with "Phase X failed:" prefix', () => {
+        const raw = 'Command was killed with SIGKILL (Forced termination): claude -p "You are..."';
+        const result = sanitizePhaseError('4', raw);
+        expect(result).not.toContain('claude -p');
+        expect(result).toContain('SIGKILL');
+        expect(result).toMatch(/^Phase \*\*4\*\* failed:/);
+    });
+    it('truncates output to 500 chars', () => {
+        const raw = 'x'.repeat(1000);
+        expect(sanitizePhaseError('1', raw).length).toBe(500);
+    });
+    it('handles case-insensitive timeout pattern', () => {
+        const raw = 'Timed Out After 90000ms';
+        expect(sanitizePhaseError('5', raw)).toBe('Phase **5** timed out after 2 minutes');
+    });
+});

package/dist/discord/status-command.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { checkDiscordToken, checkOpenAiKey, checkOpenRouterKey } from '../health/credential-check.js';
+const DEFAULT_API_CHECK_TIMEOUT_MS = 5000;
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+export function parseStatusCommand(content) {
+    const normalized = String(content ?? '').trim().toLowerCase().replace(/\s+/g, ' ');
+    if (normalized === '!status')
+        return true;
+    return null;
+}
+/**
+ * Race an API credential check against a timeout sentinel.
+ * Returns a 'fail' result if the check doesn't resolve within `timeoutMs`.
+ */
+function withApiTimeout(promise, timeoutMs, name) {
+    const timeout = new Promise((resolve) => {
+        const t = setTimeout(() => resolve({ name, status: 'fail', message: `check timed out after ${timeoutMs}ms` }), timeoutMs);
+        // Don't block the Node.js event loop exit while this timer is pending.
+        if (typeof t === 'object' && t !== null && typeof t.unref === 'function') {
+            t.unref();
+        }
+    });
+    return Promise.race([promise, timeout]);
+}
+async function countDurableItems(dir) {
+    let total = 0;
+    try {
+        const files = await fs.readdir(dir);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fs.readFile(path.join(dir, file), 'utf8');
+                const parsed = JSON.parse(raw);
+                if (parsed &&
+                    typeof parsed === 'object' &&
+                    'items' in parsed &&
+                    Array.isArray(parsed.items)) {
+                    total += parsed.items.filter((i) => i?.status === 'active').length;
+                }
+            }
+            catch {
+                // skip malformed files
+            }
+        }
+    }
+    catch {
+        // dir missing or unreadable
+    }
+    return total;
+}
+async function countRollingSummaryChars(dir) {
+    let total = 0;
+    try {
+        const files = await fs.readdir(dir);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fs.readFile(path.join(dir, file), 'utf8');
+                const parsed = JSON.parse(raw);
+                if (parsed &&
+                    typeof parsed === 'object' &&
+                    'summary' in parsed &&
+                    typeof parsed.summary === 'string') {
+                    total += parsed.summary.length;
+                }
+            }
+            catch {
+                // skip malformed files
+            }
+        }
+    }
+    catch {
+        // dir missing or unreadable
+    }
+    return total;
+}
+async function checkPaFiles(filePaths) {
+    return Promise.all(filePaths.map(async ({ label, path: filePath }) => {
+        try {
+            await fs.stat(filePath);
+            return { label, exists: true };
+        }
+        catch {
+            return { label, exists: false };
+        }
+    }));
+}
+export async function collectStatusSnapshot(opts) {
+    const now = Date.now();
+    const apiCheckTimeoutMs = opts.apiCheckTimeoutMs ?? DEFAULT_API_CHECK_TIMEOUT_MS;
+    const [durableItemCount, rollingSummaryCharCount, apiChecks, paFiles] = await Promise.all([
+        opts.durableDataDir ? countDurableItems(opts.durableDataDir) : Promise.resolve(0),
+        opts.summaryDataDir ? countRollingSummaryChars(opts.summaryDataDir) : Promise.resolve(0),
+        (async () => {
+            const checks = [
+                withApiTimeout(checkDiscordToken(opts.discordToken), apiCheckTimeoutMs, 'discord-token'),
+            ];
+            const runOpenAi = opts.activeProviders === undefined || opts.activeProviders.has('openai');
+            if (runOpenAi) {
+                checks.push(withApiTimeout(checkOpenAiKey({ apiKey: opts.openaiApiKey, baseUrl: opts.openaiBaseUrl }), apiCheckTimeoutMs, 'openai-key'));
+            }
+            const runOpenRouter = opts.activeProviders !== undefined && opts.activeProviders.has('openrouter');
+            if (runOpenRouter) {
+                checks.push(withApiTimeout(checkOpenRouterKey({ apiKey: opts.openrouterApiKey, baseUrl: opts.openrouterBaseUrl }), apiCheckTimeoutMs, 'openrouter-key'));
+            }
+            return Promise.all(checks);
+        })(),
+        checkPaFiles(opts.paFilePaths),
+    ]);
+    return {
+        uptimeMs: now - opts.startedAt,
+        lastMessageAt: opts.lastMessageAt,
+        crons: opts.scheduler?.listJobs() ?? [],
+        openTaskCount: opts.taskStore?.list().length ?? 0,
+        durableItemCount,
+        rollingSummaryCharCount,
+        apiChecks,
+        paFiles,
+    };
+}
+// ---------------------------------------------------------------------------
+// Renderer
+// ---------------------------------------------------------------------------
+function formatUptime(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = seconds % 60;
+    return `${h}h ${m}m ${s}s`;
+}
+function formatTimeAgo(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}
+function formatNextRun(date) {
+    const diff = date.getTime() - Date.now();
+    if (diff <= 0)
+        return 'imminent';
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 60)
+        return `in ${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `in ${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `in ${hours}h ${minutes % 60}m`;
+    const days = Math.floor(hours / 24);
+    return `in ${days}d ${hours % 24}h`;
+}
+export function renderStatusReport(snapshot, botDisplayName = 'Discoclaw') {
+    const lines = [];
+    lines.push(`${botDisplayName} Status`);
+    // Uptime & last message
+    lines.push(`Uptime: ${formatUptime(snapshot.uptimeMs)}`);
+    if (snapshot.lastMessageAt !== null) {
+        const agoMs = Date.now() - snapshot.lastMessageAt;
+        lines.push(`Last message: ${formatTimeAgo(agoMs)} ago`);
+    }
+    else {
+        lines.push('Last message: none since startup');
+    }
+    // Crons
+    if (snapshot.crons.length === 0) {
+        lines.push('Crons: none');
+    }
+    else {
+        lines.push(`Crons (${snapshot.crons.length}):`);
+        for (const job of snapshot.crons) {
+            const next = job.nextRun
+                ? formatNextRun(job.nextRun)
+                : job.schedule
+                    ? 'stopped'
+                    : 'manual/webhook';
+            lines.push(`  ${job.name}: next=${next}`);
+        }
+    }
+    // Tasks
+    lines.push(`Open tasks: ${snapshot.openTaskCount}`);
+    // Memory
+    lines.push(`Memory: durable=${snapshot.durableItemCount} items, summaries=${snapshot.rollingSummaryCharCount} chars`);
+    // API connectivity
+    const apiParts = snapshot.apiChecks.map((r) => {
+        const tag = r.status === 'ok' ? 'ok' : r.status === 'skip' ? 'skip' : 'FAIL';
+        const detail = r.message ? ` (${r.message})` : '';
+        return `${r.name}: ${tag}${detail}`;
+    });
+    lines.push(`API: ${apiParts.length > 0 ? apiParts.join(', ') : 'no checks'}`);
+    // Workspace PA files
+    const paAllOk = snapshot.paFiles.length > 0 && snapshot.paFiles.every((f) => f.exists);
+    const paParts = snapshot.paFiles.map((f) => `${f.label}: ${f.exists ? 'ok' : 'MISSING'}`);
+    const paSuffix = paParts.length > 0 ? paParts.join(', ') : 'none configured';
+    lines.push(`Workspace PA: ${paAllOk ? 'ok' : 'DEGRADED'} — ${paSuffix}`);
+    return `\`\`\`text\n${lines.join('\n')}\n\`\`\``;
+}