clash-kit 1.0.4 → 1.0.6

package/README.md

@@ -44,10 +44,13 @@ ck init
 
 ```bash
 # 启动 Clash 代理服务
-ck start
+ck start # 或者 ck on
 
 # 启动并自动开启系统代理
 ck start -s
+
+# 关闭服务并关闭系统代理
+ck stop # 或者 ck off
 ```
 
 ### 4. 添加订阅
@@ -56,18 +59,24 @@ ck start -s
 # 交互式管理订阅（添加、切换、删除等）【推荐使用这种方式来管理订阅】
 ck sub
 
+# 列出所有订阅
+ck sub -l
+
 # 手动添加订阅
 ck sub -a "https://example.com/subscribe?token=xxx" -n "abcName"
 ```
 
-### 4. 节点测速与切换
+### 4. 节点切换（自动测速）
 
-```bash
-# 测速
-ck test
+进入交互式界面，自动对当前节点组进行并发测速，并展示带有即时延迟数据的节点列表供选择。
 
-# 切换节点
-ck proxy
+```bash
+# 切换节点 (支持别名: node, proxy, switch)
+ck use
+# 或者
+ck switch
+# 或者
+ck node
 ```
 
 ### 5. 更多功能
@@ -76,27 +85,34 @@ ck proxy
 # 查看状态
 ck status
 
+# 节点并发测速 (仅测速不切换，支持别名: test, ls, t)
+ck list
+
+# 设置系统代理
+ck sys on
+ck sys off
+
 # 开启 TUN 模式 (需要 sudo 权限)
