salmon-loop 0.2.3

package/dist/cli/authorization/non-interactive.js

@@ -0,0 +1,166 @@
+import { execa } from 'execa';
+import { z } from 'zod';
+import { getLogger, McpClient } from '../../core/facades/cli-authorization-non-interactive.js';
+import { text } from '../locales/index.js';
+const DecisionSchema = z
+    .object({
+    outcome: z.enum(['allow', 'allow_once', 'allow_session', 'deny']),
+    reason: z.string().optional(),
+    ttlMs: z.number().int().positive().optional(),
+    persist: z.enum(['repo', 'user']).optional(),
+})
+    .strict();
+function normalizeDecisionSource(decision) {
+    return { ...decision, source: 'hook' };
+}
+function deny(reason) {
+    return normalizeDecisionSource({ outcome: 'deny', reason });
+}
+function findMcpServer(extensions, name) {
+    if (!extensions?.mcpServers)
+        return undefined;
+    return extensions.mcpServers.find((s) => s.enabled && s.name === name);
+}
+function toMcpClientConfig(server) {
+    if (server.transport === 'http') {
+        return {
+            name: server.name,
+            url: server.url,
+            headers: server.headers,
+        };
+    }
+    return {
+        name: server.name,
+        command: server.command,
+        args: server.args,
+        env: server.env,
+        cwd: server.cwd,
+    };
+}
+function extractDecisionPayloadFromMcpResult(result) {
+    if (!result || typeof result !== 'object')
+        return result;
+    const obj = result;
+    if (obj.decision && typeof obj.decision === 'object')
+        return obj.decision;
+    if (typeof obj.outcome === 'string')
+        return obj;
+    const content = obj.content;
+    if (!Array.isArray(content))
+        return result;
+    for (const item of content) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const candidate = item.json ??
+            item.text ??
+            item.value ??
+            item.data ??
+            undefined;
+        if (typeof candidate === 'string' && candidate.trim()) {
+            try {
+                return JSON.parse(candidate);
+            }
+            catch {
+                continue;
+            }
+        }
+        if (candidate && typeof candidate === 'object')
+            return candidate;
+    }
+    return result;
+}
+export async function requestNonInteractiveAuthorizationDecision(params) {
+    const strategy = params.config.nonInteractive?.strategy ?? 'deny';
+    if (strategy === 'deny')
+        return null;
+    if (strategy === 'command') {
+        const cmd = params.config.nonInteractive?.command?.cmd;
+        if (!cmd) {
+            getLogger().warn('Non-interactive authorization strategy is "command" but no command is set.');
+            return deny(text.cli.toolAuthorizationNonInteractiveMisconfigured('command'));
+        }
+        const timeoutMs = params.config.nonInteractive?.command?.timeoutMs ?? 10_000;
+        try {
+            const res = await execa(cmd, {
+                input: JSON.stringify({ request: params.request }),
+                shell: true,
+                timeout: timeoutMs,
+                reject: false,
+            });
+            if (typeof res.exitCode === 'number' && res.exitCode !== 0) {
+                return deny(text.cli.toolAuthorizationNonInteractiveFailed('command_failed'));
+            }
+            const stdout = String(res.stdout ?? '').trim();
+            if (!stdout) {
+                getLogger().warn('Non-interactive authorization command returned empty stdout.');
+                return deny(text.cli.toolAuthorizationNonInteractiveFailed('empty_response'));
+            }
+            let json;
+            try {
+                json = JSON.parse(stdout);
+            }
+            catch {
+                return deny(text.cli.toolAuthorizationNonInteractiveFailed('invalid_json'));
+            }
+            const parsed = DecisionSchema.safeParse(json);
+            if (!parsed.success) {
+                getLogger().warn('Non-interactive authorization command returned invalid decision JSON.');
+                return deny(text.cli.toolAuthorizationNonInteractiveFailed('invalid_decision'));
+            }
+            return normalizeDecisionSource(parsed.data);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            getLogger().warn(`Non-interactive authorization command failed: ${msg}`);
+            return deny(text.cli.toolAuthorizationNonInteractiveFailed('command_failed'));
+        }
+    }
+    if (strategy === 'mcp') {
+        const serverName = params.config.nonInteractive?.mcp?.server;
+        const toolName = params.config.nonInteractive?.mcp?.tool;
+        if (!serverName || !toolName) {
+            getLogger().warn('Non-interactive authorization strategy is "mcp" but server/tool is missing.');
+            return deny(text.cli.toolAuthorizationNonInteractiveMisconfigured('mcp'));
+        }
+        const server = findMcpServer(params.extensions, serverName);
+        if (!server) {
+            getLogger().warn(`Non-interactive authorization MCP server not found or disabled: ${serverName}`);
+            return deny(text.cli.toolAuthorizationNonInteractiveFailed('mcp_server_not_found'));
+        }
+        const timeoutMs = params.config.nonInteractive?.mcp?.timeoutMs ?? 10_000;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const client = new McpClient(toMcpClientConfig(server));
+        try {
+            await client.start();
+            const result = await Promise.race([
+                client.callTool(toolName, { request: params.request }),
+                new Promise((_, reject) => {
+                    controller.signal.addEventListener('abort', () => reject(new Error('timeout')), {
+                        once: true,
+                    });
+                }),
+            ]);
+            const payload = extractDecisionPayloadFromMcpResult(result);
+            const parsed = DecisionSchema.safeParse(payload);
+            if (!parsed.success) {
+                getLogger().warn('Non-interactive authorization MCP tool returned invalid decision payload.');
+                return deny(text.cli.toolAuthorizationNonInteractiveFailed('invalid_decision'));
+            }
+            return normalizeDecisionSource(parsed.data);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            getLogger().warn(`Non-interactive authorization MCP tool failed: ${msg}`);
+            return deny(text.cli.toolAuthorizationNonInteractiveFailed('mcp_failed'));
+        }
+        finally {
+            clearTimeout(timeout);
+            await client.stop();
+        }
+    }
+    const unknown = String(params.config.nonInteractive?.strategy ?? '');
+    getLogger().warn(text.cli.toolAuthorizationNonInteractiveUnsupported(unknown));
+    return deny(text.cli.toolAuthorizationNonInteractiveUnsupported(unknown));
+}
+//# sourceMappingURL=non-interactive.js.map

