@undefineds.co/linx 0.2.1

package/dist/lib/watch/runner.js

@@ -0,0 +1,1124 @@
+import { spawn } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { buildAcpPermissionResponse, buildWatchUserInputResponse, normalizeAcpInteractionRequest, normalizeAcpRequest, normalizeAcpSessionNotification, normalizeWatchCredentialSource, parseWatchJsonLine, resolveWatchAutoApprovalDecision, resolveWatchCredentialSourceResolution, shouldAttemptCloudCredentialProbe, } from '@undefineds.co/models/watch';
+import { appendWatchEvent, createWatchSession, finishWatchSession, loadWatchEvents, loadWatchSession, listWatchSessions, writeWatchSession, } from './archive.js';
+import { detectWatchAuthFailure, preflightWatchAuth } from './auth.js';
+import { createWatchDisplay } from './display.js';
+import { formatWatchSessionSummary } from './format.js';
+import { describeWatchMode, getWatchHook, listWatchHooks } from './hooks/index.js';
+import { createRemoteWatchApproval, isRemoteApprovalAbortError, resolveRemoteWatchApproval, waitForRemoteWatchApproval, } from './pod-approval.js';
+import { persistWatchConversationToPod } from './pod-persistence.js';
+import { loadPodBackendCredential, podCredentialMissingMessage } from './pod-ai.js';
+import { promptText } from '../prompt.js';
+export const watchRuntime = {
+    promptText,
+    preflightWatchAuth,
+    loadPodBackendCredential,
+    createRemoteWatchApproval,
+    waitForRemoteWatchApproval,
+    resolveRemoteWatchApproval,
+    persistWatchConversationToPod,
+};
+function createLineSplitter(stream, onLine) {
+    let buffer = '';
+    return {
+        push(chunk) {
+            buffer += chunk;
+            let newlineIndex = buffer.indexOf('\n');
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+                buffer = buffer.slice(newlineIndex + 1);
+                onLine(line, stream);
+                newlineIndex = buffer.indexOf('\n');
+            }
+            if (buffer.length > 16_384) {
+                onLine(buffer, stream);
+                buffer = '';
+            }
+        },
+        flush() {
+            if (!buffer) {
+                return;
+            }
+            onLine(buffer.replace(/\r$/, ''), stream);
+            buffer = '';
+        },
+    };
+}
+function appendEntry(record, stream, line, events) {
+    const entry = {
+        timestamp: new Date().toISOString(),
+        stream,
+        line,
+        events,
+    };
+    appendWatchEvent(record, entry);
+}
+function appendSessionNote(record, message, raw) {
+    appendEntry(record, 'system', JSON.stringify({
+        type: 'session.note',
+        message,
+    }), [{
+            type: 'session.note',
+            message,
+            raw,
+        }]);
+}
+function appendAndDisplaySessionNote(record, display, message, tone = 'note', raw) {
+    appendSessionNote(record, message, raw);
+    display.showActivity(message, tone);
+}
+async function promptApproval(display, message, allowSessionOption = true, signal) {
+    while (true) {
+        display.setPhase('approval', message);
+        const answer = (await display.chooseOption('Approval required', [`[approval] ${message}`], allowSessionOption
+            ? [
+                { label: 'Yes', value: 'y', shortcuts: ['y'] },
+                { label: 'Session', value: 's', shortcuts: ['s'] },
+                { label: 'No', value: 'n', shortcuts: ['n'] },
+                { label: 'Cancel', value: 'c', shortcuts: ['c'] },
+            ]
+            : [
+                { label: 'Yes', value: 'y', shortcuts: ['y'] },
+                { label: 'No', value: 'n', shortcuts: ['n'] },
+                { label: 'Cancel', value: 'c', shortcuts: ['c'] },
+            ], signal)).trim().toLowerCase();
+        if (answer === 'y' || answer === 'yes') {
+            display.setPhase('running', 'Continuing turn');
+            return 'accept';
+        }
+        if (allowSessionOption && (answer === 's' || answer === 'session')) {
+            display.setPhase('running', 'Continuing turn');
+            return 'accept_for_session';
+        }
+        if (answer === 'n' || answer === 'no') {
+            display.setPhase('running', 'Continuing turn');
+            return 'decline';
+        }
+        if (answer === 'c' || answer === 'cancel') {
+            display.setPhase('running', 'Continuing turn');
+            return 'cancel';
+        }
+    }
+}
+async function promptAuthContinue(display, lines) {
+    while (true) {
+        display.setPhase('question', 'Authentication required');
+        const answer = (await display.chooseOption('Authentication required', lines, [
+            { label: 'Continue', value: 'continue', shortcuts: ['c', 'y'] },
+            { label: 'Cancel', value: 'cancel', shortcuts: ['n', 'x'] },
+        ])).trim().toLowerCase();
+        if (answer === 'continue' || answer === 'c' || answer === 'y' || answer === 'yes') {
+            display.setPhase('running', 'Continuing turn');
+            return true;
+        }
+        if (answer === 'cancel' || answer === 'n' || answer === 'x' || answer === 'no') {
+            display.setPhase('running', 'Continuing turn');
+            return false;
+        }
+    }
+}
+function approvalPromptMessage(request) {
+    if (request.kind === 'command-approval') {
+        return request.command ? `Approve command: ${request.command}` : 'Approve command execution';
+    }
+    if (request.kind === 'file-change-approval') {
+        return request.reason && request.reason.trim() ? request.reason : 'Approve file changes';
+    }
+    if (request.kind === 'permissions-approval') {
+        return request.message || 'Approve additional permissions';
+    }
+    return request.message || 'Approval required';
+}
+function appendUserTurn(record, text) {
+    appendEntry(record, 'system', JSON.stringify({ type: 'user.turn', text }), []);
+}
+function appendTurnStart(record, command, args) {
+    appendEntry(record, 'system', JSON.stringify({ type: 'turn.start', command, args }), []);
+}
+function requestedCredentialSource(options) {
+    return normalizeWatchCredentialSource(options.credentialSource);
+}
+function requestedApprovalSource(options) {
+    return options.approvalSource ?? 'hybrid';
+}
+function requestedRuntime(options) {
+    return options.runtime ?? 'local';
+}
+function normalizeBackendCommandEnv(backend, env) {
+    if (!env) {
+        return undefined;
+    }
+    const next = { ...env };
+    if (backend === 'codex' && next.OPENAI_API_KEY && !next.CODEX_API_KEY) {
+        next.CODEX_API_KEY = next.OPENAI_API_KEY;
+    }
+    return next;
+}
+function mergeCommandEnv(backend, commandEnv, planEnv) {
+    const normalizedCommandEnv = normalizeBackendCommandEnv(backend, commandEnv);
+    if (!normalizedCommandEnv && !planEnv) {
+        return undefined;
+    }
+    return {
+        ...(normalizedCommandEnv ?? {}),
+        ...(planEnv ?? {}),
+    };
+}
+function syncRecordFromOptions(record, options, plan) {
+    return {
+        backend: options.backend,
+        runtime: requestedRuntime(options),
+        mode: options.mode,
+        cwd: options.cwd,
+        model: options.model,
+        prompt: options.prompt,
+        passthroughArgs: [...options.passthroughArgs],
+        credentialSource: requestedCredentialSource(options),
+        resolvedCredentialSource: options.resolvedCredentialSource,
+        approvalSource: requestedApprovalSource(options),
+        command: plan.command,
+        args: [...plan.args],
+        transport: options.transport ?? 'acp',
+    };
+}
+function withResolvedSource(options, resolvedCredentialSource, commandEnv) {
+    return {
+        ...options,
+        transport: options.transport ?? 'acp',
+        credentialSource: requestedCredentialSource(options),
+        approvalSource: requestedApprovalSource(options),
+        resolvedCredentialSource,
+        commandEnv,
+    };
+}
+async function probeCloudCredentialSource(backend, runtime) {
+    try {
+        const podCredential = await runtime.loadPodBackendCredential(backend);
+        if (!podCredential) {
+            return {
+                probe: {
+                    status: 'unavailable',
+                    message: podCredentialMissingMessage(backend),
+                },
+            };
+        }
+        return {
+            probe: { status: 'available' },
+            commandEnv: normalizeBackendCommandEnv(backend, { ...podCredential.env }),
+        };
+    }
+    catch (error) {
+        return {
+            probe: {
+                status: 'error',
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}
+export async function resolveWatchRunOptions(options, runtime = watchRuntime) {
+    const source = requestedCredentialSource(options);
+    if (source === 'cloud') {
+        const { probe, commandEnv } = await probeCloudCredentialSource(options.backend, runtime);
+        const resolution = resolveWatchCredentialSourceResolution({
+            requestedSource: source,
+            localAuthStatus: { state: 'unknown' },
+            cloudCredentialProbe: probe,
+        });
+        if (resolution.error) {
+            throw new Error(resolution.error);
+        }
+        return {
+            options: withResolvedSource(options, resolution.resolvedSource ?? 'cloud', commandEnv),
+            authPreflight: resolution.authStatus,
+        };
+    }
+    const localOptions = withResolvedSource(options, 'local');
+    const authPreflight = await runtime.preflightWatchAuth(options.backend);
+    let cloudCredentialProbe;
+    let commandEnv;
+    if (shouldAttemptCloudCredentialProbe(source, authPreflight)) {
+        const cloudResult = await probeCloudCredentialSource(options.backend, runtime);
+        cloudCredentialProbe = cloudResult.probe;
+        commandEnv = cloudResult.commandEnv;
+    }
+    const resolution = resolveWatchCredentialSourceResolution({
+        requestedSource: source,
+        localAuthStatus: authPreflight,
+        cloudCredentialProbe,
+        defaultLocalMessage: `${options.backend} is not authenticated`,
+    });
+    if (resolution.error) {
+        throw new Error(resolution.error);
+    }
+    return {
+        options: resolution.resolvedSource === 'cloud'
+            ? withResolvedSource(options, 'cloud', commandEnv)
+            : localOptions,
+        authPreflight: resolution.authStatus,
+    };
+}
+class BaseSession {
+    record;
+    display;
+    child = null;
+    activeExitPromise = null;
+    activeExitResolve = null;
+    closed = false;
+    lastExit = null;
+    constructor(record, prompt) {
+        this.record = record;
+        this.display = createWatchDisplay(record, prompt);
+    }
+    spawnProcess(command, args, cwd, env) {
+        this.activeExitPromise = new Promise((resolve) => {
+            this.activeExitResolve = resolve;
+        });
+        const child = spawn(command, args, {
+            cwd,
+            env: { ...process.env, ...env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stdout.setEncoding('utf-8');
+        child.stderr.setEncoding('utf-8');
+        this.child = child;
+        child.on('error', (error) => {
+            appendEntry(this.record, 'system', JSON.stringify({ type: 'process.error', message: error.message }), [
+                { type: 'session.note', message: error.message, raw: error.message },
+            ]);
+            this.onProcessFailure(new Error(error.message));
+        });
+        child.on('exit', (code, signal) => {
+            this.lastExit = { code, signal };
+            this.activeExitResolve?.({ code, signal });
+            this.activeExitResolve = null;
+            if (this.child === child) {
+                this.child = null;
+            }
+            this.onProcessExit(code, signal);
+        });
+        return child;
+    }
+    async finalizeAndClose(status, error) {
+        const exitState = await this.waitForActiveExit();
+        const next = finishWatchSession(this.record, {
+            status,
+            exitCode: exitState.code,
+            signal: exitState.signal,
+            error,
+        });
+        this.display.finish(status, next, error);
+        return next;
+    }
+    recordParsedLine(stream, line, events) {
+        appendEntry(this.record, stream, line, events);
+        if (events.length > 0) {
+            this.display.renderEvents(events);
+            return;
+        }
+        this.display.renderRawLine(stream, line);
+    }
+    updateRecord(updates) {
+        Object.assign(this.record, updates);
+        writeWatchSession(this.record);
+        this.display.updateRecord(this.record);
+    }
+    waitForActiveExit() {
+        if (this.lastExit) {
+            return Promise.resolve(this.lastExit);
+        }
+        if (this.activeExitPromise) {
+            return this.activeExitPromise;
+        }
+        return Promise.resolve({ code: null, signal: null });
+    }
+    async close() {
+        this.closed = true;
+        const child = this.child;
+        if (!child) {
+            return;
+        }
+        child.stdin.end();
+        const settled = await Promise.race([
+            this.waitForActiveExit().then(() => true),
+            delay(1500).then(() => false),
+        ]);
+        if (!settled) {
+            child.kill('SIGTERM');
+            await this.waitForActiveExit();
+        }
+    }
+}
+class AcpSession extends BaseSession {
+    hook;
+    options;
+    requestId = 1;
+    pendingRequests = new Map();
+    turnState = null;
+    sessionId = null;
+    authFailureMessage = null;
+    turnSettleTimer = null;
+    activeAgentRequests = 0;
+    constructor(options, hook) {
+        const plan = hook.buildSpawnPlan(options);
+        super(createWatchSession({ ...options, transport: options.transport ?? 'acp' }, plan), watchRuntime.promptText);
+        this.hook = hook;
+        this.options = options;
+    }
+    async start() {
+        const plan = this.hook.buildSpawnPlan(this.options);
+        const child = this.spawnProcess(plan.command, plan.args, this.record.cwd, mergeCommandEnv(this.options.backend, this.options.commandEnv, plan.env));
+        const stdoutSplitter = createLineSplitter('stdout', this.handleLine.bind(this));
+        const stderrSplitter = createLineSplitter('stderr', this.handleLine.bind(this));
+        child.stdout.on('data', (chunk) => stdoutSplitter.push(chunk));
+        child.stderr.on('data', (chunk) => stderrSplitter.push(chunk));
+        child.on('exit', () => {
+            stdoutSplitter.flush();
+            stderrSplitter.flush();
+        });
+        await this.sendRequest('initialize', {
+            protocolVersion: 1,
+            clientCapabilities: {},
+            clientInfo: {
+                name: 'linx-cli',
+                version: '0.1.0',
+            },
+        });
+        const newSession = await this.sendRequest('session/new', {
+            cwd: this.options.cwd,
+            mcpServers: [],
+        });
+        const sessionId = typeof newSession.sessionId === 'string'
+            ? newSession.sessionId
+            : typeof newSession.session?.id === 'string'
+                ? newSession.session.id
+                : null;
+        if (!sessionId) {
+            throw new Error(`ACP backend ${this.options.backend} did not return a session id`);
+        }
+        this.sessionId = sessionId;
+        this.updateRecord({
+            backendSessionId: sessionId,
+            error: undefined,
+        });
+        if (this.options.model) {
+            await this.trySetModel(this.options.model);
+        }
+    }
+    applyResolvedOptions(options) {
+        this.options = options;
+        const plan = this.hook.buildSpawnPlan(options);
+        this.updateRecord(syncRecordFromOptions(this.record, options, plan));
+    }
+    async setModel(model) {
+        const normalized = model.trim();
+        if (!normalized) {
+            throw new Error('Model id cannot be empty');
+        }
+        await this.trySetModel(normalized, true);
+        this.options = {
+            ...this.options,
+            model: normalized,
+        };
+        this.updateRecord({
+            model: normalized,
+        });
+    }
+    async sendTurn(text) {
+        if (!this.sessionId) {
+            throw new Error('ACP session is not initialized');
+        }
+        if (this.turnState) {
+            throw new Error('A watch turn is already in progress');
+        }
+        appendUserTurn(this.record, text);
+        appendTurnStart(this.record, this.record.command, this.record.args);
+        this.authFailureMessage = null;
+        const completion = new Promise((resolve, reject) => {
+            this.turnState = {
+                resolve,
+                reject,
+                responseReceived: false,
+            };
+        });
+        void completion.catch(() => { });
+        try {
+            const response = await this.sendRequest('session/prompt', {
+                sessionId: this.sessionId,
+                prompt: [{ type: 'text', text }],
+            });
+            const turnState = this.turnState;
+            if (turnState === null) {
+                return;
+            }
+            ;
+            turnState.responseReceived = true;
+            this.recordParsedLine('system', JSON.stringify({
+                type: 'turn.stop',
+                stopReason: typeof response.stopReason === 'string' ? response.stopReason : undefined,
+            }), [{
+                    type: 'assistant.done',
+                    raw: {
+                        stopReason: typeof response.stopReason === 'string' ? response.stopReason : undefined,
+                    },
+                }]);
+            this.scheduleTurnSettle();
+        }
+        catch (error) {
+            this.turnState = null;
+            this.clearTurnSettleTimer();
+            throw error;
+        }
+        await completion;
+    }
+    onProcessExit(code, signal) {
+        this.clearTurnSettleTimer();
+        const errorMessage = this.authFailureMessage ?? `ACP backend exited (${code ?? signal ?? 'null'})`;
+        for (const pending of this.pendingRequests.values()) {
+            pending.reject(new Error(errorMessage));
+        }
+        this.pendingRequests.clear();
+        if (this.turnState) {
+            const reject = this.turnState.reject;
+            this.turnState = null;
+            reject(new Error(this.authFailureMessage ?? `ACP backend exited during turn (${code ?? signal ?? 'null'})`));
+        }
+    }
+    onProcessFailure(error) {
+        this.clearTurnSettleTimer();
+        for (const pending of this.pendingRequests.values()) {
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        if (this.turnState) {
+            const reject = this.turnState.reject;
+            this.turnState = null;
+            reject(error);
+        }
+    }
+    clearTurnSettleTimer() {
+        if (!this.turnSettleTimer) {
+            return;
+        }
+        clearTimeout(this.turnSettleTimer);
+        this.turnSettleTimer = null;
+    }
+    scheduleTurnSettle() {
+        if (!this.turnState || !this.turnState.responseReceived || this.activeAgentRequests > 0) {
+            return;
+        }
+        this.clearTurnSettleTimer();
+        this.turnSettleTimer = setTimeout(() => {
+            if (!this.turnState || !this.turnState.responseReceived || this.activeAgentRequests > 0) {
+                return;
+            }
+            const turnState = this.turnState;
+            this.turnState = null;
+            this.turnSettleTimer = null;
+            if (this.authFailureMessage) {
+                turnState.reject(new Error(this.authFailureMessage));
+                return;
+            }
+            turnState.resolve();
+        }, 75);
+    }
+    markTurnActivity() {
+        if (!this.turnState?.responseReceived) {
+            return;
+        }
+        this.scheduleTurnSettle();
+    }
+    handleLine(line, stream) {
+        const authFailure = detectWatchAuthFailure(this.record.backend, line);
+        if (authFailure) {
+            this.authFailureMessage = authFailure.message;
+        }
+        if (stream === 'stderr') {
+            this.recordParsedLine(stream, line, []);
+            this.markTurnActivity();
+            return;
+        }
+        const message = parseWatchJsonLine(line);
+        if (!message) {
+            this.recordParsedLine(stream, line, []);
+            this.markTurnActivity();
+            return;
+        }
+        if (typeof message.method === 'string' && typeof message.id !== 'undefined') {
+            const method = message.method;
+            const params = (typeof message.params === 'object' && message.params !== null ? message.params : {});
+            const events = method === 'auth/request'
+                ? [{
+                        type: 'session.note',
+                        message: [
+                            typeof params.message === 'string' ? params.message : 'Authentication required',
+                            typeof params.url === 'string' ? `Open ${params.url}` : '',
+                        ].filter(Boolean).join(' · '),
+                        raw: message,
+                    }]
+                : normalizeAcpRequest(message);
+            if (events.length > 0) {
+                this.recordParsedLine(stream, line, events);
+            }
+            else {
+                appendEntry(this.record, stream, line, []);
+            }
+            void this.handleAgentRequest(message);
+            this.markTurnActivity();
+            return;
+        }
+        if (typeof message.method === 'string') {
+            const events = normalizeAcpSessionNotification(message);
+            if (events.length > 0) {
+                this.recordParsedLine(stream, line, events);
+            }
+            else {
+                appendEntry(this.record, stream, line, []);
+            }
+            this.markTurnActivity();
+            return;
+        }
+        if (typeof message.id !== 'undefined') {
+            appendEntry(this.record, stream, line, []);
+            this.handleResponse(message);
+            this.markTurnActivity();
+            return;
+        }
+        this.recordParsedLine(stream, line, []);
+        this.markTurnActivity();
+    }
+    handleResponse(message) {
+        const id = typeof message.id === 'number' ? message.id : Number(message.id);
+        const pending = this.pendingRequests.get(id);
+        if (!pending) {
+            return;
+        }
+        this.pendingRequests.delete(id);
+        if ('error' in message && message.error) {
+            const authFailure = detectWatchAuthFailure(this.record.backend, JSON.stringify(message));
+            if (authFailure) {
+                this.authFailureMessage = authFailure.message;
+                pending.reject(new Error(authFailure.message));
+                return;
+            }
+            const error = message.error;
+            const detail = typeof error.message === 'string'
+                ? error.message
+                : JSON.stringify(error);
+            pending.reject(new Error(detail));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    async handleAgentRequest(message) {
+        const id = typeof message.id === 'number' ? message.id : Number(message.id);
+        const method = typeof message.method === 'string' ? message.method : '';
+        const params = (typeof message.params === 'object' && message.params !== null ? message.params : {});
+        this.activeAgentRequests += 1;
+        this.clearTurnSettleTimer();
+        try {
+            if (method === 'auth/request') {
+                const lines = [
+                    `[note] ${typeof params.message === 'string' ? params.message : 'Authentication required'}`,
+                    ...(typeof params.url === 'string' ? [`[note] ${params.url}`] : []),
+                ];
+                const shouldContinue = await promptAuthContinue(this.display, lines);
+                if (!shouldContinue) {
+                    this.authFailureMessage = 'Authentication request cancelled by user';
+                }
+                this.sendResponse(id, {});
+                return;
+            }
+            const interaction = normalizeAcpInteractionRequest(message);
+            if (!interaction) {
+                this.sendError(id, -32601, `Unsupported ACP client request: ${method}`);
+                return;
+            }
+            if (interaction.kind === 'user-input') {
+                const result = await this.resolveToolUserInput(interaction.questions);
+                this.sendResponse(id, result);
+                return;
+            }
+            const autoDecision = resolveWatchAutoApprovalDecision({
+                mode: this.options.mode,
+                request: interaction,
+            });
+            const decision = autoDecision ?? await this.resolveApproval(interaction);
+            this.sendResponse(id, buildAcpPermissionResponse(interaction, decision));
+        }
+        catch (error) {
+            const messageText = error instanceof Error ? error.message : String(error);
+            this.sendError(id, -32000, messageText);
+        }
+        finally {
+            this.activeAgentRequests = Math.max(0, this.activeAgentRequests - 1);
+            this.scheduleTurnSettle();
+        }
+    }
+    async resolveToolUserInput(questions) {
+        this.display.setPhase('question', questions[0]?.header ?? 'Input required');
+        const answers = await this.display.chooseQuestions(questions);
+        this.display.setPhase('running', 'Continuing turn');
+        return buildWatchUserInputResponse(answers);
+    }
+    async resolveApproval(interaction) {
+        const source = this.options.approvalSource ?? 'hybrid';
+        if (source === 'local') {
+            return promptApproval(this.display, approvalPromptMessage(interaction), true);
+        }
+        if (source === 'remote') {
+            return this.resolveRemoteOnlyApproval(interaction);
+        }
+        return this.resolveHybridApproval(interaction);
+    }
+    async resolveRemoteOnlyApproval(interaction) {
+        const promptMessage = approvalPromptMessage(interaction);
+        appendSessionNote(this.record, `Waiting for remote approval | ${promptMessage}`);
+        this.display.setPhase('approval', `${promptMessage} · remote`);
+        const remote = await watchRuntime.createRemoteWatchApproval({
+            record: this.record,
+            request: interaction,
+        });
+        const decision = await watchRuntime.waitForRemoteWatchApproval({
+            approvalId: remote.id,
+        });
+        appendSessionNote(this.record, `Remote approval resolved | ${decision}`);
+        this.display.setPhase('running', 'Continuing turn');
+        return decision;
+    }
+    async resolveHybridApproval(interaction) {
+        const promptMessage = approvalPromptMessage(interaction);
+        let remoteApproval = null;
+        try {
+            remoteApproval = await watchRuntime.createRemoteWatchApproval({
+                record: this.record,
+                request: interaction,
+            });
+            appendSessionNote(this.record, `Remote approval opened | ${remoteApproval.id}`);
+        }
+        catch (error) {
+            appendSessionNote(this.record, `Remote approval unavailable | ${error instanceof Error ? error.message : String(error)}`);
+            return promptApproval(this.display, promptMessage, true);
+        }
+        const localAbort = new AbortController();
+        const remoteAbort = new AbortController();
+        const localDecisionPromise = promptApproval(this.display, promptMessage, true, localAbort.signal)
+            .then((decision) => ({ source: 'local', decision }));
+        const remoteDecisionPromise = watchRuntime.waitForRemoteWatchApproval({
+            approvalId: remoteApproval.id,
+            signal: remoteAbort.signal,
+        }).then((decision) => ({ source: 'remote', decision }));
+        void localDecisionPromise.catch(() => undefined);
+        void remoteDecisionPromise.catch(() => undefined);
+        try {
+            const winner = await Promise.race([localDecisionPromise, remoteDecisionPromise]);
+            if (winner.source === 'local') {
+                remoteAbort.abort();
+                appendSessionNote(this.record, `Local approval resolved | ${winner.decision}`);
+                void watchRuntime.resolveRemoteWatchApproval({
+                    approvalId: remoteApproval.id,
+                    decision: winner.decision,
+                    note: 'resolved from active local watch session',
+                }).catch(() => undefined);
+                this.display.setPhase('running', 'Continuing turn');
+                return winner.decision;
+            }
+            localAbort.abort();
+            appendSessionNote(this.record, `Remote approval resolved | ${winner.decision}`);
+            this.display.setPhase('running', 'Continuing turn');
+            return winner.decision;
+        }
+        catch (error) {
+            if (isRemoteApprovalAbortError(error)) {
+                throw error;
+            }
+            remoteAbort.abort();
+            localAbort.abort();
+            throw error;
+        }
+    }
+    sendRequest(method, params) {
+        const id = this.requestId++;
+        const child = this.child;
+        if (!child) {
+            throw new Error('ACP backend is not started');
+        }
+        child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject, method });
+        });
+    }
+    sendResponse(id, result) {
+        const child = this.child;
+        if (!child) {
+            throw new Error('ACP backend is not started');
+        }
+        child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
+    }
+    sendError(id, code, message) {
+        const child = this.child;
+        if (!child) {
+            throw new Error('ACP backend is not started');
+        }
+        child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } })}\n`);
+    }
+    async trySetModel(model, throwOnFailure = false) {
+        if (!this.sessionId) {
+            return false;
+        }
+        try {
+            await this.sendRequest('session/set_model', {
+                sessionId: this.sessionId,
+                modelId: model,
+            });
+            return true;
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            appendEntry(this.record, 'system', JSON.stringify({
+                type: 'session.set_model.skipped',
+                model,
+                reason,
+            }), []);
+            if (throwOnFailure) {
+                throw new Error(reason);
+            }
+            return false;
+        }
+    }
+}
+function buildConversationSession(options) {
+    const hook = getWatchHook(options.backend);
+    return new AcpSession(options, hook);
+}
+async function handleWatchShellCommand(args) {
+    const { input, session, display, queueState, backend, record } = args;
+    if (input === '/exit' || input === '/quit') {
+        return 'exit';
+    }
+    if (input === '/help') {
+        display.showHelp();
+        return 'handled';
+    }
+    if (input === '/session') {
+        appendAndDisplaySessionNote(record, display, [
+            `session=${record.id}`,
+            `backend=${record.backend}`,
+            `runtime=${record.runtime}`,
+            `source=${record.resolvedCredentialSource ?? record.credentialSource}`,
+            `model=${record.model ?? 'default'}`,
+            `cwd=${record.cwd}`,
+        ].join(' | '));
+        return 'handled';
+    }
+    if (input === '/queue') {
+        appendAndDisplaySessionNote(record, display, `queue | steer=${queueState.steeringCount} | follow-up=${queueState.followUpCount}`);
+        return 'handled';
+    }
+    if (input === '/sessions') {
+        const summaries = listWatchSessions().slice(0, 5).map(formatWatchSessionSummary);
+        if (summaries.length === 0) {
+            appendAndDisplaySessionNote(record, display, 'No archived watch sessions found');
+            return 'handled';
+        }
+        for (const summary of summaries) {
+            appendAndDisplaySessionNote(record, display, summary);
+        }
+        return 'handled';
+    }
+    if (input === '/new') {
+        appendAndDisplaySessionNote(record, display, 'Use `linx watch run` to start a fresh watch session');
+        return 'handled';
+    }
+    if (input === '/debug' || input === '/debug on') {
+        display.setDebugMode(true);
+        appendSessionNote(record, 'Debug protocol view enabled', { debug: true });
+        return 'handled';
+    }
+    if (input === '/debug off') {
+        display.setDebugMode(false);
+        appendSessionNote(record, 'Debug protocol view disabled', { debug: false });
+        return 'handled';
+    }
+    if (input.startsWith('/model ')) {
+        const model = input.slice('/model '.length).trim();
+        if (!model) {
+            appendAndDisplaySessionNote(record, display, 'Usage: /model <modelId>', 'error');
+            return 'handled';
+        }
+        try {
+            await session.setModel(model);
+            appendAndDisplaySessionNote(record, display, `Model set to ${model}`, 'success', { backend, model });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            appendAndDisplaySessionNote(record, display, `Model switch failed | ${reason}`, 'error', { backend, model, reason });
+        }
+        return 'handled';
+    }
+    return 'pass';
+}
+export const __testHandleWatchShellCommand = handleWatchShellCommand;
+export async function runWatch(options) {
+    const previousPlainEnv = process.env.LINX_WATCH_PLAIN;
+    if (options.plain) {
+        process.env.LINX_WATCH_PLAIN = '1';
+    }
+    let fatalError = null;
+    let session = null;
+    const requestedOptions = {
+        ...options,
+        runtime: requestedRuntime(options),
+        transport: 'acp',
+        credentialSource: requestedCredentialSource(options),
+        approvalSource: requestedApprovalSource(options),
+    };
+    try {
+        session = buildConversationSession(requestedOptions);
+        const activeSession = session;
+        activeSession.display.start();
+        activeSession.display.showHelp();
+        activeSession.display.setPhase('starting', `Preparing ${requestedOptions.backend}`);
+        activeSession.display.updateQueue({
+            steeringCount: 0,
+            followUpCount: 0,
+        });
+        let resolvedRun;
+        try {
+            resolvedRun = await resolveWatchRunOptions(requestedOptions);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendEntry(activeSession.record, 'system', JSON.stringify({
+                type: 'credentials.resolve',
+                backend: requestedOptions.backend,
+                requestedCredentialSource: requestedOptions.credentialSource,
+                error: message,
+            }), []);
+            throw error;
+        }
+        activeSession.applyResolvedOptions(resolvedRun.options);
+        appendEntry(activeSession.record, 'system', JSON.stringify({
+            type: 'credentials.resolve',
+            backend: resolvedRun.options.backend,
+            requestedCredentialSource: resolvedRun.options.credentialSource,
+            resolvedCredentialSource: resolvedRun.options.resolvedCredentialSource,
+        }), []);
+        const authPreflight = resolvedRun.authPreflight;
+        if (authPreflight.state === 'unauthenticated') {
+            const message = authPreflight.message ?? `${resolvedRun.options.backend} is not authenticated`;
+            appendEntry(activeSession.record, 'system', JSON.stringify({
+                type: 'auth.preflight',
+                backend: resolvedRun.options.backend,
+                state: authPreflight.state,
+                resolvedCredentialSource: resolvedRun.options.resolvedCredentialSource,
+            }), [
+                { type: 'session.note', message, raw: { backend: resolvedRun.options.backend, state: authPreflight.state } },
+            ]);
+            throw new Error(message);
+        }
+        await activeSession.start();
+        const steeringQueue = [];
+        const followUpQueue = [];
+        let stopRequested = false;
+        let activeTurn = null;
+        let wakeResolver = null;
+        const resolveWake = () => {
+            if (!wakeResolver) {
+                return;
+            }
+            const resolve = wakeResolver;
+            wakeResolver = null;
+            resolve();
+        };
+        const waitForWake = async () => {
+            if (fatalError || (stopRequested && activeTurn === null)) {
+                return;
+            }
+            await new Promise((resolve) => {
+                wakeResolver = resolve;
+            });
+        };
+        const updateQueueState = () => {
+            activeSession.display.updateQueue({
+                steeringCount: steeringQueue.length,
+                followUpCount: followUpQueue.length,
+            });
+        };
+        const clearQueuedSubmissions = () => {
+            if (steeringQueue.length === 0 && followUpQueue.length === 0) {
+                return;
+            }
+            steeringQueue.length = 0;
+            followUpQueue.length = 0;
+            updateQueueState();
+        };
+        const restoreQueuedSubmission = () => {
+            const restored = steeringQueue.pop() ?? followUpQueue.pop() ?? null;
+            updateQueueState();
+            return restored;
+        };
+        const inputController = {
+            restoreQueuedSubmission,
+        };
+        session.display.bindInputController(inputController);
+        const enqueueSubmission = (submission) => {
+            if (submission.mode === 'follow-up') {
+                followUpQueue.push(submission);
+            }
+            else {
+                steeringQueue.push(submission);
+            }
+            updateQueueState();
+            appendSessionNote(activeSession.record, submission.mode === 'follow-up'
+                ? `Queued follow-up message (${followUpQueue.length} total)`
+                : `Queued steering message (${steeringQueue.length} total)`, { text: submission.text, mode: submission.mode });
+            resolveWake();
+        };
+        const dequeueSubmission = () => {
+            const next = steeringQueue.shift() ?? followUpQueue.shift() ?? null;
+            updateQueueState();
+            return next;
+        };
+        const runTurn = (text) => {
+            const trimmed = text.trim();
+            if (!trimmed) {
+                return;
+            }
+            activeSession.display.showUserTurn(trimmed);
+            activeSession.display.setPhase('running', `Running ${resolvedRun.options.backend}`);
+            activeTurn = activeSession.sendTurn(trimmed)
+                .catch((error) => {
+                fatalError = error instanceof Error ? error : new Error(String(error));
+            })
+                .finally(() => {
+                activeTurn = null;
+                if (fatalError) {
+                    stopRequested = true;
+                    clearQueuedSubmissions();
+                    resolveWake();
+                    return;
+                }
+                const next = dequeueSubmission();
+                if (next) {
+                    runTurn(next.text);
+                    return;
+                }
+                if (stopRequested) {
+                    resolveWake();
+                    return;
+                }
+                activeSession.display.setPhase('ready', 'Waiting for input');
+                resolveWake();
+            });
+        };
+        const dispatchSubmission = async (submission) => {
+            const trimmed = submission.text.trim();
+            if (!trimmed) {
+                return;
+            }
+            const shellCommand = await handleWatchShellCommand({
+                input: trimmed,
+                session: activeSession,
+                display: activeSession.display,
+                queueState: {
+                    steeringCount: steeringQueue.length,
+                    followUpCount: followUpQueue.length,
+                },
+                backend: resolvedRun.options.backend,
+                record: activeSession.record,
+            });
+            if (shellCommand === 'handled') {
+                activeSession.display.setPhase(activeTurn ? 'running' : 'ready', activeTurn ? `Running ${resolvedRun.options.backend}` : 'Waiting for input');
+                resolveWake();
+                return;
+            }
+            if (shellCommand === 'exit') {
+                stopRequested = true;
+                resolveWake();
+                return;
+            }
+            if (activeTurn) {
+                enqueueSubmission({
+                    text: trimmed,
+                    mode: submission.mode,
+                });
+                return;
+            }
+            runTurn(trimmed);
+        };
+        let inputLoop = null;
+        if (resolvedRun.options.prompt) {
+            await dispatchSubmission({
+                text: resolvedRun.options.prompt,
+                mode: 'send',
+            });
+            stopRequested = true;
+        }
+        else {
+            inputLoop = (async () => {
+                activeSession.display.setPhase('ready', 'Waiting for input');
+                while (!fatalError && !stopRequested) {
+                    const submission = await activeSession.display.promptInput('you> ');
+                    await dispatchSubmission(submission);
+                }
+            })().catch((error) => {
+                fatalError = error instanceof Error ? error : new Error(String(error));
+                stopRequested = true;
+                clearQueuedSubmissions();
+                resolveWake();
+            });
+        }
+        while (!fatalError && (!stopRequested || activeTurn !== null || steeringQueue.length > 0 || followUpQueue.length > 0)) {
+            await waitForWake();
+        }
+        void inputLoop;
+        if (fatalError) {
+            throw fatalError;
+        }
+        return 0;
+    }
+    catch (error) {
+        fatalError = error instanceof Error ? error : new Error(String(error));
+        throw fatalError;
+    }
+    finally {
+        if (session) {
+            await session.close();
+            const finalRecord = await session.finalizeAndClose(fatalError ? 'failed' : 'completed', fatalError?.message);
+            await watchRuntime.persistWatchConversationToPod(finalRecord).catch(() => undefined);
+        }
+        if (options.plain) {
+            if (previousPlainEnv === undefined) {
+                delete process.env.LINX_WATCH_PLAIN;
+            }
+            else {
+                process.env.LINX_WATCH_PLAIN = previousPlainEnv;
+            }
+        }
+    }
+}
+export function listArchivedWatchSessions() {
+    return listWatchSessions();
+}
+export function loadArchivedWatchSession(id) {
+    return loadWatchSession(id);
+}
+export function loadArchivedWatchEvents(id) {
+    return loadWatchEvents(id);
+}
+export { formatWatchSessionSummary };
+export function listSupportedWatchBackends() {
+    return listWatchHooks().map((hook) => ({
+        backend: hook.id,
+        label: hook.label,
+        description: hook.description,
+        modes: {
+            manual: describeWatchMode('manual'),
+            smart: describeWatchMode('smart'),
+            auto: describeWatchMode('auto'),
+        },
+    }));
+}
+//# sourceMappingURL=runner.js.map