codexmate 0.0.22 → 0.0.24

package/web-ui/modules/app.methods.session-browser.mjs

@@ -4,6 +4,14 @@ import {
     normalizeSessionMessageRole,
     normalizeSessionPathFilter
 } from '../logic.mjs';
+import {
+    applySessionsFilterUrlState,
+    buildSessionsFilterShareUrl,
+    normalizeSessionRoleFilter,
+    normalizeSessionTimePreset,
+    readSessionsFilterUrlState,
+    syncSessionsFilterUrl
+} from './sessions-filters-url.mjs';
 
 function isSessionLoadNativeDialogEnabled(vm) {
     if (vm && typeof vm.isSessionLoadNativeDialogEnabled === 'function' && vm.isSessionLoadNativeDialogEnabled !== isSessionLoadNativeDialogEnabled) {
@@ -241,11 +249,22 @@ export function createSessionBrowserMethods(options = {}) {
         },
 
         restoreSessionFilterCache() {
+            const urlState = readSessionsFilterUrlState();
+            if (urlState) {
+                applySessionsFilterUrlState(this, urlState);
+                return;
+            }
             const sourceCache = localStorage.getItem('codexmateSessionFilterSource');
             const pathCache = localStorage.getItem('codexmateSessionPathFilter');
             const cached = buildSessionFilterCacheState(sourceCache, pathCache);
             this.sessionFilterSource = cached.source;
             this.sessionPathFilter = cached.pathFilter;
+            const queryCache = localStorage.getItem('codexmateSessionQuery');
+            const roleCache = localStorage.getItem('codexmateSessionRoleFilter');
+            const timeCache = localStorage.getItem('codexmateSessionTimePreset');
+            this.sessionQuery = typeof queryCache === 'string' ? queryCache : '';
+            this.sessionRoleFilter = normalizeSessionRoleFilter(roleCache);
+            this.sessionTimePreset = normalizeSessionTimePreset(timeCache);
             this.refreshSessionPathOptions(this.sessionFilterSource);
         },
 
@@ -257,6 +276,13 @@ export function createSessionBrowserMethods(options = {}) {
             } else {
                 localStorage.removeItem('codexmateSessionPathFilter');
             }
+            if (this.sessionQuery && isSessionQueryEnabled(this.sessionFilterSource)) {
+                localStorage.setItem('codexmateSessionQuery', this.sessionQuery);
+            } else {
+                localStorage.removeItem('codexmateSessionQuery');
+            }
+            localStorage.setItem('codexmateSessionRoleFilter', normalizeSessionRoleFilter(this.sessionRoleFilter));
+            localStorage.setItem('codexmateSessionTimePreset', normalizeSessionTimePreset(this.sessionTimePreset));
         },
 
         normalizeSessionPinnedMap(raw) {
@@ -389,15 +415,19 @@ export function createSessionBrowserMethods(options = {}) {
         async onSessionSourceChange() {
             this.refreshSessionPathOptions(this.sessionFilterSource);
             this.persistSessionFilterCache();
+            syncSessionsFilterUrl(this);
             await this.loadSessions();
         },
 
         async onSessionPathFilterChange() {
             this.persistSessionFilterCache();
+            syncSessionsFilterUrl(this);
             await this.loadSessions();
         },
 
         async onSessionFilterChange() {
+            this.persistSessionFilterCache();
+            syncSessionsFilterUrl(this);
             await this.loadSessions();
         },
 
@@ -408,9 +438,31 @@ export function createSessionBrowserMethods(options = {}) {
             this.sessionRoleFilter = 'all';
             this.sessionTimePreset = 'all';
             this.persistSessionFilterCache();
+            syncSessionsFilterUrl(this);
             await this.onSessionSourceChange();
         },
 
+        async copySessionsFilterShareUrl() {
+            const url = buildSessionsFilterShareUrl(this);
+            if (!url) {
+                this.showMessage(typeof this.t === 'function' ? this.t('sessions.filters.urlBuildFail') : 'Failed to build link', 'error');
+                return;
+            }
+            try {
+                if (navigator.clipboard && window.isSecureContext) {
+                    await navigator.clipboard.writeText(url);
+                    this.showMessage(typeof this.t === 'function' ? this.t('toast.copy.ok') : 'Copied', 'success');
+                    return;
+                }
+            } catch (_) {}
+            const ok = typeof this.fallbackCopyText === 'function' ? this.fallbackCopyText(url) : false;
+            if (ok) {
+                this.showMessage(typeof this.t === 'function' ? this.t('toast.copy.ok') : 'Copied', 'success');
+                return;
+            }
+            this.showMessage(typeof this.t === 'function' ? this.t('toast.copy.fail') : 'Copy failed', 'error');
+        },
+
         normalizeSessionMessage(message) {
             const fallback = {
                 role: 'assistant',
@@ -464,21 +516,40 @@ export function createSessionBrowserMethods(options = {}) {
 
         invalidateSessionsUsageData(options = {}) {
             this.sessionsUsageLoadedOnce = false;
+            this.sessionsUsageLoadedLimit = 0;
             this.sessionsUsageError = '';
             if (options.preserveList !== true) {
                 this.sessionsUsageList = [];
             }
         },
 
+        setSessionsUsageTimeRange(nextRange) {
+            const normalized = typeof nextRange === 'string' ? nextRange.trim().toLowerCase() : '';
+            const range = normalized === 'all' ? 'all' : (normalized === '30d' ? '30d' : '7d');
+            this.sessionsUsageTimeRange = range;
+            void this.loadSessionsUsage({ range });
+        },
+
         async loadSessionsUsage(options = {}) {
             if (this.sessionsUsageLoading) return;
+            const normalizedRange = typeof options.range === 'string'
+                ? options.range.trim().toLowerCase()
+                : (typeof this.sessionsUsageTimeRange === 'string' ? this.sessionsUsageTimeRange.trim().toLowerCase() : '');
+            const range = normalizedRange === 'all' ? 'all' : (normalizedRange === '30d' ? '30d' : '7d');
+            const defaultLimit = range === 'all' ? 2000 : (range === '30d' ? 1200 : 600);
+            const rawLimit = Number(options.limit);
+            const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.min(rawLimit, 2000)) : defaultLimit;
+            const loadedLimit = Number(this.sessionsUsageLoadedLimit || 0);
+            if (this.sessionsUsageLoadedOnce && !options.forceRefresh && loadedLimit >= limit) {
+                return;
+            }
             this.sessionsUsageLoading = true;
             this.sessionsUsageError = '';
             let loadSucceeded = false;
             try {
                 const res = await api('list-sessions-usage', {
                     source: 'all',
-                    limit: 2000,
+                    limit,
                     forceRefresh: !!options.forceRefresh
                 });
                 if (res.error) {
@@ -495,6 +566,7 @@ export function createSessionBrowserMethods(options = {}) {
                 this.sessionsUsageLoading = false;
                 if (loadSucceeded) {
                     this.sessionsUsageLoadedOnce = true;
+                    this.sessionsUsageLoadedLimit = limit;
                 }
             }
         },

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

@@ -34,6 +34,18 @@ export function createStartupClaudeMethods(options = {}) {
                         startupOk = true;
                         this.currentProvider = statusRes.provider;
                         this.currentModel = statusRes.model;
+                        try {
+                            const installRes = await api('install-status');
+                            if (installRes && !installRes.error) {
+                                const targets = Array.isArray(installRes.targets) ? installRes.targets : null;
+                                if (targets) {
+                                    this.installStatusTargets = targets;
+                                }
+                                if (typeof installRes.packageManager === 'string' && typeof this.normalizeInstallPackageManager === 'function') {
+                                    this.installPackageManager = this.normalizeInstallPackageManager(installRes.packageManager);
+                                }
+                            }
+                        } catch (_) {}
                         {
                             const tier = typeof statusRes.serviceTier === 'string'
                                 ? statusRes.serviceTier.trim().toLowerCase()

package/web-ui/modules/app.methods.task-orchestration.mjs

@@ -12,11 +12,11 @@ function createDefaultTaskOrchestrationState() {
         followUpsText: '',
         workflowIdsText: '',
         selectedEngine: 'codex',
-        allowWrite: false,
-        dryRun: false,
+        runMode: 'write',
         concurrency: 2,
         autoFixRounds: 1,
         plan: null,
+        planFingerprint: '',
         planIssues: [],
         planWarnings: [],
         overviewWarnings: [],
@@ -62,6 +62,22 @@ function isActiveStatus(status) {
     return normalized === 'running' || normalized === 'queued';
 }
 
+function normalizeTaskRunMode(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'read') return 'read';
+    if (normalized === 'dry-run' || normalized === 'dryrun' || normalized === 'plan') return 'dry-run';
+    return 'write';
+}
+
+function buildRunModeFlags(runMode) {
+    const normalized = normalizeTaskRunMode(runMode);
+    return {
+        runMode: normalized,
+        allowWrite: normalized === 'write',
+        dryRun: normalized === 'dry-run'
+    };
+}
+
 export function createTaskOrchestrationMethods(options = {}) {
     const { api } = options;
 
@@ -75,6 +91,7 @@ export function createTaskOrchestrationMethods(options = {}) {
                         current[key] = value;
                     }
                 }
+                current.runMode = normalizeTaskRunMode(current.runMode);
                 return current;
             }
             this.taskOrchestration = createDefaultTaskOrchestrationState();
@@ -83,6 +100,7 @@ export function createTaskOrchestrationMethods(options = {}) {
 
         buildTaskOrchestrationRequest() {
             const state = this.ensureTaskOrchestrationState();
+            const flags = buildRunModeFlags(state.runMode);
             return {
                 title: String(state.title || '').trim(),
                 target: String(state.target || '').trim(),
@@ -90,13 +108,29 @@ export function createTaskOrchestrationMethods(options = {}) {
                 followUps: normalizeLines(state.followUpsText),
                 workflowIds: normalizeLines(state.workflowIdsText),
                 engine: String(state.selectedEngine || 'codex').trim().toLowerCase() === 'workflow' ? 'workflow' : 'codex',
-                allowWrite: state.allowWrite === true,
-                dryRun: state.dryRun === true,
+                allowWrite: flags.allowWrite,
+                dryRun: flags.dryRun,
                 concurrency: normalizePositiveInteger(state.concurrency, 2, 1, 8),
                 autoFixRounds: normalizePositiveInteger(state.autoFixRounds, 1, 0, 5)
             };
         },
 
+        buildTaskOrchestrationFingerprint() {
+            const req = this.buildTaskOrchestrationRequest();
+            return JSON.stringify({
+                title: req.title,
+                target: req.target,
+                notes: req.notes,
+                followUps: req.followUps,
+                workflowIds: req.workflowIds,
+                engine: req.engine,
+                allowWrite: req.allowWrite,
+                dryRun: req.dryRun,
+                concurrency: req.concurrency,
+                autoFixRounds: req.autoFixRounds
+            });
+        },
+
         taskRunStatusTone(status) {
             return normalizeTaskStatusTone(status);
         },
@@ -190,6 +224,7 @@ export function createTaskOrchestrationMethods(options = {}) {
                 state.plan = res && res.plan ? res.plan : null;
                 state.planIssues = Array.isArray(res && res.issues) ? res.issues : [];
                 state.planWarnings = Array.isArray(res && res.warnings) ? res.warnings : [];
+                state.planFingerprint = state.plan ? this.buildTaskOrchestrationFingerprint() : '';
                 if (res && res.error) {
                     if (!options.silent) {
                         this.showMessage(res.error, 'error');
@@ -246,7 +281,7 @@ export function createTaskOrchestrationMethods(options = {}) {
             }
         },
 
-        async addTaskOrchestrationToQueue() {
+        async addTaskOrchestrationToQueue(options = {}) {
             const state = this.ensureTaskOrchestrationState();
             if (state.queueAdding) {
                 return null;
@@ -255,21 +290,72 @@ export function createTaskOrchestrationMethods(options = {}) {
             try {
                 const res = await api('task-queue-add', this.buildTaskOrchestrationRequest());
                 if (res && res.error) {
-                    this.showMessage(res.error, 'error');
+                    if (!options.silent) {
+                        this.showMessage(res.error, 'error');
+                    }
                     return res;
                 }
-                await this.loadTaskOrchestrationOverview({ silent: true, includeDetail: false });
-                this.showMessage(`已加入队列: ${res && res.task ? res.task.taskId : ''}`.trim(), 'success');
+                if (!options.deferRefresh) {
+                    await this.loadTaskOrchestrationOverview({ silent: true, includeDetail: false });
+                }
+                if (!options.silent) {
+                    this.showMessage(`已加入队列: ${res && res.task ? res.task.taskId : ''}`.trim(), 'success');
+                }
                 return res;
             } catch (error) {
                 const message = error && error.message ? error.message : '加入队列失败';
-                this.showMessage(message, 'error');
+                if (!options.silent) {
+                    this.showMessage(message, 'error');
+                }
                 return { error: message };
             } finally {
                 state.queueAdding = false;
             }
         },
 
+        async planAndRunTaskOrchestration() {
+            const state = this.ensureTaskOrchestrationState();
+            if (state.running || state.planning) {
+                return null;
+            }
+            if (!String(state.target || '').trim()) {
+                return null;
+            }
+            if (buildRunModeFlags(state.runMode).dryRun) {
+                return this.previewTaskPlan({ silent: false });
+            }
+            const fingerprint = this.buildTaskOrchestrationFingerprint();
+            const shouldPreview = !state.plan || state.planFingerprint !== fingerprint;
+            if (shouldPreview) {
+                const preview = await this.previewTaskPlan({ silent: true });
+                if (preview && preview.error) {
+                    this.showMessage(preview.error, 'error');
+                    return preview;
+                }
+            }
+            if (state.planIssues && state.planIssues.length) {
+                this.showMessage('计划存在问题，请先修复再执行', 'error');
+                return { error: 'Plan has blocking issues' };
+            }
+            return this.runTaskOrchestration();
+        },
+
+        async queueTaskOrchestrationAndStart() {
+            const state = this.ensureTaskOrchestrationState();
+            if (state.queueAdding || state.queueStarting || state.planning || state.running) {
+                return null;
+            }
+            if (!String(state.target || '').trim()) {
+                return null;
+            }
+            const queued = await this.addTaskOrchestrationToQueue({ silent: true, deferRefresh: true });
+            if (queued && queued.error) {
+                this.showMessage(queued.error, 'error');
+                return queued;
+            }
+            return this.startTaskQueueRunner();
+        },
+
         async startTaskQueueRunner() {
             const state = this.ensureTaskOrchestrationState();
             if (state.queueStarting) {
@@ -457,8 +543,7 @@ export function createTaskOrchestrationMethods(options = {}) {
             state.followUpsText = '';
             state.workflowIdsText = '';
             state.selectedEngine = 'codex';
-            state.allowWrite = false;
-            state.dryRun = false;
+            state.runMode = 'write';
             state.concurrency = 2;
             state.autoFixRounds = 1;
             state.plan = null;

package/web-ui/modules/config-mode.computed.mjs

@@ -47,6 +47,7 @@ export function createConfigModeComputed() {
             return `${this.activeProviderModeLabel} 当前复用 Codex Provider / Model 管理链路。`;
         },
         inspectorMainTabLabel() {
+            if (this.mainTab === 'dashboard') return '概览';
             if (this.mainTab === 'config') return '配置中心';
             if (this.mainTab === 'sessions') return '会话浏览';
             if (this.mainTab === 'usage') return 'Usage';
@@ -56,7 +57,6 @@ export function createConfigModeComputed() {
             return '未知';
         },
         inspectorConfigModeLabel() {
-            if (this.mainTab !== 'config') return '--';
             const providerMeta = getProviderConfigModeMeta(this.configMode);
             if (providerMeta) return providerMeta.label;
             if (this.configMode === 'claude') return 'Claude Code';
@@ -64,7 +64,6 @@ export function createConfigModeComputed() {
             return '未选择';
         },
         inspectorCurrentConfigLabel() {
-            if (this.mainTab !== 'config') return '--';
             if (getProviderConfigModeMeta(this.configMode)) {
                 const provider = typeof this.currentProvider === 'string' ? this.currentProvider.trim() : '';
                 return provider || '未选择';
@@ -80,7 +79,6 @@ export function createConfigModeComputed() {
             return '未选择';
         },
         inspectorCurrentModelLabel() {
-            if (this.mainTab !== 'config') return '--';
             if (getProviderConfigModeMeta(this.configMode)) {
                 const model = typeof this.currentModel === 'string' ? this.currentModel.trim() : '';
                 return model || '未选择';