salmon-loop 0.2.3

package/dist/core/tools/mcp/streamable-http.js

@@ -0,0 +1,101 @@
+import { getLogger } from '../../observability/logger.js';
+export const MCP_PROTOCOL_VERSION = '2025-11-25';
+function normalizeHeaderValue(value) {
+    return value ? value.trim().toLowerCase() : '';
+}
+export function isEventStreamResponse(response) {
+    const contentType = normalizeHeaderValue(response.headers.get('content-type'));
+    return contentType.includes('text/event-stream');
+}
+export async function* decodeSseEvents(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    function takeEventBlocks() {
+        const blocks = [];
+        while (true) {
+            const idx = buffer.indexOf('\n\n');
+            const idxCr = buffer.indexOf('\r\n\r\n');
+            const splitAt = idx === -1 ? idxCr : idxCr === -1 ? idx : Math.min(idx, idxCr);
+            if (splitAt === -1)
+                break;
+            const separatorLen = buffer.startsWith('\r\n\r\n', splitAt) ? 4 : 2;
+            blocks.push(buffer.slice(0, splitAt));
+            buffer = buffer.slice(splitAt + separatorLen);
+        }
+        return blocks;
+    }
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            for (const block of takeEventBlocks()) {
+                const lines = block.split(/\r?\n/);
+                const event = { data: '' };
+                const dataLines = [];
+                for (const line of lines) {
+                    if (!line)
+                        continue;
+                    if (line.startsWith(':'))
+                        continue;
+                    const colon = line.indexOf(':');
+                    const field = (colon === -1 ? line : line.slice(0, colon)).trim();
+                    const rawValue = colon === -1 ? '' : line.slice(colon + 1).trimStart();
+                    if (field === 'id')
+                        event.id = rawValue;
+                    else if (field === 'event')
+                        event.event = rawValue;
+                    else if (field === 'retry') {
+                        const parsed = Number.parseInt(rawValue, 10);
+                        if (!Number.isNaN(parsed))
+                            event.retry = parsed;
+                    }
+                    else if (field === 'data')
+                        dataLines.push(rawValue);
+                }
+                event.data = dataLines.join('\n');
+                yield event;
+            }
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+export function createMcpHeaders(options) {
+    const headers = {
+        Accept: 'application/json, text/event-stream',
+        'Content-Type': 'application/json',
+        'MCP-Protocol-Version': MCP_PROTOCOL_VERSION,
+        ...(options.extra ?? {}),
+    };
+    if (options.sessionId)
+        headers['MCP-Session-Id'] = options.sessionId;
+    return headers;
+}
+export function assertOk(response, context) {
+    if (!response.ok) {
+        throw new Error(`${context} failed with HTTP ${response.status}`);
+    }
+}
+export async function safeDrainResponse(response) {
+    try {
+        if (response.body) {
+            await response.arrayBuffer();
+        }
+    }
+    catch (err) {
+        getLogger().debug(`Failed to drain response body: ${String(err)}`);
+    }
+}
+export async function delayMs(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=streamable-http.js.map

package/dist/core/tools/mcp/types.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/**
+ * Configuration for an MCP server connection.
+ */
+export const McpServerConfigSchema = z
+    .object({
+    name: z.string(),
+    command: z.string().optional(),
+    url: z.string().url().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    cwd: z.string().optional(),
+})
+    .superRefine((value, ctx) => {
+    const hasCommand = Boolean(value.command);
+    const hasUrl = Boolean(value.url);
+    if (hasCommand === hasUrl) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'MCP config must include exactly one of "command" or "url".',
+            path: ['command'],
+        });
+    }
+});
+//# sourceMappingURL=types.js.map

package/dist/core/tools/parallel/isolation.js

@@ -0,0 +1,25 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdtemp, rm } from '../../adapters/fs/node-fs.js';
+export class IsolationManager {
+    async create() {
+        const tmpDir = await mkdtemp(join(tmpdir(), 'salmon-parallel-'));
+        const tempIndex = join(tmpDir, 'index');
+        return {
+            tmpDir,
+            env: {
+                GIT_INDEX_FILE: tempIndex,
+                TMPDIR: tmpDir,
+            },
+            dispose: async () => {
+                try {
+                    await rm(tmpDir, { recursive: true, force: true });
+                }
+                catch (_e) {
+                    // Ignore cleanup errors
+                }
+            },
+        };
+    }
+}
+//# sourceMappingURL=isolation.js.map

