codexmate 0.0.55 → 0.0.56

package/web-ui/modules/app.computed.session.mjs

@@ -51,6 +51,190 @@ function formatUsageRangeLabel(range, t) {
     return '近 7 天';
 }
 
+function normalizeWorkspaceText(value) {
+    if (value == null) {
+        return '';
+    }
+    return String(value)
+        .replace(/<[^>]*>/g, ' ')
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&amp;/gi, '&')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function trimWorkspaceLine(value, maxLength = 160) {
+    const text = normalizeWorkspaceText(value);
+    if (!text) return '';
+    const limit = Number.isFinite(Number(maxLength)) ? Math.max(20, Math.floor(Number(maxLength))) : 160;
+    return text.length > limit ? `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…` : text;
+}
+
+function pushUniqueWorkspaceItem(items, value, limit = 6, maxLength = 160) {
+    if (!Array.isArray(items) || items.length >= limit) return;
+    const text = trimWorkspaceLine(value, maxLength);
+    if (!text) return;
+    const key = text.toLowerCase();
+    if (items.some(item => String(item || '').toLowerCase() === key)) return;
+    items.push(text);
+}
+
+function extractWorkspaceLines(text) {
+    return String(text || '')
+        .split(/\r?\n|(?:^|\s)(?:[-*•]|\d+[.)])\s+|[。；;]\s*/g)
+        .map(line => normalizeWorkspaceText(line))
+        .filter(Boolean);
+}
+
+function isWorkspaceCommandLine(line) {
+    return /^\$\s+/.test(line)
+        || /^(?:npm|pnpm|yarn|bun|node|npx|git|gh|codex|claude|gemini|codebuddy|openclaw|pytest|go test|cargo test|make|docker)\b/i.test(line);
+}
+
+function extractInlineWorkspaceCommands(text) {
+    const source = normalizeWorkspaceText(text);
+    if (!source) return [];
+    const matches = source.match(/(?:^|[^A-Za-z0-9_])(?:\$\s*)?(?:(?:npm|pnpm|yarn|bun|node|npx|git|gh|codex|claude|gemini|codebuddy|openclaw|pytest|make|docker)\s+(?:run\s+)?[A-Za-z0-9:_./@-]+(?:\s+&&\s+(?:npm|pnpm|yarn|bun|node|npx|git|gh|codex|claude|gemini|codebuddy|openclaw|pytest|make|docker)\s+(?:run\s+)?[A-Za-z0-9:_./@-]+)?|go\s+test(?:\s+[A-Za-z0-9:_./@-]+)?|cargo\s+test(?:\s+[A-Za-z0-9:_./@-]+)?)(?=$|\s|[，。；,;])/gi) || [];
+    return matches.map(match => match.replace(/^[^A-Za-z0-9_$]*\$?\s*/, '').trim());
+}
+
+function extractWorkspaceArtifacts(line, target) {
+    if (!target || typeof line !== 'string') return;
+    const urlMatches = line.match(/https?:\/\/[^\s)\]"'<>，。；、]+/gi) || [];
+    for (const url of urlMatches) {
+        pushUniqueWorkspaceItem(target.links, url.replace(/[，。；、.,;:!?]+$/g, ''), 5, 140);
+    }
+    const fileMatches = line.match(/(?:[A-Za-z]:[\\/]|\/)?(?:[A-Za-z0-9_.@+-]+[\\/])*[A-Za-z0-9_.@+-]+\.(?:mjs|js|cjs|ts|tsx|jsx|vue|css|scss|html|json|jsonl|md|yml|yaml|toml|lock|py|go|rs|sh|txt)/g) || [];
+    for (const filePath of fileMatches) {
+        pushUniqueWorkspaceItem(target.files, filePath, 8, 120);
+    }
+}
+
+function buildWorkspaceBriefText(summary, labels = {}) {
+    if (!summary || !summary.available) return '';
+    const label = (key, fallback) => (labels && labels[key]) || fallback;
+    const lines = [
+        `# ${label('title', 'Session workspace brief')}`,
+        '',
+        `${label('source', 'Source')}: ${summary.sourceLabel || summary.source || '-'}`,
+        `${label('messages', 'Messages')}: ${summary.messageCount}`,
+        `${label('path', 'Path')}: ${summary.cwd || '-'}`,
+        ''
+    ];
+    const sections = [
+        ['signals', label('signals', 'Signals'), summary.signals],
+        ['commands', label('commands', 'Reusable commands'), summary.commands],
+        ['files', label('files', 'Files'), summary.files],
+        ['links', label('links', 'Links'), summary.links],
+        ['risks', label('risks', 'Risks / blockers'), summary.risks],
+        ['nextSteps', label('nextSteps', 'Next steps'), summary.nextSteps]
+    ];
+    for (const [, sectionTitle, items] of sections) {
+        if (!Array.isArray(items) || !items.length) continue;
+        lines.push(`## ${sectionTitle}`);
+        for (const item of items) {
+            lines.push(`- ${item}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+
+export function buildSessionWorkspaceSummary(session, messages, options = {}) {
+    const safeMessages = Array.isArray(messages) ? messages : [];
+    const roleCounts = { user: 0, assistant: 0, system: 0, other: 0 };
+    const signals = [];
+    const commands = [];
+    const files = [];
+    const links = [];
+    const risks = [];
+    const nextSteps = [];
+    const target = { files, links };
+    let firstUser = '';
+    let lastUser = '';
+    let lastAssistant = '';
+    let firstTimestamp = '';
+    let lastTimestamp = '';
+
+    safeMessages.forEach((message) => {
+        if (!message || typeof message !== 'object') return;
+        const normalizedRole = String(message.normalizedRole || message.role || '').trim().toLowerCase();
+        const role = normalizedRole === 'user' || normalizedRole === 'assistant' || normalizedRole === 'system'
+            ? normalizedRole
+            : 'other';
+        roleCounts[role] += 1;
+        const timestamp = normalizeWorkspaceText(message.timestamp || '');
+        if (timestamp && !firstTimestamp) firstTimestamp = timestamp;
+        if (timestamp) lastTimestamp = timestamp;
+        const text = normalizeWorkspaceText(message.text || message.content || '');
+        if (!text) return;
+        if (role === 'user') {
+            if (!firstUser) firstUser = text;
+            lastUser = text;
+        } else if (role === 'assistant') {
+            lastAssistant = text;
+        }
+        const lines = extractWorkspaceLines(message.text || message.content || text);
+        for (const command of extractInlineWorkspaceCommands(message.text || message.content || text)) {
+            pushUniqueWorkspaceItem(commands, command, 6, 140);
+        }
+        for (const line of lines) {
+            extractWorkspaceArtifacts(line, target);
+            if (isWorkspaceCommandLine(line)) {
+                pushUniqueWorkspaceItem(commands, line.replace(/^\$\s+/, ''), 6, 140);
+            }
+            if (/(?:blocker|blocked|risk|failed|failure|error|timeout|regression|冲突|失败|错误|阻塞|风险|不可合|超时|回归)/i.test(line)) {
+                pushUniqueWorkspaceItem(risks, line, 5, 150);
+            }
+            if (/(?:todo|next|follow[- ]?up|remaining|后续|下一步|待办|继续|剩余)/i.test(line)) {
+                pushUniqueWorkspaceItem(nextSteps, line, 5, 150);
+            }
+        }
+    });
+
+    pushUniqueWorkspaceItem(signals, firstUser, 3, 150);
+    if (lastUser && lastUser !== firstUser) {
+        pushUniqueWorkspaceItem(signals, lastUser, 3, 150);
+    }
+    pushUniqueWorkspaceItem(signals, lastAssistant, 3, 150);
+
+    const source = session && typeof session.source === 'string' ? session.source : '';
+    const sourceLabel = session && typeof session.sourceLabel === 'string' ? session.sourceLabel : source;
+    const cwd = session && typeof session.cwd === 'string' ? session.cwd : '';
+    const messageCount = safeMessages.length;
+    const available = messageCount > 0;
+    const metrics = [
+        { key: 'messages', value: String(messageCount), label: options.messagesLabel || 'Messages' },
+        { key: 'user', value: String(roleCounts.user), label: options.userLabel || 'User' },
+        { key: 'assistant', value: String(roleCounts.assistant), label: options.assistantLabel || 'Assistant' },
+        { key: 'commands', value: String(commands.length), label: options.commandsLabel || 'Commands' },
+        { key: 'artifacts', value: String(files.length + links.length), label: options.artifactsLabel || 'Artifacts' },
+        { key: 'risks', value: String(risks.length + nextSteps.length), label: options.risksLabel || 'Risks' }
+    ];
+
+    const summary = {
+        available,
+        source,
+        sourceLabel,
+        cwd,
+        firstTimestamp,
+        lastTimestamp,
+        messageCount,
+        roleCounts,
+        metrics,
+        signals,
+        commands,
+        files,
+        links,
+        risks,
+        nextSteps
+    };
+    summary.briefText = buildWorkspaceBriefText(summary, options.briefLabels || {});
+    return summary;
+}
+
 function formatUsageDuration(value, options = {}) {
     const normalizedLang = typeof options.lang === 'string' ? options.lang.trim().toLowerCase() : '';
     const isEn = normalizedLang === 'en';
@@ -267,6 +451,32 @@ export function createSessionComputed() {
             if (index < 0) return 0;
             return Math.round(((index + 1) / this.sessionTimelineNodes.length) * 100);
         },
+        activeSessionWorkspaceSummary() {
+            if (this.mainTab !== 'sessions' || !this.activeSession) {
+                return buildSessionWorkspaceSummary(null, []);
+            }
+            const t = typeof this.t === 'function' ? this.t : null;
+            return buildSessionWorkspaceSummary(this.activeSession, this.activeSessionMessages, {
+                messagesLabel: t ? t('sessions.workspace.metric.messages') : 'Messages',
+                userLabel: t ? t('sessions.workspace.metric.user') : 'User',
+                assistantLabel: t ? t('sessions.workspace.metric.assistant') : 'Assistant',
+                commandsLabel: t ? t('sessions.workspace.metric.commands') : 'Commands',
+                artifactsLabel: t ? t('sessions.workspace.metric.artifacts') : 'Artifacts',
+                risksLabel: t ? t('sessions.workspace.metric.risks') : 'Risks',
+                briefLabels: {
+                    title: t ? t('sessions.workspace.copy.title') : 'Session workspace brief',
+                    source: t ? t('sessions.workspace.copy.source') : 'Source',
+                    messages: t ? t('sessions.workspace.metric.messages') : 'Messages',
+                    path: t ? t('sessions.workspace.copy.path') : 'Path',
+                    signals: t ? t('sessions.workspace.signals') : 'Signals',
+                    commands: t ? t('sessions.workspace.commands') : 'Reusable commands',
+                    files: t ? t('sessions.workspace.files') : 'Files',
+                    links: t ? t('sessions.workspace.links') : 'Links',
+                    risks: t ? t('sessions.workspace.risks') : 'Risks / blockers',
+                    nextSteps: t ? t('sessions.workspace.nextSteps') : 'Next steps'
+                }
+            });
+        },
         sessionQueryPlaceholder() {
             if (this.isSessionQueryEnabled) {
                 return typeof this.t === 'function'

package/web-ui/modules/app.methods.claude-config.mjs

@@ -1,3 +1,5 @@
+import { nextClaudeConfigName } from './provider-default-names.mjs';
+
 function normalizeClaudeText(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -6,6 +8,21 @@ function normalizeClaudeBaseUrl(value) {
     return normalizeClaudeText(value).replace(/\/+$/g, '');
 }
 
+const DELETED_CLAUDE_SETTINGS_IMPORTS_KEY = 'deletedClaudeSettingsImports';
+
+function buildDeletedClaudeSettingsFingerprint(config = {}) {
+    const safe = config && typeof config === 'object' ? config : {};
+    const baseUrl = normalizeClaudeBaseUrl(safe.baseUrl);
+    const model = normalizeClaudeText(safe.model);
+    if (!baseUrl || !model) return null;
+    return {
+        baseUrl,
+        model,
+        providerCacheRef: normalizeClaudeText(safe.providerCacheRef),
+        deletedAt: Date.now()
+    };
+}
+
 function isValidClaudeHttpUrl(value) {
     if (!value) return false;
     try {
@@ -114,6 +131,46 @@ export function createClaudeConfigMethods(options = {}) {
             this.syncClaudeBridgeProviders();
         },
 
+        rememberDeletedClaudeSettingsImport(config) {
+            const fingerprint = buildDeletedClaudeSettingsFingerprint(config);
+            if (!fingerprint) return;
+            try {
+                const raw = localStorage.getItem(DELETED_CLAUDE_SETTINGS_IMPORTS_KEY);
+                const parsed = raw ? JSON.parse(raw) : [];
+                const entries = Array.isArray(parsed) ? parsed : [];
+                const deduped = entries.filter((entry) => {
+                    if (!entry || typeof entry !== 'object') return false;
+                    return normalizeClaudeBaseUrl(entry.baseUrl) !== fingerprint.baseUrl
+                        || normalizeClaudeText(entry.model) !== fingerprint.model;
+                });
+                deduped.push(fingerprint);
+                localStorage.setItem(DELETED_CLAUDE_SETTINGS_IMPORTS_KEY, JSON.stringify(deduped.slice(-50)));
+            } catch (_) {}
+        },
+
+        async applyCurrentClaudeConfigSilently() {
+            const name = normalizeClaudeText(this.currentClaudeConfig);
+            if (!name || !this.claudeConfigs || !this.claudeConfigs[name]) return false;
+            if (typeof this.applyClaudeConfig !== 'function') return false;
+            return await this.applyClaudeConfig(name, { silent: true });
+        },
+
+        selectClaudeFallbackConfigName(excludedNames = []) {
+            const configs = this.claudeConfigs && typeof this.claudeConfigs === 'object' ? this.claudeConfigs : {};
+            const excluded = new Set((Array.isArray(excludedNames) ? excludedNames : [excludedNames])
+                .map((name) => normalizeClaudeText(name))
+                .filter(Boolean));
+            const names = Object.keys(configs).filter((name) => name && !excluded.has(name));
+            const applyable = names.find((name) => {
+                const config = configs[name] || {};
+                return !!(config.apiKey
+                    || config.providerCacheRef
+                    || config.externalCredentialType
+                    || config.targetApi === 'ollama');
+            });
+            return applyable || names[0] || '';
+        },
+
         async hydrateClaudeConfigsFromProviderCache(options = {}) {
             const silent = options && options.silent === true;
             try {
@@ -123,10 +180,10 @@ export function createClaudeConfigMethods(options = {}) {
                     return false;
                 }
                 const providers = Array.isArray(res.providers) ? res.providers : [];
-                if (providers.length === 0) return true;
                 const configs = this.claudeConfigs && typeof this.claudeConfigs === 'object' ? this.claudeConfigs : {};
                 let changed = false;
                 let firstCachedName = '';
+                const liveCacheRefs = new Set();
                 for (const provider of providers) {
                     if (!provider || typeof provider !== 'object') continue;
                     const name = normalizeClaudeText(provider.name);
@@ -134,12 +191,15 @@ export function createClaudeConfigMethods(options = {}) {
                     const model = normalizeClaudeText(provider.model);
                     if (!name || !baseUrl || !model) continue;
                     if (!firstCachedName) firstCachedName = name;
+                    const providerCacheRef = normalizeClaudeText(provider.providerCacheRef) || name;
+                    liveCacheRefs.add(name);
+                    liveCacheRefs.add(providerCacheRef);
                     const cachedConfig = {
                         apiKey: '',
                         baseUrl,
                         model,
                         hasKey: provider.hasKey === true,
-                        providerCacheRef: normalizeClaudeText(provider.providerCacheRef) || name,
+                        providerCacheRef,
                         source: 'provider-cache',
                         targetApi: normalizeClaudeText(provider.targetApi) || 'responses'
                     };
@@ -152,11 +212,26 @@ export function createClaudeConfigMethods(options = {}) {
                         changed = true;
                     }
                 }
+                for (const [name, existing] of Object.entries(configs)) {
+                    if (!existing || typeof existing !== 'object') continue;
+                    const providerCacheRef = normalizeClaudeText(existing.providerCacheRef);
+                    const source = normalizeClaudeText(existing.source);
+                    const cacheBacked = source === 'provider-cache' || !!providerCacheRef;
+                    if (!cacheBacked) continue;
+                    const ref = providerCacheRef || normalizeClaudeText(name);
+                    if (liveCacheRefs.has(ref) || liveCacheRefs.has(normalizeClaudeText(name))) continue;
+                    delete configs[name];
+                    changed = true;
+                }
                 this.claudeConfigs = configs;
-                if (firstCachedName) {
+                const current = normalizeClaudeText(this.currentClaudeConfig);
+                if (current && !configs[current]) {
+                    this.currentClaudeConfig = firstCachedName || Object.keys(configs)[0] || '';
+                    try { localStorage.setItem('currentClaudeConfig', this.currentClaudeConfig); } catch (_) {}
+                    changed = true;
+                } else if (firstCachedName) {
                     let savedCurrent = '';
                     try { savedCurrent = localStorage.getItem('currentClaudeConfig') || ''; } catch (_) {}
-                    const current = normalizeClaudeText(this.currentClaudeConfig);
                     const currentConfig = current && configs[current] ? configs[current] : null;
                     if (!savedCurrent && (!current || (currentConfig && currentConfig.hasKey === false && !currentConfig.providerCacheRef))) {
                         this.currentClaudeConfig = firstCachedName;
@@ -323,6 +398,28 @@ export function createClaudeConfigMethods(options = {}) {
             await this.applyClaudeConfig(name);
         },
 
+        async deleteClaudeProviderCacheRef(configOrName) {
+            const config = configOrName && typeof configOrName === 'object'
+                ? configOrName
+                : (this.claudeConfigs && this.claudeConfigs[configOrName] ? this.claudeConfigs[configOrName] : null);
+            const ref = normalizeClaudeText(config && config.providerCacheRef);
+            const source = normalizeClaudeText(config && config.source);
+            if (!ref && source !== 'provider-cache') return true;
+            const name = ref || normalizeClaudeText(config && config.name) || normalizeClaudeText(configOrName);
+            if (!name) return true;
+            try {
+                const res = await api('delete-provider-cache-record', { name, group: 'claude' });
+                if (res && res.error) {
+                    this.showMessage(res.error, 'error');
+                    return false;
+                }
+                return true;
+            } catch (e) {
+                this.showMessage(e && e.message ? e.message : this.t('toast.operation.fail'), 'error');
+                return false;
+            }
+        },
+
         async deleteClaudeConfig(name) {
             if (Object.keys(this.claudeConfigs).length <= 1) {
                 return this.showMessage(this.t('toast.claude.keepOne'), 'error');
@@ -336,16 +433,30 @@ export function createClaudeConfigMethods(options = {}) {
             });
             if (!confirmed) return;
 
+            const config = this.claudeConfigs[name];
+            const cacheDeleted = await this.deleteClaudeProviderCacheRef(config || name);
+            if (!cacheDeleted) return;
+
+            if (typeof this.rememberDeletedClaudeSettingsImport === 'function') {
+                this.rememberDeletedClaudeSettingsImport(config);
+            }
             delete this.claudeConfigs[name];
             if (this.currentClaudeConfig === name) {
-                this.currentClaudeConfig = Object.keys(this.claudeConfigs)[0];
+                this.currentClaudeConfig = this.selectClaudeFallbackConfigName();
             }
             this.saveClaudeConfigs();
             this.showMessage(this.t('toast.operation.success'), 'success');
-            this.refreshClaudeModelContext();
+            if (this.currentClaudeConfig) {
+                await this.applyCurrentClaudeConfigSilently();
+            } else {
+                this.refreshClaudeModelContext();
+            }
         },
 
-        async applyClaudeConfig(name) {
+        async applyClaudeConfig(name, options = {}) {
+            const silent = !!(options && options.silent);
+            const silentSuccess = silent || !!(options && options.silentSuccess);
+            const silentError = silent || !!(options && options.silentError);
             this.currentClaudeConfig = name;
             try { localStorage.setItem('currentClaudeConfig', name || ''); } catch (_) {}
             this.refreshClaudeModelContext();
@@ -353,8 +464,10 @@ export function createClaudeConfigMethods(options = {}) {
 
             if (!config.apiKey && !config.providerCacheRef && config.targetApi !== 'ollama') {
                 if (config.externalCredentialType) {
+                    if (silentError) return false;
                     return this.showMessage(this.t('toast.claude.externalAuth'), 'info');
                 }
+                if (silentError) return false;
                 return this.showMessage(this.t('toast.claude.apiKeyRequired'), 'error');
             }
 
@@ -362,15 +475,18 @@ export function createClaudeConfigMethods(options = {}) {
             try {
                 const res = await api('apply-claude-config', { config: { ...config, name } });
                 if (res.error || res.success === false) {
-                    this.showMessage(res.error || this.t('toast.apply.fail'), 'error');
+                    if (!silentError) this.showMessage(res.error || this.t('toast.apply.fail'), 'error');
+                    return false;
                 } else {
-                    if (this._lastAppliedClaudeKey !== _claudeKey2) {
+                    if (!silentSuccess && this._lastAppliedClaudeKey !== _claudeKey2) {
                         this.showMessage(this.t('toast.apply.success'), 'success');
-                        this._lastAppliedClaudeKey = _claudeKey2;
                     }
+                    this._lastAppliedClaudeKey = _claudeKey2;
+                    return true;
                 }
             } catch (_) {
-                this.showMessage(this.t('toast.apply.fail'), 'error');
+                if (!silentError) this.showMessage(this.t('toast.apply.fail'), 'error');
+                return false;
             }
         },
 
@@ -378,7 +494,7 @@ export function createClaudeConfigMethods(options = {}) {
             this.showClaudeConfigModal = false;
             this.showAddClaudeConfigKey = false;
             this.newClaudeConfig = {
-                name: '',
+                name: nextClaudeConfigName(this.claudeConfigs),
                 apiKey: '',
                 externalCredentialType: '',
                 baseUrl: '',