codexmate 0.0.4 → 0.0.6

package/cli.js

@@ -2,34 +2,39 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const toml = require('@iarna/toml');
-const JSON5 = require('json5');
+const crypto = require('crypto');
+const toml = require('@iarna/toml');
+const JSON5 = require('json5');
+const zipLib = require('zip-lib');
 const { exec, execSync } = require('child_process');
 const http = require('http');
 const https = require('https');
 const readline = require('readline');
 
-const PORT = 3737;
+const DEFAULT_WEB_PORT = 3737;
+const DEFAULT_WEB_HOST = '127.0.0.1';
 
 // ============================================================================
 // 配置
 // ============================================================================
-const CONFIG_DIR = path.join(os.homedir(), '.codex');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.toml');
-const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
-const MODELS_FILE = path.join(CONFIG_DIR, 'models.json');
-const CURRENT_MODELS_FILE = path.join(CONFIG_DIR, 'provider-current-models.json');
-const INIT_MARK_FILE = path.join(CONFIG_DIR, 'codexmate-init.json');
-const CODEX_SESSIONS_DIR = path.join(CONFIG_DIR, 'sessions');
-const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw');
-const OPENCLAW_CONFIG_FILE = path.join(OPENCLAW_DIR, 'openclaw.json');
-const OPENCLAW_WORKSPACE_DIR = path.join(OPENCLAW_DIR, 'workspace');
-const CLAUDE_DIR = path.join(os.homedir(), '.claude');
-const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
-const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const CONFIG_DIR = path.join(os.homedir(), '.codex');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.toml');
+const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
+const MODELS_FILE = path.join(CONFIG_DIR, 'models.json');
+const CURRENT_MODELS_FILE = path.join(CONFIG_DIR, 'provider-current-models.json');
+const INIT_MARK_FILE = path.join(CONFIG_DIR, 'codexmate-init.json');
+const CODEX_SESSIONS_DIR = path.join(CONFIG_DIR, 'sessions');
+const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw');
+const OPENCLAW_CONFIG_FILE = path.join(OPENCLAW_DIR, 'openclaw.json');
+const OPENCLAW_WORKSPACE_DIR = path.join(OPENCLAW_DIR, 'workspace');
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const RECENT_CONFIGS_FILE = path.join(CONFIG_DIR, 'recent-configs.json');
 
 const DEFAULT_MODELS = ['gpt-5.3-codex', 'gpt-5.1-codex-max', 'gpt-4-turbo', 'gpt-4'];
 const SPEED_TEST_TIMEOUT_MS = 8000;
+const HEALTH_CHECK_TIMEOUT_MS = 6000;
 const MAX_SESSION_LIST_SIZE = 300;
 const MAX_EXPORT_MESSAGES = 1000;
 const DEFAULT_SESSION_DETAIL_MESSAGES = 300;
@@ -38,13 +43,18 @@ const SESSION_TITLE_READ_BYTES = 64 * 1024;
 const CODEXMATE_MANAGED_MARKER = '# codexmate-managed: true';
 const SESSION_LIST_CACHE_TTL_MS = 4000;
 const SESSION_SUMMARY_READ_BYTES = 256 * 1024;
-const SESSION_CONTENT_READ_BYTES = SESSION_SUMMARY_READ_BYTES;
-const DEFAULT_CONTENT_SCAN_LIMIT = 10;
+const SESSION_CONTENT_READ_BYTES = SESSION_SUMMARY_READ_BYTES;
+const DEFAULT_CONTENT_SCAN_LIMIT = 10;
 const SESSION_SCAN_FACTOR = 4;
 const SESSION_SCAN_MIN_FILES = 800;
 const MAX_SESSION_PATH_LIST_SIZE = 2000;
 const AGENTS_FILE_NAME = 'AGENTS.md';
 const UTF8_BOM = '\ufeff';
