open-claude-code-proxy 1.0.0 → 1.1.1

package/README.md

@@ -80,6 +80,43 @@ cd open-claude-code-proxy
    source ~/.zshrc
    ```
 
+### Port Configuration
+
+The proxy supports flexible port configuration:
+
+```bash
+# Use command line argument
+claude-local-proxy --port 8080
+claude-local-proxy -p 8080
+
+# Or use environment variable
+PORT=8080 claude-local-proxy
+
+# Or let it use saved config (~/.claude-proxy/config.json)
+claude-local-proxy
+```
+
+**Port Priority**: CLI argument > Config file > Environment variable > Default (12346)
+
+On first run, you'll be prompted to customize the port. Your choice is saved for future use.
+
+### OpenCode Auto-Configuration
+
+The proxy can automatically configure [OpenCode](https://opencode.ai) for you:
+
+- Detects OpenCode config at `~/.config/opencode/opencode.json`
+- Updates `provider.anthropic.options.baseURL` to match your proxy port
+- Creates automatic backups before modifying (keeps last 3)
+- Prompts before making changes (use `--skip-opencode` to skip)
+
+```bash
+# Auto-configure OpenCode
+claude-local-proxy -p 8080
+
+# Skip OpenCode configuration
+claude-local-proxy -p 8080 --skip-opencode
+```
+
 ### Configure Your Client
 
 Point your app to the local proxy:
@@ -93,6 +130,18 @@ Point your app to the local proxy:
 
 > **Note**: The API key can be any string - authentication is handled by your Claude Code session.
 
+### CLI Options
+
+```
+Usage: claude-local-proxy [options]
+
+Options:
+  -p, --port <port>    Server port (1024-65535)
+  --skip-opencode      Skip OpenCode auto-configuration
+  -h, --help           Show help
+  -v, --version        Show version
+```
+
 ### Commands
 
 | Command | Description |
@@ -174,6 +223,43 @@ cd open-claude-code-proxy
    source ~/.zshrc
    ```
 
