discoclaw 0.1.0

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

@@ -0,0 +1,187 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createMessageCreateHandler } from './discord.js';
+function makeQueue() {
+    return {
+        run: vi.fn(async (_key, fn) => fn()),
+    };
+}
+function makeMsg(overrides = {}) {
+    const replyObj = { edit: vi.fn(async () => { }) };
+    return {
+        author: { id: '123', bot: false, displayName: 'User', username: 'user' },
+        guildId: 'guild',
+        channelId: 'chan',
+        channel: { send: vi.fn(async () => { }), isThread: () => false, name: 'general' },
+        content: 'hello',
+        reply: vi.fn(async () => replyObj),
+        id: 'msg1',
+        ...overrides,
+    };
+}
+function baseParams(runtimeOverride) {
+    return {
+        allowUserIds: new Set(['123']),
+        botDisplayName: 'TestBot',
+        runtime: runtimeOverride,
+        sessionManager: { getOrCreate: vi.fn(async () => 'sess') },
+        workspaceCwd: '/tmp',
+        projectCwd: '/tmp',
+        groupsDir: '/tmp',
+        useGroupDirCwd: false,
+        runtimeModel: 'opus',
+        runtimeTools: [],
+        runtimeTimeoutMs: 1000,
+        requireChannelContext: false,
+        autoIndexChannelContext: false,
+        autoJoinThreads: false,
+        useRuntimeSessions: true,
+        discordActionsEnabled: false,
+        discordActionsChannels: true,
+        discordActionsMessaging: false,
+        discordActionsGuild: false,
+        discordActionsModeration: false,
+        discordActionsPolls: false,
+        discordActionsTasks: false,
+        discordActionsBotProfile: false,
+        messageHistoryBudget: 0,
+        summaryEnabled: false,
+        summaryModel: 'haiku',
+        summaryMaxChars: 2000,
+        summaryEveryNTurns: 5,
+        summaryDataDir: '/tmp/summaries',
+        summaryToDurableEnabled: false,
+        shortTermMemoryEnabled: false,
+        shortTermDataDir: '/tmp/shortterm',
+        shortTermMaxEntries: 20,
+        shortTermMaxAgeMs: 21600000,
+        shortTermInjectMaxChars: 1000,
+        durableMemoryEnabled: false,
+        durableDataDir: '/tmp/durable',
+        durableInjectMaxChars: 2000,
+        durableMaxItems: 200,
+        memoryCommandsEnabled: false,
+        actionFollowupDepth: 0,
+        reactionHandlerEnabled: false,
+        reactionRemoveHandlerEnabled: false,
+        reactionMaxAgeMs: 86400000,
+        streamStallWarningMs: 0,
+    };
+}
+function mockStatus() {
+    return {
+        online: vi.fn(async () => { }),
+        offline: vi.fn(async () => { }),
+        runtimeError: vi.fn(async () => { }),
+        handlerError: vi.fn(async () => { }),
+        actionFailed: vi.fn(async () => { }),
+        taskSyncComplete: vi.fn(async () => { }),
+    };
+}
+describe('status wiring in message handler', () => {
+    it('calls runtimeError when runtime emits an error event', async () => {
+        const runtime = {
+            invoke: async function* () {
+                yield { type: 'error', message: 'timed out' };
+            },
+        };
+        const status = mockStatus();
+        const statusRef = { current: status };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue(), statusRef);
+        await handler(makeMsg());
+        expect(status.runtimeError).toHaveBeenCalledOnce();
+        expect(status.runtimeError).toHaveBeenCalledWith(expect.objectContaining({ sessionKey: expect.any(String) }), 'timed out');
+    });
+    it('calls handlerError when an exception is thrown', async () => {
+        const runtime = {
+            invoke: async function* () {
+                throw new Error('kaboom');
+            },
+        };
+        const status = mockStatus();
+        const statusRef = { current: status };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue(), statusRef);
+        await handler(makeMsg());
+        expect(status.handlerError).toHaveBeenCalledOnce();
+        expect(status.handlerError).toHaveBeenCalledWith(expect.objectContaining({ sessionKey: expect.any(String) }), expect.any(Error));
+    });
+    it('cleans up streaming keepalive timer when invoke throws', async () => {
+        vi.useFakeTimers();
+        const setIntervalSpy = vi.spyOn(globalThis, 'setInterval');
+        const clearIntervalSpy = vi.spyOn(globalThis, 'clearInterval');
+        try {
+            const runtime = {
+                invoke: async function* () {
+                    throw new Error('kaboom');
+                },
+            };
+            const status = mockStatus();
+            const statusRef = { current: status };
+            const handler = createMessageCreateHandler(baseParams(runtime), makeQueue(), statusRef);
+            await handler(makeMsg());
+            expect(setIntervalSpy).toHaveBeenCalled();
+            const keepaliveHandle = setIntervalSpy.mock.results.find((r) => r.type === 'return')?.value;
+            expect(keepaliveHandle).toBeDefined();
+            expect(clearIntervalSpy).toHaveBeenCalledWith(keepaliveHandle);
+            expect(status.handlerError).toHaveBeenCalledOnce();
+        }
+        finally {
+            setIntervalSpy.mockRestore();
+            clearIntervalSpy.mockRestore();
+            vi.useRealTimers();
+        }
+    });
+    it('does not call status methods when statusRef.current is null', async () => {
+        const runtime = {
+            invoke: async function* () {
+                yield { type: 'error', message: 'oops' };
+            },
+        };
+        const statusRef = { current: null };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue(), statusRef);
+        // Should not throw even though status is null.
+        await expect(handler(makeMsg())).resolves.toBeUndefined();
+    });
+    it('does not call status methods when statusRef is omitted', async () => {
+        const runtime = {
+            invoke: async function* () {
+                yield { type: 'error', message: 'oops' };
+            },
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await expect(handler(makeMsg())).resolves.toBeUndefined();
+    });
+    it('swallows 50083 (thread archived) without calling handlerError', async () => {
+        const runtime = {
+            invoke: async function* () {
+                yield { type: 'text_final', text: 'Done' };
+            },
+        };
+        const status = mockStatus();
+        const statusRef = { current: status };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue(), statusRef);
+        // Make reply.edit throw a Discord 50083 "Thread is archived" error.
+        const err50083 = Object.assign(new Error('Thread is archived'), { code: 50083 });
+        const replyObj = { edit: vi.fn().mockRejectedValue(err50083), delete: vi.fn(async () => { }) };
+        const msg = makeMsg();
+        msg.reply = vi.fn(async () => replyObj);
+        await handler(msg);
+        expect(status.handlerError).not.toHaveBeenCalled();
+    });
+    it('still calls handlerError for non-50083 Discord errors', async () => {
+        const runtime = {
+            invoke: async function* () {
+                yield { type: 'text_final', text: 'Done' };
+            },
+        };
+        const status = mockStatus();
+        const statusRef = { current: status };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue(), statusRef);
+        // A different Discord error (e.g. Missing Permissions = 50013).
+        const err50013 = Object.assign(new Error('Missing Permissions'), { code: 50013 });
+        const replyObj = { edit: vi.fn().mockRejectedValue(err50013) };
+        const msg = makeMsg();
+        msg.reply = vi.fn(async () => replyObj);
+        await handler(msg);
+        expect(status.handlerError).toHaveBeenCalledOnce();
+    });
+});