+const MODELS_CACHE_TTL_MS = 60 * 1000;
+const MODELS_NEGATIVE_CACHE_TTL_MS = 5 * 1000;
+const MODELS_CACHE_MAX_ENTRIES = 50;
+const MODELS_RESPONSE_MAX_BYTES = 1024 * 1024;
+const MAX_RECENT_CONFIGS = 3;
 const BOOTSTRAP_TEXT_MARKERS = [
     'agents.md instructions',
     '<instructions>',
@@ -53,6 +63,29 @@ const BOOTSTRAP_TEXT_MARKERS = [
     'codex cli'
 ];
 
+const HTTP_KEEP_ALIVE_AGENT = new http.Agent({ keepAlive: true });
+const HTTPS_KEEP_ALIVE_AGENT = new https.Agent({ keepAlive: true });
+
+function resolveWebPort() {
+    const raw = process.env.CODEXMATE_PORT;
+    if (!raw) return DEFAULT_WEB_PORT;
+    const parsed = parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_WEB_PORT;
+    return parsed;
+}
+
+function resolveWebHost(options = {}) {
+    const optionHost = typeof options.host === 'string' ? options.host.trim() : '';
+    if (optionHost) {
+        return optionHost;
+    }
+    const envHost = typeof process.env.CODEXMATE_HOST === 'string' ? process.env.CODEXMATE_HOST.trim() : '';
+    if (envHost) {
+        return envHost;
+    }
+    return DEFAULT_WEB_HOST;
+}
+
 const EMPTY_CONFIG_FALLBACK_TEMPLATE = `model = "gpt-5.3-codex"
 model_reasoning_effort = "high"
 disable_response_storage = true
@@ -75,6 +108,8 @@ stream_idle_timeout_ms = 300000
 
 let g_initNotice = '';
 let g_sessionListCache = new Map();
+let g_modelsCache = new Map();
+let g_modelsInFlight = new Map();
 
 // ============================================================================
 // 工具函数
@@ -154,12 +189,88 @@ function readJsonFile(filePath, fallback = null) {
     }
 }
 
+function readJsonArrayFile(filePath, fallback = []) {
+    if (!fs.existsSync(filePath)) {
+        return Array.isArray(fallback) ? [...fallback] : [];
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (!content.trim()) {
+            return Array.isArray(fallback) ? [...fallback] : [];
+        }
+        const parsed = JSON.parse(content);
+        return Array.isArray(parsed) ? parsed : (Array.isArray(fallback) ? [...fallback] : []);
+    } catch (e) {
+        return Array.isArray(fallback) ? [...fallback] : [];
+    }
+}
+
 function ensureDir(dirPath) {
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
 }
 
+function expandHomePath(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return '';
+    }
+    if (trimmed === '~') {
+        return os.homedir();
+    }
+    if (trimmed.startsWith(`~${path.sep}`) || trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+        return path.resolve(os.homedir(), trimmed.slice(2));
+    }
+    return trimmed;
+}
+
+function resolveExistingDir(candidates = [], fallback = '') {
+    for (const raw of candidates) {
+        const candidate = expandHomePath(raw);
+        if (!candidate) continue;
+        try {
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+                return candidate;
+            }
+        } catch (e) {}
+    }
+    return fallback;
+}
+
+function getCodexSessionsDir() {
+    const candidates = [];
+    const envCodexHome = process.env.CODEX_HOME;
+    if (envCodexHome) {
+        candidates.push(path.join(envCodexHome, 'sessions'));
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    if (xdgConfig) {
+        candidates.push(path.join(xdgConfig, 'codex', 'sessions'));
+    }
+    candidates.push(path.join(os.homedir(), '.config', 'codex', 'sessions'));
+    candidates.push(CODEX_SESSIONS_DIR);
+    return resolveExistingDir(candidates, CODEX_SESSIONS_DIR);
+}
+
+function getClaudeProjectsDir() {
+    const candidates = [];
+    const envClaudeHome = process.env.CLAUDE_HOME || process.env.CLAUDE_CONFIG_DIR;
+    if (envClaudeHome) {
+        candidates.push(path.join(envClaudeHome, 'projects'));
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    if (xdgConfig) {
+        candidates.push(path.join(xdgConfig, 'claude', 'projects'));
+    }
+    candidates.push(path.join(os.homedir(), '.config', 'claude', 'projects'));
+    candidates.push(CLAUDE_PROJECTS_DIR);
+    return resolveExistingDir(candidates, CLAUDE_PROJECTS_DIR);
+}
+
 function hasUtf8Bom(text) {
     return typeof text === 'string' && text.charCodeAt(0) === 0xfeff;
 }
@@ -183,6 +294,239 @@ function normalizeLineEnding(text, lineEnding) {
     return lineEnding === '\r\n' ? normalized.replace(/\n/g, '\r\n') : normalized;
 }
 
+function isValidProviderName(name) {
+    return typeof name === 'string' && /^[a-zA-Z0-9._-]+$/.test(name.trim());
+}
+
+function buildModelsCandidates(baseUrl) {
+    const trimmed = typeof baseUrl === 'string' ? baseUrl.trim() : '';
+    if (!trimmed) return [];
+    if (/\/models\/?$/.test(trimmed)) {
+        return [trimmed];
+    }
+    const normalized = trimmed.replace(/\/+$/, '');
+    const candidates = [];
+    const pushUnique = (url) => {
+        if (url && !candidates.includes(url)) {
+            candidates.push(url);
+        }
+    };
+
+    if (/\/v1$/i.test(normalized)) {
+        pushUnique(normalized + '/models');
+    } else {
+        pushUnique(normalized + '/v1/models');
+        pushUnique(normalized + '/models');
+    }
+
+    pushUnique(trimmed);
+    return candidates;
+}
+
+function extractModelNames(payload) {
+    if (!payload || typeof payload !== 'object') return [];
+    const data = Array.isArray(payload.data)
+        ? payload.data
+        : (Array.isArray(payload.models) ? payload.models : []);
+    const names = [];
+    for (const item of data) {
+        if (typeof item === 'string') {
+            if (item.trim()) names.push(item.trim());
+            continue;
+        }
+        if (!item || typeof item !== 'object') continue;
+        const name = item.id || item.name || item.model || '';
+        if (typeof name === 'string' && name.trim()) {
+            names.push(name.trim());
+        }
+    }
+    return Array.from(new Set(names));
+}
+
+function hasModelsListPayload(payload) {
+    if (!payload || typeof payload !== 'object') return false;
+    return Array.isArray(payload.data) || Array.isArray(payload.models);
+}
+
+function hashModelsCacheValue(value) {
+    if (!value) return '';
+    try {
+        return crypto.createHash('sha256').update(String(value)).digest('hex');
+    } catch (e) {
+        return '';
+    }
+}
+
+function buildModelsCacheKey(baseUrl, apiKey) {
+    const normalizedUrl = typeof baseUrl === 'string'
+        ? baseUrl.trim().replace(/\/+$/, '')
+        : '';
+    const apiKeyHash = hashModelsCacheValue(apiKey);
+    return `${normalizedUrl}|${apiKeyHash}`;
+}
+
+function readModelsCacheEntry(cacheKey) {
+    if (!cacheKey) return null;
+    const entry = g_modelsCache.get(cacheKey);
+    if (!entry) return null;
+    if (Date.now() >= entry.expiresAt) {
+        g_modelsCache.delete(cacheKey);
+        return null;
+    }
+    g_modelsCache.delete(cacheKey);
+    g_modelsCache.set(cacheKey, entry);
+    return entry.result || null;
+}
+
+function writeModelsCacheEntry(cacheKey, result) {
+    if (!cacheKey) return;
+    const isNegative = !!(result && (result.error || result.unlimited));
+    const ttl = isNegative ? MODELS_NEGATIVE_CACHE_TTL_MS : MODELS_CACHE_TTL_MS;
+    const entry = {
+        result,
+        expiresAt: Date.now() + ttl
+    };
+    if (g_modelsCache.has(cacheKey)) {
+        g_modelsCache.delete(cacheKey);
+    }
+    g_modelsCache.set(cacheKey, entry);
+    while (g_modelsCache.size > MODELS_CACHE_MAX_ENTRIES) {
+        const oldestKey = g_modelsCache.keys().next().value;
+        g_modelsCache.delete(oldestKey);
+    }
+}
+
+async function fetchModelsFromBaseUrl(baseUrl, apiKey) {
+    const cacheKey = buildModelsCacheKey(baseUrl, apiKey);
+    const cached = readModelsCacheEntry(cacheKey);
+    if (cached) return cached;
+
+    const inFlight = g_modelsInFlight.get(cacheKey);
+    if (inFlight) return inFlight;
+
+    const promise = (async () => {
+        const result = await fetchModelsFromBaseUrlCore(baseUrl, apiKey);
+        writeModelsCacheEntry(cacheKey, result);
+        return result;
+    })();
+
+    g_modelsInFlight.set(cacheKey, promise);
+    promise.finally(() => {
+        g_modelsInFlight.delete(cacheKey);
+    });
+    return promise;
+}
+
+async function fetchModelsFromBaseUrlCore(baseUrl, apiKey) {
+    const candidates = buildModelsCandidates(baseUrl);
+    if (candidates.length === 0) return { error: 'Provider missing URL' };
+
+    let lastError = '';
+    for (const modelsUrl of candidates) {
+        let parsed;
+        try {
+            parsed = new URL(modelsUrl);
+        } catch (e) {
+            lastError = 'Invalid URL';
+            continue;
+        }
+
+        const transport = parsed.protocol === 'https:' ? https : http;
+        const agent = parsed.protocol === 'https:' ? HTTPS_KEEP_ALIVE_AGENT : HTTP_KEEP_ALIVE_AGENT;
+        const headers = {
+            'User-Agent': 'codexmate-models',
+            'Accept': 'application/json'
+        };
+        if (apiKey) {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+
+        const result = await new Promise((innerResolve) => {
+            let settled = false;
+            const finish = (payload) => {
+                if (settled) return;
+                settled = true;
+                innerResolve(payload);
+            };
+            const req = transport.request(parsed, { method: 'GET', headers, agent }, (res) => {
+                const status = res.statusCode || 0;
+                const contentType = String(res.headers['content-type'] || '').toLowerCase();
+                if (status === 404 || status === 405 || status === 501) {
+                    res.resume();
+                    return finish({ unavailable: true });
+                }
+                let body = '';
+                let receivedBytes = 0;
+                res.on('data', chunk => {
+                    receivedBytes += chunk.length || 0;
+                    if (receivedBytes > MODELS_RESPONSE_MAX_BYTES) {
+                        res.destroy();
+                        return finish({ unavailable: true });
+                    }
+                    body += chunk;
+                });
+                res.on('end', () => {
+                    if (settled) return;
+                    if (status >= 400) {
+                        return finish({ error: `Request failed: ${status}` });
+                    }
+                    if (contentType && !contentType.includes('application/json')) {
+                        return finish({ unavailable: true });
+                    }
+                    try {
+                        const payload = JSON.parse(body || '{}');
+                        if (!hasModelsListPayload(payload)) {
+                            return finish({ unavailable: true });
+                        }
+                        const models = extractModelNames(payload);
+                        return finish({ models });
+                    } catch (e) {
+                        return finish({ unavailable: true });
+                    }
+                });
+            });
+
+            req.setTimeout(SPEED_TEST_TIMEOUT_MS, () => {
+                req.destroy(new Error('timeout'));
+            });
+            req.on('error', (err) => {
+                finish({ error: err.message || 'Request failed' });
+            });
+            req.end();
+        });
+
+        if (result && Array.isArray(result.models)) {
+            return { models: result.models };
+        }
+        if (result && result.error) {
+            lastError = result.error;
+            continue;
+        }
+    }
+
+    if (lastError) {
+        return { error: lastError };
+    }
+    return { unlimited: true };
+}
+
+async function fetchProviderModels(providerName, overrides = {}) {
+    const { config } = readConfigOrVirtualDefault();
+    const targetProvider = providerName || config.model_provider || '';
+    if (!targetProvider) return { error: '未设置当前提供商' };
+
+    const providers = config.model_providers || {};
+    const provider = providers[targetProvider];
+    if (!provider) return { error: `提供商不存在: ${targetProvider}` };
+
+    const baseUrl = overrides.baseUrl || provider.base_url || '';
+    const apiKey = overrides.apiKey ?? provider.preferred_auth_method ?? '';
+    const res = await fetchModelsFromBaseUrl(baseUrl, apiKey);
+    if (res.unlimited) return { models: [], provider: targetProvider, unlimited: true };
+    if (res.error) return { error: res.error };
+    return { models: res.models || [], provider: targetProvider, unlimited: false };
+}
+
 function resolveAgentsFilePath(params = {}) {
     const baseDir = typeof params.baseDir === 'string' && params.baseDir.trim()
         ? params.baseDir.trim()
@@ -232,11 +576,11 @@ function readAgentsFile(params = {}) {
     }
 }
 
-function applyAgentsFile(params = {}) {
-    const filePath = resolveAgentsFilePath(params);
-    const dirCheck = validateAgentsBaseDir(filePath);
-    if (dirCheck.error) {
-        return { error: dirCheck.error };
+function applyAgentsFile(params = {}) {
+    const filePath = resolveAgentsFilePath(params);
+    const dirCheck = validateAgentsBaseDir(filePath);
+    if (dirCheck.error) {
+        return { error: dirCheck.error };
     }
 
     const content = typeof params.content === 'string' ? params.content : '';
@@ -247,241 +591,971 @@ function applyAgentsFile(params = {}) {
     try {
         fs.writeFileSync(filePath, finalContent, 'utf-8');
         return { success: true, path: filePath };
-    } catch (e) {
-        return { error: `写入 AGENTS.md 失败: ${e.message}` };
-    }
-}
-
-function resolveHomePath(input) {
-    const raw = typeof input === 'string' ? input.trim() : '';
-    if (!raw) return '';
-    if (raw === '~') return os.homedir();
-    if (raw.startsWith('~/') || raw.startsWith('~\\')) {
-        return path.join(os.homedir(), raw.slice(2));
-    }
-    return raw;
-}
-
-function resolveOpenclawWorkspaceDir(config) {
-    const workspace = config
-        && config.agents
-        && config.agents.defaults
-        && typeof config.agents.defaults.workspace === 'string'
-        ? config.agents.defaults.workspace
-        : '';
-    const resolved = resolveHomePath(workspace);
-    if (!resolved) {
-        return OPENCLAW_WORKSPACE_DIR;
-    }
-    if (path.isAbsolute(resolved)) {
-        return resolved;
-    }
-    return path.join(OPENCLAW_DIR, resolved);
-}
-
-function readOpenclawConfigFile() {
-    const filePath = OPENCLAW_CONFIG_FILE;
-    if (!fs.existsSync(filePath)) {
-        return {
-            exists: false,
-            path: filePath,
-            content: '',
-            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n'
-        };
-    }
-
-    try {
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        return {
-            exists: true,
-            path: filePath,
-            content: stripUtf8Bom(raw),
-            lineEnding: detectLineEnding(raw)
-        };
-    } catch (e) {
-        return { error: `读取 OpenClaw 配置失败: ${e.message}` };
-    }
-}
-
-function parseOpenclawConfigText(content) {
-    const raw = stripUtf8Bom(typeof content === 'string' ? content : '');
-    if (!raw.trim()) {
-        return { ok: false, error: 'OpenClaw 配置内容不能为空' };
-    }
-    try {
-        const parsed = JSON5.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return { ok: false, error: '配置格式错误（根节点必须是对象）' };
-        }
-        return { ok: true, data: parsed };
-    } catch (e) {
-        return { ok: false, error: `配置解析失败: ${e.message}` };
-    }
-}
-
-function getOpenclawWorkspaceInfo() {
-    const readResult = readOpenclawConfigFile();
-    let workspaceDir = OPENCLAW_WORKSPACE_DIR;
-    let configError = readResult.error || '';
-    if (!configError && readResult.exists && readResult.content.trim()) {
-        const parsed = parseOpenclawConfigText(readResult.content);
-        if (parsed.ok) {
-            workspaceDir = resolveOpenclawWorkspaceDir(parsed.data);
-        } else {
-            configError = parsed.error || '';
-        }
-    }
-    return {
-        workspaceDir,
-        configError,
-        configPath: readResult.path || OPENCLAW_CONFIG_FILE
-    };
-}
-
-function readOpenclawAgentsFile() {
-    const workspaceInfo = getOpenclawWorkspaceInfo();
-    const baseDir = workspaceInfo.workspaceDir;
-    const filePath = path.join(baseDir, AGENTS_FILE_NAME);
-
-    if (!fs.existsSync(baseDir)) {
-        return {
-            exists: false,
-            path: filePath,
-            content: '',
-            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n',
-            workspaceDir: baseDir,
-            configError: workspaceInfo.configError,
-            baseDirMissing: true
-        };
-    }
-
-    const readResult = readAgentsFile({ baseDir });
-    return {
-        ...readResult,
-        workspaceDir: baseDir,
-        configError: workspaceInfo.configError
-    };
-}
-
-function applyOpenclawAgentsFile(params = {}) {
-    const workspaceInfo = getOpenclawWorkspaceInfo();
-    const baseDir = workspaceInfo.workspaceDir;
-    ensureDir(baseDir);
-    const result = applyAgentsFile({
-        ...params,
-        baseDir
-    });
-    return {
-        ...result,
-        workspaceDir: baseDir,
-        configError: workspaceInfo.configError
-    };
-}
-
-function applyOpenclawConfig(params = {}) {
-    const content = typeof params.content === 'string' ? params.content : '';
-    const lineEnding = params.lineEnding === '\r\n' ? '\r\n' : '\n';
-    const normalized = normalizeLineEnding(content, lineEnding);
-    const parsed = parseOpenclawConfigText(normalized);
-    if (!parsed.ok) {
-        return { success: false, error: parsed.error };
-    }
-
-    try {
-        ensureDir(OPENCLAW_DIR);
-        const backupPath = backupFileIfNeededOnce(OPENCLAW_CONFIG_FILE);
-        fs.writeFileSync(OPENCLAW_CONFIG_FILE, normalized, 'utf-8');
-        const result = {
-            success: true,
-            targetPath: OPENCLAW_CONFIG_FILE
-        };
-        if (backupPath) {
-            result.backupPath = backupPath;
-        }
-        return result;
-    } catch (e) {
-        return {
-            success: false,
-            error: e.message || '写入 OpenClaw 配置失败'
-        };
-    }
-}
+    } catch (e) {
+        return { error: `写入 AGENTS.md 失败: ${e.message}` };
+    }
+}
 
-function readJsonObjectFromFile(filePath, fallback = {}) {
+function resolveHomePath(input) {
+    const raw = typeof input === 'string' ? input.trim() : '';
+    if (!raw) return '';
+    if (raw === '~') return os.homedir();
+    if (raw.startsWith('~/') || raw.startsWith('~\\')) {
+        return path.join(os.homedir(), raw.slice(2));
+    }
+    return raw;
+}
+
+function resolveOpenclawWorkspaceDir(config) {
+    const workspace = config
+        && config.agents
+        && config.agents.defaults
+        && typeof config.agents.defaults.workspace === 'string'
+        ? config.agents.defaults.workspace
+        : '';
+    const resolved = resolveHomePath(workspace);
+    if (!resolved) {
+        return OPENCLAW_WORKSPACE_DIR;
+    }
+    if (path.isAbsolute(resolved)) {
+        return resolved;
+    }
+    return path.join(OPENCLAW_DIR, resolved);
+}
+
+function normalizeOpenclawWorkspaceFileName(input) {
+    const raw = typeof input === 'string' ? input.trim() : '';
+    if (!raw) {
+        return { error: '文件名不能为空' };
+    }
+    if (raw.includes('\0')) {
+        return { error: '文件名非法' };
+    }
+    if (raw.includes('/') || raw.includes('\\') || raw.includes('..')) {
+        return { error: '文件名非法' };
+    }
+    const baseName = path.basename(raw);
+    if (baseName !== raw) {
+        return { error: '文件名非法' };
+    }
+    if (!raw.toLowerCase().endsWith('.md')) {
+        return { error: '仅支持 .md 文件' };
+    }
+    return { ok: true, name: raw };
+}
+
+function readOpenclawConfigFile() {
+    const filePath = OPENCLAW_CONFIG_FILE;
     if (!fs.existsSync(filePath)) {
-        return { ok: true, exists: false, data: { ...fallback } };
+        return {
+            exists: false,
+            path: filePath,
+            content: '',
+            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n'
+        };
     }
 
     try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        if (!content.trim()) {
-            return { ok: true, exists: true, data: { ...fallback } };
-        }
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return {
+            exists: true,
+            path: filePath,
+            content: stripUtf8Bom(raw),
+            lineEnding: detectLineEnding(raw)
+        };
+    } catch (e) {
+        return { error: `读取 OpenClaw 配置失败: ${e.message}` };
+    }
+}
 
-        const parsed = JSON.parse(content);
+function parseOpenclawConfigText(content) {
+    const raw = stripUtf8Bom(typeof content === 'string' ? content : '');
+    if (!raw.trim()) {
+        return { ok: false, error: 'OpenClaw 配置内容不能为空' };
+    }
+    try {
+        const parsed = JSON5.parse(raw);
         if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return {
-                ok: false,
-                exists: true,
-                error: `配置文件格式错误（根节点必须是对象）: ${filePath}`
-            };
+            return { ok: false, error: '配置格式错误（根节点必须是对象）' };
         }
-        return { ok: true, exists: true, data: parsed };
+        return { ok: true, data: parsed };
     } catch (e) {
+        return { ok: false, error: `配置解析失败: ${e.message}` };
+    }
+}
+
+function getOpenclawWorkspaceInfo() {
+    const readResult = readOpenclawConfigFile();
+    let workspaceDir = OPENCLAW_WORKSPACE_DIR;
+    let configError = readResult.error || '';
+    if (!configError && readResult.exists && readResult.content.trim()) {
+        const parsed = parseOpenclawConfigText(readResult.content);
+        if (parsed.ok) {
+            workspaceDir = resolveOpenclawWorkspaceDir(parsed.data);
+        } else {
+            configError = parsed.error || '';
+        }
+    }
+    return {
+        workspaceDir,
+        configError,
+        configPath: readResult.path || OPENCLAW_CONFIG_FILE
+    };
+}
+
+function readOpenclawAgentsFile() {
+    const workspaceInfo = getOpenclawWorkspaceInfo();
+    const baseDir = workspaceInfo.workspaceDir;
+    const filePath = path.join(baseDir, AGENTS_FILE_NAME);
+
+    if (!fs.existsSync(baseDir)) {
         return {
-            ok: false,
-            exists: true,
-            error: `配置文件解析失败: ${e.message}`
+            exists: false,
+            path: filePath,
+            content: '',
+            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n',
+            workspaceDir: baseDir,
+            configError: workspaceInfo.configError,
+            baseDirMissing: true
+        };
+    }
+
+    const readResult = readAgentsFile({ baseDir });
+    return {
+        ...readResult,
+        workspaceDir: baseDir,
+        configError: workspaceInfo.configError
+    };
+}
+
+function applyOpenclawAgentsFile(params = {}) {
+    const workspaceInfo = getOpenclawWorkspaceInfo();
+    const baseDir = workspaceInfo.workspaceDir;
+    ensureDir(baseDir);
+    const result = applyAgentsFile({
+        ...params,
+        baseDir
+    });
+    return {
+        ...result,
+        workspaceDir: baseDir,
+        configError: workspaceInfo.configError
+    };
+}
+
+function readOpenclawWorkspaceFile(params = {}) {
+    const nameResult = normalizeOpenclawWorkspaceFileName(params.fileName);
+    if (nameResult.error) {
+        return { error: nameResult.error };
+    }
+    const workspaceInfo = getOpenclawWorkspaceInfo();
+    const baseDir = workspaceInfo.workspaceDir;
+    const filePath = path.join(baseDir, nameResult.name);
+
+    if (!fs.existsSync(baseDir)) {
+        return {
+            exists: false,
+            path: filePath,
+            content: '',
+            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n',
+            workspaceDir: baseDir,
+            configError: workspaceInfo.configError,
+            baseDirMissing: true
+        };
+    }
+
+    if (!fs.existsSync(filePath)) {
+        return {
+            exists: false,
+            path: filePath,
+            content: '',
+            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n',
+            workspaceDir: baseDir,
+            configError: workspaceInfo.configError
+        };
+    }
+
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return {
+            exists: true,
+            path: filePath,
+            content: stripUtf8Bom(raw),
+            lineEnding: detectLineEnding(raw),
+            workspaceDir: baseDir,
+            configError: workspaceInfo.configError
+        };
+    } catch (e) {
+        return { error: `读取 OpenClaw 工作区文件失败: ${e.message}` };
+    }
+}
+
+function applyOpenclawWorkspaceFile(params = {}) {
+    const nameResult = normalizeOpenclawWorkspaceFileName(params.fileName);
+    if (nameResult.error) {
+        return { error: nameResult.error };
+    }
+    const workspaceInfo = getOpenclawWorkspaceInfo();
+    const baseDir = workspaceInfo.workspaceDir;
+    ensureDir(baseDir);
+
+    const content = typeof params.content === 'string' ? params.content : '';
+    const lineEnding = params.lineEnding === '\r\n' ? '\r\n' : '\n';
+    const normalized = normalizeLineEnding(content, lineEnding);
+    const finalContent = ensureUtf8Bom(normalized);
+    const filePath = path.join(baseDir, nameResult.name);
+
+    try {
+        fs.writeFileSync(filePath, finalContent, 'utf-8');
+        return {
+            success: true,
+            path: filePath,
+            workspaceDir: baseDir,
+            configError: workspaceInfo.configError
+        };
+    } catch (e) {
+        return { error: `写入 OpenClaw 工作区文件失败: ${e.message}` };
+    }
+}
+
+function applyOpenclawConfig(params = {}) {
+    const content = typeof params.content === 'string' ? params.content : '';
+    const lineEnding = params.lineEnding === '\r\n' ? '\r\n' : '\n';
+    const normalized = normalizeLineEnding(content, lineEnding);
+    const parsed = parseOpenclawConfigText(normalized);
+    if (!parsed.ok) {
+        return { success: false, error: parsed.error };
+    }
+
+    try {
+        ensureDir(OPENCLAW_DIR);
+        const backupPath = backupFileIfNeededOnce(OPENCLAW_CONFIG_FILE);
+        fs.writeFileSync(OPENCLAW_CONFIG_FILE, normalized, 'utf-8');
+        const result = {
+            success: true,
+            targetPath: OPENCLAW_CONFIG_FILE
+        };
+        if (backupPath) {
+            result.backupPath = backupPath;
+        }
+        return result;
+    } catch (e) {
+        return {
+            success: false,
+            error: e.message || '写入 OpenClaw 配置失败'
+        };
+    }
+}
+
+function readJsonObjectFromFile(filePath, fallback = {}) {
+    if (!fs.existsSync(filePath)) {
+        return { ok: true, exists: false, data: { ...fallback } };
+    }
+
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (!content.trim()) {
+            return { ok: true, exists: true, data: { ...fallback } };
+        }
+
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return {
+                ok: false,
+                exists: true,
+                error: `配置文件格式错误（根节点必须是对象）: ${filePath}`
+            };
+        }
+        return { ok: true, exists: true, data: parsed };
+    } catch (e) {
+        return {
+            ok: false,
+            exists: true,
+            error: `配置文件解析失败: ${e.message}`
+        };
+    }
+}
+
+function backupFileIfNeededOnce(filePath, backupPrefix = 'codexmate-backup') {
+    if (!fs.existsSync(filePath)) {
+        return '';
+    }
+
+    const dirPath = path.dirname(filePath);
+    const baseName = path.basename(filePath);
+    const existingPrefix = `${baseName}.${backupPrefix}-`;
+    const hasBackup = fs.readdirSync(dirPath).some(fileName =>
+        fileName.startsWith(existingPrefix) && fileName.endsWith('.bak')
+    );
+
+    if (hasBackup) {
+        return '';
+    }
+
+    const backupPath = path.join(dirPath, `${existingPrefix}${formatTimestampForFileName()}.bak`);
+    fs.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+
+function writeJsonAtomic(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    ensureDir(dirPath);
+
+    const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    const content = `${JSON.stringify(data, null, 2)}\n`;
+
+    try {
+        fs.writeFileSync(tmpPath, content, 'utf-8');
+        try {
+            fs.renameSync(tmpPath, filePath);
+        } catch (renameError) {
+            if (process.platform === 'win32') {
+                fs.copyFileSync(tmpPath, filePath);
+                fs.unlinkSync(tmpPath);
+            } else {
+                throw renameError;
+            }
+        }
+    } catch (e) {
+        if (fs.existsSync(tmpPath)) {
+            try { fs.unlinkSync(tmpPath); } catch (_) {}
+        }
+        throw new Error(`写入 JSON 文件失败: ${e.message}`);
+    }
+}
+
+function normalizeRecentConfigs(items) {
+    if (!Array.isArray(items)) return [];
+    const output = [];
+    const seen = new Set();
+    for (const item of items) {
+        if (!item || typeof item !== 'object') continue;
+        const provider = typeof item.provider === 'string' ? item.provider.trim() : '';
+        const model = typeof item.model === 'string' ? item.model.trim() : '';
+        if (!provider || !model) continue;
+        const key = `${provider}::${model}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        output.push({
+            provider,
+            model,
+            usedAt: typeof item.usedAt === 'string' ? item.usedAt : ''
+        });
+    }
+    return output;
+}
+
+function readRecentConfigs() {
+    return normalizeRecentConfigs(readJsonArrayFile(RECENT_CONFIGS_FILE, []));
+}
+
+function writeRecentConfigs(items) {
+    writeJsonAtomic(RECENT_CONFIGS_FILE, items);
+}
+
+function recordRecentConfig(provider, model) {
+    const providerName = typeof provider === 'string' ? provider.trim() : '';
+    const modelName = typeof model === 'string' ? model.trim() : '';
+    if (!providerName || !modelName) return;
+
+    const now = new Date().toISOString();
+    const current = readRecentConfigs();
+    const next = [{
+        provider: providerName,
+        model: modelName,
+        usedAt: now
+    }];
+
+    for (const item of current) {
+        if (item.provider === providerName && item.model === modelName) continue;
+        next.push(item);
+    }
+
+    const trimmed = next.slice(0, MAX_RECENT_CONFIGS);
+    writeRecentConfigs(trimmed);
+}
+
+function isValidHttpUrl(value) {
+    if (typeof value !== 'string' || !value.trim()) return false;
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    } catch (e) {
+        return false;
+    }
+}
+
+function normalizeBaseUrl(value) {
+    if (typeof value !== 'string') return '';
+    return value.trim().replace(/\/+$/g, '');
+}
+
+function joinApiUrl(baseUrl, pathSuffix) {
+    const trimmed = normalizeBaseUrl(baseUrl);
+    if (!trimmed) return '';
+    const safeSuffix = String(pathSuffix || '').replace(/^\/+/g, '');
+    if (!safeSuffix) return trimmed;
+    if (/\/v1$/i.test(trimmed)) {
+        return `${trimmed}/${safeSuffix}`;
+    }
+    return `${trimmed}/v1/${safeSuffix}`;
+}
+
+function buildModelsProbeUrl(baseUrl) {
+    return joinApiUrl(baseUrl, 'models');
+}
+
+function normalizeWireApi(value) {
+    const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (!raw) return 'responses';
+    return raw.replace(/[\s-]/g, '_');
+}
+
+function buildModelProbeSpec(provider, modelName, baseUrl) {
+    const model = typeof modelName === 'string' ? modelName.trim() : '';
+    if (!model) return null;
+
+    const wireApi = normalizeWireApi(provider && provider.wire_api);
+    if (wireApi === 'chat_completions' || wireApi === 'chat') {
+        return {
+            url: joinApiUrl(baseUrl, 'chat/completions'),
+            body: {
+                model,
+                messages: [{ role: 'user', content: 'ping' }],
+                max_tokens: 1,
+                temperature: 0
+            }
+        };
+    }
+
+    if (wireApi === 'completions') {
+        return {
+            url: joinApiUrl(baseUrl, 'completions'),
+            body: {
+                model,
+                prompt: 'ping',
+                max_tokens: 1,
+                temperature: 0
+            }
+        };
+    }
+
+    return {
+        url: joinApiUrl(baseUrl, 'responses'),
+        body: {
+            model,
+            input: 'ping',
+            max_output_tokens: 1
+        }
+    };
+}
+
+function probeUrl(targetUrl, options = {}) {
+    return new Promise((resolve) => {
+        let parsed;
+        try {
+            parsed = new URL(targetUrl);
+        } catch (e) {
+            return resolve({ ok: false, error: 'Invalid URL' });
+        }
+
+        const transport = parsed.protocol === 'https:' ? https : http;
+        const headers = {
+            'User-Agent': 'codexmate-health-check',
+            'Accept': 'application/json'
+        };
+        if (options.apiKey) {
+            headers['Authorization'] = `Bearer ${options.apiKey}`;
+        }
+
+        const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : HEALTH_CHECK_TIMEOUT_MS;
+        const maxBytes = Number.isFinite(options.maxBytes) ? options.maxBytes : 256 * 1024;
+        const start = Date.now();
+        const req = transport.request(parsed, { method: 'GET', headers }, (res) => {
+            const chunks = [];
+            let size = 0;
+            res.on('data', (chunk) => {
+                if (!chunk) return;
+                size += chunk.length;
+                if (size <= maxBytes) {
+                    chunks.push(chunk);
+                }
+            });
+            res.on('end', () => {
+                const body = chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : '';
+                resolve({
+                    ok: true,
+                    status: res.statusCode || 0,
+                    durationMs: Date.now() - start,
+                    body
+                });
+            });
+        });
+
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error('timeout'));
+        });
+
+        req.on('error', (err) => {
+            resolve({
+                ok: false,
+                error: err.message || 'request failed',
+                durationMs: Date.now() - start
+            });
+        });
+
+        req.end();
+    });
+}
+
+function probeJsonPost(targetUrl, body, options = {}) {
+    return new Promise((resolve) => {
+        let parsed;
+        try {
+            parsed = new URL(targetUrl);
+        } catch (e) {
+            return resolve({ ok: false, error: 'Invalid URL' });
+        }
+
+        const transport = parsed.protocol === 'https:' ? https : http;
+        const headers = {
+            'User-Agent': 'codexmate-health-check',
+            'Accept': 'application/json',
+            'Content-Type': 'application/json'
+        };
+        if (options.apiKey) {
+            headers['Authorization'] = `Bearer ${options.apiKey}`;
+        }
+
+        const payload = JSON.stringify(body || {});
+        headers['Content-Length'] = Buffer.byteLength(payload);
+
+        const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : HEALTH_CHECK_TIMEOUT_MS;
+        const maxBytes = Number.isFinite(options.maxBytes) ? options.maxBytes : 256 * 1024;
+        const start = Date.now();
+        const req = transport.request(parsed, { method: 'POST', headers }, (res) => {
+            const chunks = [];
+            let size = 0;
+            res.on('data', (chunk) => {
+                if (!chunk) return;
+                size += chunk.length;
+                if (size <= maxBytes) {
+                    chunks.push(chunk);
+                }
+            });
+            res.on('end', () => {
+                const bodyText = chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : '';
+                resolve({
+                    ok: true,
+                    status: res.statusCode || 0,
+                    durationMs: Date.now() - start,
+                    body: bodyText
+                });
+            });
+        });
+
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error('timeout'));
+        });
+
+        req.on('error', (err) => {
+            resolve({
+                ok: false,
+                error: err.message || 'request failed',
+                durationMs: Date.now() - start
+            });
+        });
+
+        req.write(payload);
+        req.end();
+    });
+}
+
+function extractModelIds(payload) {
+    const ids = [];
+    const pushValue = (value) => {
+        if (typeof value === 'string' && value.trim()) {
+            ids.push(value.trim());
+        }
+    };
+
+    if (!payload) return ids;
+
+    if (Array.isArray(payload)) {
+        for (const item of payload) {
+            if (item && typeof item === 'object') {
+                pushValue(item.id);
+                pushValue(item.model);
+                pushValue(item.name);
+            } else {
+                pushValue(item);
+            }
+        }
+        return ids;
+    }
+
+    if (Array.isArray(payload.data)) {
+        for (const item of payload.data) {
+            if (item && typeof item === 'object') {
+                pushValue(item.id);
+                pushValue(item.model);
+                pushValue(item.name);
+            } else {
+                pushValue(item);
+            }
+        }
+    }
+
+    if (Array.isArray(payload.models)) {
+        for (const item of payload.models) {
+            if (item && typeof item === 'object') {
+                pushValue(item.id);
+                pushValue(item.model);
+                pushValue(item.name);
+            } else {
+                pushValue(item);
+            }
+        }
+    }
+
+    return ids;
+}
+
+async function runRemoteHealthCheck(provider, modelName, options = {}) {
+    const issues = [];
+    const results = {};
+    const baseUrl = normalizeBaseUrl(provider && provider.base_url ? provider.base_url : '');
+    if (!baseUrl) {
+        issues.push({
+            code: 'remote-skip-base-url',
+            message: '无法进行远程探测：base_url 为空',
+            suggestion: '补全 base_url 或关闭远程探测'
+        });
+        return { issues, results };
+    }
+
+    const requiresAuth = provider && provider.requires_openai_auth !== false;
+    const apiKey = typeof provider.preferred_auth_method === 'string'
+        ? provider.preferred_auth_method.trim()
+        : '';
+    const authValue = requiresAuth ? apiKey : (apiKey || '');
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : HEALTH_CHECK_TIMEOUT_MS;
+
+    const baseProbe = await probeUrl(baseUrl, { apiKey: authValue, timeoutMs });
+    results.base = {
+        url: baseUrl,
+        status: baseProbe.status || 0,
+        ok: baseProbe.ok,
+        durationMs: baseProbe.durationMs || 0
+    };
+
+    if (!baseProbe.ok) {
+        issues.push({
+            code: 'remote-unreachable',
+            message: `远程探测失败：${baseProbe.error || '无法连接'}`,
+            suggestion: '检查网络与 base_url 可达性'
+        });
+        return { issues, results };
+    }
+
+    if (baseProbe.status === 401 || baseProbe.status === 403) {
+        issues.push({
+            code: 'remote-auth-failed',
+            message: '远程探测鉴权失败（401/403）',
+            suggestion: '检查 API Key 或认证方式'
+        });
+    } else if (baseProbe.status >= 400) {
+        issues.push({
+            code: 'remote-http-error',
+            message: `远程探测返回异常状态: ${baseProbe.status}`,
+            suggestion: '检查 base_url 是否正确'
+        });
+    }
+
+    const modelsUrl = buildModelsProbeUrl(baseUrl);
+    if (modelsUrl) {
+        const modelsProbe = await probeUrl(modelsUrl, { apiKey: authValue, timeoutMs, maxBytes: 256 * 1024 });
+        results.models = {
+            url: modelsUrl,
+            status: modelsProbe.status || 0,
+            ok: modelsProbe.ok,
+            durationMs: modelsProbe.durationMs || 0
+        };
+
+        if (!modelsProbe.ok) {
+            issues.push({
+                code: 'remote-models-unreachable',
+                message: `模型列表探测失败：${modelsProbe.error || '无法连接'}`,
+                suggestion: '检查 base_url 是否包含 /v1 或关闭远程探测'
+            });
+        } else if (modelsProbe.status === 401 || modelsProbe.status === 403) {
+            issues.push({
+                code: 'remote-models-auth-failed',
+                message: '模型列表鉴权失败（401/403）',
+                suggestion: '检查 API Key 或认证方式'
+            });
+        } else if (modelsProbe.status >= 400) {
+            issues.push({
+                code: 'remote-models-http-error',
+                message: `模型列表返回异常状态: ${modelsProbe.status}`,
+                suggestion: '确认 /v1/models 可用'
+            });
+        } else {
+            let payload = null;
+            try {
+                payload = modelsProbe.body ? JSON.parse(modelsProbe.body) : null;
+            } catch (e) {
+                issues.push({
+                    code: 'remote-models-parse',
+                    message: '模型列表解析失败（非 JSON）',
+                    suggestion: '确认 /v1/models 返回 JSON'
+                });
+            }
+
+            if (payload) {
+                const ids = extractModelIds(payload);
+                if (ids.length === 0) {
+                    issues.push({
+                        code: 'remote-models-empty',
+                        message: '模型列表为空或结构无法识别',
+                        suggestion: '确认 provider 是否兼容 /v1/models'
+                    });
+                } else if (modelName && !ids.includes(modelName)) {
+                    issues.push({
+                        code: 'remote-model-unavailable',
+                        message: `远程模型列表中未找到: ${modelName}`,
+                        suggestion: '切换模型或确认模型名称'
+                    });
+                }
+            }
+        }
+    }
+
+    const modelProbeSpec = buildModelProbeSpec(provider, modelName, baseUrl);
+    if (modelProbeSpec && modelProbeSpec.url) {
+        const modelProbe = await probeJsonPost(modelProbeSpec.url, modelProbeSpec.body, {
+            apiKey: authValue,
+            timeoutMs,
+            maxBytes: 256 * 1024
+        });
+
+        results.modelProbe = {
+            url: modelProbeSpec.url,
+            status: modelProbe.status || 0,
+            ok: modelProbe.ok,
+            durationMs: modelProbe.durationMs || 0
         };
+
+        if (!modelProbe.ok) {
+            issues.push({
+                code: 'remote-model-probe-unreachable',
+                message: `模型可用性探测失败：${modelProbe.error || '无法连接'}`,
+                suggestion: '检查网络或模型接口是否可用'
+            });
+        } else if (modelProbe.status === 401 || modelProbe.status === 403) {
+            issues.push({
+                code: 'remote-model-probe-auth-failed',
+                message: '模型可用性探测鉴权失败（401/403）',
+                suggestion: '检查 API Key 或认证方式'
+            });
+        } else if (modelProbe.status >= 400) {
+            issues.push({
+                code: 'remote-model-probe-http-error',
+                message: `模型可用性探测返回异常状态: ${modelProbe.status}`,
+                suggestion: '检查模型或接口路径'
+            });
+        } else {
+            let payload = null;
+            try {
+                payload = modelProbe.body ? JSON.parse(modelProbe.body) : null;
+            } catch (e) {
+                issues.push({
+                    code: 'remote-model-probe-parse',
+                    message: '模型可用性探测解析失败（非 JSON）',
+                    suggestion: '确认模型接口返回 JSON'
+                });
+            }
+            if (payload && payload.error) {
+                const message = typeof payload.error.message === 'string'
+                    ? payload.error.message
+                    : '模型接口返回错误';
+                issues.push({
+                    code: 'remote-model-probe-error',
+                    message: `模型可用性探测失败：${message}`,
+                    suggestion: '检查模型名与权限'
+                });
+            }
+        }
     }
+
+    return { issues, results };
 }
 
