codexmate 0.0.3 → 0.0.5

package/cli.js

@@ -2,13 +2,15 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
 const toml = require('@iarna/toml');
+const JSON5 = require('json5');
 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;
 
 // ============================================================================
 // 配置
@@ -20,12 +22,17 @@ 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,10 +45,15 @@ 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 BOOTSTRAP_TEXT_MARKERS = [
+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>',
     '<environment_context>',
@@ -49,6 +61,17 @@ 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;
+}
+
 const EMPTY_CONFIG_FALLBACK_TEMPLATE = `model = "gpt-5.3-codex"
 model_reasoning_effort = "high"
 disable_response_storage = true
@@ -71,6 +94,8 @@ stream_idle_timeout_ms = 300000
 
 let g_initNotice = '';
 let g_sessionListCache = new Map();
+let g_modelsCache = new Map();
+let g_modelsInFlight = new Map();
 
 // ============================================================================
 // 工具函数
@@ -150,12 +175,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;
 }
@@ -179,6 +280,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()
@@ -228,101 +562,840 @@ 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 : '';
+    const lineEnding = params.lineEnding === '\r\n' ? '\r\n' : '\n';
+    const normalized = normalizeLineEnding(content, lineEnding);
+    const finalContent = ensureUtf8Bom(normalized);
+
+    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 配置失败'
+        };
+    }
+}
+
+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 };
+}
+
+async function buildConfigHealthReport(params = {}) {
+    const issues = [];
+    const status = readConfigOrVirtualDefault();
+    const config = status.config || {};
+
+    if (status.isVirtual) {
+        issues.push({
+            code: 'config-missing',
+            message: status.reason || '未检测到 config.toml',
+            suggestion: '在模板编辑器中确认应用配置，生成可用的 config.toml'
+        });
     }
 
-    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 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'
+        });
+    }
 
-    try {
-        fs.writeFileSync(filePath, finalContent, 'utf-8');
-        return { success: true, path: filePath };
-    } catch (e) {
-        return { error: `写入 AGENTS.md 失败: ${e.message}` };
+    if (!modelName) {
+        issues.push({
+            code: 'model-missing',
+            message: '当前模型未设置',
+            suggestion: '在模板中设置 model'
+        });
     }
-}
 
-function readJsonObjectFromFile(filePath, fallback = {}) {
-    if (!fs.existsSync(filePath)) {
-        return { ok: true, exists: false, data: { ...fallback } };
+    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 配置块'
+        });
     }
 
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        if (!content.trim()) {
-            return { ok: true, exists: true, data: { ...fallback } };
+    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'
+            });
         }
 
-        const parsed = JSON.parse(content);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return {
-                ok: false,
-                exists: true,
-                error: `配置文件格式错误（根节点必须是对象）: ${filePath}`
-            };
+        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'
+                });
+            }
         }
-        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 '';
+    if (modelName) {
+        const models = readModels();
+        if (!models.includes(modelName)) {
+            issues.push({
+                code: 'model-unavailable',
+                message: `模型未在可用列表中找到: ${modelName}`,
+                suggestion: '在模型列表中添加该模型或切换到已有模型'
+            });
+        }
     }
 
-    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;
+    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))
+                : HEALTH_CHECK_TIMEOUT_MS;
+            remote = await runRemoteHealthCheck(provider, modelName, { timeoutMs });
+            if (remote && Array.isArray(remote.issues)) {
+                issues.push(...remote.issues);
             }
         }
-    } catch (e) {
-        if (fs.existsSync(tmpPath)) {
-            try { fs.unlinkSync(tmpPath); } catch (_) {}
-        }
-        throw new Error(`写入 JSON 文件失败: ${e.message}`);
     }
+
+    return {
+        ok: issues.length === 0,
+        issues,
+        summary: {
+            currentProvider: providerName,
+            currentModel: modelName
+        },
+        remote
+    };
 }
 
 function formatTimestampForFileName(value) {
@@ -530,6 +1603,8 @@ function applyConfigTemplate(params = {}) {
     currentModels[activeProvider] = parsed.model;
     writeCurrentModels(currentModels);
 
+    recordRecentConfig(activeProvider, parsed.model);
+
     return { success: true };
 }
 
@@ -651,9 +1726,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;
     }
@@ -1357,6 +2447,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;
@@ -1372,7 +2463,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
     });
@@ -1393,7 +2484,8 @@ function listCodexSessions(limit, options = {}) {
 }
 
 function listClaudeSessions(limit, options = {}) {
-    if (!fs.existsSync(CLAUDE_PROJECTS_DIR)) {
+    const claudeProjectsDir = getClaudeProjectsDir();
+    if (!fs.existsSync(claudeProjectsDir)) {
         return [];
     }
 
@@ -1416,9 +2508,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 = [];
     }
@@ -1438,6 +2530,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;
@@ -1493,7 +2590,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}`
@@ -1625,14 +2722,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;
         }
     }
@@ -2161,18 +3259,263 @@ function runSpeedTest(targetUrl, apiKey) {
 // 命令
 // ============================================================================
 
+// 交互式配置向导
+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);
+
+        const confirm = (await ask('确认应用? (Y/n): ')).trim().toLowerCase();
+        if (confirm === 'n' || confirm === 'no') {
+            console.log('已取消');
+            return;
+        }
+
+        if (isCustomProvider) {
+            if (providers[providerName]) {
+                cmdUpdate(providerName, baseUrl, apiKey, true);
+            } else {
+                cmdAdd(providerName, baseUrl, apiKey, true);
+            }
+        }
+
+        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 尚未创建）');
     }
@@ -2212,21 +3555,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();
 }
 
@@ -2271,19 +3623,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();
@@ -2310,6 +3663,7 @@ function cmdUseModel(modelName, silent = false) {
         console.log('✓ 已切换模型:', modelName);
         console.log();
     }
+    recordRecentConfig(currentProvider, modelName);
 }
 
 // 添加提供商
@@ -2523,52 +3877,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 {
@@ -2592,11 +3900,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,
@@ -2613,10 +3921,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) {
@@ -2845,7 +4151,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 || {});
@@ -2853,12 +4183,30 @@ function cmdStart() {
                         case 'apply-config-template':
                             result = applyConfigTemplate(params || {});
                             break;
+                        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 'switch':
                         case 'use':
                         case 'add':
@@ -2877,9 +4225,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)
@@ -2931,14 +4276,15 @@ function cmdStart() {
         }
     });
 
-    server.listen(PORT, () => {
-        console.log('\n✓ Web UI 已启动: http://localhost:' + PORT);
+    const port = resolveWebPort();
+    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}`;
+        const url = `http://localhost:${port}`;
 
         if (platform === 'win32') {
             command = `start "" "${url}"`;
@@ -2948,16 +4294,19 @@ function cmdStart() {
             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}`);
@@ -2968,6 +4317,7 @@ 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 <名称>    切换提供商');
@@ -2987,8 +4337,9 @@ function main() {
 
     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;
@@ -3019,4 +4370,7 @@ function main() {
     }
 }
 
-main();
+main().catch((err) => {
+    console.error('错误:', err && err.message ? err.message : err);
+    process.exit(1);
+});