@undefineds.co/linx 0.3.26 → 0.3.28

package/dist/lib/auto-mode/runner.js

@@ -1,52 +1,24 @@
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
-import { buildAcpPermissionResponse, buildAutoModeUserInputResponse, MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, normalizeAcpInteractionRequest, normalizeAcpRequest, normalizeAcpSessionNotification, parseAutoModeJsonLine, autoModeApprovalDecisionLabel, autoModeUserInputAnswersSummary, resolveAutoModeCommandRoute, shouldMaterializeAutoModeGrant, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
-import { adoptAutoModeSessionId, appendAutoModeEvent, createAutoModeSession, finishAutoModeSession, hasPendingAutoModeSync, loadAutoModeEvents, loadAutoModeSession, listAutoModeSessionsWithPendingSync, listAutoModeSessions, writeAutoModeSyncCheckpoint, writeAutoModeSession, } from './archive.js';
-import { detectAutoModeAuthFailure, preflightAutoModeAuth } from './auth.js';
+import { buildAcpPermissionResponse, buildAutoModeUserInputResponse, normalizeAcpInteractionRequest, normalizeAcpRequest, normalizeAcpSessionNotification, parseAutoModeJsonLine, autoModeApprovalDecisionLabel, autoModeUserInputAnswersSummary, shouldMaterializeAutoModeGrant, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
+import { adoptAutoModeSessionId, createAutoModeSession, finishAutoModeSession, hasPendingAutoModeSync, loadAutoModeEvents, loadAutoModeSession, listAutoModeSessionsWithPendingSync, listAutoModeSessions, writeAutoModeSyncCheckpoint, writeAutoModeSession, } from './archive.js';
+import { detectAutoModeAuthFailure, promptLinxCloudAuth, runBackendLinxLogin, runBackendLinxLogout } from './auth.js';
 import { createAutoModeDisplay } from './display.js';
 import { formatAutoModeSessionSummary } from './format.js';
-import { describeAutoControl, getAutoModeHook, linxNativeBackend, listAutoModeHooks } from './hooks/index.js';
-import { createRemoteAutoModeApproval, isRemoteApprovalAbortError, materializeRemoteAutoModeGrant, resolveExistingRemoteAutoModeGrant, resolveRemoteAutoModeApproval, waitForRemoteAutoModeApproval, } from './pod-approval.js';
-import { persistAutoModeConversationToPod } from './pod-persistence.js';
-import { loadPodBackendCredential, podCredentialMissingMessage } from './pod-ai.js';
-import { resolveAutoModeSecretaryRecommendation } from './secretary.js';
-import { promptText } from '../prompt.js';
-import { runLinxLoginCommand, runLinxLogoutCommand } from '../login-command.js';
-import { clearDefaultPodDataSession, createPodDataSession } from '../pod-data-session.js';
-import { parseSolidClientCredentials, persistSolidClientCredentialsLogin } from '../solid-client-credentials-login.js';
-import { connectAiProviderCredential } from '../ai-command.js';
-import { saveAccountSession } from '../account-session.js';
-import { clearCredentials, loadCredentials, saveCredentials } from '../credentials-store.js';
-import { resolveAccountBaseUrl } from '../account-api.js';
-import { createRemoteCompletionResult } from '../chat-api.js';
+import { describeAutoControl, getAutoModeHook, linxNativeBackend, listAutoModeHooks } from './hooks/registry.js';
+import { isRemoteApprovalAbortError } from './pod-approval.js';
+import { podCredentialMissingMessage } from './pod-ai.js';
+import { resolveSecretaryReactionWindowMs } from './secretary-reaction-window.js';
+import { isAcpAutoModeWorkerBackend, isAutoModeWorkerBackend, resolveApprovalStrategy, defaultAutoModeApprovalStrategy } from './backend-kind.js';
+import { appendAutoModeSessionEvent as appendEntry, appendAndDisplaySessionNote, appendSessionNote } from './session-log.js';
+import { handleAutoModeShellCommand } from './shell-command.js';
+import { autoModeRuntime } from './runtime.js';
 import { resolveRuntimeTarget } from '../runtime-target.js';
 import { runThreadReconcilerCycle } from '../../../vendor/agent-runtime/dist/index.js';
 import { createLinxSyncCheckpoint } from '../../../vendor/agent-runtime/dist/sync.js';
 const AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH = 10;
 const AUTO_MODE_SECRETARY_COUNTDOWN_TICK_MS = 250;
 const POD_PERSISTENCE_TIMEOUT_MS = 5_000;
-export const autoModeRuntime = {
-    promptText,
-    preflightAutoModeAuth,
-    loadPodBackendCredential,
-    connectAiProviderCredential,
-    createRemoteAutoModeApproval,
-    resolveExistingRemoteAutoModeGrant,
-    waitForRemoteAutoModeApproval,
-    resolveRemoteAutoModeApproval,
-    materializeRemoteAutoModeGrant,
-    persistAutoModeConversationToPod,
-    resolveAutoModeSecretaryRecommendation,
-    createPodDataSession,
-    clearDefaultPodDataSession,
-    loadCredentials,
-    saveCredentials,
-    clearCredentials,
-    saveAccountSession,
-    resolveAccountBaseUrl,
-    persistSolidClientCredentialsLogin,
-    createRemoteCompletionResult,
-};
 function createLineSplitter(stream, onLine) {
     let buffer = '';
     return {
@@ -123,55 +95,6 @@ function withAbortSignal(promise, signal) {
             .finally(() => signal.removeEventListener('abort', onAbort));
     });
 }
-function appendEntry(record, stream, line, events) {
-    const entry = {
-        timestamp: new Date().toISOString(),
-        stream,
-        line,
-        events,
-    };
-    appendAutoModeEvent(record, entry);
-}
-function appendSessionNote(record, message, raw) {
-    appendEntry(record, 'system', JSON.stringify({
-        type: 'session.note',
-        message,
-    }), [{
-            type: 'session.note',
-            message,
-            raw,
-        }]);
-}
-function writeFailedPodSyncCheckpoint(record, message) {
-    const now = new Date().toISOString();
-    const result = {
-        source: 'auto-mode-archive',
-        target: 'pod',
-        direction: 'local-to-core',
-        plane: 'projection',
-        authority: 'core',
-        attempted: 0,
-        applied: 0,
-        skipped: 0,
-        failed: 1,
-        failures: [{
-                operationId: 'auto-mode.persist-to-pod',
-                message,
-                failedAt: now,
-            }],
-        startedAt: now,
-        completedAt: now,
-        status: 'failed',
-    };
-    writeAutoModeSyncCheckpoint(record, createLinxSyncCheckpoint('auto-mode-archive:pod:projection', result, {
-        sessionId: record.id,
-        backend: record.backend,
-    }));
-}
-function appendAndDisplaySessionNote(record, display, message, tone = 'note', raw) {
-    appendSessionNote(record, message, raw);
-    display.showActivity(message, tone);
-}
 async function promptApproval(display, message, allowSessionOption = true, signal, recommendation) {
     while (true) {
         display.setPhase('approval', message);
@@ -211,17 +134,6 @@ function approvalPromptLines(message, recommendation) {
     }
     return lines;
 }
-function resolveSecretaryReactionWindowMs(recommendation) {
-    if (!recommendation?.canAutoDecide) {
-        return 0;
-    }
-    const reactionWindowMs = recommendation.reactionWindowMs ?? 0;
-    if (recommendation.source === 'fallback') {
-        return Math.max(0, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, reactionWindowMs));
-    }
-    return Math.max(MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, reactionWindowMs > 0 ? reactionWindowMs : MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS));
-}
-export const __testResolveSecretaryReactionWindowMs = resolveSecretaryReactionWindowMs;
 function approvalPromptOptions(allowSessionOption, recommendedDecision) {
     const option = (decision, label, description, shortcuts) => ({
         label: recommendedDecision === decision ? `${label} (recommended)` : label,
@@ -312,87 +224,6 @@ export function formatAutoModeSecretaryCountdownDetail(remainingMs, durationMs)
     const bar = `${'#'.repeat(filled)}${'-'.repeat(AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH - filled)}`;
     return `auto [${bar}] ${formatReactionWindow(clampedRemainingMs)}`;
 }
-async function promptLinxCloudAuth(display, lines, reason = 'manual') {
-    while (true) {
-        display.setPhase('question', reason === 'expired' ? 'LinX Cloud login expired' : 'LinX Cloud login required');
-        const answer = (await display.chooseOption(reason === 'expired' ? 'LinX Cloud login expired' : 'LinX Cloud login required', lines, [
-            { label: 'Authorize in browser', value: 'browser', description: 'refresh the LinX Cloud Solid session', shortcuts: ['b', '1'] },
-            { label: 'Enter Solid client credentials', value: 'client-credentials', description: 'use LinX Cloud client credentials', shortcuts: ['k', '2'] },
-            { label: 'Exit', value: 'exit', description: 'leave this session', shortcuts: ['x', '3'] },
-        ])).trim().toLowerCase();
-        if (answer === 'browser' || answer === 'b' || answer === '1') {
-            await runBackendLinxLogin(display);
-            return 'retry';
-        }
-        if (answer === 'client-credentials' || answer === 'k' || answer === '2') {
-            const saved = await promptBackendSolidClientCredentials(display);
-            if (saved) {
-                return 'retry';
-            }
-            continue;
-        }
-        if (answer === 'exit' || answer === 'x' || answer === '3' || answer === 'cancel') {
-            display.setPhase('running', 'Authentication cancelled');
-            return 'cancel';
-        }
-    }
-}
-async function runBackendLinxLogin(display) {
-    display.showActivity('Opening LinX Cloud login in your browser...');
-    await runLinxLoginCommand({}, {
-        promptText: autoModeRuntime.promptText,
-        write(chunk) {
-            for (const line of chunk.split(/\r?\n/u)) {
-                const trimmed = line.trim();
-                if (trimmed) {
-                    display.showActivity(trimmed);
-                }
-            }
-        },
-    });
-    autoModeRuntime.clearDefaultPodDataSession();
-    display.showActivity('LinX Cloud login refreshed.', 'success');
-}
-function runBackendLinxLogout(display) {
-    runLinxLogoutCommand({
-        write(chunk) {
-            for (const line of chunk.split(/\r?\n/u)) {
-                const trimmed = line.trim();
-                if (trimmed) {
-                    display.showActivity(trimmed);
-                }
-            }
-        },
-    });
-    autoModeRuntime.clearDefaultPodDataSession();
-    display.showActivity('Use /login or choose browser authorization to sign in again.', 'note');
-}
-async function promptBackendSolidClientCredentials(display) {
-    display.setPhase('question', 'Solid client credentials required');
-    const credentialsText = await display.promptSecret({
-        header: 'Solid client credentials',
-        question: 'Paste Solid client credentials in client_id:client_secret format.',
-        note: 'Input is hidden and saved locally as LinX Cloud client credentials.',
-    });
-    const parsed = parseSolidClientCredentials(credentialsText);
-    if (!parsed) {
-        display.showActivity('Solid client credentials entry cancelled or invalid. Expected client_id:client_secret.', 'error');
-        return false;
-    }
-    autoModeRuntime.clearDefaultPodDataSession();
-    try {
-        await autoModeRuntime.persistSolidClientCredentialsLogin(credentialsText, autoModeRuntime);
-        autoModeRuntime.clearDefaultPodDataSession();
-        display.showActivity('Solid client credentials saved. Retrying backend startup.', 'success');
-        return true;
-    }
-    catch (error) {
-        autoModeRuntime.clearDefaultPodDataSession();
-        const message = error instanceof Error ? error.message : String(error);
-        display.showActivity(`Solid client credentials rejected: ${message}`, 'error');
-        return false;
-    }
-}
 function isRecoverableLinxCloudAuthError(message) {
     const normalized = message.toLowerCase();
     return normalized.includes('linx login')
@@ -501,12 +332,6 @@ function createAcpInteractionThreadEvent(record, interaction) {
 function requestedCredentialSource(options) {
     return options.credentialSource === 'local' ? 'local' : 'cloud';
 }
-function defaultApprovalStrategy() {
-    return 'hybrid';
-}
-function resolveApprovalStrategy(options) {
-    return options.approvalStrategy ?? defaultApprovalStrategy();
-}
 function requestedRuntime(options) {
     return options.runtime ?? 'local';
 }
@@ -519,11 +344,31 @@ function requestedAutoModeMode(options) {
     }
     return requestedAutoEnabled(options) ? 'auto' : 'off';
 }
-function isAutoModeWorkerBackend(backend) {
-    return backend === 'linx' || backend === 'codex' || backend === 'claude' || backend === 'codebuddy';
-}
-function isAcpAutoModeWorkerBackend(backend) {
-    return backend === 'codex' || backend === 'claude' || backend === 'codebuddy';
+function writeFailedPodSyncCheckpoint(record, message) {
+    const now = new Date().toISOString();
+    const result = {
+        source: 'auto-mode-archive',
+        target: 'pod',
+        direction: 'local-to-core',
+        plane: 'projection',
+        authority: 'core',
+        attempted: 0,
+        applied: 0,
+        skipped: 0,
+        failed: 1,
+        failures: [{
+                operationId: 'auto-mode.persist-to-pod',
+                message,
+                failedAt: now,
+            }],
+        startedAt: now,
+        completedAt: now,
+        status: 'failed',
+    };
+    writeAutoModeSyncCheckpoint(record, createLinxSyncCheckpoint('auto-mode-archive:pod:projection', result, {
+        sessionId: record.id,
+        backend: record.backend,
+    }));
 }
 function normalizeBackendCommandEnv(backend, env) {
     if (!env) {
@@ -554,7 +399,7 @@ function syncRecordFromOptions(record, options, plan) {
         passthroughArgs: [...options.passthroughArgs],
         credentialSource: requestedCredentialSource(options),
         resolvedCredentialSource: options.resolvedCredentialSource,
-        approvalSource: record.approvalSource ?? defaultApprovalStrategy(),
+        approvalSource: record.approvalSource ?? defaultAutoModeApprovalStrategy(),
         command: plan.command,
         args: [...plan.args],
         transport: options.transport ?? (options.backend === 'linx' ? 'native' : 'acp'),
@@ -1496,192 +1341,6 @@ function buildConversationSession(options) {
     const hook = getAutoModeHook(options.backend);
     return new AcpSession(options, hook);
 }
-async function handleAutoModeShellCommand(args) {
-    const { input, session, display, queueState, backend, record } = args;
-    if (input === '/exit' || input === '/quit') {
-        return 'exit';
-    }
-    if (input === '/help' || input === '/hotkeys' || input === '/keymap') {
-        display.showHelp();
-        return 'handled';
-    }
-    if (input === '/login') {
-        try {
-            await runBackendLinxLogin(display);
-            appendSessionNote(record, 'LinX Cloud login refreshed from auto-mode');
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            appendAndDisplaySessionNote(record, display, `LinX Cloud login failed | ${message}`, 'error', { error: message });
-        }
-        return 'handled';
-    }
-    if (input === '/logout') {
-        runBackendLinxLogout(display);
-        appendSessionNote(record, 'LinX Cloud logout requested from auto-mode');
-        return 'handled';
-    }
-    if (input === '/session') {
-        appendAndDisplaySessionNote(record, display, [
-            `session=${record.backendSessionId ?? record.id}`,
-            `backend=${record.backend}`,
-            `runtime=${record.runtime}`,
-            'credentials=pod',
-            `model=${record.model ?? 'default'}`,
-            `cwd=${record.cwd}`,
-        ].join(' | '));
-        return 'handled';
-    }
-    const autoModeRoute = resolveAutoModeCommandRoute(input);
-    if (autoModeRoute) {
-        return handleAutoModeCommandRoute({
-            route: autoModeRoute,
-            session,
-            display,
-            record,
-        });
-    }
-    if (input === '/queue') {
-        appendAndDisplaySessionNote(record, display, `queue | steer=${queueState.steeringCount} | follow-up=${queueState.followUpCount}`);
-        return 'handled';
-    }
-    if (input.startsWith('/follow-up ')) {
-        return 'pass';
-    }
-    if (input === '/sessions') {
-        const summaries = listAutoModeSessions().slice(0, 5).map(formatAutoModeSessionSummary);
-        if (summaries.length === 0) {
-            appendAndDisplaySessionNote(record, display, 'No archived auto-mode sessions found');
-            return 'handled';
-        }
-        for (const summary of summaries) {
-            appendAndDisplaySessionNote(record, display, summary);
-        }
-        return 'handled';
-    }
-    if (input === '/new') {
-        appendAndDisplaySessionNote(record, display, 'Use `linx --backend <backend>` to start a fresh auto-mode 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';
-}
-function handleAutoModeCommandRoute(args) {
-    const { route, session, display, record } = args;
-    if (route.kind === 'control-command') {
-        return handleAutoModeControlCommand({ route, session, display, record });
-    }
-    return handleAutoModePeerCommand({ route, session, display, record });
-}
-function handleAutoModeControlCommand(args) {
-    const { route, session, display, record } = args;
-    const auto = route.auto;
-    if (!auto || auto.action === 'status') {
-        const enabled = record.autoEnabled === true;
-        appendAndDisplaySessionNote(record, display, `Auto is ${enabled ? 'on' : 'off'}. Use /auto on or /auto off.`);
-        return 'handled';
-    }
-    if (!isAutoModeWorkerBackend(record.backend)) {
-        throw new Error(`Auto control commands cannot run backend ${record.backend}`);
-    }
-    applyAutoModeAutoEnabled(session, record, auto.enabled);
-    appendAndDisplaySessionNote(record, display, `Auto ${auto.enabled ? 'on' : 'off'}: ${auto.enabled ? 'Secretary drives the session and asks when blocked' : 'user drives the session directly'}.`, 'success', { autoEnabled: auto.enabled });
-    if (auto.initialInput) {
-        const projectedRoute = resolveAutoModeCommandRoute(auto.initialInput);
-        if (projectedRoute) {
-            return handleAutoModeCommandRoute({
-                route: projectedRoute,
-                session,
-                display,
-                record,
-            });
-        }
-        return { kind: 'send', text: auto.initialInput };
-    }
-    return 'handled';
-}
-function handleAutoModePeerCommand(args) {
-    const { route, session, display, record } = args;
-    const goalMirror = route.secretaryBehavior?.goalMode;
-    if (goalMirror !== undefined) {
-        applyAutoModeGoalMode(session, record, goalMirror);
-        appendAndDisplaySessionNote(record, display, `Goal command routed to current chat peer; local supervision mirror is ${goalMirror ? 'active' : 'paused'}.`, 'success', { goalMode: goalMirror, peerCommand: route.text });
-    }
-    else {
-        appendAndDisplaySessionNote(record, display, 'Goal command routed to current chat peer.', 'note', { peerCommand: route.text });
-    }
-    return { kind: 'send', text: route.text };
-}
-function applyAutoModeAutoEnabled(session, record, enabled) {
-    session.applyResolvedOptions({
-        backend: record.backend,
-        autoEnabled: enabled,
-        mode: enabled ? 'auto' : 'off',
-        cwd: record.cwd,
-        plain: false,
-        model: record.model,
-        prompt: record.prompt,
-        passthroughArgs: record.passthroughArgs,
-        goalMode: record.goalMode,
-        runtime: record.runtime,
-        transport: record.transport,
-        credentialSource: record.credentialSource,
-        resolvedCredentialSource: record.resolvedCredentialSource,
-        approvalStrategy: resolveApprovalStrategy({ approvalStrategy: record.approvalSource }),
-    });
-    record.autoEnabled = enabled;
-    record.mode = enabled ? 'auto' : 'off';
-}
-function applyAutoModeGoalMode(session, record, enabled) {
-    if (!isAutoModeWorkerBackend(record.backend)) {
-        throw new Error(`Goal peer commands cannot run backend ${record.backend}`);
-    }
-    session.applyResolvedOptions({
-        backend: record.backend,
-        autoEnabled: record.autoEnabled === true,
-        mode: record.mode,
-        cwd: record.cwd,
-        plain: false,
-        model: record.model,
-        prompt: record.prompt,
-        passthroughArgs: record.passthroughArgs,
-        goalMode: enabled,
-        runtime: record.runtime,
-        transport: record.transport,
-        credentialSource: record.credentialSource,
-        resolvedCredentialSource: record.resolvedCredentialSource,
-        approvalStrategy: resolveApprovalStrategy({ approvalStrategy: record.approvalSource }),
-    });
-    record.goalMode = enabled || undefined;
-}
-export const __testHandleAutoModeShellCommand = handleAutoModeShellCommand;
-export const __testPromptLinxCloudAuth = promptLinxCloudAuth;
-export const __testParseSolidClientCredentials = parseSolidClientCredentials;
 export async function runAutoMode(options) {
     const previousPlainEnv = process.env.LINX_BACKEND_PLAIN;
     if (options.plain) {
@@ -1945,6 +1604,10 @@ export async function runAutoMode(options) {
                 },
                 backend: resolvedRun.options.backend,
                 record: activeSession.record,
+                auth: {
+                    login: runBackendLinxLogin,
+                    logout: runBackendLinxLogout,
+                },
             });
             if (shellCommand === 'handled') {
                 activeSession.display.setPhase(activeTurn ? 'running' : 'ready', activeTurn ? `Running ${resolvedRun.options.backend}` : 'Waiting for input');