clash-kit 1.0.0

package/README.md

@@ -0,0 +1,110 @@
+# Clash CLI
+
+一个基于 Node.js 的 Clash 命令行管理工具，旨在简化 Clash 的配置管理、订阅切换和节点测速等操作。
+
+## 特性
+
+- 🔄 **订阅管理**：支持添加、切换多个订阅源。
+- 🌐 **节点切换**：交互式选择并切换当前使用的代理节点。
+- 🔥 **热重载**：切换订阅后立即生效，无需重启服务。
+- ⚡ **节点测速**：支持多线程并发测速，彩色高亮显示延迟结果。
+- 📊 **状态监控**：实时查看服务运行状态、当前节点及延迟。
+- 🛠 **自动初始化**：自动处理二进制文件权限问题。
+
+- 💻 **系统代理**：一键开启/关闭 macOS 系统 HTTP 代理。
+- 🛡 **TUN 模式**：高级网络模式，接管系统所有流量（类 VPN 体验）。
+
+## 使用
+
+### 1. 安装
+
+```bash
+npm install -g clash-kit
+# 或者
+pnpm add -g clash-kit
+```
+
+### 2. 初始化
+
+首次安装后，需要先初始化 Clash 内核与权限：
+
+```bash
+clash init
+```
+
+### 3. 启动服务
+
+启动 Clash 核心服务（建议在一个单独的终端窗口运行）：
+
+```bash
+# 启动 Clash 代理服务
+clash start
+
+# 启动并自动开启系统代理
+clash start -s
+```
+
+### 4. 添加订阅
+
+```bash
+# 交互式管理订阅（添加、切换、删除等）
+clash sub
+
+# 手动添加订阅
+clash sub -a "https://example.com/subscribe?token=xxx" -n "abcName"
+```
+
+### 4. 节点测速与切换
+
+```bash
+# 测速
+clash test
+
+# 切换节点
+clash proxy
+```
+
+### 5. 更多功能
+
+```bash
+# 查看状态
+clash status
+
+# 开启 TUN 模式 (需要 sudo 权限)
+sudo clash tun on
+```
+
+## 命令详解
+
+| 命令                  | 说明                       | 示例                                  |
+| --------------------- | -------------------------- | ------------------------------------- |
+| `clash init`          | 初始化内核及权限           | `clash init`                          |
+| `clash start`         | 启动 Clash 服务            | `clash start -s` (启动并设置系统代理) |
+| `clash stop`          | 停止服务并关闭代理         | `clash stop`                          |
+| `clash status`        | 查看运行状态及当前节点延迟 | `clash status`                        |
+| `clash sub`(推荐)     | 管理订阅（交互式）         | `clash sub`                           |
+| `clash sub -a <url>`  | 添加订阅                   | `clash sub -a "http..." -n "pro"`     |
+| `clash sub -u <name>` | 切换订阅                   | `clash sub -u "pro"`                  |
+| `clash sub -l`        | 列出所有订阅               | `clash sub -l`                        |
+| `clash proxy`         | 切换节点（交互式）         | `clash proxy`                         |
+| `clash test`          | 节点并发测速               | `clash test`                          |
+| `clash sysproxy`      | 设置系统代理 (on/off)      | `clash sysproxy on`                   |
+| `clash tun`           | 设置 TUN 模式 (on/off)     | `sudo clash tun on`                   |
+
+## 目录结构
+
+- `bin/`: CLI 入口文件
+- `lib/`: 核心逻辑库
+- `profiles/`: 存放下载的订阅配置文件
+- `clash-meta`: Clash 核心二进制文件
+- `config.yaml`: 当前生效的配置文件
+
+## 注意事项
+
+- 本工具依赖 `clash-meta` 二进制文件，请确保其与本工具在同一目录下（安装包已包含）。
+- 测速功能依赖 Clash API，请确保 `clash start` 正在运行。
+- 默认 API 地址为 `http://127.0.0.1:9090`。
+
+## License
+
+ISC

