@jsonstudio/rcc 0.89.683 → 0.89.912

package/README.md

@@ -228,6 +228,50 @@ RouteCodex 会按以下优先级查找配置：
 
 ---
 
+## TOON 工具协议与 CLI 解码说明
+
+RouteCodex / llmswitch-core 对「模型看到的工具参数」与「CLI/执行器真正消费的参数」做了明确分层：
+
+- **模型视角（统一协议）**
+  - 所有支持 TOON 的工具（例如 `exec_command`、`apply_patch`）都可以通过 `arguments.toon` 传参：
+    - 形如 `command: ...\nworkdir: ...\n` 的多行 `key: value`。
+    - 模型无需关心 CLI 的内部 JSON 结构（`cmd` / `input` 等字段名）。
+- **执行视角（CLI 黑盒）**
+  - Codex CLI 的工具实现不会理解 TOON，只接受传统 JSON 形态：
+    - `exec_command` 只认 `{ cmd: string, workdir?, command? ... }`。
+    - `apply_patch` 只认 `{ input: string, patch?: string }`，且 `input` 必须是标准统一 diff（`*** Begin Patch` 开头）。
+  - CLI 被视为黑盒：不能指望它去解析 TOON 或结构化 `changes`。
+
+为此，llmswitch-core 在 **响应侧** 增加了成对的解码过滤器，用于在把响应发回 CLI 之前“翻译”工具参数：
+
+- `ResponseToolArgumentsToonDecodeFilter`
+  - 作用于所有协议（包括 `/v1/responses`），在响应处理阶段对 `choices[].message.tool_calls[*].function.arguments` 解码：
+    - 对 shell/exec 类工具（`shell` / `shell_command` / `exec_command`）：
+      - 从 `toon` 中解析 `command`/`cmd`、`workdir`/`cwd`、`timeout_ms`、`with_escalated_permissions`、`justification` 等字段。
+      - 统一输出为 JSON 字符串：`{"cmd":"...","command":"...","workdir":"...","timeout_ms":...,"with_escalated_permissions":...,"justification":"..."}`。
+    - 对其它工具（如 `view_image`、MCP 工具等）：
+      - 将所有 TOON `key: value` 对映射为普通 JSON 字段，并做轻量类型推断（`true/false`→布尔，数字→number，可解析的 `{}`/`[]`→JSON 对象/数组）。
+    - 对 `apply_patch`：
+      - 交由专门的 `ResponseApplyPatchToonDecodeFilter` 处理，当前过滤器只负责 shell/exec 与通用工具，避免相互覆盖。
+- `ResponseApplyPatchToonDecodeFilter`
+  - 专门负责 `apply_patch` 的响应参数规范化：
+    - 支持两类输入：
+      - `{"toon":"*** Begin Patch ... *** End Patch"}`；
+      - 结构化 `changes` payload（多种 `kind`：insert_after / insert_before / replace / delete / create_file / delete_file）。
+    - 将其统一转换为 `{ input: "<统一 diff>", patch: "<统一 diff>" }` 的 JSON 字符串挂回 `function.arguments`，以兼容 CLI 旧语义。
+
+整体约束可以概括为：
+
+- **对模型**：可以使用 TOON 或结构化 JSON（例如 `changes`）；RouteCodex 会在 Hub Pipeline 内对齐为统一 JSON 结构。
+- **对 CLI / 客户端**：始终看到历史兼容形态：
+  - `exec_command`：具备 `cmd` 字段的 JSON；
+  - `apply_patch`：具备 `input`（统一 diff）的 JSON。
+- **对维护者**：
+  - 所有 TOON → JSON 的解码逻辑集中在 `sharedmodule/llmswitch-core/src/filters/special/` 及响应工具治理路径中；
+  - CLI 侧不需要理解 TOON，也无需修改其内部工具实现；一切转换在 Hub 层完成。
+
+---
+
 ## 参考文档
 
 - `docs/ARCHITECTURE.md` – 全量架构细节与数据流

