npm - aicodeswitch - Versions diffs - 5.2.12 → 6.0.0 - Mend

aicodeswitch 5.2.12 → 6.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/README.md +6 -2
package/UPGRADE.md +5 -4
package/bin/utils/get-server.js +3 -3
package/dist/server/access-keys/index.js +2 -2
package/dist/server/access-keys/key-logger.js +63 -309
package/dist/server/agent-map/activity-extractor.js +383 -0
package/dist/server/agent-map/agent-map-service.js +1011 -0
package/dist/server/agent-map/index.js +10 -0
package/dist/server/agent-map/routes.js +88 -0
package/dist/server/agent-map/session-meta.js +300 -0
package/dist/server/conversions/index.js +10 -2
package/dist/server/conversions/thinking/providers.js +12 -7
package/dist/server/fs-database.js +169 -926
package/dist/server/log-store/index.js +21 -0
package/dist/server/log-store/log-store.js +1367 -0
package/dist/server/log-store/types.js +2 -0
package/dist/server/main.js +141 -46
package/dist/server/notifier.js +100 -0
package/dist/server/performance-tracker.js +78 -8
package/dist/server/proxy-server.js +173 -56
package/dist/server/transformers/chunk-collector.js +112 -25
package/dist/ui/assets/index-CQVhBlBB.css +1 -0
package/dist/ui/assets/index-QZBX5HHX.js +1186 -0
package/dist/ui/assets/three-CFpmPosW.js +3802 -0
package/dist/ui/index.html +3 -2
package/package.json +4 -2
package/scripts/dev.js +283 -0
package/dist/server/tools-service.js +0 -203
package/dist/server/websocket-service.js +0 -148
package/dist/ui/assets/index-BFVjD9Y2.js +0 -799
package/dist/ui/assets/index-Dm34-4zP.css +0 -1

package/dist/ui/index.html CHANGED Viewed

@@ -4,8 +4,9 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>AI Code Switch</title>
-    <script type="module" crossorigin src="./assets/index-BFVjD9Y2.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-Dm34-4zP.css">
+    <script type="module" crossorigin src="./assets/index-QZBX5HHX.js"></script>
+    <link rel="modulepreload" crossorigin href="./assets/three-CFpmPosW.js">
+    <link rel="stylesheet" crossorigin href="./assets/index-CQVhBlBB.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "aicodeswitch",
-  "version": "5.2.12",
+  "version": "6.0.0",
   "description": "A tool to help you manage AI programming tools to access large language models locally. It allows your Claude Code, Codex and other tools to no longer be limited to official models.",
   "author": "tangshuang",
   "license": "GPL-3.0",
