discoclaw 0.1.0

package/dist/discord/restart-command.js

@@ -0,0 +1,143 @@
+import { execFile } from 'node:child_process';
+import os from 'node:os';
+import { writeShutdownContext } from './shutdown-context.js';
+export function parseRestartCommand(content) {
+    const normalized = content.trim().toLowerCase().replace(/\s+/g, ' ');
+    if (normalized === '!restart')
+        return { action: 'restart' };
+    if (normalized === '!restart status')
+        return { action: 'status' };
+    if (normalized === '!restart logs')
+        return { action: 'logs' };
+    if (normalized === '!restart help')
+        return { action: 'help' };
+    return null;
+}
+function run(cmd, args) {
+    return new Promise((resolve) => {
+        execFile(cmd, args, { timeout: 15_000 }, (err, stdout, stderr) => {
+            const exitCode = err ? err.code ?? null : 0;
+            resolve({
+                stdout: String(stdout ?? ''),
+                stderr: String(stderr ?? ''),
+                exitCode: typeof exitCode === 'number' ? exitCode : null,
+            });
+        });
+    });
+}
+function getPlatformCommands() {
+    if (process.platform === 'linux') {
+        return {
+            statusCmd: ['systemctl', ['--user', 'status', 'discoclaw']],
+            logsCmd: ['journalctl', ['--user', '-u', 'discoclaw', '--no-pager', '-n', '30']],
+            checkActiveCmd: ['systemctl', ['--user', 'status', 'discoclaw']],
+            isActive: (result) => result.stdout.includes('active (running)'),
+            restartCmd: () => ['systemctl', ['--user', 'restart', 'discoclaw']],
+        };
+    }
+    if (process.platform === 'darwin') {
+        const uid = process.getuid?.() ?? 501;
+        const plistPath = `${os.homedir()}/Library/LaunchAgents/com.discoclaw.agent.plist`;
+        const domain = `gui/${uid}`;
+        const label = 'com.discoclaw.agent';
+        return {
+            statusCmd: ['launchctl', ['list', label]],
+            logsCmd: ['log', ['show', '--predicate', 'process == "node"', '--last', '5m', '--style', 'compact']],
+            checkActiveCmd: ['launchctl', ['list', label]],
+            isActive: (result) => result.exitCode === 0,
+            restartCmd: (wasActive) => wasActive
+                ? ['launchctl', ['kickstart', '-k', `${domain}/${label}`]]
+                : ['launchctl', ['bootstrap', domain, plistPath]],
+        };
+    }
+    return null;
+}
+/**
+ * Returns [cmd, args] for restarting the discoclaw service on the current
+ * platform, assuming the service is already running. Falls back to systemctl
+ * on unsupported platforms.
+ */
+export function getRestartCmdArgs() {
+    const pc = getPlatformCommands();
+    if (pc)
+        return pc.restartCmd(true);
+    return ['systemctl', ['--user', 'restart', 'discoclaw']];
+}
+export async function handleRestartCommand(cmd, opts) {
+    // Support both legacy (log) and new (opts bag) signatures.
+    const resolved = opts && typeof opts === 'object' && 'info' in opts
+        ? { log: opts }
+        : opts ?? {};
+    const { log, dataDir, userId, activeForge } = resolved;
+    try {
+        if (cmd.action === 'help') {
+            return {
+                reply: [
+                    '**!restart commands:**',
+                    '- `!restart` — restart the discoclaw service',
+                    '- `!restart status` — show service status',
+                    '- `!restart logs` — show recent logs (last 30 lines)',
+                    '- `!restart help` — this message',
+                ].join('\n'),
+            };
+        }
+        const pc = getPlatformCommands();
+        if (!pc) {
+            return {
+                reply: `!restart is not supported on this platform (${process.platform}). Only Linux (systemd) and macOS (launchd) are supported.`,
+            };
+        }
+        if (cmd.action === 'status') {
+            const result = await run(pc.statusCmd[0], pc.statusCmd[1]);
+            const output = (result.stdout || result.stderr).trim();
+            log?.info({ exitCode: result.exitCode }, 'restart-command:status');
+            return { reply: `\`\`\`\n${output.slice(0, 1800)}\n\`\`\`` };
+        }
+        if (cmd.action === 'logs') {
+            const result = await run(pc.logsCmd[0], pc.logsCmd[1]);
+            const output = (result.stdout || result.stderr).trim();
+            log?.info({}, 'restart-command:logs');
+            return { reply: `\`\`\`\n${output.slice(0, 1800)}\n\`\`\`` };
+        }
+        // action === 'restart'
+        // Check current status for context in the reply.
+        const before = await run(pc.checkActiveCmd[0], pc.checkActiveCmd[1]);
+        const wasActive = pc.isActive(before);
+        log?.info({ wasActive }, 'restart-command:restart');
+        // We can't restart inline — the restart kills this process before
+        // we can reply. Instead, return a deferred function that the caller
+        // invokes *after* sending the reply to Discord.
+        return {
+            reply: wasActive
+                ? 'Restarting discoclaw... back in a moment.'
+                : 'Starting discoclaw...',
+            deferred: () => {
+                // Write shutdown context right before triggering restart so it
+                // doesn't linger if the deferred never fires or restart fails.
+                if (dataDir) {
+                    const ctx = {
+                        reason: 'restart-command',
+                        message: 'User requested via !restart',
+                        timestamp: new Date().toISOString(),
+                        requestedBy: userId,
+                        activeForge,
+                    };
+                    // Synchronous-ish: writeFile + rename, then exec restart.
+                    writeShutdownContext(dataDir, ctx).catch((err) => {
+                        log?.warn({ err }, 'restart-command:failed to write shutdown context');
+                    });
+                }
+                // Fire and forget — the process will die during this call.
+                const [restartBin, restartArgs] = pc.restartCmd(wasActive);
+                execFile(restartBin, restartArgs, (err) => {
+                    // If we somehow survive (e.g., the service unit changed), log it.
+                    if (err)
+                        log?.error({ err }, 'restart-command:restart failed');
+                });
+            },
+        };
+    }
+    catch (err) {
+        return { reply: `Restart command error: ${String(err)}` };
+    }
+}

