codexmate 0.0.18 → 0.0.19

package/cli.js

@@ -64,7 +64,8 @@ const {
 } = require('./lib/workflow-engine');
 
 const DEFAULT_WEB_PORT = 3737;
-const DEFAULT_WEB_HOST = '127.0.0.1';
+const DEFAULT_WEB_HOST = '0.0.0.0';
+const DEFAULT_WEB_OPEN_HOST = '127.0.0.1';
 
 // ============================================================================
 // 配置
@@ -116,9 +117,13 @@ const AGENTS_FILE_NAME = 'AGENTS.md';
 const CODEX_SKILLS_DIR = path.join(CONFIG_DIR, 'skills');
 const CLAUDE_SKILLS_DIR = path.join(CLAUDE_DIR, 'skills');
 const AGENTS_SKILLS_DIR = path.join(os.homedir(), '.agents', 'skills');
+const SKILL_TARGETS = Object.freeze([
+    Object.freeze({ app: 'codex', label: 'Codex', dir: getCodexSkillsDir() }),
+    Object.freeze({ app: 'claude', label: 'Claude Code', dir: getClaudeSkillsDir() })
+]);
 const SKILL_IMPORT_SOURCES = Object.freeze([
-    { app: 'claude', label: 'Claude Code', dir: CLAUDE_SKILLS_DIR },
-    { app: 'agents', label: 'Agents', dir: AGENTS_SKILLS_DIR }
+    ...SKILL_TARGETS,
+    Object.freeze({ app: 'agents', label: 'Agents', dir: AGENTS_SKILLS_DIR })
 ]);
 const MODELS_CACHE_TTL_MS = 60 * 1000;
 const MODELS_NEGATIVE_CACHE_TTL_MS = 5 * 1000;
