@undefineds.co/linx 0.2.15 → 0.2.17

package/dist/lib/pi-adapter/branding.js

@@ -1,45 +1,24 @@
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { readFileSync } from 'node:fs';
 import { LINX_HOME_DIRNAME } from '@undefineds.co/models/client';
-import { keyHint, LoginDialogComponent, rawKeyHint } from '@mariozechner/pi-coding-agent';
+import { keyHint, rawKeyHint } from '@mariozechner/pi-coding-agent';
 import { Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@mariozechner/pi-tui';
 import { loadCredentials } from '../credentials-store.js';
 import { extractUsernameFromWebId, resolveProfileDisplayName } from '../profile-identity.js';
+import { LINX_CLI_VERSION } from '../../generated/version.js';
 export const LINX_AGENT_DIR = join(homedir(), LINX_HOME_DIRNAME, 'agent');
 export const LINX_UPDATE_PACKAGE_NAME = '@undefineds.co/linx';
 export const LINX_CHANGELOG_URL = 'https://github.com/undefineds-co/linx-cli/releases';
-export const LINX_CLI_VERSION = readLinxCliVersion();
-const LINX_AUTH_LOGIN_IN_PROGRESS = Symbol.for('linx.tui.authLoginInProgress');
-const LINX_AUTH_LOGIN_ON_INIT = Symbol.for('linx.tui.authLoginOnInit');
-const LINX_AUTH_LOGIN_SCHEDULED = Symbol.for('linx.tui.authLoginScheduled');
-const LINX_AUTH_REPORTING_ERROR = Symbol.for('linx.tui.authReportingError');
 const LINX_UPDATE_IN_PROGRESS = Symbol.for('linx.tui.updateInProgress');
-const LINX_PROVIDER_ID = 'undefineds';
-const AUTH_OPTION_BROWSER = 'Authorize in browser';
-const AUTH_OPTION_API_KEY = 'Enter API key';
-const AUTH_OPTION_EXIT = 'Exit';
-const UPDATE_OPTION_INSTALL = 'Install update and restart';
-const UPDATE_OPTION_CHANGELOG = 'Open changelog';
-const UPDATE_OPTION_LATER = 'Later';
+const LINX_UPDATE_RUNNER = Symbol.for('linx.tui.updateRunner');
 export function applyLinxInteractiveBranding(interactive) {
     patchTerminalTitle(interactive);
     patchVersionCheck(interactive);
     patchUpdateNotification(interactive);
-    patchNativeOAuthSelectors(interactive);
-    patchLoginCommand(interactive);
-    patchAuthExpiredSessionEvents(interactive);
-    patchAuthExpiredLoginPrompt(interactive);
+    patchUpdateCommand(interactive);
     patchHeader(interactive);
 }
-export function requestLinxCloudLogin(interactive, reason = 'manual') {
-    if (!interactive.isInitialized) {
-        interactive[LINX_AUTH_LOGIN_ON_INIT] = reason;
-        return;
-    }
-    void startLinxCloudLogin(interactive, { reason });
-}
 function patchTerminalTitle(interactive) {
     const original = interactive.updateTerminalTitle?.bind(interactive);
     interactive.updateTerminalTitle = function patchedUpdateTerminalTitle() {
@@ -64,7 +43,7 @@ function patchVersionCheck(interactive) {
             }
             const body = await response.json();
             const latest = typeof body.version === 'string' ? body.version.trim() : '';
-            if (!latest || !isVersionNewer(latest, LINX_CLI_VERSION)) {
+            if (!latest || !isNewerVersion(latest, LINX_CLI_VERSION)) {
                 return undefined;
             }
             return latest;
@@ -76,109 +55,45 @@ function patchVersionCheck(interactive) {
 }
 function patchUpdateNotification(interactive) {
     interactive.showNewVersionNotification = function patchedShowNewVersionNotification(newVersion) {
-        void showLinxUpdateSelector(this, newVersion);
+        const lines = [
+            '\x1b[1m\x1b[33mLinX Update Available\x1b[39m\x1b[22m',
+            `\x1b[2mNew version ${newVersion} is available. \x1b[22m\x1b[36mType /update to install now.\x1b[39m`,
+            `\x1b[2mManual install: \x1b[22m\x1b[36mnpm install -g ${LINX_UPDATE_PACKAGE_NAME}@latest\x1b[39m`,
+            `\x1b[2mChangelog: \x1b[22m\x1b[36m${LINX_CHANGELOG_URL}\x1b[39m`,
+        ];
+        this.chatContainer?.addChild?.(new Text(lines.join('\n'), 1, 0));
+        this.ui?.requestRender?.();
     };
 }
-async function showLinxUpdateSelector(interactive, newVersion) {
-    if (interactive[LINX_UPDATE_IN_PROGRESS]) {
-        return;
+function isNewerVersion(candidate, current) {
+    const candidateParts = parseSemverCore(candidate);
+    const currentParts = parseSemverCore(current);
+    if (!candidateParts || !currentParts) {
+        return candidate !== current;
     }
-    interactive[LINX_UPDATE_IN_PROGRESS] = true;
-    try {
-        const title = [
-            'LinX update available',
-            `Current ${LINX_CLI_VERSION} -> latest ${newVersion}`,
-            'Choose how to handle this update.',
-        ].join('\n');
-        const options = [UPDATE_OPTION_INSTALL, UPDATE_OPTION_CHANGELOG, UPDATE_OPTION_LATER];
-        const selected = typeof interactive.showExtensionSelector === 'function'
-            ? await interactive.showExtensionSelector(title, options)
-            : undefined;
-        if (selected === UPDATE_OPTION_INSTALL) {
-            await installLinxUpdateAndRestart(interactive, newVersion);
-            return;
-        }
-        if (selected === UPDATE_OPTION_CHANGELOG) {
-            openExternalUrl(LINX_CHANGELOG_URL, interactive);
-            interactive.showStatus?.(`Opened LinX changelog for ${newVersion}.`);
-            return;
+    for (let index = 0; index < 3; index += 1) {
+        if (candidateParts[index] > currentParts[index]) {
+            return true;
         }
-        if (!selected) {
-            showLinxUpdateFallback(interactive, newVersion);
-            return;
+        if (candidateParts[index] < currentParts[index]) {
+            return false;
         }
-        interactive.showStatus?.(`Skipped LinX ${newVersion} for now.`);
-    }
-    finally {
-        interactive[LINX_UPDATE_IN_PROGRESS] = false;
     }
+    return false;
 }
-async function installLinxUpdateAndRestart(interactive, newVersion) {
-    interactive.showStatus?.(`Installing LinX ${newVersion}...`);
-    interactive.ui?.requestRender?.();
-    try {
-        await runNpmInstallLatest();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showError?.(`LinX update failed: ${message}`);
-        return;
+function parseSemverCore(version) {
+    const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+    if (!match) {
+        return null;
     }
-    interactive.showStatus?.(`LinX ${newVersion} installed. Restarting...`);
-    interactive.ui?.requestRender?.();
-    restartCurrentProcess(interactive);
-}
-function runNpmInstallLatest() {
-    const npmCommand = process.env.npm_execpath || 'npm';
-    const args = ['install', '-g', `${LINX_UPDATE_PACKAGE_NAME}@latest`];
-    return new Promise((resolve, reject) => {
-        const child = spawn(npmCommand, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            shell: false,
-        });
-        let stderr = '';
-        child.stderr?.on('data', (chunk) => {
-            stderr += chunk.toString();
-        });
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(stderr.trim() || `npm install exited with code ${code ?? 'unknown'}`));
-        });
-    });
-}
-function restartCurrentProcess(interactive) {
-    const child = spawn(process.execPath, process.argv.slice(1), {
-        cwd: process.cwd(),
-        env: process.env,
-        stdio: 'inherit',
-        detached: false,
-    });
-    child.on('error', (error) => {
-        interactive.showError?.(`LinX restart failed: ${error.message}`);
-    });
-    interactive.stop?.();
-    setTimeout(() => process.exit(0), 50);
-}
-function showLinxUpdateFallback(interactive, newVersion) {
-    const lines = [
-        '\x1b[1m\x1b[33mLinX update available\x1b[39m\x1b[22m',
-        `\x1b[2mCurrent ${LINX_CLI_VERSION} -> latest ${newVersion}\x1b[22m`,
-        `\x1b[2mRun \x1b[22m\x1b[36mnpm install -g ${LINX_UPDATE_PACKAGE_NAME}@latest\x1b[39m\x1b[2m if this terminal cannot show the update selector.\x1b[22m`,
-        `\x1b[2mChangelog: \x1b[22m\x1b[36m${LINX_CHANGELOG_URL}\x1b[39m`,
-    ];
-    interactive.chatContainer?.addChild?.(new Text(lines.join('\n'), 1, 0));
-    interactive.ui?.requestRender?.();
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
-function patchLoginCommand(interactive) {
+function patchUpdateCommand(interactive) {
     const originalSetup = interactive.setupEditorSubmitHandler?.bind(interactive);
     if (typeof originalSetup !== 'function') {
         return;
     }
-    interactive.setupEditorSubmitHandler = function patchedLinxLoginSetupEditorSubmitHandler() {
+    interactive.setupEditorSubmitHandler = function patchedSetupEditorSubmitHandler() {
         originalSetup();
         const originalSubmit = this.defaultEditor?.onSubmit?.bind(this.defaultEditor);
         if (typeof originalSubmit !== 'function') {
@@ -186,426 +101,77 @@ function patchLoginCommand(interactive) {
         }
         this.defaultEditor.onSubmit = async (text) => {
             const command = text.trim();
-            if (command === '/login') {
+            if (command === '/update' || command === '/update linx') {
                 this.editor?.setText?.('');
-                await startLinxCloudLogin(this);
+                await runLinxUpdateFromTui(this);
                 return;
             }
             await originalSubmit(text);
         };
     };
 }
-function patchNativeOAuthSelectors(interactive) {
-    interactive.showOAuthSelector = async function patchedLinxOAuthSelector(mode = 'login') {
-        if (mode === 'logout') {
-            const authStorage = this.session?.modelRegistry?.authStorage;
-            authStorage?.logout?.(LINX_PROVIDER_ID);
-            authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, '');
-            await refreshLinxAuthState(this);
-            this.showStatus?.('Logged out of LinX Cloud.');
-            return;
-        }
-        await startLinxCloudLogin(this, { reason: 'manual' });
-    };
-    interactive.showLoginDialog = async function patchedLinxLoginDialog(providerId) {
-        if (!providerId || providerId === LINX_PROVIDER_ID) {
-            await startLinxCloudLogin(this, { reason: 'manual' });
-            return;
-        }
-        this.showStatus?.('LinX only supports LinX Cloud authentication in this TUI.');
-        await startLinxCloudLogin(this, { reason: 'manual' });
-    };
-}
-function patchAuthExpiredSessionEvents(interactive) {
-    const originalHandleEvent = interactive.handleEvent?.bind(interactive);
-    if (typeof originalHandleEvent !== 'function') {
-        return;
-    }
-    interactive.handleEvent = async function patchedHandleEvent(event) {
-        const result = await originalHandleEvent(event);
-        if (eventHasLinxAuthExpiredError(event)) {
-            scheduleLinxCloudLogin(this, 'expired');
-        }
-        return result;
-    };
-}
-function patchAuthExpiredLoginPrompt(interactive) {
-    const originalShowError = interactive.showError?.bind(interactive);
-    if (typeof originalShowError !== 'function') {
-        return;
-    }
-    interactive.showError = function patchedShowError(errorMessage) {
-        const text = typeof errorMessage === 'string' ? errorMessage : String(errorMessage);
-        if (!isLinxAuthExpiredError(text)) {
-            return originalShowError(errorMessage);
-        }
-        scheduleLinxCloudLogin(this, 'expired');
-        return undefined;
-    };
-}
-function isLinxAuthExpiredError(text) {
-    const normalized = stripAnsi(text).toLowerCase();
-    return normalized.includes('linx cloud login expired')
-        || normalized.includes('invalid solid token')
-        || (normalized.includes('chat request failed (401)') && normalized.includes('unauthorized'));
-}
-function eventHasLinxAuthExpiredError(event) {
-    if (!isRecord(event)) {
-        return false;
-    }
-    const message = isRecord(event.message) ? event.message : undefined;
-    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(`${errorMessage}\n${nestedErrorMessage}`);
-}
-async function startLinxCloudLogin(interactive, options = {}) {
-    if (interactive[LINX_AUTH_LOGIN_IN_PROGRESS]) {
+async function runLinxUpdateFromTui(interactive) {
+    if (interactive[LINX_UPDATE_IN_PROGRESS]) {
+        interactive.showStatus?.('LinX update is already running');
         return;
     }
-    interactive[LINX_AUTH_LOGIN_IN_PROGRESS] = true;
+    interactive[LINX_UPDATE_IN_PROGRESS] = true;
+    const packageSpec = `${LINX_UPDATE_PACKAGE_NAME}@latest`;
+    const npmCommand = process.env.npm_execpath && !process.env.npm_execpath.endsWith('npx-cli.js')
+        ? process.execPath
+        : 'npm';
+    const args = npmCommand === process.execPath
+        ? [process.env.npm_execpath, 'install', '-g', packageSpec]
+        : ['install', '-g', packageSpec];
     try {
-        const authStorage = interactive.session?.modelRegistry?.authStorage;
-        if (!authStorage) {
-            prefillLoginCommand(interactive);
-            return;
-        }
-        const reason = options.reason ?? 'manual';
-        const selected = await selectLinxAuthMethod(interactive, reason);
-        if (!selected) {
-            interactive.showStatus?.('LinX Cloud authorization cancelled.');
-            return;
-        }
-        if (selected === AUTH_OPTION_BROWSER) {
-            if (typeof authStorage.login !== 'function') {
-                prefillLoginCommand(interactive);
-                return;
-            }
-            await runLinxCloudBrowserLogin(interactive, authStorage, reason);
-            await refreshLinxAuthState(interactive);
-            interactive.showStatus?.(`${authStatusPrefix(reason)} Browser authorization complete. Retry your message.`);
-            return;
-        }
-        if (selected === AUTH_OPTION_API_KEY) {
-            await promptForLinxApiKey(interactive, reason);
+        interactive.showStatus?.(`Installing LinX update: ${packageSpec}`);
+        interactive.ui?.requestRender?.();
+        interactive.ui?.stop?.();
+        const runner = resolveUpdateRunner(interactive);
+        const result = await runner(npmCommand, args);
+        interactive.ui?.start?.();
+        if (result.exitCode === 0) {
+            interactive.showStatus?.('LinX updated. Restart linx to use the new version.');
             return;
         }
-        if (selected === AUTH_OPTION_EXIT) {
-            if (reason === 'startup') {
-                interactive.stop?.();
-            }
-            else {
-                interactive.showStatus?.('LinX Cloud authorization cancelled.');
-            }
-        }
+        const detail = result.signal ? `signal ${result.signal}` : `exit code ${result.exitCode}`;
+        interactive.showError?.(`LinX update failed with ${detail}`);
     }
     catch (error) {
+        interactive.ui?.start?.();
         const message = error instanceof Error ? error.message : String(error);
-        reportLinxLoginError(interactive, message);
-    }
-    finally {
-        interactive[LINX_AUTH_LOGIN_IN_PROGRESS] = false;
-    }
-}
-function scheduleLinxCloudLogin(interactive, reason) {
-    if (interactive[LINX_AUTH_LOGIN_IN_PROGRESS] || interactive[LINX_AUTH_LOGIN_SCHEDULED]) {
-        return;
-    }
-    interactive[LINX_AUTH_LOGIN_SCHEDULED] = true;
-    setTimeout(() => {
-        interactive[LINX_AUTH_LOGIN_SCHEDULED] = false;
-        void startLinxCloudLogin(interactive, { reason });
-    }, 0);
-}
-function reportLinxLoginError(interactive, message) {
-    const rendered = normalizeLinxLoginError(message);
-    if (interactive[LINX_AUTH_REPORTING_ERROR]) {
-        interactive.showStatus?.(rendered);
-        return;
-    }
-    interactive[LINX_AUTH_REPORTING_ERROR] = true;
-    try {
-        if (typeof interactive.showError === 'function') {
-            interactive.showError(rendered);
-        }
-        else {
-            interactive.showStatus?.(rendered);
-        }
+        interactive.showError?.(`LinX update failed: ${message}`);
     }
     finally {
-        interactive[LINX_AUTH_REPORTING_ERROR] = 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) {
-    const title = buildLinxAuthPromptTitle(reason, resolveRuntimeProviderLabel(interactive));
-    const options = [AUTH_OPTION_BROWSER, AUTH_OPTION_API_KEY, AUTH_OPTION_EXIT];
-    if (typeof interactive.showExtensionSelector === 'function') {
-        return await interactive.showExtensionSelector(title, 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 provide an API key, then retry your message.',
-        ].join('\n');
-    }
-    return [
-        'LinX Cloud authorization',
-        `Choose how LinX should authenticate with ${providerLabel}.`,
-    ].join('\n');
-}
-function showLinxAuthFallback(interactive, title, options) {
-    interactive.chatContainer?.addChild?.(new Text([
-        `\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'), 1, 0));
-    interactive.ui?.requestRender?.();
-}
-async function promptForLinxApiKey(interactive, reason) {
-    if (typeof interactive.showExtensionInput !== 'function') {
-        interactive.showError?.('This terminal build cannot collect an API key inside the TUI.');
-        return;
-    }
-    const apiKey = await interactive.showExtensionInput([
-        reason === 'expired' ? 'Enter LinX Cloud API key' : 'Use LinX Cloud API key',
-        'Paste a key for this TUI session. Press Escape to cancel.',
-    ].join('\n'), 'linx API key');
-    const trimmed = typeof apiKey === 'string' ? apiKey.trim() : '';
-    if (!trimmed) {
-        interactive.showStatus?.('LinX Cloud API key entry cancelled.');
-        return;
-    }
-    const authStorage = interactive.session?.modelRegistry?.authStorage;
-    authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, trimmed);
-    authStorage?.set?.(LINX_PROVIDER_ID, { type: 'api_key', key: trimmed });
-    await refreshLinxAuthState(interactive);
-    interactive.showStatus?.(`${authStatusPrefix(reason)} API key saved for this TUI session. Retry your message.`);
-}
-async function refreshLinxAuthState(interactive) {
-    interactive.session?.modelRegistry?.refresh?.();
-    await interactive.updateAvailableProviderCount?.();
-    interactive.ui?.requestRender?.();
-}
-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: reason === 'expired',
-        onAuth(info) {
-            showLinxLoginUrl(interactive, info);
-            openLoginUrl(info.url, interactive);
-            if (info.instructions) {
-                interactive.showStatus?.(info.instructions);
-            }
-        },
-        onProgress(message) {
-            interactive.showStatus?.(message);
-            interactive.ui?.requestRender?.();
-        },
-        onManualCodeInput(signal) {
-            return promptForLinxManualRedirectUrl(interactive, signal);
-        },
-    });
-    syncRuntimeCredential(interactive);
-}
-async function runLinxCloudBrowserLogin(interactive, authStorage, reason) {
-    if (canRenderLinxLoginDialog(interactive)) {
-        await runLinxCloudLoginDialog(interactive, authStorage, reason);
-        return;
-    }
-    await runLinxCloudLogin(interactive, authStorage, reason);
-}
-function canRenderLinxLoginDialog(interactive) {
-    return Boolean(interactive.ui
-        && typeof interactive.editorContainer?.clear === 'function'
-        && typeof interactive.editorContainer?.addChild === 'function'
-        && interactive.editor);
-}
-async function runLinxCloudLoginDialog(interactive, authStorage, reason) {
-    const dialog = new LoginDialogComponent(interactive.ui, LINX_PROVIDER_ID, () => undefined);
-    const restoreEditor = () => {
-        interactive.editorContainer.clear();
-        interactive.editorContainer.addChild(interactive.editor);
-        interactive.ui?.setFocus?.(interactive.editor);
+        interactive[LINX_UPDATE_IN_PROGRESS] = false;
         interactive.ui?.requestRender?.();
-    };
-    interactive.editorContainer.clear();
-    interactive.editorContainer.addChild(dialog);
-    interactive.ui?.setFocus?.(dialog);
-    interactive.ui?.requestRender?.();
-    let manualRedirectResolve;
-    let manualRedirectReject;
-    const manualRedirectPromise = new Promise((resolve, reject) => {
-        manualRedirectResolve = resolve;
-        manualRedirectReject = reject;
-    });
-    try {
-        await authStorage.login(LINX_PROVIDER_ID, {
-            forceFresh: reason === 'expired',
-            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,
-        });
-        syncRuntimeCredential(interactive);
-    }
-    finally {
-        restoreEditor();
     }
 }
-function waitForLinxDialogManualRedirect(manualRedirectPromise, signal) {
-    if (!signal) {
-        return manualRedirectPromise;
-    }
-    if (signal.aborted) {
-        return Promise.resolve('');
-    }
+function resolveUpdateRunner(interactive) {
+    return typeof interactive[LINX_UPDATE_RUNNER] === 'function'
+        ? interactive[LINX_UPDATE_RUNNER]
+        : spawnInstall;
+}
+function spawnInstall(command, args) {
     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);
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
         });
+        child.once('error', reject);
+        child.once('close', (exitCode, signal) => resolve({ exitCode, signal }));
     });
 }
-async function promptForLinxManualRedirectUrl(interactive, signal) {
-    if (typeof interactive.showExtensionInput !== 'function') {
-        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 interactive.showExtensionInput([
-        '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 = interactive.session?.modelRegistry?.authStorage;
-    const credential = authStorage?.get?.(LINX_PROVIDER_ID);
-    if (credential?.type === 'oauth' && typeof credential.access === 'string' && credential.access) {
-        authStorage.setRuntimeApiKey?.(LINX_PROVIDER_ID, credential.access);
-        return;
-    }
-    if (credential?.type === 'api_key' && typeof credential.key === 'string' && credential.key) {
-        authStorage.setRuntimeApiKey?.(LINX_PROVIDER_ID, credential.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`);
-    }
-    interactive.chatContainer?.addChild?.(new Text(lines.join('\n'), 1, 0));
-    interactive.ui?.requestRender?.();
-}
-function openLoginUrl(url, interactive) {
-    openExternalUrl(url, interactive);
-}
-function openExternalUrl(url, interactive) {
-    if (typeof interactive.openExternal === 'function') {
-        interactive.openExternal(url);
-        return;
-    }
-    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
-    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-    const child = spawn(command, args, {
-        detached: true,
-        stdio: 'ignore',
-        shell: false,
-    });
-    child.unref();
-}
-function prefillLoginCommand(interactive) {
-    interactive.editor?.setText?.('/login');
-    interactive.ui?.setFocus?.(interactive.editor);
-    interactive.ui?.requestRender?.();
-}
 function patchHeader(interactive) {
-    const originalInit = interactive.init?.bind(interactive);
-    if (typeof originalInit !== 'function') {
-        return;
-    }
+    const originalInit = interactive.init.bind(interactive);
     interactive.init = async function patchedInit() {
         await originalInit();
-        if (this[LINX_AUTH_LOGIN_ON_INIT]) {
-            const reason = typeof this[LINX_AUTH_LOGIN_ON_INIT] === 'string'
-                ? this[LINX_AUTH_LOGIN_ON_INIT]
-                : 'startup';
-            this[LINX_AUTH_LOGIN_ON_INIT] = false;
-            queueMicrotask(() => startLinxCloudLogin(this, { reason }));
-        }
         const quietStartup = this.options?.verbose ? false : this.settingsManager?.getQuietStartup?.();
         if (quietStartup) {
             return;
         }
         let profileDisplayName = null;
-        const replacement = new LinxWelcomeCard(() => buildLinxWelcomeCardState(this, profileDisplayName));
+        const replacement = new LinxWelcomeCard(() => buildHeaderState(this, profileDisplayName));
         const currentHeader = this.customHeader ?? this.builtInHeader;
         const index = this.headerContainer?.children?.indexOf?.(currentHeader) ?? -1;
         if (index >= 0) {
@@ -661,13 +227,13 @@ class LinxWelcomeCard {
         ];
     }
 }
-export function buildLinxWelcomeCardState(interactive, profileDisplayName = null) {
+function buildHeaderState(interactive, profileDisplayName = null) {
     const credentials = loadCredentials();
     const webId = credentials?.webId ?? 'not logged in';
     const workspace = interactive?.sessionManager?.getCwd?.() || process.cwd();
     const sessionId = interactive?.sessionManager?.getSessionId?.();
     const sessionName = interactive?.sessionManager?.getSessionName?.();
-    const session = sessionName && sessionId ? `${sessionName} (${formatSessionId(sessionId)})` : formatSessionId(sessionId);
+    const session = sessionName && sessionId ? `${sessionName} (${shortSessionId(sessionId)})` : shortSessionId(sessionId);
     const model = interactive?.session?.model?.id ?? 'unknown-model';
     return {
         webId,
@@ -680,7 +246,7 @@ export function buildLinxWelcomeCardState(interactive, profileDisplayName = null
             keyHint('tui.input.submit', 'send'),
             keyHint('app.model.select', 'model'),
             rawKeyHint('/login', 'auth'),
-            rawKeyHint('/hotkeys', 'keymap'),
+            rawKeyHint('/help', 'help'),
         ].join(' \x1b[2m·\x1b[22m '),
     };
 }
@@ -698,11 +264,11 @@ function wrapAndPad(line, width) {
         ? wrapped.map((entry) => padLine(entry, width))
         : [padLine('', width)];
 }
-function formatSessionId(sessionId) {
+function shortSessionId(sessionId) {
     if (typeof sessionId !== 'string' || !sessionId.trim()) {
         return 'new session';
     }
-    return sessionId.trim();
+    return sessionId.length > 12 ? sessionId.slice(0, 12) : sessionId;
 }
 function padLine(line, width) {
     const visible = visibleWidth(line);
@@ -711,44 +277,6 @@ function padLine(line, width) {
     }
     return `${line}${' '.repeat(width - visible)}`;
 }
-function readLinxCliVersion() {
-    try {
-        const raw = readFileSync(new URL('../../../package.json', import.meta.url), 'utf-8');
-        const pkg = JSON.parse(raw);
-        return typeof pkg.version === 'string' && pkg.version.trim() ? pkg.version.trim() : '0.1.0';
-    }
-    catch {
-        return '0.1.0';
-    }
-}
-export function isVersionNewer(candidate, current) {
-    const candidateVersion = parseSemverLike(candidate);
-    const currentVersion = parseSemverLike(current);
-    if (!candidateVersion || !currentVersion) {
-        return candidate !== current;
-    }
-    for (const key of ['major', 'minor', 'patch']) {
-        if (candidateVersion[key] > currentVersion[key]) {
-            return true;
-        }
-        if (candidateVersion[key] < currentVersion[key]) {
-            return false;
-        }
-    }
-    return !candidateVersion.prerelease && currentVersion.prerelease;
-}
-function parseSemverLike(version) {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.+)?$/.exec(version.trim());
-    if (!match) {
-        return null;
-    }
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-        prerelease: Boolean(match[4]),
-    };
-}
 function resolveRuntimeProviderLabel(interactive) {
     const bridge = interactive?.runtimeHost?.linxAuthBridge ?? interactive?.linxAuthBridge;
     if (bridge?.providerLabel) {
@@ -799,10 +327,4 @@ function stripPodStatusLines(input) {
         .replace(new RegExp(String.raw `Using WebID:\s*${urlPattern}[ \t]*(?:\r?\n)?`, 'g'), '')
         .replace(/Successfully connected to Solid Pod[ \t]*(?:\r?\n)?/g, '');
 }
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function stripAnsi(text) {
-    return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
-}
 //# sourceMappingURL=branding.js.map