@jsonstudio/rcc 0.89.942 → 0.89.1086

package/README.md

@@ -228,48 +228,6 @@ 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 层完成。
-
 ---
 
 ## 参考文档
@@ -444,6 +402,7 @@ RouteCodex 支持在用户消息中通过 `<**...**>` 标签设置**当前会话
     - 当前响应 `finish_reason = "stop"`；  
     - 当前轮没有工具调用（`tool_calls` 为空）；  
     - `stopMessageUsed < stopMessageMaxRepeats` 且客户端仍连接。  
+  - 会话要求：sticky 状态依赖 `sessionId` / `conversationId`。`/v1/messages` 请求请确保 `metadata.user_id` 内包含 `session_<uuid>` 字样，系统会在缺少 header/metadata.sessionId 时从 `metadata.__raw_request_body.metadata.user_id` 自动提取用作会话键。  
   - 行为：在保存的原始请求消息末尾追加一条 `{ role: "user", content: "<配置的文本>" }`，通过内部 `reenterPipeline` 自动发下一轮对话，对客户端透明。
 
 > 完整说明、状态持久化规则及 daemon 管理示例，参见 `docs/routing-instructions.md`。

package/dist/build-info.js

@@ -1,6 +1,6 @@
 export const buildInfo = {
     mode: 'release',
-    version: '0.89.942',
-    buildTime: '2026-01-12T04:43:01.796Z'
+    version: '0.89.1086',
+    buildTime: '2026-01-15T13:27:28.446Z'
 };
 //# sourceMappingURL=build-info.js.map

