salmon-loop 0.2.3

package/dist/core/runtime/sidecar-route-catalog.js

@@ -0,0 +1,103 @@
+export const defaultSidecarRouteCatalog = [
+    {
+        id: 'health',
+        method: 'GET',
+        path: '/health',
+        exposure: 'essential',
+        scope: 'uds',
+        policyTag: 'sidecar.health.read',
+    },
+    {
+        id: 'status',
+        method: 'GET',
+        path: '/status',
+        exposure: 'essential',
+        scope: 'uds',
+        policyTag: 'sidecar.status.read',
+    },
+    {
+        id: 'info',
+        method: 'GET',
+        path: '/info',
+        exposure: 'essential',
+        scope: 'uds',
+        policyTag: 'sidecar.info.read',
+    },
+    {
+        id: 'abort',
+        method: 'POST',
+        path: '/abort',
+        exposure: 'essential',
+        scope: 'uds',
+        policyTag: 'sidecar.task.abort',
+    },
+    {
+        id: 'workspace_files',
+        method: 'GET',
+        path: '/workspace/files',
+        exposure: 'conditional',
+        scope: 'uds',
+        policyTag: 'sidecar.workspace.files',
+    },
+    {
+        id: 'logs_stream',
+        method: 'GET',
+        path: '/logs/stream',
+        exposure: 'conditional',
+        scope: 'uds',
+        policyTag: 'sidecar.logs.stream',
+    },
+    {
+        id: 'config_patch',
+        method: 'PATCH',
+        path: '/config',
+        exposure: 'conditional',
+        scope: 'uds',
+        policyTag: 'sidecar.config.patch',
+    },
+    {
+        id: 'shutdown',
+        method: 'POST',
+        path: '/shutdown',
+        exposure: 'forbidden',
+        scope: 'uds',
+        policyTag: 'sidecar.shutdown',
+    },
+    {
+        id: 'config_get',
+        method: 'GET',
+        path: '/config',
+        exposure: 'forbidden',
+        scope: 'uds',
+        policyTag: 'sidecar.config.read',
+    },
+    {
+        id: 'terminal_exec',
+        method: 'POST',
+        path: '/terminal/exec',
+        exposure: 'forbidden',
+        scope: 'uds',
+        policyTag: 'sidecar.terminal.exec',
+    },
+];
+export function buildSidecarRouteDescriptors(input) {
+    const catalog = input.catalog ?? defaultSidecarRouteCatalog;
+    const descriptors = [];
+    const missing = [];
+    for (const route of catalog) {
+        if (route.exposure === 'forbidden')
+            continue;
+        const handler = input.handlers[route.id];
+        if (!handler) {
+            missing.push(route.id);
+            continue;
+        }
+        const { id: _id, ...descriptor } = route;
+        descriptors.push({ ...descriptor, handler });
+    }
+    if (input.strict && missing.length > 0) {
+        throw new Error(`Missing sidecar handler: ${missing[0]}`);
+    }
+    return descriptors;
+}
+//# sourceMappingURL=sidecar-route-catalog.js.map

package/dist/core/runtime/spawn-command.js

