@undefineds.co/linx 0.3.25 → 0.3.27

package/dist/lib/linx-interrupt-control.js

@@ -0,0 +1,96 @@
+import { handleInteractiveRewindSelector } from './linx-rewind-command.js';
+import { showLinxInteractiveError } from './linx-interactive-error-display.js';
+import { showLinxInteractiveStatus } from './linx-interactive-status-display.js';
+import { getLinxInteractiveEditorText } from './linx-interactive-editor-text-host.js';
+import { getLinxInteractiveDefaultEditorComponent } from './linx-editor-component-router.js';
+import { getLinxInteractiveRuntime } from './linx-interactive-runtime-host.js';
+import { isLinxInteractiveAutoModeEnabled } from './linx-interactive-shell-state.js';
+import { stopLinxInteractiveSessionWorkNow } from './linx-session-work-control.js';
+import { isClearInterruptInstalled, isEscapeInterruptInstalled, isEscapeInterruptWrapper, markClearInterruptInstalled, markEscapeInterruptInstalled, markEscapeInterruptWrapper, } from './linx-interrupt-control-host.js';
+export function installLinxEscapeInterrupt(interactive, options = {}) {
+    const editor = getLinxInteractiveDefaultEditorComponent(interactive);
+    if (!editor || isEscapeInterruptInstalled(editor)) {
+        return;
+    }
+    const initialOnEscape = typeof editor.onEscape === 'function'
+        ? editor.onEscape
+        : undefined;
+    let currentOnEscape = isEscapeInterruptWrapper(initialOnEscape)
+        ? undefined
+        : initialOnEscape;
+    let lastIdleEscapeTime = 0;
+    const linxEscapeInterrupt = function linxEscapeInterrupt() {
+        if (handBackAutoControlOnInterrupt(interactive, options)) {
+            lastIdleEscapeTime = 0;
+            return;
+        }
+        if (stopLinxInteractiveSessionWorkNow(interactive)) {
+            lastIdleEscapeTime = 0;
+            return;
+        }
+        if (shouldHandleLinxIdleDoubleEscape(interactive)) {
+            const now = Date.now();
+            if (now - lastIdleEscapeTime < 500) {
+                lastIdleEscapeTime = 0;
+                void openInteractiveRewindFromEscape(interactive);
+            }
+            else {
+                lastIdleEscapeTime = now;
+                showLinxInteractiveStatus(interactive, 'Press Escape again to rewind this session.');
+            }
+            return;
+        }
+        lastIdleEscapeTime = 0;
+        currentOnEscape?.call(editor);
+    };
+    markEscapeInterruptWrapper(linxEscapeInterrupt);
+    Object.defineProperty(editor, 'onEscape', {
+        configurable: true,
+        get() {
+            return linxEscapeInterrupt;
+        },
+        set(next) {
+            if (isEscapeInterruptWrapper(next)) {
+                return;
+            }
+            currentOnEscape = typeof next === 'function' ? next : undefined;
+        },
+    });
+    installLinxClearInterrupt(interactive, editor, options);
+    markEscapeInterruptInstalled(editor);
+}
+function shouldHandleLinxIdleDoubleEscape(interactive) {
+    const text = getLinxInteractiveEditorText(interactive);
+    return typeof text === 'string' && text.trim().length === 0;
+}
+async function openInteractiveRewindFromEscape(interactive) {
+    try {
+        await handleInteractiveRewindSelector(interactive, getLinxInteractiveRuntime(interactive));
+    }
+    catch (error) {
+        showLinxInteractiveError(interactive, error instanceof Error ? error.message : String(error));
+    }
+}
+function installLinxClearInterrupt(interactive, editor, options) {
+    const handlers = editor?.actionHandlers;
+    if (!(handlers instanceof Map) || isClearInterruptInstalled(editor)) {
+        return;
+    }
+    const originalClear = handlers.get('app.clear');
+    handlers.set('app.clear', () => {
+        if (handBackAutoControlOnInterrupt(interactive, options)) {
+            return;
+        }
+        originalClear?.call(editor);
+    });
+    markClearInterruptInstalled(editor);
+}
+function handBackAutoControlOnInterrupt(interactive, options) {
+    if (!isLinxInteractiveAutoModeEnabled(interactive, getLinxInteractiveRuntime(interactive))) {
+        return false;
+    }
+    stopLinxInteractiveSessionWorkNow(interactive);
+    void options.disableAutoMode?.(interactive);
+    return true;
+}
+//# sourceMappingURL=linx-interrupt-control.js.map

