clash-kit 1.1.2 → 1.1.5

package/README.md

@@ -7,15 +7,13 @@
 
 目前已兼容 Windows，MacOs，Linux。
 
-## 截图
-
-<img width="1920" alt="image" src="https://github.com/user-attachments/assets/1183f778-62b0-4ac7-ab55-b821b66161f0" />
+<img width="604" height="315" alt="image" src="https://github.com/user-attachments/assets/7c97ef51-5a95-4612-aa43-ce66423d7560" />
 
 ## 特性
 
-- 🔄 **订阅管理**：支持添加、切换多个订阅源。
+- 🔄 **订阅管理**：支持添加、切换、修改、删除多个订阅源。
 - 🌐 **节点切换**：交互式选择并切换当前使用的代理节点。
-- 🔥 **热重载**：切换订阅后立即生效，无需重启服务。
+- 🔥 **热重载**：切换订阅/开关 TUN 后立即生效，无需重启服务。
 - ⚡ **节点测速**：支持多线程并发测速，彩色高亮显示延迟结果。
 - 📊 **状态监控**：实时查看服务运行状态、当前节点及延迟。
 - 🛠 **自动初始化**：自动处理二进制文件权限问题。
@@ -23,39 +21,63 @@
 - 💻 **系统代理**：一键开启/关闭 macOS 系统 HTTP 代理。
 - 🛡 **TUN 模式**：高级网络模式，接管系统所有流量（真 · 全局代理）。
 
-## 使用
+## 安装
 
-### 1. 安装
+- 支持通过 npm 或其它任意包管理器全局安装：
 
 ```bash
 npm install -g clash-kit
 # 或者
 pnpm add -g clash-kit
+# 或者
+yarn global add clash-kit
+```
+
+- 也支持通过 Homebrew 安装：
+
+```bash
+# 1. 先通过 brew tap 添加仓库
+brew tap wangrongding/clash-kit https://github.com/wangrongding/clash-kit
+# 2. 安装 clash-kit
+brew install clash-kit
 ```
 
-### 2. 初始化
+## 使用
+
+### 1. 初始化
 
 首次安装后，需要先初始化 Clash 内核与权限：
 
 ```bash
-clash init
 # 推荐用简化命令（文档后续均以简化命令为例）
-ck init
+ck init # 或者 clash init
 ```
 
-### 3. 添加订阅
+### 3. 管理订阅
 
 ```bash
-# 交互式管理订阅（添加、切换、删除等）【推荐使用这种方式来管理订阅】
+# 交互式管理订阅（添加、切换、修改、删除）【推荐】
 ck sub
 
 # 列出所有订阅
 ck sub -l
 
-# 手动添加订阅
-ck sub -a "https://example.com/subscribe?token=xxx" -n "abcName"
+# 手动添加订阅（-n 名称，-a 链接）
+ck sub -n "test123" -a "https://example.com/subscribe?token=xxx"
+
+# 手动切换订阅
+ck sub -u "test123"
 ```
 
+交互式模式 (`ck sub`) 提供以下操作：
+
+| 操作     | 说明                                       |
+| -------- | ------------------------------------------ |
+| 切换订阅 | 从现有订阅中选择并立即生效（热重载）       |
+| 添加订阅 | 依次输入名称和链接，完成下载               |
+| 修改订阅 | 重命名 和/或 更换订阅链接（均可留空跳过）  |
+| 删除订阅 | 选择后需二次确认，若删除当前订阅会自动解绑 |
+
 ### 4. 启动服务
 
 启动 Clash 核心服务（建议在一个单独的终端窗口运行）：
@@ -68,35 +90,35 @@ ck on # 或者 ck start
 ck on -s
 # 启动并自动开启 TUN 模式(全局代理, 需要 sudo 权限)
 ck on -t
+```
 
-# 关闭服务并关闭系统代理
+### 5. 关闭服务 或 重新启动服务
+
+```bash
+# 关闭服务
 ck off # 或者 ck stop
 
 # 重新启动服务
 ck rs # 或者 ck restart
 ```
 
-### 4. 节点切换（自动测速）
+### 6. 节点切换（自动测速）
 
 进入交互式界面，自动对当前节点组进行并发测速，并展示带有即时延迟数据的节点列表供选择。
 
 ```bash
 # 切换节点 (支持别名: node, proxy, switch)
 ck use
