codexmate 0.0.14 → 0.0.16

package/cli.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const toml = require('@iarna/toml');
 const JSON5 = require('json5');
 const zipLib = require('zip-lib');
+const yauzl = require('yauzl');
 const { exec, execSync, spawn, spawnSync } = require('child_process');
 const http = require('http');
 const https = require('https');
@@ -108,12 +109,10 @@ const MAX_SESSION_PATH_LIST_SIZE = 2000;
 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 GEMINI_SKILLS_DIR = path.join(os.homedir(), '.gemini', 'skills');
-const OPENCODE_SKILLS_DIR = path.join(os.homedir(), '.opencode', 'skills');
+const AGENTS_SKILLS_DIR = path.join(os.homedir(), '.agents', 'skills');
 const SKILL_IMPORT_SOURCES = Object.freeze([
     { app: 'claude', label: 'Claude Code', dir: CLAUDE_SKILLS_DIR },
-    { app: 'gemini', label: 'Gemini CLI', dir: GEMINI_SKILLS_DIR },
-    { app: 'opencode', label: 'OpenCode', dir: OPENCODE_SKILLS_DIR }
+    { app: 'agents', label: 'Agents', dir: AGENTS_SKILLS_DIR }
 ]);
 const MODELS_CACHE_TTL_MS = 60 * 1000;
 const MODELS_NEGATIVE_CACHE_TTL_MS = 5 * 1000;
@@ -121,6 +120,12 @@ const MODELS_CACHE_MAX_ENTRIES = 50;
 const MODELS_RESPONSE_MAX_BYTES = 1024 * 1024;
 const MAX_RECENT_CONFIGS = 3;
 const MAX_UPLOAD_SIZE = 200 * 1024 * 1024;
