lark-remote 0.2.2 → 0.3.0

package/dist/clone.js

@@ -0,0 +1,415 @@
+import { registerApp } from '@larksuite/channel';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import YAML from 'yaml';
+import { getLogger } from './logger/index.js';
+import { renderQrImage } from './config/qr.js';
+import { silentlyUnlink } from './common/fs.js';
+import { atomicWrite, atomicWriteJson } from './persistence/atomic-write.js';
+import { spawnDetachedBridge } from './restart.js';
+/** 退出命令（不区分大小写）。 */
+const EXIT_COMMANDS = new Set(['/q']);
+/** 重新生成二维码的关键词（精确匹配，避免误伤普通聊天）。 */
+const RESEND_COMMANDS = new Set(['重发', '重发二维码', '重新生成', '重新生成二维码', '重新发送']);
+/** win32 保留设备名（不区分大小写），用作分身目录名会在 mkdir 时失败。 */
+const WIN_RESERVED_NAMES = new Set([
+    'con',
+    'prn',
+    'aux',
+    'nul',
+    ...Array.from({ length: 9 }, (_, i) => `com${i + 1}`),
+    ...Array.from({ length: 9 }, (_, i) => `lpt${i + 1}`),
+]);
+/**
+ * 校验用户指定的分身名字：路径分隔符、以 . 开头、尾点/尾空格（win32 会静默
+ * 吞掉）、win32 保留设备名一律拒绝。
+ */
+export function isValidCloneName(name) {
+    if (!name || name.includes('/') || name.includes('\\') || name.startsWith('.'))
+        return false;
+    if (/[\s.]$/.test(name))
+        return false;
+    if (WIN_RESERVED_NAMES.has(name.toLowerCase()))
+        return false;
+    return true;
+}
+/** 随机后缀：2 位数字 + 2 位小写字母/数字，如 `37ab`。 */
+export function generateCloneSuffix() {
+    const digits = String(crypto.randomInt(0, 100)).padStart(2, '0');
+    const charset = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let chars = '';
+    for (let i = 0; i < 2; i++)
+        chars += charset[crypto.randomInt(0, charset.length)];
+    return digits + chars;
+}
+/**
+ * 默认新实例拉起：同入口 + 同参数，仅替换 --config-dir（detached，返回 pid）。
+ * spawn 骨架（log fd / windowsHide / error 兜底）单源于 restart.ts。
+ */
+export function spawnDetachedCloneBridge(targetDir) {
+    const args = [];
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--config-dir') {
+            if (i + 1 < argv.length && !argv[i + 1].startsWith('--'))
+                i++;
+            continue;
+        }
+        args.push(argv[i]);
+    }
+    args.push('--config-dir', targetDir);
+    const entry = process.argv[1];
+    if (!entry)
+        return undefined;
+    const pid = spawnDetachedBridge([entry, ...args], path.join(targetDir, 'logs', 'spawn-child.log'));
+    return pid ?? undefined;
+}
+export class CloneSession {
+    state = 'idle';
+    targetDir;
+    abortController;
+    connector;
+    configPath;
+    configDir;
+    registerAppFn;
+    generateSuffixFn;
+    spawnNewInstanceFn;
+    constructor(opts) {
+        this.connector = opts.connector;
+        this.configPath = opts.configPath;
+        this.configDir = opts.configDir;
+        this.registerAppFn = opts.registerAppFn ?? registerApp;
+        this.generateSuffixFn = opts.generateSuffix ?? generateCloneSuffix;
+        this.spawnNewInstanceFn = opts.spawnNewInstance ?? spawnDetachedCloneBridge;
+    }
+    /** 当前状态（测试断言用）。 */
+    get currentState() {
+        return this.state;
+    }
+    isActive() {
+        return this.state !== 'idle';
+    }
+    /** 已确定但尚未写入的分身配置目录（测试断言用）。 */
+    get pendingTargetDir() {
+        return this.targetDir;
+    }
+    /**
+     * 进入创建分身流程：确定新配置目录 → 发二维码 → 等扫码。
+     * 目录已存在 / 名字非法时不进入流程（保持 idle），仅回错误说明。
+     */
+    async start(nameArg, ctx) {
+        if (this.isActive()) {
+            await this.connector.sendWithRetry(ctx.chatId, { text: '已在创建分身流程中，请先完成或输入 /Q 退出后再重新发起' }, { replyTo: ctx.messageId });
+            return;
+        }
+        let suffix;
+        if (nameArg !== undefined && nameArg.length > 0) {
+            const name = nameArg.trim();
+            if (!isValidCloneName(name)) {
+                await this.connector.sendWithRetry(ctx.chatId, {
+                    text: `⚠️ 无效的名字：${nameArg}\n` +
+                        '名字不能包含路径分隔符、不能以 . 开头、不能以点或空格结尾，' +
+                        '也不能是 Windows 保留设备名（con/nul/com1 等）\n' +
+                        '用法：/clone <名字>（省略则随机生成）',
+                }, { replyTo: ctx.messageId });
+                return;
+            }
+            suffix = name;
+        }
+        else {
+            // 随机后缀：先检查目标目录不存在再落定（存在则重新生成，最多 50 次）。
+            suffix = this.generateSuffixFn();
+            for (let i = 0; i < 50 && fs.existsSync(this.dirFor(suffix)); i++) {
+                suffix = this.generateSuffixFn();
+            }
+            if (fs.existsSync(this.dirFor(suffix))) {
+                await this.connector.sendWithRetry(ctx.chatId, { text: '⚠️ 无法确定分身目录（随机名连续冲突），请稍后重试或用 /clone <名字> 指定' }, { replyTo: ctx.messageId });
+                return;
+            }
+        }
+        const targetDir = this.dirFor(suffix);
+        if (fs.existsSync(targetDir)) {
+            await this.connector.sendWithRetry(ctx.chatId, {
+                text: `⚠️ 目录已存在：${targetDir}\n` + '请换一个名字（/clone <名字>），或省略参数随机生成',
+            }, { replyTo: ctx.messageId });
+            return;
+        }
+        this.targetDir = targetDir;
+        this.state = 'awaiting_scan';
+        getLogger().info(`[clone] start, target config dir: ${targetDir}`);
+        await this.connector.sendWithRetry(ctx.chatId, {
+            text: `🧬 开始创建分身\n` +
+                `新配置目录：${targetDir}\n` +
+                `正在生成二维码，请稍候…（完成后会以图片消息发送）`,
+        }, { replyTo: ctx.messageId });
+        this.runRegistration(ctx);
+    }
+    /**
+     * awaiting_scan / finalizing 阶段的一切入站消息都进这里（index.ts 在
+     * 消息入队前拦截，不转发 coding agent、不进命令分发）。
+     */
+    async handleMessage(content, ctx) {
+        if (this.state === 'finalizing') {
+            await this.connector.sendWithRetry(ctx.chatId, { text: '⏳ 正在完成分身创建（写配置/绑定/拉起新实例），请稍候…' }, { replyTo: ctx.messageId });
+            return;
+        }
+        const trimmed = content.trim();
+        const lowered = trimmed.toLowerCase();
+        if (EXIT_COMMANDS.has(lowered)) {
+            this.state = 'idle';
+            this.targetDir = undefined;
+            // 置空 controller 使旧注册变为过期代际：其迟到 resolve/reject 都被静默。
+            this.abortController?.abort();
+            this.abortController = undefined;
+            getLogger().info('[clone] cancelled by user');
+            await this.connector.sendWithRetry(ctx.chatId, { text: '已取消创建分身，未写入任何配置。' }, { replyTo: ctx.messageId });
+            return;
+        }
+        if (RESEND_COMMANDS.has(trimmed)) {
+            // abort 旧注册（变为过期代际，其迟到 resolve/reject 被静默），
+            // 再起新一轮注册。awaiting_scan 状态保持不变。
+            this.abortController?.abort();
+            getLogger().info('[clone] qr resend requested');
+            await this.connector.sendWithRetry(ctx.chatId, { text: '🔄 正在重新生成二维码…' }, { replyTo: ctx.messageId });
+            this.runRegistration(ctx);
+            return;
+        }
+        await this.connector.sendWithRetry(ctx.chatId, {
+            text: '🧬 正在创建分身，当前状态：等待你扫码\n' +
+                '• 直接用飞书扫描上面的二维码图片即可，无需输入任何内容\n' +
+                '• 二维码过期或创建失败：输入「重发」重新生成\n' +
+                '• 退出本流程：输入 /Q（不会写入任何配置）',
+        }, { replyTo: ctx.messageId });
+    }
+    dirFor(suffix) {
+        return `${this.configDir}-${suffix}`;
+    }
+    /** 起一轮扫码注册：QR 就绪即发图，成功 finalize，失败回引导（保持流程）。 */
+    runRegistration(ctx) {
+        const controller = new AbortController();
+        this.abortController = controller;
+        this.registerAppFn({
+            source: 'lark-remote',
+            signal: controller.signal,
+            createOnly: true,
+            onQRCodeReady: (info) => {
+                void this.sendQrCode(info, ctx);
+            },
+            onStatusChange: (info) => {
+                if (info.status === 'domain_switched') {
+                    getLogger().info('[clone] international tenant detected, switched to larksuite.com');
+                }
+                else if (info.status === 'slow_down') {
+                    getLogger().info('[clone] registration polling slowed down');
+                }
+            },
+        }).then((result) => {
+            // 代际判定：/Q 或重发后本注册已是过期代际，忽略迟到 resolve，
+            // 防止旧凭证 finalize 覆盖新一轮。
+            if (this.abortController !== controller) {
+                getLogger().info('[clone] stale registration resolved, ignored');
+                return;
+            }
+            void this.finalize(result, ctx);
+        }, (err) => {
+            if (this.abortController !== controller) {
+                // /Q 取消或重发触发的 abort：用户侧已有对应提示，静默即可。
+                getLogger().info('[clone] stale registration aborted');
+                return;
+            }
+            this.onRegistrationError(err, ctx);
+        });
+    }
+    async sendQrCode(info, ctx) {
+        const qrPath = path.join(os.tmpdir(), `lark-remote-clone-qr-${crypto.randomUUID()}.gif`);
+        const mins = Math.max(1, Math.round(info.expireIn / 60));
+        try {
+            fs.writeFileSync(qrPath, renderQrImage(info.url));
+            await this.connector.sendImage(ctx.chatId, qrPath);
+        }
+        catch (err) {
+            getLogger().warn('[clone] send QR image failed:', err);
+            // 图片发送失败不阻断流程：给出浏览器打开兜底。
+            await this.connector
+                .sendWithRetry(ctx.chatId, { text: `⚠️ 二维码图片发送失败，请在浏览器打开创建：${info.url}` }, { replyTo: ctx.messageId })
+                .catch(() => { });
+            return;
+        }
+        finally {
+            silentlyUnlink(qrPath);
+        }
+        await this.connector
+            .sendWithRetry(ctx.chatId, {
+            text: `📱 请用飞书 App 扫描上面的二维码创建新应用（约 ${mins} 分钟内有效）\n` +
+                `也可以直接在浏览器打开：${info.url}\n\n` +
+                `• 创建成功后会自动完成绑定并启动新实例，无需再做任何输入\n` +
+                `• 需要重新生成：输入「重发」\n` +
+                `• 退出：输入 /Q`,
+        }, { replyTo: ctx.messageId })
+            .catch((err) => getLogger().warn('[clone] QR guidance send failed:', err));
+    }
+    onRegistrationError(err, ctx) {
+        // 真实失败（二维码过期/网络等）：保持 awaiting_scan，让用户选「重发」或 /Q。
+        getLogger().warn('[clone] registration failed:', err);
+        void this.connector
+            .sendWithRetry(ctx.chatId, {
+            text: '⚠️ 应用创建失败或二维码已过期\n' +
+                '• 输入「重发」重新生成二维码\n' +
+                '• 输入 /Q 退出本流程',
+        }, { replyTo: ctx.messageId })
+            .catch((sendErr) => getLogger().warn('[clone] failure notice send failed:', sendErr));
+    }
+    /**
+     * 扫码成功后的自动绑定落地：
+     * 1. 复制当前 config.yaml，仅替换 feishu.appId/appSecret；
+     * 2. 同步 workspace / 常用指令 / 会话状态（session 按 openId 重绑）；
+     * 3. 用 registerApp 返回的新应用 openId 写 startup-contact.json（免认领绑定）；
+     * 4. detached 拉起指向新目录的新实例（启动后自动向新应用发启动通知）；
+     * 5. 在原应用回执「绑定完成 + 配置目录」，退出流程。
+     */
+    async finalize(result, ctx) {
+        this.state = 'finalizing';
+        const targetDir = this.targetDir;
+        if (!targetDir) {
+            this.state = 'idle';
+            return;
+        }
+        try {
+            const raw = fs.readFileSync(this.configPath, 'utf-8');
+            const cloned = YAML.parse(raw);
+            const feishu = (cloned.feishu ?? {});
+            feishu['appId'] = result.client_id;
+            feishu['appSecret'] = result.client_secret;
+            cloned['feishu'] = feishu;
+            fs.mkdirSync(targetDir, { recursive: true });
+            atomicWrite(path.join(targetDir, 'config.yaml'), YAML.stringify(cloned));
+            getLogger().info(`[clone] config written to ${targetDir} (appId=${result.client_id})`);
+            // 全局状态文件（workspace 别名 / 常用指令）与主键化状态（会话）同步
+            this.copyGlobalStateFiles(targetDir);
+            // 自动绑定：openId 是新应用作用域的，只能来自 registerApp 的 user_info。
+            let sessionSynced = false;
+            const newOpenId = result.user_info?.open_id;
+            if (newOpenId) {
+                atomicWriteJson(path.join(targetDir, 'startup-contact.json'), { userId: newOpenId });
+                getLogger().info(`[clone] pre-bound owner openId=${newOpenId} in new config dir`);
+                sessionSynced = this.copySessionState(targetDir, newOpenId);
+            }
+            else {
+                getLogger().warn('[clone] registerApp returned no user open_id; skip pre-bind');
+            }
+            const spawnPid = this.spawnNewInstanceFn(targetDir);
+            getLogger().info(`[clone] new instance spawn pid=${spawnPid ?? 'failed'}`);
+            const lines = [
+                '✅ 分身创建完成，已自动绑定',
+                `• 新应用 App ID：${result.client_id}`,
+                `• 配置目录：${targetDir}`,
+            ];
+            if (sessionSynced) {
+                lines.push('• workspace / 常用指令 / 会话与工作目录状态已同步');
+            }
+            else {
+                lines.push('• workspace / 常用指令状态已同步');
+            }
+            if (!newOpenId) {
+                lines.push('• 未拿到新应用侧的用户 ID：首次向新应用发消息时会自动完成绑定');
+            }
+            if (spawnPid !== undefined) {
+                lines.push(`• 新实例已自动启动（pid=${spawnPid}），启动后会向新应用发送启动通知`);
+            }
+            else {
+                lines.push(`• 新实例自动启动失败，请手动启动：lark-remote --config-dir ${targetDir}`);
+            }
+            await this.connector.sendWithRetry(ctx.chatId, { text: lines.join('\n') });
+            getLogger().info('[clone] finalized, flow exited');
+        }
+        catch (err) {
+            getLogger().error('[clone] finalize failed:', err);
+            this.cleanupPartialDir(targetDir);
+            await this.connector
+                .sendWithRetry(ctx.chatId, {
+                text: `⚠️ 分身配置写入失败：${err.message}\n` +
+                    `新应用凭证（请妥善保管）：App ID ${result.client_id}\n` +
+                    '可修复本机问题后用 /clone 重新走一遍流程（会创建新应用）',
+            }, { replyTo: ctx.messageId })
+                .catch(() => { });
+        }
+        finally {
+            this.state = 'idle';
+            this.targetDir = undefined;
+            this.abortController = undefined;
+        }
+    }
+    /** 全局状态文件（workspace 别名 / 常用指令）原样复制到分身目录。 */
+    copyGlobalStateFiles(targetDir) {
+        for (const name of ['workspace.json', 'orders.json']) {
+            const src = path.join(this.configDir, name);
+            if (fs.existsSync(src)) {
+                // 源文件由旧实例原子写维护，copyFile 读到的总是完整版本
+                fs.copyFileSync(src, path.join(targetDir, name));
+                getLogger().info(`[clone] state file copied: ${name}`);
+            }
+        }
+    }
+    /**
+     * last-session.json 按 openId 重绑后复制。SessionStore 以 userId 为主键，
+     * 旧应用的 openId 在新应用无效：只迁移旧 owner 的条目并挂到新 openId 名下
+     * （cwd / 各 agent sessionId / 停车位 / 到达基线 / sessionCwds 原样保留——
+     * session 文件在同一台机器上，分身实例自动恢复即可续聊）。其余用户条目
+     * 不迁移：分身实例只服务新 owner。
+     */
+    copySessionState(targetDir, newOpenId) {
+        const src = path.join(this.configDir, 'last-session.json');
+        if (!fs.existsSync(src))
+            return false;
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(src, 'utf-8'));
+        }
+        catch {
+            getLogger().warn('[clone] last-session.json unreadable, skip session state copy');
+            return false;
+        }
+        const oldOwnerId = this.readOldOwnerId();
+        const entry = oldOwnerId !== undefined ? parsed[oldOwnerId] : undefined;
+        if (typeof entry !== 'object' || entry === null) {
+            getLogger().info('[clone] no session entry for previous owner, skip last-session copy');
+            return false;
+        }
+        atomicWriteJson(path.join(targetDir, 'last-session.json'), { [newOpenId]: entry });
+        getLogger().info(`[clone] session state re-keyed ${oldOwnerId} -> ${newOpenId}`);
+        return true;
+    }
+    /** 旧实例绑定的 owner openId（来自当前目录 startup-contact.json）。 */
+    readOldOwnerId() {
+        try {
+            const raw = JSON.parse(fs.readFileSync(path.join(this.configDir, 'startup-contact.json'), 'utf-8'));
+            return typeof raw.userId === 'string' && raw.userId ? raw.userId : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * 写配置失败时清理半成品目录。守卫：只删内容全部是本次产物
+     * （config.yaml / startup-contact.json 及其 .tmp）的目录，混入其他
+     * 文件时保留现场不动。
+     */
+    cleanupPartialDir(targetDir) {
+        try {
+            const allowed = /^(config\.yaml|startup-contact\.json)(\.tmp)?$/;
+            const entries = fs.readdirSync(targetDir);
+            if (!entries.every((e) => allowed.test(e))) {
+                getLogger().warn(`[clone] target dir has foreign entries, kept: ${targetDir}`);
+                return;
+            }
+            fs.rmSync(targetDir, { recursive: true, force: true });
+            getLogger().info(`[clone] partial target dir removed: ${targetDir}`);
+        }
+        catch {
+            // 目录不存在等：无需清理
+        }
+    }
+}
+//# sourceMappingURL=clone.js.map

package/dist/config/codex-config.js

@@ -8,12 +8,17 @@
  * - catalog 模式（config.toml 声明 model_catalog_json）：模型列表/档位来自活动目录
  * - 非 catalog 模式：openai 用 bundled 全量；anthropic 仅在用户显式配置时存在
  */
-import { execFileSync, execFile } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import TOML from '@iarna/toml';
 import { getLogger } from '../logger/index.js';
+import { spawnProcess, spawnProcessSync } from '../platform/spawn.js';
+/** codex CLI 名（cross-spawn 负责 win32 .cmd 垫片解析）。 */
+const CODEX_BINARY = 'codex';
+/** codex CLI 调用超时 / 输出上限（同步与异步路径一致）。 */
+const CODEX_TIMEOUT_MS = 8_000;
+const CODEX_MAX_BUFFER = 4 * 1024 * 1024;
 /**
  * Resolve codex home directory.
  * Priority: explicit codexHome param > $CODEX_HOME env > ~/.codex
@@ -170,14 +175,7 @@ export function getCodexCatalogModels(codexHome) {
     }
     const now = Date.now();
     try {
-        const stdout = execFileSync('codex', catalogArgs(bundled), {
-            encoding: 'utf-8',
-            timeout: 8_000,
-            maxBuffer: 4 * 1024 * 1024,
-            env: process.env,
-            stdio: ['ignore', 'pipe', 'ignore'],
-            windowsHide: true, // codex 是 npm .cmd 垫片：不隐藏会闪 cmd.exe 控制台
-        });
+        const stdout = runCodexCommandSync(catalogArgs(bundled));
         const models = parseCodexModelsOutput(stdout);
         catalogCache = { key, models, ts: now, failed: models.length === 0 };
         return models;
@@ -208,7 +206,7 @@ export async function loadCodexCatalogModelsAsync(codexHome) {
     const p = (async () => {
         const now = Date.now();
         try {
-            const stdout = await execFileAsync('codex', catalogArgs(bundled));
+            const stdout = await runCodexCommandAsync(catalogArgs(bundled));
             const models = parseCodexModelsOutput(stdout);
             catalogCache = { key, models, ts: now, failed: models.length === 0 };
             return models;
@@ -236,7 +234,7 @@ export function warmCodexCatalogCache(codexHome) {
 }
 /** 计算目录缓存键（binary/home/mode + 指纹），同步与异步路径共享。 */
 function computeCodexCatalogKey(codexHome) {
-    const binary = 'codex';
+    const binary = CODEX_BINARY;
     const home = resolveCodexHome(codexHome);
     const catalogPath = readModelCatalogJsonPath(home);
     const bundled = catalogPath === undefined || catalogPath === TOML_PARSE_FAILED_SENTINEL;
@@ -277,20 +275,77 @@ function readCachedCatalog(key) {
 function catalogArgs(bundled) {
     return bundled ? ['debug', 'models', '--bundled'] : ['debug', 'models'];
 }
-/** Promisify execFile with the same 8s timeout / 4MB cap as the sync path. */
-function execFileAsync(file, args) {
+/**
+ * 同步运行 codex CLI（`debug models ...`），成功返回 stdout。
+ *
+ * 必须经 platform/spawn（cross-spawn）而非裸 execFileSync：codex 是 npm 全局
+ * 安装的 .cmd 垫片，win32 上 execFileSync 不做 PATHEXT 解析 —— 裸名 'codex'
+ * 会被解析到无扩展名的 sh 脚本（给 Git Bash/WSL 用的那份），Windows 原生
+ * 执行直接失败（bun 下 exit 1「系统找不到指定的路径」，node 下 ENOENT）；
+ * 而 execFileSync('codex.cmd') 又因 execFile 不经 shell 直接 EINVAL。
+ * cross-spawn 与 runner spawn 走同一垫片执行路径（posix 直通）。
+ * stderr 参与 pipe：失败信息带上 stderr 片段，避免只留一句无诊断价值的
+ * "Command failed"（历史教训：真因只存在于被丢弃的 stderr 里）。
+ */
+function runCodexCommandSync(args) {
+    const res = spawnProcessSync(CODEX_BINARY, args, {
+        encoding: 'utf-8',
+        timeout: CODEX_TIMEOUT_MS,
+        maxBuffer: CODEX_MAX_BUFFER,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (res.error)
+        throw res.error;
+    if (res.status !== 0) {
+        const stderr = String(res.stderr ?? '').trim();
+        throw new Error(`codex exited ${res.status}${stderr ? `: ${stderr.slice(0, 200)}` : ''}`);
+    }
+    return String(res.stdout ?? '');
+}
+/**
+ * 异步运行 codex CLI（spawnProcess + 流式收集），成功返回完整 stdout。
+ * 与同步路径同超时 / 输出上限；stdout 超 4MB 主动 kill（对齐 execFile maxBuffer 语义）。
+ */
+function runCodexCommandAsync(args) {
     return new Promise((resolve, reject) => {
-        execFile(file, args, {
-            encoding: 'utf-8',
-            timeout: 8_000,
-            maxBuffer: 4 * 1024 * 1024,
-            env: process.env,
-            windowsHide: true,
-        }, (err, stdout) => {
-            if (err)
-                reject(err);
-            else
-                resolve(stdout);
+        const child = spawnProcess(CODEX_BINARY, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            fn();
+        };
+        const timer = setTimeout(() => {
+            settle(() => {
+                child.kill();
+                reject(new Error(`codex timed out after ${CODEX_TIMEOUT_MS}ms`));
+            });
+        }, CODEX_TIMEOUT_MS);
+        child.stdout?.on('data', (chunk) => {
+            stdout += String(chunk);
+            if (stdout.length > CODEX_MAX_BUFFER) {
+                settle(() => reject(new Error('codex stdout exceeded maxBuffer (4MB)')));
+                child.kill();
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (err) => settle(() => reject(err)));
+        child.on('close', (code) => {
+            settle(() => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    const tail = stderr.trim().slice(0, 200);
+                    reject(new Error(`codex exited ${code}${tail ? `: ${tail}` : ''}`));
+                }
+            });
         });
     });
 }

package/dist/config/kimi-config.js

@@ -4,8 +4,8 @@
  * Dynamically reads available models from `kimi provider list --json`,
  * provides dynamic dropdown options for /config card.
  */
-import { execFileSync } from 'node:child_process';
 import { getLogger } from '../logger/index.js';
+import { spawnProcessSync } from '../platform/spawn.js';
 /** Valid thinking effort values for kimi (Layer 1: Schema enum source) */
 export const KIMI_THINKING_EFFORTS = ['low', 'high', 'max'];
 /** Fallback efforts when all values are filtered out */
@@ -30,13 +30,24 @@ export function loadKimiConfig() {
     }
     const logger = getLogger();
     try {
-        const output = execFileSync('kimi', ['provider', 'list', '--json'], {
-            stdio: ['ignore', 'pipe', 'ignore'],
+        // spawnProcessSync（cross-spawn）而非 execFileSync：kimi 是 npm 全局安装的
+        // .cmd 垫片，win32 上 execFileSync 不做 PATHEXT 解析（裸名解析到无扩展名的
+        // sh 脚本直接执行失败，.cmd 又 EINVAL）；cross-spawn 与 runner spawn 走
+        // 同一垫片执行路径（posix 直通）。stderr 参与 pipe 以便失败信息可诊断。
+        const res = spawnProcessSync('kimi', ['provider', 'list', '--json'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
             timeout: 10000,
             maxBuffer: 2 * 1024 * 1024,
-            windowsHide: true, // kimi 是 npm .cmd 垫片：不隐藏会闪 cmd.exe 控制台
+            encoding: 'utf-8',
         });
-        const data = JSON.parse(output.toString());
+        if (res.error)
+            throw res.error;
+        if (res.status !== 0) {
+            const stderr = String(res.stderr ?? '').trim();
+            throw new Error(`kimi exited ${res.status}${stderr ? `: ${stderr.slice(0, 200)}` : ''}`);
+        }
+        const output = String(res.stdout ?? '');
+        const data = JSON.parse(output);
         if (!data.models || Object.keys(data.models).length === 0) {
             logger.warn('[kimi-config] no models found in provider list, using defaults');
             return buildDefaultResult();

package/dist/connector/index.d.ts

@@ -140,11 +140,30 @@ export declare class FeishuConnector {
      * The SDK resolves the reaction id internally; missing reaction is a no-op.
      */
     removeReactionByEmoji(messageId: string, emoji: string): Promise<void>;
+    /**
+     * sendFile/sendImage 共用：校验文件存在与大小上限（30MB，对齐飞书
+     * im/v1 上传 API）。noun 是消息里的小写名词（'file'/'image'）。
+     */
+    private checkUploadable;
+    /**
+     * sendFile/sendImage 共用骨架：token → 上传（流在任何失败路径销毁，P2-18）
+     * → 发送媒体消息。上传端点 / form 字段 / 响应 key / msg_type 的差异由调用方
+     * 以 uploadUrl + buildForm + keyField + msgType 表达；timeout、noKeepAliveAgent
+     * （Bun keep-alive 修复）与错误包装在此单源。label 是对外错误前缀与日志
+     * 标签（'sendFile' | 'sendImage'）。
+     */
+    private uploadAndSendMedia;
     /**
      * Upload a file to Feishu and send it to the specified chat.
      * Uses the im/v1/files upload API.
      */
     sendFile(chatId: string, filePath: string): Promise<string>;
+    /**
+     * Upload a local image file to Feishu and send it as an image message
+     * (im/v1/images + msg_type=image). Used by the clone wizard to deliver the
+     * scan-to-create QR code inline instead of as a downloadable file.
+     */
+    sendImage(chatId: string, filePath: string): Promise<string>;
     /**
      * Cached tenant_access_token for sendFile (P2-18). The token is valid ~2h;
      * fetching it on every file send wastes a round-trip and an unguarded fetch