discoclaw 0.1.0

package/dist/runtime/process-pool.js

@@ -0,0 +1,93 @@
+import { LongRunningProcess } from './long-running-process.js';
+/**
+ * Pool of LongRunningProcess instances keyed by Discord session key.
+ */
+export class ProcessPool {
+    pool = new Map();
+    maxProcesses;
+    log;
+    constructor(opts) {
+        this.maxProcesses = opts?.maxProcesses ?? 5;
+        this.log = opts?.log;
+    }
+    /**
+     * Get an existing alive process for the session key, or spawn a new one.
+     * Returns null if spawn fails (caller should fall back to one-shot).
+     */
+    getOrSpawn(sessionKey, processOpts) {
+        const existing = this.pool.get(sessionKey);
+        if (existing?.state === 'idle') {
+            this.log?.debug({ sessionKey }, 'process-pool: reusing existing process');
+            // True LRU: touch on access (Map preserves insertion order).
+            this.pool.delete(sessionKey);
+            this.pool.set(sessionKey, existing);
+            return existing;
+        }
+        // Remove dead process if present.
+        if (existing) {
+            // If the process is busy, do not disrupt it: fall back to one-shot.
+            if (existing.state === 'busy') {
+                this.log?.debug({ sessionKey }, 'process-pool: session busy, falling back to one-shot');
+                return null;
+            }
+            this.pool.delete(sessionKey);
+        }
+        // Evict least-recently-used idle process if at capacity. If none are idle, do not evict.
+        if (this.pool.size >= this.maxProcesses) {
+            const evicted = this.evictOldestIdle();
+            if (!evicted) {
+                this.log?.debug({ sessionKey, poolSize: this.pool.size }, 'process-pool: at capacity with no idle processes');
+                return null;
+            }
+        }
+        // Spawn a new process.
+        const proc = new LongRunningProcess(processOpts);
+        const ok = proc.spawn();
+        if (!ok) {
+            this.log?.info({ sessionKey }, 'process-pool: spawn failed');
+            return null;
+        }
+        // Auto-remove when the process dies.
+        proc.onCleanup = () => {
+            const current = this.pool.get(sessionKey);
+            if (current === proc) {
+                this.pool.delete(sessionKey);
+            }
+        };
+        this.pool.set(sessionKey, proc);
+        this.log?.info({ sessionKey, poolSize: this.pool.size }, 'process-pool: spawned new process');
+        return proc;
+    }
+    /** Kill and remove a specific session's process. */
+    remove(sessionKey) {
+        const proc = this.pool.get(sessionKey);
+        if (proc) {
+            this.pool.delete(sessionKey);
+            proc.kill();
+            this.log?.info({ sessionKey }, 'process-pool: removed process');
+        }
+    }
+    /** Kill all processes (shutdown cleanup). */
+    killAll() {
+        for (const [key, proc] of this.pool) {
+            proc.forceKill();
+            this.log?.debug({ sessionKey: key }, 'process-pool: killed process');
+        }
+        this.pool.clear();
+    }
+    get size() {
+        return this.pool.size;
+    }
+    evictOldestIdle() {
+        // Map iteration order is LRU (oldest to newest) because we "touch" on reuse.
+        for (const [key, proc] of this.pool) {
+            if (proc.state === 'idle') {
+                this.pool.delete(key);
+                proc.kill();
+                this.log?.info({ sessionKey: key }, 'process-pool: evicted idle process');
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/runtime/process-pool.test.js

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it, vi, afterEach } from 'vitest';
+import { EventEmitter } from 'node:events';
+vi.mock('execa', () => ({
+    execa: vi.fn(),
+}));
+import { execa } from 'execa';
+import { ProcessPool } from './process-pool.js';
+function createMockSubprocess() {
+    const stdout = new EventEmitter();
+    const stderr = new EventEmitter();
+    const stdin = { write: vi.fn(), end: vi.fn() };
+    let resolvePromise;
+    const promise = new Promise((res) => {
+        resolvePromise = res;
+    });
+    const proc = Object.assign(promise, {
+        stdout,
+        stderr,
+        stdin,
+        kill: vi.fn(),
+        pid: Math.floor(Math.random() * 100000),
+    });
+    return { proc, stdout, stderr, stdin, resolve: resolvePromise };
+}
+const baseProcessOpts = {
+    claudeBin: 'claude',
+    model: 'opus',
+    cwd: '/tmp',
+    dangerouslySkipPermissions: true,
+    hangTimeoutMs: 60000,
+    idleTimeoutMs: 300000,
+};
+beforeEach(() => {
+    vi.useFakeTimers();
+    execa.mockReset?.();
+    execa.mockImplementation(() => createMockSubprocess().proc);
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+describe('ProcessPool', () => {
+    it('getOrSpawn creates a new process for a new session key', () => {
+        const pool = new ProcessPool({ maxProcesses: 3 });
+        const proc = pool.getOrSpawn('session-1', baseProcessOpts);
+        expect(proc).not.toBeNull();
+        expect(proc.isAlive).toBe(true);
+        expect(pool.size).toBe(1);
+    });
+    it('getOrSpawn returns existing process for same session key', () => {
+        const pool = new ProcessPool({ maxProcesses: 3 });
+        const proc1 = pool.getOrSpawn('session-1', baseProcessOpts);
+        const proc2 = pool.getOrSpawn('session-1', baseProcessOpts);
+        expect(proc1).toBe(proc2);
+        expect(pool.size).toBe(1);
+        // Only one execa call
+        expect(execa.mock.calls).toHaveLength(1);
+    });
+    it('getOrSpawn creates separate processes for different session keys', () => {
+        const pool = new ProcessPool({ maxProcesses: 3 });
+        const proc1 = pool.getOrSpawn('session-1', baseProcessOpts);
+        const proc2 = pool.getOrSpawn('session-2', baseProcessOpts);
+        expect(proc1).not.toBe(proc2);
+        expect(pool.size).toBe(2);
+    });
+    it('evicts oldest idle process when at capacity', () => {
+        const pool = new ProcessPool({ maxProcesses: 2 });
+        const proc1 = pool.getOrSpawn('session-1', baseProcessOpts);
+        pool.getOrSpawn('session-2', baseProcessOpts);
+        expect(pool.size).toBe(2);
+        // Adding a third should evict the first (oldest idle)
+        pool.getOrSpawn('session-3', baseProcessOpts);
+        expect(pool.size).toBe(2);
+        expect(proc1.state).toBe('dead');
+    });
+    it('touching a session makes it most-recently-used (true LRU)', () => {
+        const pool = new ProcessPool({ maxProcesses: 2 });
+        const proc1 = pool.getOrSpawn('session-1', baseProcessOpts);
+        const proc2 = pool.getOrSpawn('session-2', baseProcessOpts);
+        expect(pool.size).toBe(2);
+        // Touch session-1 so session-2 becomes the LRU entry.
+        const proc1b = pool.getOrSpawn('session-1', baseProcessOpts);
+        expect(proc1b).toBe(proc1);
+        // Adding a third should evict session-2 (LRU).
+        pool.getOrSpawn('session-3', baseProcessOpts);
+        expect(pool.size).toBe(2);
+        expect(proc2.state).toBe('dead');
+        expect(proc1.state).not.toBe('dead');
+    });
+    it('does not evict busy processes; returns null when at capacity with no idle', async () => {
+        const pool = new ProcessPool({ maxProcesses: 2 });
+        const proc1 = pool.getOrSpawn('session-1', { ...baseProcessOpts, hangTimeoutMs: 60_000 });
+        const proc2 = pool.getOrSpawn('session-2', { ...baseProcessOpts, hangTimeoutMs: 60_000 });
+        expect(proc1).not.toBeNull();
+        expect(proc2).not.toBeNull();
+        const consume1 = (async () => {
+            for await (const _evt of proc1.sendTurn('t1')) {
+                // drain until killAll unblocks
+            }
+        })();
+        const consume2 = (async () => {
+            for await (const _evt of proc2.sendTurn('t2')) {
+                // drain until killAll unblocks
+            }
+        })();
+        expect(proc1.state).toBe('busy');
+        expect(proc2.state).toBe('busy');
+        const proc3 = pool.getOrSpawn('session-3', baseProcessOpts);
+        expect(proc3).toBeNull();
+        expect(pool.size).toBe(2);
+        expect(proc1.state).toBe('busy');
+        expect(proc2.state).toBe('busy');
+        pool.killAll();
+        await Promise.all([consume1, consume2]);
+    });
+    it('remove kills and deletes a specific process', () => {
+        const pool = new ProcessPool({ maxProcesses: 3 });
+        const proc = pool.getOrSpawn('session-1', baseProcessOpts);
+        expect(pool.size).toBe(1);
+        pool.remove('session-1');
+        expect(pool.size).toBe(0);
+        expect(proc.state).toBe('dead');
+    });
+    it('remove is a no-op for unknown session key', () => {
+        const pool = new ProcessPool({ maxProcesses: 3 });
+        pool.getOrSpawn('session-1', baseProcessOpts);
+        pool.remove('nonexistent');
+        expect(pool.size).toBe(1);
+    });
+    it('killAll kills all processes and empties the pool', () => {
+        const pool = new ProcessPool({ maxProcesses: 5 });
+        const proc1 = pool.getOrSpawn('session-1', baseProcessOpts);
+        const proc2 = pool.getOrSpawn('session-2', baseProcessOpts);
+        const proc3 = pool.getOrSpawn('session-3', baseProcessOpts);
+        pool.killAll();
+        expect(pool.size).toBe(0);
+        expect(proc1.state).toBe('dead');
+        expect(proc2.state).toBe('dead');
+        expect(proc3.state).toBe('dead');
+    });
+    it('replaces dead process on getOrSpawn', () => {
+        const pool = new ProcessPool({ maxProcesses: 3 });
+        const proc1 = pool.getOrSpawn('session-1', baseProcessOpts);
+        proc1.kill(); // Mark as dead
+        const proc2 = pool.getOrSpawn('session-1', baseProcessOpts);
+        expect(proc2).not.toBe(proc1);
+        expect(proc2.isAlive).toBe(true);
+    });
+});

package/dist/runtime/registry.js

@@ -0,0 +1,15 @@
+export class RuntimeRegistry {
+    adapters = new Map();
+    register(name, adapter) {
+        this.adapters.set(name, adapter);
+    }
+    get(name) {
+        return this.adapters.get(name);
+    }
+    list() {
+        return [...this.adapters.keys()];
+    }
+    has(name) {
+        return this.adapters.has(name);
+    }
+}

package/dist/runtime/registry.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { RuntimeRegistry } from './registry.js';
+function makeMockAdapter(id) {
+    return {
+        id: id,
+        capabilities: new Set(['streaming_text']),
+        invoke() {
+            return (async function* () {
+                yield { type: 'text_final', text: '' };
+                yield { type: 'done' };
+            })();
+        },
+    };
+}
+describe('RuntimeRegistry', () => {
+    it('register + get returns the adapter', () => {
+        const registry = new RuntimeRegistry();
+        const adapter = makeMockAdapter('openai');
+        registry.register('openai', adapter);
+        expect(registry.get('openai')).toBe(adapter);
+    });
+    it('get for unknown name returns undefined', () => {
+        const registry = new RuntimeRegistry();
+        expect(registry.get('nonexistent')).toBeUndefined();
+    });
+    it('list returns registered names', () => {
+        const registry = new RuntimeRegistry();
+        registry.register('claude', makeMockAdapter('claude_code'));
+        registry.register('openai', makeMockAdapter('openai'));
+        expect(registry.list()).toEqual(['claude', 'openai']);
+    });
+    it('has returns correct boolean', () => {
+        const registry = new RuntimeRegistry();
+        registry.register('claude', makeMockAdapter('claude_code'));
+        expect(registry.has('claude')).toBe(true);
+        expect(registry.has('openai')).toBe(false);
+    });
+    it('registering the same name twice overwrites silently', () => {
+        const registry = new RuntimeRegistry();
+        const first = makeMockAdapter('openai');
+        const second = makeMockAdapter('openai');
+        registry.register('openai', first);
+        registry.register('openai', second);
+        expect(registry.get('openai')).toBe(second);
+        expect(registry.list()).toEqual(['openai']);
+    });
+});

package/dist/runtime/session-scanner.js

@@ -0,0 +1,186 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Escape a CWD path for Claude's session directory naming.
+ * `/home/user/code/proj` → `-home-user-code-proj`
+ */
+function escapeCwd(cwd) {
+    return cwd.replace(/\//g, '-');
+}
+function sessionFilePath(sessionId, cwd) {
+    const home = os.homedir();
+    const escaped = escapeCwd(cwd);
+    return path.join(home, '.claude', 'projects', escaped, `${sessionId}.jsonl`);
+}
+export class SessionFileScanner {
+    filePath;
+    callbacks;
+    log;
+    offset = 0;
+    lineBuf = '';
+    activeTools = new Map();
+    watcher = null;
+    pollTimer = null;
+    stopped = false;
+    reading = false;
+    constructor(opts, callbacks) {
+        this.filePath = sessionFilePath(opts.sessionId, opts.cwd);
+        this.callbacks = callbacks;
+        this.log = opts.log;
+    }
+    async start() {
+        // Wait for the file to appear (poll with backoff, max ~10s).
+        const existed = await this.waitForFile();
+        if (!existed || this.stopped)
+            return;
+        // Record initial file size so we skip pre-existing content.
+        try {
+            const stat = await fsp.stat(this.filePath);
+            this.offset = stat.size;
+        }
+        catch {
+            return;
+        }
+        if (this.stopped)
+            return;
+        // Start watching for changes.
+        try {
+            this.watcher = fs.watch(this.filePath, () => {
+                this.readNewBytes();
+            });
+            this.watcher.on('error', () => {
+                // Degrade gracefully — polling fallback continues.
+            });
+        }
+        catch {
+            // fs.watch not available — polling alone.
+        }
+        // Polling fallback every 2s (fs.watch isn't reliable on all platforms).
+        this.pollTimer = setInterval(() => {
+            this.readNewBytes();
+        }, 2000);
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        // Emit tool_end for any still-active tools.
+        for (const tool of this.activeTools.values()) {
+            this.callbacks.onEvent({
+                type: 'tool_end',
+                name: tool.name,
+                ok: true,
+            });
+        }
+        this.activeTools.clear();
+    }
+    async waitForFile() {
+        const delays = [100, 200, 500, 1000, 2000, 3000, 3200];
+        for (const delay of delays) {
+            if (this.stopped)
+                return false;
+            try {
+                await fsp.access(this.filePath);
+                return true;
+            }
+            catch {
+                await new Promise((r) => setTimeout(r, delay));
+            }
+        }
+        this.log?.debug('session-scanner: file never appeared, degrading gracefully');
+        return false;
+    }
+    readNewBytes() {
+        if (this.stopped || this.reading)
+            return;
+        this.reading = true;
+        let fd = null;
+        try {
+            fd = fs.openSync(this.filePath, 'r');
+            const stat = fs.fstatSync(fd);
+            if (stat.size <= this.offset) {
+                fs.closeSync(fd);
+                return;
+            }
+            const bytesToRead = stat.size - this.offset;
+            const buf = Buffer.alloc(bytesToRead);
+            fs.readSync(fd, buf, 0, bytesToRead, this.offset);
+            fs.closeSync(fd);
+            fd = null;
+            this.offset = stat.size;
+            this.lineBuf += buf.toString('utf8');
+            const lines = this.lineBuf.split('\n');
+            // Keep the last element as the incomplete line buffer.
+            this.lineBuf = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                this.processLine(trimmed);
+            }
+        }
+        catch {
+            // Degrade gracefully on read errors.
+            if (fd !== null) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    processLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.log?.debug('session-scanner: parse error', line.slice(0, 200));
+            return;
+        }
+        // Tool use: assistant message with tool_use content blocks
+        if (parsed?.type === 'assistant' && Array.isArray(parsed?.message?.content)) {
+            for (const block of parsed.message.content) {
+                if (block?.type === 'tool_use' && typeof block.name === 'string') {
+                    const blockId = String(block.id ?? '');
+                    this.activeTools.set(blockId, { name: block.name, blockId });
+                    this.callbacks.onEvent({
+                        type: 'tool_start',
+                        name: block.name,
+                        input: block.input,
+                    });
+                }
+            }
+        }
+        // Tool result: user message with tool_result content blocks
+        if (parsed?.type === 'user' && Array.isArray(parsed?.message?.content)) {
+            for (const block of parsed.message.content) {
+                if (block?.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+                    const toolUseId = block.tool_use_id;
+                    const active = this.activeTools.get(toolUseId);
+                    if (active) {
+                        this.activeTools.delete(toolUseId);
+                        this.callbacks.onEvent({
+                            type: 'tool_end',
+                            name: active.name,
+                            ok: !block.is_error,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}