package/bin/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander'
+import { init } from '../lib/commands/init.js'
+import { start } from '../lib/commands/start.js'
+import { stop } from '../lib/commands/stop.js'
+import { setSysProxy } from '../lib/commands/sysproxy.js'
+import { setTun } from '../lib/commands/tun.js'
+import { status } from '../lib/commands/status.js'
+import { manageSub } from '../lib/commands/sub.js'
+import { proxy } from '../lib/commands/proxy.js'
+import { test } from '../lib/commands/test.js'
+
+const program = new Command()
+
+program.name('clash').description('Clash CLI 管理工具').version('1.0.0')
+
+// 初始化 clash 内核
+program
+  .command('init')
+  .description('初始化 Clash 内核 (下载、解压并设置权限)')
+  .option('-f, --force', '强制重新下载内核')
+  .action(init)
+
+// 启动 clash 服务
+program.command('start').description('启动 Clash 服务').option('-s, --sysproxy', '启动后自动开启系统代理').action(start)
+
+// 停止 clash 服务
+program.command('stop').description('停止 Clash 服务').action(stop)
+
+// 设置系统代理
+program.command('sysproxy').description('设置系统代理').argument('[action]', 'on 或 off').action(setSysProxy)
+
+// 设置 TUN 模式（真正的全局代理，所有流量都会被代理）
+program.command('tun').description('设置 TUN 模式 (可能需要提权)').argument('[action]', 'on 或 off').action(setTun)
+
+// 查看 clash 状态
+program.command('status').description('查看 Clash 运行状态').action(status)
+
+// 管理订阅
+program
+  .command('sub')
+  .description('管理订阅')
+  .option('-a, --add <url>', '添加订阅链接')
+  .option('-n, --name <name>', '订阅名称')
+  .option('-l, --list', '列出所有订阅')
+  .option('-u, --use <name>', '切换使用的订阅')
+  .action(manageSub)
+
+// 切换节点
+program.command('proxy').description('切换节点').action(proxy)
+
+// 节点测速
+program.command('test').description('节点测速').action(test)
+
+program.parse(process.argv)

package/index.js