@@ -0,0 +1,392 @@
+import { spawn } from 'child_process';
+import { getBunRuntime, normalizeSignal } from './bun-runtime.js';
+function toBuffer(chunk) {
+    if (Buffer.isBuffer(chunk))
+        return chunk;
+    if (chunk instanceof Uint8Array)
+        return Buffer.from(chunk);
+    if (typeof chunk === 'string')
+        return Buffer.from(chunk);
+    return Buffer.from(String(chunk ?? ''));
+}
+function writeInput(target, input) {
+    if (input !== undefined)
+        target.write?.(input);
+    target.end?.();
+}
+function createKillProcess(processLike, detached) {
+    const isWin = process.platform === 'win32';
+    return (signal) => {
+        try {
+            if (!isWin && detached && typeof processLike.pid === 'number') {
+                process.kill(-processLike.pid, signal);
+                return;
+            }
+        }
+        catch {
+            // Fall back to child kill.
+        }
+        try {
+            processLike.kill(signal);
+        }
+        catch {
+            // Ignore kill errors.
+        }
+    };
+}
+function createFailure(input, params) {
+    return {
+        command: input.command,
+        args: input.args ?? [],
+        ...params,
+    };
+}
+function createCaptureState() {
+    return {
+        stdout: '',
+        stderr: '',
+        stdoutBytes: 0,
+        stderrBytes: 0,
+        stdoutTruncated: false,
+        stderrTruncated: false,
+    };
+}
+function appendStdout(state, input, chunk) {
+    input.onStdoutChunk?.(chunk);
+    if (state.stdoutTruncated)
+        return;
+    const maxStdoutBytes = input.maxStdoutBytes ?? Number.POSITIVE_INFINITY;
+    if (maxStdoutBytes <= 0) {
+        state.stdoutTruncated = true;
+        return;
+    }
+    const buffer = Buffer.from(chunk);
+    const remaining = maxStdoutBytes - state.stdoutBytes;
+    if (buffer.length <= remaining) {
+        state.stdout += buffer.toString();
+        state.stdoutBytes += buffer.length;
+        return;
+    }
+    if (remaining > 0) {
+        state.stdout += buffer.subarray(0, remaining).toString();
+        state.stdoutBytes += remaining;
+    }
+    state.stdoutTruncated = true;
+}
+function appendStderr(state, input, chunk) {
+    input.onStderrChunk?.(chunk);
+    if (state.stderrTruncated)
+        return;
+    const maxStderrBytes = input.maxStderrBytes ?? Number.POSITIVE_INFINITY;
+    if (maxStderrBytes <= 0) {
+        state.stderrTruncated = true;
+        return;
+    }
+    const buffer = Buffer.from(chunk);
+    const remaining = maxStderrBytes - state.stderrBytes;
+    if (buffer.length <= remaining) {
+        state.stderr += buffer.toString();
+        state.stderrBytes += buffer.length;
+        return;
+    }
+    if (remaining > 0) {
+        state.stderr += buffer.subarray(0, remaining).toString();
+        state.stderrBytes += remaining;
+    }
+    state.stderrTruncated = true;
+}
+function finalizeResult(input, state, params) {
+    let failure;
+    if (params.error) {
+        failure = createFailure(input, {
+            kind: 'spawn_error',
+            message: params.error.message,
+            code: params.error.code,
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    else if (params.aborted) {
+        failure = createFailure(input, {
+            kind: 'aborted',
+            message: 'Command aborted',
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    else if (params.timedOut) {
+        failure = createFailure(input, {
+            kind: 'timeout',
+            message: 'Command timed out',
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    else if (params.code !== 0) {
+        failure = createFailure(input, {
+            kind: 'nonzero_exit',
+            message: `Command exited with code ${String(params.code)}`,
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    return {
+        code: params.code,
+        signal: params.signal,
+        timedOut: params.timedOut,
+        aborted: params.aborted,
+        error: params.error,
+        failure,
+        stdout: state.stdout,
+        stderr: state.stderr,
+        stdoutTruncated: state.stdoutTruncated,
+        stderrTruncated: state.stderrTruncated,
+    };
+}
+async function pumpBunStream(stream, onChunk) {
+    if (!stream)
+        return;
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            if (value)
+                onChunk(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function spawnWithBun(input) {
+    if (input.signal?.aborted) {
+        return finalizeResult(input, createCaptureState(), {
+            code: null,
+            signal: null,
+            timedOut: false,
+            aborted: true,
+        });
+    }
+    const bun = getBunRuntime();
+    if (!bun) {
+        throw new Error('Bun runtime is not available');
+    }
+    const state = createCaptureState();
+    let subprocess;
+    const bunStdin = input.stdin === undefined ? 'ignore' : input.stdin;
+    try {
+        subprocess = bun.spawn([input.command, ...(input.args ?? [])], {
+            cwd: input.cwd,
+            env: input.env,
+            stdin: bunStdin,
+            stdout: 'pipe',
+            stderr: 'pipe',
+            detached: input.detached,
+            windowsHide: input.windowsHide,
+        });
+    }
+    catch (error) {
+        let code;
+        let message;
+        if (error instanceof Error) {
+            if ('code' in error) {
+                code = error.code;
+            }
+            message = error.message;
+        }
+        else {
+            message = String(error);
+        }
+        return finalizeResult(input, state, {
+            code: -1,
+            signal: null,
+            timedOut: false,
+            error: { code, message },
+        });
+    }
+    if (bunStdin === 'pipe') {
+        writeInput(subprocess.stdin ?? {}, input.stdin);
+    }
+    let timedOut = false;
+    let aborted = false;
+    let killTimer;
+    let timeoutTimer;
+    const killGraceMs = input.killGraceMs ?? 2000;
+    const killProcess = createKillProcess(subprocess, input.detached);
+    if (typeof input.timeoutMs === 'number' && input.timeoutMs > 0) {
+        timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            killProcess('SIGTERM');
+            killTimer = setTimeout(() => killProcess('SIGKILL'), killGraceMs);
+        }, input.timeoutMs);
+    }
+    let onAbort;
+    if (input.signal) {
+        onAbort = () => {
+            aborted = true;
+            killProcess('SIGTERM');
+            killTimer = setTimeout(() => killProcess('SIGKILL'), killGraceMs);
+        };
+        input.signal.addEventListener('abort', onAbort, { once: true });
+    }
+    const stdoutPump = pumpBunStream(subprocess.stdout, (chunk) => appendStdout(state, input, chunk));
+    const stderrPump = pumpBunStream(subprocess.stderr, (chunk) => appendStderr(state, input, chunk));
+    let code = null;
+    let error;
+    try {
+        code = await subprocess.exited;
+    }
+    catch (err) {
+        let errorCode;
+        let errorMessage;
+        if (err instanceof Error) {
+            if ('code' in err) {
+                errorCode = err.code;
+            }
+            errorMessage = err.message;
+        }
+        else {
+            errorMessage = String(err);
+        }
+        error = { code: errorCode, message: errorMessage };
+        code = -1;
+    }
+    finally {
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+        if (killTimer)
+            clearTimeout(killTimer);
+        if (input.signal && onAbort) {
+            input.signal.removeEventListener('abort', onAbort);
+        }
+    }
+    await Promise.all([stdoutPump, stderrPump]);
+    return finalizeResult(input, state, {
+        code,
+        signal: normalizeSignal(subprocess.signalCode),
+        timedOut,
+        aborted,
+        error,
+    });
+}
+async function spawnWithNode(input) {
+    if (input.signal?.aborted) {
+        return finalizeResult(input, createCaptureState(), {
+            code: null,
+            signal: null,
+            timedOut: false,
+            aborted: true,
+        });
+    }
+    const state = createCaptureState();
+    return await new Promise((resolve) => {
+        let timedOut = false;
+        let aborted = false;
+        let settled = false;
+        let killTimer;
+        let timeoutTimer;
+        let onAbort;
+        const child = spawn(input.command, input.args ?? [], {
+            cwd: input.cwd,
+            env: input.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: input.windowsHide,
+            detached: input.detached,
+        });
+        const settle = (code, signal, error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (input.signal && onAbort) {
+                input.signal.removeEventListener('abort', onAbort);
+            }
+            resolve(finalizeResult(input, state, {
+                code,
+                signal,
+                timedOut,
+                aborted,
+                error,
+            }));
+        };
+        const killProcess = createKillProcess({
+            pid: child.pid,
+            kill: (signal) => child.kill(signal),
+        }, input.detached);
+        const onStdoutData = (chunk) => appendStdout(state, input, toBuffer(chunk));
+        const onStderrData = (chunk) => appendStderr(state, input, toBuffer(chunk));
+        child.stdout?.on('data', onStdoutData);
+        child.stderr?.on('data', onStderrData);
+        child.on('error', (error) => {
+            if (aborted) {
+                settle(null, null);
+                return;
+            }
+            let errorCode;
+            let errorMessage;
+            if (error instanceof Error) {
+                if ('code' in error) {
+                    errorCode = error.code;
+                }
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            settle(-1, null, { code: errorCode, message: errorMessage });
+        });
+        child.on('close', (code, signal) => {
+            settle(code, normalizeSignal(signal));
+        });
+        writeInput(child.stdin ?? {}, input.stdin);
+        if (typeof input.timeoutMs === 'number' && input.timeoutMs > 0) {
+            const killGraceMs = input.killGraceMs ?? 2000;
+            timeoutTimer = setTimeout(() => {
+                timedOut = true;
+                killProcess('SIGTERM');
+                killTimer = setTimeout(() => killProcess('SIGKILL'), killGraceMs);
+            }, input.timeoutMs);
+        }
+        if (input.signal) {
+            onAbort = () => {
+                aborted = true;
+                killProcess('SIGTERM');
+                killTimer = setTimeout(() => killProcess('SIGKILL'), input.killGraceMs ?? 2000);
+            };
+            input.signal.addEventListener('abort', onAbort, { once: true });
+        }
+    });
+}
+export async function spawnCommandLocal(input) {
+    if (getBunRuntime()) {
+        return await spawnWithBun(input);
+    }
+    return await spawnWithNode(input);
+}
+export async function isCommandAvailableLocal(command) {
+    const bun = getBunRuntime();
+    if (bun?.which) {
+        return Boolean(bun.which(command));
+    }
+    const result = await spawnCommandLocal({
+        command,
+        args: ['--version'],
+        timeoutMs: 1500,
+        windowsHide: true,
+    });
+    if (!result.failure)
+        return result.code === 0;
+    if (result.failure.kind === 'spawn_error') {
+        const code = result.failure.code?.toLowerCase() ?? '';
+        if (code === 'enoent')
+            return false;
+        return !/not found|enoent/i.test(result.failure.message);
+    }
+    return result.code === 0;
+}
+//# sourceMappingURL=spawn-command.js.map

package/dist/core/runtime/spawn-interactive.js

@@ -0,0 +1,71 @@
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { getBunRuntime, normalizeSignal, toNodeReadableStream } from './bun-runtime.js';
+export function spawnInteractiveProcess(input) {
+    const bun = getBunRuntime();
+    if (bun) {
+        const subprocess = bun.spawn([input.command, ...(input.args ?? [])], {
+            cwd: input.cwd,
+            env: input.env,
+            stdin: 'pipe',
+            stdout: 'pipe',
+            stderr: 'pipe',
+            detached: input.detached,
+            windowsHide: input.windowsHide,
+        });
+        const events = new EventEmitter();
+        void subprocess.exited
+            .then((code) => {
+            events.emit('exit', code, normalizeSignal(subprocess.signalCode));
+        })
+            .catch((error) => {
+            events.emit('error', error);
+        });
+        const processRef = {
+            pid: subprocess.pid,
+            stdin: subprocess.stdin ?? undefined,
+            stdout: toNodeReadableStream(subprocess.stdout),
+            stderr: toNodeReadableStream(subprocess.stderr),
+            kill: (signal = 'SIGTERM') => {
+                try {
+                    subprocess.kill(signal);
+                }
+                catch {
+                    // Ignore kill errors.
+                }
+            },
+            on: (event, listener) => {
+                events.on(event, listener);
+                return processRef;
+            },
+        };
+        return processRef;
+    }
+    const child = spawn(input.command, input.args ?? [], {
+        cwd: input.cwd,
+        env: input.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: input.windowsHide,
+        detached: input.detached,
+    });
+    const processRef = {
+        pid: child.pid,
+        stdin: child.stdin ?? undefined,
+        stdout: child.stdout ?? undefined,
+        stderr: child.stderr ?? undefined,
+        kill: (signal = 'SIGTERM') => {
+            try {
+                child.kill(signal);
+            }
+            catch {
+                // Ignore kill errors.
+            }
+        },
+        on: (event, listener) => {
+            child.on(event, listener);
+            return processRef;
+        },
+    };
+    return processRef;
+}
+//# sourceMappingURL=spawn-interactive.js.map