discoclaw 0.1.0

package/dist/pidlock.test.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { afterEach, describe, expect, it } from 'vitest';
+import { acquirePidLock, releasePidLock } from './pidlock.js';
+async function tmpLockPath() {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'pidlock-'));
+    return path.join(dir, 'discoclaw.pid');
+}
+function lockDirPath(lockPath) {
+    return `${lockPath}.lock`;
+}
+describe('acquirePidLock', () => {
+    const paths = [];
+    afterEach(async () => {
+        for (const p of paths) {
+            await fs.rm(path.dirname(p), { recursive: true, force: true });
+        }
+        paths.length = 0;
+    });
+    it('creates a lock directory with meta for current PID', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        await acquirePidLock(lockPath);
+        const raw = await fs.readFile(path.join(lockDirPath(lockPath), 'meta.json'), 'utf-8');
+        const meta = JSON.parse(raw);
+        expect(meta.pid).toBe(process.pid);
+        expect(typeof meta.token).toBe('string');
+        expect(meta.token.length).toBe(32);
+    });
+    it('takes over stale lock with dead PID', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const lockDir = lockDirPath(lockPath);
+        await fs.mkdir(lockDir);
+        await fs.writeFile(path.join(lockDir, 'meta.json'), JSON.stringify({ pid: 999999999, token: 'old-token', acquiredAt: new Date().toISOString() }), 'utf-8');
+        await acquirePidLock(lockPath);
+        const raw = await fs.readFile(path.join(lockDir, 'meta.json'), 'utf-8');
+        const meta = JSON.parse(raw);
+        expect(meta.pid).toBe(process.pid);
+    });
+    it('throws when a live process holds the lock', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const lockDir = lockDirPath(lockPath);
+        await fs.mkdir(lockDir);
+        await fs.writeFile(path.join(lockDir, 'meta.json'), JSON.stringify({ pid: 1, token: 'held-token', acquiredAt: new Date().toISOString() }), 'utf-8');
+        await expect(acquirePidLock(lockPath)).rejects.toThrow(/already running.*PID 1/);
+    });
+    it('takes over old lock directory with corrupt meta', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const lockDir = lockDirPath(lockPath);
+        await fs.mkdir(lockDir);
+        await fs.writeFile(path.join(lockDir, 'meta.json'), 'not-json', 'utf-8');
+        const past = new Date(Date.now() - 3000);
+        await fs.utimes(lockDir, past, past);
+        await acquirePidLock(lockPath);
+        const raw = await fs.readFile(path.join(lockDir, 'meta.json'), 'utf-8');
+        const meta = JSON.parse(raw);
+        expect(meta.pid).toBe(process.pid);
+    });
+    it('blocks while lock directory is initializing (meta missing, <2s old)', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const lockDir = lockDirPath(lockPath);
+        await fs.mkdir(lockDir);
+        await expect(acquirePidLock(lockPath)).rejects.toThrow(/initializing/);
+    });
+    it('allows only one winner under concurrent acquisition attempts', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const [a, b] = await Promise.allSettled([acquirePidLock(lockPath), acquirePidLock(lockPath)]);
+        const successes = [a, b].filter((r) => r.status === 'fulfilled');
+        const failures = [a, b].filter((r) => r.status === 'rejected');
+        expect(successes).toHaveLength(1);
+        expect(failures).toHaveLength(1);
+    });
+    it('removes stale legacy PID lock file before acquiring lock directory', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        await fs.writeFile(lockPath, '999999999', 'utf-8');
+        await acquirePidLock(lockPath);
+        await expect(fs.access(lockPath)).rejects.toThrow();
+        const raw = await fs.readFile(path.join(lockDirPath(lockPath), 'meta.json'), 'utf-8');
+        const meta = JSON.parse(raw);
+        expect(meta.pid).toBe(process.pid);
+    });
+    it('rejects when a live legacy PID lock file exists', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        await fs.writeFile(lockPath, '1', 'utf-8');
+        await expect(acquirePidLock(lockPath)).rejects.toThrow(/already running.*PID 1/);
+    });
+});
+describe('releasePidLock', () => {
+    const paths = [];
+    afterEach(async () => {
+        for (const p of paths) {
+            await fs.rm(path.dirname(p), { recursive: true, force: true });
+        }
+        paths.length = 0;
+    });
+    it('removes the lock directory for current holder', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const lockDir = lockDirPath(lockPath);
+        await acquirePidLock(lockPath);
+        await releasePidLock(lockPath);
+        await expect(fs.access(lockDir)).rejects.toThrow();
+    });
+    it('does not remove lock directory when meta belongs to another PID', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        const lockDir = lockDirPath(lockPath);
+        await fs.mkdir(lockDir);
+        await fs.writeFile(path.join(lockDir, 'meta.json'), JSON.stringify({ pid: 1, token: 'other-token', acquiredAt: new Date().toISOString() }), 'utf-8');
+        await releasePidLock(lockPath);
+        const stat = await fs.stat(lockDir);
+        expect(stat.isDirectory()).toBe(true);
+    });
+    it('does nothing when the lock directory does not exist', async () => {
+        const lockPath = await tmpLockPath();
+        paths.push(lockPath);
+        // Should not throw.
+        await releasePidLock(lockPath);
+    });
+});