@@ -0,0 +1,135 @@
+import { spawn, execSync } from 'child_process'
+import path from 'path'
+import fs from 'fs'
+import chalk from 'chalk'
+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'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+// ---------------- 1. 配置项 ----------------
+const CLASH_BIN_PATH = path.join(__dirname, 'clash-meta') // 解压后的二进制文件路径
+const CLASH_CONFIG_PATH = path.join(__dirname, 'config.yaml') // 配置文件路径
+
+// ---------------- 2. 启动 Clash.Meta 进程 ----------------
+function startClash() {
+  // 尝试停止已存在的进程
+  try {
+    execSync('pkill -f clash-meta')
+  } catch (e) {
+    // 忽略错误，说明没有运行中的进程
+  }
+
+  const logPath = path.join(__dirname, 'clash.log')
+  const logFd = fs.openSync(logPath, 'a')
+
+  const clashProcess = spawn(CLASH_BIN_PATH, ['-f', CLASH_CONFIG_PATH, '-d', __dirname], {
+    cwd: __dirname,
+    detached: true,
+    stdio: ['ignore', logFd, logFd], // 重定向 stdout 和 stderr 到日志文件
+  })
+
+  clashProcess.on('error', err => {
+    console.error(`启动 Clash.Meta 失败: ${err.message}`)
+    process.exit(1)
+  })
+
+  // 监听子进程退出，方便调试
+  clashProcess.on('exit', (code, signal) => {
+    if (code !== 0) {
+      console.log(`Clash 进程异常退出，代码: ${code}, 信号: ${signal}。请查看 clash.log 获取详情。`)
+    }
+  })
+
+  // 解除与父进程的引用，让子进程在后台独立运行
+  clashProcess.unref()
+
+  return clashProcess
+}
+
+// ---------------- 3. 清理函数 ----------------
+async function cleanup() {
+  try {
+    // 关闭系统代理
+    await sysproxy.disableSystemProxy()
+
+    // 检查并关闭 TUN 模式
+    const tunEnabled = await tun.isTunEnabled()
+    if (tunEnabled) {
+      await tun.disableTun()
+      console.log('TUN 模式已关闭')
+    }
+
+    // 停止 Clash 进程
+    try {
+      execSync('pkill -f clash-meta')
+      console.log('Clash 服务已停止')
+    } catch (e) {
+      // 进程可能已经停止
+    }
+  } catch (error) {
+    console.error('清理过程出错:', error.message)
+  }
+}
+
+// ---------------- 4. 注册进程退出处理 ----------------
+function setupExitHandlers() {
+  // 处理正常退出 (Ctrl+C)
+  process.on('SIGINT', async () => {
+    console.log('\n\n正在清理配置并退出...')
+    await cleanup()
+    process.exit(0)
+  })
+
+  // 处理终止信号
+  process.on('SIGTERM', async () => {
+    console.log('\n正在清理配置并退出...')
+    await cleanup()
+    process.exit(0)
+  })
+
+  // 处理未捕获的异常
+  process.on('uncaughtException', async err => {
+    console.error('未捕获的异常:', err)
+    await cleanup()
+    process.exit(1)
+  })
+}
+
+// ---------------- 5. 执行流程 ----------------
+export function main() {
+  // 检查 clash-meta 二进制文件是否存在
+  if (!fs.existsSync(CLASH_BIN_PATH)) {
+    return console.error(chalk.red('\n找不到 Clash.Meta 内核文件,请先运行 clash init 命令初始化内核！\n'))
+  }
+  // 检查配置文件是否存在
+  if (!fs.existsSync(CLASH_CONFIG_PATH)) {
+    return console.error(chalk.red('\n找不到配置文件 config.yaml,请先通过 clash sub 命令添加或选择订阅配置！\n'))
+  }
+
+  // 设置退出处理
+  setupExitHandlers()
+
+  const clashProcess = startClash()
+  const { http, socks } = getProxyPort()
+
+  console.log(chalk.green('\n代理服务已在后台启动✅'))
+  if (clashProcess.pid) {
+    console.log(`PID: ${chalk.yellow(clashProcess.pid)}`)
+  }
+
+  console.log(``)
+  console.log(`HTTP Proxy:   ${chalk.cyan(`127.0.0.1:${http}`)}`)
+  console.log(`SOCKS5 Proxy: ${chalk.cyan(`127.0.0.1:${socks}`)}`)
+  console.log(`API:          ${chalk.cyan.underline(getApiBase())}`)
+  console.log(``)
+  console.log(chalk.gray('提示: 如需停止代理可使用 clash stop 命令'))
+}
+
+// 运行脚本
+if (process.argv[1] === __filename) {
+  main()
+}

package/lib/api.js