package/dist/discord/restart-command.test.js

@@ -0,0 +1,196 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { parseRestartCommand, handleRestartCommand } from './restart-command.js';
+import * as shutdownCtx from './shutdown-context.js';
+vi.mock('node:child_process', () => ({
+    execFile: vi.fn((cmd, args, optsOrCb, maybeCb) => {
+        const cb = typeof optsOrCb === 'function' ? optsOrCb : maybeCb;
+        // Simulate systemctl status returning "active (running)"
+        if (args.includes('status')) {
+            cb(null, 'active (running)\n', '');
+        }
+        else if (args.includes('restart')) {
+            cb(null, '', '');
+        }
+        else {
+            // journalctl logs / launchctl list / log show / kickstart / bootstrap
+            cb(null, 'Feb 12 14:00:00 discoclaw[1234]: started\n', '');
+        }
+    }),
+}));
+vi.mock('node:os', () => ({
+    default: {
+        homedir: () => '/Users/testuser',
+    },
+}));
+const savedPlatform = process.platform;
+describe('parseRestartCommand', () => {
+    it('parses !restart as restart action', () => {
+        expect(parseRestartCommand('!restart')).toEqual({ action: 'restart' });
+    });
+    it('parses !restart status', () => {
+        expect(parseRestartCommand('!restart status')).toEqual({ action: 'status' });
+    });
+    it('parses !restart logs', () => {
+        expect(parseRestartCommand('!restart logs')).toEqual({ action: 'logs' });
+    });
+    it('parses !restart help', () => {
+        expect(parseRestartCommand('!restart help')).toEqual({ action: 'help' });
+    });
+    it('returns null for non-restart messages', () => {
+        expect(parseRestartCommand('hello')).toBeNull();
+        expect(parseRestartCommand('!memory show')).toBeNull();
+        expect(parseRestartCommand('!restarting')).toBeNull();
+    });
+    it('is case-insensitive', () => {
+        expect(parseRestartCommand('!RESTART')).toEqual({ action: 'restart' });
+        expect(parseRestartCommand('!Restart Status')).toEqual({ action: 'status' });
+    });
+    it('handles whitespace', () => {
+        expect(parseRestartCommand('  !restart  ')).toEqual({ action: 'restart' });
+        expect(parseRestartCommand('  !restart  status  ')).toEqual({ action: 'status' });
+    });
+});
+describe('handleRestartCommand', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: savedPlatform, configurable: true });
+    });
+    it('help returns usage text without calling execFile', async () => {
+        const { execFile } = await import('node:child_process');
+        const result = await handleRestartCommand({ action: 'help' });
+        expect(result.reply).toContain('!restart commands');
+        expect(result.deferred).toBeUndefined();
+        expect(execFile).not.toHaveBeenCalled();
+    });
+    it('status returns code-block output', async () => {
+        const result = await handleRestartCommand({ action: 'status' });
+        expect(result.reply).toContain('```');
+        expect(result.reply).toContain('active (running)');
+        expect(result.deferred).toBeUndefined();
+    });
+    it('logs returns code-block output', async () => {
+        const result = await handleRestartCommand({ action: 'logs' });
+        expect(result.reply).toContain('```');
+        expect(result.reply).toContain('discoclaw');
+        expect(result.deferred).toBeUndefined();
+    });
+    it('restart returns a deferred function and correct reply', async () => {
+        const result = await handleRestartCommand({ action: 'restart' });
+        expect(result.reply).toBe('Restarting discoclaw... back in a moment.');
+        expect(typeof result.deferred).toBe('function');
+    });
+    it('does not write shutdown context until deferred is called', async () => {
+        const spy = vi.spyOn(shutdownCtx, 'writeShutdownContext').mockResolvedValue();
+        const result = await handleRestartCommand({ action: 'restart' }, { dataDir: '/tmp/test', userId: '123', activeForge: 'plan-001' });
+        // Before deferred: no write.
+        expect(spy).not.toHaveBeenCalled();
+        // After deferred: write happens.
+        result.deferred();
+        expect(spy).toHaveBeenCalledOnce();
+        expect(spy.mock.calls[0][1]).toMatchObject({
+            reason: 'restart-command',
+            requestedBy: '123',
+            activeForge: 'plan-001',
+        });
+        spy.mockRestore();
+    });
+    it('restart reports "Starting" when service was not active', async () => {
+        const { execFile } = await import('node:child_process');
+        // Override mock to simulate inactive service (only for the status-check call)
+        execFile.mockImplementationOnce((cmd, args, opts, cb) => {
+            cb(null, 'inactive (dead)\n', '');
+        });
+        const result = await handleRestartCommand({ action: 'restart' });
+        expect(result.reply).toBe('Starting discoclaw...');
+    });
+});
+describe('handleRestartCommand - macOS', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+        vi.spyOn(process, 'getuid').mockReturnValue(501);
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: savedPlatform, configurable: true });
+        vi.restoreAllMocks();
+    });
+    it('status calls launchctl list instead of systemctl', async () => {
+        const { execFile } = await import('node:child_process');
+        const result = await handleRestartCommand({ action: 'status' });
+        expect(result.reply).toContain('```');
+        expect(result.deferred).toBeUndefined();
+        const calls = execFile.mock.calls;
+        const statusCall = calls.find((c) => c[0] === 'launchctl');
+        expect(statusCall).toBeDefined();
+        expect(statusCall[1]).toContain('list');
+        expect(statusCall[1]).toContain('com.discoclaw.agent');
+        // Must NOT call systemctl
+        expect(calls.every((c) => c[0] !== 'systemctl')).toBe(true);
+    });
+    it('logs calls log show instead of journalctl', async () => {
+        const { execFile } = await import('node:child_process');
+        const result = await handleRestartCommand({ action: 'logs' });
+        expect(result.reply).toContain('```');
+        expect(result.deferred).toBeUndefined();
+        const calls = execFile.mock.calls;
+        const logsCall = calls.find((c) => c[0] === 'log');
+        expect(logsCall).toBeDefined();
+        expect(logsCall[1]).toContain('show');
+        expect(logsCall[1]).toContain('--predicate');
+        // Must NOT call journalctl
+        expect(calls.every((c) => c[0] !== 'journalctl')).toBe(true);
+    });
+    it('restart uses launchctl kickstart in deferred when service is active', async () => {
+        const { execFile } = await import('node:child_process');
+        // Default mock returns exit code 0 for launchctl list → wasActive = true
+        const result = await handleRestartCommand({ action: 'restart' });
+        expect(result.reply).toBe('Restarting discoclaw... back in a moment.');
+        expect(typeof result.deferred).toBe('function');
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const kickstartCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('kickstart'));
+        expect(kickstartCall).toBeDefined();
+        expect(kickstartCall[1]).toContain('-k');
+        expect(kickstartCall[1]).toContain('gui/501/com.discoclaw.agent');
+    });
+    it('restart uses launchctl bootstrap in deferred when service is inactive', async () => {
+        const { execFile } = await import('node:child_process');
+        // Return non-zero exit code for the launchctl list check → wasActive = false
+        execFile.mockImplementationOnce((cmd, args, opts, cb) => {
+            const err = Object.assign(new Error('not loaded'), { code: 1 });
+            cb(err, '', '');
+        });
+        const result = await handleRestartCommand({ action: 'restart' });
+        expect(result.reply).toBe('Starting discoclaw...');
+        expect(typeof result.deferred).toBe('function');
+        result.deferred();
+        const calls = execFile.mock.calls;
+        const bootstrapCall = calls.find((c) => c[0] === 'launchctl' && c[1].includes('bootstrap'));
+        expect(bootstrapCall).toBeDefined();
+        expect(bootstrapCall[1]).toContain('gui/501');
+        expect(bootstrapCall[1]).toContain('/Users/testuser/Library/LaunchAgents/com.discoclaw.agent.plist');
+    });
+});
+describe('handleRestartCommand - unsupported platform', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: savedPlatform, configurable: true });
+    });
+    it('restart returns explicit error message', async () => {
+        const result = await handleRestartCommand({ action: 'restart' });
+        expect(result.reply).toContain('!restart is not supported on this platform (win32)');
+        expect(result.reply).toContain('Only Linux (systemd) and macOS (launchd) are supported.');
+        expect(result.deferred).toBeUndefined();
+    });
+    it('status returns explicit error message', async () => {
+        const result = await handleRestartCommand({ action: 'status' });
+        expect(result.reply).toContain('!restart is not supported on this platform (win32)');
+        expect(result.reply).toContain('Only Linux (systemd) and macOS (launchd) are supported.');
+    });
+});

