discoclaw 0.1.0

package/dist/runtime/concurrency-limit.js

@@ -0,0 +1,80 @@
+class Semaphore {
+    max;
+    active = 0;
+    queue = [];
+    constructor(max) {
+        this.max = max;
+    }
+    async acquire() {
+        if (!(this.max > 0)) {
+            return () => { };
+        }
+        if (this.active < this.max) {
+            this.active++;
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                this.release();
+            };
+        }
+        return await new Promise((resolve) => {
+            this.queue.push((release) => resolve(release));
+        });
+    }
+    release() {
+        const next = this.queue.shift();
+        if (next) {
+            // Keep active count constant: transfer slot to the next waiter.
+            let released = false;
+            next(() => {
+                if (released)
+                    return;
+                released = true;
+                this.release();
+            });
+            return;
+        }
+        this.active = Math.max(0, this.active - 1);
+    }
+}
+export function createConcurrencyLimiter(maxConcurrentInvocations) {
+    const max = Number.isFinite(maxConcurrentInvocations)
+        ? Math.max(0, Math.floor(maxConcurrentInvocations))
+        : 0;
+    if (max <= 0)
+        return null;
+    const sem = new Semaphore(max);
+    return {
+        max,
+        acquire: () => sem.acquire(),
+    };
+}
+/**
+ * Wrap a runtime adapter with a global concurrency limiter.
+ *
+ * Important: the permit is held for the entire lifetime of the async iterator,
+ * so consumers must exhaust/close the iterator to release the slot.
+ */
+export function withConcurrencyLimit(runtime, opts) {
+    const limiter = opts.limiter ?? createConcurrencyLimiter(opts.maxConcurrentInvocations);
+    if (!limiter)
+        return runtime;
+    return {
+        ...runtime,
+        async *invoke(params) {
+            const release = await limiter.acquire();
+            opts.log?.debug?.({ max: limiter.max }, 'runtime:concurrency slot acquired');
+            try {
+                for await (const evt of runtime.invoke(params)) {
+                    yield evt;
+                }
+            }
+            finally {
+                release();
+                opts.log?.debug?.({ max: limiter.max }, 'runtime:concurrency slot released');
+            }
+        },
+    };
+}

package/dist/runtime/concurrency-limit.test.js