package/dist/build-info.js

@@ -1,6 +1,6 @@
 export const buildInfo = {
     mode: 'release',
-    version: '0.89.683',
-    buildTime: '2026-01-04T14:19:20.587Z'
+    version: '0.89.912',
+    buildTime: '2026-01-11T04:53:36.258Z'
 };
 //# sourceMappingURL=build-info.js.map

package/dist/cli.js

@@ -118,84 +118,64 @@ program
     .description('RouteCodex CLI - Multi-provider OpenAI proxy server and Claude Code interface')
     .version(cliVersion);
 async function ensureTokenDaemonAutoStart() {
+    // Token 刷新逻辑已经在服务器进程内通过 ManagerDaemon/TokenManagerModule 执行。
+    // 为避免重复启动独立的 token-daemon 进程，这里不再自动拉起后台守护，仅保留显式 CLI 命令。
+    const disabledEnv = String(process.env.ROUTECODEX_TOKEN_DAEMON_DISABLED || process.env.RCC_TOKEN_DAEMON_DISABLED || '')
+        .trim()
+        .toLowerCase();
+    if (disabledEnv !== '1' && disabledEnv !== 'true' && disabledEnv !== 'yes') {
+        logger.info('Token manager is now integrated into the server process; automatic external token-daemon auto-start is disabled.');
+    }
+}
+async function stopTokenDaemonIfRunning() {
     try {
-        const disabledEnv = String(process.env.ROUTECODEX_TOKEN_DAEMON_DISABLED || process.env.RCC_TOKEN_DAEMON_DISABLED || '')
-            .trim()
-            .toLowerCase();
-        if (disabledEnv === '1' || disabledEnv === 'true' || disabledEnv === 'yes') {
-            logger.info('Token daemon auto-start disabled via env (ROUTECODEX_TOKEN_DAEMON_DISABLED/RCC_TOKEN_DAEMON_DISABLED)');
+        if (!fs.existsSync(TOKEN_DAEMON_PID_FILE)) {
             return;
         }
-        let existingPid = null;
+        const txt = fs.readFileSync(TOKEN_DAEMON_PID_FILE, 'utf8');
+        const parsed = Number(String(txt || '').trim());
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            return;
+        }
+        const pid = parsed;
+        let running = false;
         try {
-            if (fs.existsSync(TOKEN_DAEMON_PID_FILE)) {
-                const txt = fs.readFileSync(TOKEN_DAEMON_PID_FILE, 'utf8');
-                const parsed = Number(String(txt || '').trim());
-                if (Number.isFinite(parsed) && parsed > 0) {
-                    existingPid = parsed;
-                }
-            }
+            process.kill(pid, 0);
+            running = true;
         }
         catch {
-            existingPid = null;
+            running = false;
         }
-        const waitForProcessExit = async (pid, timeoutMs) => {
-            const deadline = Date.now() + timeoutMs;
-            while (Date.now() < deadline) {
-                try {
-                    process.kill(pid, 0);
-                }
-                catch {
-                    return;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            }
-        };
-        if (existingPid) {
-            let running = false;
-            try {
-                process.kill(existingPid, 0);
-                running = true;
-            }
-            catch {
-                running = false;
-            }
-            if (running) {
-                logger.info(`Restarting token daemon to refresh environment (pid=${existingPid})`);
-                try {
-                    process.kill(existingPid, 'SIGTERM');
-                }
-                catch {
-                    // ignore
-                }
-                await waitForProcessExit(existingPid, 2000);
-            }
+        if (!running) {
             try {
                 fs.unlinkSync(TOKEN_DAEMON_PID_FILE);
             }
-            catch {
-                // ignore
-            }
+            catch { /* ignore */ }
+            return;
         }
-        const nodeBin = process.execPath;
-        const cliEntry = path.resolve(__dirname, 'cli.js');
-        const args = [cliEntry, 'token-daemon', 'start'];
-        const { spawn } = await import('child_process');
-        const child = spawn(nodeBin, args, {
-            stdio: 'ignore',
-            detached: true,
-            env: { ...process.env }
-        });
         try {
-            child.unref();
+            process.kill(pid, 'SIGTERM');
         }
         catch {
             // ignore
         }
-        logger.info('Token daemon auto-started in background');
+        const deadline = Date.now() + 2000;
+        while (Date.now() < deadline) {
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                break;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        try {
+            fs.unlinkSync(TOKEN_DAEMON_PID_FILE);
+        }
+        catch { /* ignore */ }
     }
-    catch (error) {
-        logger.debug(`Failed to auto-start token daemon: ${error instanceof Error ? error.message : String(error)}`);
+    catch {
+        // best-effort: failures here must not break CLI shutdown
     }
 }
 // Provider command group - update models and generate minimal provider config
@@ -204,12 +184,36 @@ try {
     program.addCommand(createProviderUpdateCommand());
 }
 catch { /* optional: command not available in some builds */ }
+// Camoufox fingerprint debug command (optional)
+try {
+    const { createCamoufoxFpCommand } = await import('./commands/camoufox-fp.js');
+    program.addCommand(createCamoufoxFpCommand());
+}
+catch { /* optional */ }
+// Camoufox fingerprint backfill command (optional)
+try {
+    const { createCamoufoxBackfillCommand } = await import('./commands/camoufox-backfill.js');
+    program.addCommand(createCamoufoxBackfillCommand());
+}
+catch { /* optional */ }
 // Token daemon command group - manage OAuth tokens
 try {
     const { createTokenDaemonCommand } = await import('./commands/token-daemon.js');
     program.addCommand(createTokenDaemonCommand());
 }
 catch { /* optional: command not available in some builds */ }
+// Quota status command - inspect daemon-managed quota snapshot
+try {
+    const { createQuotaStatusCommand } = await import('./commands/quota-status.js');
+    program.addCommand(createQuotaStatusCommand());
+}
+catch { /* optional */ }
+// OAuth command - force re-auth for a specific token (Camoufox-aware when enabled)
+try {
+    const { createOauthCommand } = await import('./commands/oauth.js');
+    program.addCommand(createOauthCommand());
+}
+catch { /* optional: command not available in some builds */ }
 // Validate command - auto start server then run E2E checks
 try {
     const { createValidateCommand } = await import('./commands/validate.js');
@@ -796,6 +800,9 @@ program
                     catch { /* ignore */ }
                 }
             }
+            if (IS_DEV_PACKAGE) {
+                await stopTokenDaemonIfRunning();
+            }
             // Ensure parent exits even if child fails to exit
             try {
                 process.exit(0);
@@ -1072,37 +1079,54 @@ program
     .action(async () => {
     const spinner = await createSpinner('Stopping RouteCodex server...');
     try {
-        // Resolve config path and port
-        const configPath = path.join(homedir(), '.routecodex', 'config.json');
-        // Check if config exists
-        if (!fs.existsSync(configPath)) {
-            spinner.fail(`Configuration file not found: ${configPath}`);
-            logger.error('Cannot determine server port without configuration file');
-            logger.info('Please create a configuration file first:');
-            logger.info('  rcc config init');
-            process.exit(1);
-        }
-        // Load configuration to get port
-        let config;
-        try {
-            const configContent = fs.readFileSync(configPath, 'utf8');
-            config = JSON.parse(configContent);
-        }
-        catch (error) {
-            spinner.fail('Failed to parse configuration file');
-            logger.error(`Invalid JSON in configuration file: ${configPath}`);
-            process.exit(1);
+        let resolvedPort;
+        if (IS_DEV_PACKAGE) {
+            const envPort = Number(process.env.ROUTECODEX_PORT || process.env.RCC_PORT || NaN);
+            if (!Number.isNaN(envPort) && envPort > 0) {
+                logger.info(`Using port ${envPort} from environment (ROUTECODEX_PORT/RCC_PORT) [dev package: routecodex]`);
+                resolvedPort = envPort;
+            }
+            else {
+                resolvedPort = DEFAULT_DEV_PORT;
+                logger.info(`Using dev default port ${resolvedPort} (routecodex dev package)`);
+            }
         }
-        const port = (config?.httpserver?.port ?? config?.server?.port ?? config?.port);
-        if (!port || typeof port !== 'number' || port <= 0) {
-            spinner.fail('Invalid or missing port configuration');
-            logger.error('Configuration file must specify a valid port number');
-            process.exit(1);
+        else {
+            // Resolve config path and port
+            const configPath = path.join(homedir(), '.routecodex', 'config.json');
+            // Check if config exists
+            if (!fs.existsSync(configPath)) {
+                spinner.fail(`Configuration file not found: ${configPath}`);
+                logger.error('Cannot determine server port without configuration file');
+                logger.info('Please create a configuration file first:');
+                logger.info('  rcc config init');
+                process.exit(1);
+            }
+            // Load configuration to get port
+            let config;
+            try {
+                const configContent = fs.readFileSync(configPath, 'utf8');
+                config = JSON.parse(configContent);
+            }
+            catch (error) {
+                spinner.fail('Failed to parse configuration file');
+                logger.error(`Invalid JSON in configuration file: ${configPath}`);
+                process.exit(1);
+            }
+            const port = (config?.httpserver?.port ?? config?.server?.port ?? config?.port);
+            if (!port || typeof port !== 'number' || port <= 0) {
+                spinner.fail('Invalid or missing port configuration');
+                logger.error('Configuration file must specify a valid port number');
+                process.exit(1);
+            }
+            resolvedPort = port;
         }
-        const resolvedPort = port;
         const pids = findListeningPids(resolvedPort);
         if (!pids.length) {
             spinner.succeed(`No server listening on ${resolvedPort}.`);
+            if (IS_DEV_PACKAGE) {
+                await stopTokenDaemonIfRunning();
+            }
             return;
         }
         for (const pid of pids) {
@@ -1115,6 +1139,9 @@ program
         while (Date.now() < deadline) {
             if (findListeningPids(resolvedPort).length === 0) {
                 spinner.succeed(`Stopped server on ${resolvedPort}.`);
+                if (IS_DEV_PACKAGE) {
+                    await stopTokenDaemonIfRunning();
+                }
                 return;
             }
             await sleep(100);
@@ -1129,6 +1156,9 @@ program
             }
         }
         spinner.succeed(`Force stopped server on ${resolvedPort}.`);
+        if (IS_DEV_PACKAGE) {
+            await stopTokenDaemonIfRunning();
+        }
     }
     catch (e) {
         spinner.fail(`Failed to stop: ${e.message}`);
@@ -1146,34 +1176,51 @@ program
     .action(async (options) => {
     const spinner = await createSpinner('Restarting RouteCodex server...');
     try {
-        // Resolve config path
-        const configPath = options.config || path.join(homedir(), '.routecodex', 'config.json');
-        // Check if config exists
-        if (!fs.existsSync(configPath)) {
-            spinner.fail(`Configuration file not found: ${configPath}`);
-            logger.error('Cannot determine server port without configuration file');
-            logger.info('Please create a configuration file first:');
-            logger.info('  rcc config init');
-            process.exit(1);
-        }
-        // Load configuration to get port
-        let config;
-        try {
-            const configContent = fs.readFileSync(configPath, 'utf8');
-            config = JSON.parse(configContent);
-        }
-        catch (error) {
-            spinner.fail('Failed to parse configuration file');
-            logger.error(`Invalid JSON in configuration file: ${configPath}`);
-            process.exit(1);
+        let resolvedPort;
+        let resolvedHost = LOCAL_HOSTS.LOCALHOST;
+        if (IS_DEV_PACKAGE) {
+            const envPort = Number(process.env.ROUTECODEX_PORT || process.env.RCC_PORT || NaN);
+            if (!Number.isNaN(envPort) && envPort > 0) {
+                logger.info(`Using port ${envPort} from environment (ROUTECODEX_PORT/RCC_PORT) [dev package: routecodex]`);
+                resolvedPort = envPort;
+            }
+            else {
+                resolvedPort = DEFAULT_DEV_PORT;
+                logger.info(`Using dev default port ${resolvedPort} (routecodex dev package)`);
+            }
         }
-        const port = (config?.httpserver?.port ?? config?.server?.port ?? config?.port);
-        if (!port || typeof port !== 'number' || port <= 0) {
-            spinner.fail('Invalid or missing port configuration');
-            logger.error('Configuration file must specify a valid port number');
-            process.exit(1);
+        else {
+            // Resolve config path
+            const configPath = options.config || path.join(homedir(), '.routecodex', 'config.json');
+            // Check if config exists
+            if (!fs.existsSync(configPath)) {
+                spinner.fail(`Configuration file not found: ${configPath}`);
+                logger.error('Cannot determine server port without configuration file');
+                logger.info('Please create a configuration file first:');
+                logger.info('  rcc config init');
+                process.exit(1);
+            }
+            // Load configuration to get port
+            let config;
+            try {
+                const configContent = fs.readFileSync(configPath, 'utf8');
+                config = JSON.parse(configContent);
+            }
+            catch (error) {
+                spinner.fail('Failed to parse configuration file');
+                logger.error(`Invalid JSON in configuration file: ${configPath}`);
+                process.exit(1);
+            }
+            const port = (config?.httpserver?.port ?? config?.server?.port ?? config?.port);
+            if (!port || typeof port !== 'number' || port <= 0) {
+                spinner.fail('Invalid or missing port configuration');
+                logger.error('Configuration file must specify a valid port number');
+                process.exit(1);
+            }
+            resolvedPort = port;
+            resolvedHost =
+                (config?.httpserver?.host || config?.server?.host || config?.host || LOCAL_HOSTS.LOCALHOST);
         }
-        const resolvedPort = port;
         // Stop current instance (if any)
         const pids = findListeningPids(resolvedPort);
         if (pids.length) {
@@ -1221,8 +1268,7 @@ program
             fs.writeFileSync(path.join(homedir(), '.routecodex', 'server.cli.pid'), String(child.pid ?? ''), 'utf8');
         }
         catch (error) { /* ignore */ }
-        const host = (config?.httpserver?.host || config?.server?.host || config?.host || LOCAL_HOSTS.LOCALHOST);
-        spinner.succeed(`RouteCodex server restarting on ${host}:${resolvedPort}`);
+        spinner.succeed(`RouteCodex server restarting on ${resolvedHost}:${resolvedPort}`);
         logger.info(`Server will run on port: ${resolvedPort}`);
         logger.info('Press Ctrl+C to stop the server');
         const shutdown = async (sig) => {
@@ -1622,7 +1668,9 @@ async function ensurePortAvailable(port, parentSpinner, opts = {}) {
 }
 function findListeningPids(port) {
     try {
-        const result = spawnSync('lsof', ['-tiTCP', `:${port}`, '-sTCP:LISTEN'], { encoding: 'utf8' });
+        // macOS/BSD lsof expects either "-i TCP:port" or "-tiTCP:port" as a single argument.
+        // Use the compact form to avoid treating ":port" as a filename.
+        const result = spawnSync('lsof', [`-tiTCP:${port}`, '-sTCP:LISTEN'], { encoding: 'utf8' });
         if (result.error) {
             logger.warning(`lsof not available to inspect port usage: ${result.error.message}`);
             return [];