package/dist/discord/runtime-utils.js

@@ -0,0 +1,43 @@
+/**
+ * Collect the final text from a runtime invocation, streaming through all events.
+ *
+ * When `opts.requireFinalEvent` is true, throws if the stream ends without
+ * a `text_final` event (distinguishes a complete response from a truncated one).
+ *
+ * When `opts.onEvent` is provided, each event is forwarded to it before
+ * processing — used to drive live streaming preview in Discord progress messages.
+ */
+export async function collectRuntimeText(runtime, prompt, model, cwd, tools, addDirs, timeoutMs, opts) {
+    let text = '';
+    let sawFinal = false;
+    for await (const evt of runtime.invoke({
+        prompt,
+        model,
+        cwd,
+        tools,
+        addDirs: addDirs.length > 0 ? addDirs : undefined,
+        timeoutMs,
+        ...(opts?.sessionKey ? { sessionKey: opts.sessionKey } : {}),
+        ...(opts?.signal ? { signal: opts.signal } : {}),
+    })) {
+        try {
+            opts?.onEvent?.(evt);
+        }
+        catch { /* UI callback errors must not abort execution */ }
+        if (evt.type === 'text_final') {
+            text = evt.text;
+            sawFinal = true;
+        }
+        else if (evt.type === 'text_delta') {
+            // Accumulate deltas in case text_final isn't emitted
+            text += evt.text;
+        }
+        else if (evt.type === 'error') {
+            throw new Error(`Runtime error: ${evt.message}`);
+        }
+    }
+    if (opts?.requireFinalEvent && !sawFinal) {
+        throw new Error('Runtime stream ended without text_final event (response may be truncated)');
+    }
+    return text;
+}