package/dist/build-info.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-info.js","sourceRoot":"","sources":["../src/build-info.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAc;IAClC,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,UAAU;IACnB,SAAS,EAAE,0BAA0B;CACtC,CAAC"}
+{"version":3,"file":"build-info.js","sourceRoot":"","sources":["../src/build-info.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAc;IAClC,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,WAAW;IACpB,SAAS,EAAE,0BAA0B;CACtC,CAAC"}

package/dist/cli.js

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'url';
 import { LOCAL_HOSTS, HTTP_PROTOCOLS, API_PATHS, DEFAULT_CONFIG, API_ENDPOINTS } from './constants/index.js';
 import { buildInfo } from './build-info.js';
 import { ensureLocalTokenPortalEnv } from './token-portal/local-token-portal.js';
+import { parseNetstatListeningPids } from './utils/windows-netstat.js';
 async function createSpinner(text) {
     const mod = await dynamicImport('ora');
     const oraFactory = typeof mod?.default === 'function' ? mod.default : undefined;
@@ -111,6 +112,7 @@ const pkgName = (() => {
 // - routecodex（dev 包）：默认端口 5555，用于本地开发调试，不读取配置端口，除非显式设置 ROUTECODEX_PORT/RCC_PORT
 // - rcc（release 包）：严格按配置文件端口启动（httpserver.port/server.port/port）
 const IS_DEV_PACKAGE = pkgName === 'routecodex';
+const IS_WINDOWS = process.platform === 'win32';
 const DEFAULT_DEV_PORT = 5555;
 const TOKEN_DAEMON_PID_FILE = path.join(homedir(), '.routecodex', 'token-daemon.pid');
 program
@@ -127,6 +129,30 @@ async function ensureTokenDaemonAutoStart() {
         logger.info('Token manager is now integrated into the server process; automatic external token-daemon auto-start is disabled.');
     }
 }
+function killPidBestEffort(pid, opts) {
+    if (!Number.isFinite(pid) || pid <= 0) {
+        return;
+    }
+    if (IS_WINDOWS) {
+        const args = ['/PID', String(pid), '/T'];
+        if (opts.force) {
+            args.push('/F');
+        }
+        try {
+            spawnSync('taskkill', args, { stdio: 'ignore', encoding: 'utf8' });
+        }
+        catch {
+            // best-effort
+        }
+        return;
+    }
+    try {
+        process.kill(pid, opts.force ? 'SIGKILL' : 'SIGTERM');
+    }
+    catch {
+        // best-effort
+    }
+}
 async function stopTokenDaemonIfRunning() {
     try {
         if (!fs.existsSync(TOKEN_DAEMON_PID_FILE)) {
@@ -154,7 +180,7 @@ async function stopTokenDaemonIfRunning() {
             return;
         }
         try {
-            process.kill(pid, 'SIGTERM');
+            killPidBestEffort(pid, { force: false });
         }
         catch {
             // ignore
@@ -208,6 +234,12 @@ try {
     program.addCommand(createQuotaStatusCommand());
 }
 catch { /* optional */ }
+// Quota daemon command - offline replay/once maintenance for provider-quota snapshot
+try {
+    const { createQuotaDaemonCommand } = await import('./commands/quota-daemon.js');
+    program.addCommand(createQuotaDaemonCommand());
+}
+catch { /* optional */ }
 // OAuth command - force re-auth for a specific token (Camoufox-aware when enabled)
 try {
     const { createOauthCommand } = await import('./commands/oauth.js');
@@ -227,7 +259,9 @@ program
     .option('-p, --port <port>', 'RouteCodex server port (overrides config file)')
     // Default to IPv4 localhost to avoid environments where localhost resolves to ::1
     .option('-h, --host <host>', 'RouteCodex server host', LOCAL_HOSTS.IPV4)
+    .option('--url <url>', 'RouteCodex base URL (overrides host/port), e.g. https://code.codewhisper.cc')
     .option('-c, --config <config>', 'RouteCodex configuration file path')
+    .option('--apikey <apikey>', 'RouteCodex server apikey (defaults to httpserver.apikey in config when present)')
     .option('--claude-path <path>', 'Path to Claude Code executable', 'claude')
     .option('--cwd <dir>', 'Working directory for Claude Code (defaults to current shell cwd)')
     .option('--model <model>', 'Model to use with Claude Code')
@@ -240,13 +274,57 @@ program
     const extraArgsFromCommander = Array.isArray(extraArgs) ? extraArgs : [];
     const spinner = await createSpinner('Preparing Claude Code with RouteCodex...');
     try {
+        const parseServerUrl = (raw) => {
+            const trimmed = String(raw || '').trim();
+            if (!trimmed) {
+                throw new Error('--url is empty');
+            }
+            let parsed;
+            try {
+                parsed = new URL(trimmed);
+            }
+            catch {
+                parsed = new URL(`http://${trimmed}`);
+            }
+            const protocol = parsed.protocol === 'https:' ? 'https' : 'http';
+            const host = parsed.hostname;
+            const hasExplicitPort = Boolean(parsed.port && parsed.port.trim());
+            const port = hasExplicitPort ? Number(parsed.port) : null;
+            const rawPath = typeof parsed.pathname === 'string' ? parsed.pathname : '';
+            const basePath = rawPath && rawPath !== '/' ? rawPath.replace(/\/+$/, '') : '';
+            return { protocol, host, port: Number.isFinite(port) ? port : null, basePath };
+        };
+        const readConfigApiKey = (configPath) => {
+            try {
+                if (!configPath || !fs.existsSync(configPath)) {
+                    return null;
+                }
+                const txt = fs.readFileSync(configPath, 'utf8');
+                const cfg = JSON.parse(txt);
+                const direct = cfg?.httpserver?.apikey ?? cfg?.modules?.httpserver?.config?.apikey ?? cfg?.server?.apikey;
+                const value = typeof direct === 'string' ? direct.trim() : '';
+                return value ? value : null;
+            }
+            catch {
+                return null;
+            }
+        };
         // Resolve configuration and determine port
         let configPath = options.config;
         if (!configPath) {
             configPath = path.join(homedir(), '.routecodex', 'config.json');
         }
+        let actualProtocol = 'http';
         let actualPort = options.port ? parseInt(options.port, 10) : null;
         let actualHost = options.host;
+        let actualBasePath = '';
+        if (options.url && String(options.url).trim()) {
+            const parsed = parseServerUrl(options.url);
+            actualProtocol = parsed.protocol;
+            actualHost = parsed.host || actualHost;
+            actualPort = parsed.port ?? actualPort;
+            actualBasePath = parsed.basePath;
+        }
         // Determine effective port for code command:
         // - dev package (routecodex): env override, otherwise固定 5555，不读取配置端口
         // - release package (rcc): 按配置/参数解析端口
@@ -259,7 +337,7 @@ program
         }
         else {
             // 非 dev 包：若未显式指定端口，则从配置文件解析
-            if (!actualPort && fs.existsSync(configPath)) {
+            if (!actualPort && fs.existsSync(configPath) && !(options.url && String(options.url).trim())) {
                 try {
                     const configContent = fs.readFileSync(configPath, 'utf8');
                     const config = JSON.parse(configContent);
@@ -271,12 +349,22 @@ program
                 }
             }
         }
-        // Require explicit port if not resolved
-        if (!actualPort) {
+        // Require explicit port if not resolved (except when --url is used; default ports are implicit).
+        if (!(options.url && String(options.url).trim()) && !actualPort) {
             spinner.fail('Invalid or missing port configuration for RouteCodex server');
             logger.error('Please set httpserver.port in your configuration (e.g., ~/.routecodex/config.json) or use --port');
             process.exit(1);
         }
+        const configuredApiKey = (typeof options.apikey === 'string' && options.apikey.trim()
+            ? options.apikey.trim()
+            : null)
+            ?? (typeof process.env.ROUTECODEX_APIKEY === 'string' && process.env.ROUTECODEX_APIKEY.trim()
+                ? process.env.ROUTECODEX_APIKEY.trim()
+                : null)
+            ?? (typeof process.env.RCC_APIKEY === 'string' && process.env.RCC_APIKEY.trim()
+                ? process.env.RCC_APIKEY.trim()
+                : null)
+            ?? readConfigApiKey(configPath);
         // Check if RouteCodex server needs to be started
         if (options.ensureServer) {
             spinner.text = 'Checking RouteCodex server status...';
@@ -291,11 +379,13 @@ program
                 return h || LOCAL_HOSTS.IPV4;
             };
             const connectHost = normalizeConnectHost(actualHost);
-            const serverUrl = `http://${connectHost}:${actualPort}`;
+            const portPart = actualPort ? `:${actualPort}` : '';
+            const serverUrl = `${actualProtocol}://${connectHost}${portPart}${actualBasePath}`;
             try {
                 const controller = new AbortController();
                 const timeoutId = setTimeout(() => controller.abort(), 3000);
-                const response = await fetch(`${serverUrl}/ready`, { signal: controller.signal, method: 'GET' });
+                const headers = configuredApiKey ? { 'x-api-key': configuredApiKey } : undefined;
+                const response = await fetch(`${serverUrl}/ready`, { signal: controller.signal, method: 'GET', headers });
                 clearTimeout(timeoutId);
                 if (!response.ok) {
                     throw new Error('Server not ready');
@@ -307,6 +397,11 @@ program
                 spinner.succeed('RouteCodex server is ready');
             }
             catch (error) {
+                if (options.url && String(options.url).trim()) {
+                    spinner.fail('RouteCodex server is not reachable (ensure-server with --url cannot auto-start)');
+                    logger.error(error instanceof Error ? error.message : String(error));
+                    process.exit(1);
+                }
                 spinner.info('RouteCodex server is not running, starting it...');
                 // Start RouteCodex server in background
                 const { spawn } = await import('child_process');
@@ -324,7 +419,8 @@ program
                 for (let i = 0; i < 30; i++) {
                     await sleep(1000);
                     try {
-                        const res = await fetch(`${serverUrl}/ready`, { method: 'GET' });
+                        const headers = configuredApiKey ? { 'x-api-key': configuredApiKey } : undefined;
+                        const res = await fetch(`${serverUrl}/ready`, { method: 'GET', headers });
                         if (res.ok) {
                             const jr = await res.json().catch(() => ({}));
                             if (jr?.status === 'ready') {
@@ -355,7 +451,8 @@ program
             }
             return actualHost || LOCAL_HOSTS.IPV4;
         })());
-        const anthropicBase = `http://${resolvedBaseHost}:${actualPort}`;
+        const portPart = actualPort ? `:${actualPort}` : '';
+        const anthropicBase = `${actualProtocol}://${resolvedBaseHost}${portPart}${actualBasePath}`;
         const currentCwd = (() => {
             try {
                 const d = options.cwd ? String(options.cwd) : process.cwd();
@@ -379,7 +476,7 @@ program
             // Cover both common env var names used by Anthropic SDK / tools
             ANTHROPIC_BASE_URL: anthropicBase,
             ANTHROPIC_API_URL: anthropicBase,
-            ANTHROPIC_API_KEY: 'rcc-proxy-key'
+            ANTHROPIC_API_KEY: configuredApiKey || 'rcc-proxy-key'
         };
         // Avoid auth conflict: prefer API key routed via RouteCodex; remove shell tokens
         try {
@@ -409,8 +506,33 @@ program
             const sepIndex = afterCode.indexOf('--');
             const tail = sepIndex >= 0 ? afterCode.slice(sepIndex + 1) : afterCode;
             // 过滤本命令自身已识别的选项，剩余的作为透传参数
-            const knownOpts = new Set(['-p', '--port', '-h', '--host', '-c', '--config', '--claude-path', '--model', '--profile', '--ensure-server']);
-            const requireValue = new Set(['-p', '--port', '-h', '--host', '-c', '--config', '--claude-path', '--model', '--profile']);
+            const knownOpts = new Set([
+                '-p',
+                '--port',
+                '-h',
+                '--host',
+                '--url',
+                '-c',
+                '--config',
+                '--apikey',
+                '--claude-path',
+                '--model',
+                '--profile',
+                '--ensure-server'
+            ]);
+            const requireValue = new Set([
+                '-p',
+                '--port',
+                '-h',
+                '--host',
+                '--url',
+                '-c',
+                '--config',
+                '--apikey',
+                '--claude-path',
+                '--model',
+                '--profile'
+            ]);
             const passThrough = [];
             for (let i = 0; i < tail.length; i++) {
                 const tok = tail[i];
@@ -466,10 +588,16 @@ program
             const envPath = String(process.env.CLAUDE_PATH || '').trim();
             return envPath || 'claude';
         })();
+        // Windows: Node spawn does not resolve .cmd shims unless using a shell. Prefer shell for bare commands.
+        const shouldUseShell = IS_WINDOWS &&
+            !path.extname(claudeBin) &&
+            !claudeBin.includes('/') &&
+            !claudeBin.includes('\\');
         const claudeProcess = spawn(claudeBin, claudeArgs, {
             stdio: 'inherit',
             env: claudeEnv,
-            cwd: currentCwd
+            cwd: currentCwd,
+            shell: shouldUseShell
         });
         spinner.succeed('Claude Code launched with RouteCodex proxy');
         // Log normalized IPv4 host to avoid confusion (do not print ::/localhost)
@@ -490,6 +618,16 @@ program
         };
         process.on('SIGINT', () => { void shutdown('SIGINT'); });
         process.on('SIGTERM', () => { void shutdown('SIGTERM'); });
+        claudeProcess.on('error', (err) => {
+            try {
+                logger.error(`Failed to launch Claude Code (${claudeBin}): ${err instanceof Error ? err.message : String(err)}`);
+                if (IS_WINDOWS && shouldUseShell) {
+                    logger.error('Tip: If Claude is installed via npm, ensure the shim is in PATH (e.g. claude.cmd).');
+                }
+            }
+            catch { /* ignore */ }
+            process.exit(1);
+        });
         claudeProcess.on('exit', (code, signal) => {
             if (signal) {
                 process.exit(0);
@@ -769,12 +907,14 @@ program
                 childProc.kill(sig);
             }
             catch (error) { /* ignore */ }
-            try {
-                if (childProc.pid) {
-                    process.kill(-childProc.pid, sig);
+            if (!IS_WINDOWS) {
+                try {
+                    if (childProc.pid) {
+                        process.kill(-childProc.pid, sig);
+                    }
                 }
+                catch (error) { /* ignore */ }
             }
-            catch (error) { /* ignore */ }
             // 3) Wait briefly; if still listening, try SIGTERM/SIGKILL by port
             const deadline = Date.now() + 3500;
             while (Date.now() < deadline) {
@@ -786,10 +926,7 @@ program
             const remain = findListeningPids(resolvedPort);
             if (remain.length) {
                 for (const pid of remain) {
-                    try {
-                        process.kill(pid, 'SIGTERM');
-                    }
-                    catch { /* ignore */ }
+                    killPidBestEffort(pid, { force: false });
                 }
                 const killDeadline = Date.now() + 1500;
                 while (Date.now() < killDeadline) {
@@ -802,10 +939,7 @@ program
             const still = findListeningPids(resolvedPort);
             if (still.length) {
                 for (const pid of still) {
-                    try {
-                        process.kill(pid, 'SIGKILL');
-                    }
-                    catch { /* ignore */ }
+                    killPidBestEffort(pid, { force: true });
                 }
             }
             if (IS_DEV_PACKAGE) {
@@ -1138,10 +1272,7 @@ program
             return;
         }
         for (const pid of pids) {
-            try {
-                process.kill(pid, 'SIGTERM');
-            }
-            catch { /* ignore */ }
+            killPidBestEffort(pid, { force: false });
         }
         const deadline = Date.now() + 3000;
         while (Date.now() < deadline) {
@@ -1157,10 +1288,7 @@ program
         const remain = findListeningPids(resolvedPort);
         if (remain.length) {
             for (const pid of remain) {
-                try {
-                    process.kill(pid, 'SIGKILL');
-                }
-                catch { /* ignore */ }
+                killPidBestEffort(pid, { force: true });
             }
         }
         spinner.succeed(`Force stopped server on ${resolvedPort}.`);
@@ -1233,10 +1361,7 @@ program
         const pids = findListeningPids(resolvedPort);
         if (pids.length) {
             for (const pid of pids) {
-                try {
-                    process.kill(pid, 'SIGTERM');
-                }
-                catch { /* ignore */ }
+                killPidBestEffort(pid, { force: false });
             }
             const deadline = Date.now() + 3500;
             while (Date.now() < deadline) {
@@ -1247,10 +1372,7 @@ program
             }
             const remain = findListeningPids(resolvedPort);
             for (const pid of remain) {
-                try {
-                    process.kill(pid, 'SIGKILL');
-                }
-                catch { /* ignore */ }
+                killPidBestEffort(pid, { force: true });
             }
         }
         spinner.text = 'Starting RouteCodex server...';
@@ -1288,12 +1410,14 @@ program
                 child.kill(sig);
             }
             catch (error) { /* ignore */ }
-            try {
-                if (child.pid) {
-                    process.kill(-child.pid, sig);
+            if (!IS_WINDOWS) {
+                try {
+                    if (child.pid) {
+                        process.kill(-child.pid, sig);
+                    }
                 }
+                catch (error) { /* ignore */ }
             }
-            catch (error) { /* ignore */ }
             const deadline = Date.now() + 3500;
             while (Date.now() < deadline) {
                 if (findListeningPids(resolvedPort).length === 0) {
@@ -1303,10 +1427,7 @@ program
             }
             const remain = findListeningPids(resolvedPort);
             for (const pid of remain) {
-                try {
-                    process.kill(pid, 'SIGTERM');
-                }
-                catch (error) { /* ignore */ }
+                killPidBestEffort(pid, { force: false });
             }
             const killDeadline = Date.now() + 1500;
             while (Date.now() < killDeadline) {
@@ -1317,10 +1438,7 @@ program
             }
             const still = findListeningPids(resolvedPort);
             for (const pid of still) {
-                try {
-                    process.kill(pid, 'SIGKILL');
-                }
-                catch (error) { /* ignore */ }
+                killPidBestEffort(pid, { force: true });
             }
             // Ensure parent exits in any case
             try {
@@ -1623,7 +1741,7 @@ async function ensurePortAvailable(port, parentSpinner, opts = {}) {
     const pollInterval = 150;
     for (const pid of initialPids) {
         try {
-            process.kill(pid, 'SIGTERM');
+            killPidBestEffort(pid, { force: false });
         }
         catch (error) {
             stopSpinner.warn(`Failed to send SIGTERM to PID ${pid}: ${error.message}`);
@@ -1645,7 +1763,7 @@ async function ensurePortAvailable(port, parentSpinner, opts = {}) {
         logger.warning(`Graceful stop timed out. Forcing SIGKILL to PID(s): ${remaining.join(', ')}`);
         for (const pid of remaining) {
             try {
-                process.kill(pid, 'SIGKILL');
+                killPidBestEffort(pid, { force: true });
             }
             catch (error) {
                 const message = error.message;
@@ -1676,6 +1794,14 @@ async function ensurePortAvailable(port, parentSpinner, opts = {}) {
 }
 function findListeningPids(port) {
     try {
+        if (IS_WINDOWS) {
+            const result = spawnSync('netstat', ['-ano', '-p', 'tcp'], { encoding: 'utf8' });
+            if (result.error) {
+                logger.warning(`netstat not available to inspect port usage: ${result.error.message}`);
+                return [];
+            }
+            return parseNetstatListeningPids(result.stdout || '', port);
+        }
         // 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' });
@@ -1846,7 +1972,7 @@ program
             const ksp = await createSpinner(`Killing ${pids.length} listener(s) on ${port}...`);
             for (const pid of pids) {
                 try {
-                    process.kill(pid, 'SIGKILL');
+                    killPidBestEffort(pid, { force: true });
                 }
                 catch (e) {
                     ksp.warn(`Failed to kill ${pid}: ${e.message}`);