+const MAX_SKILLS_ZIP_UPLOAD_SIZE = 20 * 1024 * 1024;
+const MAX_SKILLS_ZIP_ENTRY_COUNT = 2000;
+const MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+const DEFAULT_EXTRACT_SUFFIXES = Object.freeze(['.json']);
+const DOWNLOAD_ARTIFACT_TTL_MS = 10 * 60 * 1000;
+const g_downloadArtifacts = new Map();
 const BUILTIN_PROXY_PROVIDER_NAME = 'codexmate-proxy';
 const DEFAULT_BUILTIN_PROXY_SETTINGS = Object.freeze({
     enabled: false,
@@ -1804,6 +1809,7 @@ function importCodexSkills(params = {}) {
             const visitedRealPaths = new Set([sourceDirForCopy]);
             copyDirRecursive(sourceDirForCopy, targetPath, {
                 dereferenceSymlinks: true,
+                allowedRootRealPath: sourceDirForCopy,
                 visitedRealPaths
             });
             copiedToTarget = true;
@@ -1835,6 +1841,306 @@ function importCodexSkills(params = {}) {
     };
 }
 
+function collectSkillDirectoriesFromRoot(rootDir, limit = MAX_SKILLS_ZIP_ENTRY_COUNT) {
+    const results = [];
+    let truncated = false;
+    if (!rootDir || !fs.existsSync(rootDir)) {
+        return { results, truncated };
+    }
+    const normalizedLimit = Number.isFinite(limit) && limit > 0
+        ? Math.floor(limit)
+        : MAX_SKILLS_ZIP_ENTRY_COUNT;
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        if (results.length >= normalizedLimit) {
+            truncated = true;
+            break;
+        }
+        const currentDir = stack.pop();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        } catch (e) {
+            continue;
+        }
+
+        const hasSkillFile = entries.some((entry) => entry && entry.isFile() && String(entry.name || '') === 'SKILL.md');
+        if (hasSkillFile) {
+            results.push(currentDir);
+            continue;
+        }
+
+        for (const entry of entries) {
+            if (!entry || !entry.isDirectory()) continue;
+            const entryName = typeof entry.name === 'string' ? entry.name.trim() : '';
+            if (!entryName || entryName.startsWith('.')) {
+                continue;
+            }
+            stack.push(path.join(currentDir, entryName));
+        }
+    }
+    return { results, truncated };
+}
+
+function resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbackName = '') {
+    const directoryBaseName = path.basename(skillDir || '');
+    const extractionBaseName = path.basename(extractionRoot || '');
+    let candidate = directoryBaseName;
+    if (!candidate || candidate === extractionBaseName || candidate.startsWith('.')) {
+        const fallback = typeof fallbackName === 'string' ? fallbackName.trim() : '';
+        const fallbackBase = fallback ? path.basename(fallback, path.extname(fallback)) : '';
+        candidate = fallbackBase || candidate;
+    }
+    return normalizeCodexSkillName(candidate);
+}
+
+async function importCodexSkillsFromZipFile(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');
+
+    try {
+        await inspectZipArchiveLimits(zipPath, {
+            maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
+            maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
+        });
+
+        await extractUploadZip(zipPath, extractionRoot);
+        const discovery = collectSkillDirectoriesFromRoot(extractionRoot, MAX_SKILLS_ZIP_ENTRY_COUNT);
+        const discoveredDirs = discovery.results;
+        if (discoveredDirs.length === 0) {
+            return { error: '压缩包中未发现包含 SKILL.md 的技能目录' };
+        }
+        if (discovery.truncated) {
+            return { error: '压缩包中的技能目录数量超出导入上限' };
+        }
+
+        ensureDir(CODEX_SKILLS_DIR);
+        for (const skillDir of discoveredDirs) {
+            const normalizedName = resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbackName);
+            if (normalizedName.error) {
+                failed.push({
+                    name: path.basename(skillDir || ''),
+                    error: normalizedName.error
+                });
+                continue;
+            }
+            const dedupKey = normalizedName.name.toLowerCase();
+            if (dedupNames.has(dedupKey)) {
+                continue;
+            }
+            dedupNames.add(dedupKey);
+
+            const targetPath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
+            const targetRelative = path.relative(CODEX_SKILLS_DIR, targetPath);
+            if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
+                failed.push({
+                    name: normalizedName.name,
+                    error: '目标路径非法'
+                });
+                continue;
+            }
+            if (fs.existsSync(targetPath)) {
+                failed.push({
+                    name: normalizedName.name,
+                    error: 'Codex 中已存在同名 skill'
+                });
+                continue;
+            }
+
+            let copiedToTarget = false;
+            try {
+                const sourceRealPath = fs.realpathSync(skillDir);
+                const sourceStat = fs.statSync(sourceRealPath);
+                if (!sourceStat.isDirectory()) {
+                    failed.push({
+                        name: normalizedName.name,
+                        error: '来源 skill 无法读取'
+                    });
+                    continue;
+                }
+                const visitedRealPaths = new Set([sourceRealPath]);
+                copyDirRecursive(sourceRealPath, targetPath, {
+                    dereferenceSymlinks: true,
+                    allowedRootRealPath: sourceRealPath,
+                    visitedRealPaths
+                });
+                copiedToTarget = true;
+                imported.push({
+                    name: normalizedName.name,
+                    path: targetPath
+                });
+            } catch (e) {
+                if (!copiedToTarget && fs.existsSync(targetPath)) {
+                    try {
+                        removeDirectoryRecursive(targetPath);
+                    } catch (_) {}
+                }
+                failed.push({
+                    name: normalizedName.name,
+                    error: e && e.message ? e.message : '导入失败'
+                });
+            }
+        }
+
+        if (imported.length === 0 && failed.length > 0) {
+            return {
+                error: failed[0].error || '导入失败',
+                imported,
+                failed,
+                root: CODEX_SKILLS_DIR
+            };
+        }
+
+        return {
+            success: failed.length === 0,
+            imported,
+            failed,
+            root: CODEX_SKILLS_DIR
+        };
+    } catch (e) {
+        return {
+            error: `导入失败：${e && e.message ? e.message : '未知错误'}`
+        };
+    } finally {
+        if (tempDir) {
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            } catch (_) {}
+        } else if (fs.existsSync(extractionRoot)) {
+            try {
+                fs.rmSync(extractionRoot, { recursive: true, force: true });
+            } catch (_) {}
+        }
+    }
+}
+
+async function importCodexSkillsFromZip(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');
+    if (upload.error) {
+        return { error: upload.error };
+    }
+    return importCodexSkillsFromZipFile(upload.zipPath, {
+        tempDir: upload.tempDir,
+        fallbackName: payload.fileName || ''
+    });
+}
+
+async function exportCodexSkills(params = {}) {
+    const rawNames = Array.isArray(params.names) ? params.names : [];
+    const uniqueNames = Array.from(new Set(rawNames
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter(Boolean)));
+    if (uniqueNames.length === 0) {
+        return { error: '请先选择要导出的 skill' };
+    }
+
+    const exported = [];
+    const failed = [];
+    const stagingTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-skills-export-'));
+    const stagingRoot = path.join(stagingTempDir, 'skills');
+    ensureDir(stagingRoot);
+
+    try {
+        for (const rawName of uniqueNames) {
+            const normalizedName = normalizeCodexSkillName(rawName);
+            if (normalizedName.error) {
+                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);
+            if (sourceRelative.startsWith('..') || path.isAbsolute(sourceRelative)) {
+                failed.push({ name: normalizedName.name, error: '来源路径非法' });
+                continue;
+            }
+            if (!fs.existsSync(sourcePath)) {
+                failed.push({ name: normalizedName.name, error: 'skill 不存在' });
+                continue;
+            }
+
+            try {
+                const lstat = fs.lstatSync(sourcePath);
+                if (!lstat.isDirectory() && !lstat.isSymbolicLink()) {
+                    failed.push({ name: normalizedName.name, error: '来源不是技能目录' });
+                    continue;
+                }
+                const sourceDirForCopy = lstat.isSymbolicLink() ? fs.realpathSync(sourcePath) : sourcePath;
+                const sourceStat = fs.statSync(sourceDirForCopy);
+                if (!sourceStat.isDirectory()) {
+                    failed.push({ name: normalizedName.name, error: '来源 skill 无法读取' });
+                    continue;
+                }
+                const targetPath = path.join(stagingRoot, normalizedName.name);
+                const visitedRealPaths = new Set([sourceDirForCopy]);
+                copyDirRecursive(sourceDirForCopy, targetPath, {
+                    dereferenceSymlinks: true,
+                    allowedRootRealPath: sourceDirForCopy,
+                    visitedRealPaths
+                });
+                exported.push({
+                    name: normalizedName.name,
+                    path: sourcePath
+                });
+            } catch (e) {
+                failed.push({
+                    name: normalizedName.name,
+                    error: e && e.message ? e.message : '导出失败'
+                });
+            }
+        }
+
+        if (exported.length === 0) {
+            return {
+                error: failed[0] && failed[0].error ? failed[0].error : '无可导出的 skill',
+                exported,
+                failed,
+                root: CODEX_SKILLS_DIR
+            };
+        }
+
+        const randomToken = crypto.randomBytes(12).toString('hex');
+        const zipFileName = `codex-skills-${randomToken}.zip`;
+        const zipFilePath = path.join(os.tmpdir(), zipFileName);
+        if (fs.existsSync(zipFilePath)) {
+            try {
+                fs.unlinkSync(zipFilePath);
+            } catch (_) {}
+        }
+        await zipLib.archiveFolder(stagingRoot, zipFilePath);
+        const artifact = registerDownloadArtifact(zipFilePath, {
+            fileName: zipFileName,
+            deleteAfterDownload: true
+        });
+
+        return {
+            success: failed.length === 0,
+            fileName: zipFileName,
+            downloadPath: artifact.downloadPath,
+            exported,
+            failed,
+            root: CODEX_SKILLS_DIR
+        };
+    } catch (e) {
+        return {
+            error: `导出失败：${e && e.message ? e.message : '未知错误'}`,
+            exported,
+            failed,
+            root: CODEX_SKILLS_DIR
+        };
+    } finally {
+        try {
+            fs.rmSync(stagingTempDir, { recursive: true, force: true });
+        } catch (_) {}
+    }
+}
+
 function removeDirectoryRecursive(targetPath) {
     if (typeof fs.rmSync === 'function') {
         fs.rmSync(targetPath, { recursive: true, force: false });
@@ -6629,6 +6935,70 @@ function readClaudeSettingsInfo() {
     };
 }
 
+function registerDownloadArtifact(filePath, options = {}) {
+    const token = crypto.randomBytes(16).toString('hex');
+    const fileName = typeof options.fileName === 'string' && options.fileName.trim()
+        ? options.fileName.trim()
+        : path.basename(filePath || '');
+    const ttlMs = Number.isFinite(options.ttlMs) && options.ttlMs > 0
+        ? Math.floor(options.ttlMs)
+        : DOWNLOAD_ARTIFACT_TTL_MS;
+    const expiresAt = Date.now() + ttlMs;
+    const deleteAfterDownload = options.deleteAfterDownload !== false;
+
+    g_downloadArtifacts.set(token, {
+        filePath,
+        fileName,
+        deleteAfterDownload,
+        expiresAt
+    });
+
+    setTimeout(() => {
+        const artifact = g_downloadArtifacts.get(token);
+        if (!artifact) return;
+        if (Date.now() < artifact.expiresAt) return;
+        g_downloadArtifacts.delete(token);
+        if (artifact.deleteAfterDownload && artifact.filePath && fs.existsSync(artifact.filePath)) {
+            try {
+                fs.unlinkSync(artifact.filePath);
+            } catch (_) {}
+        }
+    }, ttlMs + 2000);
+
+    return {
+        token,
+        fileName,
+        downloadPath: `/download/${encodeURIComponent(token)}`
+    };
+}
+
+function resolveDownloadArtifact(tokenOrFileName, options = {}) {
+    if (!tokenOrFileName) return null;
+    const token = typeof tokenOrFileName === 'string' ? tokenOrFileName.trim() : '';
+    if (!token) return null;
+
+    const artifact = g_downloadArtifacts.get(token);
+    if (!artifact) {
+        return null;
+    }
+    if (Date.now() > artifact.expiresAt) {
+        g_downloadArtifacts.delete(token);
+        if (artifact.deleteAfterDownload && artifact.filePath && fs.existsSync(artifact.filePath)) {
+            try {
+                fs.unlinkSync(artifact.filePath);
+            } catch (_) {}
+        }
+        return null;
+    }
+    if (options && options.consume === true) {
+        g_downloadArtifacts.delete(token);
+    }
+    return {
+        token,
+        ...artifact
+    };
+}
+
 // API: 打包 Claude 配置目录（系统 zip 可用则使用，否则回退 zip-lib）
 async function prepareClaudeDirDownload() {
     try {
@@ -6693,12 +7063,16 @@ async function prepareCodexDirDownload() {
 
 function copyDirRecursive(srcDir, destDir, options = {}) {
     const dereferenceSymlinks = !!(options && options.dereferenceSymlinks);
+    const allowedRootRealPath = (options && typeof options.allowedRootRealPath === 'string')
+        ? options.allowedRootRealPath
+        : '';
     const visitedRealPaths = options && options.visitedRealPaths instanceof Set
         ? options.visitedRealPaths
         : new Set();
     const childOptions = {
         ...options,
         dereferenceSymlinks,
+        allowedRootRealPath,
         visitedRealPaths
     };
     ensureDir(destDir);
@@ -6712,6 +7086,9 @@ function copyDirRecursive(srcDir, destDir, options = {}) {
                 continue;
             }
             const realPath = fs.realpathSync(srcPath);
+            if (allowedRootRealPath && !isPathInside(realPath, allowedRootRealPath)) {
+                throw new Error(`symlink escapes skill root: ${srcPath}`);
+            }
             if (visitedRealPaths.has(realPath)) {
                 continue;
             }
@@ -6724,6 +7101,9 @@ function copyDirRecursive(srcDir, destDir, options = {}) {
         } else if (entry.isSymbolicLink()) {
             if (dereferenceSymlinks) {
                 const realPath = fs.realpathSync(srcPath);
+                if (allowedRootRealPath && !isPathInside(realPath, allowedRootRealPath)) {
+                    throw new Error(`symlink escapes skill root: ${srcPath}`);
+                }
                 const realStat = fs.statSync(realPath);
                 if (realStat.isDirectory()) {
                     if (visitedRealPaths.has(realPath)) {
@@ -6748,6 +7128,139 @@ function copyDirRecursive(srcDir, destDir, options = {}) {
     }
 }
 
+function inspectZipArchiveLimits(zipPath, options = {}) {
+    const maxEntryCount = Number.isFinite(options.maxEntryCount) && options.maxEntryCount > 0
+        ? Math.floor(options.maxEntryCount)
+        : MAX_SKILLS_ZIP_ENTRY_COUNT;
+    const maxUncompressedBytes = Number.isFinite(options.maxUncompressedBytes) && options.maxUncompressedBytes > 0
+        ? Math.floor(options.maxUncompressedBytes)
+        : MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES;
+
+    return new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true, autoClose: true }, (openErr, zipFile) => {
+            if (openErr) {
+                reject(openErr);
+                return;
+            }
+            if (!zipFile) {
+                reject(new Error('无法读取 ZIP 文件'));
+                return;
+            }
+            let entryCount = 0;
+            let totalUncompressedBytes = 0;
+            let settled = false;
+            const finish = (err, data) => {
+                if (settled) return;
+                settled = true;
+                try {
+                    zipFile.close();
+                } catch (_) {}
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(data);
+                }
+            };
+
+            zipFile.on('entry', (entry) => {
+                if (settled) return;
+                entryCount += 1;
+                const entrySize = Number.isFinite(entry.uncompressedSize) ? entry.uncompressedSize : 0;
+                totalUncompressedBytes += entrySize;
+                if (entryCount > maxEntryCount) {
+                    finish(new Error(`压缩包条目过多（>${maxEntryCount}）`));
+                    return;
+                }
+                if (totalUncompressedBytes > maxUncompressedBytes) {
+                    finish(new Error(`压缩包解压总大小超限（>${Math.floor(maxUncompressedBytes / 1024 / 1024)}MB）`));
+                    return;
+                }
+                zipFile.readEntry();
+            });
+
+            zipFile.on('end', () => {
+                finish(null, { entryCount, totalUncompressedBytes });
+            });
+
+            zipFile.on('error', (zipErr) => {
+                finish(zipErr);
+            });
+
+            zipFile.readEntry();
+        });
+    });
+}
+
+function writeUploadZipStream(req, prefix, originalName = '', maxSize = MAX_SKILLS_ZIP_UPLOAD_SIZE) {
+    return new Promise((resolve, reject) => {
+        const lengthHeader = parseInt(req.headers['content-length'] || '0', 10);
+        if (Number.isFinite(lengthHeader) && lengthHeader > maxSize) {
+            reject(new Error(`备份文件过大（>${Math.floor(maxSize / 1024 / 1024)}MB）`));
+            return;
+        }
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
+        const rawName = originalName && typeof originalName === 'string' ? originalName : `${prefix}.zip`;
+        const fileName = path.basename(rawName);
+        const zipPath = path.join(tempDir, fileName.toLowerCase().endsWith('.zip') ? fileName : `${fileName}.zip`);
+        const stream = fs.createWriteStream(zipPath);
+        let bytesWritten = 0;
+        let settled = false;
+        let hasContent = false;
+
+        const fail = (err) => {
+            if (settled) return;
+            settled = true;
+            try {
+                stream.destroy();
+            } catch (_) {}
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            } catch (_) {}
+            reject(err);
+        };
+
+        const done = () => {
+            if (settled) return;
+            settled = true;
+            if (!hasContent || bytesWritten <= 0) {
+                try {
+                    fs.rmSync(tempDir, { recursive: true, force: true });
+                } catch (_) {}
+                reject(new Error('备份文件为空'));
+                return;
+            }
+            resolve({ tempDir, zipPath });
+        };
+
+        req.on('error', (err) => fail(err));
+        req.on('aborted', () => fail(new Error('上传已中断')));
+        req.on('close', () => {
+            if (!settled && !req.complete) {
+                fail(new Error('上传已中断'));
+            }
+        });
+        stream.on('error', (err) => fail(err));
+        req.on('data', (chunk) => {
+            if (settled) return;
+            hasContent = true;
+            bytesWritten += chunk.length;
+            if (bytesWritten > maxSize) {
+                fail(new Error(`备份文件过大（>${Math.floor(maxSize / 1024 / 1024)}MB）`));
+                try {
+                    req.destroy();
+                } catch (_) {}
+                return;
+            }
+            stream.write(chunk);
+        });
+        req.on('end', () => {
+            if (settled) return;
+            stream.end(() => done());
+        });
+    });
+}
+
 function writeUploadZip(base64, prefix, originalName = '') {
     let buffer;
     try {
@@ -7272,27 +7785,339 @@ async function cmdUnzip(zipPath, outputDir) {
     }
 }
 
-function resolveExportOutputPath(outputPath, defaultFileName) {
-    const fallback = path.resolve(process.cwd(), defaultFileName);
-    if (typeof outputPath !== 'string' || !outputPath.trim()) {
-        return fallback;
+function splitExtractSuffixInput(rawValue) {
+    if (Array.isArray(rawValue)) {
+        return rawValue.flatMap((item) => splitExtractSuffixInput(item));
     }
-
-    const trimmed = outputPath.trim();
-    const resolved = path.resolve(trimmed);
-    const hasTrailingSep = /[\\\/]$/.test(trimmed);
-    if (hasTrailingSep) {
-        ensureDir(resolved);
-        return path.join(resolved, defaultFileName);
+    if (typeof rawValue !== 'string') {
+        return [];
     }
+    return rawValue
+        .split(/[,\s]+/g)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
 
-    if (fs.existsSync(resolved)) {
-        try {
-            const stat = fs.statSync(resolved);
-            if (stat.isDirectory()) {
-                return path.join(resolved, defaultFileName);
-            }
-        } catch (e) {}
+function normalizeExtractSuffix(rawSuffix, fallbackSuffixes = DEFAULT_EXTRACT_SUFFIXES) {
+    const fallbackItems = splitExtractSuffixInput(fallbackSuffixes);
+    const sourceItems = splitExtractSuffixInput(rawSuffix);
+    const source = sourceItems.length > 0 ? sourceItems : fallbackItems;
+    const dedup = new Set();
+
+    for (const item of source) {
+        const lower = item.toLowerCase();
+        if (!lower) {
+            continue;
+        }
+        const normalized = lower.startsWith('.') ? lower : `.${lower}`;
+        if (normalized.length > 1) {
+            dedup.add(normalized);
+        }
+    }
+
+    if (dedup.size === 0) {
+        return [...DEFAULT_EXTRACT_SUFFIXES];
+    }
+    return Array.from(dedup);
+}
+
+function buildDefaultExtractOutputDir(baseCwd = process.cwd()) {
+    const normalizedCwd = path.resolve(baseCwd);
+    const parentDir = path.dirname(normalizedCwd);
+    const timestamp = formatTimestampForFileName().replace(/-/g, '');
+    return path.join(parentDir, timestamp);
+}
+
+function sanitizeNameSegment(rawValue, fallback = 'item') {
+    const value = typeof rawValue === 'string' ? rawValue.trim() : '';
+    const sanitized = value
+        .replace(/[^\w.-]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return sanitized || fallback;
+}
+
+function resolveDuplicateOutputPath(outputDir, originalFileName, zipPath = '', counters = new Map()) {
+    const fallbackName = `file${path.extname(originalFileName || '')}`;
+    const fileName = path.basename(originalFileName || '') || fallbackName;
+    const firstChoice = path.join(outputDir, fileName);
+    const firstChoiceKey = `exact:${fileName}`;
+    if (!counters.has(firstChoiceKey)) {
+        counters.set(firstChoiceKey, true);
+        if (!fs.existsSync(firstChoice)) {
+            return firstChoice;
+        }
+    }
+
+    const ext = path.extname(fileName);
+    const baseName = path.basename(fileName, ext);
+    const safeBaseName = sanitizeNameSegment(baseName, 'file');
+    const zipBaseName = sanitizeNameSegment(path.basename(zipPath || '', '.zip'), 'zip');
+    const duplicateKey = `dup:${safeBaseName}|${zipBaseName}|${ext}`;
+    let index = counters.has(duplicateKey) ? counters.get(duplicateKey) : 1;
+
+    for (; index <= 100000; index++) {
+        const candidateName = `${safeBaseName}__${zipBaseName}__${index}${ext}`;
+        const candidatePath = path.join(outputDir, candidateName);
+        if (!fs.existsSync(candidatePath)) {
+            counters.set(duplicateKey, index + 1);
+            return candidatePath;
+        }
+    }
+
+    throw new Error(`重名文件过多，无法生成唯一文件名: ${fileName}`);
+}
+
+function collectZipFilesFromDir(rootDir, recursive = true) {
+    const queue = [rootDir];
+    const result = [];
+
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        } catch (e) {
+            throw new Error(`读取目录失败: ${currentDir} (${e.message})`);
+        }
+
+        for (const entry of entries) {
+            const entryPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (recursive) {
+                    queue.push(entryPath);
+                }
+                continue;
+            }
+            if (entry.isFile() && entry.name.toLowerCase().endsWith('.zip')) {
+                result.push(entryPath);
+            }
+        }
+    }
+
+    result.sort((a, b) => a.localeCompare(b));
+    return result;
+}
+
+function extractMatchedEntriesFromZip(zipPath, outputDir, suffixes, duplicateCounters = new Map()) {
+    const normalizedSuffixes = normalizeExtractSuffix(suffixes);
+    return new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true, autoClose: false }, (openErr, zipFile) => {
+            if (openErr) {
+                reject(openErr);
+                return;
+            }
+            if (!zipFile) {
+                reject(new Error('无法读取 ZIP 文件'));
+                return;
+            }
+
+            let settled = false;
+            let matched = 0;
+            let extracted = 0;
+            let skippedDir = 0;
+            let skippedExt = 0;
+
+            const finish = (err) => {
+                if (settled) return;
+                settled = true;
+                try {
+                    zipFile.close();
+                } catch (_) {}
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve({ matched, extracted, skippedDir, skippedExt });
+                }
+            };
+
+            zipFile.on('entry', (entry) => {
+                if (settled) return;
+                const rawEntryName = typeof entry.fileName === 'string' ? entry.fileName : '';
+                const normalizedEntryName = rawEntryName.replace(/\\/g, '/');
+
+                if (!normalizedEntryName || normalizedEntryName.endsWith('/')) {
+                    skippedDir += 1;
+                    zipFile.readEntry();
+                    return;
+                }
+
+                const entryBaseName = path.basename(normalizedEntryName);
+                const lowerBaseName = entryBaseName.toLowerCase();
+                const matchedSuffix = normalizedSuffixes.some((suffix) => lowerBaseName.endsWith(suffix));
+                if (!entryBaseName || !matchedSuffix) {
+                    skippedExt += 1;
+                    zipFile.readEntry();
+                    return;
+                }
+
+                matched += 1;
+                zipFile.openReadStream(entry, (streamErr, readStream) => {
+                    if (streamErr || !readStream) {
+                        finish(streamErr || new Error('无法读取 ZIP 条目流'));
+                        return;
+                    }
+
+                    let completed = false;
+                    const outputPath = resolveDuplicateOutputPath(outputDir, entryBaseName, zipPath, duplicateCounters);
+                    const writeStream = fs.createWriteStream(outputPath);
+                    const fail = (writeErr) => {
+                        if (completed) return;
+                        completed = true;
+                        try {
+                            readStream.destroy();
+                        } catch (_) {}
+                        try {
+                            writeStream.destroy();
+                        } catch (_) {}
+                        try {
+                            if (fs.existsSync(outputPath)) {
+                                fs.unlinkSync(outputPath);
+                            }
+                        } catch (_) {}
+                        finish(writeErr);
+                    };
+
+                    readStream.on('error', fail);
+                    writeStream.on('error', fail);
+                    writeStream.on('finish', () => {
+                        if (completed || settled) return;
+                        completed = true;
+                        extracted += 1;
+                        zipFile.readEntry();
+                    });
+
+                    readStream.pipe(writeStream);
+                });
+            });
+
+            zipFile.on('end', () => {
+                finish(null);
+            });
+            zipFile.on('error', (zipErr) => {
+                finish(zipErr);
+            });
+
+            zipFile.readEntry();
+        });
+    });
+}
+
+async function cmdUnzipExt(zipDirPath, outputDir, options = {}) {
+    if (!zipDirPath) {
+        console.error('用法: codexmate unzip-ext <zip目录> [输出目录] [--ext:后缀[,后缀...]] [--no-recursive]');
+        console.log('\n示例:');
+        console.log('  codexmate unzip-ext ./archives');
+        console.log('  codexmate unzip-ext ./archives ./output --ext:json,txt');
+        console.log('  codexmate unzip-ext D:/data/zips --ext:txt --no-recursive');
+        console.log('  说明: 默认递归扫描子目录，可通过 --no-recursive 关闭递归');
+        process.exit(1);
+    }
+
+    const recursive = options.recursive !== false;
+    const suffixes = normalizeExtractSuffix(options.ext);
+    const absZipDir = path.resolve(zipDirPath);
+    const absOutputDir = outputDir ? path.resolve(outputDir) : buildDefaultExtractOutputDir(process.cwd());
+
+    if (!fs.existsSync(absZipDir)) {
+        console.error('错误: 目录不存在:', absZipDir);
+        process.exit(1);
+    }
+    try {
+        if (!fs.statSync(absZipDir).isDirectory()) {
+            console.error('错误: 仅支持目录路径:', absZipDir);
+            process.exit(1);
+        }
+    } catch (e) {
+        console.error('错误: 无法读取目录信息:', e.message);
+        process.exit(1);
+    }
+
+    let zipFiles = [];
+    try {
+        zipFiles = collectZipFilesFromDir(absZipDir, recursive);
+    } catch (e) {
+        console.error('扫描 ZIP 文件失败:', e.message);
+        process.exit(1);
+    }
+
+    if (zipFiles.length === 0) {
+        console.error('错误: 未找到任何 ZIP 文件');
+        process.exit(1);
+    }
+
+    ensureDir(absOutputDir);
+
+    console.log('\n批量解压配置:');
+    console.log('  ZIP 目录:', absZipDir);
+    console.log('  输出目录:', absOutputDir);
+    console.log('  后缀过滤:', suffixes.join(', '));
+    console.log('  递归扫描:', recursive ? '是' : '否');
+    console.log('  ZIP 数量:', zipFiles.length);
+    console.log('\n开始提取...\n');
+
+    let totalMatched = 0;
+    let totalExtracted = 0;
+    let totalSkippedDir = 0;
+    let totalSkippedExt = 0;
+    const failed = [];
+    const duplicateCounters = new Map();
+
+    for (const zipFilePath of zipFiles) {
+        try {
+            await inspectZipArchiveLimits(zipFilePath, {
+                maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
+                maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
+            });
+            const result = await extractMatchedEntriesFromZip(zipFilePath, absOutputDir, suffixes, duplicateCounters);
+            totalMatched += result.matched;
+            totalExtracted += result.extracted;
+            totalSkippedDir += result.skippedDir;
+            totalSkippedExt += result.skippedExt;
+            console.log(`✓ ${path.basename(zipFilePath)}: 命中 ${result.matched}，提取 ${result.extracted}`);
+        } catch (e) {
+            failed.push({ zipFilePath, message: e && e.message ? e.message : String(e) });
+            console.error(`✗ ${path.basename(zipFilePath)}: ${e && e.message ? e.message : e}`);
+        }
+    }
+
+    console.log('\n提取结果:');
+    console.log('  输出目录:', absOutputDir);
+    console.log('  扫描 ZIP:', zipFiles.length);
+    console.log('  命中条目:', totalMatched);
+    console.log('  已提取:', totalExtracted);
+    console.log('  已跳过(目录条目):', totalSkippedDir);
+    console.log('  已跳过(后缀不匹配):', totalSkippedExt);
+    if (failed.length > 0) {
+        console.error('  失败数量:', failed.length);
+        for (const item of failed) {
+            console.error(`    - ${item.zipFilePath}: ${item.message}`);
+        }
+        process.exit(1);
+    }
+    console.log();
+}
+
+function resolveExportOutputPath(outputPath, defaultFileName) {
+    const fallback = path.resolve(process.cwd(), defaultFileName);
+    if (typeof outputPath !== 'string' || !outputPath.trim()) {
+        return fallback;
+    }
+
+    const trimmed = outputPath.trim();
+    const resolved = path.resolve(trimmed);
+    const hasTrailingSep = /[\\\/]$/.test(trimmed);
+    if (hasTrailingSep) {
+        ensureDir(resolved);
+        return path.join(resolved, defaultFileName);
+    }
+
+    if (fs.existsSync(resolved)) {
+        try {
+            const stat = fs.statSync(resolved);
+            if (stat.isDirectory()) {
+                return path.join(resolved, defaultFileName);
+            }
+        } catch (e) {}
     }
 
     return resolved;
@@ -7443,7 +8268,7 @@ async function cmdExportSession(args = []) {
 }
 
 function parseStartOptions(args = []) {
-    const options = { host: '' };
+    const options = { host: '', noBrowser: false };
     if (!Array.isArray(args)) {
         return options;
     }
@@ -7451,6 +8276,10 @@ function parseStartOptions(args = []) {
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (!arg) continue;
+        if (arg === '--no-browser') {
+            options.noBrowser = true;
+            continue;
+        }
         if (arg.startsWith('--host=')) {
             options.host = arg.slice('--host='.length);
             continue;
@@ -7523,11 +8352,125 @@ function watchPathsForRestart(targets, onChange) {
     };
 }
 
+function writeJsonResponse(res, statusCode, payload) {
+    const body = JSON.stringify(payload, null, 2);
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(body, 'utf-8')
+    });
+    res.end(body, 'utf-8');
+}
+
+function streamZipDownloadResponse(res, filePath, options = {}) {
+    if (!filePath || !fs.existsSync(filePath)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('File Not Found');
+        return;
+    }
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+        res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Not a File');
+        return;
+    }
+    const downloadName = typeof options.fileName === 'string' && options.fileName.trim()
+        ? options.fileName.trim()
+        : path.basename(filePath);
+    const deleteAfterDownload = !!options.deleteAfterDownload;
+    const onAfterComplete = typeof options.onAfterComplete === 'function'
+        ? options.onAfterComplete
+        : null;
+    res.writeHead(200, {
+        'Content-Type': 'application/zip',
+        'Content-Disposition': `attachment; filename="${path.basename(downloadName)}"`,
+        'Content-Length': stat.size
+    });
+
+    const stream = fs.createReadStream(filePath);
+    let finished = false;
+    const finalize = () => {
+        if (finished) return;
+        finished = true;
+        if (deleteAfterDownload && fs.existsSync(filePath)) {
+            try {
+                fs.unlinkSync(filePath);
+            } catch (_) {}
+        }
+        if (onAfterComplete) {
+            try {
+                onAfterComplete();
+            } catch (_) {}
+        }
+    };
+    stream.on('error', () => {
+        if (!res.headersSent) {
+            res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('Download Error');
+        } else {
+            try {
+                res.destroy();
+            } catch (_) {}
+        }
+        finalize();
+    });
+    res.on('finish', finalize);
+    res.on('close', finalize);
+    stream.pipe(res);
+}
+
+function resolveUploadFileNameFromRequest(req, fallbackName = 'codex-skills.zip') {
+    const rawHeader = req.headers['x-codexmate-file-name'];
+    const source = Array.isArray(rawHeader) ? rawHeader[0] : rawHeader;
+    const fallback = typeof fallbackName === 'string' && fallbackName.trim()
+        ? fallbackName.trim()
+        : 'codex-skills.zip';
+    if (!source || typeof source !== 'string') {
+        return fallback;
+    }
+    const decoded = (() => {
+        try {
+            return decodeURIComponent(source);
+        } catch (_) {
+            return source;
+        }
+    })();
+    const normalized = path.basename(decoded.trim());
+    return normalized || fallback;
+}
+
+async function handleImportCodexSkillsZipUpload(req, res) {
+    if (req.method !== 'POST') {
+        writeJsonResponse(res, 405, { error: 'Method Not Allowed' });
+        return;
+    }
+    try {
+        const fileName = resolveUploadFileNameFromRequest(req, 'codex-skills.zip');
+        const upload = await writeUploadZipStream(
+            req,
+            'codex-skills-import',
+            fileName,
+            MAX_SKILLS_ZIP_UPLOAD_SIZE
+        );
+        const result = await importCodexSkillsFromZipFile(upload.zipPath, {
+            tempDir: upload.tempDir,
+            fallbackName: fileName
+        });
+        writeJsonResponse(res, 200, result || {});
+    } catch (e) {
+        const message = e && e.message ? e.message : '上传失败';
+        writeJsonResponse(res, 400, { error: message });
+    }
+}
+
 function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser }) {
     const connections = new Set();
 
     const server = http.createServer((req, res) => {
         const requestPath = (req.url || '/').split('?')[0];
+        if (requestPath === '/api/import-codex-skills-zip') {
+            void handleImportCodexSkillsZipUpload(req, res);
+            return;
+        }
         if (requestPath === '/api') {
             let body = '';
             req.on('data', chunk => body += chunk);
@@ -7651,6 +8594,9 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'import-codex-skills':
                             result = importCodexSkills(params || {});
                             break;
+                        case 'export-codex-skills':
+                            result = await exportCodexSkills(params || {});
+                            break;
                         case 'get-openclaw-config':
                             result = readOpenclawConfigFile();
                             break;
@@ -7909,32 +8855,35 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
             fs.createReadStream(filePath).pipe(res);
         } else if (requestPath.startsWith('/download/')) {
             const fileName = requestPath.slice('/download/'.length);
-            const decodedFileName = decodeURIComponent(fileName);
-            const tempDir = os.tmpdir();
-            const filePath = path.join(tempDir, decodedFileName);
-
-            if (!isPathInside(filePath, tempDir)) {
-                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('Forbidden');
+            let decodedFileName = '';
+            try {
+                decodedFileName = decodeURIComponent(fileName);
+            } catch (_) {
+                res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Bad Request');
                 return;
             }
-            if (!fs.existsSync(filePath)) {
-                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('File Not Found');
+
+            const artifact = resolveDownloadArtifact(decodedFileName, { consume: true });
+            if (artifact) {
+                streamZipDownloadResponse(res, artifact.filePath, {
+                    fileName: artifact.fileName,
+                    deleteAfterDownload: artifact.deleteAfterDownload !== false
+                });
                 return;
             }
-            const stat = fs.statSync(filePath);
-            if (!stat.isFile()) {
-                res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('Not a File');
+
+            const tempDir = os.tmpdir();
+            const legacyFilePath = path.join(tempDir, decodedFileName);
+            if (!isPathInside(legacyFilePath, tempDir)) {
+                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Forbidden');
                 return;
             }
-            res.writeHead(200, {
-                'Content-Type': 'application/zip',
-                'Content-Disposition': `attachment; filename="${path.basename(filePath)}"`,
-                'Content-Length': stat.size
+            streamZipDownloadResponse(res, legacyFilePath, {
+                fileName: path.basename(legacyFilePath),
+                deleteAfterDownload: false
             });
-            fs.createReadStream(filePath).pipe(res);
         } else if (requestPath.startsWith('/res/')) {
             const normalized = path.normalize(requestPath).replace(/^([\\.\\/])+/, '');
             const filePath = path.join(__dirname, normalized);
@@ -8057,7 +9006,7 @@ function cmdStart(options = {}) {
         webDir,
         host,
         port,
-        openBrowser: true
+        openBrowser: !options.noBrowser
     });
 
     const proxySettings = readBuiltinProxySettings();
@@ -8597,7 +9546,317 @@ async function cmdWorkflow(args = []) {
     throw new Error(`未知 workflow 子命令: ${subcommand}`);
 }
 
-async function runProxyCommand(displayName, binNames, args = [], installTip = '') {
+// #region parseCodexProxyOptions
+function parseCodexProxyOptions(args = []) {
+    const options = {
+        passthroughArgs: [],
+        queuedFollowUps: []
+    };
+    const argv = Array.isArray(args) ? args : [];
+
+    const pushFollowUp = (value, optionName) => {
+        const raw = value === undefined || value === null ? '' : String(value);
+        if (!raw.trim()) {
+            throw new Error(`${optionName} 需要提供非空内容`);
+        }
+        options.queuedFollowUps.push(raw);
+    };
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined || arg === null) {
+            continue;
+        }
+        const text = String(arg);
+        if (text === '--') {
+            options.passthroughArgs.push(...argv.slice(i).map((item) => String(item)));
+            break;
+        }
+        if (text === '--queued-follow-up' || text === '--follow-up') {
+            const next = argv[i + 1];
+            if (next === undefined) {
+                throw new Error(`${text} 需要提供内容`);
+            }
+            pushFollowUp(next, text);
+            i += 1;
+            continue;
+        }
+        if (text.startsWith('--queued-follow-up=')) {
+            pushFollowUp(text.slice('--queued-follow-up='.length), '--queued-follow-up');
+            continue;
+        }
+        if (text.startsWith('--follow-up=')) {
+            pushFollowUp(text.slice('--follow-up='.length), '--follow-up');
+            continue;
+        }
+        options.passthroughArgs.push(text);
+    }
+
+    return options;
+}
+// #endregion parseCodexProxyOptions
+
+function shellEscapePosixArg(value) {
+    const text = value === undefined || value === null ? '' : String(value);
+    return `'${text.replace(/'/g, `'\"'\"'`)}'`;
+}
+
+// #region buildScriptCommandArgs
+function buildScriptCommandArgs(commandLine) {
+    const platform = process.platform;
+    // util-linux script needs -e/--return to propagate child exit code.
+    if (platform === 'linux' || platform === 'android') {
+        return ['-q', '-e', '-c', commandLine, '/dev/null'];
+    }
+    // NetBSD supports -e/-c, matching util-linux style contract.
+    if (platform === 'netbsd') {
+        return ['-q', '-e', '-c', commandLine, '/dev/null'];
+    }
+    // OpenBSD supports "-c <command>" with a trailing output file path.
+    if (platform === 'openbsd') {
+        return ['-c', commandLine, '/dev/null'];
+    }
+    // BSD/macOS script does not support util-linux "-c <cmd>" syntax.
+    if (platform === 'darwin' || platform === 'freebsd') {
+        return ['-q', '/dev/null', 'sh', '-lc', commandLine];
+    }
+    throw new Error(`当前平台暂不支持 --follow-up 自动排队（platform=${platform}）`);
+}
+// #endregion buildScriptCommandArgs
+
+// #region runProxyCommandWithQueuedFollowUps
+async function runProxyCommandWithQueuedFollowUps(selectedBin, finalArgs = [], queuedFollowUps = []) {
+    if (!process.stdin || !process.stdin.isTTY) {
+        throw new Error('当前 stdin 不是 TTY，无法使用 --follow-up 自动排队。');
+    }
+
+    const scriptPath = resolveCommandPath('script');
+    if (!scriptPath) {
+        throw new Error('未找到 script 命令，无法自动注入 queued follow-up 消息。');
+    }
+
+    const commandLine = [selectedBin, ...finalArgs].map((item) => shellEscapePosixArg(item)).join(' ');
+    const scriptArgs = buildScriptCommandArgs(commandLine);
+
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const child = spawn(scriptPath, scriptArgs, {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        const stdin = process.stdin;
+        const hadRawMode = !!stdin.isRaw;
+        let cleanedUp = false;
+        let waitingDrain = false;
+        let followUpsFlushed = false;
+        let outputReadyDetected = false;
+        const timers = [];
+        const pendingWrites = [];
+        let onChildStdinDrain = null;
+        let onChildStdinError = null;
+        const resolveOnce = (code) => {
+            if (settled) return;
+            settled = true;
+            resolve(code);
+        };
+        const rejectOnce = (error) => {
+            if (settled) return;
+            settled = true;
+            reject(error);
+        };
+        const handleWriteFailure = (error) => {
+            const err = error instanceof Error ? error : new Error(String(error || 'unknown'));
+            cleanup();
+            try {
+                if (!child.killed) {
+                    child.kill('SIGTERM');
+                }
+            } catch (_) {
+                // Ignore failure to terminate child after stdin write failure.
+            }
+            rejectOnce(new Error(`写入 ${selectedBin} stdin 失败: ${err.message}`));
+        };
+        const flushPendingWrites = () => {
+            if (cleanedUp || child.stdin.destroyed) {
+                pendingWrites.length = 0;
+                return;
+            }
+            while (pendingWrites.length > 0) {
+                const chunk = pendingWrites[0];
+                let canContinue = true;
+                try {
+                    canContinue = child.stdin.write(chunk, (error) => {
+                        if (error) {
+                            handleWriteFailure(error);
+                        }
+                    });
+                } catch (error) {
+                    handleWriteFailure(error);
+                    return;
+                }
+                pendingWrites.shift();
+                if (!canContinue) {
+                    waitingDrain = true;
+                    try {
+                        stdin.pause();
+                    } catch (_) {
+                        // Ignore stdin pause failures.
+                    }
+                    return;
+                }
+            }
+            waitingDrain = false;
+            try {
+                stdin.resume();
+            } catch (_) {
+                // Ignore stdin resume failures.
+            }
+        };
+        const enqueueWrite = (chunk) => {
+            if (cleanedUp) return;
+            pendingWrites.push(chunk);
+            flushPendingWrites();
+        };
+        const onInput = (chunk) => {
+            if (!child.stdin.destroyed) {
+                enqueueWrite(chunk);
+            }
+        };
+        const flushQueuedFollowUps = () => {
+            if (followUpsFlushed) return;
+            followUpsFlushed = true;
+            queuedFollowUps.forEach((message, index) => {
+                const timer = setTimeout(() => {
+                    if (!child.stdin.destroyed) {
+                        // PTY submit should use CR instead of LF.
+                        enqueueWrite(`${message}\r`);
+                    }
+                }, index * 80);
+                timers.push(timer);
+            });
+        };
+        const markOutputReady = () => {
+            if (outputReadyDetected) return;
+            outputReadyDetected = true;
+            timers.push(setTimeout(() => {
+                flushQueuedFollowUps();
+            }, 120));
+        };
+        const onStdoutData = (chunk) => {
+            process.stdout.write(chunk);
+            markOutputReady();
+        };
+        const onStderrData = (chunk) => {
+            process.stderr.write(chunk);
+            markOutputReady();
+        };
+        const onProcessExit = () => {
+            cleanup();
+        };
+        const onProcessSigint = () => {
+            cleanup();
+            try {
+                if (!child.killed) {
+                    child.kill('SIGINT');
+                }
+            } catch (_) {
+                // Ignore forwarding failures and keep exit path deterministic.
+            }
+            process.exit(130);
+        };
+        const onProcessSigterm = () => {
+            cleanup();
+            try {
+                if (!child.killed) {
+                    child.kill('SIGTERM');
+                }
+            } catch (_) {
+                // Ignore forwarding failures and keep exit path deterministic.
+            }
+            process.exit(143);
+        };
+        const cleanup = () => {
+            if (cleanedUp) return;
+            cleanedUp = true;
+            stdin.removeListener('data', onInput);
+            process.removeListener('exit', onProcessExit);
+            process.removeListener('SIGINT', onProcessSigint);
+            process.removeListener('SIGTERM', onProcessSigterm);
+            child.stdout.removeListener('data', onStdoutData);
+            child.stderr.removeListener('data', onStderrData);
+            if (onChildStdinDrain) {
+                child.stdin.removeListener('drain', onChildStdinDrain);
+            }
+            if (onChildStdinError) {
+                child.stdin.removeListener('error', onChildStdinError);
+            }
+            while (timers.length > 0) {
+                clearTimeout(timers.pop());
+            }
+            try {
+                if (typeof stdin.setRawMode === 'function' && !hadRawMode) {
+                    stdin.setRawMode(false);
+                }
+            } catch (_) {
+                // Ignore raw mode restore failures at shutdown.
+            }
+        };
+
+        process.on('exit', onProcessExit);
+        process.on('SIGINT', onProcessSigint);
+        process.on('SIGTERM', onProcessSigterm);
+        child.stdout.on('data', onStdoutData);
+        child.stderr.on('data', onStderrData);
+        onChildStdinDrain = () => {
+            waitingDrain = false;
+            flushPendingWrites();
+        };
+        onChildStdinError = (error) => {
+            handleWriteFailure(error);
+        };
+        child.stdin.on('drain', onChildStdinDrain);
+        child.stdin.on('error', onChildStdinError);
+        try {
+            if (typeof stdin.setRawMode === 'function' && !hadRawMode) {
+                stdin.setRawMode(true);
+            }
+        } catch (_) {
+            // Keep graceful fallback if raw mode toggle is not supported.
+        }
+
+        stdin.resume();
+        stdin.on('data', onInput);
+        // Fallback in case the child stays silent before prompt render.
+        timers.push(setTimeout(() => {
+            flushQueuedFollowUps();
+        }, 1500));
+
+        child.on('error', (err) => {
+            cleanup();
+            rejectOnce(new Error(`运行 ${selectedBin} 失败: ${err.message}`));
+        });
+
+        child.on('close', (code, signal) => {
+            cleanup();
+            if (typeof code === 'number') {
+                resolveOnce(code);
+                return;
+            }
+            if (signal === 'SIGINT') {
+                resolveOnce(130);
+                return;
+            }
+            if (signal === 'SIGTERM') {
+                resolveOnce(143);
+                return;
+            }
+            resolveOnce(1);
+        });
+    });
+}
+// #endregion runProxyCommandWithQueuedFollowUps
+
+async function runProxyCommand(displayName, binNames, args = [], installTip = '', runtimeOptions = {}) {
     const extraArgs = Array.isArray(args) ? args.filter(arg => arg !== undefined) : [];
     const hasYolo = extraArgs.includes('--yolo');
     const finalArgs = hasYolo ? extraArgs : ['--yolo', ...extraArgs];
@@ -8623,6 +9882,14 @@ async function runProxyCommand(displayName, binNames, args = [], installTip = ''
         throw new Error(msg);
     }
 
+    const queuedFollowUps = runtimeOptions && Array.isArray(runtimeOptions.queuedFollowUps)
+        ? runtimeOptions.queuedFollowUps.filter((item) => typeof item === 'string' && item.trim())
+        : [];
+
+    if (queuedFollowUps.length > 0) {
+        return runProxyCommandWithQueuedFollowUps(selectedBin, finalArgs, queuedFollowUps);
+    }
+
     return new Promise((resolve, reject) => {
         const child = spawn(selectedBin, finalArgs, {
             stdio: 'inherit',
@@ -8652,27 +9919,16 @@ async function runProxyCommand(displayName, binNames, args = [], installTip = ''
 }
 
 async function cmdCodex(args = []) {
-    const ensureResult = await ensureBuiltinProxyForCodexDefault({});
-    if (!ensureResult || ensureResult.success !== true) {
-        const message = ensureResult && ensureResult.error
-            ? ensureResult.error
-            : '内建代理准备失败';
-        throw new Error(message);
-    }
-    if (ensureResult.runtime && ensureResult.runtime.listenUrl) {
-        console.log(`~ Codex 默认走内建代理: ${ensureResult.runtime.listenUrl}`);
-    }
-    return runProxyCommand('Codex', 'codex', args);
+    const parsed = parseCodexProxyOptions(args);
+    return runProxyCommand('Codex', 'codex', parsed.passthroughArgs, '', {
+        queuedFollowUps: parsed.queuedFollowUps
+    });
 }
 
 async function cmdQwen(args = []) {
     return runProxyCommand('Qwen', ['qwen', 'qwen-code'], args, 'npm install -g @qwen-code/qwen-code');
 }
 
-async function cmdGemini(args = []) {
-    return runProxyCommand('Gemini', ['gemini', 'gemini-cli'], args, 'npm install -g @google/gemini-cli');
-}
-
 function parseMcpOptions(args = []) {
     const options = {
         subcommand: 'serve',
@@ -10132,14 +11388,15 @@ async function main() {
         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>]    启动 Web 界面');
-        console.log('  codexmate codex [参数...]  等同于 codex --yolo');
+        console.log('  codexmate run [--host <HOST>] [--no-browser]    启动 Web 界面');
+        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 gemini [参数...] 等同于 gemini --yolo');
         console.log('  codexmate mcp [serve] [--transport stdio] [--allow-write|--read-only]');
         console.log('  codexmate export-session --source <codex|claude> (--session-id <ID>|--file <PATH>) [--output <PATH>] [--max-messages <N|all|Infinity>]');
         console.log('  codexmate zip <路径> [--max:级别]  压缩（系统 zip 优先，其次 zip-lib）');
         console.log('  codexmate unzip <zip文件> [输出目录]  解压（zip-lib）');
+        console.log('  codexmate unzip-ext <zip目录> [输出目录] [--ext:后缀[,后缀...]] [--no-recursive]  批量提取 ZIP 指定后缀文件（默认递归）');
         console.log('');
         process.exit(0);
     }
@@ -10174,11 +11431,6 @@ async function main() {
             process.exit(exitCode);
             break;
         }
-        case 'gemini': {
-            const exitCode = await cmdGemini(args.slice(1));
-            process.exit(exitCode);
-            break;
-        }
         case 'mcp': await cmdMcp(args.slice(1)); break;
         case 'export-session': await cmdExportSession(args.slice(1)); break;
         case 'zip': {
@@ -10197,6 +11449,38 @@ async function main() {
             break;
         }
         case 'unzip': await cmdUnzip(args[1], args[2]); break;
+        case 'unzip-ext': {
+            const unzipExtOptions = {
+                ext: [],
+                recursive: true
+            };
+            let zipDirPath = null;
+            let outputDir = null;
+            for (let i = 1; i < args.length; i++) {
+                const arg = args[i];
+                if (arg.startsWith('--ext:')) {
+                    unzipExtOptions.ext.push(...splitExtractSuffixInput(arg.substring(6)));
+                } else if (arg.startsWith('--ext=')) {
+                    unzipExtOptions.ext.push(...splitExtractSuffixInput(arg.substring(6)));
+                } else if (arg === '--ext') {
+                    const nextArg = args[i + 1];
+                    if (typeof nextArg === 'string' && !nextArg.startsWith('--')) {
+                        unzipExtOptions.ext.push(...splitExtractSuffixInput(nextArg));
+                        i += 1;
+                    }
+                } else if (arg === '--recursive') {
+                    unzipExtOptions.recursive = true;
+                } else if (arg === '--no-recursive') {
+                    unzipExtOptions.recursive = false;
+                } else if (!zipDirPath) {
+                    zipDirPath = arg;
+                } else if (!outputDir) {
+                    outputDir = arg;
+                }
+            }
+            await cmdUnzipExt(zipDirPath, outputDir, unzipExtOptions);
+            break;
+        }
         default:
             console.error('错误: 未知命令:', command);
             console.log('运行 "codexmate" 查看帮助');