salmon-loop 0.2.3

package/dist/core/runtime/initialize.js

@@ -0,0 +1,132 @@
+import { initializeDefaultCalculator } from '../context/policies/pack-until-full.js';
+import { createLogger, getLogger, setLogger, tryGetLogger } from '../observability/logger.js';
+import { createMonitor, setMonitor, tryGetMonitor } from '../observability/monitor.js';
+import { registerDefaultSubAgentProfiles } from '../sub-agent/registry-defaults.js';
+import { createSubAgentRegistry, setSubAgentRegistry, tryGetSubAgentRegistry, } from '../sub-agent/registry.js';
+/**
+ * Initializes the Core safety runtime.
+ * Mounts global error handlers and ensures environment safety.
+ */
+export function initializeRuntime() {
+    // Prevent duplicate initialization
+    if (globalThis.__SALMON_RUNTIME_INITIALIZED__)
+        return;
+    // Bypass interception in debug mode to allow raw console/stream output
+    if (process.env.SALMONLOOP_DEBUG === 'true') {
+        globalThis.__SALMON_RUNTIME_INITIALIZED__ = true;
+        return;
+    }
+    // Preload token calculator in background (non-blocking)
+    initializeDefaultCalculator().catch(() => {
+        // Silently fallback to char-based if initialization fails
+    });
+    // Initialize logger before installing global error handlers.
+    if (!tryGetLogger()) {
+        setLogger(createLogger());
+    }
+    // Initialize monitor once so subsystems can record metrics without hidden singletons.
+    if (!tryGetMonitor()) {
+        setMonitor(createMonitor());
+    }
+    // Sub-agent profiles are runtime state; wire explicitly for predictable tests.
+    if (!tryGetSubAgentRegistry()) {
+        const registry = createSubAgentRegistry();
+        registerDefaultSubAgentProfiles(registry);
+        setSubAgentRegistry(registry);
+    }
+    const isGui = process.argv.includes('--gui');
+    // 1. Terminal Output Interceptor (The Nuclear Option)
+    // Monkey-patch console.error to ensure ANY direct console calls are sanitized
+    const originalConsoleError = console.error;
+    console.error = (...args) => {
+        const sanitizedArgs = args.map((arg) => {
+            if (typeof arg === 'object' && arg !== null) {
+                // Drop the object structure entirely for console output to prevent UI pollution
+                const code = arg.code || arg.llmCode || 'TECHNICAL_ERROR';
+                const msg = arg.message || 'No detail provided';
+                return `[${code}] ${msg}`;
+            }
+            return arg;
+        });
+        originalConsoleError.apply(console, sanitizedArgs);
+    };
+    const originalConsoleLog = console.log;
+    console.log = (...args) => {
+        const sanitizedArgs = args.map((arg) => {
+            if (typeof arg === 'object' && arg !== null) {
+                // Prevent JSON tree leakage in logs as well
+                return arg instanceof Error ? `[${arg.name}] ${arg.message}` : '[Object]';
+            }
+            return arg;
+        });
+        originalConsoleLog.apply(console, sanitizedArgs);
+    };
+    // 1.5 Byte-Stream Interceptor (The Absolute Physical Defense)
+    // Hijack raw stdout/stderr to filter out sensitive info even if it escapes as a raw string or Buffer
+    const TOKEN_ERROR_TEST_REGEX = /(Token error|api[-_]key|secret)[^ \n\r'"]*/i;
+    const TOKEN_ERROR_REPLACE_REGEX = /(Token error|api[-_]key|secret)[^ \n\r'"]*/gi;
+    const ERROR_DUMP_HINT_REGEX = /(token|api|key|secret|apicallerror|retryerror|requestbodyvalues|responsebody|vercel\.ai\.error)/i;
+    const ERROR_DUMP_PAYLOAD_REGEX = /(requestBodyValues|responseHeaders|responseBody|\[Symbol\(vercel\.ai\.error)/i;
+    const ERROR_DUMP_LINE_REGEX = /\[AI_RetryError\]\s+Failed after \d+ attempts\./i;
+    const bufferHasHint = (buf) => buf.includes('Token') ||
+        buf.includes('token') ||
+        buf.includes('API') ||
+        buf.includes('api') ||
+        buf.includes('KEY') ||
+        buf.includes('key') ||
+        buf.includes('SECRET') ||
+        buf.includes('secret') ||
+        buf.includes('APICallError') ||
+        buf.includes('RetryError') ||
+        buf.includes('requestBodyValues') ||
+        buf.includes('responseBody') ||
+        buf.includes('vercel.ai.error');
+    const sanitizeStream = (stream) => {
+        const originalWrite = stream.write.bind(stream);
+        stream.write = (chunk, encodingOrCb, cb) => {
+            const isBuffer = Buffer.isBuffer(chunk);
+            const data = isBuffer ? '' : typeof chunk === 'string' ? chunk : '';
+            // Ink-based GUI renders through high-frequency stdout writes. Avoid expensive
+            // string conversions and regex checks unless the chunk looks like it may contain secrets.
+            if (isGui) {
+                if (isBuffer) {
+                    if (!chunk || chunk.length === 0)
+                        return originalWrite(chunk, encodingOrCb, cb);
+                    if (!bufferHasHint(chunk))
+                        return originalWrite(chunk, encodingOrCb, cb);
+                }
+                else if (!data || !ERROR_DUMP_HINT_REGEX.test(data)) {
+                    return originalWrite(chunk, encodingOrCb, cb);
+                }
+            }
+            const resolvedData = isBuffer ? chunk.toString() : data;
+            if (isGui && ERROR_DUMP_LINE_REGEX.test(resolvedData)) {
+                // Drop known noisy retry summaries; the UI already renders a structured retry event.
+                const nextChunk = isBuffer ? Buffer.from('') : '';
+                return originalWrite(nextChunk, encodingOrCb, cb);
+            }
+            if (isGui && ERROR_DUMP_PAYLOAD_REGEX.test(resolvedData)) {
+                const redacted = 'ERR_TECHNICAL_DETAILS_HIDDEN\n';
+                const nextChunk = isBuffer ? Buffer.from(redacted) : redacted;
+                return originalWrite(nextChunk, encodingOrCb, cb);
+            }
+            if (TOKEN_ERROR_TEST_REGEX.test(resolvedData)) {
+                const cleaned = resolvedData.replace(TOKEN_ERROR_REPLACE_REGEX, '[REDACTED]');
+                const nextChunk = isBuffer ? Buffer.from(cleaned) : cleaned;
+                return originalWrite(nextChunk, encodingOrCb, cb);
+            }
+            return originalWrite(chunk, encodingOrCb, cb);
+        };
+    };
+    sanitizeStream(process.stderr);
+    sanitizeStream(process.stdout);
+    // 2. Global Process Handlers
+    process.on('unhandledRejection', (reason) => {
+        getLogger().error('Unhandled Rejection detected in Core runtime', reason, true);
+    });
+    process.on('uncaughtException', (error) => {
+        getLogger().error('Uncaught Exception detected in Core runtime', error, true);
+    });
+    globalThis.__SALMON_RUNTIME_INITIALIZED__ = true;
+}
+//# sourceMappingURL=initialize.js.map

package/dist/core/runtime/loop-finalize.js

@@ -0,0 +1,71 @@
+import { text } from '../../locales/index.js';
+import { appendAuditTrailToAuditFile } from '../observability/audit-file.js';
+import { clearAuditContext, drainAuditDropStats, recordAuditEvent, } from '../observability/audit-trail.js';
+import { getLogger } from '../observability/logger.js';
+import { buildRunOutcomeReport } from '../observability/run-outcome-reporter.js';
+import { drainRedactionMetrics } from '../security/redaction.js';
+export async function finalizeLoopRun(params) {
+    let { latestAuditPath } = params;
+    const { finalResult } = params;
+    const { config, options, hostRunner, correlationId } = params;
+    try {
+        await hostRunner.teardown();
+    }
+    finally {
+        if (options.outcomeReporter && finalResult) {
+            try {
+                await options.outcomeReporter.report(buildRunOutcomeReport(finalResult), {
+                    runId: correlationId,
+                    auditPath: latestAuditPath,
+                    mode: options.mode,
+                    repoPath: options.repoPath,
+                    sessionId: options.langfuseSessionId,
+                    userId: options.langfuseUserId,
+                    instruction: options.instruction,
+                    verify: options.verify,
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                getLogger().warn(text.grizzco.observability.outcomeReporterFailed(msg));
+            }
+        }
+        const redactionStats = drainRedactionMetrics();
+        if (redactionStats.count > 0) {
+            recordAuditEvent('context.redaction.count', { count: redactionStats.count }, { source: 'security', severity: 'low', scope: 'session' });
+        }
+        const dropStats = drainAuditDropStats();
+        if (dropStats.count > 0) {
+            recordAuditEvent('audit.dropped', { count: dropStats.count, since: dropStats.since }, { source: 'audit', severity: 'medium', scope: 'session' });
+            const warnThreshold = config.observability.audit.buffer.droppedWarn;
+            if (dropStats.count >= warnThreshold) {
+                getLogger().warn(`Audit buffer dropped ${dropStats.count} events (threshold=${warnThreshold}).`);
+                recordAuditEvent('audit.dropped.warn', { count: dropStats.count, since: dropStats.since, threshold: warnThreshold }, { source: 'audit', severity: 'high', scope: 'session' });
+            }
+        }
+        const fallbackFailureReason = finalResult && !finalResult.success ? finalResult.reason : undefined;
+        const appendedPath = await appendAuditTrailToAuditFile({
+            auditPath: latestAuditPath,
+            repoPath: options.repoPath,
+            auditScope: options.auditScope,
+            failureReason: fallbackFailureReason,
+            runId: correlationId,
+            finalOutcome: finalResult
+                ? {
+                    success: finalResult.success,
+                    reasonCode: finalResult.reasonCode,
+                    failurePhase: finalResult.failurePhase,
+                    errorCode: finalResult.errorCode,
+                }
+                : undefined,
+        });
+        if (!latestAuditPath && appendedPath) {
+            latestAuditPath = appendedPath;
+            if (finalResult)
+                finalResult.auditPath = appendedPath;
+        }
+        clearAuditContext();
+    }
+    return { latestAuditPath, finalResult };
+}
+//# sourceMappingURL=loop-finalize.js.map

package/dist/core/runtime/loop-run-lifecycle.js

@@ -0,0 +1,73 @@
+import { randomBytes } from 'crypto';
+import { createFlowEventAdapter, LoopTelemetry } from '../grizzco/engine/observability/index.js';
+import { buildLoopFailureResult } from '../grizzco/engine/outcome/index.js';
+import { HostRunner } from '../grizzco/runtime/host/index.js';
+import { sanitizeError } from '../llm/errors.js';
+import { clearAuditTrail, recordAuditEvent, setAuditContext, } from '../observability/audit-trail.js';
+import { extractErrorCode, REDACTED_ERROR_TOKEN } from '../observability/error-envelope.js';
+import { Phase, } from '../types/runtime.js';
+function buildSafeMeta(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    if (!('safeMeta' in error))
+        return undefined;
+    const safeMeta = error.safeMeta;
+    if (!safeMeta || typeof safeMeta !== 'object')
+        return undefined;
+    return safeMeta;
+}
+export function initializeLoopLifecycle(options) {
+    clearAuditTrail();
+    const correlationId = `run-${randomBytes(4).toString('hex')}`;
+    setAuditContext({
+        correlationId,
+        scope: 'session',
+        sessionId: options.langfuseSessionId,
+        userId: options.langfuseUserId,
+    });
+    const now = () => new Date();
+    const telemetry = new LoopTelemetry(now);
+    const { emitSanitized, emitFlow } = createFlowEventAdapter({
+        onEvent: options.onEvent,
+        telemetry,
+    });
+    const hostRunner = new HostRunner(options, emitSanitized, now);
+    const shadowTaskId = randomBytes(4).toString('hex');
+    const runMode = 'run';
+    return {
+        correlationId,
+        now,
+        telemetry,
+        emitSanitized,
+        emitFlow,
+        hostRunner,
+        shadowTaskId,
+        runMode,
+    };
+}
+export function buildLoopFailureFromError(params) {
+    const extractedCode = extractErrorCode(params.error);
+    const errorCode = extractedCode && extractedCode !== 'Error' ? extractedCode : undefined;
+    const message = sanitizeError(params.error);
+    recordAuditEvent('run.failed.diagnostic', {
+        errorName: params.error instanceof Error ? params.error.name : typeof params.error,
+        errorCode,
+        phase: Phase.PREFLIGHT,
+        source: 'runtime.loop.catch',
+        redacted: message === REDACTED_ERROR_TOKEN,
+        safeMeta: buildSafeMeta(params.error),
+    }, { source: 'runtime', severity: 'high', scope: 'session', phase: Phase.PREFLIGHT });
+    params.telemetry.recordLog(Phase.PREFLIGHT, message, false);
+    params.emitSanitized({ type: 'log', level: 'error', message, timestamp: params.now() });
+    const fallbackFlowMode = params.options.mode ?? 'patch';
+    return buildLoopFailureResult({
+        message,
+        flowMode: fallbackFlowMode,
+        telemetry: params.telemetry,
+        auditPath: params.latestAuditPath,
+        reasonCode: 'LOOP_FAILED',
+        failurePhase: Phase.PREFLIGHT,
+        errorCode,
+    });
+}
+//# sourceMappingURL=loop-run-lifecycle.js.map

package/dist/core/runtime/loop-run-reporter.js

@@ -0,0 +1,19 @@
+import { recordAuditEvent } from '../observability/audit-trail.js';
+export function recordLoopRunStart(params) {
+    params.emitSanitized({ type: 'run.start', mode: params.runMode, timestamp: params.now() });
+    recordAuditEvent('run.start', { mode: params.runMode }, { scope: 'session', severity: 'low' });
+}
+export function recordLoopRunEnd(params) {
+    params.emitSanitized({
+        type: 'run.end',
+        mode: params.runMode,
+        success: params.success,
+        timestamp: params.now(),
+    });
+    recordAuditEvent('run.end', { mode: params.runMode, success: params.success }, {
+        scope: 'session',
+        severity: params.success ? 'low' : 'medium',
+        ...params.auditMeta,
+    });
+}
+//# sourceMappingURL=loop-run-reporter.js.map

package/dist/core/runtime/loop-runtime-config.js

@@ -0,0 +1,26 @@
+import { resolveConfig } from '../config/resolve.js';
+import { getGlobalAdjuster, resetGlobalAdjuster } from '../context/budget/dynamic-adjuster.js';
+import { initializeDefaultCalculator, setDefaultModel, setUseTokenBudget, } from '../context/policies/pack-until-full.js';
+import { setAuditBufferLimits } from '../observability/audit-trail.js';
+import { setRedactionConfig } from '../security/redaction.js';
+export async function resolveAndApplyRuntimeConfig(options) {
+    const config = await resolveConfig({
+        repoRoot: options.repoPath,
+    });
+    setUseTokenBudget(config.context.useTokenBudget);
+    setAuditBufferLimits(config.observability.audit.buffer);
+    setRedactionConfig(config.security.redaction);
+    const modelId = config.llm.models.selectedModelId;
+    if (modelId) {
+        setDefaultModel(modelId);
+    }
+    await initializeDefaultCalculator().catch(() => {
+        // Fall back to char-based budget if tokenizer bootstrap fails.
+    });
+    resetGlobalAdjuster();
+    if (config.context.dynamicBudget.enabled) {
+        getGlobalAdjuster(config.context.dynamicBudget);
+    }
+    return config;
+}
+//# sourceMappingURL=loop-runtime-config.js.map

package/dist/core/runtime/loop-session-runner.js

@@ -0,0 +1,30 @@
+import { buildFlowTransactionRunner, runFlowSession } from '../grizzco/engine/transaction/index.js';
+export async function executeLoopSession(params) {
+    const hostContext = await params.lifecycle.hostRunner.boot();
+    const runner = buildFlowTransactionRunner({
+        flowMode: hostContext.flowMode,
+        fsAdapter: hostContext.fsAdapter,
+        env: hostContext.env,
+        activeRepoPath: hostContext.activeRepoPath,
+        planRuntime: hostContext.planRuntime,
+        options: params.options,
+        emitFlow: params.lifecycle.emitFlow,
+        now: params.lifecycle.now,
+        telemetry: params.lifecycle.telemetry,
+        shadowTaskId: params.lifecycle.shadowTaskId,
+    });
+    const sessionResult = await runFlowSession({
+        runner,
+        flowMode: hostContext.flowMode,
+        options: params.options,
+        telemetry: params.lifecycle.telemetry,
+        now: params.lifecycle.now,
+        emitSanitized: params.lifecycle.emitSanitized,
+        auditPath: params.latestAuditPath,
+    });
+    return {
+        result: sessionResult.result,
+        auditPath: sessionResult.auditPath,
+    };
+}
+//# sourceMappingURL=loop-session-runner.js.map

package/dist/core/runtime/loop.js

@@ -0,0 +1,84 @@
+import { LIMITS } from '../config/limits.js';
+import { Phase } from '../types/runtime.js';
+import { finalizeLoopRun } from './loop-finalize.js';
+import { buildLoopFailureFromError, initializeLoopLifecycle } from './loop-run-lifecycle.js';
+import { recordLoopRunEnd, recordLoopRunStart } from './loop-run-reporter.js';
+import { resolveAndApplyRuntimeConfig } from './loop-runtime-config.js';
+import { executeLoopSession } from './loop-session-runner.js';
+import { Semaphore } from './semaphore.js';
+export function createRunSalmonLoop(deps) {
+    const semaphore = deps?.semaphore ?? new Semaphore(LIMITS.maxConcurrentOperations);
+    const resolveConfig = deps?.resolveConfig ?? resolveAndApplyRuntimeConfig;
+    return async (options) => semaphore.run(async () => {
+        const config = await resolveConfig(options);
+        const loop = new SalmonLoop(config);
+        return loop.run(options);
+    });
+}
+const defaultRunSalmonLoop = createRunSalmonLoop();
+export async function runSalmonLoop(options) {
+    return defaultRunSalmonLoop(options);
+}
+export class SalmonLoop {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async run(options) {
+        const lifecycle = initializeLoopLifecycle(options);
+        let latestAuditPath;
+        let finalResult;
+        recordLoopRunStart({
+            emitSanitized: lifecycle.emitSanitized,
+            runMode: lifecycle.runMode,
+            now: lifecycle.now,
+        });
+        try {
+            const sessionResult = await executeLoopSession({
+                options,
+                lifecycle,
+                latestAuditPath,
+            });
+            latestAuditPath = sessionResult.auditPath;
+            finalResult = sessionResult.result;
+            recordLoopRunEnd({
+                emitSanitized: lifecycle.emitSanitized,
+                runMode: lifecycle.runMode,
+                success: Boolean(finalResult.success),
+                now: lifecycle.now,
+            });
+            return finalResult;
+        }
+        catch (error) {
+            finalResult = buildLoopFailureFromError({
+                error,
+                options,
+                telemetry: lifecycle.telemetry,
+                emitSanitized: lifecycle.emitSanitized,
+                now: lifecycle.now,
+                latestAuditPath,
+            });
+            recordLoopRunEnd({
+                emitSanitized: lifecycle.emitSanitized,
+                runMode: lifecycle.runMode,
+                success: false,
+                now: lifecycle.now,
+                auditMeta: { severity: 'high', phase: Phase.PREFLIGHT },
+            });
+            return finalResult;
+        }
+        finally {
+            const finalized = await finalizeLoopRun({
+                config: this.config,
+                options,
+                hostRunner: lifecycle.hostRunner,
+                correlationId: lifecycle.correlationId,
+                latestAuditPath,
+                finalResult,
+            });
+            latestAuditPath = finalized.latestAuditPath;
+            finalResult = finalized.finalResult;
+        }
+    }
+}
+//# sourceMappingURL=loop.js.map

package/dist/core/runtime/paths.js

@@ -0,0 +1,84 @@
+import { createHash } from 'crypto';
+import * as os from 'os';
+import path from 'path';
+import { mkdir, readdir, rename, rm, stat } from '../adapters/fs/node-fs.js';
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getRuntimeRoot(repoRoot) {
+    return path.join(repoRoot, '.salmonloop', 'runtime');
+}
+export function getUserRuntimeRoot() {
+    return path.join(os.homedir(), '.salmonloop', 'runtime');
+}
+export function getAuditDir(repoRoot, scope = 'repo') {
+    if (scope === 'user') {
+        return path.join(getUserRuntimeRoot(), 'audit');
+    }
+    return path.join(getRuntimeRoot(repoRoot), 'audit');
+}
+export function getRejectionsDir(repoRoot) {
+    return path.join(getRuntimeRoot(repoRoot), 'rejections');
+}
+export function getTmpDir(repoRoot) {
+    return path.join(getRuntimeRoot(repoRoot), 'tmp');
+}
+export function getCheckpointsDir(repoRoot) {
+    return path.join(getRuntimeRoot(repoRoot), 'checkpoints');
+}
+export function getUserCheckpointManifestDir(repoRoot) {
+    const digest = createHash('sha256').update(repoRoot).digest('hex').slice(0, 16);
+    return path.join(getUserRuntimeRoot(), 'checkpoints', digest);
+}
+export function getUserAcpSessionStorePath() {
+    return path.join(getUserRuntimeRoot(), 'acp', 'sessions.v1.json');
+}
+export function getShadowLockPath(shadowRoot) {
+    return path.join(shadowRoot, '.salmonloop', 'runtime', 'locks', 'shadow.lock');
+}
+export async function migrateLegacyRuntime(repoRoot) {
+    const legacyRoot = path.join(repoRoot, '.s8p');
+    const runtimeRoot = getRuntimeRoot(repoRoot);
+    if (!(await pathExists(legacyRoot))) {
+        return;
+    }
+    if (!(await pathExists(runtimeRoot))) {
+        await mkdir(path.dirname(runtimeRoot), { recursive: true });
+        try {
+            await rename(legacyRoot, runtimeRoot);
+            return;
+        }
+        catch {
+            await mkdir(runtimeRoot, { recursive: true });
+        }
+    }
+    const entries = await readdir(legacyRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        const from = path.join(legacyRoot, entry.name);
+        const to = path.join(runtimeRoot, entry.name);
+        if (await pathExists(to))
+            continue;
+        try {
+            await rename(from, to);
+        }
+        catch {
+            // Best-effort migration; keep legacy data if move fails.
+        }
+    }
+    try {
+        const remaining = await readdir(legacyRoot);
+        if (remaining.length === 0) {
+            await rm(legacyRoot, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // Ignore cleanup failures; legacy folder can be removed manually.
+    }
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/runtime/process-runner.js

@@ -0,0 +1,16 @@
+import { getActiveCommandRunner } from './command-runner-context.js';
+import { isCommandAvailableLocal, spawnCommandLocal } from './spawn-command.js';
+export async function spawnCommand(input) {
+    const runner = getActiveCommandRunner();
+    if (runner)
+        return await runner.spawnCommand(input);
+    return await spawnCommandLocal(input);
+}
+export async function isCommandAvailable(command) {
+    const runner = getActiveCommandRunner();
+    if (runner)
+        return await runner.isCommandAvailable(command);
+    return await isCommandAvailableLocal(command);
+}
+export { spawnInteractiveProcess } from './spawn-interactive.js';
+//# sourceMappingURL=process-runner.js.map

package/dist/core/runtime/process-types.js

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

package/dist/core/runtime/semaphore.js

@@ -0,0 +1,41 @@
+/**
+ * Simple Semaphore class to limit concurrent operations
+ */
+export class Semaphore {
+    max;
+    tasks = [];
+    count;
+    constructor(max) {
+        this.max = max;
+        this.count = max;
+    }
+    async acquire() {
+        if (this.count > 0) {
+            this.count--;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.tasks.push(resolve);
+        });
+    }
+    release() {
+        if (this.tasks.length > 0) {
+            const next = this.tasks.shift();
+            if (next)
+                next();
+        }
+        else {
+            this.count++;
+        }
+    }
+    async run(task) {
+        await this.acquire();
+        try {
+            return await task();
+        }
+        finally {
+            this.release();
+        }
+    }
+}
+//# sourceMappingURL=semaphore.js.map

package/dist/core/runtime/sidecar-fastify-plugin.js

@@ -0,0 +1,35 @@
+import { buildFetchRequest, sendFetchResponse, } from './fastify-fetch-bridge.js';
+export function createSidecarFastifyPlugin(deps) {
+    const baseUrl = deps.baseUrl ?? 'http://localhost';
+    const allowConditional = deps.allowConditional ?? false;
+    return async function sidecarFastifyPlugin(fastify) {
+        for (const route of deps.routes) {
+            if (route.exposure === 'forbidden')
+                continue;
+            if (route.scope !== 'both' && route.scope !== deps.scope)
+                continue;
+            if (!allowConditional && route.exposure === 'conditional')
+                continue;
+            const handler = async (request, reply) => {
+                const fetchRequest = buildFetchRequest(request, baseUrl);
+                if (deps.authorize) {
+                    const decision = await deps.authorize({
+                        request: fetchRequest,
+                        policyTag: route.policyTag,
+                        scope: deps.scope,
+                    });
+                    if (!decision.allowed) {
+                        await sendFetchResponse(reply, new Response(decision.message ?? 'Forbidden', {
+                            status: decision.status ?? 403,
+                        }));
+                        return;
+                    }
+                }
+                const response = await route.handler(fetchRequest);
+                await sendFetchResponse(reply, response);
+            };
+            fastify.route({ method: route.method, url: route.path, handler });
+        }
+    };
+}
+//# sourceMappingURL=sidecar-fastify-plugin.js.map

package/dist/core/runtime/sidecar-paths.js

@@ -0,0 +1,47 @@
+import os from 'node:os';
+import { defaultPathAdapter } from '../adapters/path/path-adapter.js';
+const DEFAULT_APP_NAME = 'SalmonLoop';
+export function resolveUserDataDir(options) {
+    const platform = options?.platform ?? process.platform;
+    const env = options?.env ?? process.env;
+    const home = options?.homedir ?? os.homedir();
+    const pathAdapter = options?.pathAdapter ?? defaultPathAdapter;
+    const appName = options?.appName ?? DEFAULT_APP_NAME;
+    if (platform === 'win32') {
+        const base = env.APPDATA ?? env.LOCALAPPDATA ?? pathAdapter.join(home, 'AppData', 'Roaming');
+        return pathAdapter.join(base, appName);
+    }
+    if (platform === 'darwin') {
+        return pathAdapter.join(home, 'Library', 'Application Support', appName);
+    }
+    const xdg = env.XDG_DATA_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : pathAdapter.join(home, '.local', 'share');
+    return pathAdapter.join(base, appName);
+}
+export function getSidecarSocketPath(options) {
+    const platform = options?.platform ?? process.platform;
+    const socketName = options?.socketName ?? 'agent-message.sock';
+    if (platform === 'win32') {
+        return '\\\\.\\pipe\\salmonloop-agent-message';
+    }
+    const dataDir = resolveUserDataDir(options);
+    const pathAdapter = options?.pathAdapter ?? defaultPathAdapter;
+    return pathAdapter.join(dataDir, 'sidecar', socketName);
+}
+export function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}
+export function createPipeListenOptions(path) {
+    return { type: 'pipe', path };
+}
+export function createTcpListenOptions(port, host = '127.0.0.1') {
+    return { type: 'tcp', port, host };
+}
+export function getSidecarListenOptions(options) {
+    const platform = options?.platform ?? process.platform;
+    if (platform === 'win32' && isBunRuntime()) {
+        return { type: 'tcp', port: options?.sidecarPort ?? 7432, host: '127.0.0.1' };
+    }
+    return { type: 'pipe', path: getSidecarSocketPath(options) };
+}
+//# sourceMappingURL=sidecar-paths.js.map