@@ -167,6 +172,38 @@ const CLI_INSTALL_TARGETS = Object.freeze([
 const HTTP_KEEP_ALIVE_AGENT = new http.Agent({ keepAlive: true });
 const HTTPS_KEEP_ALIVE_AGENT = new https.Agent({ keepAlive: true });
 
+function getCodexSkillsDir() {
+    const envCodexHome = typeof process.env.CODEX_HOME === 'string' ? process.env.CODEX_HOME.trim() : '';
+    if (envCodexHome) {
+        const target = path.join(envCodexHome, 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const xdgConfig = typeof process.env.XDG_CONFIG_HOME === 'string' ? process.env.XDG_CONFIG_HOME.trim() : '';
+    if (xdgConfig) {
+        const target = path.join(xdgConfig, 'codex', 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const homeConfigDir = path.join(os.homedir(), '.config', 'codex', 'skills');
+    return resolveExistingDir([homeConfigDir], CODEX_SKILLS_DIR);
+}
+
+function getClaudeSkillsDir() {
+    const envClaudeHome = typeof process.env.CLAUDE_HOME === 'string' && process.env.CLAUDE_HOME.trim()
+        ? process.env.CLAUDE_HOME.trim()
+        : (typeof process.env.CLAUDE_CONFIG_DIR === 'string' ? process.env.CLAUDE_CONFIG_DIR.trim() : '');
+    if (envClaudeHome) {
+        const target = path.join(envClaudeHome, 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const xdgConfig = typeof process.env.XDG_CONFIG_HOME === 'string' ? process.env.XDG_CONFIG_HOME.trim() : '';
+    if (xdgConfig) {
+        const target = path.join(xdgConfig, 'claude', 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const homeConfigDir = path.join(os.homedir(), '.config', 'claude', 'skills');
+    return resolveExistingDir([homeConfigDir], CLAUDE_SKILLS_DIR);
+}
+
 function resolveWebPort() {
     const raw = process.env.CODEXMATE_PORT;
     if (!raw) return DEFAULT_WEB_PORT;
@@ -216,7 +253,7 @@ let g_builtinProxyRuntime = null;
 const DEFAULT_LOCAL_PROVIDER_NAME = 'local';
 
 function isBuiltinProxyProvider(providerName) {
-    return typeof providerName === 'string' && providerName.trim() === BUILTIN_PROXY_PROVIDER_NAME;
+    return typeof providerName === 'string' && providerName.trim().toLowerCase() === BUILTIN_PROXY_PROVIDER_NAME.toLowerCase();
 }
 
 function isReservedProviderNameForCreation(providerName) {
@@ -889,12 +926,18 @@ function normalizeAuthRegistry(raw) {
     };
 }
 
+function ensureAuthProfileStoragePrepared() {
+    ensureDir(AUTH_PROFILES_DIR);
+}
+
 function readAuthRegistry() {
+    ensureAuthProfileStoragePrepared();
     const parsed = readJsonFile(AUTH_REGISTRY_FILE, null);
     return normalizeAuthRegistry(parsed);
 }
 
 function writeAuthRegistry(registry) {
+    ensureAuthProfileStoragePrepared();
     writeJsonAtomic(AUTH_REGISTRY_FILE, normalizeAuthRegistry(registry));
 }
 
@@ -953,6 +996,7 @@ function listAuthProfilesInfo() {
 }
 
 function upsertAuthProfile(payload, options = {}) {
+    ensureAuthProfileStoragePrepared();
     const safePayload = parseAuthProfileJson(JSON.stringify(payload || {}));
     const sourceFile = typeof options.sourceFile === 'string' ? options.sourceFile : '';
     const preferredName = normalizeAuthProfileName(options.name || '');
@@ -1042,6 +1086,7 @@ function importAuthProfileFromUpload(payload = {}) {
 }
 
 function switchAuthProfile(name, options = {}) {
+    ensureAuthProfileStoragePrepared();
     const profileName = normalizeAuthProfileName(name);
     if (!profileName) {
         throw new Error('认证名称不能为空');
@@ -1087,6 +1132,7 @@ function switchAuthProfile(name, options = {}) {
 }
 
 function deleteAuthProfile(name) {
+    ensureAuthProfileStoragePrepared();
     const profileName = normalizeAuthProfileName(name);
     if (!profileName) {
         return { error: '认证名称不能为空' };
@@ -1135,6 +1181,7 @@ function deleteAuthProfile(name) {
 }
 
 function resolveAuthTokenFromCurrentProfile() {
+    ensureAuthProfileStoragePrepared();
     const registry = readAuthRegistry();
     if (!registry.current) return '';
     const profile = registry.items.find((item) => item.name === registry.current);
@@ -1390,8 +1437,40 @@ function normalizeCodexSkillName(name) {
     return { name: value };
 }
 
-function isSkillDirectoryEntry(entryName) {
-    const targetPath = path.join(CODEX_SKILLS_DIR, entryName);
+function normalizeSkillTargetApp(app) {
+    const value = typeof app === 'string' ? app.trim().toLowerCase() : '';
+    return SKILL_TARGETS.some((item) => item.app === value) ? value : '';
+}
+
+function getSkillTargetByApp(app) {
+    const normalizedApp = normalizeSkillTargetApp(app);
+    if (!normalizedApp) return null;
+    return SKILL_TARGETS.find((item) => item.app === normalizedApp) || null;
+}
+
+function resolveSkillTarget(params = {}, defaultApp = 'codex') {
+    const hasExplicitTargetApp = !!(params && typeof params === 'object'
+        && Object.prototype.hasOwnProperty.call(params, 'targetApp'));
+    const hasExplicitTarget = !!(params && typeof params === 'object'
+        && Object.prototype.hasOwnProperty.call(params, 'target'));
+    const hasAnyExplicitTarget = hasExplicitTargetApp || hasExplicitTarget;
+    const rawTargetApp = hasExplicitTargetApp ? params.targetApp : '';
+    const rawTarget = hasExplicitTarget ? params.target : '';
+    const raw = rawTargetApp || rawTarget || '';
+    if (hasAnyExplicitTarget && raw === '') {
+        return null;
+    }
+    if (hasAnyExplicitTarget && !getSkillTargetByApp(raw)) {
+        return null;
+    }
+    return getSkillTargetByApp(raw)
+        || getSkillTargetByApp(defaultApp)
+        || SKILL_TARGETS[0]
+        || null;
+}
+
+function isSkillDirectoryEntryAtRoot(rootDir, entryName) {
+    const targetPath = path.join(rootDir, entryName);
     try {
         const stat = fs.statSync(targetPath);
         return stat.isDirectory();
@@ -1560,13 +1639,13 @@ function readCodexSkillMetadata(skillPath) {
     }
 }
 
-function getCodexSkillEntryInfoByName(entryName) {
-    const targetPath = path.join(CODEX_SKILLS_DIR, entryName);
+function getSkillEntryInfoByName(rootDir, entryName) {
+    const targetPath = path.join(rootDir, entryName);
     const normalized = normalizeCodexSkillName(entryName);
     if (normalized.error) {
         return null;
     }
-    const relativePath = path.relative(CODEX_SKILLS_DIR, targetPath);
+    const relativePath = path.relative(rootDir, targetPath);
     if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
         return null;
     }
@@ -1577,7 +1656,7 @@ function getCodexSkillEntryInfoByName(entryName) {
         if (!lstat.isDirectory() && !isSymbolicLink) {
             return null;
         }
-        if (isSymbolicLink && !isSkillDirectoryEntry(entryName)) {
+        if (isSymbolicLink && !isSkillDirectoryEntryAtRoot(rootDir, entryName)) {
             return null;
         }
         const metadata = readCodexSkillMetadata(targetPath);
@@ -1595,26 +1674,34 @@ function getCodexSkillEntryInfoByName(entryName) {
     }
 }
 
-function listCodexSkills() {
-    if (!fs.existsSync(CODEX_SKILLS_DIR)) {
+function listSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    if (!fs.existsSync(target.dir)) {
         return {
-            root: CODEX_SKILLS_DIR,
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir,
             exists: false,
             items: []
         };
     }
     try {
-        const entries = fs.readdirSync(CODEX_SKILLS_DIR, { withFileTypes: true });
+        const entries = fs.readdirSync(target.dir, { withFileTypes: true });
         const items = entries
             .map((entry) => {
                 const name = entry && entry.name ? entry.name : '';
                 if (!name || name.startsWith('.')) return null;
-                return getCodexSkillEntryInfoByName(name);
+                return getSkillEntryInfoByName(target.dir, name);
             })
             .filter(Boolean)
             .sort((a, b) => a.displayName.localeCompare(b.displayName, 'zh-Hans-CN'));
         return {
-            root: CODEX_SKILLS_DIR,
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir,
             exists: true,
             items
         };
@@ -1623,6 +1710,10 @@ function listCodexSkills() {
     }
 }
 
+function listCodexSkills() {
+    return listSkills({ targetApp: 'codex' });
+}
+
 function listSkillEntriesByRoot(rootDir) {
     if (!rootDir || !fs.existsSync(rootDir)) {
         return [];
@@ -1668,8 +1759,13 @@ function listSkillEntriesByRoot(rootDir) {
     }
 }
 
-function scanUnmanagedCodexSkills() {
-    const existing = listCodexSkills();
+function scanUnmanagedSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    const targetRoot = resolveCopyTargetRoot(target.dir);
+    const existing = listSkills({ targetApp: target.app });
     if (existing.error) {
         return { error: existing.error };
     }
@@ -1678,9 +1774,14 @@ function scanUnmanagedCodexSkills() {
         .filter(Boolean));
 
     const items = [];
-    for (const source of SKILL_IMPORT_SOURCES) {
+    const sources = SKILL_IMPORT_SOURCES.filter((source) => source.app !== target.app);
+    for (const source of sources) {
         const sourceEntries = listSkillEntriesByRoot(source.dir);
         for (const entry of sourceEntries) {
+            const targetCandidate = path.join(targetRoot, entry.name);
+            if (fs.existsSync(targetCandidate)) {
+                continue;
+            }
             if (existingNames.has(entry.name)) {
                 continue;
             }
@@ -1706,9 +1807,11 @@ function scanUnmanagedCodexSkills() {
     });
 
     return {
-        root: CODEX_SKILLS_DIR,
+        targetApp: target.app,
+        targetLabel: target.label,
+        root: target.dir,
         items,
-        sources: SKILL_IMPORT_SOURCES.map((source) => ({
+        sources: sources.map((source) => ({
             app: source.app,
             label: source.label,
             path: source.dir,
@@ -1717,14 +1820,21 @@ function scanUnmanagedCodexSkills() {
     };
 }
 
-function importCodexSkills(params = {}) {
+function scanUnmanagedCodexSkills() {
+    return scanUnmanagedSkills({ targetApp: 'codex' });
+}
+
+function importSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    const targetRoot = resolveCopyTargetRoot(target.dir);
     const rawItems = Array.isArray(params.items) ? params.items : [];
     if (!rawItems.length) {
         return { error: '请先选择要导入的 skill' };
     }
 
-    ensureDir(CODEX_SKILLS_DIR);
-
     const imported = [];
     const failed = [];
     const dedup = new Set();
@@ -1749,6 +1859,14 @@ function importCodexSkills(params = {}) {
             });
             continue;
         }
+        if (source.app === target.app) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
+                error: '来源与目标相同，无需导入'
+            });
+            continue;
+        }
         const dedupKey = `${source.app}:${normalizedName.name}`;
         if (dedup.has(dedupKey)) {
             continue;
@@ -1774,8 +1892,8 @@ function importCodexSkills(params = {}) {
             continue;
         }
 
-        const targetPath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-        const targetRelative = path.relative(CODEX_SKILLS_DIR, targetPath);
+        const targetPath = path.join(targetRoot, normalizedName.name);
+        const targetRelative = path.relative(targetRoot, targetPath);
         if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
             failed.push({
                 name: normalizedName.name,
@@ -1788,7 +1906,7 @@ function importCodexSkills(params = {}) {
             failed.push({
                 name: normalizedName.name,
                 sourceApp: source.app,
-                error: 'Codex 中已存在同名 skill'
+                error: `${target.label} 中已存在同名 skill`
             });
             continue;
         }
@@ -1814,6 +1932,15 @@ function importCodexSkills(params = {}) {
                 });
                 continue;
             }
+            if (isPathInside(targetRoot, sourceDirForCopy)) {
+                failed.push({
+                    name: normalizedName.name,
+                    sourceApp: source.app,
+                    error: '目标路径不能位于来源 skill 目录内'
+                });
+                continue;
+            }
+            ensureDir(targetRoot);
             const visitedRealPaths = new Set([sourceDirForCopy]);
             copyDirRecursive(sourceDirForCopy, targetPath, {
                 dereferenceSymlinks: true,
@@ -1825,6 +1952,8 @@ function importCodexSkills(params = {}) {
                 name: normalizedName.name,
                 sourceApp: source.app,
                 sourceLabel: source.label,
+                targetApp: target.app,
+                targetLabel: target.label,
                 path: targetPath
             });
         } catch (e) {
@@ -1845,10 +1974,16 @@ function importCodexSkills(params = {}) {
         success: failed.length === 0,
         imported,
         failed,
-        root: CODEX_SKILLS_DIR
+        targetApp: target.app,
+        targetLabel: target.label,
+        root: targetRoot
     };
 }
 
+function importCodexSkills(params = {}) {
+    return importSkills({ ...(params || {}), targetApp: 'codex' });
+}
+
 function collectSkillDirectoriesFromRoot(rootDir, limit = MAX_SKILLS_ZIP_ENTRY_COUNT) {
     const results = [];
     let truncated = false;
@@ -1902,15 +2037,22 @@ function resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbac
     return normalizeCodexSkillName(candidate);
 }
 
-async function importCodexSkillsFromZipFile(zipPath, options = {}) {
+async function importSkillsFromZipFile(zipPath, options = {}) {
     const fallbackName = typeof options.fallbackName === 'string' ? options.fallbackName : '';
     const tempDir = typeof options.tempDir === 'string' ? options.tempDir : '';
     const imported = [];
     const failed = [];
     const dedupNames = new Set();
     const extractionRoot = path.join(tempDir || path.dirname(zipPath), 'extract');
+    let target = null;
+    let targetRoot = '';
 
     try {
+        target = resolveSkillTarget(options, 'codex');
+        if (!target) {
+            return { error: '目标宿主不支持' };
+        }
+        targetRoot = resolveCopyTargetRoot(target.dir);
         await inspectZipArchiveLimits(zipPath, {
             maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
             maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
@@ -1926,7 +2068,6 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             return { error: '压缩包中的技能目录数量超出导入上限' };
         }
 
-        ensureDir(CODEX_SKILLS_DIR);
         for (const skillDir of discoveredDirs) {
             const normalizedName = resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbackName);
             if (normalizedName.error) {
@@ -1942,8 +2083,8 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             }
             dedupNames.add(dedupKey);
 
-            const targetPath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-            const targetRelative = path.relative(CODEX_SKILLS_DIR, targetPath);
+            const targetPath = path.join(targetRoot, normalizedName.name);
+            const targetRelative = path.relative(targetRoot, targetPath);
             if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
                 failed.push({
                     name: normalizedName.name,
@@ -1954,7 +2095,7 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             if (fs.existsSync(targetPath)) {
                 failed.push({
                     name: normalizedName.name,
-                    error: 'Codex 中已存在同名 skill'
+                    error: `${target.label} 中已存在同名 skill`
                 });
                 continue;
             }
@@ -1970,6 +2111,14 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                     });
                     continue;
                 }
+                if (isPathInside(targetRoot, sourceRealPath)) {
+                    failed.push({
+                        name: normalizedName.name,
+                        error: '目标路径不能位于来源 skill 目录内'
+                    });
+                    continue;
+                }
+                ensureDir(targetRoot);
                 const visitedRealPaths = new Set([sourceRealPath]);
                 copyDirRecursive(sourceRealPath, targetPath, {
                     dereferenceSymlinks: true,
@@ -1979,6 +2128,8 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                 copiedToTarget = true;
                 imported.push({
                     name: normalizedName.name,
+                    targetApp: target.app,
+                    targetLabel: target.label,
                     path: targetPath
                 });
             } catch (e) {
@@ -1999,7 +2150,9 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                 error: failed[0].error || '导入失败',
                 imported,
                 failed,
-                root: CODEX_SKILLS_DIR
+                targetApp: target.app,
+                targetLabel: target.label,
+                root: targetRoot
             };
         }
 
@@ -2007,7 +2160,9 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             success: failed.length === 0,
             imported,
             failed,
-            root: CODEX_SKILLS_DIR
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: targetRoot
         };
     } catch (e) {
         return {
@@ -2026,21 +2181,40 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
     }
 }
 
-async function importCodexSkillsFromZip(payload = {}) {
+async function importCodexSkillsFromZipFile(zipPath, options = {}) {
+    return importSkillsFromZipFile(zipPath, { ...(options || {}), targetApp: 'codex' });
+}
+
+async function importSkillsFromZip(payload = {}) {
     if (!payload || typeof payload.fileBase64 !== 'string' || !payload.fileBase64.trim()) {
         return { error: '缺少技能压缩包内容' };
     }
-    const upload = writeUploadZip(payload.fileBase64, 'codex-skills-import', payload.fileName || 'codex-skills.zip');
+    const fallbackTarget = resolveSkillTarget(payload, 'codex');
+    const fallbackTargetApp = fallbackTarget ? fallbackTarget.app : 'codex';
+    const fallbackName = payload.fileName || `${fallbackTargetApp}-skills.zip`;
+    const upload = writeUploadZip(payload.fileBase64, 'codex-skills-import', fallbackName);
     if (upload.error) {
         return { error: upload.error };
     }
-    return importCodexSkillsFromZipFile(upload.zipPath, {
-        tempDir: upload.tempDir,
-        fallbackName: payload.fileName || ''
-    });
+    const importOptions = { tempDir: upload.tempDir, fallbackName };
+    if (Object.prototype.hasOwnProperty.call(payload, 'targetApp')) {
+        importOptions.targetApp = payload.targetApp;
+    }
+    if (Object.prototype.hasOwnProperty.call(payload, 'target')) {
+        importOptions.target = payload.target;
+    }
+    return importSkillsFromZipFile(upload.zipPath, importOptions);
 }
 
-async function exportCodexSkills(params = {}) {
+async function importCodexSkillsFromZip(payload = {}) {
+    return importSkillsFromZip({ ...(payload || {}), targetApp: 'codex' });
+}
+
+async function exportSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
     const rawNames = Array.isArray(params.names) ? params.names : [];
     const uniqueNames = Array.from(new Set(rawNames
         .map((item) => (typeof item === 'string' ? item.trim() : ''))
@@ -2062,8 +2236,8 @@ async function exportCodexSkills(params = {}) {
                 failed.push({ name: rawName, error: normalizedName.error });
                 continue;
             }
-            const sourcePath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-            const sourceRelative = path.relative(CODEX_SKILLS_DIR, sourcePath);
+            const sourcePath = path.join(target.dir, normalizedName.name);
+            const sourceRelative = path.relative(target.dir, sourcePath);
             if (sourceRelative.startsWith('..') || path.isAbsolute(sourceRelative)) {
                 failed.push({ name: normalizedName.name, error: '来源路径非法' });
                 continue;
@@ -2109,12 +2283,14 @@ async function exportCodexSkills(params = {}) {
                 error: failed[0] && failed[0].error ? failed[0].error : '无可导出的 skill',
                 exported,
                 failed,
-                root: CODEX_SKILLS_DIR
+                targetApp: target.app,
+                targetLabel: target.label,
+                root: target.dir
             };
         }
 
         const randomToken = crypto.randomBytes(12).toString('hex');
-        const zipFileName = `codex-skills-${randomToken}.zip`;
+        const zipFileName = `${target.app}-skills-${randomToken}.zip`;
         const zipFilePath = path.join(os.tmpdir(), zipFileName);
         if (fs.existsSync(zipFilePath)) {
             try {
@@ -2133,14 +2309,18 @@ async function exportCodexSkills(params = {}) {
             downloadPath: artifact.downloadPath,
             exported,
             failed,
-            root: CODEX_SKILLS_DIR
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir
         };
     } catch (e) {
         return {
             error: `导出失败：${e && e.message ? e.message : '未知错误'}`,
             exported,
             failed,
-            root: CODEX_SKILLS_DIR
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir
         };
     } finally {
         try {
@@ -2149,6 +2329,10 @@ async function exportCodexSkills(params = {}) {
     }
 }
 
+async function exportCodexSkills(params = {}) {
+    return exportSkills({ ...(params || {}), targetApp: 'codex' });
+}
+
 function removeDirectoryRecursive(targetPath) {
     if (typeof fs.rmSync === 'function') {
         fs.rmSync(targetPath, { recursive: true, force: false });
@@ -2157,7 +2341,11 @@ function removeDirectoryRecursive(targetPath) {
     fs.rmdirSync(targetPath, { recursive: true });
 }
 
-function deleteCodexSkills(params = {}) {
+function deleteSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
     const rawList = Array.isArray(params.names) ? params.names : [];
     const uniqueNames = Array.from(new Set(rawList
         .map((item) => (typeof item === 'string' ? item.trim() : ''))
@@ -2175,8 +2363,8 @@ function deleteCodexSkills(params = {}) {
             continue;
         }
 
-        const skillPath = path.join(CODEX_SKILLS_DIR, normalized.name);
-        const relativePath = path.relative(CODEX_SKILLS_DIR, skillPath);
+        const skillPath = path.join(target.dir, normalized.name);
+        const relativePath = path.relative(target.dir, skillPath);
         if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
             failed.push({ name: normalized.name, error: '技能路径非法' });
             continue;
@@ -2206,10 +2394,16 @@ function deleteCodexSkills(params = {}) {
         success: failed.length === 0,
         deleted,
         failed,
-        root: CODEX_SKILLS_DIR
+        targetApp: target.app,
+        targetLabel: target.label,
+        root: target.dir
     };
 }
 
+function deleteCodexSkills(params = {}) {
+    return deleteSkills({ ...(params || {}), targetApp: 'codex' });
+}
+
 function readAgentsFile(params = {}) {
     const filePath = resolveAgentsFilePath(params);
     const dirCheck = validateAgentsBaseDir(filePath);
@@ -2991,11 +3185,40 @@ function buildVirtualDefaultConfig() {
     return toml.parse(EMPTY_CONFIG_FALLBACK_TEMPLATE);
 }
 
+function sanitizeRemovedBuiltinProxyProvider(config) {
+    const safeConfig = isPlainObject(config) ? config : {};
+    const providers = isPlainObject(safeConfig.model_providers) ? safeConfig.model_providers : null;
+    const currentProvider = typeof safeConfig.model_provider === 'string' ? safeConfig.model_provider.trim() : '';
+    const hasRemovedBuiltin = !!(providers && providers[BUILTIN_PROXY_PROVIDER_NAME]);
+    const currentIsRemovedBuiltin = currentProvider === BUILTIN_PROXY_PROVIDER_NAME;
+
+    if (!hasRemovedBuiltin && !currentIsRemovedBuiltin) {
+        return safeConfig;
+    }
+
+    const nextProviders = providers ? { ...providers } : {};
+    delete nextProviders[BUILTIN_PROXY_PROVIDER_NAME];
+    const providerNames = Object.keys(nextProviders);
+    const fallbackProvider = providerNames[0] || '';
+    const currentModels = readCurrentModels();
+    const fallbackModel = fallbackProvider
+        ? (currentModels[fallbackProvider] || (typeof safeConfig.model === 'string' ? safeConfig.model : ''))
+        : '';
+
+    return {
+        ...safeConfig,
+        model_providers: nextProviders,
+        model_provider: currentIsRemovedBuiltin ? fallbackProvider : safeConfig.model_provider,
+        model: currentIsRemovedBuiltin ? fallbackModel : safeConfig.model
+    };
+}
+
 function readConfigOrVirtualDefault() {
     if (fs.existsSync(CONFIG_FILE)) {
         try {
+            removePersistedBuiltinProxyProviderFromConfig();
             return {
-                config: readConfig(),
+                config: sanitizeRemovedBuiltinProxyProvider(readConfig()),
                 isVirtual: false,
                 reason: '',
                 detail: '',
@@ -3012,7 +3235,9 @@ function readConfigOrVirtualDefault() {
                 ? e.configDetail.trim()
                 : (e && e.message ? e.message : publicReason);
             return {
-                config: errorType === 'missing' ? buildVirtualDefaultConfig() : {},
+                config: errorType === 'missing'
+                    ? sanitizeRemovedBuiltinProxyProvider(buildVirtualDefaultConfig())
+                    : {},
                 isVirtual: true,
                 reason: publicReason,
                 detail,
@@ -3022,7 +3247,7 @@ function readConfigOrVirtualDefault() {
     }
 
     return {
-        config: buildVirtualDefaultConfig(),
+        config: sanitizeRemovedBuiltinProxyProvider(buildVirtualDefaultConfig()),
         isVirtual: true,
         reason: '未检测到 config.toml',
         detail: `配置文件不存在: ${CONFIG_FILE}`,
@@ -3118,8 +3343,8 @@ function getConfigTemplate(params = {}) {
             }
         } catch (e) {}
     }
-    const selectedProvider = params.provider || '';
-    const selectedModel = params.model || '';
+    const selectedProvider = typeof params.provider === 'string' ? params.provider.trim() : '';
+    const selectedModel = typeof params.model === 'string' ? params.model.trim() : '';
     let template = normalizeTopLevelConfigWithTemplate(content, selectedProvider, selectedModel);
     if (typeof params.serviceTier === 'string') {
         template = applyServiceTierToTemplate(template, params.serviceTier);
@@ -3196,7 +3421,7 @@ function addProviderToConfig(params = {}) {
         return { error: 'local provider 为系统保留名称，不可新增' };
     }
     if (isBuiltinProxyProvider(name) && !allowManaged) {
-        return { error: '本地代理配置为系统内建项，不可手动添加' };
+        return { error: 'codexmate-proxy 为保留名称，不可手动添加' };
     }
 
     ensureConfigDir();
@@ -3274,7 +3499,7 @@ function updateProviderInConfig(params = {}) {
         if (isDefaultLocalProvider(name)) {
             return { error: 'local provider 为系统保留项，不可编辑' };
         }
-        return { error: '本地代理配置为系统内建项，不可编辑' };
+        return { error: 'codexmate-proxy 为保留名称，不可编辑' };
     }
 
     try {
@@ -3292,7 +3517,7 @@ function deleteProviderFromConfig(params = {}) {
         if (isDefaultLocalProvider(name)) {
             return { error: 'local provider 为系统保留项，不可删除' };
         }
-        return { error: '本地代理配置为系统内建项，不可删除' };
+        return { error: 'codexmate-proxy 为保留名称，不可删除' };
     }
     if (!fs.existsSync(CONFIG_FILE)) {
         return { error: 'config.toml 不存在' };
@@ -3322,7 +3547,7 @@ function performProviderDeletion(name, options = {}) {
     if (isNonDeletableProvider(name)) {
         const msg = isDefaultLocalProvider(name)
             ? 'local provider 为系统保留项，不可删除'
-            : '本地代理配置为系统内建项，不可删除';
+            : 'codexmate-proxy 为保留名称，不可删除';
         if (!silent) console.error('错误:', msg);
         return { error: msg };
     }
@@ -3625,6 +3850,27 @@ function isPathInside(targetPath, rootPath) {
     return resolvedTarget.startsWith(rootWithSlash);
 }
 
+function resolveCopyTargetRoot(targetDir) {
+    const suffixSegments = [];
+    let current = path.resolve(targetDir || '');
+    while (current && !fs.existsSync(current)) {
+        const parent = path.dirname(current);
+        if (!parent || parent === current) {
+            break;
+        }
+        suffixSegments.unshift(path.basename(current));
+        current = parent;
+    }
+    let resolvedRoot = normalizePathForCompare(current || targetDir);
+    if (!resolvedRoot) {
+        resolvedRoot = path.resolve(targetDir || '');
+    }
+    for (const segment of suffixSegments) {
+        resolvedRoot = path.join(resolvedRoot, segment);
+    }
+    return resolvedRoot;
+}
+
 function collectJsonlFiles(rootDir, maxFiles = 5000) {
     if (!fs.existsSync(rootDir)) {
         return [];
@@ -5306,6 +5552,124 @@ function buildProxyListenUrl(settings) {
     return `http://${host}:${settings.port}`;
 }
 
+function buildBuiltinProxyProviderBaseUrl(settings) {
+    return `${buildProxyListenUrl(settings).replace(/\/+$/, '')}/v1`;
+}
+
+function buildBuiltinProxyProviderConfig(settings) {
+    return {
+        name: BUILTIN_PROXY_PROVIDER_NAME,
+        base_url: buildBuiltinProxyProviderBaseUrl(settings),
+        wire_api: 'responses',
+        requires_openai_auth: false,
+        preferred_auth_method: '',
+        request_max_retries: 4,
+        stream_max_retries: 10,
+        stream_idle_timeout_ms: 300000
+    };
+}
+
+function injectBuiltinProxyProvider(config) {
+    return isPlainObject(config) ? config : {};
+}
+
+function removePersistedBuiltinProxyProviderFromConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return { success: true, removed: false };
+    }
+
+    let config;
+    try {
+        config = readConfig();
+    } catch (e) {
+        return { error: e.message || '读取 config.toml 失败' };
+    }
+
+    if (!config.model_providers || !config.model_providers[BUILTIN_PROXY_PROVIDER_NAME]) {
+        return { success: true, removed: false };
+    }
+
+    const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
+    const hasBom = content.charCodeAt(0) === 0xFEFF;
+    const providerConfig = config.model_providers[BUILTIN_PROXY_PROVIDER_NAME];
+    const providerSegments = providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)
+        ? providerConfig.__codexmate_legacy_segments
+        : null;
+    const providerSegmentVariants = (() => {
+        const variants = [];
+        const seen = new Set();
+        const pushVariant = (segments) => {
+            const normalized = normalizeLegacySegments(segments);
+            const key = buildLegacySegmentsKey(normalized);
+            if (!key || seen.has(key)) return;
+            seen.add(key);
+            variants.push(normalized);
+        };
+        if (providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)) {
+            pushVariant(providerConfig.__codexmate_legacy_segments);
+        }
+        if (providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segment_variants)) {
+            for (const segments of providerConfig.__codexmate_legacy_segment_variants) {
+                pushVariant(segments);
+            }
+        }
+        if (providerSegments) {
+            pushVariant(providerSegments);
+        }
+        if (variants.length === 0) {
+            pushVariant(String(BUILTIN_PROXY_PROVIDER_NAME || '').split('.').filter((item) => item));
+        }
+        return variants;
+    })();
+
+    let updatedContent = null;
+    const combinedRanges = [];
+    for (const segments of providerSegmentVariants) {
+        combinedRanges.push(...findProviderSectionRanges(content, BUILTIN_PROXY_PROVIDER_NAME, segments));
+        combinedRanges.push(...findProviderDescendantSectionRanges(content, segments));
+    }
+    if (combinedRanges.length === 0) {
+        combinedRanges.push(...findProviderSectionRanges(content, BUILTIN_PROXY_PROVIDER_NAME, providerSegments));
+    }
+
+    if (combinedRanges.length > 0) {
+        const sorted = combinedRanges.sort((a, b) => b.start - a.start || b.end - a.end);
+        const seen = new Set();
+        let removedContent = content;
+        for (const range of sorted) {
+            const rangeKey = `${range.start}:${range.end}`;
+            if (seen.has(rangeKey)) continue;
+            seen.add(rangeKey);
+            removedContent = removedContent.slice(0, range.start) + removedContent.slice(range.end);
+        }
+        updatedContent = removedContent.replace(/\n{3,}/g, lineEnding + lineEnding);
+    }
+
+    if (!updatedContent) {
+        const rebuilt = JSON.parse(JSON.stringify(config));
+        delete rebuilt.model_providers[BUILTIN_PROXY_PROVIDER_NAME];
+        const hasMarker = content.includes(CODEXMATE_MANAGED_MARKER);
+        let rebuiltToml = toml.stringify(rebuilt).trimEnd();
+        rebuiltToml = rebuiltToml.replace(/\n/g, lineEnding);
+        if (hasMarker && !rebuiltToml.includes(CODEXMATE_MANAGED_MARKER)) {
+            rebuiltToml = `${CODEXMATE_MANAGED_MARKER}${lineEnding}${rebuiltToml}`;
+        }
+        updatedContent = rebuiltToml + lineEnding;
+        if (hasBom && updatedContent.charCodeAt(0) !== 0xFEFF) {
+            updatedContent = '\uFEFF' + updatedContent;
+        }
+    }
+
+    try {
+        writeConfig(updatedContent.trimEnd() + lineEnding);
+    } catch (e) {
+        return { error: e.message || '写入 config.toml 失败' };
+    }
+
+    return { success: true, removed: true };
+}
+
 function hasCodexConfigReadyForProxy() {
     const result = readConfigOrVirtualDefault();
     if (!result || result.isVirtual) {
@@ -5582,131 +5946,11 @@ function getBuiltinProxyStatus() {
 }
 
 function applyBuiltinProxyProvider(params = {}) {
-    const settings = readBuiltinProxySettings();
-    const hostForUrl = formatHostForUrl(settings.host);
-    const baseUrl = `http://${hostForUrl}:${settings.port}`;
-
-    const { config } = readConfigOrVirtualDefault();
-    const providers = config && isPlainObject(config.model_providers) ? config.model_providers : {};
-    const exists = !!providers[BUILTIN_PROXY_PROVIDER_NAME];
-    const saveResult = exists
-        ? updateProviderInConfig({
-            name: BUILTIN_PROXY_PROVIDER_NAME,
-            url: baseUrl,
-            key: '',
-            allowManaged: true
-        })
-        : addProviderToConfig({
-            name: BUILTIN_PROXY_PROVIDER_NAME,
-            url: baseUrl,
-            key: '',
-            allowManaged: true
-        });
-
-    if (saveResult && saveResult.error) {
-        return saveResult;
-    }
-
-    const switchToProxy = params.switchToProxy !== false;
-    let targetModel = '';
-    if (switchToProxy) {
-        try {
-            targetModel = cmdSwitch(BUILTIN_PROXY_PROVIDER_NAME, true) || '';
-        } catch (e) {
-            return { error: `写入代理 provider 成功，但切换失败: ${e.message}` };
-        }
-    }
-
-    return {
-        success: true,
-        provider: BUILTIN_PROXY_PROVIDER_NAME,
-        baseUrl,
-        switched: switchToProxy,
-        model: targetModel
-    };
+    return { error: '该功能已移除' };
 }
 
 async function ensureBuiltinProxyForCodexDefault(params = {}) {
-    const payload = isPlainObject(params) ? { ...params } : {};
-    const switchToProxy = payload.switchToProxy !== false;
-    delete payload.switchToProxy;
-    payload.enabled = true;
-
-    const saveResult = saveBuiltinProxySettings(payload);
-    if (saveResult.error) {
-        return { error: saveResult.error };
-    }
-    let nextSettings = saveResult.settings;
-
-    let upstreamResult = resolveBuiltinProxyUpstream(nextSettings);
-    if (upstreamResult.error) {
-        return { error: upstreamResult.error };
-    }
-
-    const runtime = g_builtinProxyRuntime;
-    const shouldRestart = !!runtime && (
-        runtime.settings.host !== nextSettings.host
-        || runtime.settings.port !== nextSettings.port
-        || runtime.settings.authSource !== nextSettings.authSource
-        || runtime.settings.timeoutMs !== nextSettings.timeoutMs
-        || runtime.upstream.providerName !== upstreamResult.providerName
-        || runtime.upstream.baseUrl !== upstreamResult.baseUrl
-        || runtime.upstream.authHeader !== upstreamResult.authHeader
-    );
-
-    if (shouldRestart) {
-        await stopBuiltinProxyRuntime();
-    }
-
-    if (!g_builtinProxyRuntime) {
-        let startRes = await startBuiltinProxyRuntime(nextSettings);
-        if (!startRes.success && /EADDRINUSE/i.test(String(startRes.error || ''))) {
-            const fallbackPort = await findAvailablePort(nextSettings.host, nextSettings.port + 1, 30);
-            if (fallbackPort > 0) {
-                const retrySave = saveBuiltinProxySettings({
-                    ...nextSettings,
-                    port: fallbackPort,
-                    enabled: true
-                });
-                if (retrySave.success) {
-                    nextSettings = retrySave.settings;
-                    upstreamResult = resolveBuiltinProxyUpstream(nextSettings);
-                    if (upstreamResult.error) {
-                        return { error: upstreamResult.error };
-                    }
-                    startRes = await startBuiltinProxyRuntime(nextSettings);
-                }
-            }
-        }
-        if (!startRes.success) {
-            return { error: startRes.error || '启动内建代理失败' };
-        }
-    }
-
-    let applyRes = {
-        success: true,
-        provider: BUILTIN_PROXY_PROVIDER_NAME,
-        baseUrl: buildProxyListenUrl(nextSettings),
-        switched: false,
-        model: ''
-    };
-    if (switchToProxy) {
-        applyRes = applyBuiltinProxyProvider({ switchToProxy: true });
-        if (applyRes.error) {
-            return applyRes;
-        }
-    }
-
-    const status = getBuiltinProxyStatus();
-    return {
-        success: true,
-        provider: applyRes.provider,
-        baseUrl: applyRes.baseUrl,
-        switched: applyRes.switched,
-        model: applyRes.model || '',
-        settings: status.settings,
-        runtime: status.runtime
-    };
+    return { error: '该功能已移除' };
 }
 
 function removeClaudeSessionIndexEntry(indexPath, sessionFilePath, sessionId) {
@@ -7348,7 +7592,8 @@ async function cmdSetup() {
         const { config } = readConfigOrVirtualDefault();
         const providers = config.model_providers || {};
         const providerNames = Object.keys(providers);
-        const defaultProvider = config.model_provider || providerNames[0] || '';
+        const currentProvider = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+        const defaultProvider = currentProvider || providerNames[0] || '';
         let availableModels = [];
         let defaultModel = config.model || '';
         let modelFetchUnlimited = false;
@@ -7634,7 +7879,7 @@ async function cmdModels() {
 
 // 切换提供商
 function cmdSwitch(providerName, silent = false) {
-    const config = readConfig();
+    const config = sanitizeRemovedBuiltinProxyProvider(readConfig());
     const providers = config.model_providers || {};
 
     if (!providers[providerName]) {
@@ -7737,6 +7982,10 @@ function cmdAdd(name, baseUrl, apiKey, silent = false) {
         if (!silent) console.error('错误: local provider 为系统保留名称，不可新增');
         throw new Error('local provider 为系统保留名称，不可新增');
     }
+    if (isBuiltinProxyProvider(providerName)) {
+        if (!silent) console.error('错误: codexmate-proxy 为保留名称，不可手动添加');
+        throw new Error('codexmate-proxy 为保留名称，不可手动添加');
+    }
 
     const config = readConfig();
     if (config.model_providers && config.model_providers[providerName]) {
@@ -7801,7 +8050,7 @@ function cmdUpdate(name, baseUrl, apiKey, silent = false, options = {}) {
     if (isNonEditableProvider(name) && !allowManaged) {
         const msg = isDefaultLocalProvider(name)
             ? 'local provider 为系统保留项，不可编辑'
-            : '本地代理配置为系统内建项，不可编辑';
+            : 'codexmate-proxy 为保留名称，不可编辑';
         if (!silent) console.error(`错误: ${msg}`);
         throw new Error(msg);
     }
@@ -9633,22 +9882,55 @@ function resolveUploadFileNameFromRequest(req, fallbackName = 'codex-skills.zip'
     return normalized || fallback;
 }
 
-async function handleImportCodexSkillsZipUpload(req, res) {
+function resolveSkillTargetAppFromRequest(req, fallbackApp = 'codex') {
+    const fallbackTarget = resolveSkillTarget({}, fallbackApp);
+    const fallback = fallbackTarget ? fallbackTarget.app : 'codex';
+    try {
+        const parsed = new URL(req.url || '/', 'http://localhost');
+        const hasTargetApp = parsed.searchParams.has('targetApp');
+        const hasTarget = parsed.searchParams.has('target');
+        if (hasTargetApp || hasTarget) {
+            const target = resolveSkillTarget({
+                ...(hasTargetApp ? { targetApp: parsed.searchParams.get('targetApp') } : {}),
+                ...(hasTarget ? { target: parsed.searchParams.get('target') } : {})
+            }, fallback);
+            return target ? target.app : null;
+        }
+        return fallback;
+    } catch (_) {
+        return fallback;
+    }
+}
+
+async function handleImportSkillsZipUpload(req, res, options = {}) {
     if (req.method !== 'POST') {
+        if (req && typeof req.resume === 'function') {
+            req.resume();
+        }
         writeJsonResponse(res, 405, { error: 'Method Not Allowed' });
         return;
     }
     try {
-        const fileName = resolveUploadFileNameFromRequest(req, 'codex-skills.zip');
+        const forcedTargetApp = normalizeSkillTargetApp(options && options.targetApp ? options.targetApp : '');
+        const targetApp = forcedTargetApp || resolveSkillTargetAppFromRequest(req, 'codex');
+        if (!targetApp) {
+            if (req && typeof req.resume === 'function') {
+                req.resume();
+            }
+            writeJsonResponse(res, 400, { error: '目标宿主不支持' });
+            return;
+        }
+        const fileName = resolveUploadFileNameFromRequest(req, `${targetApp}-skills.zip`);
         const upload = await writeUploadZipStream(
             req,
             'codex-skills-import',
             fileName,
             MAX_SKILLS_ZIP_UPLOAD_SIZE
         );
-        const result = await importCodexSkillsFromZipFile(upload.zipPath, {
+        const result = await importSkillsFromZipFile(upload.zipPath, {
             tempDir: upload.tempDir,
-            fallbackName: fileName
+            fallbackName: fileName,
+            targetApp
         });
         writeJsonResponse(res, 200, result || {});
     } catch (e) {
@@ -9662,8 +9944,12 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
 
     const server = http.createServer((req, res) => {
         const requestPath = (req.url || '/').split('?')[0];
+        if (requestPath === '/api/import-skills-zip') {
+            void handleImportSkillsZipUpload(req, res);
+            return;
+        }
         if (requestPath === '/api/import-codex-skills-zip') {
-            void handleImportCodexSkillsZipUpload(req, res);
+            void handleImportSkillsZipUpload(req, res, { targetApp: 'codex' });
             return;
         }
         if (requestPath === '/api') {
@@ -9795,6 +10081,21 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'preview-agents-diff':
                             result = buildAgentsDiff(params || {});
                             break;
+                        case 'list-skills':
+                            result = listSkills(params || {});
+                            break;
+                        case 'delete-skills':
+                            result = deleteSkills(params || {});
+                            break;
+                        case 'scan-unmanaged-skills':
+                            result = scanUnmanagedSkills(params || {});
+                            break;
+                        case 'import-skills':
+                            result = importSkills(params || {});
+                            break;
+                        case 'export-skills':
+                            result = await exportSkills(params || {});
+                            break;
                         case 'list-codex-skills':
                             result = listCodexSkills();
                             break;
@@ -10154,7 +10455,9 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
         process.exit(1);
     });
 
-    const openHost = isAnyAddressHost(host) ? DEFAULT_WEB_HOST : host;
+    const openHost = host === '::'
+        ? '::1'
+        : (host === '0.0.0.0' ? DEFAULT_WEB_OPEN_HOST : host);
     const openUrl = `http://${formatHostForUrl(openHost)}:${port}`;
     server.listen(port, host, () => {
         console.log('\n✓ Web UI 已启动:', openUrl);
@@ -10297,25 +10600,6 @@ function cmdStart(options = {}) {
         openBrowser: !options.noBrowser
     });
 
-    const proxySettings = readBuiltinProxySettings();
-    const shouldAutoStartProxy = proxySettings.enabled || hasCodexConfigReadyForProxy();
-    if (shouldAutoStartProxy) {
-        ensureBuiltinProxyForCodexDefault({
-            ...proxySettings,
-            switchToProxy: false
-        }).then((res) => {
-            if (res && res.success && res.runtime && res.runtime.listenUrl) {
-                const entryProvider = res.runtime.provider || DEFAULT_LOCAL_PROVIDER_NAME;
-                const upstreamLabel = res.runtime.upstreamProvider ? `（上游: ${res.runtime.upstreamProvider}）` : '';
-                console.log(`~ 内建代理已启动(${entryProvider}): ${res.runtime.listenUrl}${upstreamLabel}`);
-            } else if (res && res.error) {
-                console.warn(`! 内建代理启动失败: ${res.error}`);
-            }
-        }).catch((err) => {
-            console.warn(`! 内建代理启动失败: ${err && err.message ? err.message : err}`);
-        });
-    }
-
     const requestWebUiRestart = createSerializedWebUiRestartHandler(async (info) => {
             const fileLabel = info && info.filename ? info.filename : (info && info.target ? path.basename(info.target) : 'unknown');
             console.log(`\n~ 侦测到前端变更 (${fileLabel})，重启中...`);
@@ -10507,111 +10791,8 @@ function parseProxyCliOptions(args = []) {
 }
 
 async function cmdProxy(args = []) {
-    const subcommand = (args[0] || 'status').toLowerCase();
-    const optionResult = parseProxyCliOptions(args.slice(1));
-    if (optionResult.error) {
-        throw new Error(optionResult.error);
-    }
-    const options = optionResult.payload || {};
-
-    if (subcommand === 'status') {
-        const status = getBuiltinProxyStatus();
-        const settings = status.settings || DEFAULT_BUILTIN_PROXY_SETTINGS;
-        console.log('\n内建代理状态:');
-        console.log('  运行中:', status.running ? '是' : '否');
-        console.log('  启用:', settings.enabled ? '是' : '否');
-        console.log('  监听:', buildProxyListenUrl(settings));
-        console.log('  上游 provider:', settings.provider || '(自动)');
-        console.log('  鉴权来源:', settings.authSource);
-        if (status.runtime) {
-            console.log('  实际上游:', status.runtime.upstreamProvider);
-            console.log('  启动时间:', status.runtime.startedAt);
-        }
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'set' || subcommand === 'config') {
-        const result = saveBuiltinProxySettings(options);
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        const settings = result.settings;
-        console.log('✓ 内建代理配置已保存');
-        console.log('  监听:', buildProxyListenUrl(settings));
-        console.log('  上游 provider:', settings.provider || '(自动)');
-        console.log('  鉴权来源:', settings.authSource);
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'apply' || subcommand === 'apply-provider') {
-        const result = applyBuiltinProxyProvider({
-            switchToProxy: options.switchToProxy !== false
-        });
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        console.log(`✓ 已写入本地代理 provider: ${result.provider}`);
-        console.log(`  URL: ${result.baseUrl}`);
-        if (result.switched) {
-            console.log(`  已切换到 ${result.provider}${result.model ? ` / ${result.model}` : ''}`);
-        }
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'enable' || subcommand === 'default-codex') {
-        const result = await ensureBuiltinProxyForCodexDefault(options);
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        const listenUrl = result.runtime && result.runtime.listenUrl
-            ? result.runtime.listenUrl
-            : buildProxyListenUrl(result.settings || DEFAULT_BUILTIN_PROXY_SETTINGS);
-        console.log('✓ 已启用 Codex 内建代理默认模式');
-        console.log(`  监听: ${listenUrl}`);
-        if (result.runtime && result.runtime.upstreamProvider) {
-            console.log(`  上游 provider: ${result.runtime.upstreamProvider}`);
-        }
-        console.log(`  当前 provider: ${result.provider}${result.model ? ` / ${result.model}` : ''}`);
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'start') {
-        const result = await startBuiltinProxyRuntime({
-            ...options,
-            enabled: true
-        });
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        console.log(`✓ 内建代理已启动: ${result.listenUrl}`);
-        console.log(`  上游 provider: ${result.upstreamProvider}`);
-        console.log('  按 Ctrl+C 停止代理\n');
-
-        await new Promise((resolve) => {
-            let stopping = false;
-            const gracefulStop = async () => {
-                if (stopping) return;
-                stopping = true;
-                await stopBuiltinProxyRuntime();
-                resolve();
-            };
-            process.once('SIGINT', gracefulStop);
-            process.once('SIGTERM', gracefulStop);
-        });
-        return;
-    }
-
-    if (subcommand === 'stop') {
-        await stopBuiltinProxyRuntime();
-        console.log('✓ 内建代理已停止\n');
-        return;
-    }
-
-    throw new Error(`未知 proxy 子命令: ${subcommand}`);
+    void args;
+    throw new Error('该功能已移除');
 }
 
 function parseWorkflowInputArg(rawInput) {
@@ -12685,11 +12866,9 @@ async function main() {
         console.log('  codexmate claude <BaseURL> <API密钥> [模型]  写入 Claude Code 配置');
         console.log('  codexmate add-model <模型> 添加模型');
         console.log('  codexmate delete-model <模型> 删除模型');
-        console.log('  codexmate auth <list|import|switch|delete|status>  认证文件管理');
-        console.log('  codexmate proxy <status|set|apply|enable|start|stop>  内建代理');
         console.log('  codexmate workflow <list|get|validate|run|runs>  MCP 工作流中心');
         console.log('  codexmate run [--host <HOST>] [--no-browser]    启动 Web 界面');
-        console.log('  codexmate codex [参数...] [--follow-up <文本>|--queued-follow-up <文本> 可重复]  等同于 codex --yolo（不会自动启用内建代理）');
+        console.log('  codexmate codex [参数...] [--follow-up <文本>|--queued-follow-up <文本> 可重复]  等同于 codex --yolo');
         console.log('    注: follow-up 自动排队仅支持 linux/android/netbsd/openbsd/darwin/freebsd 且 stdin 必须是 TTY，其他平台会报错');
         console.log('  codexmate qwen [参数...]   等同于 qwen --yolo');
         console.log('  codexmate mcp [serve] [--transport stdio] [--allow-write|--read-only]');