@@ -35,7 +35,7 @@
     "aicodeswitch": "./bin/cli.js"
   },
   "scripts": {
-    "dev": "concurrently \"npm run dev:server\" \"npm run dev:ui\"",
+    "dev": "node scripts/dev.js",
     "dev:ui": "vite",
     "dev:server": "tsx --tsconfig=tsconfig.server.json src/server/main.ts",
     "dev:server:watch": "tsx watch --tsconfig=tsconfig.server.json --clear-screen=false --watch-kill-signal=SIGINT src/server/main.ts",
@@ -80,6 +80,7 @@
     "@types/node": "^20.11.5",
     "@types/react": "^18.2.43",
     "@types/react-dom": "^18.2.17",
+    "@types/three": "^0.165.0",
     "@typescript-eslint/eslint-plugin": "^6.14.0",
     "@typescript-eslint/parser": "^6.14.0",
     "@vitejs/plugin-react": "^4.2.1",
@@ -96,6 +97,7 @@
     "react-router-dom": "^6.21.3",
     "recharts": "^3.7.0",
     "standard-version": "^9.5.0",
+    "three": "^0.165.0",
     "tsx": "^4.7.0",
     "typescript": "^5.2.2",
     "vite": "^5.0.8"

package/scripts/dev.js ADDED Viewed

@@ -0,0 +1,283 @@
+/**
+ * 开发模式启动器（替代 concurrently）
+ *
+ * 目标：
+ * 1. 先启动 server，轮询 /health 确认服务可用后，再启动 UI（避免 UI 起来后代理目标尚未就绪）。
+ * 2. Ctrl+C 后「同步阻塞」到服务子进程真正退出（即服务端打印 Server stopped. 并
+ *    process.exit 之后）再退出父进程，从而避免「终端提示符已回但端口 4567 尚未释放」
+ *    导致的快速重启 EADDRINUSE 冲突。
+ *
+ * 原理：Node 无法真正同步阻塞事件循环，但只要本进程（前台进程组长）不调用
+ * process.exit，终端就不会回到提示符。因此我们在信号处理器里 await 子进程的
+ * 'exit' 事件，等价于「等到 Server stopped. 出现」。
+ *
+ * 直接运行：node scripts/dev.js（package.json 的 dev 脚本）
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const readline = require('readline');
+const http = require('http');
+// 可选彩色前缀；非 TTY 时 chalk 自动失活，无副作用
+let chalk;
+try {
+  // eslint-disable-next-line global-require
+  chalk = require('chalk');
+} catch {
+  chalk = {
+    cyan: (s) => s,
+    magenta: (s) => s,
+    gray: (s) => s,
+    yellow: (s) => s,
+  };
+}
+const ROOT = path.resolve(__dirname, '..');
+// 等待子进程优雅退出的硬超时（秒）。需大于服务端 server.close 的 5s 上限 + 配置恢复余量。
+const SHUTDOWN_TIMEOUT_MS = 15000;
+// 服务端健康检查配置：轮询 /health 直到服务可用再启动 UI。
+const SERVER_PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
+const SERVER_HOST = '127.0.0.1';
+const HEALTH_PATH = '/health';
+const HEALTH_POLL_INTERVAL_MS = 300;
+const HEALTH_WAIT_TIMEOUT_MS = 30000;
+const SERVER_LABEL = chalk.cyan('[server]');
+const UI_LABEL = chalk.magenta('[ui]');
+const DEV_LABEL = chalk.gray('[dev]');
+/**
+ * 探测服务端 /health 是否可用（返回 2xx 即视为就绪）。
+ * @returns {Promise<boolean>}
+ */
+function checkServerHealth() {
+  return new Promise((resolve) => {
+    const req = http.get(
+      {
+        host: SERVER_HOST,
+        port: SERVER_PORT,
+        path: HEALTH_PATH,
+        timeout: 1500,
+      },
+      (res) => {
+        res.resume();
+        resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 300);
+      },
+    );
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+/**
+ * 轮询等待服务端可用。期间若 serverChild 已退出，立即返回 false。
+ * @param {import('child_process').ChildProcess} serverChild
+ * @returns {Promise<boolean>} 服务是否在超时内就绪
+ */
+async function waitForServerReady(serverChild) {
+  const deadline = Date.now() + HEALTH_WAIT_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    // 服务进程已退出则无需再等
+    if (serverChild.exitCode !== null || serverChild.signalCode) return false;
+    if (await checkServerHealth()) return true; // eslint-disable-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, HEALTH_POLL_INTERVAL_MS)); // eslint-disable-line no-await-in-loop
+  }
+  return false;
+}
+/**
+ * 给子进程的 stdout/stderr 加行级前缀后写出。
+ * @param {import('child_process').ChildProcess} child
+ * @param {string} label
+ */
+function prefixStream(child, label) {
+  for (const streamName of ['stdout', 'stderr']) {
+    const stream = child[streamName];
+    if (!stream) continue;
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on('line', (line) => {
+      process.stdout.write(`${label} ${line}\n`);
+    });
+  }
+}
+const IS_WIN = process.platform === 'win32';
+/**
+ * 进程组是否仍存活（组内还有任意进程）。
+ * 子进程以 detached:true 启动后，其 pid == pgid，故 -pid 可探测整组。
+ * 关键点：tsx 会 fork——serverChild 只是 tsx 启动器（launcher），真正运行
+ * main.ts 的 node 进程、以及 esbuild 服务进程都是它的子孙，与启动器同组。
+ * 启动器的 'exit'/'close' 在它自身一退出就触发（Ctrl+C 时几乎立刻），
+ * 而真正的服务进程仍在做数秒优雅关闭并随后打印 "Server stopped."。
+ * 因此「等启动器退出」≠「等服务停止」。改用「轮询整组存活」：只要组内
+ * 还有任何进程（真正的 node 服务），就算未停止；等整组清空才等价于
+ * 「Server stopped. 已出现并 process.exit」。
+ */
+function groupAlive(pid) {
+  if (pid == null) return false;
+  try {
+    process.kill(-pid, 0); // 信号 0 = 探测存在性；-pid = 整个进程组
+    return true;
+  } catch {
+    return false;
+  }
+}
+/**
+ * 向子进程所在进程组发信号（覆盖 launcher + 真正服务 + esbuild）。
+ * Windows 无进程组语义，退化为直接 kill 直接子进程。
+ */
+function signalGroup(child, signal) {
+  if (!child || child.exitCode !== null || child.signalCode) return;
+  const pid = child.pid;
+  if (IS_WIN || pid == null) {
+    try { child.kill(signal); } catch { /* ignore */ }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try { child.kill(signal); } catch { /* ignore */ }
+  }
+}
+/**
+ * 等待整个进程组清空（POSIX），Windows 退化为等待直接子进程 'close'。
+ * 不带内部超时——超时由调用方用 SIGKILL 清组后，本函数下一拍（≤100ms）即感知并 resolve。
+ * @returns {Promise<number>} 直接子进程的 exit code（仅用于异常码上报）
+ */
+function waitForGroupExit(child) {
+  return new Promise((resolve) => {
+    const pid = child.pid;
+    if (IS_WIN || pid == null) {
+      if (child.exitCode !== null || child.signalCode) { resolve(child.exitCode ?? 0); return; }
+      child.once('close', (code, signal) => resolve(code ?? (signal ? 128 + 1 : 0)));
+      return;
+    }
+    if (!groupAlive(pid)) { resolve(child.exitCode ?? 0); return; }
+    const iv = setInterval(() => {
+      if (!groupAlive(pid)) {
+        clearInterval(iv);
+        resolve(child.exitCode ?? 0);
+      }
+    }, 100);
+  });
+}
+async function main() {
+  let exitCode = 0;
+  let shuttingDown = false;
+  let uiChild = null;
+  // 直接调本地 bin，去掉 `npm run` 额外进程层。
+  // POSIX 不开 shell（避免中间 /bin/sh 抢先于 SIGINT 退出）；Windows 的 .cmd 仍需 shell。
+  // detached:true：把子进程放进它自己的进程组（POSIX setsid），这样我们可以用
+  // process.kill(-pid, sig) 给整组发信号、用 groupAlive(-pid) 探测整组存活。
+  // 这一点对本脚本的核心目标至关重要——见 waitForGroupExit 注释：tsx 会 fork，
+  // serverChild 只是启动器，真正的 node 服务是它的孙进程，只有「整组存活探测」
+  // 才能把退出阻塞到真正的 "Server stopped."。
+  const USE_SHELL = IS_WIN;
+  const serverChild = spawn(
+    'tsx',
+    ['--tsconfig=tsconfig.server.json', 'src/server/main.ts'],
+    { cwd: ROOT, shell: USE_SHELL, detached: !IS_WIN, stdio: ['inherit', 'pipe', 'pipe'] },
+  );
+  prefixStream(serverChild, SERVER_LABEL);
+  // 在启动 UI 之前注册信号处理与 server 退出级联，确保等待健康期间 Ctrl+C 也能正确清理
+  process.on('SIGINT', () => { void stop('Ctrl+C'); });
+  process.on('SIGTERM', () => { void stop('SIGTERM'); });
+  serverChild.once('exit', (code) => {
+    if (!shuttingDown) {
+      process.stderr.write(
+        `${DEV_LABEL} 服务进程已退出${code ? `（code=${code}）` : ''}，停止 UI 进程。\n`,
+      );
+      if (code && code !== 0) exitCode = code;
+      void stop();
+    }
+  });
+  // 1) 先等待服务端 /health 可用，再启动 UI，避免 UI 启动时代理目标尚未就绪
+  process.stdout.write(
+    `${DEV_LABEL} 等待服务端就绪（http://${SERVER_HOST}:${SERVER_PORT}${HEALTH_PATH}）...\n`,
+  );
+  const ready = await waitForServerReady(serverChild);
+  if (!ready) {
+    process.stderr.write(
+      `${DEV_LABEL} 服务端在 ${HEALTH_WAIT_TIMEOUT_MS / 1000}s 内未就绪，放弃启动 UI。\n`,
+    );
+    // 走正常停止流程：清理可能残留的服务子进程后退出
+    await stop();
+    return;
+  }
+  process.stdout.write(`${DEV_LABEL} 服务端已就绪，启动 UI...\n`);
+  // 2) 启动 UI（同样放进独立进程组，便于整组信号/清理，避免 vite 的 esbuild 子进程残留）
+  uiChild = spawn('vite', [], {
+    cwd: ROOT,
+    shell: USE_SHELL,
+    detached: !IS_WIN,
+    stdio: ['inherit', 'pipe', 'pipe'],
+  });
+  prefixStream(uiChild, UI_LABEL);
+  uiChild.once('exit', (code) => {
+    if (!shuttingDown) {
+      process.stderr.write(
+        `${DEV_LABEL} UI 进程已退出${code ? `（code=${code}）` : ''}，停止服务进程。\n`,
+      );
+      if (code && code !== 0) exitCode = code;
+      void stop();
+    }
+  });
+  /**
+   * 停止流程：向子进程转发信号，等待服务子进程（长时序）与 UI 子进程（若已启动）都退出。
+   * 关键：不在此处立即 process.exit——父进程存活 = 终端提示符不回。
+   */
+  async function stop(reason) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (reason) {
+      process.stdout.write(
+        `${DEV_LABEL} ${chalk.yellow(reason)}，等待服务完全停止后再退出...\n`,
+      );
+    }
+    // 子进程各自在独立进程组里，Ctrl+C 不会直达它们，必须由父进程显式给整组发 SIGINT，
+    // 真正的服务进程才会进入优雅关闭（恢复配置 + server.close + 打印 "Server stopped."）。
+    signalGroup(serverChild, 'SIGINT');
+    signalGroup(uiChild, 'SIGINT');
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      process.stderr.write(
+        `${DEV_LABEL} 等待超时（${SHUTDOWN_TIMEOUT_MS / 1000}s），强制终止残留子进程。\n`,
+      );
+      signalGroup(serverChild, 'SIGKILL');
+      signalGroup(uiChild, 'SIGKILL');
+    }, SHUTDOWN_TIMEOUT_MS);
+    // 阻塞到「整组清空」：等真正的 node 服务进程也退出（而不仅是 tsx 启动器）。
+    const exits = [waitForGroupExit(serverChild)];
+    if (uiChild) exits.push(waitForGroupExit(uiChild));
+    const [serverCode, uiCode] = await Promise.all(exits);
+    clearTimeout(timer);
+    if (timedOut) exitCode = 1;
+    else if (serverCode && serverCode !== 0) exitCode = serverCode;
+    else if (uiCode && uiCode !== 0) exitCode = uiCode;
+    process.exit(exitCode);
+  }
+}
+main();