@@ -0,0 +1,137 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createConcurrencyLimiter, withConcurrencyLimit } from './concurrency-limit.js';
+function makeDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+describe('withConcurrencyLimit', () => {
+    it('serializes invocations when maxConcurrentInvocations=1', async () => {
+        const started = [];
+        const finishA = makeDeferred();
+        const finishB = makeDeferred();
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(['streaming_text']),
+            async *invoke(params) {
+                started.push(params.prompt);
+                if (params.prompt === 'A')
+                    await finishA.promise;
+                if (params.prompt === 'B')
+                    await finishB.promise;
+                yield { type: 'text_final', text: params.prompt };
+                yield { type: 'done' };
+            },
+        };
+        const limited = withConcurrencyLimit(runtime, { maxConcurrentInvocations: 1 });
+        const consume = async (prompt) => {
+            const out = [];
+            for await (const evt of limited.invoke({ prompt, model: 'm', cwd: '/tmp' })) {
+                out.push(evt);
+            }
+            return out;
+        };
+        const pA = consume('A');
+        // Let A acquire the slot and start.
+        await vi.waitFor(() => {
+            expect(started).toEqual(['A']);
+        });
+        const pB = consume('B');
+        // B should not start until A finishes.
+        await new Promise((r) => setTimeout(r, 25));
+        expect(started).toEqual(['A']);
+        finishA.resolve();
+        await vi.waitFor(() => {
+            expect(started).toEqual(['A', 'B']);
+        });
+        finishB.resolve();
+        const [outA, outB] = await Promise.all([pA, pB]);
+        expect(outA.some((e) => e.type === 'text_final' && e.text === 'A')).toBe(true);
+        expect(outB.some((e) => e.type === 'text_final' && e.text === 'B')).toBe(true);
+    });
+    it('is a no-op when maxConcurrentInvocations=0', async () => {
+        const started = [];
+        const finishA = makeDeferred();
+        const finishB = makeDeferred();
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(['streaming_text']),
+            async *invoke(params) {
+                started.push(params.prompt);
+                if (params.prompt === 'A')
+                    await finishA.promise;
+                if (params.prompt === 'B')
+                    await finishB.promise;
+                yield { type: 'done' };
+            },
+        };
+        const limited = withConcurrencyLimit(runtime, { maxConcurrentInvocations: 0 });
+        const pA = (async () => {
+            for await (const _ of limited.invoke({ prompt: 'A', model: 'm', cwd: '/tmp' })) {
+                // ignore
+            }
+        })();
+        const pB = (async () => {
+            for await (const _ of limited.invoke({ prompt: 'B', model: 'm', cwd: '/tmp' })) {
+                // ignore
+            }
+        })();
+        await vi.waitFor(() => {
+            expect(new Set(started)).toEqual(new Set(['A', 'B']));
+        });
+        finishA.resolve();
+        finishB.resolve();
+        await Promise.all([pA, pB]);
+    });
+    it('shares one limiter across multiple runtime wrappers', async () => {
+        const started = [];
+        const finishA = makeDeferred();
+        const finishB = makeDeferred();
+        const runtimeA = {
+            id: 'other',
+            capabilities: new Set(['streaming_text']),
+            async *invoke() {
+                started.push('A');
+                await finishA.promise;
+                yield { type: 'done' };
+            },
+        };
+        const runtimeB = {
+            id: 'other',
+            capabilities: new Set(['streaming_text']),
+            async *invoke() {
+                started.push('B');
+                await finishB.promise;
+                yield { type: 'done' };
+            },
+        };
+        const limiter = createConcurrencyLimiter(1);
+        const limitedA = withConcurrencyLimit(runtimeA, { maxConcurrentInvocations: 1, limiter });
+        const limitedB = withConcurrencyLimit(runtimeB, { maxConcurrentInvocations: 1, limiter });
+        const pA = (async () => {
+            for await (const _ of limitedA.invoke({ prompt: 'x', model: 'm', cwd: '/tmp' })) {
+                // ignore
+            }
+        })();
+        await vi.waitFor(() => {
+            expect(started).toEqual(['A']);
+        });
+        const pB = (async () => {
+            for await (const _ of limitedB.invoke({ prompt: 'x', model: 'm', cwd: '/tmp' })) {
+                // ignore
+            }
+        })();
+        await new Promise((r) => setTimeout(r, 25));
+        expect(started).toEqual(['A']);
+        finishA.resolve();
+        await vi.waitFor(() => {
+            expect(started).toEqual(['A', 'B']);
+        });
+        finishB.resolve();
+        await Promise.all([pA, pB]);
+    });
+});

package/dist/runtime/gemini-cli.js

@@ -0,0 +1,16 @@
+// Gemini CLI runtime adapter — thin wrapper around the universal CLI adapter.
+// Phase 1: one-shot text mode. Sessions, JSONL streaming, and preflight are Phase 2.
+// Auth is resolved by the `gemini` binary itself (OAuth via ~/.gemini/oauth_creds.json
+// or GEMINI_API_KEY env var). This adapter spawns the binary and does not manage auth.
+import { createCliRuntime, killAllSubprocesses } from './cli-adapter.js';
+import { createGeminiStrategy } from './strategies/gemini-strategy.js';
+/** SIGKILL all tracked Gemini subprocesses (e.g. on SIGTERM). */
+export function killActiveGeminiSubprocesses() {
+    killAllSubprocesses();
+}
+export function createGeminiCliRuntime(opts) {
+    return createCliRuntime(createGeminiStrategy(opts.defaultModel), {
+        binary: opts.geminiBin,
+        log: opts.log,
+    });
+}

package/dist/runtime/gemini-cli.test.js

