whistle.easy-proxy 1.0.0

package/lib/cli/commands/intercept.js

@@ -0,0 +1,222 @@
+const { CONFIG_PATH } = require('../../config');
+const {
+  readConfig,
+  writeConfig,
+  promptConfirm,
+  info,
+  ok,
+  err,
+  warn,
+  title,
+  sep,
+  c,
+} = require('../helpers');
+
+function registerIntercept(program) {
+  const interceptCmd = program.command('intercept').description('拦截规则管理');
+
+  interceptCmd
+    .command('status')
+    .description('查看拦截规则状态')
+    .action(() => {
+      const cfg = readConfig();
+      const enabled = cfg.interceptEnabled !== false;
+      const rules = cfg.interceptRules || {};
+      const hostCount = Object.keys(rules).length;
+      let pathCount = 0;
+      for (const h of Object.keys(rules)) {
+        pathCount += Object.keys(rules[h] || {}).length;
+      }
+      title('拦截规则状态');
+      sep();
+      info(`拦截开关:   ${enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`}${c.reset}`);
+      info(`域名规则数: ${hostCount} 个域名, ${pathCount} 条路径规则`);
+      info(`配置文件:   ${CONFIG_PATH}`);
+      sep();
+      info('使用 easy-proxy intercept list 查看所有规则');
+      info('使用 easy-proxy intercept search <关键词> 搜索规则');
+    });
+
+  interceptCmd
+    .command('enable')
+    .description('启用拦截规则')
+    .action(() => {
+      const cfg = readConfig();
+      cfg.interceptEnabled = true;
+      writeConfig(cfg);
+      ok('拦截规则已启用');
+    });
+
+  interceptCmd
+    .command('disable')
+    .description('关闭拦截规则')
+    .action(() => {
+      const cfg = readConfig();
+      cfg.interceptEnabled = false;
+      writeConfig(cfg);
+      ok('拦截规则已关闭');
+    });
+
+  interceptCmd
+    .command('list')
+    .description('列出所有拦截规则')
+    .option('-d, --domain <domain>', '只显示指定域名的规则')
+    .option('--json', '以 JSON 格式输出')
+    .action((opts) => {
+      const cfg = readConfig();
+      const rules = cfg.interceptRules || {};
+      const hosts = Object.keys(rules).sort();
+
+      if (opts.json) {
+        const result = {};
+        for (const host of hosts) {
+          if (opts.domain && host !== opts.domain && host.indexOf(opts.domain) < 0) continue;
+          result[host] = rules[host];
+        }
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      title('拦截规则列表');
+      sep();
+      let count = 0;
+      for (const host of hosts) {
+        if (opts.domain && host !== opts.domain && host.indexOf(opts.domain) < 0) continue;
+        const pathRules = rules[host];
+        console.log(c.bold + c.blue + host + c.reset);
+        for (const pathPattern of Object.keys(pathRules)) {
+          const actions = pathRules[pathPattern];
+          const actionKeys = Object.keys(actions).filter(
+            (k) => ['desc', 'remark', 'test'].indexOf(k) < 0
+          );
+          const desc = actions.desc || '';
+          const actionStr =
+            actionKeys.length > 0
+              ? actionKeys
+                  .map((k) => {
+                    const v = actions[k];
+                    if (typeof v === 'object') return `${k}:{...}`;
+                    return `${k}:${v}`;
+                  })
+                  .join(', ')
+              : `${c.gray}(仅文档)${c.reset}`;
+          console.log(`  ${c.gray}${pathPattern}${c.reset} → ${actionStr}`);
+          if (desc) console.log(`    ${c.gray}${desc}${c.reset}`);
+          count++;
+        }
+        console.log('');
+      }
+      sep();
+      info(`共 ${hosts.length} 个域名, ${count} 条路径规则`);
+    });
+
+  interceptCmd
+    .command('search <keyword>')
+    .description('搜索拦截规则')
+    .action((keyword) => {
+      const cfg = readConfig();
+      const rules = cfg.interceptRules || {};
+      const hosts = Object.keys(rules).filter((h) => h.indexOf(keyword) >= 0);
+      title(`搜索: "${keyword}"`);
+      sep();
+      if (hosts.length === 0) {
+        info('未找到匹配的规则');
+        return;
+      }
+      for (const host of hosts) {
+        const pathRules = rules[host];
+        console.log(c.bold + c.blue + host + c.reset);
+        for (const pathPattern of Object.keys(pathRules)) {
+          const actions = pathRules[pathPattern];
+          const actionKeys = Object.keys(actions).filter(
+            (k) => ['desc', 'remark', 'test'].indexOf(k) < 0
+          );
+          const actionStr =
+            actionKeys.length > 0
+              ? actionKeys
+                  .map((k) => {
+                    const v = actions[k];
+                    if (typeof v === 'object') return `${k}:{...}`;
+                    return `${k}:${v}`;
+                  })
+                  .join(', ')
+              : `${c.gray}(仅文档)${c.reset}`;
+          console.log(`  ${c.gray}${pathPattern}${c.reset} → ${actionStr}`);
+        }
+        console.log('');
+      }
+      sep();
+      info(`找到 ${hosts.length} 个匹配域名`);
+    });
+
+  interceptCmd
+    .command('add <host> <path> <actionJson>')
+    .description('添加拦截规则 (actionJson 为 JSON 字符串)')
+    .action((host, pathPattern, actionJson) => {
+      let actions;
+      try {
+        actions = JSON.parse(actionJson);
+      } catch (e) {
+        err(`actionJson 格式错误: ${e.message}`);
+        info('示例: easy-proxy intercept add example.com ".*" \'{"sni":"baidu.com"}\'');
+        return;
+      }
+      const cfg = readConfig();
+      if (!cfg.interceptRules || typeof cfg.interceptRules !== 'object') {
+        cfg.interceptRules = {};
+      }
+      if (!cfg.interceptRules[host]) {
+        cfg.interceptRules[host] = {};
+      }
+      cfg.interceptRules[host][pathPattern] = actions;
+      writeConfig(cfg);
+      ok(`已添加规则: ${host} ${pathPattern}`);
+      info(`动作: ${JSON.stringify(actions)}`);
+    });
+
+  interceptCmd
+    .command('remove <host> [path]')
+    .description('删除拦截规则 (不指定 path 则删除整个域名)')
+    .action((host, pathPattern) => {
+      const cfg = readConfig();
+      if (!cfg.interceptRules?.[host]) {
+        err(`未找到域名: ${host}`);
+        return;
+      }
+      if (pathPattern) {
+        if (!cfg.interceptRules[host][pathPattern]) {
+          err(`未找到路径规则: ${pathPattern}`);
+          return;
+        }
+        delete cfg.interceptRules[host][pathPattern];
+        if (Object.keys(cfg.interceptRules[host]).length === 0) {
+          delete cfg.interceptRules[host];
+        }
+        writeConfig(cfg);
+        ok(`已删除: ${host} ${pathPattern}`);
+      } else {
+        delete cfg.interceptRules[host];
+        writeConfig(cfg);
+        ok(`已删除域名: ${host}`);
+      }
+    });
+
+  interceptCmd
+    .command('reset')
+    .description('重置为默认拦截规则')
+    .action(async () => {
+      const confirmed = await promptConfirm('重置为默认拦截规则? 这将丢失自定义规则 (y/N) ');
+      if (!confirmed) {
+        info('已取消');
+        return;
+      }
+      const cfg = readConfig();
+      cfg.interceptRules = require('../../plugin/default-rules');
+      writeConfig(cfg);
+      ok('已重置为默认拦截规则');
+    });
+}
+
+module.exports = {
+  registerIntercept,
+};

package/lib/cli/commands/network.js

@@ -0,0 +1,32 @@
+const { info, ok, err } = require('../helpers');
+
+function registerNetwork(program) {
+  const netCmd = program.command('network').description('网络工具');
+
+  netCmd
+    .command('ip')
+    .description('显示本机 IP')
+    .action(() => {
+      const { getLocalIp } = require('../../network-utils');
+      info(`本机 IP: ${getLocalIp()}`);
+    });
+
+  netCmd
+    .command('delay')
+    .description('检测网络延迟')
+    .option('-p, --port <port>', '通过代理端口检测（不指定则直连）')
+    .action(async (opts) => {
+      const { checkDelay } = require('../../network-utils');
+      const port = opts.port ? parseInt(opts.port, 10) : undefined;
+      try {
+        const ms = await checkDelay(port);
+        ok(`延迟: ${ms}ms${port ? `（通过端口 ${port}）` : '（直连）'}`);
+      } catch (e) {
+        err(`检测失败: ${e.message}`);
+      }
+    });
+}
+
+module.exports = {
+  registerNetwork,
+};

package/lib/cli/commands/proxy.js

@@ -0,0 +1,279 @@
+const { localW2Path, getWhistleStatus, info, ok, warn, err, title, sep, c, editInEditor } = require('../helpers');
+
+function enableSystemProxy() {
+  const { execSync } = require('node:child_process');
+  const proxyConfig = require('../proxy-config');
+  const bypass = proxyConfig.getEffectiveBypass();
+  const bypassArg = bypass.join(', ');
+  info(`开启系统代理（bypass: ${bypass.length} 个域名）...`);
+  execSync(`"${localW2Path}" proxy -x "${bypassArg}"`, { stdio: 'inherit' });
+  ok('系统代理已开启');
+}
+
+function disableSystemProxy() {
+  const { execSync } = require('node:child_process');
+  execSync(`"${localW2Path}" proxy 0`, { stdio: 'inherit' });
+  ok('系统代理已关闭');
+}
+
+// ---- 尝试同步上游代理规则到 whistle（静默失败） ----
+async function trySyncUpstream(upstream, proxies) {
+  try {
+    const ruleApi = require('../rule-api');
+    await upstream.syncToWhistle(ruleApi, proxies);
+    info(`已同步上游代理规则到 whistle 规则集 "${upstream.RULESET_NAME}"`);
+  } catch (_e) {
+    // whistle 未运行时静默跳过，下次 start 后可手动 sync
+    info(
+      c.gray +
+        '(whistle 未运行，规则未同步 — 启动后可用 easy-proxy proxy upstream sync 同步)' +
+        c.reset
+    );
+  }
+}
+
+function registerProxy(program) {
+  const proxyCmd = program.command('proxy').description('系统代理管理');
+
+  // proxy on — 开启系统代理（调用 w2 proxy，自动带上 bypass 列表）
+  proxyCmd
+    .command('on')
+    .description('开启系统代理（自动带上 bypass 域名）')
+    .action(async () => {
+      try {
+        enableSystemProxy();
+      } catch (e) {
+        err(`开启系统代理失败: ${e.message}`);
+        info('请确保 whistle 已运行: easy-proxy start --init');
+        process.exit(1);
+      }
+    });
+
+  // proxy off — 关闭系统代理
+  proxyCmd
+    .command('off')
+    .description('关闭系统代理')
+    .action(() => {
+      try {
+        disableSystemProxy();
+      } catch (e) {
+        err(`关闭系统代理失败: ${e.message}`);
+        process.exit(1);
+      }
+    });
+
+  // proxy status — 检查系统代理是否指向 whistle
+  proxyCmd
+    .command('status')
+    .description('检查系统代理状态')
+    .action(async () => {
+      const { getLocalIp } = require('../../network-utils');
+      info(`本机 IP: ${getLocalIp()}`);
+      // 检查 whistle 是否运行
+      const ws = getWhistleStatus();
+      if (!ws.running) {
+        warn('whistle 代理未运行');
+        info('运行 easy-proxy start --init 启动代理');
+        return;
+      }
+      if (ws.port) info(`whistle 端口: ${ws.port}`);
+      // 检查系统代理
+      const { checkSystemProxy } = require('../../proxy-check');
+      const proxyOn = await checkSystemProxy(ws.port);
+      if (proxyOn) {
+        ok('系统代理: 已开启（指向 whistle）');
+      } else {
+        warn('系统代理: 未指向 whistle');
+        info('运行 easy-proxy proxy on 开启系统代理');
+      }
+    });
+
+  // ---- proxy upstream ----
+  const upstreamCmd = proxyCmd.command('upstream').description('上游代理管理');
+
+  upstreamCmd
+    .command('edit')
+    .description('编辑上游代理配置（打开 $EDITOR）')
+    .action(async () => {
+      const upstream = require('../upstream-proxy');
+      const { parse, buildEditContent } = require('../upstream-editor');
+      const oldProxies = upstream.loadProxies();
+      let content = buildEditContent(oldProxies);
+
+      let newProxies;
+      while (true) {
+        let editedText;
+        try {
+          editedText = editInEditor(content, 'upstream');
+        } catch (_e) {
+          // 编辑器非零退出码（如 vi :q!）视为用户取消
+          info('已取消');
+          return;
+        }
+        try {
+          newProxies = parse(editedText);
+          break;
+        } catch (e) {
+          err(e.message);
+          warn('解析失败，请修正后重新保存...');
+          content = editedText;
+        }
+      }
+
+      if (JSON.stringify(oldProxies) === JSON.stringify(newProxies)) {
+        info('无改动');
+        return;
+      }
+
+      upstream.saveProxies(newProxies);
+      await trySyncUpstream(upstream, newProxies);
+      ok('上游代理配置已更新');
+    });
+
+  upstreamCmd
+    .command('status')
+    .description('查看上游代理配置')
+    .action(() => {
+      const upstream = require('../upstream-proxy');
+      const proxies = upstream.loadProxies();
+      title('上游代理配置');
+      sep();
+      if (proxies.length === 0) {
+        info('未配置代理');
+      } else {
+        proxies.forEach((p) => {
+          info(`${p.name}: ${p.url}`);
+          if (p.domains.length > 0) {
+            p.domains.forEach((d) => {
+              info(`  ${d}`);
+            });
+          } else {
+            info('  (无域名)');
+          }
+        });
+      }
+      info('默认: 直连');
+      sep();
+      info(`规则集名: ${upstream.RULESET_NAME}`);
+    });
+
+  // proxy upstream sync — 手动同步规则到 whistle
+  upstreamCmd
+    .command('sync')
+    .description('手动同步上游代理规则到 whistle')
+    .action(async () => {
+      const upstream = require('../upstream-proxy');
+      const proxies = upstream.loadProxies();
+      try {
+        const ruleApi = require('../rule-api');
+        await upstream.syncToWhistle(ruleApi, proxies);
+        ok(`已同步 ${proxies.length} 个上游代理规则到 whistle`);
+      } catch (e) {
+        err(`同步失败: ${e.message}`);
+        info('请确保 whistle 已运行: easy-proxy start --init');
+        process.exit(1);
+      }
+    });
+
+  // ---- proxy bypass ----
+  const bypassCmd = proxyCmd.command('bypass').description('管理跳过代理的域名');
+
+  bypassCmd
+    .command('show')
+    .description('查看当前跳过列表')
+    .action(() => {
+      const proxyConfig = require('../proxy-config');
+      const config = proxyConfig.loadConfig();
+      const domains = config.bypassDomains || proxyConfig.getDefaultBypass();
+      title('跳过代理的域名');
+      sep();
+      if (domains.length === 0) {
+        info('(空)');
+      } else {
+        domains.forEach((d) => {
+          info(`  ${d}`);
+        });
+      }
+      if (!config.bypassDomains) {
+        info(`${c.gray}(使用默认列表)${c.reset}`);
+      }
+      sep();
+    });
+
+  bypassCmd
+    .command('set <domains>')
+    .description('设置跳过列表（逗号分隔，如: 127.0.0.1,localhost,*.local）')
+    .action((domains) => {
+      const proxyConfig = require('../proxy-config');
+      const list = domains
+        .split(',')
+        .map((d) => d.trim())
+        .filter(Boolean);
+      if (list.length === 0) {
+        err('请提供至少一个域名');
+        return;
+      }
+      proxyConfig.saveConfig({ bypassDomains: list });
+      ok(`已设置跳过列表: ${list.join(', ')}`);
+      info('重新开启系统代理后生效: easy-proxy proxy on');
+    });
+
+  bypassCmd
+    .command('add <domain>')
+    .description('添加一个跳过域名')
+    .action((domain) => {
+      const proxyConfig = require('../proxy-config');
+      const config = proxyConfig.loadConfig();
+      const list = config.bypassDomains
+        ? config.bypassDomains.slice()
+        : proxyConfig.getDefaultBypass().slice();
+      if (list.indexOf(domain) >= 0) {
+        warn(`已存在: ${domain}`);
+        return;
+      }
+      list.push(domain);
+      proxyConfig.saveConfig({ bypassDomains: list });
+      ok(`已添加: ${domain}`);
+      info('重新开启系统代理后生效: easy-proxy proxy on');
+    });
+
+  bypassCmd
+    .command('remove <domain>')
+    .description('移除一个跳过域名')
+    .action((domain) => {
+      const proxyConfig = require('../proxy-config');
+      const config = proxyConfig.loadConfig();
+      if (!config.bypassDomains) {
+        warn('未自定义跳过列表，当前使用默认列表');
+        return;
+      }
+      const index = config.bypassDomains.indexOf(domain);
+      if (index < 0) {
+        warn(`未找到: ${domain}`);
+        return;
+      }
+      config.bypassDomains.splice(index, 1);
+      proxyConfig.saveConfig({ bypassDomains: config.bypassDomains });
+      ok(`已移除: ${domain}`);
+      info('重新开启系统代理后生效: easy-proxy proxy on');
+    });
+
+  bypassCmd
+    .command('reset')
+    .description('重置为默认跳过列表')
+    .action(() => {
+      const proxyConfig = require('../proxy-config');
+      proxyConfig.saveConfig({ bypassDomains: null });
+      ok('已重置为默认列表');
+      proxyConfig.getDefaultBypass().forEach((d) => {
+        info(`  ${d}`);
+      });
+      info('重新开启系统代理后生效: easy-proxy proxy on');
+    });
+}
+
+module.exports = {
+  registerProxy,
+  enableSystemProxy,
+  disableSystemProxy,
+};