package/dist/core/tools/parallel/lock-manager.js

@@ -0,0 +1,124 @@
+function keyToString(k) {
+    switch (k.kind) {
+        case 'repo':
+            return `repo:${k.id}`;
+        case 'pathPrefix':
+            return `path:${k.repoId}:${k.prefix}`;
+        case 'snapshot':
+            return `snap:${k.id}`;
+        case 'network':
+            return `net:${k.scope}`;
+        case 'process':
+            return `proc:${k.scope}:${k.repoId ?? ''}`;
+    }
+}
+class RWLock {
+    readers = 0;
+    writer = false;
+    queue = [];
+    async acquire(mode, signal) {
+        if (signal.aborted)
+            throw new Error('Lock acquisition aborted');
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                const idx = this.queue.findIndex((q) => q.resolve === resolve);
+                if (idx !== -1) {
+                    this.queue.splice(idx, 1);
+                }
+                reject(new Error('Lock acquisition aborted'));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            const tryAcquire = () => {
+                if (mode === 'read') {
+                    if (!this.writer && this.queue.length === 0) {
+                        this.readers++;
+                        signal.removeEventListener('abort', onAbort);
+                        return resolve(() => this.releaseRead());
+                    }
+                }
+                else {
+                    if (!this.writer && this.readers === 0) {
+                        this.writer = true;
+                        signal.removeEventListener('abort', onAbort);
+                        return resolve(() => this.releaseWrite());
+                    }
+                }
+                this.queue.push({ mode, resolve, reject, signal, onAbort });
+            };
+            tryAcquire();
+        });
+    }
+    releaseRead() {
+        this.readers--;
+        this.drain();
+    }
+    releaseWrite() {
+        this.writer = false;
+        this.drain();
+    }
+    drain() {
+        if (this.writer)
+            return;
+        // Writer priority to avoid starvation
+        const nextWriterIdx = this.queue.findIndex((q) => q.mode === 'write');
+        if (nextWriterIdx === 0 && this.readers === 0) {
+            const w = this.queue.shift();
+            w.signal.removeEventListener('abort', w.onAbort);
+            this.writer = true;
+            w.resolve(() => this.releaseWrite());
+            return;
+        }
+        // Release all consecutive readers at the front
+        while (this.queue.length > 0 && this.queue[0].mode === 'read' && !this.writer) {
+            const r = this.queue.shift();
+            this.readers++;
+            r.signal.removeEventListener('abort', r.onAbort);
+            r.resolve(() => this.releaseRead());
+        }
+        // If head is write and no readers, release it
+        if (this.queue.length > 0 &&
+            this.queue[0].mode === 'write' &&
+            this.readers === 0 &&
+            !this.writer) {
+            const w = this.queue.shift();
+            this.writer = true;
+            w.signal.removeEventListener('abort', w.onAbort);
+            w.resolve(() => this.releaseWrite());
+        }
+    }
+}
+export class InMemoryLockManager {
+    locks = new Map();
+    async acquire(keys, mode, signal) {
+        // Sort keys to prevent ABBA deadlocks
+        const ks = [...keys].map(keyToString).sort();
+        const releases = [];
+        try {
+            for (const k of ks) {
+                let lock = this.locks.get(k);
+                if (!lock) {
+                    lock = new RWLock();
+                    this.locks.set(k, lock);
+                }
+                const release = await lock.acquire(mode, signal);
+                releases.push(release);
+            }
+        }
+        catch (e) {
+            // Rollback: release all acquired locks in reverse order
+            for (let i = releases.length - 1; i >= 0; i--) {
+                releases[i]();
+            }
+            throw e;
+        }
+        return {
+            release() {
+                // Release in reverse order of acquisition
+                for (let i = releases.length - 1; i >= 0; i--) {
+                    releases[i]();
+                }
+            },
+        };
+    }
+}
+//# sourceMappingURL=lock-manager.js.map

package/dist/core/tools/parallel/persistence.js