@@ -0,0 +1,413 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+// We mock execa at the module level so createGeminiCliRuntime uses our mock.
+const mockExeca = vi.fn();
+vi.mock('execa', () => ({
+    execa: (...args) => mockExeca(...args),
+}));
+// Import after mock setup.
+const { createGeminiCliRuntime, killActiveGeminiSubprocesses } = await import('./gemini-cli.js');
+async function collectEvents(iter) {
+    const events = [];
+    for await (const evt of iter) {
+        events.push(evt);
+    }
+    return events;
+}
+/** Create a mock subprocess that mimics execa's ResultPromise shape. */
+function createMockSubprocess(opts) {
+    const stdoutChunks = opts.stdout ? [Buffer.from(opts.stdout)] : [];
+    const stdoutListeners = {};
+    const stderrListeners = {};
+    let thenCb = null;
+    let catchCb = null;
+    const mockStdout = {
+        on(event, cb) {
+            if (!stdoutListeners[event])
+                stdoutListeners[event] = [];
+            stdoutListeners[event].push(cb);
+            return mockStdout;
+        },
+    };
+    const mockStderr = {
+        on(event, cb) {
+            if (!stderrListeners[event])
+                stderrListeners[event] = [];
+            stderrListeners[event].push(cb);
+            return mockStderr;
+        },
+    };
+    const mockStdin = {
+        write: vi.fn(),
+        end: vi.fn(),
+    };
+    const subprocess = {
+        stdout: mockStdout,
+        stderr: mockStderr,
+        stdin: mockStdin,
+        pid: 12345,
+        kill: vi.fn(),
+        then(cb) {
+            thenCb = cb;
+            return { catch(cb2) { catchCb = cb2; } };
+        },
+    };
+    // Simulate async process completion.
+    // Use queueMicrotask to fire after the generator sets up listeners.
+    queueMicrotask(() => {
+        // Emit stdout data
+        for (const chunk of stdoutChunks) {
+            for (const cb of (stdoutListeners['data'] || [])) {
+                cb(chunk);
+            }
+        }
+        // Emit stderr data
+        if (opts.stderr) {
+            for (const cb of (stderrListeners['data'] || [])) {
+                cb(Buffer.from(opts.stderr));
+            }
+        }
+        // End streams
+        for (const cb of (stdoutListeners['end'] || []))
+            cb();
+        for (const cb of (stderrListeners['end'] || []))
+            cb();
+        // Resolve/reject the process promise.
+        if (opts.rejectWith) {
+            catchCb?.(opts.rejectWith);
+        }
+        else if (opts.timedOut) {
+            catchCb?.({
+                timedOut: true,
+                message: 'timed out',
+                originalMessage: 'timed out',
+                shortMessage: 'timed out',
+            });
+        }
+        else {
+            const exitCode = opts.exitCode ?? 0;
+            const result = {
+                exitCode,
+                stdout: opts.stdout ?? '',
+                stderr: opts.stderr ?? '',
+                timedOut: false,
+                failed: exitCode !== 0 || (opts.failed ?? false),
+                ...opts.resultExtra,
+            };
+            thenCb?.(result);
+        }
+    });
+    return subprocess;
+}
+describe('Gemini CLI runtime adapter', () => {
+    beforeEach(() => {
+        mockExeca.mockReset();
+    });
+    it('happy path: stdout text emits text_delta + text_final + done', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'Hello world',
+            exitCode: 0,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        expect(deltas.length).toBeGreaterThan(0);
+        expect(deltas.map((d) => d.text).join('')).toBe('Hello world');
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('Hello world');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('error path: non-zero exit code emits error + done', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            stderr: 'model not found',
+            exitCode: 1,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('model not found');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('timeout path: timedOut flag emits timeout error + done', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            timedOut: true,
+            exitCode: undefined,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+            timeoutMs: 5000,
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('timed out');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('model override: params.model takes precedence over defaultModel', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: 'gemini-2.5-flash',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        const modelIdx = callArgs.indexOf('--model');
+        expect(callArgs[modelIdx + 1]).toBe('gemini-2.5-flash');
+    });
+    it('inserts -- argument terminator before prompt to prevent flag parsing', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        await collectEvents(rt.invoke({
+            prompt: '--- SOUL.md ---\ntext',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const callArgs = mockExeca.mock.calls[0][1];
+        const dashdashIdx = callArgs.indexOf('--');
+        expect(dashdashIdx).toBeGreaterThan(-1);
+        expect(callArgs[dashdashIdx + 1]).toBe('--- SOUL.md ---\ntext');
+    });
+    it('empty model fallback: params.model="" resolves to defaultModel', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        const modelIdx = callArgs.indexOf('--model');
+        expect(callArgs[modelIdx + 1]).toBe('gemini-2.5-pro');
+    });
+    it('large prompt uses stdin instead of positional arg', async () => {
+        const largePrompt = 'x'.repeat(200_000);
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: 'ok',
+            exitCode: 0,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        await collectEvents(rt.invoke({
+            prompt: largePrompt,
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(mockExeca).toHaveBeenCalledTimes(1);
+        const callArgs = mockExeca.mock.calls[0][1];
+        // Should NOT contain the large prompt as a positional arg.
+        expect(callArgs).not.toContain(largePrompt);
+        // No -- terminator when using stdin (no positional arg).
+        expect(callArgs).not.toContain('--');
+        // Verify stdin was used.
+        const execaOpts = mockExeca.mock.calls[0][2];
+        expect(execaOpts.stdin).toBe('pipe');
+    });
+    it('runtime has correct id and capabilities', () => {
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        expect(rt.id).toBe('gemini');
+        expect(rt.capabilities.has('streaming_text')).toBe(true);
+        // Phase 1: no sessions, no fs tools, no exec tools declared.
+        expect(rt.capabilities.has('sessions')).toBe(false);
+        expect(rt.capabilities.has('tools_fs')).toBe(false);
+        expect(rt.capabilities.has('tools_exec')).toBe(false);
+    });
+    it('shutdown cleanup: killActiveGeminiSubprocesses kills tracked processes', async () => {
+        const sub = createMockSubprocess({
+            stdout: '',
+            exitCode: 0,
+        });
+        // Prevent the subprocess from resolving immediately so it stays tracked.
+        sub.then = () => ({ catch: () => { } });
+        mockExeca.mockReturnValue(sub);
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        // Start invoke but don't consume fully — just trigger subprocess creation.
+        const iter = rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        });
+        // Pull one event to start the generator (which adds the subprocess to tracking).
+        const iterResult = iter;
+        iterResult.next(); // don't await — we just need it to run up to the first yield/await
+        await new Promise(r => setTimeout(r, 10));
+        // Kill all tracked subprocesses.
+        killActiveGeminiSubprocesses();
+        expect(sub.kill).toHaveBeenCalledWith('SIGKILL');
+    });
+    it('empty stdout emits done without text_final', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            exitCode: 0,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        // No text_final for empty response.
+        expect(events.find((e) => e.type === 'text_final')).toBeUndefined();
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('error messages are sanitized: multi-line stderr returns first line only', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            stderr: 'auth token expired\nfull prompt: You are a helpful assistant...\nsession: /tmp/gemini/abc123',
+            exitCode: 1,
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Say hello',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        // Should contain first line only.
+        expect(msg).toContain('auth token expired');
+        // Should NOT contain prompt or session content from subsequent lines.
+        expect(msg).not.toContain('full prompt');
+        expect(msg).not.toContain('session:');
+    });
+    it('ENOENT via tryFinalize: uses fixed message, never leaks prompt', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            exitCode: undefined,
+            failed: true,
+            resultExtra: {
+                exitCode: null,
+                failed: true,
+                code: 'ENOENT',
+                originalMessage: 'spawn gemini ENOENT',
+                shortMessage: "Command failed: gemini --model gemini-2.5-pro -- 'TOP SECRET PROMPT DATA'\nspawn gemini ENOENT",
+            },
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'TOP SECRET PROMPT DATA',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        expect(msg).toContain('gemini binary not found');
+        expect(msg).not.toContain('TOP SECRET');
+        expect(msg).not.toContain('Command failed');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('ENOENT via catch handler: uses fixed message, never leaks prompt', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            rejectWith: {
+                code: 'ENOENT',
+                originalMessage: 'spawn gemini ENOENT',
+                shortMessage: "Command failed: gemini --model gemini-2.5-pro -- 'TOP SECRET PROMPT DATA'\nspawn gemini ENOENT",
+                message: "Command failed: gemini --model gemini-2.5-pro -- 'TOP SECRET PROMPT DATA'\nspawn gemini ENOENT",
+            },
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'TOP SECRET PROMPT DATA',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        expect(msg).toContain('gemini binary not found');
+        expect(msg).not.toContain('TOP SECRET');
+        expect(msg).not.toContain('Command failed');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('non-ENOENT spawn failure via catch handler: generic message, no raw error', async () => {
+        mockExeca.mockReturnValue(createMockSubprocess({
+            stdout: '',
+            rejectWith: {
+                code: 'EACCES',
+                originalMessage: 'spawn gemini EACCES',
+                shortMessage: "Command failed: gemini --model gemini-2.5-pro -- 'secret prompt'\nspawn gemini EACCES",
+                message: "Command failed: gemini ...",
+            },
+        }));
+        const rt = createGeminiCliRuntime({
+            geminiBin: 'gemini',
+            defaultModel: 'gemini-2.5-pro',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'secret prompt',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        const msg = errorEvt.message;
+        expect(msg).toBe('gemini process failed unexpectedly (EACCES)');
+        expect(msg).not.toContain('secret prompt');
+        expect(msg).not.toContain('Command failed');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+});