@@ -0,0 +1,106 @@
+import axios from 'axios'
+import fs from 'fs'
+import path from 'path'
+import YAML from 'yaml'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const CONFIG_PATH = path.join(__dirname, '../config.yaml')
+
+export function getProxyPort() {
+  try {
+    const configContent = fs.readFileSync(CONFIG_PATH, 'utf8')
+    const config = YAML.parse(configContent)
+    const httpPort = config['port'] || config['mixed-port']
+    const socksPort = config['socks-port']
+    return { http: httpPort, socks: socksPort }
+  } catch (error) {
+    throw new Error(`读取配置文件失败: ${error.message}`)
+  }
+}
+
+export function getApiBase() {
+  let apiBase = 'http://127.0.0.1:9090'
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const configContent = fs.readFileSync(CONFIG_PATH, 'utf8')
+      const config = YAML.parse(configContent)
+      if (config['external-controller']) {
+        let host = config['external-controller']
+        // 处理 :9090 这种情况
+        if (host.startsWith(':')) {
+          host = '127.0.0.1' + host
+        }
+        // 处理 0.0.0.0
+        host = host.replace('0.0.0.0', '127.0.0.1')
+        apiBase = `http://${host}`
+      }
+    }
+  } catch (e) {
+    console.error('读取配置文件失败，使用默认 API 地址', e)
+  }
+  return apiBase
+}
+
+const API_SECRET = 'your-strong-secret-key' // 实际项目中应该从 config 读取
+
+const headers = {
+  Authorization: `Bearer ${API_SECRET}`,
+}
+
+export async function getProxies() {
+  try {
+    const res = await axios.get(`${getApiBase()}/proxies`, { headers })
+    return res.data.proxies
+  } catch (err) {
+    throw new Error(`
+      无法连接到 Clash API: ${err.message}
+      
+      请确保 Clash 正在运行并且 API 密钥正确设置。
+      你可以通过 clash status 命令检查状态。
+    `)
+  }
+}
+
+export async function switchProxy(groupName, proxyName) {
+  try {
+    await axios.put(`${getApiBase()}/proxies/${encodeURIComponent(groupName)}`, { name: proxyName }, { headers })
+  } catch (err) {
+    throw new Error(`切换节点失败: ${err.message}`)
+  }
+}
+
+export async function getProxyDelay(proxyName, testUrl = 'http://www.gstatic.com/generate_204') {
+  try {
+    const res = await axios.get(`${getApiBase()}/proxies/${encodeURIComponent(proxyName)}/delay`, {
+      params: {
+        timeout: 5000,
+        url: testUrl,
+      },
+      headers,
+    })
+    return res.data.delay
+  } catch (err) {
+    return -1 // 超时或失败
+  }
+}
+
+export async function getConfig() {
+  try {
+    const res = await axios.get(`${getApiBase()}/configs`, { headers })
+    return res.data
+  } catch (err) {
+    throw new Error(`获取配置失败: ${err.message}`)
+  }
+}
+
+export async function reloadConfig(configPath) {
+  try {
+    // Clash API: PUT /configs
+    // payload: { path: '/absolute/path/to/config.yaml' }
+    await axios.put(`${getApiBase()}/configs?force=true`, { path: configPath }, { headers })
+  } catch (err) {
+    throw new Error(`重载配置失败: ${err.message}`)
+  }
+}

package/lib/commands/init.js