+### 端口配置
+
+代理支持灵活的端口配置方式：
+
+```bash
+# 使用命令行参数
+claude-local-proxy --port 8080
+claude-local-proxy -p 8080
+
+# 或使用环境变量
+PORT=8080 claude-local-proxy
+
+# 或使用已保存的配置 (~/.claude-proxy/config.json)
+claude-local-proxy
+```
+
+**端口优先级**：命令行参数 > 配置文件 > 环境变量 > 默认值 (12346)
+
+首次运行时会提示你自定义端口，你的选择会被保存供后续使用。
+
+### OpenCode 自动配置
+
+代理可以自动为 [OpenCode](https://opencode.ai) 配置连接：
+
+- 自动检测 `~/.config/opencode/opencode.json` 配置文件
+- 更新 `provider.anthropic.options.baseURL` 为代理端口
+- 修改前自动备份（保留最近 3 个备份）
+- 修改前会询问确认（使用 `--skip-opencode` 跳过）
+
+```bash
+# 自动配置 OpenCode
+claude-local-proxy -p 8080
+
+# 跳过 OpenCode 配置
+claude-local-proxy -p 8080 --skip-opencode
+```
+
 ### 配置客户端
 
 将你的应用指向本地代理：
@@ -187,6 +273,18 @@ cd open-claude-code-proxy
 
 > **注意**：API Key 可以是任意字符串，实际认证由 Claude Code 会话处理。
 
+### CLI 选项
+
+```
+用法: claude-local-proxy [选项]
+
+选项:
+  -p, --port <port>    服务器端口 (1024-65535)
+  --skip-opencode      跳过 OpenCode 自动配置
+  -h, --help           显示帮助
+  -v, --version        显示版本
+```
+
 ### 命令说明
 
 | 命令 | 说明 |

package/claude-proxy

@@ -6,6 +6,21 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 SERVER_JS="$SCRIPT_DIR/server.js"
 PID_FILE="$SCRIPT_DIR/.claude-proxy.pid"
 LOG_FILE="$SCRIPT_DIR/proxy.log"
+CONFIG_FILE="$HOME/.claude-proxy/config.json"
+
+# 从配置文件读取端口
+get_port() {
+    if [ -f "$CONFIG_FILE" ]; then
+        PORT=$(cat "$CONFIG_FILE" | grep -o '"port":[[:space:]]*[0-9]*' | grep -o '[0-9]*')
+        if [ -n "$PORT" ]; then
+            echo "$PORT"
+            return
+        fi
+    fi
+    echo "${PORT:-12346}"
+}
+
+PROXY_PORT=$(get_port)
 
 # 颜色定义
 RED='\033[0;31m'
@@ -115,8 +130,8 @@ start() {
         return 1
     fi
 
-    # 后台启动
-    nohup node "$SERVER_JS" > "$LOG_FILE" 2>&1 &
+    # 后台启动（使用配置的端口）
+    PORT=$PROXY_PORT nohup node "$SERVER_JS" > "$LOG_FILE" 2>&1 &
     PID=$!
     echo $PID > "$PID_FILE"
 
@@ -125,7 +140,7 @@ start() {
 
     if is_running; then
         success "服务已启动 (PID: $PID)"
-        success "监听地址: http://localhost:12346"
+        success "监听地址: http://localhost:$PROXY_PORT"
         echo ""
         info "查看日志: $0 logs"
         info "查看状态: $0 status"
@@ -184,7 +199,7 @@ status() {
         success "服务运行中"
         echo ""
         echo "  PID:      $PID"
-        echo "  地址:     http://localhost:12346"
+        echo "  地址:     http://localhost:$PROXY_PORT"
         echo "  日志:     $LOG_FILE"
         echo ""
 
@@ -240,7 +255,7 @@ Claude Local Proxy 控制脚本
 配置文件:
   客户端配置 (opencode/cursor):
     {
-      "baseURL": "http://localhost:12346",
+      "baseURL": "http://localhost:$PROXY_PORT",
       "apiKey": "sk-any-key-works"
     }
 

package/cli.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Local Proxy CLI
+ * 交互式命令行入口
+ */
+
+const readline = require('readline');
+const config = require('./lib/config');
+const portUtils = require('./lib/port-utils');
+const opencodeConfig = require('./lib/opencode-config');
+
+const VERSION = '1.0.0';
+
+/**
+ * 解析命令行参数
+ * @returns {{port: number|null, help: boolean, version: boolean, skipOpencode: boolean}}
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    port: null,
+    help: false,
+    version: false,
+    skipOpencode: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--help' || arg === '-h') {
+      result.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      result.version = true;
+    } else if (arg === '--skip-opencode') {
+      result.skipOpencode = true;
+    } else if (arg === '--port' || arg === '-p') {
+      const portValue = args[++i];
+      if (portValue) {
+        result.port = parseInt(portValue, 10);
+      }
+    } else if (arg.startsWith('--port=')) {
+      result.port = parseInt(arg.split('=')[1], 10);
+    } else if (arg.startsWith('-p=')) {
+      result.port = parseInt(arg.split('=')[1], 10);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 显示帮助信息
+ */
+function showHelp() {
+  console.log(`
+Claude Local Proxy - 本地代理服务器
+
+用法:
+  claude-local-proxy [选项]
+
+选项:
+  -p, --port <port>    指定服务器监听端口 (1024-65535)
+  --skip-opencode      跳过 OpenCode 配置自动更新
+  -h, --help           显示帮助信息
+  -v, --version        显示版本号
+
+端口优先级:
+  1. 命令行参数 (--port)
+  2. 配置文件 (~/.claude-proxy/config.json)
+  3. 环境变量 (PORT)
+  4. 默认值 (12346)
+
+配置文件位置:
+  ${config.CONFIG_FILE}
+
+示例:
+  claude-local-proxy                 # 使用默认端口或已保存的配置
+  claude-local-proxy -p 8080         # 使用端口 8080
+  claude-local-proxy --port=9000     # 使用端口 9000
+  claude-local-proxy --skip-opencode # 跳过 OpenCode 配置更新
+`);
+}
+
+/**
+ * 创建 readline 接口
+ */
+function createReadlineInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * 异步询问用户输入
+ * @param {readline.Interface} rl readline 接口
+ * @param {string} question 问题
+ * @returns {Promise<string>}
+ */
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * 交互式获取端口
+ * @param {readline.Interface} rl readline 接口
+ * @param {number} defaultPort 默认端口
+ * @returns {Promise<number>}
+ */
+async function promptForPort(rl, defaultPort) {
+  let attempts = 0;
+  const maxAttempts = 3;
+
+  while (attempts < maxAttempts) {
+    const answer = await ask(rl, `请输入端口号 (默认: ${defaultPort}): `);
+
+    if (!answer) {
+      return defaultPort;
+    }
+
+    const port = parseInt(answer, 10);
+    const validation = config.validatePort(port);
+
+    if (validation.valid) {
+      const available = await portUtils.isPortAvailable(port);
+      if (available) {
+        return port;
+      } else {
+        console.log(`\n${portUtils.getPortOccupiedMessage(port)}`);
+        attempts++;
+      }
+    } else {
+      console.log(`\n错误: ${validation.error}`);
+      attempts++;
+    }
+
+    if (attempts < maxAttempts) {
+      console.log(`请重新输入 (剩余尝试次数: ${maxAttempts - attempts})\n`);
+    }
+  }
+
+  console.log(`\n已达到最大尝试次数，将使用默认端口 ${defaultPort}`);
+  return defaultPort;
+}
+
+/**
+ * 询问是否更新 OpenCode 配置
+ * @param {readline.Interface} rl readline 接口
+ * @returns {Promise<boolean>}
+ */
+async function askUpdateOpenCode(rl) {
+  const answer = await ask(rl, '是否自动更新 OpenCode 配置? (Y/n): ');
+  return answer.toLowerCase() !== 'n';
+}
+
+/**
+ * 询问备份失败时是否继续
+ * @param {readline.Interface} rl readline 接口
+ * @returns {Promise<boolean>}
+ */
+async function askContinueWithoutBackup(rl) {
+  const answer = await ask(rl, '备份失败，是否仍然继续更新配置? (y/N): ');
+  return answer.toLowerCase() === 'y';
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+  const args = parseArgs();
+
+  // 显示版本
+  if (args.version) {
+    console.log(`claude-local-proxy v${VERSION}`);
+    process.exit(0);
+  }
+
+  // 显示帮助
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // 验证 CLI 端口参数
+  if (args.port !== null) {
+    const validation = config.validatePort(args.port);
+    if (!validation.valid) {
+      console.error(`错误: ${validation.error}`);
+      process.exit(1);
+    }
+  }
+
+  let finalPort;
+  let rl = null;
+
+  try {
+    // 确定端口
+    if (args.port !== null) {
+      // CLI 参数指定了端口
+      finalPort = args.port;
+    } else {
+      // 获取配置的端口
+      finalPort = config.getPort();
+
+      // 检查端口是否可用
+      const isAvailable = await portUtils.isPortAvailable(finalPort);
+
+      if (!isAvailable) {
+        console.log(`\n默认端口 ${finalPort} 已被占用。`);
+
+        rl = createReadlineInterface();
+
+        // 交互式获取新端口
+        finalPort = await promptForPort(rl, config.DEFAULT_PORT);
+      } else if (config.isFirstRun()) {
+        // 首次运行，询问是否自定义端口
+        console.log('\n欢迎使用 Claude Local Proxy!');
+        console.log('这是首次运行，您可以自定义服务器端口。\n');
+
+        rl = createReadlineInterface();
+
+        const answer = await ask(rl, `使用默认端口 ${config.DEFAULT_PORT}? (Y/n): `);
+
+        if (answer.toLowerCase() === 'n') {
+          finalPort = await promptForPort(rl, config.DEFAULT_PORT);
+        }
+      }
+    }
+
+    // 再次检查最终端口是否可用
+    const finalAvailable = await portUtils.isPortAvailable(finalPort);
+    if (!finalAvailable) {
+      console.error(`\n错误: 端口 ${finalPort} 不可用。`);
+      console.log(portUtils.getPortOccupiedMessage(finalPort));
+      if (rl) rl.close();
+      process.exit(1);
+    }
+
+    // 保存端口配置
+    config.savePort(finalPort);
+    console.log(`\n端口配置已保存: ${finalPort}`);
+
+    // OpenCode 配置更新
+    if (!args.skipOpencode) {
+      const opencodeDetect = opencodeConfig.detectOpenCodeConfig();
+
+      if (opencodeDetect.exists) {
+        let shouldUpdate = true;
+
+        // 如果有交互能力，询问用户
+        if (!rl && process.stdin.isTTY) {
+          rl = createReadlineInterface();
+        }
+
+        if (rl) {
+          shouldUpdate = await askUpdateOpenCode(rl);
+        }
+
+        if (shouldUpdate) {
+          const updateResult = opencodeConfig.updateOpenCodeBaseURL(finalPort);
+
+          if (updateResult.success) {
+            console.log(`\n${updateResult.message}`);
+            if (updateResult.backupPath) {
+              console.log(`备份文件: ${updateResult.backupPath}`);
+            }
+            console.log('\n请重启 OpenCode 以使配置生效。');
+          } else {
+            console.log(`\n警告: ${updateResult.message}`);
+            console.log(opencodeConfig.getManualConfigGuide(finalPort));
+          }
+        } else {
+          console.log('\n跳过 OpenCode 配置更新。');
+          console.log(opencodeConfig.getManualConfigGuide(finalPort));
+        }
+      } else {
+        console.log('\n未检测到 OpenCode 配置文件。');
+        console.log(opencodeConfig.getManualConfigGuide(finalPort));
+      }
+    }
+
+    if (rl) {
+      rl.close();
+    }
+
+    // 设置环境变量并启动服务器
+    process.env.PORT = finalPort.toString();
+
+    console.log('\n正在启动代理服务器...\n');
+
+    // 加载并运行服务器
+    require('./server');
+
+  } catch (error) {
+    console.error('启动失败:', error.message);
+    if (rl) rl.close();
+    process.exit(1);
+  }
+}
+
+// 运行
+main();

package/lib/config.js

@@ -0,0 +1,122 @@
+/**
+ * 配置文件管理模块
+ * 负责读写 ~/.claude-proxy/config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.claude-proxy');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_PORT = 12346;
+
+/**
+ * 确保配置目录存在
+ */
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * 读取配置文件
+ * @returns {Object} 配置对象
+ */
+function readConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.warn(`警告: 配置文件读取失败 - ${error.message}`);
+  }
+  return {};
+}
+
+/**
+ * 写入配置文件
+ * @param {Object} config 配置对象
+ */
+function writeConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+
+/**
+ * 获取端口配置
+ * 优先级: CLI 参数 > 配置文件 > 环境变量 > 默认值
+ * @param {number|null} cliPort CLI 参数指定的端口
+ * @returns {number} 端口号
+ */
+function getPort(cliPort = null) {
+  // 1. CLI 参数优先级最高
+  if (cliPort !== null && cliPort !== undefined) {
+    return cliPort;
+  }
+
+  // 2. 配置文件
+  const config = readConfig();
+  if (config.port) {
+    return config.port;
+  }
+
+  // 3. 环境变量
+  if (process.env.PORT) {
+    const envPort = parseInt(process.env.PORT, 10);
+    if (!isNaN(envPort)) {
+      return envPort;
+    }
+  }
+
+  // 4. 默认值
+  return DEFAULT_PORT;
+}
+
+/**
+ * 保存端口配置
+ * @param {number} port 端口号
+ */
+function savePort(port) {
+  const config = readConfig();
+  config.port = port;
+  writeConfig(config);
+}
+
+/**
+ * 检查是否首次运行（配置文件不存在）
+ * @returns {boolean}
+ */
+function isFirstRun() {
+  return !fs.existsSync(CONFIG_FILE);
+}
+
+/**
+ * 验证端口号是否有效
+ * @param {number} port 端口号
+ * @returns {{valid: boolean, error?: string}}
+ */
+function validatePort(port) {
+  const num = parseInt(port, 10);
+  if (isNaN(num)) {
+    return { valid: false, error: '端口必须是数字' };
+  }
+  if (num < 1024 || num > 65535) {
+    return { valid: false, error: '端口范围必须在 1024-65535 之间' };
+  }
+  return { valid: true };
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  DEFAULT_PORT,
+  readConfig,
+  writeConfig,
+  getPort,
+  savePort,
+  isFirstRun,
+  validatePort
+};

package/lib/opencode-config.js

@@ -0,0 +1,228 @@
+/**
+ * OpenCode 配置管理模块
+ * 负责检测、备份和更新 OpenCode 配置文件
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * 获取 OpenCode 配置文件路径（跨平台）
+ * @returns {string} 配置文件路径
+ */
+function getOpenCodeConfigPath() {
+  const homedir = os.homedir();
+  if (process.platform === 'win32') {
+    return path.join(homedir, '.config', 'opencode', 'opencode.json');
+  }
+  // macOS / Linux
+  return path.join(homedir, '.config', 'opencode', 'opencode.json');
+}
+
+/**
+ * 检测 OpenCode 配置文件是否存在
+ * @returns {{exists: boolean, path: string}}
+ */
+function detectOpenCodeConfig() {
+  const configPath = getOpenCodeConfigPath();
+  return {
+    exists: fs.existsSync(configPath),
+    path: configPath
+  };
+}
+
+/**
+ * 读取 OpenCode 配置
+ * @returns {{success: boolean, config?: Object, error?: string, path: string}}
+ */
+function readOpenCodeConfig() {
+  const configPath = getOpenCodeConfigPath();
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { success: false, error: '配置文件不存在', path: configPath };
+    }
+    const content = fs.readFileSync(configPath, 'utf8');
+    const config = JSON.parse(content);
+    return { success: true, config, path: configPath };
+  } catch (error) {
+    return { success: false, error: error.message, path: configPath };
+  }
+}
+
+/**
+ * 创建备份文件
+ * @param {string} configPath 配置文件路径
+ * @returns {{success: boolean, backupPath?: string, error?: string}}
+ */
+function createBackup(configPath) {
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { success: false, error: '配置文件不存在' };
+    }
+
+    const dir = path.dirname(configPath);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+    const backupPath = path.join(dir, `opencode.json.backup.${timestamp}`);
+
+    // 复制文件
+    fs.copyFileSync(configPath, backupPath);
+
+    // 清理旧备份，只保留最近 3 个
+    cleanupOldBackups(dir, 3);
+
+    return { success: true, backupPath };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * 清理旧备份文件
+ * @param {string} dir 目录路径
+ * @param {number} keepCount 保留数量
+ */
+function cleanupOldBackups(dir, keepCount) {
+  try {
+    const files = fs.readdirSync(dir)
+      .filter(f => f.startsWith('opencode.json.backup.'))
+      .map(f => ({
+        name: f,
+        path: path.join(dir, f),
+        mtime: fs.statSync(path.join(dir, f)).mtime
+      }))
+      .sort((a, b) => b.mtime - a.mtime); // 按修改时间降序
+
+    // 删除多余的备份
+    for (let i = keepCount; i < files.length; i++) {
+      fs.unlinkSync(files[i].path);
+    }
+  } catch (error) {
+    // 清理失败不影响主流程
+  }
+}
+
+/**
+ * 更新 OpenCode 配置中的 baseURL
+ * @param {number} port 端口号
+ * @param {boolean} createBackupFirst 是否先创建备份
+ * @returns {{success: boolean, message: string, backupPath?: string, configPath?: string}}
+ */
+function updateOpenCodeBaseURL(port, createBackupFirst = true) {
+  const configPath = getOpenCodeConfigPath();
+  const newBaseURL = `http://localhost:${port}`;
+
+  try {
+    // 检查文件是否存在
+    if (!fs.existsSync(configPath)) {
+      return {
+        success: false,
+        message: 'OpenCode 配置文件不存在',
+        configPath
+      };
+    }
+
+    // 读取现有配置
+    const content = fs.readFileSync(configPath, 'utf8');
+    let config;
+    try {
+      config = JSON.parse(content);
+    } catch {
+      return {
+        success: false,
+        message: 'OpenCode 配置文件 JSON 格式无效',
+        configPath
+      };
+    }
+
+    // 检查当前 baseURL
+    const currentBaseURL = config?.provider?.anthropic?.options?.baseURL;
+    if (currentBaseURL === newBaseURL) {
+      return {
+        success: true,
+        message: `OpenCode 配置已是最新 (baseURL: ${newBaseURL})`,
+        configPath
+      };
+    }
+
+    // 创建备份
+    let backupPath = null;
+    if (createBackupFirst) {
+      const backupResult = createBackup(configPath);
+      if (!backupResult.success) {
+        return {
+          success: false,
+          message: `备份失败: ${backupResult.error}`,
+          configPath
+        };
+      }
+      backupPath = backupResult.backupPath;
+    }
+
+    // 确保嵌套结构存在
+    if (!config.provider) config.provider = {};
+    if (!config.provider.anthropic) config.provider.anthropic = {};
+    if (!config.provider.anthropic.options) config.provider.anthropic.options = {};
+
+    // 更新 baseURL
+    config.provider.anthropic.options.baseURL = newBaseURL;
+
+    // 写回配置文件
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+    return {
+      success: true,
+      message: `OpenCode 配置已更新 (baseURL: ${newBaseURL})`,
+      backupPath,
+      configPath
+    };
+  } catch (error) {
+    if (error.code === 'EACCES') {
+      return {
+        success: false,
+        message: '权限不足，无法写入 OpenCode 配置文件',
+        configPath
+      };
+    }
+    return {
+      success: false,
+      message: `更新失败: ${error.message}`,
+      configPath
+    };
+  }
+}
+
+/**
+ * 获取手动配置指南
+ * @param {number} port 端口号
+ * @returns {string} 配置指南文本
+ */
+function getManualConfigGuide(port) {
+  const configPath = getOpenCodeConfigPath();
+  return `
+手动配置 OpenCode:
+1. 编辑配置文件: ${configPath}
+2. 添加或修改以下配置:
+
+{
+  "provider": {
+    "anthropic": {
+      "options": {
+        "baseURL": "http://localhost:${port}"
+      }
+    }
+  }
+}
+
+3. 重启 OpenCode 使配置生效
+`;
+}
+
+module.exports = {
+  getOpenCodeConfigPath,
+  detectOpenCodeConfig,
+  readOpenCodeConfig,
+  createBackup,
+  updateOpenCodeBaseURL,
+  getManualConfigGuide
+};