package/dist/cli/authorization/provider.js

@@ -0,0 +1,416 @@
+import { createInterface } from 'readline/promises';
+import { getLogger } from '../../core/facades/cli-authorization-provider.js';
+import { TOOL_AUTH_CONFIG } from '../config.js';
+import { text } from '../locales/index.js';
+import { getPendingAuthorization, requestAuthorization } from '../ui/authorization/bus.js';
+import { loadAllowlistDecision, persistAllowlistDecision } from './allowlist.js';
+import { requestNonInteractiveAuthorizationDecision } from './non-interactive.js';
+const buildSummary = (request) => {
+    if (request.argsSummary && request.argsSummary.trim())
+        return request.argsSummary;
+    return 'none';
+};
+const buildEffects = (request) => {
+    return request.sideEffects.length > 0 ? request.sideEffects.join(', ') : 'none';
+};
+const applySessionTtl = (decision, config) => {
+    if (decision.outcome !== 'allow_session')
+        return decision;
+    return {
+        ...decision,
+        ttlMs: typeof decision.ttlMs === 'number' ? decision.ttlMs : config.sessionTtlMs,
+    };
+};
+const shouldAutoAllow = (request, config) => {
+    return Boolean(config.autoAllowRisk?.[request.riskLevel]);
+};
+const resolveConfig = (config) => {
+    if (config)
+        return config;
+    return {
+        sessionTtlMs: TOOL_AUTH_CONFIG.SESSION_TTL_MS,
+        autoAllowRisk: TOOL_AUTH_CONFIG.AUTO_ALLOW_RISK,
+        allowlist: {
+            repoFile: '.salmonloop/config/authorization.json',
+            userFile: '~/.salmonloop/config/authorization-user.json',
+        },
+    };
+};
+export function createUiAuthorizationProvider(options) {
+    const pending = new Map();
+    const resolved = new Map();
+    const queue = [];
+    const queued = new Map();
+    const queuedResolvers = new Map();
+    const queuedRejectors = new Map();
+    const finalize = async (request, decision, config) => {
+        if (decision.outcome === 'deny') {
+            options?.emit?.({
+                type: 'log',
+                level: 'warn',
+                message: text.cli.toolAuthorizationDenied,
+            });
+            return {
+                outcome: 'deny',
+                reason: text.cli.toolAuthorizationDenied,
+                source: 'user',
+            };
+        }
+        options?.emit?.({
+            type: 'log',
+            level: 'info',
+            message: text.cli.toolAuthorizationApproved,
+        });
+        if (decision.persist) {
+            await persistAllowlistDecision({
+                config,
+                repoRoot: request.repoRoot,
+                toolName: request.toolName,
+                phase: request.phase,
+                scope: decision.persist,
+                mode: 'allow',
+                sideEffects: request.sideEffects,
+                argsHash: request.argsHash,
+            });
+        }
+        return applySessionTtl({ ...decision, source: decision.source ?? 'user' }, config);
+    };
+    return {
+        async waitForAuthorization(requestId, signal) {
+            const cached = resolved.get(requestId);
+            if (cached)
+                return cached;
+            const existing = pending.get(requestId);
+            if (!existing)
+                return null;
+            if (!signal)
+                return existing;
+            if (signal.aborted)
+                return null;
+            return Promise.race([
+                existing,
+                new Promise((resolve) => {
+                    signal.addEventListener('abort', () => resolve(null), { once: true });
+                }),
+            ]);
+        },
+        async requestAuthorizationDeferred(request) {
+            const config = resolveConfig(options?.config);
+            if (options?.permissionMode === 'yolo') {
+                return {
+                    kind: 'decision',
+                    decision: applySessionTtl({
+                        outcome: 'allow_session',
+                        source: 'auto',
+                        reason: 'permission_mode_yolo',
+                    }, config),
+                };
+            }
+            const cached = resolved.get(request.id);
+            if (cached) {
+                return { kind: 'decision', decision: cached };
+            }
+            const existing = pending.get(request.id);
+            if (existing) {
+                const challenge = request.id.slice(0, 6);
+                return {
+                    kind: 'pending',
+                    challenge,
+                    message: text.cli.toolAuthorizationPrompt(request.toolName, request.riskLevel, buildEffects(request), buildSummary(request)),
+                };
+            }
+            const allowlistDecision = await loadAllowlistDecision({
+                config,
+                repoRoot: request.repoRoot,
+                toolName: request.toolName,
+                phase: request.phase,
+                sideEffects: request.sideEffects,
+                argsHash: request.argsHash,
+            });
+            if (allowlistDecision === 'allow') {
+                options?.emit?.({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.toolAuthorizationAllowlisted(request.toolName),
+                });
+                return { kind: 'decision', decision: { outcome: 'allow', source: 'allowlist' } };
+            }
+            if (allowlistDecision === 'deny') {
+                options?.emit?.({
+                    type: 'log',
+                    level: 'warn',
+                    message: text.cli.toolAuthorizationDenylisted(request.toolName),
+                });
+                return {
+                    kind: 'decision',
+                    decision: {
+                        outcome: 'deny',
+                        reason: text.cli.toolAuthorizationDenylisted(request.toolName),
+                        source: 'allowlist',
+                    },
+                };
+            }
+            if (shouldAutoAllow(request, config)) {
+                options?.emit?.({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.toolAuthorizationAutoApproved(request.toolName, request.riskLevel),
+                });
+                return {
+                    kind: 'decision',
+                    decision: applySessionTtl({ outcome: 'allow_session', source: 'auto' }, config),
+                };
+            }
+            const summary = buildSummary(request);
+            const effects = buildEffects(request);
+            const message = text.cli.toolAuthorizationPrompt(request.toolName, request.riskLevel, effects, summary);
+            const challenge = request.id.slice(0, 6);
+            const startNext = () => {
+                if (getPendingAuthorization())
+                    return;
+                const next = queue.shift();
+                if (!next)
+                    return;
+                queued.delete(next.id);
+                const resolver = queuedResolvers.get(next.id);
+                const rejector = queuedRejectors.get(next.id);
+                const p = requestAuthorization({
+                    id: next.id,
+                    message: text.cli.toolAuthorizationPrompt(next.toolName, next.riskLevel, buildEffects(next), buildSummary(next)),
+                    challenge: next.id.slice(0, 6),
+                }).then((decision) => finalize(next, decision, config));
+                pending.set(next.id, p);
+                p.then((decision) => {
+                    resolved.set(next.id, decision);
+                    pending.delete(next.id);
+                    queuedResolvers.delete(next.id);
+                    queuedRejectors.delete(next.id);
+                    resolver?.(decision);
+                    startNext();
+                }).catch((err) => {
+                    pending.delete(next.id);
+                    queuedResolvers.delete(next.id);
+                    queuedRejectors.delete(next.id);
+                    rejector?.(err);
+                    startNext();
+                });
+            };
+            if (!queued.has(request.id)) {
+                queued.set(request.id, request);
+                queue.push(request);
+                const promise = new Promise((resolve, reject) => {
+                    queuedResolvers.set(request.id, resolve);
+                    queuedRejectors.set(request.id, reject);
+                });
+                pending.set(request.id, promise);
+            }
+            startNext();
+            return { kind: 'pending', challenge, message };
+        },
+        async requestAuthorization(request) {
+            const config = resolveConfig(options?.config);
+            if (options?.permissionMode === 'yolo') {
+                return applySessionTtl({
+                    outcome: 'allow_session',
+                    source: 'auto',
+                    reason: 'permission_mode_yolo',
+                }, config);
+            }
+            const allowlistDecision = await loadAllowlistDecision({
+                config,
+                repoRoot: request.repoRoot,
+                toolName: request.toolName,
+                phase: request.phase,
+                sideEffects: request.sideEffects,
+                argsHash: request.argsHash,
+            });
+            if (allowlistDecision === 'allow') {
+                options?.emit?.({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.toolAuthorizationAllowlisted(request.toolName),
+                });
+                return { outcome: 'allow', source: 'allowlist' };
+            }
+            if (allowlistDecision === 'deny') {
+                options?.emit?.({
+                    type: 'log',
+                    level: 'warn',
+                    message: text.cli.toolAuthorizationDenylisted(request.toolName),
+                });
+                return {
+                    outcome: 'deny',
+                    reason: text.cli.toolAuthorizationDenylisted(request.toolName),
+                    source: 'allowlist',
+                };
+            }
+            if (shouldAutoAllow(request, config)) {
+                options?.emit?.({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.toolAuthorizationAutoApproved(request.toolName, request.riskLevel),
+                });
+                return applySessionTtl({ outcome: 'allow_session', source: 'auto' }, config);
+            }
+            const summary = buildSummary(request);
+            const effects = buildEffects(request);
+            const message = text.cli.toolAuthorizationPrompt(request.toolName, request.riskLevel, effects, summary);
+            const challenge = request.id.slice(0, 6);
+            const decision = await requestAuthorization({
+                id: request.id,
+                message,
+                challenge,
+            });
+            const finalized = await finalize(request, decision, config);
+            resolved.set(request.id, finalized);
+            return finalized;
+        },
+    };
+}
+export function createTerminalAuthorizationProvider(options) {
+    const forceNonInteractive = Boolean(options?.forceNonInteractive);
+    const deferredRequests = new Map();
+    const shouldUseForcedDeferred = (request, config) => {
+        if (!forceNonInteractive)
+            return false;
+        if (config.nonInteractive?.strategy === 'deny')
+            return false;
+        if (!request.id || !request.id.trim())
+            return false;
+        return true;
+    };
+    const buildDeferredMessage = (request) => {
+        const summary = buildSummary(request);
+        const effects = buildEffects(request);
+        return text.cli.toolAuthorizationPrompt(request.toolName, request.riskLevel, effects, summary);
+    };
+    return {
+        async waitForAuthorization(requestId) {
+            const pending = deferredRequests.get(requestId);
+            if (!pending)
+                return null;
+            deferredRequests.delete(requestId);
+            return await this.requestAuthorization(pending);
+        },
+        async requestAuthorizationDeferred(request) {
+            const config = resolveConfig(options?.config);
+            if (options?.permissionMode === 'yolo') {
+                return {
+                    kind: 'decision',
+                    decision: applySessionTtl({
+                        outcome: 'allow_session',
+                        source: 'auto',
+                        reason: 'permission_mode_yolo',
+                    }, config),
+                };
+            }
+            if (shouldUseForcedDeferred(request, config)) {
+                deferredRequests.set(request.id, request);
+                return {
+                    kind: 'pending',
+                    challenge: request.id.slice(0, 6),
+                    message: buildDeferredMessage(request),
+                };
+            }
+            const decision = await this.requestAuthorization(request);
+            return { kind: 'decision', decision };
+        },
+        async requestAuthorization(request) {
+            const config = resolveConfig(options?.config);
+            if (options?.permissionMode === 'yolo') {
+                return applySessionTtl({
+                    outcome: 'allow_session',
+                    source: 'auto',
+                    reason: 'permission_mode_yolo',
+                }, config);
+            }
+            const allowlistDecision = await loadAllowlistDecision({
+                config,
+                repoRoot: request.repoRoot,
+                toolName: request.toolName,
+                phase: request.phase,
+                sideEffects: request.sideEffects,
+                argsHash: request.argsHash,
+            });
+            if (allowlistDecision === 'allow') {
+                getLogger().info(text.cli.toolAuthorizationAllowlisted(request.toolName));
+                return { outcome: 'allow', source: 'allowlist' };
+            }
+            if (allowlistDecision === 'deny') {
+                getLogger().warn(text.cli.toolAuthorizationDenylisted(request.toolName));
+                return {
+                    outcome: 'deny',
+                    reason: text.cli.toolAuthorizationDenylisted(request.toolName),
+                    source: 'allowlist',
+                };
+            }
+            if (shouldAutoAllow(request, config)) {
+                getLogger().info(text.cli.toolAuthorizationAutoApproved(request.toolName, request.riskLevel));
+                return applySessionTtl({ outcome: 'allow_session', source: 'auto' }, config);
+            }
+            if (forceNonInteractive || !process.stdin.isTTY || !process.stdout.isTTY) {
+                const nonInteractive = await requestNonInteractiveAuthorizationDecision({
+                    request,
+                    config,
+                    extensions: options?.extensions,
+                });
+                if (nonInteractive) {
+                    if (nonInteractive.persist) {
+                        await persistAllowlistDecision({
+                            config,
+                            repoRoot: request.repoRoot,
+                            toolName: request.toolName,
+                            phase: request.phase,
+                            scope: nonInteractive.persist,
+                            mode: nonInteractive.outcome === 'deny' ? 'deny' : 'allow',
+                            sideEffects: request.sideEffects,
+                            argsHash: request.argsHash,
+                        });
+                    }
+                    return applySessionTtl(nonInteractive, config);
+                }
+                getLogger().warn(text.cli.toolAuthorizationMissingUi);
+                return { outcome: 'deny', reason: text.cli.toolAuthorizationMissingUi };
+            }
+            const summary = buildSummary(request);
+            const effects = buildEffects(request);
+            const prompt = text.cli.toolAuthorizationPrompt(request.toolName, request.riskLevel, effects, summary);
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                const answer = await rl.question(`${prompt}\n${text.cli.toolAuthorizationTerminalQuestion} `);
+                const normalized = answer.trim().toLowerCase();
+                const allowSession = normalized.startsWith('a');
+                const allowOnce = normalized.startsWith('y');
+                const allowRepo = normalized.startsWith('s');
+                const allowUser = normalized.startsWith('g');
+                if (!allowSession && !allowOnce && !allowRepo && !allowUser) {
+                    getLogger().warn(text.cli.toolAuthorizationDenied);
+                    return { outcome: 'deny', reason: text.cli.toolAuthorizationDenied, source: 'user' };
+                }
+                getLogger().info(text.cli.toolAuthorizationApproved);
+                const decision = allowRepo
+                    ? { outcome: 'allow', persist: 'repo', source: 'user' }
+                    : allowUser
+                        ? { outcome: 'allow', persist: 'user', source: 'user' }
+                        : { outcome: allowSession ? 'allow_session' : 'allow_once', source: 'user' };
+                if (decision.persist) {
+                    await persistAllowlistDecision({
+                        config,
+                        repoRoot: request.repoRoot,
+                        toolName: request.toolName,
+                        phase: request.phase,
+                        scope: decision.persist,
+                        mode: 'allow',
+                        sideEffects: request.sideEffects,
+                        argsHash: request.argsHash,
+                    });
+                }
+                return applySessionTtl(decision, config);
+            }
+            finally {
+                rl.close();
+            }
+        },
+    };
+}
+//# sourceMappingURL=provider.js.map