-# 或者
-ck switch
-# 或者
-ck node
 ```
 
-### 5. 更多功能
+### 7. 更多功能
 
 ```bash
 # 查看状态
 ck info # 或者 ck status, ck view
 
 # 节点并发测速 (仅测速不切换，支持别名: test, ls, t)
-ck list # 或者 ck test, ck ls
+ck ls # 或者 ck list，ck test，ck t
 
 # 设置系统代理
 ck sys on
@@ -117,14 +139,18 @@ ck tun off # 关闭
 | `ck rs` (`restart`)           | 重启 Clash 服务            | `ck rs` `ck rs -s` (重启并设置系统代理) `ck rs -t` (重启并开启 TUN 模式) |
 | `ck info` (`status`, `view`)  | 查看运行状态及当前节点延迟 | `ck info` / `ck status` / `ck view`                                      |
 | `ck sysproxy` (`sys`)         | 设置系统代理               | `ck sys on` / `ck sys off`                                               |
-| `ck tun`                      | 设置 TUN 模式 (需要 sudo)  | `ck tun on`                                                              |
+| `ck tun`                      | 设置 TUN 模式 (需要 sudo)  | `ck tun on` / `ck tun off`                                               |
 | `ck sub`                      | 管理订阅（交互式）【推荐】 | `ck sub`                                                                 |
 | `ck sub -l`                   | 列出所有订阅               | `ck sub -l`                                                              |
-| `ck sub -a <url>`             | 添加订阅                   | `ck sub -a "http..." -n "pro"`                                           |
+| `ck sub -n <name> -a <url>`   | 添加订阅                   | `ck sub -n "pro" -a "http..."`                                           |
 | `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`                                                    |
 
+## 截图
+
+<img width="1920" alt="image" src="https://github.com/user-attachments/assets/1183f778-62b0-4ac7-ab55-b821b66161f0" />
+
 ## License
 
 [MIT](./LICENSE).

package/bin/index.js

@@ -12,10 +12,26 @@ 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'
+import updateNotifier from 'update-notifier'
 
 const require = createRequire(import.meta.url)
 const pkg = require('../package.json')
 
+updateNotifier({
+  pkg: pkg,
+  updateCheckInterval: 1000 * 60 * 60 * 24, // 检查更新间隔，1 day
+  shouldNotifyInNpmScript: true,
+}).notify({
+  isGlobal: true,
+  boxenOptions: {
+    title: '有新版本的 Clash Kit 可用',
+    padding: 1,
+    margin: 1,
+    align: 'center',
+    borderColor: 'yellowBright',
+    borderStyle: 'round',
+  },
+})
 const program = new Command()
 
 program.name('clash').alias('ck').description('Clash CLI 管理工具 (Alias: ck)').version(pkg.version, '-v, --version')
@@ -71,6 +87,7 @@ program
   .option('-n, --name <name>', '订阅名称')
   .option('-l, --list', '列出所有订阅')
   .option('-u, --use <name>', '切换使用的订阅')
+  .option('-d, --delete <name>', '删除订阅')
   .action(manageSub)
 
 // 切换节点

package/lib/api.js