package/dist/pipeline/engine.js

@@ -0,0 +1,206 @@
+import { execa } from 'execa';
+/**
+ * Replace `{{prev.output}}` and `{{steps.<id>.output}}` variables in a static
+ * string. Unresolvable references are returned verbatim.
+ */
+function interpolateTemplate(template, stepIndex, steps, outputs) {
+    return template.replace(/\{\{([^{}]+)\}\}/g, (match, keyRaw) => {
+        const key = keyRaw.trim();
+        if (key === 'prev.output') {
+            return stepIndex > 0 ? (outputs[stepIndex - 1] ?? '') : '';
+        }
+        const stepRef = /^steps\.(.+)\.output$/.exec(key);
+        if (stepRef) {
+            const refId = stepRef[1];
+            const refIdx = steps.findIndex((s, idx) => s.id === refId && idx < stepIndex);
+            if (refIdx === -1)
+                return match; // unresolvable — leave as literal
+            return outputs[refIdx] ?? match;
+        }
+        return match; // unrecognized pattern — leave as literal
+    });
+}
+/**
+ * Recursively walk a JSON-like value and apply `interpolateTemplate` to every
+ * string leaf. Non-string primitives and `null` are returned as-is.
+ */
+function interpolateDeep(value, stepIndex, steps, outputs) {
+    if (typeof value === 'string') {
+        return interpolateTemplate(value, stepIndex, steps, outputs);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => interpolateDeep(item, stepIndex, steps, outputs));
+    }
+    if (value !== null && typeof value === 'object') {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = interpolateDeep(v, stepIndex, steps, outputs);
+        }
+        return result;
+    }
+    return value;
+}
+/** Drain a runtime event stream, collecting final text. Throws on error events. */
+async function collectText(events, signal) {
+    let finalText = '';
+    let deltaText = '';
+    for await (const evt of events) {
+        if (evt.type === 'text_final') {
+            finalText = evt.text;
+        }
+        else if (evt.type === 'text_delta') {
+            deltaText += evt.text;
+        }
+        else if (evt.type === 'error') {
+            throw new Error(evt.message);
+        }
+        // Check abort after processing the current event so we don't discard it.
+        if (signal?.aborted)
+            break;
+    }
+    return finalText || deltaText;
+}
+/**
+ * Execute a sequence of steps where each step's text output is made
+ * available as context for subsequent steps.
+ */
+export async function runPipeline(def) {
+    const { steps, runtime, cwd, model, signal, onProgress, confirmAllowed } = def;
+    const outputs = [];
+    // Validate step IDs — duplicates are rejected up-front.
+    const seenIds = new Set();
+    for (const s of steps) {
+        if (s.id !== undefined) {
+            if (seenIds.has(s.id))
+                throw new Error(`Duplicate step ID: "${s.id}"`);
+            seenIds.add(s.id);
+        }
+    }
+    for (let i = 0; i < steps.length; i++) {
+        if (signal?.aborted)
+            break;
+        const step = steps[i];
+        const stepId = step.id ?? String(i);
+        const ctx = {
+            stepIndex: i,
+            previousOutput: outputs.length > 0 ? outputs[outputs.length - 1] : '',
+            allOutputs: outputs,
+        };
+        // --- Shell step ---
+        if (step.kind === 'shell') {
+            const shellBinary = step.command[0];
+            if (!shellBinary || shellBinary.trim() === '') {
+                throw new Error(`Pipeline step ${i} failed: shell: command must include a non-empty executable`);
+            }
+            if (step.confirm && !confirmAllowed) {
+                throw new Error(`Pipeline step ${i}: confirm=true requires confirmAllowed on the pipeline`);
+            }
+            if (step.dryRun) {
+                outputs.push('');
+                const argCount = step.command.length - 1;
+                onProgress?.(`step ${stepId}: dry-run (${shellBinary}, ${argCount} arg${argCount !== 1 ? 's' : ''})`);
+                continue;
+            }
+            // Interpolate template variables in command args before execution.
+            const interpolatedCommand = step.command.map((arg) => interpolateTemplate(arg, i, steps, outputs));
+            if (!interpolatedCommand[0] || interpolatedCommand[0].trim() === '') {
+                throw new Error(`Pipeline step ${i} failed: shell: command resolved to an empty executable`);
+            }
+            let text;
+            try {
+                const result = await execa(interpolatedCommand[0], interpolatedCommand.slice(1), {
+                    reject: false,
+                    timeout: step.timeoutMs,
+                    cancelSignal: signal,
+                    cwd: step.cwd ?? cwd,
+                });
+                if (result.isCanceled) {
+                    throw new Error('shell: command canceled');
+                }
+                if (result.timedOut) {
+                    throw new Error(`shell: command timed out after ${step.timeoutMs ?? 0}ms`);
+                }
+                if (result.failed && result.exitCode == null) {
+                    throw new Error('shell: command failed to spawn');
+                }
+                if (result.exitCode !== 0) {
+                    const parts = [`shell: command exited with code ${result.exitCode}`];
+                    if (result.signal)
+                        parts.push(`(signal: ${result.signal})`);
+                    throw new Error(parts.join(' '));
+                }
+                text = result.stdout.trimEnd();
+            }
+            catch (err) {
+                if (step.onError === 'skip') {
+                    outputs.push('');
+                    onProgress?.(`step ${stepId}: skipped`);
+                    continue;
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`Pipeline step ${i} failed: ${message}`);
+            }
+            outputs.push(text);
+            onProgress?.(`step ${stepId}: done`);
+            continue;
+        }
+        // --- Discord action step ---
+        if (step.kind === 'discord-action') {
+            const resolvedActions = typeof step.actions === 'function' ? step.actions(ctx) : step.actions;
+            const interpolatedActions = interpolateDeep(resolvedActions, i, steps, outputs);
+            let results;
+            try {
+                results = await step.execute(interpolatedActions);
+                const failed = results.filter((r) => !r.ok);
+                if (failed.length > 0) {
+                    const errorMsg = failed.map((r) => r.error ?? 'action failed').join('; ');
+                    throw new Error(errorMsg);
+                }
+            }
+            catch (err) {
+                if (step.onError === 'skip') {
+                    outputs.push('');
+                    onProgress?.(`step ${stepId}: skipped`);
+                    continue;
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`Pipeline step ${i} failed: ${message}`);
+            }
+            outputs.push(JSON.stringify(results));
+            onProgress?.(`step ${stepId}: done`);
+            continue;
+        }
+        // --- Prompt step ---
+        const resolvedPrompt = typeof step.prompt === 'function'
+            ? step.prompt(ctx)
+            : interpolateTemplate(step.prompt, i, steps, outputs);
+        const stepRuntime = step.runtime ?? runtime;
+        const invokeParams = {
+            prompt: resolvedPrompt,
+            model: step.model ?? model,
+            cwd,
+            signal,
+            ...(step.tools !== undefined && { tools: step.tools }),
+            ...(step.addDirs !== undefined && { addDirs: step.addDirs }),
+            ...(step.timeoutMs !== undefined && { timeoutMs: step.timeoutMs }),
+            ...(step.sessionId !== undefined && { sessionId: step.sessionId }),
+            ...(step.sessionKey !== undefined && { sessionKey: step.sessionKey }),
+        };
+        let text;
+        try {
+            text = await collectText(stepRuntime.invoke(invokeParams), signal);
+        }
+        catch (err) {
+            if (step.onError === 'skip') {
+                outputs.push('');
+                onProgress?.(`step ${stepId}: skipped`);
+                continue;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Pipeline step ${i} failed: ${message}`);
+        }
+        outputs.push(text);
+        onProgress?.(`step ${stepId}: done`);
+    }
+    return { outputs };
+}