package/dist/lib/linx-interrupt-control.js.map

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

package/dist/lib/linx-login-flow.js

@@ -0,0 +1,566 @@
+import { clearAccountSession } from './account-session.js';
+import { clearCredentials } from './credentials-store.js';
+import { clearOidcSessionStorage } from './oidc-session-storage.js';
+import { persistSolidClientCredentialsLogin } from './solid-client-credentials-login.js';
+import { LINX_RUNTIME_MANAGED_AUTH_KEY } from './linx-runtime-auth.js';
+import { formatLinxCliErrorMessage, isLinxCloudAuthExpiredMessage } from './linx-cloud-errors.js';
+import { normalizeSelectorChoice } from './linx-selector-choice.js';
+import { openExternalUrl } from './linx-external-url.js';
+import { clearLinxInteractiveRuntimeAuthPromptOnStart, resolveLinxInteractiveRuntimeProviderLabel, } from './linx-interactive-runtime-host.js';
+import { registerLinxInteractiveSubmitHandler } from './linx-interactive-submit-router.js';
+import { registerLinxInteractiveLoginDialogHandler, registerLinxInteractiveOAuthSelectorHandler, } from './linx-interactive-login-ui-router.js';
+import { registerLinxInteractiveErrorHandler, registerLinxInteractiveEventHandler, } from './linx-interactive-event-router.js';
+import { showLinxInteractiveError } from './linx-interactive-error-display.js';
+import { showLinxInteractiveStatus } from './linx-interactive-status-display.js';
+import { refreshLinxInteractiveProviderCount } from './linx-interactive-provider-count-host.js';
+import { getLinxInteractiveAuthStorage, getLinxInteractiveLoginAuthStorage, refreshLinxInteractiveModelRegistry, } from './linx-interactive-model-registry-host.js';
+import { canCollectLinxInteractiveExtensionInput, collectLinxInteractiveExtensionInput, } from './linx-interactive-extension-input-host.js';
+import { canChooseLinxInteractiveExtensionSelectorOption, chooseLinxInteractiveExtensionSelectorOption, } from './linx-interactive-extension-selector-host.js';
+import { clearLinxInteractiveStreamingMessage } from './linx-interactive-streaming-message-host.js';
+import { appendLinxInteractiveChatText } from './linx-interactive-chat-text-host.js';
+import { setLinxInteractiveEditorText } from './linx-interactive-editor-text-host.js';
+import { getLinxInteractiveAuthState } from './linx-interactive-auth-state-host.js';
+import { isLinxInteractiveInitialized } from './linx-interactive-lifecycle-host.js';
+import { stopInteractiveShellUnlessRestarting } from './shell-lifecycle.js';
+import { canMountLinxEditorComponent, createLinxLoginDialogComponent, mountLinxEditorComponent, } from './linx-editor-component-router.js';
+import { captureLinxSessionRetryTurn, restoreLinxSessionHistoryBranch, } from './linx-session-history.js';
+import { retryLinxInteractiveSessionTurn } from './linx-session-work-control.js';
+const LINX_PROVIDER_ID = 'undefineds';
+const linxLoginFlowOptions = new WeakMap();
+const AUTH_OPTION_BROWSER = 'Authorize in browser';
+const AUTH_OPTION_CLIENT_CREDENTIALS = 'Enter Solid client credentials';
+const AUTH_OPTION_EXIT = 'Exit';
+export function installLinxLoginFlow(interactive, options = {}) {
+    rememberLinxLoginFlowOptions(interactive, options);
+    patchNativeOAuthSelectors(interactive, options);
+    patchLoginCommand(interactive, options);
+    patchAuthExpiredSessionEvents(interactive, options);
+    patchAuthExpiredLoginPrompt(interactive, options);
+}
+export function shouldDeferLinxCloudLogin(interactive) {
+    const authState = getLinxInteractiveAuthState(interactive);
+    return Boolean(authState.loginInProgress
+        || authState.loginOnInit
+        || authState.pendingRetry
+        || authState.loginScheduled);
+}
+export function requestLinxCloudLogin(interactive, reason = 'manual', options = {}) {
+    rememberLinxLoginFlowOptions(interactive, options);
+    if (!isLinxInteractiveInitialized(interactive)) {
+        getLinxInteractiveAuthState(interactive).loginOnInit = reason;
+        return;
+    }
+    void startLinxCloudLogin(interactive, { reason }, options);
+}
+export function startPendingLinxCloudLoginAfterInit(interactive) {
+    const authState = getLinxInteractiveAuthState(interactive);
+    if (!authState.loginOnInit) {
+        return;
+    }
+    const reason = typeof authState.loginOnInit === 'string'
+        ? authState.loginOnInit
+        : 'startup';
+    authState.loginOnInit = false;
+    const options = getLinxLoginFlowOptions(interactive);
+    queueMicrotask(() => startLinxCloudLogin(interactive, { reason }, options));
+}
+function rememberLinxLoginFlowOptions(interactive, options) {
+    if (interactive && typeof interactive === 'object') {
+        linxLoginFlowOptions.set(interactive, options);
+    }
+}
+function getLinxLoginFlowOptions(interactive) {
+    if (!interactive || typeof interactive !== 'object') {
+        return {};
+    }
+    return linxLoginFlowOptions.get(interactive) ?? {};
+}
+function patchLoginCommand(interactive, options) {
+    registerLinxInteractiveSubmitHandler(interactive, {
+        name: 'linx-login',
+        priority: 10,
+        async handler({ interactive: target, input }) {
+            if (input !== '/login') {
+                return false;
+            }
+            setLinxInteractiveEditorText(target, '');
+            await startLinxCloudLogin(target, {}, options);
+            return true;
+        },
+    });
+}
+function patchNativeOAuthSelectors(interactive, options) {
+    registerLinxInteractiveOAuthSelectorHandler(interactive, {
+        name: 'linx-login-flow:oauth-selector',
+        priority: 0,
+        async handler({ interactive: target, mode }) {
+            if (mode === 'logout') {
+                const authStorage = getLinxInteractiveAuthStorage(target);
+                authStorage?.logout?.(LINX_PROVIDER_ID);
+                authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, '');
+                clearAccountSession();
+                clearCredentials();
+                clearOidcSessionStorage();
+                await refreshLinxAuthState(target);
+                showLinxInteractiveStatus(target, 'Logged out of LinX Cloud.');
+                return { handled: true };
+            }
+            await startLinxCloudLogin(target, { reason: 'manual' }, options);
+            return { handled: true };
+        },
+    });
+    registerLinxInteractiveLoginDialogHandler(interactive, {
+        name: 'linx-login-flow:login-dialog',
+        priority: 0,
+        async handler({ interactive: target, providerId }) {
+            if (!providerId || providerId === LINX_PROVIDER_ID) {
+                await startLinxCloudLogin(target, { reason: 'manual' }, options);
+                return { handled: true };
+            }
+            showLinxInteractiveStatus(target, 'LinX only supports LinX Cloud authentication in this TUI.');
+            await startLinxCloudLogin(target, { reason: 'manual' }, options);
+            return { handled: true };
+        },
+    });
+}
+function patchAuthExpiredSessionEvents(interactive, options) {
+    registerLinxInteractiveEventHandler(interactive, {
+        name: 'linx-login-flow:auth-expired-event',
+        priority: 0,
+        handler({ interactive: target, event }) {
+            const normalizedEvent = normalizeLinxCliErrorEvent(event);
+            if (eventHasLinxAuthExpiredError(normalizedEvent)) {
+                showLinxAuthExpiredRecoveryNotice(target);
+                prepareLinxAuthExpiredRetry(target);
+                suppressLinxAuthExpiredAssistantError(target);
+                scheduleLinxCloudLogin(target, 'expired', options);
+                return { handled: true };
+            }
+            return { handled: false, event: normalizedEvent };
+        },
+    });
+}
+function patchAuthExpiredLoginPrompt(interactive, options) {
+    registerLinxInteractiveErrorHandler(interactive, {
+        name: 'linx-login-flow:auth-expired-error',
+        priority: 0,
+        handler({ interactive: target, errorMessage }) {
+            const text = typeof errorMessage === 'string' ? errorMessage : String(errorMessage);
+            if (getLinxInteractiveAuthState(target).reportingError || !isLinxAuthExpiredError(text)) {
+                return { handled: false, errorMessage: formatLinxCliErrorMessage(errorMessage) };
+            }
+            showLinxAuthExpiredRecoveryNotice(target);
+            prepareLinxAuthExpiredRetry(target);
+            scheduleLinxCloudLogin(target, 'expired', options);
+            return { handled: true };
+        },
+    });
+}
+function isLinxAuthExpiredError(text) {
+    return isLinxCloudAuthExpiredMessage(text);
+}
+function eventHasLinxAuthExpiredError(event) {
+    if (!isRecord(event)) {
+        return false;
+    }
+    const message = isRecord(event.message) ? event.message : undefined;
+    const topLevelErrorMessage = typeof event.errorMessage === 'string' ? event.errorMessage : '';
+    const errorMessage = typeof message?.errorMessage === 'string' ? message.errorMessage : '';
+    const error = isRecord(event.error) ? event.error : undefined;
+    const nestedErrorMessage = typeof error?.errorMessage === 'string' ? error.errorMessage : '';
+    return isLinxAuthExpiredError(`${topLevelErrorMessage}\n${errorMessage}\n${nestedErrorMessage}`);
+}
+function normalizeLinxCliErrorEvent(event) {
+    if (typeof event === 'string') {
+        const normalized = formatLinxCliErrorMessage(event);
+        return normalized === event ? event : normalized;
+    }
+    if (Array.isArray(event)) {
+        let changed = false;
+        const next = event.map((item) => {
+            const normalized = normalizeLinxCliErrorEvent(item);
+            if (normalized !== item) {
+                changed = true;
+            }
+            return normalized;
+        });
+        return changed ? next : event;
+    }
+    if (!isRecord(event)) {
+        return event;
+    }
+    let changed = false;
+    const next = {};
+    for (const [key, value] of Object.entries(event)) {
+        const normalized = normalizeLinxCliErrorEvent(value);
+        next[key] = normalized;
+        if (normalized !== value) {
+            changed = true;
+        }
+    }
+    return changed ? { ...event, ...next } : event;
+}
+function showLinxAuthExpiredRecoveryNotice(interactive) {
+    showLinxInteractiveStatus(interactive, [
+        'LinX Cloud login expired.',
+        'Your message reached LinX, but the Cloud token was rejected.',
+        'Choose a sign-in method below, or run /login if the selector is not visible.',
+    ].join('\n'));
+}
+async function startLinxCloudLogin(interactive, loginOptions = {}, options = {}) {
+    const authState = getLinxInteractiveAuthState(interactive);
+    if (authState.loginInProgress) {
+        return;
+    }
+    authState.loginInProgress = true;
+    try {
+        const authStorage = getLinxInteractiveAuthStorage(interactive);
+        if (!authStorage) {
+            prefillLoginCommand(interactive);
+            return;
+        }
+        const reason = loginOptions.reason ?? 'manual';
+        const selected = await selectLinxAuthMethod(interactive, reason, options);
+        if (!selected) {
+            showLinxInteractiveStatus(interactive, 'LinX Cloud authorization cancelled.');
+            return;
+        }
+        if (selected === AUTH_OPTION_BROWSER) {
+            const loginAuthStorage = getLinxInteractiveLoginAuthStorage(interactive);
+            if (!loginAuthStorage) {
+                prefillLoginCommand(interactive);
+                return;
+            }
+            await runLinxCloudBrowserLogin(interactive, loginAuthStorage, reason);
+            await refreshLinxAuthState(interactive);
+            await finishLinxAuthSuccess(interactive, reason, 'Browser authorization complete.');
+            return;
+        }
+        if (selected === AUTH_OPTION_CLIENT_CREDENTIALS) {
+            await promptForLinxClientCredentials(interactive, reason, options);
+            return;
+        }
+        if (selected === AUTH_OPTION_EXIT) {
+            if (reason === 'startup') {
+                stopInteractiveShellUnlessRestarting(interactive);
+            }
+            else {
+                showLinxInteractiveStatus(interactive, 'LinX Cloud authorization cancelled.');
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reportLinxLoginError(interactive, message);
+    }
+    finally {
+        authState.loginInProgress = false;
+        options.onLoginSettled?.(interactive);
+    }
+}
+function scheduleLinxCloudLogin(interactive, reason, options) {
+    const authState = getLinxInteractiveAuthState(interactive);
+    if (authState.loginInProgress || authState.loginScheduled) {
+        return;
+    }
+    authState.loginScheduled = true;
+    setTimeout(() => {
+        getLinxInteractiveAuthState(interactive).loginScheduled = false;
+        void startLinxCloudLogin(interactive, { reason }, options);
+    }, 0);
+}
+function reportLinxLoginError(interactive, message) {
+    const authState = getLinxInteractiveAuthState(interactive);
+    const rendered = normalizeLinxLoginError(message);
+    if (authState.reportingError) {
+        showLinxInteractiveStatus(interactive, rendered);
+        return;
+    }
+    authState.reportingError = true;
+    try {
+        showLinxInteractiveError(interactive, rendered);
+    }
+    finally {
+        authState.reportingError = false;
+    }
+}
+function normalizeLinxLoginError(message) {
+    const oidcCallbackError = /^OIDC callback returned\b/i.test(message);
+    if (oidcCallbackError) {
+        return `LinX Cloud login failed: ${message}`;
+    }
+    if (/server_error/i.test(message)) {
+        return `LinX Cloud login failed: the identity server rejected this browser login. ${message}`;
+    }
+    return `LinX Cloud login failed: ${message}`;
+}
+async function selectLinxAuthMethod(interactive, reason, flowOptions) {
+    const title = buildLinxAuthPromptTitle(reason, resolveProviderLabel(interactive, flowOptions));
+    const options = [AUTH_OPTION_BROWSER, AUTH_OPTION_CLIENT_CREDENTIALS, AUTH_OPTION_EXIT];
+    if (canChooseLinxInteractiveExtensionSelectorOption(interactive)) {
+        const choice = await chooseLinxInteractiveExtensionSelectorOption(interactive, title, options);
+        return normalizeSelectorChoice(choice, options);
+    }
+    showLinxAuthFallback(interactive, title, options);
+    return undefined;
+}
+function buildLinxAuthPromptTitle(reason, providerLabel) {
+    if (reason === 'startup') {
+        return [
+            'LinX Cloud login required',
+            `Connect to ${providerLabel} before using LinX TUI.`,
+            'Choose a sign-in method.',
+        ].join('\n');
+    }
+    if (reason === 'expired') {
+        return [
+            'LinX Cloud login expired',
+            'Your current Solid token was rejected by LinX Cloud.',
+            'Re-authorize or enter Solid client credentials, then retry your message.',
+        ].join('\n');
+    }
+    return [
+        'LinX Cloud authorization',
+        `Choose how LinX should authenticate with ${providerLabel}.`,
+    ].join('\n');
+}
+function showLinxAuthFallback(interactive, title, options) {
+    appendLinxInteractiveChatText(interactive, [
+        `\x1b[1m${title}\x1b[22m`,
+        '',
+        ...options.map((option) => `- ${option}`),
+        '',
+        'This terminal build cannot render the LinX auth selector. Run `linx login` in another shell.',
+    ].join('\n'));
+}
+async function promptForLinxClientCredentials(interactive, reason, options) {
+    if (!canCollectLinxInteractiveExtensionInput(interactive)) {
+        showLinxInteractiveError(interactive, 'This terminal build cannot collect Solid client credentials inside the TUI.');
+        return;
+    }
+    const credentials = await collectLinxInteractiveExtensionInput(interactive, [
+        reason === 'expired' ? 'Enter Solid client credentials' : 'Use Solid client credentials',
+        'This is only for Solid/LinX identity. AI provider keys belong in `linx ai connect`.',
+        'Format: client_id:client_secret',
+        'Press Escape to cancel.',
+    ].join('\n'), 'client_id:client_secret');
+    const trimmed = typeof credentials === 'string' ? credentials.trim() : '';
+    if (!trimmed) {
+        showLinxInteractiveStatus(interactive, 'Solid client credentials entry cancelled.');
+        return;
+    }
+    const result = await resolveSolidClientCredentialsLogin(options)(trimmed);
+    const authStorage = getLinxInteractiveAuthStorage(interactive);
+    authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, LINX_RUNTIME_MANAGED_AUTH_KEY);
+    authStorage?.set?.(LINX_PROVIDER_ID, {
+        type: 'api_key',
+        key: LINX_RUNTIME_MANAGED_AUTH_KEY,
+        webId: result.webId,
+        podUrl: result.podUrl,
+    });
+    await refreshLinxAuthState(interactive);
+    await finishLinxAuthSuccess(interactive, reason, 'Solid client credentials saved to ~/.solid/auth.');
+}
+function resolveSolidClientCredentialsLogin(options) {
+    return options.persistSolidClientCredentialsLogin ?? persistSolidClientCredentialsLogin;
+}
+async function finishLinxAuthSuccess(interactive, reason, detail) {
+    const prefix = authStatusPrefix(reason);
+    const retryStarted = await retryPendingLinxAuthTurn(interactive, reason);
+    if (retryStarted) {
+        showLinxInteractiveStatus(interactive, `${prefix} ${detail} Retrying your message...`);
+        return;
+    }
+    const suffix = reason === 'expired' ? ' Retry your message.' : '';
+    showLinxInteractiveStatus(interactive, `${prefix} ${detail}${suffix}`);
+}
+function prepareLinxAuthExpiredRetry(interactive) {
+    const authState = getLinxInteractiveAuthState(interactive);
+    if (authState.pendingRetry) {
+        return;
+    }
+    const pending = captureLinxSessionRetryTurn({ interactive });
+    authState.pendingRetry = pending;
+    // AgentSession persists the assistant error after TUI subscribers run. Restore
+    // the active branch on the next tick so "continue" never resumes from the
+    // failed auth assistant message if the user cancels or login fails.
+    setTimeout(() => {
+        if (getLinxInteractiveAuthState(interactive).pendingRetry === pending) {
+            restoreLinxSessionHistoryBranch({ interactive }, pending.continueFromId);
+        }
+    }, 0);
+}
+function suppressLinxAuthExpiredAssistantError(interactive) {
+    clearLinxInteractiveStreamingMessage(interactive);
+}
+async function retryPendingLinxAuthTurn(interactive, reason) {
+    if (reason !== 'expired') {
+        return false;
+    }
+    const authState = getLinxInteractiveAuthState(interactive);
+    const pending = authState.pendingRetry;
+    if (!pending) {
+        return false;
+    }
+    authState.pendingRetry = undefined;
+    return retryLinxInteractiveSessionTurn(interactive, pending, {
+        onRetryFailed(error) {
+            const message = error instanceof Error ? error.message : String(error);
+            showLinxInteractiveError(interactive, `LinX Cloud retry failed: ${message}`);
+        },
+    });
+}
+export async function refreshLinxAuthState(interactive) {
+    clearLinxInteractiveRuntimeAuthPromptOnStart(interactive);
+    syncRuntimeCredential(interactive);
+    refreshLinxInteractiveModelRegistry(interactive);
+    await refreshLinxInteractiveProviderCount(interactive);
+    showLinxInteractiveStatus(interactive, null);
+}
+function authStatusPrefix(reason) {
+    if (reason === 'expired') {
+        return 'LinX Cloud login refreshed.';
+    }
+    if (reason === 'startup') {
+        return 'LinX Cloud connected.';
+    }
+    return 'LinX Cloud authorization updated.';
+}
+async function runLinxCloudLogin(interactive, authStorage, reason) {
+    await authStorage.login(LINX_PROVIDER_ID, {
+        forceFresh: true,
+        onAuth(info) {
+            showLinxLoginUrl(interactive, info);
+            openLoginUrl(info.url, interactive);
+            if (info.instructions) {
+                showLinxInteractiveStatus(interactive, info.instructions);
+            }
+        },
+        onProgress(message) {
+            showLinxInteractiveStatus(interactive, message);
+        },
+        onManualCodeInput(signal) {
+            return promptForLinxManualRedirectUrl(interactive, signal);
+        },
+    });
+}
+async function runLinxCloudBrowserLogin(interactive, authStorage, reason) {
+    if (canRenderLinxLoginDialog(interactive)) {
+        await runLinxCloudLoginDialog(interactive, authStorage, reason);
+        return;
+    }
+    await runLinxCloudLogin(interactive, authStorage, reason);
+}
+function canRenderLinxLoginDialog(interactive) {
+    return canMountLinxEditorComponent(interactive);
+}
+async function runLinxCloudLoginDialog(interactive, authStorage, reason) {
+    const dialog = createLinxLoginDialogComponent(interactive, LINX_PROVIDER_ID);
+    const restoreEditor = mountLinxEditorComponent(interactive, dialog);
+    let manualRedirectResolve;
+    let manualRedirectReject;
+    const manualRedirectPromise = new Promise((resolve, reject) => {
+        manualRedirectResolve = resolve;
+        manualRedirectReject = reject;
+    });
+    try {
+        await authStorage.login(LINX_PROVIDER_ID, {
+            forceFresh: true,
+            onAuth(info) {
+                dialog.showAuth(info.url, info.instructions);
+                dialog.showManualInput('Paste redirect URL below, or complete login in browser:')
+                    .then((value) => {
+                    if (value && manualRedirectResolve) {
+                        manualRedirectResolve(value);
+                        manualRedirectResolve = undefined;
+                        manualRedirectReject = undefined;
+                    }
+                })
+                    .catch((error) => {
+                    if (manualRedirectReject) {
+                        manualRedirectReject(error);
+                        manualRedirectResolve = undefined;
+                        manualRedirectReject = undefined;
+                    }
+                });
+            },
+            onProgress(message) {
+                dialog.showProgress(message);
+            },
+            onManualCodeInput(signal) {
+                return waitForLinxDialogManualRedirect(manualRedirectPromise, signal);
+            },
+            signal: dialog.signal,
+        });
+    }
+    finally {
+        restoreEditor();
+    }
+}
+function waitForLinxDialogManualRedirect(manualRedirectPromise, signal) {
+    if (!signal) {
+        return manualRedirectPromise;
+    }
+    if (signal.aborted) {
+        return Promise.resolve('');
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => resolve('');
+        signal.addEventListener('abort', onAbort, { once: true });
+        manualRedirectPromise
+            .then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        })
+            .catch((error) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+async function promptForLinxManualRedirectUrl(interactive, signal) {
+    if (!canCollectLinxInteractiveExtensionInput(interactive)) {
+        throw new Error('Manual redirect paste is not available in this terminal. Run `linx login` in another shell if the browser callback is blocked.');
+    }
+    const redirect = await collectLinxInteractiveExtensionInput(interactive, [
+        'Paste final redirect URL',
+        'If the browser cannot return to this terminal, paste the full callback URL below.',
+    ].join('\n'), 'http://127.0.0.1:PORT/auth/callback?code=...&state=...&iss=...', signal ? { signal } : undefined);
+    const trimmed = typeof redirect === 'string' ? redirect.trim() : '';
+    if (!trimmed) {
+        throw new Error('Login cancelled');
+    }
+    return trimmed;
+}
+function syncRuntimeCredential(interactive) {
+    const authStorage = getLinxInteractiveAuthStorage(interactive);
+    authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, LINX_RUNTIME_MANAGED_AUTH_KEY);
+}
+function showLinxLoginUrl(interactive, info) {
+    const lines = [
+        '\x1b[1mLinX Cloud authorization\x1b[22m',
+        'Complete consent in the browser, then return here.',
+        '',
+        `\x1b[36m${info.url}\x1b[39m`,
+    ];
+    if (info.instructions) {
+        lines.push('', `\x1b[2m${info.instructions}\x1b[22m`);
+    }
+    appendLinxInteractiveChatText(interactive, lines.join('\n'));
+}
+function openLoginUrl(url, interactive) {
+    openExternalUrl(url, interactive);
+}
+function prefillLoginCommand(interactive) {
+    setLinxInteractiveEditorText(interactive, '/login', { focus: true, render: true });
+}
+function resolveProviderLabel(interactive, options) {
+    return options.resolveProviderLabel?.(interactive) ?? resolveLinxInteractiveRuntimeProviderLabel(interactive);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
+}
+//# sourceMappingURL=linx-login-flow.js.map