@@ -76,7 +76,7 @@ export async function getProxyDelay(proxyName, testUrl = 'http://www.gstatic.com
   try {
     const res = await axios.get(`${getApiBase()}/proxies/${encodeURIComponent(proxyName)}/delay`, {
       params: {
-        timeout: 5000,
+        timeout: 3000,
         url: testUrl,
       },
       headers,

package/lib/commands/init.js

@@ -120,6 +120,12 @@ export async function init(options) {
     console.log('正在初始化 Clash 内核...')
     await downloadClash(rootDir)
     console.log('Clash 内核初始化成功！')
+
+    console.log(chalk.bold.green('\n✅ 初始化完成！接下来：'))
+    console.log(chalk.cyan('  1. ck sub      ') + chalk.gray('添加订阅'))
+    console.log(chalk.cyan('  2. ck on    ') + chalk.gray('启动 Clash 服务'))
+    console.log(chalk.cyan('  3. ck sys on   ') + chalk.gray('开启系统代理'))
+    console.log(chalk.gray('\n  更多帮助: ck help\n'))
   } catch (err) {
     console.error(`初始化失败: ${err.message}`)
     process.exit(1)

package/lib/commands/proxy.js

@@ -8,8 +8,6 @@ export async function proxy() {
   try {
     let proxies = await api.getProxies()
     spinner.stop()
-
-    // 通常我们只关心 Proxy 组或者 Selector 类型的组
     const groups = Object.values(proxies).filter(p => p.type === 'Selector')
 
     if (groups.length === 0) {
@@ -35,39 +33,49 @@ export async function proxy() {
 
     const updatedGroup = proxies[groupName]
 
-    // 选择节点
-    const proxyName = await select({
-      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 = ''
+    // 构建节点条目并按延迟排序，超时/未测速排最后
+    const nodeEntries = updatedGroup.all.map(n => {
+      const node = proxies[n]
+      const lastHistory = node?.history && node.history.length ? node.history[node.history.length - 1] : null
+      let delay = Infinity
+      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(' [超时]')
+      if (lastHistory && lastHistory.delay > 0) {
+        delay = lastHistory.delay
+        if (delay < 200) {
+          delayInfo = chalk.green(` ${delay}ms`)
+        } else if (delay < 800) {
+          delayInfo = chalk.yellow(` ${delay}ms`)
         } else {
-          delayInfo = chalk.gray(' [未测速]')
+          delayInfo = chalk.red(` ${delay}ms`)
         }
+      } else if (lastHistory && lastHistory.delay === 0) {
+        delayInfo = chalk.red(' [超时]')
+      } else {
+        delayInfo = chalk.gray(' [未测速]')
+      }
 
-        return { name: `${n}${delayInfo}`, value: n }
-      }),
+      return { name: `${n}${delayInfo}`, value: n, delay }
+    })
+
+    nodeEntries.sort((a, b) => a.delay - b.delay)
+
+    // 选择节点
+    const proxyName = await select({
+      message: `[${groupName}] 当前: ${updatedGroup.now}, 请选择节点:`,
+      pageSize: 15,
+      choices: nodeEntries.map(({ name, value }) => ({ name, value })),
     })
 
     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)
+    if (spinner && spinner.isSpinning) spinner.stop()
+    if (err.message && (err.message.includes('ECONNREFUSED') || err.message.includes('无法连接'))) {
+      console.error(chalk.red('\nClash 服务未运行，请先执行: ck start\n'))
+    } else {
+      console.error(chalk.red(err.message))
+    }
   }
 }

package/lib/commands/start.js

@@ -1,30 +1,38 @@
 import * as sysproxy from '../sysproxy.js'
-import { main as startClashService } from '../../index.js'
+import { main as startClashService } from '../service.js'
 import { setTun } from './tun.js'
+import ora from 'ora'
+import boxen from 'boxen'
+import chalk from 'chalk'
 
 export async function start(options) {
+  const spinner = ora('正在启动 Clash 服务...').start()
   await startClashService()
+  spinner.stop()
 
   const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
 
   if (options.sysproxy) {
-    console.log('正在等待 Clash API 就绪以设置系统代理...')
-
-    // 尝试 5 次，每次间隔 1 秒
+    const sysSpinner = ora('正在等待 Clash API 就绪以设置系统代理...').start()
+    let sysOk = false
     for (let i = 0; i < 5; i++) {
       await sleep(1000)
       try {
-        const success = await sysproxy.enableSystemProxy()
-        if (success) break
+        const result = await sysproxy.enableSystemProxy()
+        if (result.success) {
+          sysSpinner.succeed(`系统代理已开启: ${result.host}:${result.port}`)
+          sysOk = true
+          break
+        }
       } catch (e) {
-        if (i === 4) console.error('设置系统代理超时，请稍后手动设置: clash sysproxy on')
+        // 继续重试
       }
     }
+    if (!sysOk) sysSpinner.fail('设置系统代理超时，请稍后手动执行: ck sys on')
   }
 
   if (options.tun) {
-    // 稍微延迟一下，确保服务可能有响应
-    await sleep(1000)
+    await sleep(500)
     await setTun('on')
   }
 }

package/lib/commands/status.js

@@ -25,13 +25,28 @@ export async function status() {
     const configPath = sub.CONFIG_PATH
     const logPath = path.resolve(path.dirname(configPath), 'clash.log')
 
+    // 订阅节点数
+    let profileNodeCount = ''
+    if (currentProfile) {
+      try {
+        const profilePath = path.join(path.dirname(configPath), 'profiles', `${currentProfile}.yaml`)
+        const YAML = (await import('yaml')).default
+        const fs = (await import('fs')).default
+        if (fs.existsSync(profilePath)) {
+          const parsed = YAML.parse(fs.readFileSync(profilePath, 'utf8'))
+          const count = parsed?.proxies?.length || 0
+          if (count > 0) profileNodeCount = chalk.gray(` (${count} 个节点)`)
+        }
+      } catch {}
+    }
+
     const content = []
     let statusLine = `状态：${chalk.green('运行中')}`
     if (processInfo?.pid) {
       statusLine += ` (PID: ${chalk.yellow(processInfo.pid)})`
     }
     content.push(statusLine)
-    content.push(`当前配置: ${currentProfile || '未知'}`)
+    content.push(`当前配置: ${currentProfile || '未知'}${profileNodeCount}`)
     content.push(`运行模式: ${config.mode}`)
     content.push(`API 地址:    ${chalk.cyan(apiBase)}`)
     content.push(`HTTP 代理:   ${chalk.cyan(`http://127.0.0.1:${config['port'] || '未设置'}`)}`)
@@ -40,14 +55,20 @@ export async function status() {
       `混合代理:    ${config['mixed-port'] ? chalk.cyan(`127.0.0.1:${config['mixed-port']}`) : chalk.gray('未设置')}`,
     )
     content.push('')
-    const sysProxyText = sysProxyStatus.enabled
+    const sysProxyText = sysProxyStatus?.enabled
       ? chalk.green(`已开启 (${sysProxyStatus.server}:${sysProxyStatus.port})`)
       : chalk.gray('未开启')
     content.push(`系统代理: ${sysProxyText}`)
     content.push(`TUN 模式(拦截所有流量): ${tunEnabled ? chalk.green('已开启') : chalk.gray('未开启')}`)
-    content.push('')
-    content.push(`日志文件: ${chalk.blueBright.underline(logPath)}`)
+    if (tunEnabled && config.dns) {
+      const dnsServers = config.dns.nameserver?.slice(0, 2).join(', ') || ''
+      const dnsMode = config.dns['enhanced-mode'] || ''
+      content.push(
+        `DNS 模式: ${chalk.cyan(dnsMode || '默认')}${dnsServers ? '  服务器: ' + chalk.cyan(dnsServers) : ''}`,
+      )
+    }
     content.push(`配置文件: ${chalk.blueBright.underline(configPath)}`)
+    content.push(`日志文件: ${chalk.blueBright.underline(logPath)}`)
     content.push('')
 
     content.push('')
@@ -57,7 +78,7 @@ export async function status() {
 
     console.log(
       boxen(content.join('\n'), {
-        title: chalk.bold.bgGreen('Clash Kit'),
+        title: chalk.bold.whiteBright.bgGreen(' Clash Kit '),
         titleAlignment: 'center',
         padding: 1,
         borderStyle: 'bold',
@@ -79,7 +100,7 @@ export async function status() {
       } else {
         delayStr = chalk.red('超时/失败')
       }
-      console.log(`🚀 节点延迟 [${group.name}: ${group.now}]: ${delayStr}`)
+      console.log(`🚀 节点延迟 [${group.name}: ${group.now}]: ${delayStr}\n`)
     }
   } catch (err) {
     if (spinner.isSpinning) spinner.stop()
@@ -91,7 +112,7 @@ export async function status() {
       content.push(`当前配置文件: ${configPath || '未知'}`)
       console.log(
         boxen(content.join('\n'), {
-          title: chalk.bold.bgYellow('Clash Kit'),
+          title: chalk.bold.bgYellow(' Clash Kit '),
           titleAlignment: 'center',
           padding: 1,
           borderStyle: 'single',

package/lib/commands/stop.js

@@ -11,18 +11,18 @@ export async function stop() {
   try {
     let wasTunEnabled = false
 
-    // 1. 关闭系统代理
+    // 1. 关闭系统代理（失败不中断）
     spinner.text = '正在关闭系统代理...'
-    await sysproxy.disableSystemProxy()
+    await sysproxy.disableSystemProxy().catch(() => {})
 
-    // 2. 检查并关闭 TUN 模式
-    const tunEnabled = await tun.isTunEnabled()
+    // 2. 检查并关闭 TUN 模式（失败不中断，继续杀进程）
+    const tunEnabled = await tun.isTunEnabled().catch(() => false)
     if (tunEnabled) {
       wasTunEnabled = true
       spinner.text = '正在关闭 TUN 模式...'
-      const result = await setTun('off', { silent: true })
+      const result = await setTun('off', { silent: true }).catch(() => ({ success: false }))
       if (!result.success) {
-        throw new Error(`关闭 TUN 模式失败: ${result.error}`)
+        spinner.text = 'TUN 关闭失败，继续停止进程...'
       }
     }
 
@@ -40,7 +40,7 @@ export async function stop() {
 
       console.log(
         boxen(content.join('\n'), {
-          title: 'Clash Kit',
+          title: ' Clash Kit ',
           padding: 1,
           margin: 1,
           borderStyle: 'round',
@@ -51,7 +51,7 @@ export async function stop() {
     } else {
       console.log(
         boxen(chalk.yellow('未找到运行中的 Clash 服务'), {
-          title: 'Clash Kit',
+          title: ' Clash Kit ',
           padding: 1,
           margin: 1,
           borderStyle: 'round',

package/lib/commands/sub.js

@@ -4,7 +4,8 @@ import fs from 'fs'
 import { fileURLToPath } from 'url'
 import chalk from 'chalk'
 import * as sub from '../subscription.js'
-import { CLASH_BIN_PATH } from '../../index.js'
+import { confirm } from '@inquirer/prompts'
+import { CLASH_BIN_PATH } from '../service.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -45,37 +46,79 @@ export async function manageSub(options) {
     } catch (err) {
       console.error(err.message)
     }
+  } else if (options.delete) {
+    console.log('🌸🌸🌸 / options: ', options)
+    try {
+      sub.deleteProfile(options.delete)
+      console.log(chalk.green(`订阅 "${options.delete}" 已删除`))
+    } catch (err) {
+      console.error(chalk.red(err.message))
+    }
   } else {
     // 交互式模式
     const profiles = sub.listProfiles()
 
-    const action = await select({
-      message: '请选择操作:',
-      choices: [
-        { name: '切换订阅', value: 'switch' },
-        { name: '添加订阅', value: 'add' },
-      ],
-    })
+    const choices = [
+      { name: '切换订阅', value: 'switch' },
+      { name: '添加订阅', value: 'add' },
+      { name: '修改订阅', value: 'edit' },
+      { name: '删除订阅', value: 'delete' },
+    ]
+
+    const action = await select({ message: '请选择操作:', choices })
 
     if (action === 'switch') {
-      if (profiles.length === 0) {
-        console.log('暂无订阅，请先添加')
-        return
-      }
+      if (profiles.length === 0) return console.log('暂无订阅，请先添加')
       const profile = await select({
         message: '选择要使用的订阅:',
         choices: profiles.map(p => ({ name: p, value: p })),
       })
       await sub.useProfile(profile)
     } else if (action === 'add') {
-      const url = await input({ message: '请输入订阅链接:' })
       const name = await input({ message: '请输入订阅名称:' })
-
+      const url = await input({ message: '请输入订阅链接:' })
       try {
         await handleAddSubscription(url, name)
       } catch (err) {
         console.error(err.message)
       }
+    } else if (action === 'edit') {
+      if (profiles.length === 0) return console.log('暂无订阅，请先添加')
+      const profile = await select({
+        message: '选择要修改的订阅:',
+        choices: profiles.map(p => ({ name: p, value: p })),
+      })
+      const newName = await input({ message: `新名称 (留空保持 "${profile}" 不变):` })
+      const newUrl = await input({ message: '新订阅链接 (留空则不重新下载):' })
+      const finalName = newName.trim() || profile
+      try {
+        if (newName.trim() && newName.trim() !== profile) {
+          sub.renameProfile(profile, finalName)
+          console.log(chalk.green(`已重命名: ${profile} → ${finalName}`))
+        }
+        if (newUrl.trim()) {
+          await sub.downloadSubscription(newUrl.trim(), finalName)
+        }
+        if (!newName.trim() && !newUrl.trim()) {
+          console.log(chalk.gray('未做任何修改'))
+        }
+      } catch (err) {
+        console.error(chalk.red(err.message))
+      }
+    } else if (action === 'delete') {
+      if (profiles.length === 0) return console.log('暂无订阅，请先添加')
+      const profile = await select({
+        message: '选择要删除的订阅:',
+        choices: profiles.map(p => ({ name: p, value: p })),
+      })
+      const ok = await confirm({ message: `确定删除订阅 "${profile}"?`, default: false })
+      if (!ok) return console.log(chalk.gray('已取消'))
+      try {
+        sub.deleteProfile(profile)
+        console.log(chalk.green(`订阅 "${profile}" 已删除`))
+      } catch (err) {
+        console.error(chalk.red(err.message))
+      }
     }
   }
 }

package/lib/commands/test.js

@@ -3,7 +3,17 @@ import * as api from '../api.js'
 
 export async function test() {
   try {
-    const proxies = await api.getProxies()
+    let proxies
+    try {
+      proxies = await api.getProxies()
+    } catch (err) {
+      if (err.message && (err.message.includes('ECONNREFUSED') || err.message.includes('无法连接'))) {
+        console.error(chalk.red('\nClash 服务未运行，请先执行: ck start\n'))
+      } else {
+        console.error(chalk.red(err.message))
+      }
+      return
+    }
     // 默认测速 Proxy 组的所有节点
     const group = proxies['Proxy'] || Object.values(proxies).find(p => p.type === 'Selector')
 
@@ -15,17 +25,13 @@ export async function test() {
     console.log(`\n[${group.name}]${group.all.length}个节点, 当前选中: ${group.now}\n`)
 
     const results = []
-    const concurrency = 10 // 并发数量
-    const queue = [...group.all]
     const total = group.all.length
     let completed = 0
     const current = group.now // 当前选中节点
 
-    const worker = async () => {
-      while (queue.length > 0) {
-        const name = queue.shift()
-        if (!name) break
-
+    // 全并发测速
+    await Promise.all(
+      group.all.map(async name => {
         try {
           const testUrl = name === 'DIRECT' ? 'http://connect.rom.miui.com/generate_204' : undefined
           const delay = await api.getProxyDelay(name, testUrl)
@@ -46,10 +52,8 @@ export async function test() {
           completed++
           results.push({ name, delay: 99999, isCurrent: name === current })
         }
-      }
-    }
-
-    await Promise.all(Array.from({ length: Math.min(concurrency, total) }, () => worker()))
+      }),
+    )
 
     console.log(chalk.bold.blue('\n=== 测速结果 (Top 5) ==='))
     results.sort((a, b) => a.delay - b.delay)

package/lib/commands/tun.js

@@ -4,7 +4,7 @@ import ora from 'ora'
 import boxen from 'boxen'
 import * as tun from '../tun.js'
 import * as sysnet from '../sysnet.js'
-import { main as startClashService } from '../../index.js'
+import { main as startClashService } from '../service.js'
 
 async function turnOn() {
   const spinner = ora('正在配置 TUN 模式...').start()
@@ -73,9 +73,9 @@ async function turnOff(options = {}) {
     await tun.disableTun()
 
     if (spinner) spinner.text = '正在恢复系统 DNS...'
-    const dnsResult = sysnet.setDNS([]) // This is silent now
+    const dnsResult = sysnet.setDNS([])
     if (!dnsResult.success) {
-      throw new Error(`恢复 DNS 失败: ${dnsResult.error}`)
+      console.warn(chalk.yellow(`\n  DNS 恢复失败 (可忽略，DNS 将在重启后自动恢复): ${dnsResult.error}`))
     }
 
     if (spinner) spinner.stop()

package/{index.js → lib/service.js}

@@ -1,25 +1,26 @@
-import { spawn, execSync } from 'child_process'
+import { spawn } from 'child_process'
 import path from 'path'
 import fs from 'fs'
 import chalk from 'chalk'
 import axios from 'axios'
 import ora from 'ora'
-import boxen from 'boxen'
 import YAML from 'yaml'
 import { fileURLToPath } from 'url'
-import { getApiBase, getProxyPort } from './lib/api.js'
-import { status } from './lib/commands/status.js'
-import * as sysproxy from './lib/sysproxy.js'
-import * as tun from './lib/tun.js'
-import { isPortOpen, extractPort, getPortOccupier } from './lib/port.js'
-import { killClashProcess } from './lib/kernel.js'
+import { getApiBase } from './api.js'
+import { status } from './commands/status.js'
+import * as sysproxy from './sysproxy.js'
+import * as tun from './tun.js'
+import { isPortOpen, extractPort, getPortOccupier } from './port.js'
+import { killClashProcess } from './kernel.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
 // ----------------  配置项 ----------------
-export const CLASH_BIN_PATH = path.join(__dirname, process.platform === 'win32' ? 'clash-kit.exe' : 'clash-kit') // 解压后的二进制文件路径
-export const CLASH_CONFIG_PATH = path.join(__dirname, 'config.yaml') // 配置文件路径
+export const CLASH_BIN_PATH = path.join(__dirname, '..', process.platform === 'win32' ? 'clash-kit.exe' : 'clash-kit') // 解压后的二进制文件路径
+export const CLASH_CONFIG_PATH = path.join(__dirname, '..', 'config.yaml') // 配置文件路径
+
+const ROOT_DIR = path.join(__dirname, '..')
 
 async function checkPorts() {
   try {
@@ -70,11 +71,11 @@ async function startClash() {
   // 检查端口占用 (核心策略：报错/启动失败)
   await checkPorts()
 
-  const logPath = path.join(__dirname, 'clash.log')
+  const logPath = path.join(ROOT_DIR, 'clash.log')
   const logFd = fs.openSync(logPath, 'a')
 
-  const clashProcess = spawn(CLASH_BIN_PATH, ['-f', CLASH_CONFIG_PATH, '-d', __dirname], {
-    cwd: __dirname,
+  const clashProcess = spawn(CLASH_BIN_PATH, ['-f', CLASH_CONFIG_PATH, '-d', ROOT_DIR], {
+    cwd: ROOT_DIR,
     detached: true,
     stdio: ['ignore', logFd, logFd], // 重定向 stdout 和 stderr 到日志文件
   })
@@ -177,7 +178,7 @@ export async function main() {
 
   if (!started) {
     spinner.fail(chalk.red('启动失败'))
-    const logPath = path.join(__dirname, 'clash.log')
+    const logPath = path.join(ROOT_DIR, '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')
@@ -197,8 +198,3 @@ export async function main() {
   // 调用 status 命令来打印完整的状态信息
   await status()
 }
-
-// 运行脚本
-if (process.argv[1] === __filename) {
-  main()
-}

package/lib/subscription.js

@@ -126,3 +126,27 @@ export async function useProfile(name) {
     spinner.succeed('配置已切换（Clash 未运行，将在下次启动时生效）')
   }
 }
+
+export function deleteProfile(name) {
+  const filePath = path.join(PROFILES_DIR, `${name}.yaml`)
+  if (!fs.existsSync(filePath)) throw new Error(`订阅 ${name} 不存在`)
+  fs.unlinkSync(filePath)
+  // 若删除的是当前使用的订阅，清除记录
+  if (fs.existsSync(CURRENT_PROFILE_PATH)) {
+    const current = fs.readFileSync(CURRENT_PROFILE_PATH, 'utf8').trim()
+    if (current === name) fs.unlinkSync(CURRENT_PROFILE_PATH)
+  }
+}
+
+export function renameProfile(oldName, newName) {
+  const oldPath = path.join(PROFILES_DIR, `${oldName}.yaml`)
+  const newPath = path.join(PROFILES_DIR, `${newName}.yaml`)
+  if (!fs.existsSync(oldPath)) throw new Error(`订阅 ${oldName} 不存在`)
+  if (fs.existsSync(newPath)) throw new Error(`订阅名称 ${newName} 已存在`)
+  fs.renameSync(oldPath, newPath)
+  // 同步更新当前使用记录
+  if (fs.existsSync(CURRENT_PROFILE_PATH)) {
+    const current = fs.readFileSync(CURRENT_PROFILE_PATH, 'utf8').trim()
+    if (current === oldName) fs.writeFileSync(CURRENT_PROFILE_PATH, newName)
+  }
+}

package/lib/sysnet.js

@@ -1,11 +1,4 @@
 import { execSync } from 'child_process'
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const HELPER_BIN = path.join(__dirname, '../bin/dns-helper')
 
 /**
  * 获取 macOS 当前主要的网络服务名称 (Wi-Fi, Ethernet 等)
@@ -38,34 +31,18 @@ function getMainNetworkService() {
  */
 export function setDNS(servers) {
   if (process.platform !== 'darwin') {
-    return { success: true, message: 'Platform is not macOS, skipping DNS change.' }
+    return { success: true }
   }
 
   const service = getMainNetworkService()
   if (!service) {
-    return { success: false, error: 'Could not determine main network service.' }
-  }
-
-  // 检查是否存在 helper
-  let useHelper = false
-  try {
-    if (fs.existsSync(HELPER_BIN)) {
-      const stats = fs.statSync(HELPER_BIN)
-      if (stats.uid === 0 && (stats.mode & 0o4000)) {
-        useHelper = true
-      }
-    }
-  } catch (e) {
-    /* ignore */
+    return { success: false, error: '无法获取网络服务' }
   }
 
-  const serversArg = servers.length > 0 ? servers.join(' ') : 'Empty'
-  const command = useHelper
-    ? `"${HELPER_BIN}" "${service}" ${serversArg}`
-    : `sudo networksetup -setdnsservers "${service}" ${serversArg}`
+  const serversArg = servers.length > 0 ? servers.join(' ') : '"Empty"'
 
   try {
-    execSync(command, { stdio: 'pipe' }) // Use 'pipe' to suppress output
+    execSync(`sudo networksetup -setdnsservers "${service}" ${serversArg}`)
     return { success: true }
   } catch (e) {
     return { success: false, error: e.message }

package/lib/tun.js

@@ -9,8 +9,6 @@ const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 const CONFIG_PATH = path.join(__dirname, '../config.yaml')
 const BIN_PATH = path.join(__dirname, '../clash-kit')
-const HELPER_SRC = path.join(__dirname, '../scripts/dns-helper.c')
-const HELPER_BIN = path.join(__dirname, '../bin/dns-helper')
 
 export function checkTunPermissions() {
   if (process.platform === 'win32') return true // Windows 需要管理员权限终端，难以通过文件属性判断
@@ -21,15 +19,7 @@ export function checkTunPermissions() {
     // 检查所有者是否为 root (uid 0) 并且拥有 SUID 位
     const isRootOwned = stats.uid === 0
     const hasSuid = (stats.mode & 0o4000) === 0o4000
-    
-    // 同时也检查 DNS 辅助工具的权限
-    let helperOk = false
-    if (fs.existsSync(HELPER_BIN)) {
-      const hStats = fs.statSync(HELPER_BIN)
-      helperOk = hStats.uid === 0 && (hStats.mode & 0o4000) === 0o4000
-    }
-
-    return isRootOwned && hasSuid && helperOk
+    return isRootOwned && hasSuid
   } catch (e) {
     return false
   }
@@ -48,20 +38,6 @@ export function setupPermissions() {
     console.log('正在提升内核权限 (需要 sudo 密码)...')
     execSync(`sudo ${cmdChown}`, { stdio: 'inherit' })
     execSync(`sudo ${cmdChmod}`, { stdio: 'inherit' })
-
-    // 编译并设置 DNS 辅助工具
-    if (fs.existsSync(HELPER_SRC)) {
-      console.log('正在编译 DNS 辅助工具...')
-      try {
-        execSync(`cc "${HELPER_SRC}" -o "${HELPER_BIN}"`, { stdio: 'inherit' })
-        execSync(`sudo chown root:${group} "${HELPER_BIN}"`, { stdio: 'inherit' })
-        execSync(`sudo chmod +sx "${HELPER_BIN}"`, { stdio: 'inherit' })
-        console.log('DNS 辅助工具设置成功')
-      } catch (compileErr) {
-        console.warn('DNS 辅助工具编译或设置失败，系统 DNS 切换可能仍需密码:', compileErr.message)
-      }
-    }
-
     return true
   } catch (e) {
     throw new Error('权限设置失败')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clash-kit",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "type": "module",
   "description": "A command-line interface for managing Clash configurations, subscriptions, and proxies.",
   "bin": {
@@ -13,12 +13,10 @@
     ".gitignore",
     "default.yaml",
     "country.mmdb",
-    "index.js",
     "LICENSE.md",
     "package.json",
     "README.md"
   ],
-  "main": "index.js",
   "scripts": {
     "start": "node bin/index.js start",
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -45,6 +43,7 @@
     "commander": "^14.0.2",
     "inquirer": "^13.1.0",
     "ora": "^9.0.0",
+    "update-notifier": "^7.3.1",
     "yaml": "^2.8.2"
   }
 }