package/dist/engine/claudeCli.js

@@ -0,0 +1,137 @@
+import { execa } from 'execa';
+function extractTextFromUnknownEvent(evt) {
+    if (!evt || typeof evt !== 'object')
+        return null;
+    const anyEvt = evt;
+    const candidates = [
+        anyEvt.text,
+        anyEvt.delta,
+        anyEvt.content,
+        // Sometimes nested.
+        (anyEvt.data && typeof anyEvt.data === 'object') ? anyEvt.data.text : undefined,
+    ];
+    for (const c of candidates) {
+        if (typeof c === 'string' && c.length > 0)
+            return c;
+    }
+    return null;
+}
+function* textAsChunks(text) {
+    if (!text)
+        return;
+    yield { type: 'text_final', text };
+    yield { type: 'done' };
+}
+export function createClaudeCliRuntime(opts) {
+    const capabilities = new Set([
+        'streaming_text',
+        'sessions',
+        'workspace_instructions',
+        'tools_exec',
+        'tools_fs',
+        'tools_web',
+        'mcp',
+    ]);
+    async function* invoke(params) {
+        const args = ['-p', '--model', params.model];
+        if (opts.dangerouslySkipPermissions) {
+            args.push('--dangerously-skip-permissions');
+        }
+        if (params.sessionId) {
+            args.push('--session-id', params.sessionId);
+        }
+        if (opts.outputFormat) {
+            args.push('--output-format', opts.outputFormat);
+        }
+        if (opts.outputFormat === 'stream-json') {
+            args.push('--include-partial-messages');
+        }
+        // Tool flags are runtime-specific; keep optional and configurable.
+        if (params.tools && params.tools.length > 0) {
+            // `--tools` accepts a comma-separated list for built-in tools.
+            // We keep this simple; if we need finer control, add --allowedTools/--disallowedTools.
+            args.push('--tools', params.tools.join(','));
+        }
+        args.push(params.prompt);
+        const subprocess = execa(opts.claudeBin, args, {
+            cwd: params.cwd,
+            timeout: params.timeoutMs,
+            reject: false,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        if (!subprocess.stdout) {
+            yield { type: 'error', message: 'claude: missing stdout stream' };
+            yield { type: 'done' };
+            return;
+        }
+        if (opts.outputFormat === 'text') {
+            const { stdout, stderr, exitCode } = await subprocess;
+            if (exitCode !== 0) {
+                const msg = (stderr || stdout || `claude exit ${exitCode}`).trim();
+                yield { type: 'error', message: msg };
+                yield { type: 'done' };
+                return;
+            }
+            yield* textAsChunks(stdout.trimEnd());
+            return;
+        }
+        // stream-json: parse line-delimited JSON events.
+        let buffered = '';
+        subprocess.stdout.on('data', (chunk) => {
+            buffered += String(chunk);
+        });
+        // Consume progressively while the process runs.
+        while (subprocess.exitCode == null) {
+            await new Promise((r) => setTimeout(r, 75));
+            const lines = buffered.split(/\r?\n/);
+            buffered = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const evt = JSON.parse(trimmed);
+                    const text = extractTextFromUnknownEvent(evt);
+                    if (text) {
+                        yield { type: 'text_delta', text };
+                    }
+                }
+                catch {
+                    // If CLI prints non-JSON noise, treat it as text.
+                    yield { type: 'text_delta', text: trimmed };
+                }
+            }
+        }
+        const { stdout, stderr, exitCode } = await subprocess;
+        if (exitCode !== 0) {
+            yield { type: 'error', message: (stderr || stdout || `claude exit ${exitCode}`).trim() };
+            yield { type: 'done' };
+            return;
+        }
+        // Flush any trailing buffered line.
+        const tail = buffered.trim();
+        if (tail) {
+            try {
+                const evt = JSON.parse(tail);
+                const text = extractTextFromUnknownEvent(evt);
+                if (text)
+                    yield { type: 'text_delta', text };
+            }
+            catch {
+                yield { type: 'text_delta', text: tail };
+            }
+        }
+        // Provide a final merged text as well, based on what the CLI returned.
+        // (This makes Discord output stable even if the event model changes.)
+        if (stdout.trim()) {
+            yield { type: 'text_final', text: stdout.trimEnd() };
+        }
+        yield { type: 'done' };
+    }
+    return {
+        id: 'claude_code',
+        capabilities,
+        invoke,
+    };
+}