package/lib/port-utils.js

@@ -0,0 +1,67 @@
+/**
+ * 端口检测工具模块
+ * 负责检测端口可用性
+ */
+
+const net = require('net');
+
+/**
+ * 检测端口是否可用
+ * @param {number} port 端口号
+ * @returns {Promise<boolean>} 端口是否可用
+ */
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+
+    // 不指定地址，检测所有接口
+    server.listen(port);
+  });
+}
+
+/**
+ * 查找可用端口（从指定端口开始递增查找）
+ * @param {number} startPort 起始端口
+ * @param {number} maxAttempts 最大尝试次数
+ * @returns {Promise<number|null>} 可用端口或 null
+ */
+async function findAvailablePort(startPort, maxAttempts = 10) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (port > 65535) break;
+
+    const available = await isPortAvailable(port);
+    if (available) {
+      return port;
+    }
+  }
+  return null;
+}
+
+/**
+ * 获取占用指定端口的进程信息（仅用于提示）
+ * @param {number} port 端口号
+ * @returns {string} 提示信息
+ */
+function getPortOccupiedMessage(port) {
+  return `端口 ${port} 已被占用。请使用 \`lsof -i :${port}\` 或 \`netstat -an | grep ${port}\` 查看占用进程。`;
+}
+
+module.exports = {
+  isPortAvailable,
+  findAvailablePort,
+  getPortOccupiedMessage
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "open-claude-code-proxy",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Local proxy that forwards API requests through the official Claude Code CLI",
   "main": "server.js",
   "bin": {
-    "open-claude-code-proxy": "server.js",
-    "claude-local-proxy": "claude-proxy"
+    "open-claude-code-proxy": "cli.js",
+    "claude-local-proxy": "cli.js",
+    "claude-proxy": "claude-proxy"
   },
   "scripts": {
     "start": "node server.js",