@@ -0,0 +1,126 @@
+import path from 'path';
+import { syncFs as fs } from '../../adapters/fs/node-fs.js';
+/**
+ * Persistence layer for parallel execution plans.
+ * Supports saving, loading, and listing plans from the .salmonloop/parallel directory.
+ */
+export class PlanPersistence {
+    /**
+     * Gets the directory where parallel plans are stored.
+     * @param repoRoot The absolute path to the repository root.
+     */
+    static getPersistenceDir(repoRoot) {
+        return path.join(repoRoot, '.salmonloop', 'parallel');
+    }
+    /**
+     * Saves a plan and its current result/state.
+     * @param repoRoot The absolute path to the persistence root (usually the base repo).
+     * @param plan The execution plan to save.
+     * @param result The current result/state of the plan.
+     * @param runtime Optional runtime metadata (best-effort, for resuming/debugging).
+     */
+    static async save(repoRoot, plan, result, runtime) {
+        const dir = this.getPersistenceDir(repoRoot);
+        await fs.mkdir(dir, { recursive: true });
+        const state = {
+            version: 1,
+            plan,
+            result,
+            runtime,
+            updatedAt: new Date().toISOString(),
+        };
+        const filePath = path.join(dir, `${plan.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf8');
+    }
+    /**
+     * Loads a persisted plan state by its ID.
+     * @param repoRoot The absolute path to the repository root.
+     * @param planId The ID of the plan to load.
+     */
+    static async load(repoRoot, planId) {
+        const filePath = path.join(this.getPersistenceDir(repoRoot), `${planId}.json`);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (_error) {
+            if (_error.code === 'ENOENT') {
+                return null;
+            }
+            throw _error;
+        }
+    }
+    /**
+     * Lists all persisted plan states.
+     * @param repoRoot The absolute path to the repository root.
+     */
+    static async listAll(repoRoot) {
+        const dir = this.getPersistenceDir(repoRoot);
+        try {
+            const files = await fs.readdir(dir);
+            const jsonFiles = files.filter((f) => f.endsWith('.json'));
+            const states = [];
+            for (const file of jsonFiles) {
+                try {
+                    const content = await fs.readFile(path.join(dir, file), 'utf8');
+                    states.push(JSON.parse(content));
+                }
+                catch (_error) {
+                    // Skip malformed or unreadable files
+                    continue;
+                }
+            }
+            return states;
+        }
+        catch (_error) {
+            if (_error.code === 'ENOENT') {
+                return [];
+            }
+            throw _error;
+        }
+    }
+    /**
+     * Lists plans that are currently pending or blocked by approval.
+     * @param repoRoot The absolute path to the repository root.
+     */
+    static async listPendingOrBlocked(repoRoot) {
+        const allStates = await this.listAll(repoRoot);
+        return allStates.filter((state) => {
+            // If it's explicitly failed or canceled, it's not pending/blocked
+            if (state.result.failed || state.result.canceled) {
+                return false;
+            }
+            // If there are blocked approvals, it's blocked
+            if (state.result.blockedApprovals && state.result.blockedApprovals.length > 0) {
+                return true;
+            }
+            // Check if any node results indicate it's not finished
+            const results = Object.values(state.result.nodeResults);
+            if (results.length === 0) {
+                return true; // Empty plan or just started
+            }
+            const hasIncomplete = results.some((r) => r.status === 'PENDING' ||
+                r.status === 'READY' ||
+                r.status === 'RUNNING' ||
+                r.status === 'BLOCKED_APPROVAL');
+            return hasIncomplete;
+        });
+    }
+    /**
+     * Deletes a persisted plan state.
+     * @param repoRoot The absolute path to the repository root.
+     * @param planId The ID of the plan to delete.
+     */
+    static async delete(repoRoot, planId) {
+        const filePath = path.join(this.getPersistenceDir(repoRoot), `${planId}.json`);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch (_error) {
+            if (_error.code !== 'ENOENT') {
+                throw _error;
+            }
+        }
+    }
+}
+//# sourceMappingURL=persistence.js.map

package/dist/core/tools/parallel/plan-builder.js

@@ -0,0 +1,66 @@
+export class PlanBuilder {
+    id;
+    nodes = new Map();
+    dependencies = new Map();
+    constructor(id = `plan-${Date.now()}`) {
+        this.id = id;
+    }
+    addNode(toolName, args, id) {
+        const nodeId = id || `node-${this.nodes.size}`;
+        if (this.nodes.has(nodeId)) {
+            throw new Error(`Node with id ${nodeId} already exists`);
+        }
+        this.nodes.set(nodeId, {
+            id: nodeId,
+            toolName,
+            args,
+            deps: [],
+        });
+        return nodeId;
+    }
+    depends(on, next) {
+        if (!this.nodes.has(on))
+            throw new Error(`Node ${on} not found`);
+        if (!this.nodes.has(next))
+            throw new Error(`Node ${next} not found`);
+        let deps = this.dependencies.get(next);
+        if (!deps) {
+            deps = new Set();
+            this.dependencies.set(next, deps);
+        }
+        deps.add(on);
+        return this;
+    }
+    parallel(_ids) {
+        // No explicit dependencies between these nodes
+        return this;
+    }
+    serial(ids) {
+        for (let i = 0; i < ids.length - 1; i++) {
+            this.depends(ids[i], ids[i + 1]);
+        }
+        return this;
+    }
+    ref(nodeId) {
+        return { $ref: 'nodeOutput', nodeId };
+    }
+    refPath(nodeId, path) {
+        return { $ref: 'nodeOutputPath', nodeId, path };
+    }
+    build(policy) {
+        const nodes = [];
+        for (const [id, node] of this.nodes) {
+            const deps = Array.from(this.dependencies.get(id) || []);
+            nodes.push({
+                ...node,
+                deps,
+            });
+        }
+        return {
+            id: this.id,
+            nodes,
+            policy,
+        };
+    }
+}
+//# sourceMappingURL=plan-builder.js.map

package/dist/core/tools/parallel/plan.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plan.js.map

package/dist/core/tools/parallel/refs.js

@@ -0,0 +1,7 @@
+export function isOutputRef(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        (v.$ref === 'nodeOutput' || v.$ref === 'nodeOutputPath') &&
+        typeof v.nodeId === 'string');
+}
+//# sourceMappingURL=refs.js.map

package/dist/core/tools/parallel/resolve-args.js

@@ -0,0 +1,50 @@
+import { isOutputRef } from './refs.js';
+/**
+ * Resolves a path within an object (e.g., "a.b[0].c")
+ */
+function getValueAtPath(obj, path) {
+    if (!path)
+        return obj;
+    const parts = path.split(/[.[\]]+/).filter(Boolean);
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Recursively resolves OutputRef instances in an arguments object
+ * using the results from previously executed nodes.
+ */
+export function resolveArgsWithResults(args, results) {
+    if (isOutputRef(args)) {
+        const ref = args;
+        const nodeResult = results[ref.nodeId];
+        if (!nodeResult) {
+            throw new Error(`Reference to unknown node: ${ref.nodeId}`);
+        }
+        if (nodeResult.status !== 'SUCCEEDED') {
+            throw new Error(`Reference to node ${ref.nodeId} which has status ${nodeResult.status}`);
+        }
+        if (ref.$ref === 'nodeOutput') {
+            return nodeResult.output;
+        }
+        else {
+            return getValueAtPath(nodeResult.output, ref.path);
+        }
+    }
+    if (Array.isArray(args)) {
+        return args.map((item) => resolveArgsWithResults(item, results));
+    }
+    if (args !== null && typeof args === 'object') {
+        const resolved = {};
+        for (const [key, value] of Object.entries(args)) {
+            resolved[key] = resolveArgsWithResults(value, results);
+        }
+        return resolved;
+    }
+    return args;
+}
+//# sourceMappingURL=resolve-args.js.map

package/dist/core/tools/parallel/resource-helpers.js

@@ -0,0 +1,35 @@
+import path from 'path';
+const toPosix = (value) => value.replace(/\\/g, '/');
+const normalizePrefix = (value) => {
+    const trimmed = toPosix(value).replace(/^\/+/, '');
+    if (!trimmed || trimmed === '.')
+        return '';
+    if (trimmed.endsWith('/')) {
+        return trimmed;
+    }
+    const dir = path.posix.dirname(trimmed);
+    if (dir === '.' || dir === '')
+        return '';
+    return dir.endsWith('/') ? dir : `${dir}/`;
+};
+export const repoResource = (ctx) => ({
+    kind: 'repo',
+    id: ctx.repoRoot,
+});
+export const processResource = (ctx) => ({
+    kind: 'process',
+    scope: 'repo',
+    repoId: ctx.repoRoot,
+});
+export const pathPrefixResource = (ctx, relativePath) => {
+    const prefix = normalizePrefix(relativePath);
+    if (!prefix) {
+        return repoResource(ctx);
+    }
+    return {
+        kind: 'pathPrefix',
+        repoId: ctx.repoRoot,
+        prefix,
+    };
+};
+//# sourceMappingURL=resource-helpers.js.map

package/dist/core/tools/parallel/resources.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resources.js.map