codexmate 0.0.15 → 0.0.17

package/cli.js

@@ -123,6 +123,7 @@ 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';
@@ -5890,8 +5891,15 @@ function buildProviderSharePayload(params = {}) {
 
     const baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
     const apiKey = typeof provider.preferred_auth_method === 'string'
-        ? provider.preferred_auth_method
+        ? provider.preferred_auth_method.trim()
+        : '';
+    const currentModels = readCurrentModels();
+    const savedModel = currentModels && typeof currentModels[name] === 'string'
+        ? currentModels[name].trim()
         : '';
+    const activeProvider = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+    const activeModel = typeof config.model === 'string' ? config.model.trim() : '';
+    const model = savedModel || (activeProvider === name ? activeModel : '');
 
     if (!baseUrl) {
         return { error: `提供商 ${name} 缺少 base_url` };
@@ -5901,7 +5909,8 @@ function buildProviderSharePayload(params = {}) {
         payload: {
             name,
             baseUrl,
-            apiKey
+            apiKey,
+            model
         }
     };
 }
@@ -6928,6 +6937,8 @@ function readClaudeSettingsInfo() {
         exists: !!readResult.exists,
         targetPath: CLAUDE_SETTINGS_FILE,
         apiKey: typeof env.ANTHROPIC_API_KEY === 'string' ? env.ANTHROPIC_API_KEY : '',
+        authToken: typeof env.ANTHROPIC_AUTH_TOKEN === 'string' ? env.ANTHROPIC_AUTH_TOKEN : '',
+        useKey: typeof env.CLAUDE_CODE_USE_KEY === 'string' ? env.CLAUDE_CODE_USE_KEY : '',
         baseUrl: typeof env.ANTHROPIC_BASE_URL === 'string' ? env.ANTHROPIC_BASE_URL : '',
         model: typeof env.ANTHROPIC_MODEL === 'string' ? env.ANTHROPIC_MODEL : '',
         env
@@ -7784,6 +7795,318 @@ async function cmdUnzip(zipPath, outputDir) {
     }
 }
 
+function splitExtractSuffixInput(rawValue) {
+    if (Array.isArray(rawValue)) {
+        return rawValue.flatMap((item) => splitExtractSuffixInput(item));
+    }
+    if (typeof rawValue !== 'string') {
+        return [];
+    }
+    return rawValue
+        .split(/[,\s]+/g)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+
+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()) {
@@ -9233,7 +9556,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];
@@ -9259,6 +9892,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',
@@ -9288,17 +9929,10 @@ 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 = []) {
@@ -10765,12 +11399,14 @@ async function main() {
         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 [参数...]  等同于 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]');
         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);
     }
@@ -10823,6 +11459,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" 查看帮助');