@provos/ironcurtain 0.5.0 → 0.6.0

package/dist/mux/mux-escalation-manager.js

@@ -0,0 +1,162 @@
+/**
+ * MuxEscalationManager -- manages escalation watchers for all PTY sessions.
+ *
+ * Wraps the existing EscalationWatcher and ListenerState modules for the
+ * mux context. Creates watchers directly when sessions are spawned, and
+ * optionally polls the PTY registry for externally-spawned sessions.
+ */
+import { mkdirSync } from 'node:fs';
+import { getPtyRegistryDir } from '../config/paths.js';
+import { readActiveRegistrations } from '../escalation/session-registry.js';
+import { createEscalationWatcher } from '../escalation/escalation-watcher.js';
+import { createInitialState, addSession, removeSession, addEscalation, resolveEscalation, expireEscalation, } from '../escalation/listener-state.js';
+/** Poll interval for the session registry directory (ms). */
+const REGISTRY_POLL_INTERVAL_MS = 1000;
+/**
+ * Creates a new MuxEscalationManager.
+ */
+export function createMuxEscalationManager() {
+    let state = createInitialState();
+    const changeCallbacks = [];
+    const discoveryCallbacks = [];
+    let registryPollInterval = null;
+    // Track session IDs that we manage (spawned by mux)
+    const managedSessionIds = new Set();
+    // Tombstones: removed sessions that may still linger in the registry briefly
+    const removedSessionIds = new Set();
+    function notifyChange() {
+        for (const cb of changeCallbacks)
+            cb();
+    }
+    function createWatcherForSession(sessionId, escalationDir) {
+        return createEscalationWatcher(escalationDir, {
+            onEscalation: (request) => {
+                state = addEscalation(state, sessionId, request);
+                notifyChange();
+                // BEL to alert user
+                process.stderr.write('\x07');
+            },
+            onEscalationExpired: (escalationId) => {
+                state = expireEscalation(state, sessionId, escalationId);
+                notifyChange();
+            },
+        }, { pollIntervalMs: 300 });
+    }
+    return {
+        get state() {
+            return state;
+        },
+        get pendingCount() {
+            return state.pendingEscalations.size;
+        },
+        addSession(registration) {
+            managedSessionIds.add(registration.sessionId);
+            const watcher = createWatcherForSession(registration.sessionId, registration.escalationDir);
+            state = addSession(state, registration, watcher);
+            watcher.start();
+            notifyChange();
+        },
+        removeSession(sessionId) {
+            const session = state.sessions.get(sessionId);
+            session?.watcher.stop();
+            removedSessionIds.add(sessionId);
+            state = removeSession(state, sessionId);
+            notifyChange();
+        },
+        resolve(displayNumber, decision) {
+            const escalation = state.pendingEscalations.get(displayNumber);
+            if (!escalation) {
+                return `No pending escalation #${displayNumber}`;
+            }
+            const session = state.sessions.get(escalation.sessionId);
+            if (!session) {
+                return `Session for escalation #${displayNumber} no longer active`;
+            }
+            try {
+                const accepted = session.watcher.resolve(escalation.request.escalationId, decision);
+                state = resolveEscalation(state, displayNumber, decision);
+                notifyChange();
+                if (!accepted) {
+                    return `Escalation #${displayNumber} expired (response was too late)`;
+                }
+                const label = decision === 'approved' ? 'APPROVED' : 'DENIED';
+                return `Escalation #${displayNumber} ${label}`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        resolveAll(decision) {
+            if (state.pendingEscalations.size === 0) {
+                return 'No pending escalations';
+            }
+            const messages = [];
+            const nums = [...state.pendingEscalations.keys()].sort((a, b) => a - b);
+            for (const num of nums) {
+                messages.push(this.resolve(num, decision));
+            }
+            return messages.join('\n');
+        },
+        startRegistryPolling() {
+            if (registryPollInterval)
+                return;
+            const registryDir = getPtyRegistryDir();
+            mkdirSync(registryDir, { recursive: true, mode: 0o700 });
+            registryPollInterval = setInterval(() => {
+                const registrations = readActiveRegistrations(registryDir);
+                const currentIds = new Set(registrations.map((r) => r.sessionId));
+                const stateIds = new Set(state.sessions.keys());
+                let changed = false;
+                // Add externally-spawned sessions (skip managed, tombstoned)
+                for (const reg of registrations) {
+                    if (!stateIds.has(reg.sessionId) &&
+                        !managedSessionIds.has(reg.sessionId) &&
+                        !removedSessionIds.has(reg.sessionId)) {
+                        const watcher = createWatcherForSession(reg.sessionId, reg.escalationDir);
+                        state = addSession(state, reg, watcher);
+                        watcher.start();
+                        changed = true;
+                        for (const cb of discoveryCallbacks)
+                            cb(reg);
+                    }
+                }
+                // Clear tombstones once the registry entry disappears
+                for (const id of removedSessionIds) {
+                    if (!currentIds.has(id)) {
+                        removedSessionIds.delete(id);
+                    }
+                }
+                // Remove gone external sessions
+                for (const id of stateIds) {
+                    if (!currentIds.has(id) && !managedSessionIds.has(id)) {
+                        const session = state.sessions.get(id);
+                        session?.watcher.stop();
+                        state = removeSession(state, id);
+                        changed = true;
+                    }
+                }
+                if (changed)
+                    notifyChange();
+            }, REGISTRY_POLL_INTERVAL_MS);
+        },
+        stop() {
+            if (registryPollInterval) {
+                clearInterval(registryPollInterval);
+                registryPollInterval = null;
+            }
+            for (const session of state.sessions.values()) {
+                session.watcher.stop();
+            }
+        },
+        onChange(callback) {
+            changeCallbacks.push(callback);
+        },
+        onSessionDiscovered(callback) {
+            discoveryCallbacks.push(callback);
+        },
+        claimSession(sessionId) {
+            managedSessionIds.add(sessionId);
+        },
+    };
+}
+//# sourceMappingURL=mux-escalation-manager.js.map

package/dist/mux/mux-escalation-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mux-escalation-manager.js","sourceRoot":"","sources":["../../src/mux/mux-escalation-manager.ts"],"names":[],"mappings":"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"}

package/dist/mux/mux-input-handler.d.ts

@@ -0,0 +1,49 @@
+/**
+ * MuxInputHandler -- key routing state machine for the terminal multiplexer.
+ *
+ * Two input modes:
+ * - PTY mode: all keystrokes go to the active PtyBridge except Ctrl-A
+ * - Command mode: keystrokes collected in a line buffer, dispatched on Enter
+ *
+ * Ctrl-A toggles between modes (following screen/tmux convention).
+ * Pressing Ctrl-A in PTY mode enters command mode; pressing it again
+ * returns to PTY mode.
+ */
+import type { InputMode, MuxAction } from './types.js';
+export type PickerPhase = 'menu' | 'browse';
+export interface PickerState {
+    phase: PickerPhase;
+    menuSelection: number;
+    inputPath: string;
+    cursorPos: number;
+    entries: string[];
+    selectedIndex: number;
+    scrollOffset: number;
+    inList: boolean;
+    error: string | null;
+}
+export interface MuxInputHandler {
+    /** Current input mode. */
+    readonly mode: InputMode;
+    /** Current command-mode input buffer (for display). */
+    readonly inputBuffer: string;
+    /** Cursor position within the input buffer. */
+    readonly cursorPos: number;
+    /** Current picker state (null when not in picker mode). */
+    readonly pickerState: PickerState | null;
+    /** Enter picker mode (called by /new command handler). */
+    enterPickerMode(): void;
+    /** Re-enter picker browse phase with a validation error. */
+    enterBrowseWithError(path: string, error: string): void;
+    /** Exit picker mode and return to PTY mode (no side effects). */
+    exitPickerMode(): void;
+    /**
+     * Processes a key event from terminal-kit.
+     * Returns a MuxAction describing what the orchestrator should do.
+     */
+    handleKey(key: string): MuxAction;
+}
+export interface MuxInputHandlerOptions {
+    initialMode?: InputMode;
+}
+export declare function createMuxInputHandler(options?: MuxInputHandlerOptions): MuxInputHandler;

package/dist/mux/mux-input-handler.js

@@ -0,0 +1,457 @@
+/**
+ * MuxInputHandler -- key routing state machine for the terminal multiplexer.
+ *
+ * Two input modes:
+ * - PTY mode: all keystrokes go to the active PtyBridge except Ctrl-A
+ * - Command mode: keystrokes collected in a line buffer, dispatched on Enter
+ *
+ * Ctrl-A toggles between modes (following screen/tmux convention).
+ * Pressing Ctrl-A in PTY mode enters command mode; pressing it again
+ * returns to PTY mode.
+ */
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { expandTilde } from '../types/argument-roles.js';
+/** terminal-kit key names for special keys. */
+const CTRL_A = 'CTRL_A';
+const ENTER = 'ENTER';
+const ESCAPE = 'ESCAPE';
+const CTRL_C = 'CTRL_C';
+const BACKSPACE = 'BACKSPACE';
+const DELETE = 'DELETE';
+const LEFT = 'LEFT';
+const RIGHT = 'RIGHT';
+const UP = 'UP';
+const DOWN = 'DOWN';
+const TAB = 'TAB';
+/**
+ * Maps terminal-kit key names to raw escape sequences for the PTY.
+ * terminal-kit emits human-readable names (e.g. 'ENTER'), but the
+ * child PTY expects raw bytes (e.g. '\r').
+ */
+const KEY_TO_SEQUENCE = {
+    ENTER: '\r',
+    BACKSPACE: '\x7f',
+    ESCAPE: '\x1b',
+    DELETE: '\x1b[3~',
+    TAB: '\t',
+    UP: '\x1b[A',
+    DOWN: '\x1b[B',
+    RIGHT: '\x1b[C',
+    LEFT: '\x1b[D',
+    HOME: '\x1b[H',
+    END: '\x1b[F',
+    PAGE_UP: '\x1b[5~',
+    PAGE_DOWN: '\x1b[6~',
+    INSERT: '\x1b[2~',
+    // Ctrl keys -> raw bytes
+    ...Object.fromEntries(Array.from({ length: 26 }, (_, i) => [`CTRL_${String.fromCharCode(65 + i)}`, String.fromCharCode(i + 1)])),
+};
+/**
+ * Splits a path input into the directory portion and the filename prefix.
+ */
+function splitDirPrefix(inputPath) {
+    const lastSlash = inputPath.lastIndexOf('/');
+    if (lastSlash === -1) {
+        return { dir: homedir(), prefix: inputPath };
+    }
+    return { dir: inputPath.slice(0, lastSlash) || '/', prefix: inputPath.slice(lastSlash + 1) };
+}
+// Cache for directory listings to avoid re-reading on every keystroke
+// when only the prefix (filename portion) changes.
+let _cachedDir = null;
+let _cachedDirents = [];
+/**
+ * Reads directory entries for the picker's browse phase.
+ * Returns entries matching the prefix, with trailing `/` for directories.
+ * Directories are sorted first, then alphabetical.
+ * Caches the raw directory listing; only re-reads when the directory changes.
+ */
+function refreshEntries(inputPath) {
+    const { dir: rawDir, prefix } = splitDirPrefix(inputPath);
+    const dir = expandTilde(rawDir);
+    try {
+        if (dir !== _cachedDir) {
+            _cachedDirents = readdirSync(dir, { withFileTypes: true });
+            _cachedDir = dir;
+        }
+        const entries = [];
+        for (const ent of _cachedDirents) {
+            if (!ent.name.startsWith(prefix))
+                continue;
+            if (ent.name.startsWith('.') && !prefix.startsWith('.'))
+                continue;
+            entries.push({ name: ent.name, isDir: ent.isDirectory() });
+        }
+        entries.sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        return entries.map((e) => (e.isDir ? e.name + '/' : e.name));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Finds the longest common prefix among a list of strings.
+ */
+function longestCommonPrefix(strings) {
+    if (strings.length === 0)
+        return '';
+    let prefix = strings[0];
+    for (let i = 1; i < strings.length; i++) {
+        while (!strings[i].startsWith(prefix)) {
+            prefix = prefix.slice(0, -1);
+            if (prefix.length === 0)
+                return '';
+        }
+    }
+    return prefix;
+}
+export function createMuxInputHandler(options) {
+    let _mode = options?.initialMode ?? 'pty';
+    let _inputBuffer = '';
+    let _cursorPos = 0;
+    let _pickerState = null;
+    function enterPickerMode() {
+        _mode = 'picker';
+        _pickerState = {
+            phase: 'menu',
+            menuSelection: 0,
+            inputPath: '',
+            cursorPos: 0,
+            entries: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+            inList: false,
+            error: null,
+        };
+    }
+    /** Resets entry selection and scroll after refreshing entries. */
+    function resetEntrySelection(ps) {
+        ps.entries = refreshEntries(ps.inputPath);
+        ps.selectedIndex = 0;
+        ps.scrollOffset = 0;
+    }
+    function initBrowsePhase(path) {
+        if (!_pickerState)
+            return;
+        const browsePath = path ?? homedir() + '/';
+        _pickerState.phase = 'browse';
+        _pickerState.inputPath = browsePath;
+        _pickerState.cursorPos = browsePath.length;
+        _pickerState.inList = false;
+        _pickerState.error = null;
+        resetEntrySelection(_pickerState);
+    }
+    function enterBrowseWithError(path, error) {
+        _mode = 'picker';
+        _pickerState = {
+            phase: 'browse',
+            menuSelection: 0,
+            inputPath: path,
+            cursorPos: path.length,
+            entries: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+            inList: false,
+            error,
+        };
+        resetEntrySelection(_pickerState);
+    }
+    function exitPickerMode() {
+        _mode = 'pty';
+        _pickerState = null;
+    }
+    function executeMenuSelection(selection) {
+        if (selection === 0) {
+            _mode = 'pty';
+            _pickerState = null;
+            return { kind: 'picker-spawn' };
+        }
+        initBrowsePhase();
+        return { kind: 'redraw-picker' };
+    }
+    function handleMenuKey(key) {
+        const ps = _pickerState;
+        if (!ps)
+            return { kind: 'none' };
+        if (key === '1')
+            return executeMenuSelection(0);
+        if (key === '2')
+            return executeMenuSelection(1);
+        if (key === ENTER)
+            return executeMenuSelection(ps.menuSelection);
+        if (key === UP || key === DOWN) {
+            ps.menuSelection = ps.menuSelection === 0 ? 1 : 0;
+            return { kind: 'redraw-picker' };
+        }
+        if (key === ESCAPE || key === CTRL_C) {
+            _mode = 'command';
+            _pickerState = null;
+            return { kind: 'picker-cancel' };
+        }
+        return { kind: 'none' };
+    }
+    function handleBrowseKey(key) {
+        const ps = _pickerState;
+        if (!ps)
+            return { kind: 'none' };
+        ps.error = null;
+        if (key === ESCAPE || key === CTRL_C) {
+            if (ps.inList) {
+                // Return from list to input field
+                ps.inList = false;
+                return { kind: 'redraw-picker' };
+            }
+            // Return to menu phase
+            ps.phase = 'menu';
+            ps.menuSelection = 0;
+            return { kind: 'redraw-picker' };
+        }
+        // Tab completion (only when in input field)
+        if (key === TAB && !ps.inList) {
+            if (ps.entries.length === 0) {
+                return { kind: 'none' };
+            }
+            const { dir: dirPart, prefix } = splitDirPrefix(ps.inputPath);
+            const base = dirPart === homedir() && !ps.inputPath.includes('/') ? '' : dirPart + '/';
+            if (ps.entries.length === 1) {
+                ps.inputPath = base + ps.entries[0];
+                ps.cursorPos = ps.inputPath.length;
+                resetEntrySelection(ps);
+            }
+            else {
+                const names = ps.entries.map((e) => e.replace(/\/$/, ''));
+                const lcp = longestCommonPrefix(names);
+                if (lcp.length > prefix.length) {
+                    ps.inputPath = base + lcp;
+                    ps.cursorPos = ps.inputPath.length;
+                    resetEntrySelection(ps);
+                }
+            }
+            return { kind: 'redraw-picker' };
+        }
+        // Up/Down navigation
+        if (key === DOWN) {
+            if (!ps.inList) {
+                // Move focus from input field into the entry list
+                if (ps.entries.length > 0) {
+                    ps.inList = true;
+                    ps.selectedIndex = 0;
+                    ps.scrollOffset = 0;
+                }
+            }
+            else if (ps.selectedIndex < ps.entries.length - 1) {
+                ps.selectedIndex++;
+            }
+            return { kind: 'redraw-picker' };
+        }
+        if (key === UP) {
+            if (ps.inList) {
+                if (ps.selectedIndex > 0) {
+                    ps.selectedIndex--;
+                    if (ps.selectedIndex < ps.scrollOffset) {
+                        ps.scrollOffset = ps.selectedIndex;
+                    }
+                }
+                else {
+                    // At top of list — return focus to input field
+                    ps.inList = false;
+                }
+            }
+            return { kind: 'redraw-picker' };
+        }
+        // When in list mode, Enter picks the entry into the input field
+        if (key === ENTER && ps.inList) {
+            if (ps.selectedIndex < ps.entries.length) {
+                const selected = ps.entries[ps.selectedIndex];
+                const { dir: dirPart } = splitDirPrefix(ps.inputPath);
+                ps.inputPath = dirPart + '/' + selected;
+                ps.cursorPos = ps.inputPath.length;
+                ps.inList = false;
+                resetEntrySelection(ps);
+            }
+            return { kind: 'redraw-picker' };
+        }
+        // When in input field, Enter submits the current path
+        if (key === ENTER && !ps.inList) {
+            if (ps.inputPath.trim()) {
+                const workspacePath = ps.inputPath.replace(/\/+$/, '');
+                _mode = 'pty';
+                _pickerState = null;
+                return { kind: 'picker-spawn', workspacePath };
+            }
+            return { kind: 'redraw-picker' };
+        }
+        // Keys below only apply when focus is on the input field
+        if (ps.inList) {
+            return { kind: 'none' };
+        }
+        // Cursor movement within input path
+        if (key === LEFT) {
+            if (ps.cursorPos > 0)
+                ps.cursorPos--;
+            return { kind: 'redraw-picker' };
+        }
+        if (key === RIGHT) {
+            if (ps.cursorPos < ps.inputPath.length)
+                ps.cursorPos++;
+            return { kind: 'redraw-picker' };
+        }
+        // Backspace
+        if (key === BACKSPACE) {
+            if (ps.cursorPos > 0) {
+                ps.inputPath = ps.inputPath.slice(0, ps.cursorPos - 1) + ps.inputPath.slice(ps.cursorPos);
+                ps.cursorPos--;
+                resetEntrySelection(ps);
+            }
+            return { kind: 'redraw-picker' };
+        }
+        // Delete
+        if (key === DELETE) {
+            if (ps.cursorPos < ps.inputPath.length) {
+                ps.inputPath = ps.inputPath.slice(0, ps.cursorPos) + ps.inputPath.slice(ps.cursorPos + 1);
+                resetEntrySelection(ps);
+            }
+            return { kind: 'redraw-picker' };
+        }
+        // Printable character
+        if (key.length === 1 && key.charCodeAt(0) >= 32) {
+            ps.inputPath = ps.inputPath.slice(0, ps.cursorPos) + key + ps.inputPath.slice(ps.cursorPos);
+            ps.cursorPos++;
+            resetEntrySelection(ps);
+            return { kind: 'redraw-picker' };
+        }
+        return { kind: 'none' };
+    }
+    function handlePickerKey(key) {
+        if (!_pickerState)
+            return { kind: 'none' };
+        if (_pickerState.phase === 'menu')
+            return handleMenuKey(key);
+        return handleBrowseKey(key);
+    }
+    function handlePtyKey(key) {
+        if (key === CTRL_A) {
+            _mode = 'command';
+            _inputBuffer = '';
+            _cursorPos = 0;
+            return { kind: 'enter-command-mode' };
+        }
+        return { kind: 'write-pty', data: KEY_TO_SEQUENCE[key] ?? key };
+    }
+    function handleCommandKey(key) {
+        // Ctrl-A in command mode returns to PTY mode
+        if (key === CTRL_A) {
+            _mode = 'pty';
+            _inputBuffer = '';
+            _cursorPos = 0;
+            return { kind: 'enter-pty-mode' };
+        }
+        // Escape: discard buffer, return to PTY mode
+        if (key === ESCAPE) {
+            _mode = 'pty';
+            _inputBuffer = '';
+            _cursorPos = 0;
+            return { kind: 'enter-pty-mode' };
+        }
+        // Ctrl-C: clear input buffer
+        if (key === CTRL_C) {
+            _inputBuffer = '';
+            _cursorPos = 0;
+            return { kind: 'redraw-input' };
+        }
+        // Enter: dispatch command or trusted input
+        if (key === ENTER) {
+            const text = _inputBuffer.trim();
+            _inputBuffer = '';
+            _cursorPos = 0;
+            if (!text) {
+                return { kind: 'redraw-input' };
+            }
+            // Commands start with /
+            if (text.startsWith('/')) {
+                const parts = text.slice(1).split(/\s+/);
+                const command = parts[0].toLowerCase();
+                const args = parts.slice(1);
+                return { kind: 'command', command, args };
+            }
+            // Non-command text -> trusted input
+            return { kind: 'trusted-input', text };
+        }
+        // Backspace
+        if (key === BACKSPACE) {
+            if (_cursorPos > 0) {
+                _inputBuffer = _inputBuffer.slice(0, _cursorPos - 1) + _inputBuffer.slice(_cursorPos);
+                _cursorPos--;
+                return { kind: 'redraw-input' };
+            }
+            return { kind: 'none' };
+        }
+        // Delete
+        if (key === DELETE) {
+            if (_cursorPos < _inputBuffer.length) {
+                _inputBuffer = _inputBuffer.slice(0, _cursorPos) + _inputBuffer.slice(_cursorPos + 1);
+                return { kind: 'redraw-input' };
+            }
+            return { kind: 'none' };
+        }
+        // Arrow keys
+        if (key === LEFT) {
+            if (_cursorPos > 0) {
+                _cursorPos--;
+                return { kind: 'redraw-input' };
+            }
+            return { kind: 'none' };
+        }
+        if (key === RIGHT) {
+            if (_cursorPos < _inputBuffer.length) {
+                _cursorPos++;
+                return { kind: 'redraw-input' };
+            }
+            return { kind: 'none' };
+        }
+        // Alt-1 through Alt-9: quick tab switching
+        const altMatch = /^ALT_(\d)$/.exec(key);
+        if (altMatch) {
+            return { kind: 'command', command: 'tab', args: [altMatch[1]] };
+        }
+        // Regular printable character
+        if (key.length === 1 && key.charCodeAt(0) >= 32) {
+            _inputBuffer = _inputBuffer.slice(0, _cursorPos) + key + _inputBuffer.slice(_cursorPos);
+            _cursorPos++;
+            return { kind: 'redraw-input' };
+        }
+        return { kind: 'none' };
+    }
+    return {
+        get mode() {
+            return _mode;
+        },
+        get inputBuffer() {
+            return _inputBuffer;
+        },
+        get cursorPos() {
+            return _cursorPos;
+        },
+        get pickerState() {
+            return _pickerState;
+        },
+        enterPickerMode,
+        enterBrowseWithError,
+        exitPickerMode,
+        handleKey(key) {
+            if (_mode === 'pty') {
+                return handlePtyKey(key);
+            }
+            if (_mode === 'picker') {
+                return handlePickerKey(key);
+            }
+            return handleCommandKey(key);
+        },
+    };
+}
+//# sourceMappingURL=mux-input-handler.js.map