package/dist/engine/types.js

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

package/dist/group-queue.js

@@ -0,0 +1,25 @@
+export class KeyedQueue {
+    tails = new Map();
+    size() {
+        return this.tails.size;
+    }
+    async run(key, fn) {
+        const prev = this.tails.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise((r) => {
+            release = r;
+        });
+        const tail = prev.then(() => current, () => current);
+        this.tails.set(key, tail);
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.tails.get(key) === tail) {
+                this.tails.delete(key);
+            }
+        }
+    }
+}

package/dist/health/credential-check.js

@@ -0,0 +1,175 @@
+import fs from 'node:fs/promises';
+const DISCORD_API_BASE = 'https://discord.com/api/v10';
+const OPENAI_API_DEFAULT_BASE = 'https://api.openai.com/v1';
+const OPENROUTER_API_DEFAULT_BASE = 'https://openrouter.ai/api/v1';
+// Credentials in this set gate core bot functionality; failure is surfaced prominently.
+const CRITICAL = new Set(['discord-token']);
+/**
+ * Validate the Discord bot token by calling GET /users/@me.
+ * Always resolves — returns a 'fail' result on network error instead of throwing.
+ */
+export async function checkDiscordToken(token) {
+    const name = 'discord-token';
+    try {
+        const res = await fetch(`${DISCORD_API_BASE}/users/@me`, {
+            headers: { Authorization: `Bot ${token}` },
+        });
+        if (res.ok) {
+            return { name, status: 'ok' };
+        }
+        if (res.status === 401) {
+            return { name, status: 'fail', message: 'invalid or revoked token (401)' };
+        }
+        return { name, status: 'fail', message: `unexpected status ${res.status}` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name, status: 'fail', message: `network error: ${msg}` };
+    }
+}
+/**
+ * Validate the OpenAI API key by calling GET /models on the configured base URL.
+ * Returns 'skip' when no key is configured.
+ * Always resolves — returns a 'fail' result on network error instead of throwing.
+ */
+export async function checkOpenAiKey(opts) {
+    const name = 'openai-key';
+    const { apiKey, baseUrl } = opts;
+    if (!apiKey) {
+        return { name, status: 'skip' };
+    }
+    const base = (baseUrl ?? OPENAI_API_DEFAULT_BASE).replace(/\/$/, '');
+    try {
+        const res = await fetch(`${base}/models`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (res.ok) {
+            return { name, status: 'ok' };
+        }
+        if (res.status === 401) {
+            return { name, status: 'fail', message: 'invalid or expired key (401)' };
+        }
+        if (res.status === 403) {
+            return { name, status: 'fail', message: 'key lacks required permissions (403)' };
+        }
+        return { name, status: 'fail', message: `unexpected status ${res.status}` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name, status: 'fail', message: `network error: ${msg}` };
+    }
+}
+/**
+ * Validate the OpenRouter API key by calling GET /models on the configured base URL.
+ * Returns 'skip' when no key is configured.
+ * Always resolves — returns a 'fail' result on network error instead of throwing.
+ */
+export async function checkOpenRouterKey(opts) {
+    const name = 'openrouter-key';
+    const { apiKey, baseUrl } = opts;
+    if (!apiKey) {
+        return { name, status: 'skip' };
+    }
+    const base = (baseUrl ?? OPENROUTER_API_DEFAULT_BASE).replace(/\/$/, '');
+    try {
+        const res = await fetch(`${base}/models`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (res.ok) {
+            return { name, status: 'ok' };
+        }
+        if (res.status === 401) {
+            return { name, status: 'fail', message: 'invalid or expired key (401)' };
+        }
+        if (res.status === 403) {
+            return { name, status: 'fail', message: 'key lacks required permissions (403)' };
+        }
+        return { name, status: 'fail', message: `unexpected status ${res.status}` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name, status: 'fail', message: `network error: ${msg}` };
+    }
+}
+/**
+ * Check that the workspace path exists and is read/write accessible.
+ * Returns 'skip' if no path is provided.
+ * Always resolves — returns a 'fail' result on access error instead of throwing.
+ */
+export async function checkWorkspacePath(workspacePath) {
+    const name = 'workspace-path';
+    if (!workspacePath) {
+        return { name, status: 'skip' };
+    }
+    try {
+        await fs.access(workspacePath, fs.constants.R_OK | fs.constants.W_OK);
+        return { name, status: 'ok' };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name, status: 'fail', message: `workspace not accessible: ${msg}` };
+    }
+}
+/**
+ * Validate that a status channel is configured (either a name or Discord snowflake ID).
+ * Returns 'skip' if no channel is configured.
+ */
+export function checkStatusChannel(channelId) {
+    const name = 'status-channel';
+    if (!channelId) {
+        return { name, status: 'skip', message: 'not configured' };
+    }
+    return { name, status: 'ok' };
+}
+/**
+ * Run all credential checks concurrently and return a structured report.
+ * Never throws — individual validators are responsible for their own error handling.
+ *
+ * When `activeProviders` is provided, the OpenAI key check is only run if
+ * `'openai'` is in the set; otherwise the result is omitted from the report
+ * entirely. The OpenRouter key check is only run if `'openrouter'` is in the
+ * set; otherwise the result is omitted from the report entirely. The Discord
+ * token check always runs. If `activeProviders` is omitted, the current
+ * behavior is preserved (OpenAI check runs as normal).
+ */
+export async function runCredentialChecks(opts) {
+    const runOpenAi = opts.activeProviders === undefined || opts.activeProviders.has('openai');
+    const runOpenRouter = opts.activeProviders !== undefined && opts.activeProviders.has('openrouter');
+    const [discordResult, openaiResult, openrouterResult, workspaceResult, statusResult] = await Promise.all([
+        checkDiscordToken(opts.token),
+        runOpenAi
+            ? checkOpenAiKey({ apiKey: opts.openaiApiKey, baseUrl: opts.openaiBaseUrl })
+            : null,
+        runOpenRouter
+            ? checkOpenRouterKey({ apiKey: opts.openrouterApiKey, baseUrl: opts.openrouterBaseUrl })
+            : null,
+        checkWorkspacePath(opts.workspacePath),
+        Promise.resolve(checkStatusChannel(opts.statusChannelId)),
+    ]);
+    const results = [discordResult];
+    if (openaiResult !== null)
+        results.push(openaiResult);
+    if (openrouterResult !== null)
+        results.push(openrouterResult);
+    results.push(workspaceResult, statusResult);
+    const criticalFailures = results
+        .filter((r) => r.status === 'fail' && CRITICAL.has(r.name))
+        .map((r) => r.name);
+    const allOk = results.every((r) => r.status === 'ok' || r.status === 'skip');
+    return { results, criticalFailures, allOk };
+}
+/**
+ * Format a credential check report into a compact, single-line string
+ * suitable for inclusion in the boot report posted to the status channel.
+ *
+ * Example: "discord-token: ok, openai-key: FAIL (invalid or expired key (401))"
+ */
+export function formatCredentialReport(report) {
+    return report.results
+        .map((r) => {
+        const tag = r.status === 'ok' ? 'ok' : r.status === 'skip' ? 'skip' : 'FAIL';
+        const detail = r.message ? ` (${r.message})` : '';
+        return `${r.name}: ${tag}${detail}`;
+    })
+        .join(', ');
+}