codexmate 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
-{
+{
   "name": "codexmate",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Codex/Claude Code 配置与会话管理 CLI + Web 工具",
   "main": "cli.js",
   "bin": {

package/web-ui/app.js

@@ -12,7 +12,9 @@
     normalizeSessionPathFilter,
     buildSessionFilterCacheState,
     buildSessionTimelineNodes,
-    normalizeSessionMessageRole
+    normalizeSessionMessageRole,
+    runLatestOnlyQueue,
+    shouldForceCompactLayoutMode
 } from './logic.mjs';
 import {
     CONFIG_MODE_SET,
@@ -170,6 +172,8 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     claudeSpeedLoading: {},
                     claudeShareLoading: {},
                     providerShareLoading: {},
+                    providerSwitchInProgress: false,
+                    pendingProviderSwitch: '',
                     installPackageManager: 'npm',
                     installCommandAction: 'install',
                     installRegistryPreset: 'default',
@@ -291,11 +295,13 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     proxyStarting: false,
                     proxyStopping: false,
                     proxyApplying: false,
-                    showProxyAdvanced: false
+                    showProxyAdvanced: false,
+                    forceCompactLayout: false
                 }
             },
             mounted() {
                 this.initSessionStandalone();
+                this.updateCompactLayoutMode();
                 const savedSessionYolo = localStorage.getItem('codexmateSessionResumeYolo');
                 if (savedSessionYolo === '0' || savedSessionYolo === 'false') {
                     this.sessionResumeWithYolo = false;
@@ -343,6 +349,7 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                 this.cancelSessionTimelineSync();
                 this.disconnectSessionPreviewHeaderResizeObserver();
                 window.removeEventListener('resize', this.onWindowResize);
+                this.applyCompactLayoutClass(false);
                 this.sessionPreviewScrollEl = null;
                 this.sessionPreviewContainerEl = null;
                 this.sessionPreviewHeaderEl = null;
@@ -542,7 +549,8 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     }
                 },
 
-                async loadModelsForProvider(providerName) {
+                async loadModelsForProvider(providerName, options = {}) {
+                    const silentError = !!options.silentError;
                     this.codexModelsLoading = true;
                     if (!providerName) {
                         this.models = [];
@@ -560,7 +568,9 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                             return;
                         }
                         if (res.error) {
-                            this.showMessage('获取模型列表失败', 'error');
+                            if (!silentError) {
+                                this.showMessage('获取模型列表失败', 'error');
+                            }
                             this.models = [];
                             this.modelsSource = 'error';
                             this.modelsHasCurrent = true;
@@ -571,7 +581,9 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                         this.modelsSource = res.source || 'remote';
                         this.modelsHasCurrent = !!this.currentModel && list.includes(this.currentModel);
                     } catch (e) {
-                        this.showMessage('获取模型列表失败', 'error');
+                        if (!silentError) {
+                            this.showMessage('获取模型列表失败', 'error');
+                        }
                         this.models = [];
                         this.modelsSource = 'error';
                         this.modelsHasCurrent = true;
@@ -603,15 +615,58 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     return findDuplicateClaudeConfigName(this.claudeConfigs, config);
                 },
 
-                async refreshClaudeSelectionFromSettings(options = {}) {
-                    const configNames = Object.keys(this.claudeConfigs || {});
-                    if (configNames.length === 0) {
-                        this.currentClaudeConfig = '';
-                        this.currentClaudeModel = '';
-                        this.resetClaudeModelsState();
-                        return;
+                mergeClaudeConfig(existing = {}, updates = {}) {
+                    const previous = this.normalizeClaudeConfig(existing);
+                    const next = this.normalizeClaudeConfig({ ...existing, ...updates });
+                    const externalCredentialType = next.apiKey
+                        ? ''
+                        : (next.externalCredentialType || previous.externalCredentialType || '');
+                    return {
+                        apiKey: next.apiKey,
+                        baseUrl: next.baseUrl,
+                        model: next.model || previous.model || 'glm-4.7',
+                        hasKey: !!(next.apiKey || externalCredentialType),
+                        externalCredentialType
+                    };
+                },
+
+                buildClaudeImportedConfigName(baseUrl) {
+                    const normalizedUrl = typeof baseUrl === 'string' ? baseUrl.trim() : '';
+                    if (!normalizedUrl) return '导入配置';
+                    try {
+                        const parsed = new URL(normalizedUrl);
+                        const host = typeof parsed.host === 'string' ? parsed.host.trim() : '';
+                        if (host) return `导入-${host}`;
+                    } catch (_) {
+                        // keep generic fallback name
+                    }
+                    return '导入配置';
+                },
+
+                ensureClaudeConfigFromSettings(env = {}) {
+                    const normalized = this.normalizeClaudeSettingsEnv(env);
+                    const hasCredential = !!(normalized.apiKey || normalized.authToken || normalized.useKey);
+                    if (!normalized.baseUrl || !hasCredential) return '';
+
+                    const duplicateName = this.findDuplicateClaudeConfigName(normalized);
+                    if (duplicateName) return duplicateName;
+
+                    const preferredName = this.buildClaudeImportedConfigName(normalized.baseUrl);
+                    let candidateName = preferredName;
+                    let suffix = 2;
+                    while (this.claudeConfigs[candidateName]) {
+                        candidateName = `${preferredName}-${suffix}`;
+                        suffix += 1;
                     }
+
+                    this.claudeConfigs[candidateName] = this.mergeClaudeConfig({}, normalized);
+                    this.saveClaudeConfigs();
+                    return candidateName;
+                },
+
+                async refreshClaudeSelectionFromSettings(options = {}) {
                     const silent = !!options.silent;
+                    const silentModelError = !!options.silentModelError || silent;
                     try {
                         const res = await api('get-claude-settings');
                         if (res && res.error) {
@@ -625,7 +680,18 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                             if (this.currentClaudeConfig !== matchName) {
                                 this.currentClaudeConfig = matchName;
                             }
-                            this.refreshClaudeModelContext();
+                            this.refreshClaudeModelContext({ silentError: silentModelError });
+                            return;
+                        }
+                        const importedName = this.ensureClaudeConfigFromSettings((res && res.env) || {});
+                        if (importedName) {
+                            if (this.currentClaudeConfig !== importedName) {
+                                this.currentClaudeConfig = importedName;
+                            }
+                            this.refreshClaudeModelContext({ silentError: silentModelError });
+                            if (!silent) {
+                                this.showMessage(`检测到外部 Claude 配置，已自动导入：${importedName}`, 'success');
+                            }
                             return;
                         }
                         this.currentClaudeConfig = '';
@@ -649,9 +715,9 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     this.currentClaudeModel = config && config.model ? config.model : '';
                 },
 
-                refreshClaudeModelContext() {
+                refreshClaudeModelContext(options = {}) {
                     this.syncClaudeModelFromConfig();
-                    this.loadClaudeModels();
+                    return this.loadClaudeModels(options);
                 },
 
                 resetClaudeModelsState() {
@@ -666,7 +732,8 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     this.claudeModelsHasCurrent = !!currentModel && this.claudeModels.includes(currentModel);
                 },
 
-                async loadClaudeModels() {
+                async loadClaudeModels(options = {}) {
+                    const silentError = !!options.silentError;
                     const config = this.getCurrentClaudeConfig();
                     if (!config) {
                         this.resetClaudeModelsState();
@@ -674,11 +741,20 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     }
                     const baseUrl = (config.baseUrl || '').trim();
                     const apiKey = (config.apiKey || '').trim();
+                    const externalCredentialType = typeof config.externalCredentialType === 'string'
+                        ? config.externalCredentialType.trim()
+                        : '';
 
                     if (!baseUrl) {
                         this.resetClaudeModelsState();
                         return;
                     }
+                    if (!apiKey && externalCredentialType) {
+                        this.claudeModels = [];
+                        this.claudeModelsSource = 'unlimited';
+                        this.claudeModelsHasCurrent = true;
+                        return;
+                    }
 
                     this.claudeModelsLoading = true;
                     try {
@@ -690,7 +766,9 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                             return;
                         }
                         if (res.error) {
-                            this.showMessage('获取模型列表失败', 'error');
+                            if (!silentError) {
+                                this.showMessage('获取模型列表失败', 'error');
+                            }
                             this.claudeModels = [];
                             this.claudeModelsSource = 'error';
                             this.claudeModelsHasCurrent = true;
@@ -701,7 +779,9 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                         this.claudeModelsSource = res.source || 'remote';
                         this.updateClaudeModelsCurrent();
                     } catch (e) {
-                        this.showMessage('获取模型列表失败', 'error');
+                        if (!silentError) {
+                            this.showMessage('获取模型列表失败', 'error');
+                        }
                         this.claudeModels = [];
                         this.claudeModelsSource = 'error';
                         this.claudeModelsHasCurrent = true;
@@ -996,6 +1076,7 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     const name = typeof payload.name === 'string' ? payload.name.trim() : '';
                     const baseUrl = typeof payload.baseUrl === 'string' ? payload.baseUrl.trim() : '';
                     const apiKey = typeof payload.apiKey === 'string' ? payload.apiKey : '';
+                    const model = typeof payload.model === 'string' ? payload.model.trim() : '';
                     if (!name || !baseUrl) return '';
 
                     const nameArg = this.quoteShellArg(name);
@@ -1005,7 +1086,8 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     const addCmd = apiKey
                         ? `codexmate add ${nameArg} ${urlArg} ${keyArg}`
                         : `codexmate add ${nameArg} ${urlArg}`;
-                    return `${addCmd} && ${switchCmd}`;
+                    const modelCmd = model ? ` && codexmate use ${this.quoteShellArg(model)}` : '';
+                    return `${addCmd} && ${switchCmd}${modelCmd}`;
                 },
 
                 buildClaudeShareCommand(payload) {
@@ -1399,9 +1481,59 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     this.scheduleSessionTimelineSync();
                 },
                 onWindowResize() {
+                    this.updateCompactLayoutMode();
                     this.updateSessionTimelineOffset();
                     this.scheduleSessionTimelineSync();
                 },
+                shouldForceCompactLayout() {
+                    if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+                        return false;
+                    }
+                    const doc = typeof document !== 'undefined' ? document : null;
+                    const viewportWidth = Math.max(
+                        0,
+                        Number(window.innerWidth || 0),
+                        Number(doc && doc.documentElement ? doc.documentElement.clientWidth : 0)
+                    );
+                    const screenWidth = Number(window.screen && window.screen.width ? window.screen.width : 0);
+                    const screenHeight = Number(window.screen && window.screen.height ? window.screen.height : 0);
+                    const shortEdge = screenWidth > 0 && screenHeight > 0
+                        ? Math.min(screenWidth, screenHeight)
+                        : 0;
+                    const touchPoints = Number(navigator.maxTouchPoints || 0);
+                    const userAgent = String(navigator.userAgent || '');
+                    const isMobileUa = /(Android|iPhone|iPad|iPod|Mobile)/i.test(userAgent);
+                    let coarsePointer = false;
+                    let noHover = false;
+                    try {
+                        coarsePointer = !!(window.matchMedia && window.matchMedia('(pointer: coarse)').matches);
+                    } catch (_) {}
+                    try {
+                        noHover = !!(window.matchMedia && window.matchMedia('(hover: none)').matches);
+                    } catch (_) {}
+                    return shouldForceCompactLayoutMode({
+                        viewportWidth,
+                        screenWidth,
+                        screenHeight,
+                        shortEdge,
+                        maxTouchPoints: touchPoints,
+                        userAgent,
+                        isMobileUa,
+                        coarsePointer,
+                        noHover
+                    });
+                },
+                applyCompactLayoutClass(enabled) {
+                    if (typeof document === 'undefined' || !document.body) {
+                        return;
+                    }
+                    document.body.classList.toggle('force-compact', !!enabled);
+                },
+                updateCompactLayoutMode() {
+                    const enabled = this.shouldForceCompactLayout();
+                    this.forceCompactLayout = enabled;
+                    this.applyCompactLayoutClass(enabled);
+                },
                 syncSessionTimelineActiveFromScroll() {
                     const nodes = Array.isArray(this.sessionTimelineNodes) ? this.sessionTimelineNodes : [];
                     if (!nodes.length) {
@@ -1751,17 +1883,75 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     }
                 },
 
-                async switchProvider(name) {
+                async quickSwitchProvider(name) {
+                    const target = String(name || '').trim();
+                    if (!target || target === this.pendingProviderSwitch) {
+                        return;
+                    }
+                    if (!this.providerSwitchInProgress && target === this.currentProvider) {
+                        return;
+                    }
+                    await this.switchProvider(target);
+                },
+
+                async waitForCodexApplyIdle(maxWaitMs = 20000) {
+                    const startedAt = Date.now();
+                    while (this.codexApplying) {
+                        if ((Date.now() - startedAt) > maxWaitMs) {
+                            throw new Error('等待配置应用完成超时');
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, 50));
+                    }
+                },
+
+                async performProviderSwitch(name) {
+                    await this.waitForCodexApplyIdle();
                     this.currentProvider = name;
                     await this.loadModelsForProvider(name);
                     if (this.modelsSource === 'remote' && this.models.length > 0 && !this.models.includes(this.currentModel)) {
                         this.currentModel = this.models[0];
                     }
                     if (getProviderConfigModeMeta(this.configMode)) {
+                        await this.waitForCodexApplyIdle();
                         await this.applyCodexConfigDirect({ silent: true });
                     }
                 },
 
+                async switchProvider(name) {
+                    const target = String(name || '').trim();
+                    if (!target) {
+                        return;
+                    }
+                    if (this.providerSwitchInProgress) {
+                        this.pendingProviderSwitch = target;
+                        return;
+                    }
+                    this.providerSwitchInProgress = true;
+                    let lastError = '';
+                    try {
+                        this.pendingProviderSwitch = '';
+                        const result = await runLatestOnlyQueue(target, {
+                            perform: async (queuedTarget) => {
+                                await this.performProviderSwitch(queuedTarget);
+                            },
+                            consumePending: () => {
+                                const queued = this.pendingProviderSwitch;
+                                this.pendingProviderSwitch = '';
+                                return queued;
+                            }
+                        });
+                        if (result && typeof result.lastError === 'string') {
+                            lastError = result.lastError;
+                        }
+                    } finally {
+                        this.providerSwitchInProgress = false;
+                        this.pendingProviderSwitch = '';
+                    }
+                    if (lastError) {
+                        this.showMessage(lastError, 'error');
+                    }
+                },
+
                 async onModelChange() {
                     await this.applyCodexConfigDirect();
                 },
@@ -1963,8 +2153,8 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     }
                 },
 
-                ...createSkillsMethods({ api }),
-
+                ...createSkillsMethods({ api }),
+
                 async openOpenclawAgentsEditor() {
                     this.setAgentsModalContext('openclaw');
                     this.agentsLoading = true;
@@ -2341,12 +2531,7 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     }
                     const existing = this.claudeConfigs[name] || {};
                     this.currentClaudeModel = model;
-                    this.claudeConfigs[name] = {
-                        apiKey: existing.apiKey || '',
-                        baseUrl: existing.baseUrl || '',
-                        model: model,
-                        hasKey: !!existing.apiKey
-                    };
+                    this.claudeConfigs[name] = this.mergeClaudeConfig(existing, { model });
                     this.saveClaudeConfigs();
                     this.updateClaudeModelsCurrent();
                     if (!this.claudeConfigs[name].apiKey) {
@@ -2373,12 +2558,7 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
 
                 updateConfig() {
                     const name = this.editingConfig.name;
-                    this.claudeConfigs[name] = {
-                        apiKey: this.editingConfig.apiKey,
-                        baseUrl: this.editingConfig.baseUrl,
-                        model: this.editingConfig.model,
-                        hasKey: !!this.editingConfig.apiKey
-                    };
+                    this.claudeConfigs[name] = this.mergeClaudeConfig(this.claudeConfigs[name], this.editingConfig);
                     this.saveClaudeConfigs();
                     this.showMessage('操作成功', 'success');
                     this.closeEditConfigModal();
@@ -2394,12 +2574,7 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
 
                 async saveAndApplyConfig() {
                     const name = this.editingConfig.name;
-                    this.claudeConfigs[name] = {
-                        apiKey: this.editingConfig.apiKey,
-                        baseUrl: this.editingConfig.baseUrl,
-                        model: this.editingConfig.model,
-                        hasKey: !!this.editingConfig.apiKey
-                    };
+                    this.claudeConfigs[name] = this.mergeClaudeConfig(this.claudeConfigs[name], this.editingConfig);
                     this.saveClaudeConfigs();
 
                     const config = this.claudeConfigs[name];
@@ -2438,12 +2613,7 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                         return this.showMessage('配置已存在', 'info');
                     }
 
-                    this.claudeConfigs[name] = {
-                        apiKey: this.newClaudeConfig.apiKey,
-                        baseUrl: this.newClaudeConfig.baseUrl,
-                        model: this.newClaudeConfig.model,
-                        hasKey: !!this.newClaudeConfig.apiKey
-                    };
+                    this.claudeConfigs[name] = this.mergeClaudeConfig({}, this.newClaudeConfig);
 
                     this.currentClaudeConfig = name;
                     this.saveClaudeConfigs();
@@ -2474,6 +2644,9 @@ import { createSkillsMethods } from './modules/skills.methods.mjs';
                     const config = this.claudeConfigs[name];
 
                     if (!config.apiKey) {
+                        if (config.externalCredentialType) {
+                            return this.showMessage('检测到外部 Claude 认证状态；当前仅支持展示，若需由 codexmate 接管请补充 API Key', 'info');
+                        }
                         return this.showMessage('请先配置 API Key', 'error');
                     }
 

package/web-ui/index.html

@@ -282,6 +282,20 @@
                         <span class="value">{{ sessionsList.length }}</span>
                     </div>
                 </div>
+                <div
+                    v-if="!sessionStandalone && mainTab === 'config' && isProviderConfigMode && forceCompactLayout && !loading && !initError && providersList.length > 1"
+                    class="provider-fast-switch">
+                    <label class="provider-fast-switch-label" for="provider-fast-switch-select">快速切换提供商</label>
+                    <select
+                        id="provider-fast-switch-select"
+                        class="provider-fast-switch-select"
+                        :value="currentProvider"
+                        @change="quickSwitchProvider($event.target.value)">
+                        <option v-for="provider in providersList" :key="'quick-switch-' + provider.name" :value="provider.name">
+                            {{ provider.name }}
+                        </option>
+                    </select>
+                </div>
 
                 <div v-if="false && mainTab === 'config' && !sessionStandalone" class="config-subtabs">
                     <button :class="['config-subtab', { active: configMode === 'codex' }]" @click="switchConfigMode('codex')">
@@ -672,7 +686,7 @@
                                         <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/>
                                     </svg>
                                 </button>
-                                <button class="card-action-btn" :class="{ loading: claudeShareLoading[name] }" @click="copyClaudeShareCommand(name)" title="分享导入命令" aria-label="Share import command">
+                                <button class="card-action-btn" :class="{ loading: claudeShareLoading[name] }" @click="copyClaudeShareCommand(name)" disabled title="分享导入命令（暂时禁用）" aria-label="Share import command">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                         <path d="M4 12v7a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1v-7"/>
                                         <path d="M16 6l-4-4-4 4"/>

package/web-ui/logic.mjs

@@ -8,33 +8,63 @@ export function normalizeClaudeConfig(config) {
     return {
         apiKey: normalizeClaudeValue(safe.apiKey),
         baseUrl: normalizeClaudeValue(safe.baseUrl),
-        model: normalizeClaudeValue(safe.model)
+        model: normalizeClaudeValue(safe.model),
+        authToken: normalizeClaudeValue(safe.authToken),
+        useKey: normalizeClaudeValue(safe.useKey),
+        externalCredentialType: normalizeClaudeValue(safe.externalCredentialType)
     };
 }
 
 export function normalizeClaudeSettingsEnv(env) {
     const safe = env && typeof env === 'object' ? env : {};
+    const apiKey = normalizeClaudeValue(safe.ANTHROPIC_API_KEY);
+    const authToken = normalizeClaudeValue(safe.ANTHROPIC_AUTH_TOKEN);
+    const useKey = normalizeClaudeValue(safe.CLAUDE_CODE_USE_KEY);
     return {
-        apiKey: normalizeClaudeValue(safe.ANTHROPIC_API_KEY),
+        apiKey,
         baseUrl: normalizeClaudeValue(safe.ANTHROPIC_BASE_URL),
-        model: normalizeClaudeValue(safe.ANTHROPIC_MODEL)
+        model: normalizeClaudeValue(safe.ANTHROPIC_MODEL) || 'glm-4.7',
+        authToken,
+        useKey,
+        externalCredentialType: apiKey
+            ? ''
+            : (authToken ? 'auth-token' : (useKey ? 'claude-code-use-key' : ''))
     };
 }
 
+function normalizeClaudeComparableUrl(value) {
+    const trimmed = normalizeClaudeValue(value);
+    if (!trimmed) return '';
+    return trimmed.replace(/\/+$/g, '');
+}
+
+function hasClaudeCredential(config = {}) {
+    return !!(config.apiKey || config.authToken || config.useKey);
+}
+
 export function matchClaudeConfigFromSettings(claudeConfigs = {}, env = {}) {
     const normalizedSettings = normalizeClaudeSettingsEnv(env);
-    if (!normalizedSettings.apiKey || !normalizedSettings.baseUrl || !normalizedSettings.model) {
+    if (!normalizedSettings.baseUrl || !normalizedSettings.model || !hasClaudeCredential(normalizedSettings)) {
         return '';
     }
+    const comparableSettingsUrl = normalizeClaudeComparableUrl(normalizedSettings.baseUrl);
     const entries = Object.entries(claudeConfigs || {});
     for (const [name, config] of entries) {
         const normalizedConfig = normalizeClaudeConfig(config);
-        if (!normalizedConfig.apiKey || !normalizedConfig.baseUrl || !normalizedConfig.model) {
+        if (!normalizedConfig.baseUrl || !normalizedConfig.model) {
             continue;
         }
-        if (normalizedConfig.apiKey === normalizedSettings.apiKey
-            && normalizedConfig.baseUrl === normalizedSettings.baseUrl
-            && normalizedConfig.model === normalizedSettings.model) {
+        if (normalizeClaudeComparableUrl(normalizedConfig.baseUrl) !== comparableSettingsUrl
+            || normalizedConfig.model !== normalizedSettings.model) {
+            continue;
+        }
+        if (normalizedSettings.apiKey && normalizedConfig.apiKey === normalizedSettings.apiKey) {
+            return name;
+        }
+        if (!normalizedSettings.apiKey
+            && normalizedConfig.apiKey === ''
+            && normalizedConfig.externalCredentialType
+            && normalizedConfig.externalCredentialType === normalizedSettings.externalCredentialType) {
             return name;
         }
     }
@@ -43,18 +73,30 @@ export function matchClaudeConfigFromSettings(claudeConfigs = {}, env = {}) {
 
 export function findDuplicateClaudeConfigName(claudeConfigs = {}, config) {
     const normalized = normalizeClaudeConfig(config);
-    if (!normalized.apiKey || !normalized.baseUrl || !normalized.model) {
+    if (!normalized.baseUrl || !normalized.model) {
+        return '';
+    }
+    const comparableUrl = normalizeClaudeComparableUrl(normalized.baseUrl);
+    const isExternal = !normalized.apiKey && !!normalized.externalCredentialType;
+    if (!normalized.apiKey && !isExternal) {
         return '';
     }
     const entries = Object.entries(claudeConfigs || {});
     for (const [name, existing] of entries) {
         const normalizedExisting = normalizeClaudeConfig(existing);
-        if (!normalizedExisting.apiKey || !normalizedExisting.baseUrl || !normalizedExisting.model) {
+        if (!normalizedExisting.baseUrl || !normalizedExisting.model) {
+            continue;
+        }
+        if (normalizeClaudeComparableUrl(normalizedExisting.baseUrl) !== comparableUrl
+            || normalizedExisting.model !== normalized.model) {
             continue;
         }
-        if (normalizedExisting.apiKey === normalized.apiKey
-            && normalizedExisting.baseUrl === normalized.baseUrl
-            && normalizedExisting.model === normalized.model) {
+        if (normalized.apiKey && normalizedExisting.apiKey === normalized.apiKey) {
+            return name;
+        }
+        if (isExternal
+            && !normalizedExisting.apiKey
+            && normalizedExisting.externalCredentialType === normalized.externalCredentialType) {
             return name;
         }
     }
@@ -126,6 +168,64 @@ export function buildSpeedTestIssue(name, result) {
     return null;
 }
 
+export async function runLatestOnlyQueue(initialTarget, options = {}) {
+    const perform = typeof options.perform === 'function'
+        ? options.perform
+        : async () => {};
+    const consumePending = typeof options.consumePending === 'function'
+        ? options.consumePending
+        : () => '';
+    let currentTarget = typeof initialTarget === 'string' ? initialTarget.trim() : '';
+    let lastError = '';
+
+    while (currentTarget) {
+        try {
+            await perform(currentTarget);
+            lastError = '';
+        } catch (e) {
+            lastError = e && e.message ? e.message : 'queue task failed';
+        }
+        const queued = String(consumePending() || '').trim();
+        if (!queued || queued === currentTarget) {
+            break;
+        }
+        currentTarget = queued;
+    }
+
+    return {
+        lastTarget: currentTarget,
+        lastError
+    };
+}
+
+export function shouldForceCompactLayoutMode(options = {}) {
+    const viewportWidth = Number(options.viewportWidth || 0);
+    const screenWidth = Number(options.screenWidth || 0);
+    const screenHeight = Number(options.screenHeight || 0);
+    const shortEdge = Number(options.shortEdge || (screenWidth > 0 && screenHeight > 0 ? Math.min(screenWidth, screenHeight) : 0));
+    const maxTouchPoints = Number(options.maxTouchPoints || 0);
+    const userAgent = typeof options.userAgent === 'string' ? options.userAgent : '';
+    const isMobileUa = typeof options.isMobileUa === 'boolean'
+        ? options.isMobileUa
+        : /(Android|iPhone|iPad|iPod|Mobile)/i.test(userAgent);
+    const coarsePointer = !!options.coarsePointer;
+    const noHover = !!options.noHover;
+    const isSmallPhysicalScreen = shortEdge > 0 && shortEdge <= 920;
+    const isNarrowViewport = viewportWidth > 0 && viewportWidth <= 960;
+    const pointerSuggestsTouchOnly = coarsePointer && noHover;
+
+    if (isMobileUa) {
+        return isNarrowViewport || isSmallPhysicalScreen;
+    }
+    if (!pointerSuggestsTouchOnly) {
+        return false;
+    }
+    if (maxTouchPoints <= 0) {
+        return false;
+    }
+    return isSmallPhysicalScreen;
+}
+
 // Session filtering helpers
 export function isSessionQueryEnabled(source) {
     const normalized = normalizeSessionSource(source, '');