@undefineds.co/linx 0.3.5 → 0.3.8

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

@@ -1,16 +1,19 @@
 import { spawn } from 'node:child_process';
-import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
+import { basename } 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 { Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@mariozechner/pi-tui';
+import { keyHint, LoginDialogComponent, rawKeyHint } from '@earendil-works/pi-coding-agent';
+import { Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
 import { clearAccountSession } from '../account-session.js';
 import { clearCredentials, loadCredentials } from '../credentials-store.js';
 import { clearOidcSessionStorage } from '../oidc-session-storage.js';
+import { persistSolidClientCredentialsLogin } from '../solid-client-credentials-login.js';
 import { extractUsernameFromWebId, resolveProfileDisplayName } from '../profile-identity.js';
 import { LINX_TUI_KEYMAP_COMMAND, LINX_TUI_KEYMAP_LABEL, LINX_TUI_LOGIN_COMMAND } from '../linx-tui-contract.js';
-export const LINX_AGENT_DIR = join(homedir(), LINX_HOME_DIRNAME, 'agent');
+import { suppressPodStatusOutput } from './pod-status-output.js';
+import { LINX_RUNTIME_MANAGED_AUTH_KEY } from './runtime.js';
+import { formatLinxCliErrorMessage } from '../linx-cloud-errors.js';
+import { getSolidLinxAgentDir } from '../solid-local-store.js';
+export const LINX_AGENT_DIR = getSolidLinxAgentDir();
 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();
@@ -20,9 +23,11 @@ const LINX_AUTH_PENDING_RETRY = Symbol.for('linx.tui.authPendingRetry');
 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_UPDATE_CHECK_SCHEDULED = Symbol.for('linx.tui.updateCheckScheduled');
+const LINX_SUPPRESS_UPSTREAM_PI_UPDATE = Symbol.for('linx.tui.suppressUpstreamPiUpdate');
 const LINX_PROVIDER_ID = 'undefineds';
 const AUTH_OPTION_BROWSER = 'Authorize in browser';
-const AUTH_OPTION_API_KEY = 'Enter API key';
+const AUTH_OPTION_CLIENT_CREDENTIALS = 'Enter Solid client credentials';
 const AUTH_OPTION_EXIT = 'Exit';
 const UPDATE_OPTION_INSTALL = 'Install update and restart';
 const UPDATE_OPTION_CHANGELOG = 'Open changelog';
@@ -55,34 +60,77 @@ function patchTerminalTitle(interactive) {
     };
 }
 function patchVersionCheck(interactive) {
+    const originalRun = interactive.run?.bind(interactive);
+    if (typeof originalRun === 'function') {
+        interactive.run = async function patchedLinxRun(...args) {
+            this[LINX_SUPPRESS_UPSTREAM_PI_UPDATE] = true;
+            return originalRun(...args);
+        };
+    }
+    const originalInit = interactive.init?.bind(interactive);
+    if (typeof originalInit === 'function') {
+        interactive.init = async function patchedLinxVersionInit(...args) {
+            await originalInit(...args);
+            scheduleLinxVersionCheck(this);
+        };
+    }
     interactive.checkForNewVersion = async function patchedCheckForNewVersion() {
-        if (process.env.PI_OFFLINE) {
-            return undefined;
-        }
-        try {
-            const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(LINX_UPDATE_PACKAGE_NAME)}/latest`, {
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!response.ok) {
-                return undefined;
-            }
-            const body = await response.json();
-            const latest = typeof body.version === 'string' ? body.version.trim() : '';
-            if (!latest || !isVersionNewer(latest, LINX_CLI_VERSION)) {
-                return undefined;
-            }
-            return latest;
-        }
-        catch {
-            return undefined;
-        }
+        return checkForNewLinxVersion();
     };
 }
 function patchUpdateNotification(interactive) {
     interactive.showNewVersionNotification = function patchedShowNewVersionNotification(newVersion) {
-        void showLinxUpdateSelector(this, newVersion);
+        if (this[LINX_SUPPRESS_UPSTREAM_PI_UPDATE]) {
+            return;
+        }
+        if (shouldDeferLinxUpdateNotification(this)) {
+            return;
+        }
+        const normalizedVersion = normalizeLinxUpdateVersion(newVersion);
+        if (!normalizedVersion) {
+            return;
+        }
+        void showLinxUpdateSelector(this, normalizedVersion);
     };
 }
+function scheduleLinxVersionCheck(interactive) {
+    if (interactive[LINX_UPDATE_CHECK_SCHEDULED]) {
+        return;
+    }
+    interactive[LINX_UPDATE_CHECK_SCHEDULED] = true;
+    queueMicrotask(() => {
+        void checkForNewLinxVersion()
+            .then((latest) => {
+            if (!latest || shouldDeferLinxUpdateNotification(interactive)) {
+                return;
+            }
+            void showLinxUpdateSelector(interactive, latest);
+        })
+            .catch(() => undefined);
+    });
+}
+async function checkForNewLinxVersion() {
+    if (process.env.PI_OFFLINE) {
+        return undefined;
+    }
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(LINX_UPDATE_PACKAGE_NAME)}/latest`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            return undefined;
+        }
+        const body = await response.json();
+        const latest = typeof body.version === 'string' ? body.version.trim() : '';
+        if (!latest || !isVersionNewer(latest, LINX_CLI_VERSION)) {
+            return undefined;
+        }
+        return latest;
+    }
+    catch {
+        return undefined;
+    }
+}
 async function showLinxUpdateSelector(interactive, newVersion) {
     if (interactive[LINX_UPDATE_IN_PROGRESS]) {
         return;
@@ -94,10 +142,11 @@ async function showLinxUpdateSelector(interactive, newVersion) {
             `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'
+        const options = [UPDATE_OPTION_LATER, UPDATE_OPTION_INSTALL, UPDATE_OPTION_CHANGELOG];
+        const rawSelected = typeof interactive.showExtensionSelector === 'function'
             ? await interactive.showExtensionSelector(title, options)
             : undefined;
+        const selected = normalizeSelectorChoice(rawSelected, options);
         if (selected === UPDATE_OPTION_INSTALL) {
             await installLinxUpdateAndRestart(interactive, newVersion);
             return;
@@ -117,6 +166,28 @@ async function showLinxUpdateSelector(interactive, newVersion) {
         interactive[LINX_UPDATE_IN_PROGRESS] = false;
     }
 }
+function shouldDeferLinxUpdateNotification(interactive) {
+    return Boolean(interactive[LINX_AUTH_LOGIN_IN_PROGRESS]
+        || interactive[LINX_AUTH_LOGIN_ON_INIT]
+        || interactive[LINX_AUTH_PENDING_RETRY]
+        || interactive[LINX_AUTH_LOGIN_SCHEDULED]);
+}
+function normalizeLinxUpdateVersion(value) {
+    const direct = normalizeNonEmptyString(value);
+    if (direct) {
+        return direct;
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    for (const key of ['version', 'latest', 'latestVersion', 'packageVersion', 'newVersion']) {
+        const nested = normalizeNonEmptyString(value[key]);
+        if (nested) {
+            return nested;
+        }
+    }
+    return undefined;
+}
 async function installLinxUpdateAndRestart(interactive, newVersion) {
     interactive.showStatus?.(`Installing LinX ${newVersion}...`);
     interactive.ui?.requestRender?.();
@@ -229,13 +300,15 @@ function patchAuthExpiredSessionEvents(interactive) {
         return;
     }
     interactive.handleEvent = async function patchedHandleEvent(event) {
-        if (eventHasLinxAuthExpiredError(event)) {
+        const normalizedEvent = normalizeLinxCliErrorEvent(event);
+        if (eventHasLinxAuthExpiredError(normalizedEvent)) {
+            showLinxAuthExpiredRecoveryNotice(this);
             prepareLinxAuthExpiredRetry(this);
             suppressLinxAuthExpiredAssistantError(this);
             scheduleLinxCloudLogin(this, 'expired');
             return undefined;
         }
-        const result = await originalHandleEvent(event);
+        const result = await originalHandleEvent(normalizedEvent);
         return result;
     };
 }
@@ -246,9 +319,11 @@ function patchAuthExpiredLoginPrompt(interactive) {
     }
     interactive.showError = function patchedShowError(errorMessage) {
         const text = typeof errorMessage === 'string' ? errorMessage : String(errorMessage);
-        if (!isLinxAuthExpiredError(text)) {
-            return originalShowError(errorMessage);
+        if (this[LINX_AUTH_REPORTING_ERROR] || !isLinxAuthExpiredError(text)) {
+            return originalShowError(formatLinxCliErrorMessage(errorMessage));
         }
+        showLinxAuthExpiredRecoveryNotice(this);
+        prepareLinxAuthExpiredRetry(this);
         scheduleLinxCloudLogin(this, 'expired');
         return undefined;
     };
@@ -264,10 +339,49 @@ function eventHasLinxAuthExpiredError(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(`${errorMessage}\n${nestedErrorMessage}`);
+    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) {
+    interactive.showStatus?.([
+        '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'));
+    interactive.ui?.requestRender?.();
 }
 async function startLinxCloudLogin(interactive, options = {}) {
     if (interactive[LINX_AUTH_LOGIN_IN_PROGRESS]) {
@@ -296,8 +410,8 @@ async function startLinxCloudLogin(interactive, options = {}) {
             await finishLinxAuthSuccess(interactive, reason, 'Browser authorization complete.');
             return;
         }
-        if (selected === AUTH_OPTION_API_KEY) {
-            await promptForLinxApiKey(interactive, reason);
+        if (selected === AUTH_OPTION_CLIENT_CREDENTIALS) {
+            await promptForLinxClientCredentials(interactive, reason);
             return;
         }
         if (selected === AUTH_OPTION_EXIT) {
@@ -358,13 +472,37 @@ function normalizeLinxLoginError(message) {
 }
 async function selectLinxAuthMethod(interactive, reason) {
     const title = buildLinxAuthPromptTitle(reason, resolveRuntimeProviderLabel(interactive));
-    const options = [AUTH_OPTION_BROWSER, AUTH_OPTION_API_KEY, AUTH_OPTION_EXIT];
+    const options = [AUTH_OPTION_BROWSER, AUTH_OPTION_CLIENT_CREDENTIALS, AUTH_OPTION_EXIT];
     if (typeof interactive.showExtensionSelector === 'function') {
-        return await interactive.showExtensionSelector(title, options);
+        return normalizeSelectorChoice(await interactive.showExtensionSelector(title, options), options);
     }
     showLinxAuthFallback(interactive, title, options);
     return undefined;
 }
+function normalizeSelectorChoice(value, options) {
+    const direct = matchSelectorChoice(value, options);
+    if (direct) {
+        return direct;
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    for (const key of ['value', 'label', 'title', 'name', 'display', 'text', 'option', 'id']) {
+        const match = matchSelectorChoice(value[key], options);
+        if (match) {
+            return match;
+        }
+    }
+    return undefined;
+}
+function matchSelectorChoice(value, options) {
+    const normalized = normalizeNonEmptyString(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return options.find((option) => option === normalized)
+        ?? options.find((option) => stripAnsi(option).trim() === stripAnsi(normalized).trim());
+}
 function buildLinxAuthPromptTitle(reason, providerLabel) {
     if (reason === 'startup') {
         return [
@@ -377,7 +515,7 @@ function buildLinxAuthPromptTitle(reason, providerLabel) {
         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.',
+            'Re-authorize or enter Solid client credentials, then retry your message.',
         ].join('\n');
     }
     return [
@@ -395,25 +533,37 @@ function showLinxAuthFallback(interactive, title, options) {
     ].join('\n'), 1, 0));
     interactive.ui?.requestRender?.();
 }
-async function promptForLinxApiKey(interactive, reason) {
+async function promptForLinxClientCredentials(interactive, reason) {
     if (typeof interactive.showExtensionInput !== 'function') {
-        interactive.showError?.('This terminal build cannot collect an API key inside the TUI.');
+        interactive.showError?.('This terminal build cannot collect Solid client credentials 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() : '';
+    const credentials = await interactive.showExtensionInput([
+        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) {
-        interactive.showStatus?.('LinX Cloud API key entry cancelled.');
+        interactive.showStatus?.('Solid client credentials entry cancelled.');
         return;
     }
+    const result = await resolveSolidClientCredentialsLogin(interactive)(trimmed);
     const authStorage = interactive.session?.modelRegistry?.authStorage;
-    authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, trimmed);
-    authStorage?.set?.(LINX_PROVIDER_ID, { type: 'api_key', key: trimmed });
+    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, 'API key saved for this TUI session.');
+    await finishLinxAuthSuccess(interactive, reason, 'Solid client credentials saved to ~/.solid/auth.');
+}
+function resolveSolidClientCredentialsLogin(interactive) {
+    const override = interactive?.__linxPersistSolidClientCredentialsLogin ?? interactive?.__linxPersistSolidSecretLogin;
+    return typeof override === 'function' ? override : persistSolidClientCredentialsLogin;
 }
 async function finishLinxAuthSuccess(interactive, reason, detail) {
     const prefix = authStatusPrefix(reason);
@@ -619,10 +769,13 @@ function extractUserMessageText(message) {
     return text || undefined;
 }
 async function refreshLinxAuthState(interactive) {
+    clearLinxAuthPromptOnStart(interactive);
+    syncRuntimeCredential(interactive);
     interactive.session?.modelRegistry?.refresh?.();
     await interactive.updateAvailableProviderCount?.();
     interactive.ui?.requestRender?.();
 }
+export const __testRefreshLinxAuthState = refreshLinxAuthState;
 function authStatusPrefix(reason) {
     if (reason === 'expired') {
         return 'LinX Cloud login refreshed.';
@@ -650,7 +803,6 @@ async function runLinxCloudLogin(interactive, authStorage, reason) {
             return promptForLinxManualRedirectUrl(interactive, signal);
         },
     });
-    syncRuntimeCredential(interactive);
 }
 async function runLinxCloudBrowserLogin(interactive, authStorage, reason) {
     if (canRenderLinxLoginDialog(interactive)) {
@@ -712,7 +864,6 @@ async function runLinxCloudLoginDialog(interactive, authStorage, reason) {
             },
             signal: dialog.signal,
         });
-        syncRuntimeCredential(interactive);
     }
     finally {
         restoreEditor();
@@ -755,13 +906,20 @@ async function promptForLinxManualRedirectUrl(interactive, signal) {
 }
 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);
+    authStorage?.setRuntimeApiKey?.(LINX_PROVIDER_ID, LINX_RUNTIME_MANAGED_AUTH_KEY);
+}
+function clearLinxAuthPromptOnStart(interactive) {
+    const candidates = [
+        interactive,
+        interactive?.runtimeHost,
+        interactive?.runtime,
+        interactive?.session,
+    ];
+    for (const candidate of candidates) {
+        const bridge = candidate?.linxAuthBridge;
+        if (bridge && typeof bridge === 'object') {
+            bridge.shouldPromptLoginOnStart = false;
+        }
     }
 }
 function showLinxLoginUrl(interactive, info) {
@@ -890,13 +1048,29 @@ export function buildLinxWelcomeCardState(interactive, profileDisplayName = null
         workspace,
         session,
         next: [
-            keyHint('tui.input.submit', 'send'),
-            keyHint('app.model.select', 'model'),
-            rawKeyHint(LINX_TUI_LOGIN_COMMAND, 'auth'),
-            rawKeyHint(LINX_TUI_KEYMAP_COMMAND, LINX_TUI_KEYMAP_LABEL),
+            safeKeyHint('tui.input.submit', 'send'),
+            safeKeyHint('app.model.select', 'model'),
+            safeRawKeyHint(LINX_TUI_LOGIN_COMMAND, 'auth'),
+            safeRawKeyHint(LINX_TUI_KEYMAP_COMMAND, LINX_TUI_KEYMAP_LABEL),
         ].join(' \x1b[2m·\x1b[22m '),
     };
 }
+function safeKeyHint(keybinding, description) {
+    try {
+        return keyHint(keybinding, description);
+    }
+    catch {
+        return `\x1b[2m${keybinding}\x1b[22m \x1b[2m${description}\x1b[22m`;
+    }
+}
+function safeRawKeyHint(key, description) {
+    try {
+        return rawKeyHint(key, description);
+    }
+    catch {
+        return `\x1b[2m${key}\x1b[22m \x1b[2m${description}\x1b[22m`;
+    }
+}
 function renderField(label, value, width) {
     const prefix = `\x1b[2m${label}\x1b[22m`;
     const paddedPrefix = prefix + ' '.repeat(Math.max(1, 10 - visibleWidth(prefix)));
@@ -967,54 +1141,18 @@ function resolveRuntimeProviderLabel(interactive) {
     if (bridge?.providerLabel) {
         return bridge.providerLabel;
     }
-    return 'undefineds';
-}
-async function suppressPodStatusOutput(operation) {
-    if (process.env.LINX_TUI_SHOW_POD_STATUS === '1') {
-        return await operation();
-    }
-    const restoreStdout = patchPodStatusWriter(process.stdout);
-    const restoreStderr = patchPodStatusWriter(process.stderr);
-    try {
-        return await operation();
-    }
-    finally {
-        restoreStdout();
-        restoreStderr();
-    }
-}
-function patchPodStatusWriter(stream) {
-    const originalWrite = stream.write.bind(stream);
-    stream.write = function patchedWrite(chunk, encodingOrCallback, callback) {
-        const encoding = typeof encodingOrCallback === 'string' ? encodingOrCallback : undefined;
-        const onComplete = typeof encodingOrCallback === 'function' ? encodingOrCallback : callback;
-        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString(encoding);
-        const filtered = stripPodStatusLines(text);
-        if (!filtered) {
-            onComplete?.();
-            return true;
-        }
-        if (typeof chunk === 'string') {
-            return originalWrite(filtered, encodingOrCallback, callback);
-        }
-        return originalWrite(Buffer.from(filtered, encoding), callback);
-    };
-    return () => {
-        ;
-        stream.write = originalWrite;
-    };
-}
-function stripPodStatusLines(input) {
-    const urlPattern = String.raw `https?:\/\/[A-Za-z0-9._~:/?#[\]@!$&'()*+,;=%-]+`;
-    return input
-        .replace(new RegExp(String.raw `\[Container\]\s*容器已存在:\s*${urlPattern}[ \t]*(?:\r?\n)?`, 'g'), '')
-        .replace(new RegExp(String.raw `Connecting to Solid Pod:\s*${urlPattern}[ \t]*(?:\r?\n)?`, 'g'), '')
-        .replace(new RegExp(String.raw `Using WebID:\s*${urlPattern}[ \t]*(?:\r?\n)?`, 'g'), '')
-        .replace(/Successfully connected to Solid Pod[ \t]*(?:\r?\n)?/g, '');
+    return 'LinX Cloud';
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function normalizeNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized || undefined;
+}
 function stripAnsi(text) {
     return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
 }