-function backupFileIfNeededOnce(filePath, backupPrefix = 'codexmate-backup') {
-    if (!fs.existsSync(filePath)) {
-        return '';
-    }
+async function buildConfigHealthReport(params = {}) {
+    const issues = [];
+    const status = readConfigOrVirtualDefault();
+    const config = status.config || {};
 
-    const dirPath = path.dirname(filePath);
-    const baseName = path.basename(filePath);
-    const existingPrefix = `${baseName}.${backupPrefix}-`;
-    const hasBackup = fs.readdirSync(dirPath).some(fileName =>
-        fileName.startsWith(existingPrefix) && fileName.endsWith('.bak')
-    );
+    if (status.isVirtual) {
+        issues.push({
+            code: 'config-missing',
+            message: status.reason || '未检测到 config.toml',
+            suggestion: '在模板编辑器中确认应用配置，生成可用的 config.toml'
+        });
+    }
 
-    if (hasBackup) {
-        return '';
+    const providerName = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+    const modelName = typeof config.model === 'string' ? config.model.trim() : '';
+    if (!providerName) {
+        issues.push({
+            code: 'provider-missing',
+            message: '当前 provider 未设置',
+            suggestion: '在模板中设置 model_provider'
+        });
     }
 
-    const backupPath = path.join(dirPath, `${existingPrefix}${formatTimestampForFileName()}.bak`);
-    fs.copyFileSync(filePath, backupPath);
-    return backupPath;
-}
+    if (!modelName) {
+        issues.push({
+            code: 'model-missing',
+            message: '当前模型未设置',
+            suggestion: '在模板中设置 model'
+        });
+    }
 
-function writeJsonAtomic(filePath, data) {
-    const dirPath = path.dirname(filePath);
-    ensureDir(dirPath);
+    const providers = config.model_providers && typeof config.model_providers === 'object'
+        ? config.model_providers
+        : {};
+    const provider = providerName ? providers[providerName] : null;
+    if (providerName && !provider) {
+        issues.push({
+            code: 'provider-not-found',
+            message: `当前 provider 未在配置中找到: ${providerName}`,
+            suggestion: '检查 model_providers 是否包含该 provider 配置块'
+        });
+    }
 
-    const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-    const content = `${JSON.stringify(data, null, 2)}\n`;
+    if (provider && typeof provider === 'object') {
+        const baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
+        if (!isValidHttpUrl(baseUrl)) {
+            issues.push({
+                code: 'base-url-invalid',
+                message: '当前 provider 的 base_url 无效',
+                suggestion: '请设置为 http/https 的完整 URL'
+            });
+        }
 
-    try {
-        fs.writeFileSync(tmpPath, content, 'utf-8');
-        try {
-            fs.renameSync(tmpPath, filePath);
-        } catch (renameError) {
-            if (process.platform === 'win32') {
-                fs.copyFileSync(tmpPath, filePath);
-                fs.unlinkSync(tmpPath);
-            } else {
-                throw renameError;
+        const requiresAuth = provider.requires_openai_auth;
+        if (requiresAuth !== false) {
+            const apiKey = typeof provider.preferred_auth_method === 'string'
+                ? provider.preferred_auth_method.trim()
+                : '';
+            if (!apiKey) {
+                issues.push({
+                    code: 'api-key-missing',
+                    message: '当前 provider 未配置 API Key',
+                    suggestion: '在模板中设置 preferred_auth_method'
+                });
             }
         }
-    } catch (e) {
-        if (fs.existsSync(tmpPath)) {
-            try { fs.unlinkSync(tmpPath); } catch (_) {}
+    }
+
+    if (modelName) {
+        const models = readModels();
+        if (!models.includes(modelName)) {
+            issues.push({
+                code: 'model-unavailable',
+                message: `模型未在可用列表中找到: ${modelName}`,
+                suggestion: '在模型列表中添加该模型或切换到已有模型'
+            });
+        }
+    }
+
+    const remoteEnabled = !!params.remote;
+    let remote = null;
+    if (remoteEnabled) {
+        const baseUrl = provider && typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
+        if (!provider) {
+            issues.push({
+                code: 'remote-skip-provider',
+                message: '无法进行远程探测：provider 未找到',
+                suggestion: '检查 model_provider 配置或关闭远程探测'
+            });
+        } else if (!isValidHttpUrl(baseUrl)) {
+            issues.push({
+                code: 'remote-skip-base-url',
+                message: '无法进行远程探测：base_url 无效',
+                suggestion: '补全 base_url 或关闭远程探测'
+            });
+        } else {
+            const timeoutMs = Number.isFinite(params.timeoutMs)
+                ? Math.max(1000, Number(params.timeoutMs))
+                : undefined;
+            const apiKey = typeof provider.preferred_auth_method === 'string'
+                ? provider.preferred_auth_method.trim()
+                : '';
+            const speedResult = await runSpeedTest(baseUrl, apiKey, { timeoutMs });
+            const status = speedResult && typeof speedResult.status === 'number'
+                ? speedResult.status
+                : 0;
+            const durationMs = speedResult && typeof speedResult.durationMs === 'number'
+                ? speedResult.durationMs
+                : 0;
+            const error = speedResult && speedResult.error ? String(speedResult.error) : '';
+            remote = {
+                type: 'speed-test',
+                url: baseUrl,
+                ok: !!speedResult.ok,
+                status,
+                durationMs,
+                error
+            };
+
+            if (!speedResult.ok) {
+                const errorLower = error.toLowerCase();
+                if (errorLower.includes('timeout')) {
+                    issues.push({
+                        code: 'remote-speedtest-timeout',
+                        message: '远程测速超时',
+                        suggestion: '检查网络或 base_url 是否可达'
+                    });
+                } else if (errorLower.includes('invalid url')) {
+                    issues.push({
+                        code: 'remote-speedtest-invalid-url',
+                        message: '远程测速失败：base_url 无效',
+                        suggestion: '请设置为 http/https 的完整 URL'
+                    });
+                } else {
+                    issues.push({
+                        code: 'remote-speedtest-unreachable',
+                        message: `远程测速失败：${error || '无法连接'}`,
+                        suggestion: '检查网络或 base_url 是否可用'
+                    });
+                }
+            } else if (status === 401 || status === 403) {
+                issues.push({
+                    code: 'remote-speedtest-auth-failed',
+                    message: '远程测速鉴权失败（401/403）',
+                    suggestion: '检查 API Key 或认证方式'
+                });
+            } else if (status >= 400) {
+                issues.push({
+                    code: 'remote-speedtest-http-error',
+                    message: `远程测速返回异常状态: ${status}`,
+                    suggestion: '检查 base_url 或服务状态'
+                });
+            }
         }
-        throw new Error(`写入 JSON 文件失败: ${e.message}`);
     }
+
+    return {
+        ok: issues.length === 0,
+        issues,
+        summary: {
+            currentProvider: providerName,
+            currentModel: modelName
+        },
+        remote
+    };
 }
 
 function formatTimestampForFileName(value) {
@@ -510,6 +1584,16 @@ function toIsoTime(value, fallback = '') {
     return date.toISOString();
 }
 
+function updateLatestIso(currentIso, candidate) {
+    const currentTime = Date.parse(currentIso || '') || 0;
+    const candidateIso = toIsoTime(candidate, '');
+    const candidateTime = Date.parse(candidateIso || '') || 0;
+    if (!candidateTime) {
+        return currentIso;
+    }
+    return candidateTime > currentTime ? candidateIso : currentIso;
+}
+
 function truncateText(text, maxLength = 90) {
     if (!text) return '';
     const normalized = String(text).replace(/\s+/g, ' ').trim();
@@ -689,6 +1773,8 @@ function applyConfigTemplate(params = {}) {
     currentModels[activeProvider] = parsed.model;
     writeCurrentModels(currentModels);
 
+    recordRecentConfig(activeProvider, parsed.model);
+
     return { success: true };
 }
 
@@ -810,9 +1896,24 @@ function consumeInitNotice() {
     return notice;
 }
 
+function normalizePathForCompare(targetPath, options = {}) {
+    const ignoreCase = !!options.ignoreCase;
+    let resolved = '';
+    try {
+        resolved = fs.realpathSync.native ? fs.realpathSync.native(targetPath) : fs.realpathSync(targetPath);
+    } catch (e) {
+        resolved = path.resolve(targetPath);
+    }
+    return ignoreCase ? resolved.toLowerCase() : resolved;
+}
+
 function isPathInside(targetPath, rootPath) {
-    const resolvedTarget = path.resolve(targetPath).toLowerCase();
-    const resolvedRoot = path.resolve(rootPath).toLowerCase();
+    if (!targetPath || !rootPath) {
+        return false;
+    }
+    const ignoreCase = process.platform === 'win32';
+    const resolvedTarget = normalizePathForCompare(targetPath, { ignoreCase });
+    const resolvedRoot = normalizePathForCompare(rootPath, { ignoreCase });
     if (resolvedTarget === resolvedRoot) {
         return true;
     }
@@ -1155,23 +2256,23 @@ function scanSessionContentForQuery(session, tokens, options = {}) {
         ? Math.max(0, Number(options.snippetLimit))
         : 0;
 
-    const messages = [];
-    for (const record of records) {
-        const message = extractMessageFromRecord(record, session.source);
-        if (!message || !message.text) {
-            continue;
-        }
-        messages.push(message);
-    }
-
-    const filteredMessages = roleFilter === 'system'
-        ? messages
-        : removeLeadingSystemMessage(messages);
-
-    let count = 0;
-    const snippets = [];
-
-    for (const message of filteredMessages) {
+    const messages = [];
+    for (const record of records) {
+        const message = extractMessageFromRecord(record, session.source);
+        if (!message || !message.text) {
+            continue;
+        }
+        messages.push(message);
+    }
+
+    const filteredMessages = roleFilter === 'system'
+        ? messages
+        : removeLeadingSystemMessage(messages);
+
+    let count = 0;
+    const snippets = [];
+
+    for (const message of filteredMessages) {
         if (roleFilter !== 'all' && message.role !== roleFilter) {
             continue;
         }
@@ -1198,11 +2299,11 @@ function applySessionQueryFilter(sessions, options = {}) {
     }
 
     const mode = normalizeQueryMode(options.queryMode);
-    const scope = normalizeQueryScope(options.queryScope);
-    const roleFilter = normalizeRoleFilter(options.roleFilter);
-    const contentScanLimit = Number.isFinite(Number(options.contentScanLimit))
-        ? Math.max(1, Number(options.contentScanLimit))
-        : DEFAULT_CONTENT_SCAN_LIMIT;
+    const scope = normalizeQueryScope(options.queryScope);
+    const roleFilter = normalizeRoleFilter(options.roleFilter);
+    const contentScanLimit = Number.isFinite(Number(options.contentScanLimit))
+        ? Math.max(1, Number(options.contentScanLimit))
+        : DEFAULT_CONTENT_SCAN_LIMIT;
     const contentScanBytes = Number.isFinite(Number(options.contentScanBytes))
         ? Math.max(1024, Number(options.contentScanBytes))
         : SESSION_CONTENT_READ_BYTES;
@@ -1254,7 +2355,7 @@ function applySessionQueryFilter(sessions, options = {}) {
 
     return results;
 }
-function collectRecentJsonlFiles(rootDir, options = {}) {
+function collectRecentJsonlFiles(rootDir, options = {}) {
     if (!fs.existsSync(rootDir)) {
         return [];
     }
@@ -1366,7 +2467,7 @@ function parseCodexSessionSummary(filePath) {
 
     for (const record of records) {
         if (record.timestamp) {
-            updatedAt = toIsoTime(record.timestamp, updatedAt);
+            updatedAt = updateLatestIso(updatedAt, record.timestamp);
         }
 
         if (record.type === 'session_meta' && record.payload) {
@@ -1455,7 +2556,7 @@ function parseClaudeSessionSummary(filePath) {
             createdAt = toIsoTime(record.timestamp, createdAt);
         }
         if (record.timestamp) {
-            updatedAt = toIsoTime(record.timestamp, updatedAt);
+            updatedAt = updateLatestIso(updatedAt, record.timestamp);
         }
 
         if (!cwd && record.cwd) {
@@ -1516,6 +2617,7 @@ function parseClaudeSessionSummary(filePath) {
 }
 
 function listCodexSessions(limit, options = {}) {
+    const codexSessionsDir = getCodexSessionsDir();
     const scanFactor = Number.isFinite(Number(options.scanFactor))
         ? Math.max(1, Number(options.scanFactor))
         : SESSION_SCAN_FACTOR;
@@ -1531,7 +2633,7 @@ function listCodexSessions(limit, options = {}) {
     const maxFilesScanned = Number.isFinite(Number(options.maxFilesScanned))
         ? Math.max(scanCount, Math.floor(Number(options.maxFilesScanned)))
         : Math.max(scanCount * 2, minFiles);
-    const files = collectRecentJsonlFiles(CODEX_SESSIONS_DIR, {
+    const files = collectRecentJsonlFiles(codexSessionsDir, {
         returnCount: scanCount,
         maxFilesScanned
     });
@@ -1552,7 +2654,8 @@ function listCodexSessions(limit, options = {}) {
 }
 
 function listClaudeSessions(limit, options = {}) {
-    if (!fs.existsSync(CLAUDE_PROJECTS_DIR)) {
+    const claudeProjectsDir = getClaudeProjectsDir();
+    if (!fs.existsSync(claudeProjectsDir)) {
         return [];
     }
 
@@ -1575,9 +2678,9 @@ function listClaudeSessions(limit, options = {}) {
     const sessions = [];
     let projectDirs = [];
     try {
-        projectDirs = fs.readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true })
+        projectDirs = fs.readdirSync(claudeProjectsDir, { withFileTypes: true })
             .filter(entry => entry.isDirectory())
-            .map(entry => path.join(CLAUDE_PROJECTS_DIR, entry.name));
+            .map(entry => path.join(claudeProjectsDir, entry.name));
     } catch (e) {
         projectDirs = [];
     }
@@ -1597,6 +2700,11 @@ function listClaudeSessions(limit, options = {}) {
             let filePath = typeof entry.fullPath === 'string' && entry.fullPath
                 ? entry.fullPath
                 : path.join(projectDir, `${sessionId}.jsonl`);
+            filePath = expandHomePath(filePath);
+            if (filePath && !path.isAbsolute(filePath)) {
+                filePath = path.join(projectDir, filePath);
+            }
+            filePath = filePath ? path.resolve(filePath) : '';
 
             if (!fs.existsSync(filePath)) {
                 continue;
@@ -1652,7 +2760,7 @@ function listClaudeSessions(limit, options = {}) {
     }
 
     if (sessions.length === 0) {
-        const fallbackFiles = collectRecentJsonlFiles(CLAUDE_PROJECTS_DIR, {
+        const fallbackFiles = collectRecentJsonlFiles(claudeProjectsDir, {
             returnCount: scanCount,
             maxFilesScanned,
             ignoreSubPath: `${path.sep}subagents${path.sep}`
@@ -1712,18 +2820,18 @@ function listAllSessions(params = {}) {
         sessions = sessions.filter(item => matchesSessionPathFilter(item, normalizedPathFilter));
     }
 
-    let result = sessions;
-    if (hasQuery) {
-        result = applySessionQueryFilter(result, {
-            tokens: queryTokens,
-            queryMode: params.queryMode,
-            queryScope: params.queryScope,
-            roleFilter: params.roleFilter,
-            contentScanLimit: params.contentScanLimit,
-            contentScanBytes: params.contentScanBytes
-        });
-    }
-    result = mergeAndLimitSessions(result, limit);
+    let result = sessions;
+    if (hasQuery) {
+        result = applySessionQueryFilter(result, {
+            tokens: queryTokens,
+            queryMode: params.queryMode,
+            queryScope: params.queryScope,
+            roleFilter: params.roleFilter,
+            contentScanLimit: params.contentScanLimit,
+            contentScanBytes: params.contentScanBytes
+        });
+    }
+    result = mergeAndLimitSessions(result, limit);
     if (!hasQuery) {
         setSessionListCache(cacheKey, result);
     }
@@ -1784,14 +2892,15 @@ function listSessionPaths(params = {}) {
 }
 
 function resolveSessionFilePath(source, filePath, sessionId) {
-    const root = source === 'claude' ? CLAUDE_PROJECTS_DIR : CODEX_SESSIONS_DIR;
+    const root = source === 'claude' ? getClaudeProjectsDir() : getCodexSessionsDir();
     if (!root || !fs.existsSync(root)) {
         return '';
     }
 
     if (typeof filePath === 'string' && filePath.trim()) {
-        const targetPath = path.resolve(filePath.trim());
-        if (fs.existsSync(targetPath) && isPathInside(targetPath, root)) {
+        const expandedPath = expandHomePath(filePath.trim());
+        const targetPath = expandedPath ? path.resolve(expandedPath) : '';
+        if (targetPath && fs.existsSync(targetPath) && isPathInside(targetPath, root)) {
             return targetPath;
         }
     }
@@ -1808,7 +2917,269 @@ function resolveSessionFilePath(source, filePath, sessionId) {
     return '';
 }
 
-function buildSessionMarkdown(payload) {
+function findClaudeSessionIndexPath(sessionFilePath) {
+    const root = getClaudeProjectsDir();
+    if (!root || !sessionFilePath) {
+        return '';
+    }
+    if (!isPathInside(sessionFilePath, root)) {
+        return '';
+    }
+    let current = path.dirname(sessionFilePath);
+    const resolvedRoot = path.resolve(root);
+    while (current && isPathInside(current, resolvedRoot)) {
+        const candidate = path.join(current, 'sessions-index.json');
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return '';
+}
+
+function updateClaudeSessionIndex(indexPath, sessionFilePath, sessionId) {
+    if (!indexPath || !fs.existsSync(indexPath)) {
+        return;
+    }
+    const index = readJsonFile(indexPath, null);
+    if (!index || !Array.isArray(index.entries)) {
+        return;
+    }
+    const resolvedFile = sessionFilePath ? path.resolve(sessionFilePath) : '';
+    const resolvedLower = resolvedFile ? resolvedFile.toLowerCase() : '';
+    const filtered = index.entries.filter((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return false;
+        }
+        const entrySessionId = typeof entry.sessionId === 'string' ? entry.sessionId : '';
+        if (sessionId && entrySessionId === sessionId) {
+            return false;
+        }
+        if (entry.fullPath) {
+            const expanded = expandHomePath(entry.fullPath);
+            const entryPath = expanded ? path.resolve(expanded) : '';
+            if (entryPath && resolvedLower && entryPath.toLowerCase() === resolvedLower) {
+                return false;
+            }
+        }
+        return true;
+    });
+    if (filtered.length === index.entries.length) {
+        return;
+    }
+    index.entries = filtered;
+    try {
+        fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+    } catch (e) {}
+}
+
+async function deleteSessionData(params = {}) {
+    const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : '');
+    if (!source) {
+        return { error: 'Invalid source' };
+    }
+
+    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    if (!filePath) {
+        return { error: 'Session file not found' };
+    }
+
+    const sessionId = params.sessionId || path.basename(filePath, '.jsonl');
+    try {
+        fs.unlinkSync(filePath);
+    } catch (e) {
+        return { error: `删除会话失败: ${e.message}` };
+    }
+
+    if (source === 'claude') {
+        const indexPath = findClaudeSessionIndexPath(filePath);
+        if (indexPath) {
+            updateClaudeSessionIndex(indexPath, filePath, sessionId);
+        }
+    }
+
+    invalidateSessionListCache();
+
+    return {
+        success: true,
+        source,
+        sessionId,
+        filePath
+    };
+}
+
+function generateCloneSessionId() {
+    if (crypto.randomUUID) {
+        return `clone-${crypto.randomUUID()}`;
+    }
+    const timePart = Date.now().toString(36);
+    const randomPart = crypto.randomBytes(8).toString('hex');
+    return `clone-${timePart}-${randomPart}`;
+}
+
+function allocateCloneSessionTarget(dirPath) {
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+        const sessionId = generateCloneSessionId();
+        const filePath = path.join(dirPath, `${sessionId}.jsonl`);
+        if (!fs.existsSync(filePath)) {
+            return { sessionId, filePath };
+        }
+    }
+    const fallbackId = `clone-${Date.now().toString(36)}-${crypto.randomBytes(8).toString('hex')}`;
+    return { sessionId: fallbackId, filePath: path.join(dirPath, `${fallbackId}.jsonl`) };
+}
+
+function parseTimestampMs(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        if (value > 1e12) return value;
+        if (value > 1e9) return value * 1000;
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) {
+            if (numeric > 1e12) return numeric;
+            if (numeric > 1e9) return numeric * 1000;
+            return numeric;
+        }
+    }
+    return null;
+}
+
+async function cloneCodexSession(params = {}) {
+    const source = params.source === 'codex' ? 'codex' : '';
+    if (!source) {
+        return { error: '仅支持 Codex 会话克隆' };
+    }
+
+    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    if (!filePath) {
+        return { error: 'Session file not found' };
+    }
+
+    let content = '';
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    } catch (e) {
+        return { error: `读取会话失败: ${e.message}` };
+    }
+
+    if (!content.trim()) {
+        return { error: 'Session file is empty' };
+    }
+
+    const lineEnding = detectLineEnding(content);
+    const rawLines = content.split(/\r?\n/);
+    if (rawLines.length > 0 && rawLines[rawLines.length - 1] === '') {
+        rawLines.pop();
+    }
+
+    let originalSessionId = typeof params.sessionId === 'string' ? params.sessionId.trim() : '';
+    if (!originalSessionId) {
+        originalSessionId = path.basename(filePath, '.jsonl');
+    }
+    let maxTimestampMs = 0;
+
+    for (const line of rawLines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+            const record = JSON.parse(trimmed);
+            if (record && record.type === 'session_meta' && record.payload) {
+                if (record.payload.id) {
+                    originalSessionId = record.payload.id;
+                }
+            }
+            if (record && record.timestamp !== undefined) {
+                const ts = parseTimestampMs(record.timestamp);
+                if (Number.isFinite(ts) && ts > maxTimestampMs) {
+                    maxTimestampMs = ts;
+                }
+            }
+        } catch (e) {}
+    }
+
+    const sessionsDir = getCodexSessionsDir();
+    ensureDir(sessionsDir);
+    const target = allocateCloneSessionTarget(sessionsDir);
+    const newSessionId = target.sessionId;
+    const newFilePath = target.filePath;
+    const offsetMs = maxTimestampMs ? (Date.now() - maxTimestampMs) : 0;
+    const cloneTime = new Date(Date.now() + 1);
+    const cloneIso = cloneTime.toISOString();
+
+    const outputLines = [];
+    for (const line of rawLines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            outputLines.push(line);
+            continue;
+        }
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        } catch (e) {
+            outputLines.push(line);
+            continue;
+        }
+
+        if (originalSessionId && typeof record.sessionId === 'string' && record.sessionId === originalSessionId) {
+            record.sessionId = newSessionId;
+        }
+        if (originalSessionId && typeof record.session_id === 'string' && record.session_id === originalSessionId) {
+            record.session_id = newSessionId;
+        }
+        if (offsetMs && record.timestamp !== undefined) {
+            const ts = parseTimestampMs(record.timestamp);
+            if (Number.isFinite(ts)) {
+                record.timestamp = new Date(ts + offsetMs).toISOString();
+            }
+        }
+        if (record && record.type === 'session_meta' && record.payload && typeof record.payload === 'object') {
+            record.payload = {
+                ...record.payload,
+                id: newSessionId,
+                timestamp: cloneIso
+            };
+            record.timestamp = cloneIso;
+        }
+
+        outputLines.push(JSON.stringify(record));
+    }
+
+    const output = outputLines.join(lineEnding) + lineEnding;
+    try {
+        fs.writeFileSync(newFilePath, output, 'utf-8');
+    } catch (e) {
+        return { error: `写入克隆会话失败: ${e.message}` };
+    }
+    try {
+        fs.utimesSync(newFilePath, cloneTime, cloneTime);
+    } catch (e) {}
+
+    invalidateSessionListCache();
+
+    return {
+        success: true,
+        source,
+        sourceLabel: 'Codex',
+        sessionId: newSessionId,
+        filePath: newFilePath
+    };
+}
+
+function buildSessionMarkdown(payload) {
     const lines = [
         '# AI Session Export',
         '',
@@ -1837,24 +3208,75 @@ function buildSessionMarkdown(payload) {
         lines.push('');
     });
 
-    return lines.join('\n');
-}
-
-function resolveStateMaxMessages(state) {
-    if (!state || typeof state !== 'object') {
-        return MAX_EXPORT_MESSAGES;
-    }
-
-    if (state.maxMessages === Infinity) {
-        return Infinity;
-    }
-
-    const rawMax = Number(state.maxMessages);
-    if (Number.isFinite(rawMax) && rawMax > 0) {
-        return Math.floor(rawMax);
-    }
-    return MAX_EXPORT_MESSAGES;
-}
+    return lines.join('\n');
+}
+
+function buildSessionPlainText(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return '';
+    }
+
+    const lines = [];
+    messages.forEach((message) => {
+        const role = normalizeRole(message && message.role) || 'unknown';
+        const text = message && typeof message.text === 'string' ? message.text : '';
+        lines.push(role);
+        lines.push(text);
+        lines.push('');
+    });
+
+    while (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+
+    return lines.join('\n');
+}
+
+function parseMaxMessagesValue(value) {
+    if (value === Infinity) {
+        return Infinity;
+    }
+
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return null;
+        }
+        const lower = trimmed.toLowerCase();
+        if (lower === 'all' || lower === 'infinity' || lower === 'inf') {
+            return Infinity;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+
+    if (Number.isFinite(value)) {
+        return value;
+    }
+    return null;
+}
+
+function resolveMaxMessagesValue(value, fallback) {
+    const parsed = parseMaxMessagesValue(value);
+    if (parsed === null) {
+        return fallback;
+    }
+    if (parsed === Infinity) {
+        return Infinity;
+    }
+    return Math.max(1, Math.floor(parsed));
+}
+
+function resolveStateMaxMessages(state) {
+    if (!state || typeof state !== 'object') {
+        return MAX_EXPORT_MESSAGES;
+    }
+
+    return resolveMaxMessagesValue(state.maxMessages, MAX_EXPORT_MESSAGES);
+}
 
 function canAppendMessage(state) {
     const maxMessages = resolveStateMaxMessages(state);
@@ -1891,7 +3313,7 @@ function extractCodexMessageFromRecord(record, state, lineIndex = -1) {
     }
 }
 
-function extractClaudeMessageFromRecord(record, state, lineIndex = -1) {
+function extractClaudeMessageFromRecord(record, state, lineIndex = -1) {
     if (record.timestamp) {
         state.updatedAt = toIsoTime(record.timestamp, state.updatedAt);
     }
@@ -1916,89 +3338,130 @@ function extractClaudeMessageFromRecord(record, state, lineIndex = -1) {
                 recordLineIndex: Number.isInteger(lineIndex) ? lineIndex : -1
             });
         }
-    }
-}
-
-function extractMessagesFromRecords(records, source, options = {}) {
-    const maxMessages = options.maxMessages === Infinity
-        ? Infinity
-        : (Number.isFinite(Number(options.maxMessages)) ? Math.max(1, Number(options.maxMessages)) : MAX_EXPORT_MESSAGES);
-    const state = {
-        sessionId: '',
-        cwd: '',
-        updatedAt: '',
-        messages: [],
-        maxMessages
-    };
-
-    let lineIndex = 0;
-    for (const record of records) {
-        if (source === 'codex') {
-            extractCodexMessageFromRecord(record, state, lineIndex);
-        } else {
-            extractClaudeMessageFromRecord(record, state, lineIndex);
-        }
-
-        lineIndex += 1;
-
-        if (state.maxMessages !== Infinity && state.messages.length >= state.maxMessages) {
-            break;
-        }
-    }
-
-    return state;
-}
-
-async function extractMessagesFromFile(filePath, source, options = {}) {
-    const maxMessages = options.maxMessages === Infinity
-        ? Infinity
-        : (Number.isFinite(Number(options.maxMessages)) ? Math.max(1, Number(options.maxMessages)) : MAX_EXPORT_MESSAGES);
-    const state = {
-        sessionId: '',
-        cwd: '',
-        updatedAt: '',
-        messages: [],
-        maxMessages
-    };
+    }
+}
+
+function recordHasCodexMessage(record) {
+    if (!record || record.type !== 'response_item' || !record.payload) {
+        return false;
+    }
+    if (record.payload.type !== 'message') {
+        return false;
+    }
+    const role = normalizeRole(record.payload.role);
+    if (role !== 'user' && role !== 'assistant' && role !== 'system') {
+        return false;
+    }
+    const text = extractMessageText(record.payload.content);
+    return !!text;
+}
+
+function recordHasClaudeMessage(record) {
+    if (!record) {
+        return false;
+    }
+    const role = normalizeRole(record.type);
+    if (role !== 'user' && role !== 'assistant' && role !== 'system') {
+        return false;
+    }
+    const content = record.message ? record.message.content : '';
+    const text = extractMessageText(content);
+    return !!text;
+}
+
+function recordHasMessage(record, source) {
+    return source === 'codex'
+        ? recordHasCodexMessage(record)
+        : recordHasClaudeMessage(record);
+}
+
+function extractMessagesFromRecords(records, source, options = {}) {
+    const maxMessages = resolveMaxMessagesValue(options.maxMessages, MAX_EXPORT_MESSAGES);
+    const state = {
+        sessionId: '',
+        cwd: '',
+        updatedAt: '',
+        messages: [],
+        maxMessages,
+        truncated: false
+    };
+
+    for (let lineIndex = 0; lineIndex < records.length; lineIndex++) {
+        const record = records[lineIndex];
+        if (source === 'codex') {
+            extractCodexMessageFromRecord(record, state, lineIndex);
+        } else {
+            extractClaudeMessageFromRecord(record, state, lineIndex);
+        }
+
+        if (state.maxMessages !== Infinity && state.messages.length >= state.maxMessages) {
+            for (let i = lineIndex + 1; i < records.length; i++) {
+                if (recordHasMessage(records[i], source)) {
+                    state.truncated = true;
+                    break;
+                }
+            }
+            break;
+        }
+    }
+
+    return state;
+}
 
-    let stream;
-    let rl;
-    try {
-        stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
-        rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+async function extractMessagesFromFile(filePath, source, options = {}) {
+    const maxMessages = resolveMaxMessagesValue(options.maxMessages, MAX_EXPORT_MESSAGES);
+    const state = {
+        sessionId: '',
+        cwd: '',
+        updatedAt: '',
+        messages: [],
+        maxMessages,
+        truncated: false
+    };
 
-        let lineIndex = 0;
-        for await (const line of rl) {
-            const currentLineIndex = lineIndex;
-            lineIndex += 1;
+    let stream;
+    let rl;
+    try {
+        stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+        rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+        let lineIndex = 0;
+        let limitReached = false;
+        for await (const line of rl) {
+            const currentLineIndex = lineIndex;
+            lineIndex += 1;
 
             const trimmed = line.trim();
             if (!trimmed) continue;
 
             let record;
-            try {
-                record = JSON.parse(trimmed);
-            } catch (e) {
-                continue;
-            }
-
-            if (source === 'codex') {
-                extractCodexMessageFromRecord(record, state, currentLineIndex);
-            } else {
-                extractClaudeMessageFromRecord(record, state, currentLineIndex);
-            }
-
-            if (state.maxMessages !== Infinity && state.messages.length >= state.maxMessages) {
-                rl.close();
-                if (stream.destroy) {
-                    stream.destroy();
-                }
-                break;
-            }
-        }
-    } catch (e) {
-        const fallbackRecords = readJsonlRecords(filePath);
-        return extractMessagesFromRecords(fallbackRecords, source, { maxMessages });
+            try {
+                record = JSON.parse(trimmed);
+            } catch (e) {
+                continue;
+            }
+
+            if (limitReached) {
+                if (recordHasMessage(record, source)) {
+                    state.truncated = true;
+                    break;
+                }
+                continue;
+            }
+
+            if (source === 'codex') {
+                extractCodexMessageFromRecord(record, state, currentLineIndex);
+            } else {
+                extractClaudeMessageFromRecord(record, state, currentLineIndex);
+            }
+
+            if (state.maxMessages !== Infinity && state.messages.length >= state.maxMessages) {
+                limitReached = true;
+            }
+        }
+    } catch (e) {
+        const fallbackRecords = readJsonlRecords(filePath);
+        return extractMessagesFromRecords(fallbackRecords, source, { maxMessages });
     } finally {
         if (rl) {
             try { rl.close(); } catch (e) {}
@@ -2011,7 +3474,7 @@ async function extractMessagesFromFile(filePath, source, options = {}) {
     return state;
 }
 
-async function readSessionDetail(params = {}) {
+async function readSessionDetail(params = {}) {
     const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : '');
     if (!source) {
         return { error: 'Invalid source' };
@@ -2038,37 +3501,83 @@ async function readSessionDetail(params = {}) {
     const startIndex = Math.max(0, allMessages.length - messageLimit);
     const clippedMessages = allMessages.slice(startIndex);
 
-    return {
-        source,
-        sourceLabel,
-        sessionId,
+    return {
+        source,
+        sourceLabel,
+        sessionId,
         cwd: extracted.cwd || '',
         updatedAt: extracted.updatedAt || '',
         totalMessages: allMessages.length,
         clipped: allMessages.length > clippedMessages.length,
         messageLimit,
         messages: clippedMessages,
-        filePath
-    };
-}
-
-async function exportSessionData(params = {}) {
-    const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : '');
-    if (!source) {
-        return { error: 'Invalid source' };
-    }
-
-    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
-    if (!filePath) {
-        return { error: 'Session file not found' };
-    }
-
-    let extracted;
-    try {
-        extracted = await extractMessagesFromFile(filePath, source);
-    } catch (e) {
-        extracted = null;
-    }
+        filePath
+    };
+}
+
+async function readSessionPlain(params = {}) {
+    const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : '');
+    if (!source) {
+        return { error: 'Invalid source' };
+    }
+
+    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    if (!filePath) {
+        return { error: 'Session file not found' };
+    }
+
+    let extracted;
+    try {
+        extracted = await extractMessagesFromFile(filePath, source, { maxMessages: Infinity });
+    } catch (e) {
+        extracted = null;
+    }
+
+    if (!extracted) {
+        return { error: 'Failed to parse session file' };
+    }
+
+    if ((!extracted.messages || extracted.messages.length === 0) && !extracted.sessionId && !extracted.cwd) {
+        const fallbackRecords = readJsonlRecords(filePath);
+        if (fallbackRecords.length === 0) {
+            return { error: 'Session file is empty' };
+        }
+        extracted = extractMessagesFromRecords(fallbackRecords, source, { maxMessages: Infinity });
+    }
+
+    const sessionId = extracted.sessionId || params.sessionId || path.basename(filePath, '.jsonl');
+    const sourceLabel = source === 'codex' ? 'Codex' : 'Claude Code';
+    const messages = removeLeadingSystemMessage(Array.isArray(extracted.messages) ? extracted.messages : []);
+    const text = buildSessionPlainText(messages);
+
+    return {
+        source,
+        sourceLabel,
+        sessionId,
+        title: sessionId,
+        filePath,
+        text
+    };
+}
+
+async function exportSessionData(params = {}) {
+    const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : '');
+    if (!source) {
+        return { error: 'Invalid source' };
+    }
+
+    const maxMessages = resolveMaxMessagesValue(params.maxMessages, MAX_EXPORT_MESSAGES);
+    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    if (!filePath) {
+        return { error: 'Session file not found' };
+    }
+
+    let extracted;
+    try {
+        extracted = await extractMessagesFromFile(filePath, source, { maxMessages });
+    } catch (e) {
+        extracted = null;
+    }
 
     if (!extracted) {
         return { error: 'Failed to parse session file' };
@@ -2076,11 +3585,11 @@ async function exportSessionData(params = {}) {
 
     if ((!extracted.messages || extracted.messages.length === 0) && !extracted.sessionId && !extracted.cwd) {
         const fallbackRecords = readJsonlRecords(filePath);
-        if (fallbackRecords.length === 0) {
-            return { error: 'Session file is empty' };
-        }
-        extracted = extractMessagesFromRecords(fallbackRecords, source);
-    }
+        if (fallbackRecords.length === 0) {
+            return { error: 'Session file is empty' };
+        }
+        extracted = extractMessagesFromRecords(fallbackRecords, source, { maxMessages });
+    }
 
     extracted.messages = removeLeadingSystemMessage(Array.isArray(extracted.messages) ? extracted.messages : []);
 
@@ -2092,25 +3601,29 @@ async function exportSessionData(params = {}) {
     }
 
     const sessionId = extracted.sessionId || params.sessionId || path.basename(filePath, '.jsonl');
-    const safeSessionId = String(sessionId).replace(/[^a-zA-Z0-9_-]/g, '_');
-    const sourceLabel = source === 'codex' ? 'Codex' : 'Claude Code';
-    const markdown = buildSessionMarkdown({
-        sourceLabel,
-        sessionId,
-        updatedAt: extracted.updatedAt,
-        cwd: extracted.cwd,
+    const safeSessionId = String(sessionId).replace(/[^a-zA-Z0-9_-]/g, '_');
+    const sourceLabel = source === 'codex' ? 'Codex' : 'Claude Code';
+    const truncated = !!extracted.truncated;
+    const maxMessagesLabel = maxMessages === Infinity ? 'all' : maxMessages;
+    const markdown = buildSessionMarkdown({
+        sourceLabel,
+        sessionId,
+        updatedAt: extracted.updatedAt,
+        cwd: extracted.cwd,
         filePath,
         messages: extracted.messages
     });
 
-    return {
-        source,
-        sourceLabel,
-        sessionId,
-        fileName: `${source}-session-${safeSessionId}.md`,
-        content: markdown
-    };
-}
+    return {
+        source,
+        sourceLabel,
+        sessionId,
+        fileName: `${source}-session-${safeSessionId}.md`,
+        content: markdown,
+        truncated,
+        maxMessages: maxMessagesLabel
+    };
+}
 
 function buildExportPayload(includeKeys) {
     const { config } = readConfigOrVirtualDefault();
@@ -2274,7 +3787,7 @@ function resolveSpeedTestTarget(params) {
     return { error: 'Missing name or url' };
 }
 
-function runSpeedTest(targetUrl, apiKey) {
+function runSpeedTest(targetUrl, apiKey, options = {}) {
     return new Promise((resolve) => {
         let parsed;
         try {
@@ -2283,6 +3796,10 @@ function runSpeedTest(targetUrl, apiKey) {
             return resolve({ ok: false, error: 'Invalid URL' });
         }
 
+        const timeoutMs = Number.isFinite(options.timeoutMs)
+            ? Math.max(1000, Number(options.timeoutMs))
+            : SPEED_TEST_TIMEOUT_MS;
+
         const transport = parsed.protocol === 'https:' ? https : http;
         const headers = {
             'User-Agent': 'codexmate-speed-test',
@@ -2292,46 +3809,291 @@ function runSpeedTest(targetUrl, apiKey) {
             headers['Authorization'] = `Bearer ${apiKey}`;
         }
 
-        const start = Date.now();
-        const req = transport.request(parsed, { method: 'GET', headers }, (res) => {
-            res.on('data', () => {});
-            res.on('end', () => {
-                resolve({
-                    ok: true,
-                    status: res.statusCode || 0,
-                    durationMs: Date.now() - start
-                });
-            });
-        });
+        const start = Date.now();
+        const req = transport.request(parsed, { method: 'GET', headers }, (res) => {
+            res.on('data', () => {});
+            res.on('end', () => {
+                resolve({
+                    ok: true,
+                    status: res.statusCode || 0,
+                    durationMs: Date.now() - start
+                });
+            });
+        });
+
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error('timeout'));
+        });
+
+        req.on('error', (err) => {
+            resolve({ ok: false, error: err.message, durationMs: Date.now() - start });
+        });
+
+        req.end();
+    });
+}
+
+// ============================================================================
+// 命令
+// ============================================================================
+
+// 交互式配置向导
+async function cmdSetup() {
+    console.log('\n交互式配置向导');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const lineQueue = [];
+    let lineResolver = null;
+    let rlClosed = false;
+    rl.on('line', (line) => {
+        if (lineResolver) {
+            const resolve = lineResolver;
+            lineResolver = null;
+            resolve(line);
+        } else {
+            lineQueue.push(line);
+        }
+    });
+    rl.on('close', () => {
+        rlClosed = true;
+        if (lineResolver) {
+            const resolve = lineResolver;
+            lineResolver = null;
+            resolve('');
+        }
+    });
+    const ask = async (question) => {
+        if (question) {
+            process.stdout.write(question);
+        }
+        if (lineQueue.length > 0) {
+            return lineQueue.shift();
+        }
+        if (rlClosed) {
+            return '';
+        }
+        return await new Promise(resolve => {
+            lineResolver = resolve;
+        });
+    };
+
+    let providerName = '';
+    let baseUrl = '';
+    let apiKey = '';
+    let modelName = '';
+    let isCustomProvider = false;
+
+    try {
+        const { config } = readConfigOrVirtualDefault();
+        const providers = config.model_providers || {};
+        const providerNames = Object.keys(providers);
+        const defaultProvider = config.model_provider || providerNames[0] || '';
+        let availableModels = [];
+        let defaultModel = config.model || '';
+        let modelFetchUnlimited = false;
+
+        while (true) {
+            console.log('\n选择提供商:');
+            if (providerNames.length > 0) {
+                providerNames.forEach((name, index) => {
+                    console.log(`  ${index + 1}. ${name}`);
+                });
+                console.log(`  ${providerNames.length + 1}. 自定义`);
+            } else {
+                console.log('  (暂无提供商，需自定义)');
+            }
+
+            const suffix = defaultProvider ? ` (默认 ${defaultProvider})` : '';
+            const input = (await ask(`请输入序号或名称${suffix}: `)).trim();
+
+            if (!input) {
+                if (defaultProvider) {
+                    providerName = defaultProvider;
+                    isCustomProvider = false;
+                    break;
+                }
+                isCustomProvider = true;
+                break;
+            }
+
+            if (/^\d+$/.test(input)) {
+                const index = parseInt(input, 10);
+                if (index >= 1 && index <= providerNames.length) {
+                    providerName = providerNames[index - 1];
+                    isCustomProvider = false;
+                    break;
+                }
+                if (index === providerNames.length + 1) {
+                    isCustomProvider = true;
+                    break;
+                }
+                console.log('提示: 序号无效，请重试。');
+                continue;
+            }
+
+            if (providers[input]) {
+                providerName = input;
+                isCustomProvider = false;
+                break;
+            }
+
+            if (isValidProviderName(input)) {
+                providerName = input;
+                isCustomProvider = true;
+                break;
+            }
+
+            console.log('提示: 名称仅支持字母/数字/._-');
+        }
+
+        if (isCustomProvider && !providerName) {
+            while (true) {
+                const nameInput = (await ask('请输入自定义提供商名称(字母/数字/._-): ')).trim();
+                if (!nameInput) {
+                    console.log('提示: 名称不能为空。');
+                    continue;
+                }
+                if (!isValidProviderName(nameInput)) {
+                    console.log('提示: 名称仅支持字母/数字/._-');
+                    continue;
+                }
+                providerName = nameInput;
+                break;
+            }
+        }
+
+        if (isCustomProvider) {
+            while (true) {
+                const urlInput = (await ask('Base URL: ')).trim();
+                if (!urlInput) {
+                    console.log('提示: Base URL 不能为空。');
+                    continue;
+                }
+                baseUrl = urlInput;
+                break;
+            }
+            apiKey = (await ask('API Key (可空): ')).trim();
+        }
+
+        let modelFetchError = '';
+        if (providerName) {
+            if (isCustomProvider) {
+                const res = await fetchModelsFromBaseUrl(baseUrl, apiKey);
+                if (res.unlimited) {
+                    modelFetchUnlimited = true;
+                } else if (res.error) {
+                    modelFetchError = res.error;
+                } else {
+                    availableModels = res.models || [];
+                }
+            } else {
+                const res = await fetchProviderModels(providerName);
+                if (res.unlimited) {
+                    modelFetchUnlimited = true;
+                } else if (res.error) {
+                    modelFetchError = res.error;
+                } else {
+                    availableModels = res.models || [];
+                }
+            }
+        }
+        if (modelFetchUnlimited) {
+            console.log('提示: 提供商未提供模型列表，视为不限，请手动输入。');
+        } else if (modelFetchError) {
+            console.log(`提示: 获取模型列表失败: ${modelFetchError}，请手动输入。`);
+        }
+        if (availableModels.length > 0) {
+            if (!defaultModel || !availableModels.includes(defaultModel)) {
+                defaultModel = availableModels[0];
+            }
+        }
+
+        while (true) {
+            console.log('\n选择模型:');
+            if (availableModels.length > 0) {
+                availableModels.forEach((name, index) => {
+                    console.log(`  ${index + 1}. ${name}`);
+                });
+            } else {
+                console.log('  (暂无模型，将使用自定义输入)');
+            }
+
+            const suffix = defaultModel ? ` (默认 ${defaultModel})` : '';
+            const input = (await ask(`请输入序号或名称${suffix}: `)).trim();
+
+            if (!input) {
+                if (defaultModel) {
+                    modelName = defaultModel;
+                    break;
+                }
+                console.log('提示: 模型不能为空。');
+                continue;
+            }
+
+            if (/^\d+$/.test(input)) {
+                const index = parseInt(input, 10);
+                if (index >= 1 && index <= availableModels.length) {
+                    modelName = availableModels[index - 1];
+                    break;
+                }
+                console.log('提示: 序号无效，请重试。');
+                continue;
+            }
+
+            modelName = input;
+            break;
+        }
+
+        console.log('\n即将应用:');
+        console.log('  提供商:', providerName);
+        if (isCustomProvider) {
+            console.log('  Base URL:', baseUrl);
+        }
+        console.log('  模型:', modelName);
 
-        req.setTimeout(SPEED_TEST_TIMEOUT_MS, () => {
-            req.destroy(new Error('timeout'));
-        });
+        const confirm = (await ask('确认应用? (Y/n): ')).trim().toLowerCase();
+        if (confirm === 'n' || confirm === 'no') {
+            console.log('已取消');
+            return;
+        }
 
-        req.on('error', (err) => {
-            resolve({ ok: false, error: err.message, durationMs: Date.now() - start });
-        });
+        if (isCustomProvider) {
+            if (providers[providerName]) {
+                cmdUpdate(providerName, baseUrl, apiKey, true);
+            } else {
+                cmdAdd(providerName, baseUrl, apiKey, true);
+            }
+        }
 
-        req.end();
-    });
-}
+        const latestModels = readModels();
+        if (modelName && !latestModels.includes(modelName)) {
+            cmdAddModel(modelName, true);
+        }
 
-// ============================================================================
-// 命令
-// ============================================================================
+        cmdSwitch(providerName, true);
+        cmdUseModel(modelName, true);
+
+        console.log('✓ 已应用配置');
+        console.log('  提供商:', providerName);
+        console.log('  模型:', modelName);
+        console.log();
+    } catch (e) {
+        console.error('错误:', e.message || e);
+        process.exitCode = 1;
+    } finally {
+        rl.close();
+    }
+}
 
 // 显示当前状态
 function cmdStatus() {
     const { config, isVirtual } = readConfigOrVirtualDefault();
     const current = config.model_provider || '未设置';
     const currentModel = config.model || '未设置';
-    const models = readModels();
-    const currentModels = readCurrentModels();
 
     console.log('\n当前状态:');
     console.log('  提供商:', current);
     console.log('  模型:', currentModel);
-    console.log('  模型列表:', models.length, '个');
+    console.log('  模型列表: 接口提供');
     if (isVirtual) {
         console.log('  说明: 当前为虚拟默认配置（config.toml 尚未创建）');
     }
@@ -2371,21 +4133,30 @@ function cmdList() {
 }
 
 // 列出所有模型
-function cmdModels() {
-    const models = readModels();
-    const currentModels = readCurrentModels();
-
-    console.log('\n可用模型:');
-    models.forEach((m, i) => {
-        const users = Object.entries(currentModels)
-            .filter(([_, model]) => model === m)
-            .map(([name, _]) => name);
-        const usage = users.length > 0 ? users.join(', ') : '(未使用)';
-        console.log(`  ${i + 1}. ${m}`);
-        if (users.length > 0) {
-            console.log(`     → ${usage}`);
-        }
-    });
+async function cmdModels() {
+    const res = await fetchProviderModels('');
+    if (res.error) {
+        console.error('错误: 获取模型列表失败:', res.error);
+        process.exitCode = 1;
+        return;
+    }
+    if (res.unlimited) {
+        const label = res.provider ? ` (${res.provider})` : '';
+        console.log(`\n可用模型${label}:`);
+        console.log('  (接口未提供，视为不限)');
+        console.log();
+        return;
+    }
+    const models = Array.isArray(res.models) ? res.models : [];
+    const label = res.provider ? ` (${res.provider})` : '';
+    console.log(`\n可用模型${label}:`);
+    if (models.length === 0) {
+        console.log('  (空)');
+    } else {
+        models.forEach((m, i) => {
+            console.log(`  ${i + 1}. ${m}`);
+        });
+    }
     console.log();
 }
 
@@ -2430,19 +4201,20 @@ function cmdSwitch(providerName, silent = false) {
         console.log('✓ 当前模型:', targetModel);
         console.log();
     }
+    recordRecentConfig(providerName, targetModel);
     return targetModel;
 }
 
 // 切换模型
 function cmdUseModel(modelName, silent = false) {
+    if (!modelName) {
+        if (!silent) console.error('错误: 模型名称必填');
+        throw new Error('模型名称必填');
+    }
     const models = readModels();
     if (!models.includes(modelName)) {
-        if (!silent) {
-            console.error('错误: 模型不存在:', modelName);
-            console.log('\n可用的模型:');
-            models.forEach(m => console.log('  -', m));
-        }
-        throw new Error('模型不存在');
+        models.push(modelName);
+        writeModels(models);
     }
 
     const config = readConfig();
@@ -2469,6 +4241,7 @@ function cmdUseModel(modelName, silent = false) {
         console.log('✓ 已切换模型:', modelName);
         console.log();
     }
+    recordRecentConfig(currentProvider, modelName);
 }
 
 // 添加提供商
@@ -2682,52 +4455,6 @@ function maskKey(key) {
     return key.substring(0, 4) + '...' + key.substring(key.length - 4);
 }
 
-// 应用到系统环境变量
-function applyToSystemEnv(config = {}) {
-    try {
-        const apiKey = config.apiKey || '';
-
-        // Windows 使用 setx 命令设置用户环境变量
-        if (process.platform === 'win32') {
-            const envVars = [
-                ['ANTHROPIC_API_KEY', apiKey],
-                ['ANTHROPIC_AUTH_TOKEN', apiKey],
-                ['ANTHROPIC_BASE_URL', config.baseUrl || 'https://open.bigmodel.cn/api/anthropic'],
-                ['CLAUDE_CODE_USE_KEY', '1'],
-                ['ANTHROPIC_MODEL', config.model || 'glm-4.7']
-            ];
-
-            const errors = [];
-            for (const [key, value] of envVars) {
-                try {
-                    // 转义值中的双引号，防止命令注入
-                    const safeValue = value.replace(/"/g, '""');
-                    execSync(`setx ${key} "${safeValue}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-                } catch (e) {
-                    errors.push(`${key}: ${e.message || '设置失败'}`);
-                }
-            }
-
-            if (errors.length > 0) {
-                return {
-                    success: false,
-                    mode: 'env-vars',
-                    error: `部分环境变量设置失败:\n${errors.join('\n')}`
-                };
-            }
-            return {
-                success: true,
-                mode: 'env-vars',
-                updatedKeys: envVars.map(([key]) => key)
-            };
-        } else {
-            return { success: false, mode: 'env-vars', error: '仅支持 Windows 系统' };
-        }
-    } catch (e) {
-        return { success: false, mode: 'env-vars', error: e.message };
-    }
-}
-
 // 应用到 Claude Code settings.json（跨平台）
 function applyToClaudeSettings(config = {}) {
     try {
@@ -2751,11 +4478,11 @@ function applyToClaudeSettings(config = {}) {
         const nextEnv = {
             ...currentEnv,
             ANTHROPIC_API_KEY: apiKey,
-            ANTHROPIC_AUTH_TOKEN: apiKey,
             ANTHROPIC_BASE_URL: baseUrl,
-            ANTHROPIC_MODEL: model,
-            CLAUDE_CODE_USE_KEY: '1'
+            ANTHROPIC_MODEL: model
         };
+        delete nextEnv.ANTHROPIC_AUTH_TOKEN;
+        delete nextEnv.CLAUDE_CODE_USE_KEY;
 
         const nextSettings = {
             ...currentSettings,
@@ -2772,10 +4499,8 @@ function applyToClaudeSettings(config = {}) {
             targetPath: CLAUDE_SETTINGS_FILE,
             updatedKeys: [
                 'env.ANTHROPIC_API_KEY',
-                'env.ANTHROPIC_AUTH_TOKEN',
                 'env.ANTHROPIC_BASE_URL',
-                'env.ANTHROPIC_MODEL',
-                'env.CLAUDE_CODE_USE_KEY'
+                'env.ANTHROPIC_MODEL'
             ]
         };
         if (backupPath) {
@@ -2791,8 +4516,67 @@ function applyToClaudeSettings(config = {}) {
     }
 }
 
-// 多线程压缩
-function cmdZip(targetPath, options = {}) {
+function commandExists(command, args = '') {
+    try {
+        execSync(`${command} ${args}`, { stdio: 'ignore' });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+const SEVEN_ZIP_PATHS = [
+    'C:\\Program Files\\7-Zip\\7z.exe',
+    'C:\\Program Files (x86)\\7-Zip\\7z.exe',
+    '7z'
+];
+
+function findSevenZipExecutable() {
+    for (const candidate of SEVEN_ZIP_PATHS) {
+        try {
+            if (candidate === '7z') {
+                if (commandExists('7z', '--help')) {
+                    return '7z';
+                }
+            } else if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        } catch (e) {}
+    }
+    return null;
+}
+
+function resolveZipTool() {
+    const sevenZipExe = findSevenZipExecutable();
+    if (sevenZipExe) {
+        return { type: '7z', cmd: sevenZipExe };
+    }
+    return { type: 'lib', cmd: 'zip-lib' };
+}
+
+function resolveUnzipTool() {
+    const sevenZipExe = findSevenZipExecutable();
+    if (sevenZipExe) {
+        return { type: '7z', cmd: sevenZipExe };
+    }
+    return { type: 'lib', cmd: 'zip-lib' };
+}
+
+async function zipWithLibrary(absPath, outputPath) {
+    const stat = fs.lstatSync(absPath);
+    if (stat.isDirectory()) {
+        await zipLib.archiveFolder(absPath, outputPath);
+        return;
+    }
+    await zipLib.archiveFile(absPath, outputPath);
+}
+
+async function unzipWithLibrary(zipPath, outputDir) {
+    await zipLib.extract(zipPath, outputDir);
+}
+
+// 压缩（7-Zip 优先）
+async function cmdZip(targetPath, options = {}) {
     if (!targetPath) {
         console.error('用法: codexmate zip <文件或文件夹路径> [--max:压缩级别]');
         console.log('\n示例:');
@@ -2820,58 +4604,43 @@ function cmdZip(targetPath, options = {}) {
     const outputDir = path.dirname(absPath);
     const outputPath = path.join(outputDir, `${baseName}.zip`);
 
-    // 查找 7-Zip
-    const sevenZipPaths = [
-        'C:\\Program Files\\7-Zip\\7z.exe',
-        'C:\\Program Files (x86)\\7-Zip\\7z.exe',
-        '7z'
-    ];
-
-    let sevenZipExe = null;
-    for (const p of sevenZipPaths) {
-        try {
-            if (p === '7z') {
-                execSync('7z --help', { stdio: 'ignore' });
-                sevenZipExe = '7z';
-                break;
-            } else if (fs.existsSync(p)) {
-                sevenZipExe = p;
-                break;
-            }
-        } catch (e) {}
-    }
-
-    if (!sevenZipExe) {
-        console.error('错误: 未找到 7-Zip，请先安装 7-Zip');
-        console.log('下载地址: https://www.7-zip.org/');
-        process.exit(1);
-    }
+    const zipTool = resolveZipTool();
 
     console.log('\n压缩配置:');
     console.log('  源路径:', absPath);
     console.log('  输出文件:', outputPath);
     console.log('  压缩级别:', compressionLevel);
-    console.log('  多线程: 启用');
+    console.log('  压缩工具:', zipTool.type === '7z' ? '7-Zip' : 'zip-lib');
+    console.log('  多线程:', zipTool.type === '7z' ? '启用' : '未启用（JS 库）');
+    if (zipTool.type !== '7z') {
+        console.log('  提示: JS 库不支持压缩级别，已忽略 --max');
+    }
     console.log('\n开始压缩...\n');
 
     try {
-        const cmd = `"${sevenZipExe}" a -tzip -mmt=on -mx=${compressionLevel} "${outputPath}" "${absPath}"`;
-        const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
-
-        // 解析输出获取文件信息
-        const sizeMatch = result.match(/Archive size:\s*(\d+)\s*bytes/);
-        const filesMatch = result.match(/(\d+)\s*files/);
+        if (zipTool.type === '7z') {
+            const cmd = `"${zipTool.cmd}" a -tzip -mmt=on -mx=${compressionLevel} "${outputPath}" "${absPath}"`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
+            const sizeMatch = result.match(/Archive size:\s*(\d+)\s*bytes/);
+            const filesMatch = result.match(/(\d+)\s*files/);
+
+            console.log('✓ 压缩完成!');
+            console.log('  输出文件:', outputPath);
+            if (sizeMatch) {
+                const sizeBytes = parseInt(sizeMatch[1]);
+                const sizeMB = (sizeBytes / 1024 / 1024).toFixed(2);
+                console.log('  压缩大小:', sizeMB, 'MB');
+            }
+            if (filesMatch) {
+                console.log('  文件数量:', filesMatch[1]);
+            }
+            console.log();
+            return;
+        }
 
+        await zipWithLibrary(absPath, outputPath);
         console.log('✓ 压缩完成!');
         console.log('  输出文件:', outputPath);
-        if (sizeMatch) {
-            const sizeBytes = parseInt(sizeMatch[1]);
-            const sizeMB = (sizeBytes / 1024 / 1024).toFixed(2);
-            console.log('  压缩大小:', sizeMB, 'MB');
-        }
-        if (filesMatch) {
-            console.log('  文件数量:', filesMatch[1]);
-        }
         console.log();
     } catch (e) {
         console.error('压缩失败:', e.message);
@@ -2879,8 +4648,8 @@ function cmdZip(targetPath, options = {}) {
     }
 }
 
-// 多线程解压
-function cmdUnzip(zipPath, outputDir) {
+// 解压（7-Zip 优先）
+async function cmdUnzip(zipPath, outputDir) {
     if (!zipPath) {
         console.error('用法: codexmate unzip <zip文件路径> [输出目录]');
         console.log('\n示例:');
@@ -2906,65 +4675,254 @@ function cmdUnzip(zipPath, outputDir) {
     const defaultOutputDir = path.join(path.dirname(absZipPath), baseName);
     const absOutputDir = outputDir ? path.resolve(outputDir) : defaultOutputDir;
 
-    // 查找 7-Zip
-    const sevenZipPaths = [
-        'C:\\Program Files\\7-Zip\\7z.exe',
-        'C:\\Program Files (x86)\\7-Zip\\7z.exe',
-        '7z'
-    ];
-
-    let sevenZipExe = null;
-    for (const p of sevenZipPaths) {
-        try {
-            if (p === '7z') {
-                execSync('7z --help', { stdio: 'ignore' });
-                sevenZipExe = '7z';
-                break;
-            } else if (fs.existsSync(p)) {
-                sevenZipExe = p;
-                break;
-            }
-        } catch (e) {}
-    }
-
-    if (!sevenZipExe) {
-        console.error('错误: 未找到 7-Zip，请先安装 7-Zip');
-        console.log('下载地址: https://www.7-zip.org/');
-        process.exit(1);
-    }
+    const unzipTool = resolveUnzipTool();
 
     console.log('\n解压配置:');
     console.log('  源文件:', absZipPath);
     console.log('  输出目录:', absOutputDir);
-    console.log('  多线程: 启用');
+    console.log('  解压工具:', unzipTool.type === '7z' ? '7-Zip' : 'zip-lib');
+    console.log('  多线程:', unzipTool.type === '7z' ? '启用' : '未启用（JS 库）');
     console.log('\n开始解压...\n');
 
     try {
-        const cmd = `"${sevenZipExe}" x -mmt=on -o"${absOutputDir}" "${absZipPath}" -y`;
-        const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
-
-        // 解析输出获取文件信息
-        const filesMatch = result.match(/(\d+)\s*files/);
+        if (unzipTool.type === '7z') {
+            const cmd = `"${unzipTool.cmd}" x -mmt=on -o"${absOutputDir}" "${absZipPath}" -y`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
+            const filesMatch = result.match(/(\d+)\s*files/);
+            console.log('✓ 解压完成!');
+            console.log('  输出目录:', absOutputDir);
+            if (filesMatch) {
+                console.log('  文件数量:', filesMatch[1]);
+            }
+            console.log();
+            return;
+        }
 
+        await unzipWithLibrary(absZipPath, absOutputDir);
         console.log('✓ 解压完成!');
         console.log('  输出目录:', absOutputDir);
-        if (filesMatch) {
-            console.log('  文件数量:', filesMatch[1]);
-        }
         console.log();
     } catch (e) {
         console.error('解压失败:', e.message);
         process.exit(1);
-    }
-}
-
-// 打开 Web UI
-function cmdStart() {
-    const htmlPath = path.join(__dirname, 'web-ui.html');
-    if (!fs.existsSync(htmlPath)) {
-        console.error('错误: web-ui.html 不存在');
-        process.exit(1);
-    }
+    }
+}
+
+function resolveExportOutputPath(outputPath, defaultFileName) {
+    const fallback = path.resolve(process.cwd(), defaultFileName);
+    if (typeof outputPath !== 'string' || !outputPath.trim()) {
+        return fallback;
+    }
+
+    const trimmed = outputPath.trim();
+    const resolved = path.resolve(trimmed);
+    const hasTrailingSep = /[\\\/]$/.test(trimmed);
+    if (hasTrailingSep) {
+        ensureDir(resolved);
+        return path.join(resolved, defaultFileName);
+    }
+
+    if (fs.existsSync(resolved)) {
+        try {
+            const stat = fs.statSync(resolved);
+            if (stat.isDirectory()) {
+                return path.join(resolved, defaultFileName);
+            }
+        } catch (e) {}
+    }
+
+    return resolved;
+}
+
+function printExportSessionUsage() {
+    console.log('\n用法: codexmate export-session --source <codex|claude> (--session-id <ID>|--file <PATH>) [--output <PATH>] [--max-messages <N|all|Infinity>]');
+    console.log('\n示例:');
+    console.log('  codexmate export-session --source codex --session-id 123456');
+    console.log('  codexmate export-session --source claude --file "~/.claude/projects/demo/session.jsonl"');
+    console.log('  codexmate export-session --source codex --session-id 123456 --max-messages=all');
+}
+
+function parseExportSessionArgs(args = []) {
+    const options = {
+        source: '',
+        sessionId: '',
+        filePath: '',
+        output: '',
+        maxMessages: undefined
+    };
+    const errors = [];
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg) continue;
+
+        if (arg.startsWith('--source=')) {
+            options.source = arg.slice('--source='.length);
+            continue;
+        }
+        if (arg === '--source') {
+            options.source = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--session-id=')) {
+            options.sessionId = arg.slice('--session-id='.length);
+            continue;
+        }
+        if (arg === '--session-id') {
+            options.sessionId = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--file=')) {
+            options.filePath = arg.slice('--file='.length);
+            continue;
+        }
+        if (arg === '--file') {
+            options.filePath = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--output=')) {
+            options.output = arg.slice('--output='.length);
+            continue;
+        }
+        if (arg === '--output') {
+            options.output = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--max-messages=')) {
+            options.maxMessages = arg.slice('--max-messages='.length);
+            continue;
+        }
+        if (arg === '--max-messages') {
+            options.maxMessages = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+
+        errors.push(`未知参数: ${arg}`);
+    }
+
+    const normalizedSource = options.source.trim().toLowerCase();
+    if (normalizedSource && normalizedSource !== 'codex' && normalizedSource !== 'claude') {
+        errors.push('参数 --source 仅支持 codex 或 claude');
+    }
+    options.source = normalizedSource;
+
+    if (!options.source) {
+        errors.push('缺少 --source');
+    }
+
+    if (!options.sessionId && !options.filePath) {
+        errors.push('必须指定 --session-id 或 --file');
+    }
+
+    if (options.maxMessages !== undefined) {
+        const parsed = parseMaxMessagesValue(options.maxMessages);
+        if (parsed === null) {
+            errors.push('参数 --max-messages 无效');
+        } else {
+            options.maxMessages = parsed === Infinity ? Infinity : Math.max(1, Math.floor(parsed));
+        }
+    }
+
+    return {
+        options,
+        error: errors.length > 0 ? errors.join('；') : ''
+    };
+}
+
+async function cmdExportSession(args = []) {
+    const parsed = parseExportSessionArgs(args);
+    if (parsed.error) {
+        console.error('错误:', parsed.error);
+        printExportSessionUsage();
+        process.exit(1);
+    }
+
+    const options = parsed.options;
+    const maxMessages = resolveMaxMessagesValue(options.maxMessages, MAX_EXPORT_MESSAGES);
+    let result;
+    try {
+        result = await exportSessionData({
+            source: options.source,
+            sessionId: options.sessionId,
+            filePath: options.filePath,
+            maxMessages
+        });
+    } catch (e) {
+        console.error('导出失败:', e.message || e);
+        process.exit(1);
+    }
+
+    if (result && result.error) {
+        console.error('导出失败:', result.error);
+        process.exit(1);
+    }
+
+    const defaultFileName = (result && result.fileName)
+        ? result.fileName
+        : `${options.source}-session-${options.sessionId || Date.now()}.md`;
+    const outputPath = resolveExportOutputPath(options.output, defaultFileName);
+    ensureDir(path.dirname(outputPath));
+    fs.writeFileSync(outputPath, (result && result.content) ? result.content : '', 'utf-8');
+
+    console.log('\n✓ 会话已导出:', outputPath);
+    if (result && result.truncated) {
+        const label = maxMessages === Infinity ? 'all' : maxMessages;
+        console.log(`! 已截断: 仅导出前 ${label} 条消息`);
+        console.log('  可使用 --max-messages=all 导出完整内容');
+    }
+    console.log();
+}
+
+function parseStartOptions(args = []) {
+    const options = { host: '' };
+    if (!Array.isArray(args)) {
+        return options;
+    }
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg) continue;
+        if (arg.startsWith('--host=')) {
+            options.host = arg.slice('--host='.length);
+            continue;
+        }
+        if (arg === '--host') {
+            options.host = args[i + 1] || '';
+            i += 1;
+        }
+    }
+
+    return options;
+}
+
+function isAnyAddressHost(host) {
+    return host === '0.0.0.0' || host === '::';
+}
+
+function formatHostForUrl(host) {
+    const value = typeof host === 'string' ? host.trim() : '';
+    if (!value) return '';
+    if (value.startsWith('[') && value.endsWith(']')) {
+        return value;
+    }
+    if (value.includes(':')) {
+        return `[${value}]`;
+    }
+    return value;
+}
+
+// 打开 Web UI
+function cmdStart(options = {}) {
+    const htmlPath = path.join(__dirname, 'web-ui.html');
+    if (!fs.existsSync(htmlPath)) {
+        console.error('错误: web-ui.html 不存在');
+        process.exit(1);
+    }
 
     const server = http.createServer((req, res) => {
         if (req.url === '/api') {
@@ -3004,7 +4962,31 @@ function cmdStart() {
                             };
                             break;
                         case 'models':
-                            result = { models: readModels() };
+                            {
+                                const providerName = params && typeof params.provider === 'string' ? params.provider : '';
+                                const res = await fetchProviderModels(providerName);
+                                if (res.error) {
+                                    result = { error: res.error, models: [], source: 'remote' };
+                                } else if (res.unlimited) {
+                                    result = { models: [], source: 'remote', provider: res.provider || '', unlimited: true };
+                                } else {
+                                    result = { models: res.models || [], source: 'remote', provider: res.provider || '' };
+                                }
+                            }
+                            break;
+                        case 'models-by-url':
+                            {
+                                const baseUrl = params && typeof params.baseUrl === 'string' ? params.baseUrl : '';
+                                const apiKey = params && typeof params.apiKey === 'string' ? params.apiKey : '';
+                                const res = await fetchModelsFromBaseUrl(baseUrl, apiKey);
+                                if (res.error) {
+                                    result = { error: res.error, models: [], source: 'remote' };
+                                } else if (res.unlimited) {
+                                    result = { models: [], source: 'remote', unlimited: true };
+                                } else {
+                                    result = { models: res.models || [], source: 'remote' };
+                                }
+                            }
                             break;
                         case 'get-config-template':
                             result = getConfigTemplate(params || {});
@@ -3012,27 +4994,39 @@ function cmdStart() {
                         case 'apply-config-template':
                             result = applyConfigTemplate(params || {});
                             break;
-                        case 'get-agents-file':
-                            result = readAgentsFile(params || {});
-                            break;
-                        case 'apply-agents-file':
-                            result = applyAgentsFile(params || {});
-                            break;
-                        case 'get-openclaw-config':
-                            result = readOpenclawConfigFile();
-                            break;
-                        case 'apply-openclaw-config':
-                            result = applyOpenclawConfig(params || {});
-                            break;
-                        case 'get-openclaw-agents-file':
-                            result = readOpenclawAgentsFile();
-                            break;
-                        case 'apply-openclaw-agents-file':
-                            result = applyOpenclawAgentsFile(params || {});
-                            break;
-                        case 'switch':
-                        case 'use':
-                        case 'add':
+                        case 'get-recent-configs':
+                            result = { items: readRecentConfigs() };
+                            break;
+                        case 'config-health-check':
+                            result = await buildConfigHealthReport(params || {});
+                            break;
+                        case 'get-agents-file':
+                            result = readAgentsFile(params || {});
+                            break;
+                        case 'apply-agents-file':
+                            result = applyAgentsFile(params || {});
+                            break;
+                        case 'get-openclaw-config':
+                            result = readOpenclawConfigFile();
+                            break;
+                        case 'apply-openclaw-config':
+                            result = applyOpenclawConfig(params || {});
+                            break;
+                        case 'get-openclaw-agents-file':
+                            result = readOpenclawAgentsFile();
+                            break;
+                        case 'apply-openclaw-agents-file':
+                            result = applyOpenclawAgentsFile(params || {});
+                            break;
+                        case 'get-openclaw-workspace-file':
+                            result = readOpenclawWorkspaceFile(params || {});
+                            break;
+                        case 'apply-openclaw-workspace-file':
+                            result = applyOpenclawWorkspaceFile(params || {});
+                            break;
+                        case 'switch':
+                        case 'use':
+                        case 'add':
                         case 'delete':
                         case 'update':
                             result = { error: 'Codex 配置改动已切换为模板确认模式，请使用模板编辑器并手动确认应用。' };
@@ -3048,9 +5042,6 @@ function cmdStart() {
                         case 'apply-claude-config':
                             result = applyToClaudeSettings(params.config);
                             break;
-                        case 'apply-env':
-                            result = applyToSystemEnv(params.config);
-                            break;
                         case 'export-config':
                             result = {
                                 data: buildExportPayload(!!params.includeKeys)
@@ -3081,12 +5072,21 @@ function cmdStart() {
                         case 'export-session':
                             result = await exportSessionData(params);
                             break;
-                        case 'session-detail':
-                            result = await readSessionDetail(params);
+                        case 'delete-session':
+                            result = await deleteSessionData(params || {});
                             break;
-                        default:
-                            result = { error: '未知操作' };
-                    }
+                        case 'clone-session':
+                            result = await cloneCodexSession(params || {});
+                            break;
+                        case 'session-detail':
+                            result = await readSessionDetail(params);
+                            break;
+                        case 'session-plain':
+                            result = await readSessionPlain(params);
+                            break;
+                        default:
+                            result = { error: '未知操作' };
+                    }
 
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify(result));
@@ -3102,33 +5102,47 @@ function cmdStart() {
         }
     });
 
-    server.listen(PORT, () => {
-        console.log('\n✓ Web UI 已启动: http://localhost:' + PORT);
-        console.log('  按 Ctrl+C 退出\n');
-
-        // 打开浏览器
-        const platform = process.platform;
-        let command;
-        const url = `http://localhost:${PORT}`;
-
-        if (platform === 'win32') {
-            command = `start "" "${url}"`;
+    const port = resolveWebPort();
+    const host = resolveWebHost(options);
+    const openHost = isAnyAddressHost(host) ? DEFAULT_WEB_HOST : host;
+    const openUrl = `http://${formatHostForUrl(openHost)}:${port}`;
+    server.listen(port, host, () => {
+        console.log('\n✓ Web UI 已启动:', openUrl);
+        if (host && host !== openHost) {
+            console.log('  监听地址:', host);
+        }
+        console.log('  按 Ctrl+C 退出\n');
+        if (isAnyAddressHost(host)) {
+            console.warn('! 安全提示: 当前监听所有网卡（无鉴权）。');
+            console.warn('  建议仅在可信网络使用，或改用 --host 127.0.0.1。');
+        }
+
+        // 打开浏览器
+        const platform = process.platform;
+        let command;
+        const url = openUrl;
+
+        if (platform === 'win32') {
+            command = `start "" "${url}"`;
         } else if (platform === 'darwin') {
             command = `open "${url}"`;
         } else {
             command = `xdg-open "${url}"`;
         }
 
-        exec(command, (error) => {
-            if (error) console.warn('无法自动打开浏览器，请手动访问:', url);
-        });
+        const disableBrowser = process.env.CODEXMATE_NO_BROWSER === '1';
+        if (!disableBrowser) {
+            exec(command, (error) => {
+                if (error) console.warn('无法自动打开浏览器，请手动访问:', url);
+            });
+        }
     });
 }
 
 // ============================================================================
 // 主程序
 // ============================================================================
-function main() {
+async function main() {
     const bootstrap = ensureManagedConfigBootstrap();
     if (bootstrap && bootstrap.notice) {
         console.log(`\n[Init] ${bootstrap.notice}`);
@@ -3139,37 +5153,41 @@ function main() {
         console.log('\nCodex Mate - Codex 提供商管理工具');
         console.log('\n用法:');
         console.log('  codexmate status           显示当前状态');
+        console.log('  codexmate setup            交互式配置向导');
         console.log('  codexmate list             列出所有提供商');
         console.log('  codexmate models           列出所有模型');
         console.log('  codexmate switch <名称>    切换提供商');
         console.log('  codexmate use <模型>       切换模型');
         console.log('  codexmate add <名称> <URL> [密钥]');
         console.log('  codexmate delete <名称>    删除提供商');
-        console.log('  codexmate add-model <模型> 添加模型');
-        console.log('  codexmate delete-model <模型> 删除模型');
-        console.log('  codexmate start            启动 Web 界面');
-        console.log('  codexmate zip <路径> [--max:级别]  多线程压缩');
-        console.log('  codexmate unzip <zip文件> [输出目录]  多线程解压');
-        console.log('');
-        process.exit(0);
-    }
+        console.log('  codexmate add-model <模型> 添加模型');
+        console.log('  codexmate delete-model <模型> 删除模型');
+        console.log('  codexmate start [--host <HOST>]  启动 Web 界面');
+        console.log('  codexmate export-session --source <codex|claude> (--session-id <ID>|--file <PATH>) [--output <PATH>] [--max-messages <N|all|Infinity>]');
+        console.log('  codexmate zip <路径> [--max:级别]  压缩（7-Zip 优先）');
+        console.log('  codexmate unzip <zip文件> [输出目录]  解压（7-Zip 优先）');
+        console.log('');
+        process.exit(0);
+    }
 
     const command = args[0];
 
     switch (command) {
         case 'status': cmdStatus(); break;
+        case 'setup': await cmdSetup(); break;
         case 'list': cmdList(); break;
-        case 'models': cmdModels(); break;
+        case 'models': await cmdModels(); break;
         case 'switch': cmdSwitch(args[1]); break;
         case 'use': cmdUseModel(args[1]); break;
         case 'add': cmdAdd(args[1], args[2], args[3]); break;
         case 'delete': cmdDelete(args[1]); break;
-        case 'add-model': cmdAddModel(args[1]); break;
-        case 'delete-model': cmdDeleteModel(args[1]); break;
-        case 'start': cmdStart(); break;
-        case 'zip': {
-            // 解析 --max:N 参数
-            const zipOptions = {};
+        case 'add-model': cmdAddModel(args[1]); break;
+        case 'delete-model': cmdDeleteModel(args[1]); break;
+        case 'start': cmdStart(parseStartOptions(args.slice(1))); break;
+        case 'export-session': await cmdExportSession(args.slice(1)); break;
+        case 'zip': {
+            // 解析 --max:N 参数
+            const zipOptions = {};
             let targetPath = null;
             for (let i = 1; i < args.length; i++) {
                 const arg = args[i];
@@ -3179,10 +5197,10 @@ function main() {
                     targetPath = arg;
                 }
             }
-            cmdZip(targetPath, zipOptions);
+            await cmdZip(targetPath, zipOptions);
             break;
         }
-        case 'unzip': cmdUnzip(args[1], args[2]); break;
+        case 'unzip': await cmdUnzip(args[1], args[2]); break;
         default:
             console.error('错误: 未知命令:', command);
             console.log('运行 "codexmate" 查看帮助');
@@ -3190,4 +5208,8 @@ function main() {
     }
 }
 
-main();
+main().catch((err) => {
+    console.error('错误:', err && err.message ? err.message : err);
+    process.exit(1);
+});
+