package/dist/discord/runtime-utils.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { collectRuntimeText } from './runtime-utils.js';
+function makeCaptureRuntime() {
+    const calls = [];
+    const runtime = {
+        id: 'claude_code',
+        capabilities: new Set(['streaming_text']),
+        invoke(params) {
+            calls.push(params);
+            return (async function* () {
+                yield { type: 'text_final', text: 'ok' };
+            })();
+        },
+    };
+    return { runtime, calls };
+}
+function makeMultiEventRuntime(events) {
+    return {
+        id: 'claude_code',
+        capabilities: new Set(['streaming_text']),
+        invoke() {
+            return (async function* () {
+                for (const evt of events)
+                    yield evt;
+            })();
+        },
+    };
+}
+describe('collectRuntimeText', () => {
+    it('passes sessionKey through to runtime.invoke() when provided', async () => {
+        const { runtime, calls } = makeCaptureRuntime();
+        await collectRuntimeText(runtime, 'hello', 'test-model', '/tmp', ['Read'], [], 30000, { sessionKey: 'forge:plan-001:opus:drafter' });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].sessionKey).toBe('forge:plan-001:opus:drafter');
+    });
+    it('does not include sessionKey in invoke params when opts omitted', async () => {
+        const { runtime, calls } = makeCaptureRuntime();
+        await collectRuntimeText(runtime, 'hello', 'test-model', '/tmp', ['Read'], [], 30000);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].sessionKey).toBeUndefined();
+    });
+    it('does not include sessionKey when opts has no sessionKey', async () => {
+        const { runtime, calls } = makeCaptureRuntime();
+        await collectRuntimeText(runtime, 'hello', 'test-model', '/tmp', ['Read'], [], 30000, { requireFinalEvent: true });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].sessionKey).toBeUndefined();
+    });
+});
+describe('collectRuntimeText signal', () => {
+    it('passes signal through to runtime.invoke() when provided', async () => {
+        const { runtime, calls } = makeCaptureRuntime();
+        const ac = new AbortController();
+        await collectRuntimeText(runtime, 'hello', 'test-model', '/tmp', ['Read'], [], 30000, { signal: ac.signal });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].signal).toBe(ac.signal);
+    });
+    it('does not include signal when opts has no signal', async () => {
+        const { runtime, calls } = makeCaptureRuntime();
+        await collectRuntimeText(runtime, 'hello', 'test-model', '/tmp', ['Read'], [], 30000, { requireFinalEvent: true });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].signal).toBeUndefined();
+    });
+    it('throws when runtime emits error due to pre-aborted signal', async () => {
+        const ac = new AbortController();
+        ac.abort();
+        const runtime = makeMultiEventRuntime([
+            { type: 'error', message: 'aborted' },
+        ]);
+        await expect(collectRuntimeText(runtime, 'p', 'm', '/tmp', [], [], 30000, { signal: ac.signal })).rejects.toThrow('aborted');
+    });
+});
+describe('collectRuntimeText onEvent', () => {
+    it('forwards events to onEvent in order', async () => {
+        const events = [
+            { type: 'text_delta', text: 'hello' },
+            { type: 'text_delta', text: ' world' },
+            { type: 'text_final', text: 'hello world' },
+        ];
+        const runtime = makeMultiEventRuntime(events);
+        const received = [];
+        await collectRuntimeText(runtime, 'p', 'm', '/tmp', [], [], 30000, {
+            onEvent: (evt) => received.push(evt),
+        });
+        expect(received).toEqual(events);
+    });
+    it('return value is unchanged when onEvent is provided', async () => {
+        const runtime = makeMultiEventRuntime([{ type: 'text_final', text: 'result text' }]);
+        const result = await collectRuntimeText(runtime, 'p', 'm', '/tmp', [], [], 30000, {
+            onEvent: () => { },
+        });
+        expect(result).toBe('result text');
+    });
+    it('does not propagate a throwing onEvent', async () => {
+        const runtime = makeMultiEventRuntime([{ type: 'text_final', text: 'ok' }]);
+        await expect(collectRuntimeText(runtime, 'p', 'm', '/tmp', [], [], 30000, {
+            onEvent: () => { throw new Error('callback error'); },
+        })).resolves.toBe('ok');
+    });
+    it('still processes all events even when onEvent throws', async () => {
+        const events = [
+            { type: 'text_delta', text: 'a' },
+            { type: 'text_final', text: 'final' },
+        ];
+        const runtime = makeMultiEventRuntime(events);
+        const callCount = { n: 0 };
+        const result = await collectRuntimeText(runtime, 'p', 'm', '/tmp', [], [], 30000, {
+            onEvent: () => { callCount.n++; throw new Error('oops'); },
+        });
+        expect(callCount.n).toBe(2);
+        expect(result).toBe('final');
+    });
+});

package/dist/discord/session-key.js

@@ -0,0 +1,7 @@
+export function discordSessionKey(msg) {
+    if (msg.isDm)
+        return `discord:dm:${msg.authorId}`;
+    if (msg.threadId)
+        return `discord:thread:${msg.threadId}`;
+    return `discord:channel:${msg.channelId}`;
+}

package/dist/discord/session-key.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { discordSessionKey } from './session-key.js';
+describe('discordSessionKey', () => {
+    it('uses dm:<authorId> for DMs', () => {
+        expect(discordSessionKey({ channelId: 'c', authorId: 'u', isDm: true })).toBe('discord:dm:u');
+    });
+    it('uses thread:<threadId> for threads', () => {
+        expect(discordSessionKey({ channelId: 'c', authorId: 'u', isDm: false, threadId: 't' })).toBe('discord:thread:t');
+    });
+    it('uses channel:<channelId> for normal channels', () => {
+        expect(discordSessionKey({ channelId: 'c', authorId: 'u', isDm: false })).toBe('discord:channel:c');
+    });
+});