package/dist/server/tools-service.js DELETED Viewed

@@ -1,203 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToolsInstallationStatus = getToolsInstallationStatus;
-exports.installTool = installTool;
-const child_process_1 = require("child_process");
-const os_1 = __importDefault(require("os"));
-/**
- * 检测工具是否已安装
- */
-function checkToolInstalled(toolName) {
-    return __awaiter(this, void 0, void 0, function* () {
-        console.log(`[ToolsService] 开始检测工具: ${toolName}`);
-        return new Promise((resolve) => {
-            var _a, _b;
-            const command = toolName === 'claude-code' ? 'claude' : 'codex';
-            console.log(`[ToolsService] 执行命令: ${command} --version`);
-            const child = (0, child_process_1.spawn)(command, ['--version'], {
-                shell: true,
-                stdio: ['ignore', 'pipe', 'pipe'],
-                windowsHide: true, // 隐藏 Windows 命令行窗口，避免检测时闪窗
-            });
-            let stdout = '';
-            let stderr = '';
-            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                stdout += data.toString();
-                console.log(`[ToolsService] ${toolName} stdout:`, data.toString());
-            });
-            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-                stderr += data.toString();
-                console.log(`[ToolsService] ${toolName} stderr:`, data.toString());
-            });
-            child.on('close', (code) => {
-                console.log(`[ToolsService] ${toolName} 进程退出，退出码: ${code}`);
-                if (code === 0) {
-                    // 尝试从输出中提取版本号
-                    const versionMatch = stdout.match(/(\d+\.\d+\.\d+)/) || stderr.match(/(\d+\.\d+\.\d+)/);
-                    resolve({
-                        installed: true,
-                        version: versionMatch ? versionMatch[1] : 'unknown',
-                    });
-                }
-                else {
-                    resolve({ installed: false });
-                }
-            });
-            child.on('error', (err) => {
-                console.log(`[ToolsService] ${toolName} 检测出错:`, err);
-                resolve({ installed: false });
-            });
-            // 10秒超时
-            setTimeout(() => {
-                console.log(`[ToolsService] ${toolName} 检测超时`);
-                child.kill();
-                resolve({ installed: false });
-            }, 10000);
-        });
-    });
-}
-/**
- * 获取工具的安装命令
- */
-function getInstallCommand(toolName) {
-    const platform = os_1.default.platform();
-    const tool = toolName === 'claude-code' ? '@anthropic-ai/claude-code' : '@openai/codex';
-    if (platform === 'win32') {
-        return `npm install -g ${tool}`;
-    }
-    else {
-        // macOS 和 Linux 需要 sudo
-        return `sudo npm install -g ${tool}`;
-    }
-}
-/**
- * 检测所有工具的安装状态
- */
-function getToolsInstallationStatus() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [claudeCodeStatus, codexStatus] = yield Promise.all([
-            checkToolInstalled('claude-code'),
-            checkToolInstalled('codex'),
-        ]);
-        return {
-            claudeCode: Object.assign(Object.assign({}, claudeCodeStatus), { installCommand: claudeCodeStatus.installed ? undefined : getInstallCommand('claude-code') }),
-            codex: Object.assign(Object.assign({}, codexStatus), { installCommand: codexStatus.installed ? undefined : getInstallCommand('codex') }),
-        };
-    });
-}
-/**
- * 执行工具安装
- */
-function installTool(toolName, callbacks) {
-    var _a, _b;
-    const command = getInstallCommand(toolName);
-    const platform = os_1.default.platform();
-    console.log(`[ToolsService] ========== 开始安装 ${toolName} ==========`);
-    console.log(`[ToolsService] 操作系统: ${platform}`);
-    console.log(`[ToolsService] 安装命令: ${command}`);
-    // 立即发送启动消息，让前端快速进入 terminal 界面
-    callbacks.onData(`\n========== 开始安装 ${toolName} ==========\n`);
-    callbacks.onData(`操作系统: ${platform}\n`);
-    callbacks.onData(`执行命令: ${command}\n`);
-    callbacks.onData(`进程启动中...\n\n`);
-    // 在 macOS/Linux 上，需要使用 sudo 并且可能需要输入密码
-    // 在 Windows 上直接使用 cmd 执行 npm 命令
-    let child;
-    if (platform === 'win32') {
-        // Windows: 使用 cmd.exe 执行命令
-        console.log(`[ToolsService] Windows 环境，使用 cmd.exe`);
-        child = (0, child_process_1.spawn)('cmd.exe', ['/c', command], {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: false,
-            windowsHide: true, // 隐藏命令行窗口
-        });
-    }
-    else {
-        // Unix: 使用 sh 执行命令
-        console.log(`[ToolsService] Unix 环境，使用 sh`);
-        child = (0, child_process_1.spawn)('sh', ['-c', command], {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: false,
-        });
-    }
-    console.log(`[ToolsService] 子进程 PID: ${child.pid}`);
-    // 立即发送进程信息
-    callbacks.onData(`子进程已创建 (PID: ${child.pid})\n`);
-    callbacks.onData(`等待 npm 输出...\n\n`);
-    // 设置超时：30分钟后自动终止
-    const timeout = 30 * 60 * 1000;
-    const timeoutHandle = setTimeout(() => {
-        console.error(`[ToolsService] ${toolName} 安装超时 (${timeout}ms)，终止进程`);
-        child.kill('SIGTERM');
-        callbacks.onError(`\n安装超时 (${timeout / 60000} 分钟)，请检查网络连接或手动执行命令：\n${command}\n`);
-    }, timeout);
-    let hasReceivedData = false;
-    (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-        const output = data.toString();
-        if (!hasReceivedData) {
-            console.log(`[ToolsService] ${toolName} 首次收到 stdout 数据`);
-            hasReceivedData = true;
-        }
-        console.log(`[ToolsService] ${toolName} stdout:`, output.slice(0, 200)); // 只记录前200字符
-        callbacks.onData(output);
-    });
-    (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-        const output = data.toString();
-        if (!hasReceivedData) {
-            console.log(`[ToolsService] ${toolName} 首次收到 stderr 数据`);
-            hasReceivedData = true;
-        }
-        console.log(`[ToolsService] ${toolName} stderr:`, output.slice(0, 200)); // 只记录前200字符
-        callbacks.onError(output);
-    });
-    child.on('close', (code) => {
-        clearTimeout(timeoutHandle);
-        console.log(`[ToolsService] ${toolName} 安装进程关闭，退出码: ${code}`);
-        if (code === 0) {
-            callbacks.onData(`\n========== 安装完成 ==========\n`);
-        }
-        else if (code === null) {
-            callbacks.onError(`\n========== 安装被终止 ==========\n`);
-        }
-        else {
-            callbacks.onError(`\n========== 安装失败 (退出码: ${code}) ==========\n`);
-        }
-        callbacks.onClose(code);
-    });
-    child.on('error', (err) => {
-        clearTimeout(timeoutHandle);
-        console.error(`[ToolsService] ${toolName} 安装进程错误:`, err);
-        callbacks.onError(`启动安装进程失败: ${err.message}\n`);
-        callbacks.onError(`错误详情: ${err}\n`);
-        callbacks.onClose(null);
-    });
-    // 处理进程退出信号
-    child.on('exit', (_code, signal) => {
-        clearTimeout(timeoutHandle);
-        if (signal) {
-            console.log(`[ToolsService] ${toolName} 进程被信号终止: ${signal}`);
-            callbacks.onError(`\n安装进程被信号终止: ${signal}\n`);
-        }
-    });
-    // 如果10秒后还没有收到任何数据，发送提示
-    setTimeout(() => {
-        if (!hasReceivedData) {
-            console.log(`[ToolsService] ${toolName} 10秒内未收到输出，发送等待提示`);
-            callbacks.onData(`[提示] 正在连接 npm 服务器，这可能需要一些时间...\n`);
-            callbacks.onData(`[提示] 如果持续无响应，请检查网络连接或 npm 配置\n\n`);
-        }
-    }, 10000);
-    return child;
-}