-sudo ck tun on
+ck tun on # 开启
+ck tun off # 关闭
 ```
 
 ## 命令详解
 
-| 命令 (别名)           | 说明                       | 示例                            |
-| --------------------- | -------------------------- | ------------------------------- |
-| `ck init` (`i`)       | 初始化内核及权限           | `ck i`                          |
-| `ck start` (`on`)     | 启动 Clash 服务            | `ck on -s` (启动并设置系统代理) |
-| `ck stop` (`off`)     | 停止服务并关闭代理         | `ck off`                        |
-| `ck status` (`st`)    | 查看运行状态及当前节点延迟 | `ck st`                         |
-| `ck sub` (`s`)        | 管理订阅（交互式）         | `ck s`                          |
-| `ck sub -a <url>`     | 添加订阅                   | `ck s -a "http..." -n "pro"`    |
-| `ck sub -u <name>`    | 切换订阅                   | `ck s -u "pro"`                 |
-| `ck sub -l`           | 列出所有订阅               | `ck s -l`                       |
-| `ck proxy` (`p`)      | 切换节点（交互式）         | `ck p`                          |
-| `ck test` (`t`)       | 节点并发测速               | `ck t`                          |
-| `ck sysproxy` (`sys`) | 设置系统代理 (on/off)      | `ck sys on`                     |
-| `ck tun`              | 设置 TUN 模式 (on/off)     | `sudo ck tun on`                |
-
+| 命令 (别名)                   | 说明                       | 示例                                    |
+| ----------------------------- | -------------------------- | --------------------------------------- |
+| `ck init`                     | 初始化内核及权限           | `ck init`                               |
+| `ck start` (`on`)             | 启动 Clash 服务            | `ck on` `ck on -s` (启动并设置系统代理) |
+| `ck stop` (`off`)             | 停止服务并关闭代理         | `ck off`                                |
+| `ck status` (`info`, `view`)  | 查看运行状态及当前节点延迟 | `ck status`                             |
+| `ck sysproxy` (`sys`)         | 设置系统代理               | `ck sys on` / `ck sys off`              |
+| `ck tun`                      | 设置 TUN 模式 (需要 sudo)  | `ck tun on`                             |
+| `ck sub`                      | 管理订阅（交互式）【推荐】 | `ck sub`                                |
+| `ck sub -l`                   | 列出所有订阅               | `ck sub -l`                             |
+| `ck sub -a <url>`             | 添加订阅                   | `ck sub -a "http..." -n "pro"`          |
+| `ck sub -u <name>`            | 切换订阅                   | `ck sub -u "pro"`                       |
+| `ck use` (`node`, `switch`)   | 切换节点 (自动测速)        | `ck use` / `ck node`                    |
+| `ck list` (`ls`, `test`, `t`) | 节点测速列表 (不切换)      | `ck list` / `ck test`                   |
 
 ## License
 

package/bin/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander'
+import { createRequire } from 'module'
 import { init } from '../lib/commands/init.js'
 import { start } from '../lib/commands/start.js'
 import { stop } from '../lib/commands/stop.js'
@@ -11,9 +12,12 @@ import { manageSub } from '../lib/commands/sub.js'
 import { proxy } from '../lib/commands/proxy.js'
 import { test } from '../lib/commands/test.js'
 
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json')
+
 const program = new Command()
 
-program.name('clash').alias('ck').description('Clash CLI 管理工具 (Alias: ck)').version('1.0.0')
+program.name('clash').alias('ck').description('Clash CLI 管理工具 (Alias: ck)').version(pkg.version, '-v, --version')
 
 // 初始化 clash 内核
 program
@@ -23,10 +27,15 @@ program
   .action(init)
 
 // 启动 clash 服务
-program.command('start').description('启动 Clash 服务').option('-s, --sysproxy', '启动后自动开启系统代理').action(start)
+program
+  .command('start')
+  .alias('on')
+  .description('启动 Clash 服务')
+  .option('-s, --sysproxy', '启动后自动开启系统代理')
+  .action(start)
 
 // 停止 clash 服务
-program.command('stop').description('停止 Clash 服务').action(stop)
+program.command('stop').alias('off').description('停止 Clash 服务').action(stop)
 
 // 设置系统代理
 program
@@ -40,7 +49,7 @@ program
 program.command('tun').description('设置 TUN 模式 (可能需要提权)').argument('[action]', 'on 或 off').action(setTun)
 
 // 查看 clash 状态
-program.command('status').alias('st').description('查看 Clash 运行状态').action(status)
+program.command('status').alias('st').alias('view').alias('info').description('查看 Clash 运行状态').action(status)
 
 // 管理订阅
 program
@@ -53,9 +62,24 @@ program
   .action(manageSub)
 
 // 切换节点
-program.command('proxy').alias('p').description('切换节点').action(proxy)
+program
+  .command('use')
+  .aliases(['node', 'proxy', 'switch'])
+  .description('切换节点 (别名: node, proxy, switch)')
+  .action(proxy)
+
+// 列出所有节点，并测速
+program
+  .command('list')
+  .alias('ls')
+  .alias('test')
+  .alias('t')
+  .description('节点测速 (别名: list, ls, test, t) ')
+  .action(test)
 
-// 节点测速
-program.command('test').alias('t').description('节点测速').action(test)
+// Support -V for version
+if (process.argv.includes('-V')) {
+  process.argv[process.argv.indexOf('-V')] = '-v'
+}
 
 program.parse(process.argv)

package/index.js

@@ -2,27 +2,75 @@ import { spawn, execSync } from 'child_process'
 import path from 'path'
 import fs from 'fs'
 import chalk from 'chalk'
+import axios from 'axios'
+import ora from 'ora'
+import YAML from 'yaml'
 import { fileURLToPath } from 'url'
 import { getApiBase, getProxyPort } from './lib/api.js'
 import * as sysproxy from './lib/sysproxy.js'
 import * as tun from './lib/tun.js'
+import { isPortOpen, extractPort, getPortOccupier } from './lib/port.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-// ---------------- 1. 配置项 ----------------
+// ----------------  配置项 ----------------
 const CLASH_BIN_PATH = path.join(__dirname, 'clash-kit') // 解压后的二进制文件路径
 const CLASH_CONFIG_PATH = path.join(__dirname, 'config.yaml') // 配置文件路径
 
-// ---------------- 2. 启动 Clash.Meta 进程 ----------------
-function startClash() {
+async function checkPorts() {
+  try {
+    if (fs.existsSync(CLASH_CONFIG_PATH)) {
+      const configContent = fs.readFileSync(CLASH_CONFIG_PATH, 'utf8')
+      const config = YAML.parse(configContent)
+
+      const checks = [
+        { key: 'mixed-port', name: 'Mixed Port' },
+        { key: 'port', name: 'HTTP Port' },
+        { key: 'socks-port', name: 'SOCKS Port' },
+        { key: 'external-controller', name: 'External Controller' },
+      ]
+
+      for (const check of checks) {
+        const val = config[check.key]
+        const port = extractPort(val)
+        if (port) {
+          const isOpen = await isPortOpen(port)
+          if (!isOpen) {
+            const occupier = getPortOccupier(port)
+            const occupierInfo = occupier ? ` (被 ${occupier} 占用)` : ''
+
+            console.error(chalk.red(`\n启动失败: 端口 ${port} (${check.name}) 已被占用${occupierInfo}`))
+            console.error(chalk.yellow(`请检查是否有其他代理软件正在运行，或修改 config.yaml 中的 ${check.key} \n`))
+
+            if (!occupierInfo) {
+              console.error(`占用进程未知，可能是权限不足或系统进程`)
+              console.error(chalk.yellow(`提示: 可尝试使用 'sudo lsof -i :${port}' 手动查看端口占用情况`))
+            }
+            process.exit(1)
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.error(chalk.yellow('警告: 端口检查预检失败，将尝试直接启动内核:', e.message))
+  }
+}
+
+// ---------------- 启动 Clash.Meta 进程 ----------------
+async function startClash() {
   // 尝试停止已存在的进程
   try {
     execSync('pkill -f clash-kit')
+    // 稍微等待端口释放，避免 restart 时偶发端口占用报错
+    await new Promise(resolve => setTimeout(resolve, 500))
   } catch (e) {
     // 忽略错误，说明没有运行中的进程
   }
 
+  // 检查端口占用 (核心策略：报错/启动失败)
+  await checkPorts()
+
   const logPath = path.join(__dirname, 'clash.log')
   const logFd = fs.openSync(logPath, 'a')
 
@@ -50,7 +98,7 @@ function startClash() {
   return clashProcess
 }
 
-// ---------------- 3. 清理函数 ----------------
+// 清理函数
 async function cleanup() {
   try {
     // 关闭系统代理
@@ -75,7 +123,7 @@ async function cleanup() {
   }
 }
 
-// ---------------- 4. 注册进程退出处理 ----------------
+// 注册进程退出处理
 function setupExitHandlers() {
   // 处理正常退出 (Ctrl+C)
   process.on('SIGINT', async () => {
@@ -99,8 +147,21 @@ function setupExitHandlers() {
   })
 }
 
-// ---------------- 5. 执行流程 ----------------
-export function main() {
+// 检查服务健康状态
+async function checkServiceHealth(apiBase, maxRetries = 20) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      await axios.get(apiBase, { timeout: 1000 })
+      return true
+    } catch (e) {
+      if (e.response) return true // 端口已通 (即使是 401 也可以)
+      await new Promise(r => setTimeout(r, 200)) // 200ms * 20 = 4s
+    }
+  }
+  return false
+}
+
+export async function main() {
   // 检查 clash-kit 二进制文件是否存在
   if (!fs.existsSync(CLASH_BIN_PATH)) {
     return console.error(chalk.red('\n找不到 Clash.Meta 内核文件,请先运行 clash init 命令初始化内核！\n'))
@@ -113,10 +174,30 @@ export function main() {
   // 设置退出处理
   setupExitHandlers()
 
-  const clashProcess = startClash()
+  const clashProcess = await startClash()
+
+  const spinner = ora('正在等待服务启动...').start()
+  const started = await checkServiceHealth(getApiBase())
+
+  if (!started) {
+    spinner.fail(chalk.red('启动失败'))
+    const logPath = path.join(__dirname, 'clash.log')
+    if (fs.existsSync(logPath)) {
+      console.log(chalk.yellow('\n------- clash.log (Last 20 lines) -------'))
+      const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n')
+      console.log(lines.slice(-20).join('\n'))
+      console.log(chalk.yellow('-----------------------------------------\n'))
+    }
+    try {
+      process.kill(clashProcess.pid)
+    } catch (e) {}
+    process.exit(1)
+  }
+
+  spinner.succeed(chalk.green('启动成功'))
+
   const { http, socks } = getProxyPort()
 
-  console.log(chalk.green('\n代理服务已在后台启动✅'))
   if (clashProcess.pid) {
     console.log(`进程名称：${chalk.yellow('clash-kit')} PID: ${chalk.yellow(clashProcess.pid)}`)
   }

package/lib/commands/proxy.js

@@ -1,11 +1,12 @@
 import { select } from '@inquirer/prompts'
 import ora from 'ora'
+import chalk from 'chalk'
 import * as api from '../api.js'
 
 export async function proxy() {
   let spinner = ora('正在获取最新代理列表...').start()
   try {
-    const proxies = await api.getProxies()
+    let proxies = await api.getProxies()
     spinner.stop()
 
     // 通常我们只关心 Proxy 组或者 Selector 类型的组
@@ -24,10 +25,42 @@ export async function proxy() {
 
     const group = proxies[groupName]
 
+    // 自动对组内所有节点进行测速
+    spinner = ora(`测速后选择合适的节点，正在对 [${groupName}] 进行测速...`).start()
+    await Promise.all(group.all.map(n => api.getProxyDelay(n).catch(() => {})))
+
+    // 测速完成后，刷新数据以获取最新状态
+    proxies = await api.getProxies()
+    spinner.stop()
+
+    const updatedGroup = proxies[groupName]
+
     // 选择节点
     const proxyName = await select({
-      message: `[${groupName}] 当前: ${group.now}, 请选择节点:`,
-      choices: group.all.map(n => ({ name: n, value: n })),
+      message: `[${groupName}] 当前: ${updatedGroup.now}, 请选择节点:`,
+      pageSize: 15,
+      choices: updatedGroup.all.map(n => {
+        const node = proxies[n]
+        const lastHistory = node?.history && node.history.length ? node.history[node.history.length - 1] : null
+        let delayInfo = ''
+
+        if (lastHistory && lastHistory.delay > 0) {
+          const delay = lastHistory.delay
+          if (delay < 800) {
+            delayInfo = chalk.green(` ${delay}ms`)
+          } else if (delay < 1500) {
+            delayInfo = chalk.yellow(` ${delay}ms`)
+          } else {
+            delayInfo = chalk.red(` ${delay}ms`)
+          }
+        } else if (lastHistory && lastHistory.delay === 0) {
+          delayInfo = chalk.red(' [超时]')
+        } else {
+          delayInfo = chalk.gray(' [未测速]')
+        }
+
+        return { name: `${n}${delayInfo}`, value: n }
+      }),
     })
 
     spinner = ora(`正在切换到 ${proxyName}...`).start()

package/lib/commands/start.js

@@ -2,7 +2,7 @@ import * as sysproxy from '../sysproxy.js'
 import { main as startClashService } from '../../index.js'
 
 export async function start(options) {
-  startClashService()
+  await startClashService()
 
   if (options.sysproxy) {
     console.log('正在等待 Clash API 就绪以设置系统代理...')

package/lib/port.js

@@ -0,0 +1,108 @@
+import net from 'net'
+import { execSync } from 'child_process'
+import os from 'os'
+
+/**
+ * 检查端口是否被占用 (true = 空闲, false = 被占用)
+ * @param {number} port 
+ * @returns {Promise<boolean>}
+ */
+export function isPortOpen(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer()
+    server.once('error', (err) => {
+      resolve(false) // 端口被占用
+    })
+    server.once('listening', () => {
+      server.close()
+      resolve(true) // 端口可用
+    })
+    server.listen(port, '127.0.0.1')
+  })
+}
+
+/**
+ * 获取占用端口的进程信息
+ * @param {number} port 
+ * @returns {string|null} 进程名称(PID)，例如 "mihomo (PID: 1234)"
+ */
+export function getPortOccupier(port) {
+  try {
+    const platform = os.platform()
+    if (platform === 'win32') {
+      // Windows 实现
+      try {
+        const output = execSync(`netstat -ano | findstr :${port}`).toString()
+        const lines = output.trim().split('\n')
+        if(lines.length > 0) {
+            const parts = lines[0].trim().split(/\s+/)
+            const pid = parts[parts.length - 1]
+            return `PID: ${pid}`
+        }
+      } catch (e) { return null }
+    } else {
+        // macOS / Linux
+        // lsof output format: COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
+        const output = execSync(`lsof -i :${port} -sTCP:LISTEN -P -n`).toString().trim()
+        const lines = output.split('\n')
+        if (lines.length > 1) {
+            const parts = lines[1].trim().split(/\s+/)
+            return `${parts[0]} (PID: ${parts[1]})`
+        }
+    }
+  } catch (e) {
+    // lsof 找不到时会返回非 0 退出码，抛出错误
+    return null
+  }
+  return null
+}
+
+/**
+ * 寻找可用端口
+ * @param {number} startPort 
+ * @returns {Promise<number>}
+ */
+export function findAvailablePort(startPort) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.on('error', (err) => {
+      if (startPort <= 65535) {
+        // 核心逻辑：如果报错，递归尝试 +1 的端口
+        resolve(findAvailablePort(startPort + 1))
+      } else {
+        reject(err)
+      }
+    })
+    server.on('listening', () => {
+      server.close(() => {
+        resolve(startPort)
+      })
+    })
+    server.listen(startPort, '127.0.0.1')
+  })
+}
+
+/**
+ * 从配置值中提取端口号
+ * @param {string|number} val - 例如 9090, ":9090", "127.0.0.1:9090"
+ * @returns {number|null}
+ */
+export function extractPort(val) {
+  if (!val) return null
+  if (typeof val === 'number') return val
+  if (typeof val === 'string') {
+    // 移除空白
+    val = val.trim()
+    // 如果是纯数字字符串
+    if (/^\d+$/.test(val)) return parseInt(val, 10)
+    
+    // 如果包含冒号，取最后一部分
+    if (val.includes(':')) {
+      const parts = val.split(':')
+      const lastPart = parts[parts.length - 1]
+      const port = parseInt(lastPart, 10)
+      return isNaN(port) ? null : port
+    }
+  }
+  return null
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clash-kit",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "type": "module",
   "description": "A command-line interface for managing Clash configurations, subscriptions, and proxies.",
   "bin": {