package/dist/cli/chat-interface.js

@@ -0,0 +1,83 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { getLogger } from '../core/facades/cli-observability.js';
+import { text } from './locales/index.js';
+/**
+ * Handles interruptions (Ctrl+C, ESC) for chat mode.
+ */
+export class ChatInterface {
+    sigintHandler = null;
+    keypressHandler = null;
+    abortController = null;
+    /**
+     * Set the current AbortController for task interruption
+     */
+    setAbortController(controller) {
+        this.abortController = controller;
+    }
+    /**
+     * Start listening for interruption keys (Ctrl+C, ESC) during task execution.
+     */
+    startTaskListener(onInterrupt) {
+        const isTTY = process.stdin.isTTY;
+        if (isTTY) {
+            // TTY mode: Use Raw Mode + Keypress to catch ESC and Ctrl+C
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            readline.emitKeypressEvents(process.stdin);
+            this.keypressHandler = (_str, key) => {
+                // Ctrl+C
+                if (key.ctrl && key.name === 'c') {
+                    this.handleInterrupt(onInterrupt, 'Ctrl+C');
+                    return;
+                }
+                // ESC
+                if (key.name === 'escape') {
+                    this.handleInterrupt(onInterrupt, 'ESC');
+                    return;
+                }
+            };
+            process.stdin.on('keypress', this.keypressHandler);
+        }
+        else {
+            // Non-TTY mode: Fallback to standard SIGINT
+            this.sigintHandler = () => {
+                this.handleInterrupt(onInterrupt, 'SIGINT');
+            };
+            process.on('SIGINT', this.sigintHandler);
+        }
+        return () => this.cleanup();
+    }
+    /**
+     * Handle the interruption signal
+     */
+    handleInterrupt(onInterrupt, _source) {
+        if (this.abortController && !this.abortController.signal.aborted) {
+            // Only log if we're actually aborting a new signal
+            getLogger().log(chalk.yellow(`\n${text.cli.chatTaskInterrupted}`));
+            this.abortController.abort();
+            onInterrupt();
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        // Cleanup Keypress
+        if (this.keypressHandler) {
+            process.stdin.off('keypress', this.keypressHandler);
+            this.keypressHandler = null;
+        }
+        // Cleanup SIGINT
+        if (this.sigintHandler) {
+            process.off('SIGINT', this.sigintHandler);
+            this.sigintHandler = null;
+        }
+        // Restore TTY state
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+            // Do not pause stdin as inquirer will need it immediately after
+        }
+    }
+}
+//# sourceMappingURL=chat-interface.js.map