package/dist/server/websocket-service.js DELETED Viewed

@@ -1,148 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolInstallationWS = void 0;
-exports.createToolInstallationWSServer = createToolInstallationWSServer;
-// @ts-ignore - ws 类型声明可能需要手动安装 @types/ws
-const ws_1 = require("ws");
-const tools_service_1 = require("./tools-service");
-const os_1 = __importDefault(require("os"));
-/**
- * WebSocket 连接管理
- */
-class ToolInstallationWS {
-    constructor(ws, req) {
-        Object.defineProperty(this, "ws", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "childProcess", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        this.ws = ws;
-        console.log(`[WS] 新的 WebSocket 连接: ${req.socket.remoteAddress}`);
-        this.ws.on('message', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                console.log(`[WS] 收到消息:`, message.type);
-                if (message.type === 'input') {
-                    // 用户输入（如密码），发送到子进程的 stdin
-                    if (this.childProcess && this.childProcess.stdin) {
-                        console.log(`[WS] 发送用户输入到子进程:`, message.data.slice(0, 10));
-                        this.childProcess.stdin.write(message.data);
-                    }
-                    else {
-                        console.warn(`[WS] 子进程不存在或无 stdin，无法发送输入`);
-                    }
-                }
-            }
-            catch (err) {
-                console.error(`[WS] 解析消息失败:`, err);
-            }
-        });
-        this.ws.on('close', () => {
-            console.log(`[WS] WebSocket 连接关闭`);
-            this.cleanup();
-        });
-        this.ws.on('error', (err) => {
-            console.error(`[WS] WebSocket 错误:`, err);
-            this.cleanup();
-        });
-    }
-    /**
-     * 开始安装工具
-     */
-    startInstallation(toolName) {
-        console.log(`[WS] 开始安装 ${toolName}`);
-        const callbacks = {
-            onData: (data) => {
-                this.sendMessage({ type: 'stdout', data });
-            },
-            onError: (data) => {
-                this.sendMessage({ type: 'stderr', data });
-            },
-            onClose: (code) => {
-                const success = code === 0;
-                this.sendMessage({ type: 'close', data: { code, success } });
-                // 延迟关闭连接，让客户端收到最终消息
-                setTimeout(() => {
-                    this.ws.close();
-                }, 1000);
-            },
-        };
-        // 启动安装进程
-        this.childProcess = (0, tools_service_1.installTool)(toolName, callbacks);
-        // 发送启动信息
-        const platform = os_1.default.platform();
-        const command = platform === 'win32'
-            ? `npm install -g ${toolName === 'claude-code' ? '@anthropic-ai/claude-code' : '@openai/codex'}`
-            : `sudo npm install -g ${toolName === 'claude-code' ? '@anthropic-ai/claude-code' : '@openai/codex'}`;
-        this.sendMessage({
-            type: 'start',
-            data: {
-                tool: toolName,
-                os: platform,
-                command,
-                pid: this.childProcess.pid || 0,
-            },
-        });
-    }
-    /**
-     * 发送消息到客户端
-     */
-    sendMessage(message) {
-        if (this.ws.readyState === ws_1.WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(message));
-        }
-    }
-    /**
-     * 清理资源
-     */
-    cleanup() {
-        if (this.childProcess) {
-            console.log(`[WS] 清理资源，终止子进程`);
-            // 给进程5秒时间正常退出
-            setTimeout(() => {
-                if (this.childProcess && !this.childProcess.killed) {
-                    this.childProcess.kill('SIGTERM');
-                }
-            }, 5000);
-        }
-    }
-}
-exports.ToolInstallationWS = ToolInstallationWS;
-/**
- * 创建 WebSocket 服务器
- */
-function createToolInstallationWSServer() {
-    const wss = new ws_1.WebSocketServer({ noServer: true });
-    wss.on('connection', (ws, req) => {
-        const wsHandler = new ToolInstallationWS(ws, req);
-        // 监听第一次消息，获取要安装的工具名称
-        ws.once('message', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                if (message.type === 'install' && message.tool) {
-                    wsHandler.startInstallation(message.tool);
-                }
-                else {
-                    ws.send(JSON.stringify({ type: 'error', data: '无效的请求' }));
-                    ws.close();
-                }
-            }
-            catch (error) {
-                console.error(`[WS] 解析安装请求失败:`, error);
-                ws.send(JSON.stringify({ type: 'error', data: '解析请求失败' }));
-                ws.close();
-            }
-        });
-    });
-    return wss;
-}