@@ -0,0 +1,58 @@
+import path from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+import { downloadClash } from '../kernel.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const DEFAULT_CONFIG = `mixed-port: 7890
+`
+
+export async function init(options) {
+  const rootDir = path.join(__dirname, '../..')
+  const binName = process.platform === 'win32' ? 'clash-meta.exe' : 'clash-meta'
+  const binPath = path.join(rootDir, binName)
+  const configPath = path.join(rootDir, 'config.yaml')
+
+  try {
+    // 创建默认配置文件（如果不存在）
+    if (!fs.existsSync(configPath)) {
+      fs.writeFileSync(configPath, DEFAULT_CONFIG, 'utf8')
+      console.log(`已创建默认配置文件: ${configPath}`)
+    }
+
+    if (fs.existsSync(binPath) && !options.force) {
+      console.log(`Clash 内核已存在: ${binPath}`)
+      console.log('正在检查权限...')
+      if (process.platform !== 'win32') {
+        // 检查是否已有 SUID 权限，如果有则不再重置为 755
+        const stats = fs.statSync(binPath)
+        const hasSuid = (stats.mode & 0o4000) === 0o4000
+
+        if (!hasSuid) {
+          fs.chmodSync(binPath, 0o755)
+          console.log('权限已设置为 755 (普通执行权限)。')
+        } else {
+          console.log('检测到 SUID 权限，保持不变。')
+        }
+      }
+      console.log('权限检查通过！')
+      return
+    }
+
+    if (options.force && fs.existsSync(binPath)) {
+      console.log('强制更新模式，正在移除旧内核...')
+      try {
+        fs.unlinkSync(binPath)
+      } catch (e) {}
+    }
+
+    console.log('正在初始化 Clash 内核...')
+    await downloadClash(rootDir)
+    console.log('Clash 内核初始化成功！')
+  } catch (err) {
+    console.error(`初始化失败: ${err.message}`)
+    process.exit(1)
+  }
+}

package/lib/commands/proxy.js

@@ -0,0 +1,40 @@
+import { select } from '@inquirer/prompts'
+import ora from 'ora'
+import * as api from '../api.js'
+
+export async function proxy() {
+  let spinner = ora('正在获取最新代理列表...').start()
+  try {
+    const proxies = await api.getProxies()
+    spinner.stop()
+
+    // 通常我们只关心 Proxy 组或者 Selector 类型的组
+    const groups = Object.values(proxies).filter(p => p.type === 'Selector')
+
+    if (groups.length === 0) {
+      console.log('没有找到可选的节点组')
+      return
+    }
+
+    // 选择组
+    const groupName = await select({
+      message: '请选择节点组:',
+      choices: groups.map(g => ({ name: g.name, value: g.name })),
+    })
+
+    const group = proxies[groupName]
+
+    // 选择节点
+    const proxyName = await select({
+      message: `[${groupName}] 当前: ${group.now}, 请选择节点:`,
+      choices: group.all.map(n => ({ name: n, value: n })),
+    })
+
+    spinner = ora(`正在切换到 ${proxyName}...`).start()
+    await api.switchProxy(groupName, proxyName)
+    spinner.succeed(`已切换 ${groupName} -> ${proxyName}`)
+  } catch (err) {
+    if (spinner && spinner.isSpinning) spinner.fail(err.message)
+    else console.error(err.message)
+  }
+}

package/lib/commands/start.js

@@ -0,0 +1,22 @@
+import * as sysproxy from '../sysproxy.js'
+import { main as startClashService } from '../../index.js'
+
+export async function start(options) {
+  startClashService()
+
+  if (options.sysproxy) {
+    console.log('正在等待 Clash API 就绪以设置系统代理...')
+    const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+    // 尝试 5 次，每次间隔 1 秒
+    for (let i = 0; i < 5; i++) {
+      await sleep(1000)
+      try {
+        const success = await sysproxy.enableSystemProxy()
+        if (success) break
+      } catch (e) {
+        if (i === 4) console.error('设置系统代理超时，请稍后手动设置: clash sysproxy on')
+      }
+    }
+  }
+}

package/lib/commands/status.js

@@ -0,0 +1,85 @@
+import ora from 'ora'
+import * as api from '../api.js'
+import * as sub from '../subscription.js'
+import * as tun from '../tun.js'
+import * as sysproxy from '../sysproxy.js'
+
+export async function status() {
+  const spinner = ora('正在获取 Clash 状态...').start()
+  try {
+    const config = await api.getConfig()
+    spinner.stop()
+    const apiBase = api.getApiBase()
+    const currentProfile = sub.getCurrentProfile()
+
+    // 获取 TUN 和系统代理状态
+    const tunEnabled = await tun.isTunEnabled()
+    const sysProxyStatus = await sysproxy.getSystemProxyStatus()
+
+    console.log('\n=== Clash 状态 ===')
+    console.log(`状态: \x1b[32m运行中\x1b[0m`)
+    console.log(`当前配置: ${currentProfile || '未知 (默认或手动修改)'}`)
+    console.log(`API 地址: ${apiBase}`)
+    console.log(`运行模式: ${config.mode}`)
+    console.log(`HTTP 端口: ${config['port'] || '未设置'}`)
+    console.log(`Socks5 端口: ${config['socks-port'] || '未设置'}`)
+    if (config['mixed-port']) {
+      console.log(`Mixed 端口: ${config['mixed-port']}`)
+    }
+
+    console.log('\n=== 代理模式 ===')
+    // TUN 状态
+    if (tunEnabled) {
+      console.log(`TUN 模式: \x1b[32m已开启\x1b[0m`)
+    } else {
+      console.log(`TUN 模式: \x1b[90m未开启\x1b[0m`)
+    }
+    // 系统代理状态
+    if (sysProxyStatus.enabled) {
+      console.log(`系统代理: \x1b[32m已开启\x1b[0m (${sysProxyStatus.server}:${sysProxyStatus.port})`)
+    } else {
+      console.log(`系统代理: \x1b[90m未开启\x1b[0m`)
+    }
+
+    const proxies = await api.getProxies()
+
+    // 过滤出 Selector 类型的代理组
+    const selectors = Object.entries(proxies)
+      .filter(([name, proxy]) => proxy.type === 'Selector')
+      .map(([name, proxy]) => ({ name, now: proxy.now }))
+
+    console.log('\n=== 节点信息 ===')
+
+    if (selectors.length === 0) {
+      console.log('未找到节点选择组。')
+    } else {
+      for (const { name, now } of selectors) {
+        process.stdout.write(`组 [${name}] 当前节点: ${now} ... 测速中`)
+        const testUrl = now === 'DIRECT' ? 'http://connect.rom.miui.com/generate_204' : undefined
+        const delay = await api.getProxyDelay(now, testUrl)
+
+        let delayStr = ''
+        if (delay > 0) {
+          if (delay < 200) delayStr = `\x1b[32m${delay}ms\x1b[0m`
+          else if (delay < 500) delayStr = `\x1b[33m${delay}ms\x1b[0m`
+          else delayStr = `\x1b[31m${delay}ms\x1b[0m`
+        } else {
+          delayStr = `\x1b[31m超时/失败\x1b[0m`
+        }
+
+        process.stdout.clearLine(0)
+        process.stdout.cursorTo(0)
+        console.log(`组 [${name}] 当前节点: ${now} - 延迟: ${delayStr}`)
+      }
+    }
+  } catch (err) {
+    if (spinner.isSpinning) spinner.stop()
+    if (err.message && (err.message.includes('ECONNREFUSED') || err.message.includes('无法连接'))) {
+      console.log('\n=== Clash 状态 ===')
+      console.log(`状态: \x1b[31m未运行\x1b[0m`)
+      console.log('提示: 请使用 `clash start` 启动服务')
+    } else {
+      console.error(`获取状态失败: ${err.message}`)
+    }
+  }
+}

package/lib/commands/stop.js

@@ -0,0 +1,28 @@
+import { execSync } from 'child_process'
+import ora from 'ora'
+import * as sysproxy from '../sysproxy.js'
+import * as tun from '../tun.js'
+
+export async function stop() {
+  const spinner = ora('正在停止 Clash 服务...').start()
+  try {
+    // 停止前先关闭系统代理
+    await sysproxy.disableSystemProxy()
+
+    // 检查并关闭 TUN 模式
+    const tunEnabled = await tun.isTunEnabled()
+    if (tunEnabled) {
+      spinner.text = '正在关闭 TUN 模式...'
+      await tun.disableTun()
+      console.log('TUN 模式已关闭')
+    }
+
+    // 使用 pkill 匹配进程名包含 clash-meta 的进程
+    spinner.text = '正在停止 Clash 服务...'
+    execSync('pkill -f clash-meta')
+    spinner.succeed('Clash 服务已停止')
+  } catch (err) {
+    // pkill 如果没找到进程会抛出错误，这里捕获并提示
+    spinner.warn('未找到运行中的 Clash 服务，或已停止')
+  }
+}