whistle.easy-proxy 1.0.0

package/lib/cli/commands/rule.js

@@ -0,0 +1,352 @@
+const api = require('../rule-api');
+const cfg = require('../../config');
+const { parse, buildEditContent, findUnknownOperators } = require('../rule-editor');
+const {
+  warnWhistleNotRunning,
+  editInEditor,
+  promptConfirm,
+  info,
+  ok,
+  warn,
+  err,
+  title,
+  sep,
+  c,
+} = require('../helpers');
+
+function registerRule(program) {
+  const ruleCmd = program
+    .command('rule')
+    .description('Whistle 规则管理（离线可用，启动后自动同步）');
+
+  ruleCmd
+    .command('list')
+    .description('列出所有规则集')
+    .action(async () => {
+      const running = warnWhistleNotRunning();
+      try {
+        let data, source;
+        if (running) {
+          data = await api.listRulesets();
+          source = 'whistle（已连接）';
+        } else {
+          const rules = api.loadOfflineRulesets();
+          data = {
+            defaultRules: api.getOfflineDefaultRules(),
+            list: rules,
+            enabledCount: rules.filter((r) => r.enabled).length,
+          };
+          source = '本地配置';
+        }
+        title('Whistle 规则集');
+        sep();
+        const defaultOn = !data.defaultRulesIsDisabled;
+        info(
+          (defaultOn ? `${c.green}✓` : `${c.red}✗`) +
+            c.reset +
+            ' 默认规则' +
+            c.gray +
+            '（内置）' +
+            c.reset
+        );
+        if (data.defaultRules) {
+          const lines = data.defaultRules.split('\n').filter((l) => l.trim());
+          lines.slice(0, 3).forEach((l) => console.log(`${c.gray}  ${l}${c.reset}`));
+          if (lines.length > 3)
+            console.log(`${c.gray}  ...（还有 ${lines.length - 3} 行）${c.reset}`);
+        }
+        const list = data.list || [];
+        const groups = {};
+        const ungrouped = [];
+        let currentGroup = null;
+        list.forEach((item) => {
+          if (item.name && item.name.charCodeAt(0) === 13) {
+            currentGroup = item.name;
+            groups[currentGroup] = [];
+          } else if (currentGroup) {
+            groups[currentGroup].push(item);
+          } else {
+            ungrouped.push(item);
+          }
+        });
+        if (groups[api.SYSTEM_GROUP]) {
+          console.log(`${c.blue}⚙ ${api.SYSTEM_GROUP.slice(1)}${c.reset}`);
+          groups[api.SYSTEM_GROUP].forEach((item) => {
+            const on = item.selected;
+            console.log(`  ${on ? `${c.green}✓` : `${c.red}✗`}${c.reset} ${item.name}`);
+          });
+        }
+        if (groups[api.USER_GROUP]) {
+          console.log(`${c.blue}✎ ${api.USER_GROUP.slice(1)}${c.reset}`);
+          groups[api.USER_GROUP].forEach((item) => {
+            const on = item.selected;
+            console.log(`  ${on ? `${c.green}✓` : `${c.red}✗`}${c.reset} ${item.name}`);
+            const data = item.data || item.content;
+            if (data) {
+              const lines = data.split('\n').filter((l) => l.trim());
+              lines.slice(0, 3).forEach((l) => console.log(`${c.gray}    ${l}${c.reset}`));
+              if (lines.length > 3)
+                console.log(`${c.gray}    ...（还有 ${lines.length - 3} 行）${c.reset}`);
+            }
+          });
+        }
+        if (ungrouped.length > 0) {
+          console.log(`${c.blue}📂 其他规则${c.reset}`);
+          ungrouped.forEach((item) => {
+            const on = item.selected;
+            console.log(`  ${on ? `${c.green}✓` : `${c.red}✗`}${c.reset} ${item.name}`);
+          });
+        }
+        sep();
+        info(`共 ${list.length + 1} 个规则集（已启用 ${data.enabledCount} 个）`);
+        info(`来源: ${source}`);
+        if (running) info('Web 界面: http://local.whistlejs.com/#rules');
+      } catch (e) {
+        err(e.message);
+        process.exit(1);
+      }
+    });
+
+  ruleCmd
+    .command('add <name> [pattern] [target]')
+    .description('新增规则集（打开 $EDITOR，或直接指定 pattern+target）')
+    .action(async (name, pattern, target) => {
+      if (name === 'Default') {
+        err('不能添加名为 "Default" 的规则集 — 请使用: easy-proxy rule edit Default');
+        return;
+      }
+      const running = warnWhistleNotRunning();
+      const api = require('../rule-api');
+      try {
+        let content;
+        if (pattern && target) {
+          content = `${pattern} ${target}`;
+          // 校验直接传入的内容
+          try {
+            parse(content);
+          } catch (e) {
+            err(e.message);
+            return;
+          }
+        } else {
+          // 打开编辑器，带语法提示和校验循环
+          let editText = buildEditContent('');
+          while (true) {
+            try {
+              editText = editInEditor(editText, name);
+            } catch (_e) {
+              info('已取消');
+              return;
+            }
+            try {
+              parse(editText);
+              break;
+            } catch (e) {
+              err(e.message);
+              warn('解析失败，请修正后重新保存...');
+            }
+          }
+          // 从编辑内容中提取有效规则（去掉注释头部）
+          content = editText;
+        }
+        if (!content.trim()) {
+          info('内容为空，已取消');
+          return;
+        }
+
+        if (running) {
+          const data = await api.listRulesets();
+          const exists = (data.list || []).some((r) => r.name === name);
+          if (exists) {
+            err(`规则集 "${name}" 已存在 — 请使用: easy-proxy rule edit ${name}`);
+            return;
+          }
+          await api.createGroup(api.USER_GROUP);
+          await api.addRuleset(name, content, api.USER_GROUP);
+        }
+
+        if (api.loadOfflineRulesets().some((r) => r.name === name)) {
+          err(`规则集 "${name}" 已存在`);
+          return;
+        }
+        cfg.saveRuleset(name, content, false, api.USER_GROUP);
+        ok(`规则集 "${name}" 已添加: ${content}`);
+      } catch (e) {
+        err(e.message);
+        process.exit(1);
+      }
+    });
+
+  ruleCmd
+    .command('edit <name>')
+    .description('编辑规则集内容（打开 $EDITOR，带语法提示和校验）')
+    .action(async (name) => {
+      const running = warnWhistleNotRunning();
+      try {
+        let current = '';
+        if (running) {
+          const data = await api.listRulesets();
+          if (name === 'Default') current = data.defaultRules || '';
+          else {
+            const item = (data.list || []).find((r) => r.name === name);
+            if (!item) {
+              err(`规则集 "${name}" 不存在`);
+              return;
+            }
+            current = item.data || '';
+          }
+        } else {
+          if (name === 'Default') current = api.getOfflineDefaultRules() || '';
+          else {
+            const item = api.loadOfflineRulesets().find((r) => r.name === name);
+            if (!item) {
+              err(`规则集 "${name}" 不存在`);
+              return;
+            }
+            current = item.content || '';
+          }
+        }
+
+        // 打开编辑器，带注释头部和语法校验循环
+        let editText = buildEditContent(current);
+        let parsedRules;
+        while (true) {
+          try {
+            editText = editInEditor(editText, name);
+          } catch (_e) {
+            info('已取消');
+            return;
+          }
+          try {
+            parsedRules = parse(editText);
+            break;
+          } catch (e) {
+            err(e.message);
+            warn('解析失败，请修正后重新保存...');
+          }
+        }
+
+        // 重新格式化回纯规则文本（去掉注释头部）
+        const { format } = require('../rule-editor');
+        const content = format(parsedRules);
+
+        if (content === current.trim()) {
+          info('无改动');
+          return;
+        }
+
+        // 未知 operator 警告（不阻塞）
+        const unknown = findUnknownOperators(parsedRules);
+        if (unknown.length > 0) {
+          warn(
+            `注意：${unknown.length} 个操作符未识别：${unknown.map((u) => u.operator).join(', ')}`
+          );
+          info('保存继续，如需取消请按 Ctrl+C');
+        }
+
+        if (running) await api.addRuleset(name, content);
+        if (name === 'Default') cfg.saveRuleset('default', content, true, '');
+        else {
+          const r = cfg.getRuleset(name);
+          if (r) cfg.saveRuleset(name, content, r.enabled, r.group);
+        }
+        ok(`规则集 "${name}" 已更新（${parsedRules.length} 条规则）`);
+      } catch (e) {
+        err(e.message);
+        process.exit(1);
+      }
+    });
+
+  ruleCmd
+    .command('remove <name>')
+    .description('移除规则集')
+    .action(async (name) => {
+      if (name === 'Default') {
+        err('不能移除默认规则集');
+        return;
+      }
+      const running = warnWhistleNotRunning();
+      try {
+        if (running) {
+          const data = await api.listRulesets();
+          if (!(data.list || []).some((r) => r.name === name)) {
+            err(`规则集 "${name}" 不存在`);
+            return;
+          }
+          const confirmed = await promptConfirm(`删除规则集 "${name}"？(y/N) `);
+          if (!confirmed) {
+            info('已取消');
+            return;
+          }
+          await api.removeRuleset(name);
+        }
+        if (!cfg.getRuleset(name)) {
+          err(`规则集 "${name}" 不存在`);
+          return;
+        }
+        cfg.deleteRuleset(name);
+        ok(`规则集 "${name}" 已移除`);
+      } catch (e) {
+        err(e.message);
+        process.exit(1);
+      }
+    });
+
+  ruleCmd
+    .command('enable <name>')
+    .description('启用规则集')
+    .action(async (name) => {
+      const running = warnWhistleNotRunning();
+      try {
+        if (running) {
+          if (name === 'Default') await api.enableDefault();
+          else {
+            const data = await api.listRulesets();
+            const item = (data.list || []).find((r) => r.name === name);
+            if (!item) {
+              err(`规则集 "${name}" 不存在`);
+              return;
+            }
+            await api.selectRuleset(name, item.data || '');
+          }
+        }
+        const r = cfg.getRuleset(name);
+        if (r) cfg.saveRuleset(name, r.content, true, r.group);
+        ok(`规则集 "${name}" 已启用`);
+      } catch (e) {
+        err(e.message);
+        process.exit(1);
+      }
+    });
+
+  ruleCmd
+    .command('disable <name>')
+    .description('关闭规则集')
+    .action(async (name) => {
+      const running = warnWhistleNotRunning();
+      try {
+        if (running) {
+          if (name === 'Default') await api.disableDefault();
+          else {
+            const data = await api.listRulesets();
+            const item = (data.list || []).find((r) => r.name === name);
+            if (!item) {
+              err(`规则集 "${name}" 不存在`);
+              return;
+            }
+            await api.unselectRuleset(name, item.data || '');
+          }
+        }
+        const r = cfg.getRuleset(name);
+        if (r) cfg.saveRuleset(name, r.content, false, r.group);
+        ok(`规则集 "${name}" 已关闭`);
+      } catch (e) {
+        err(e.message);
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = {
+  registerRule,
+};

package/lib/cli/commands/start.js

@@ -0,0 +1,98 @@
+const { localW2Path, ok, err, info, debug } = require('../helpers');
+const { enableSystemProxy, disableSystemProxy } = require('./proxy');
+
+function registerStart(program) {
+  program
+    .command('start')
+    .description('启动 whistle（自动设置代理和安装证书）')
+    .option('--init', '初始化（安装证书 + 设置代理）')
+    .action(async (opts) => {
+      const { execSync } = require('node:child_process');
+      try {
+        const args = opts.init ? 'start --init' : 'start';
+        execSync(`"${localW2Path}" ${args}`, { stdio: 'inherit' });
+        ok('whistle 已启动');
+
+        try {
+          enableSystemProxy();
+        } catch (e) {
+          err(`开启系统代理失败: ${e.message}`);
+        }
+
+        const upstream = require('../upstream-proxy');
+        const proxies = upstream.loadProxies();
+        if (proxies.length > 0) {
+          info('同步上游代理规则...');
+          try {
+            await upstream.syncToWhistle(require('../rule-api'), proxies);
+            ok(`已同步 ${proxies.length} 个上游代理规则`);
+          } catch (e) {
+            err(`上游代理规则同步失败: ${e.message}`);
+          }
+        }
+
+        const api = require('../rule-api');
+        const rules = api.loadOfflineRulesets();
+        if (rules.length > 0) {
+          info('同步自定义规则...');
+          let count = 0;
+          for (const r of rules) {
+            try {
+              await api.addRuleset(r.name, r.content, r.group);
+              if (r.enabled) await api.selectRuleset(r.name, r.content);
+              count++;
+            } catch (e) {
+              debug('Rule sync skipped (duplicate):', r.name, e.message);
+            }
+          }
+          if (count > 0) ok(`已同步 ${count} 个自定义规则`);
+        }
+      } catch (e) {
+        err(`启动 whistle 失败: ${e.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+function registerStop(program) {
+  program
+    .command('stop')
+    .description('停止 whistle')
+    .action(() => {
+      const { execSync } = require('node:child_process');
+      try {
+        try {
+          disableSystemProxy();
+        } catch (e) {
+          err(`关闭系统代理失败: ${e.message}`);
+        }
+        execSync(`"${localW2Path}" stop`, { stdio: 'inherit' });
+        ok('whistle 已停止');
+      } catch (e) {
+        err(`停止 whistle 失败: ${e.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+function registerW2(program) {
+  program
+    .command('w2')
+    .description('直接执行 w2 命令')
+    .arguments('[args...]')
+    .action((args) => {
+      const { execSync } = require('node:child_process');
+      try {
+        execSync(`"${localW2Path}" ${args.join(' ')}`, { stdio: 'inherit' });
+      } catch (e) {
+        err(`w2 命令执行失败: ${e.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = {
+  registerStart,
+  registerStop,
+  registerW2,
+};

package/lib/cli/commands/status.js

@@ -0,0 +1,50 @@
+const { CONFIG_PATH } = require('../../config');
+const { readConfig, getWhistleStatus, info, ok, title, sep, c } = require('../helpers');
+
+function registerStatus(program) {
+  program
+    .command('status')
+    .description('查看 EasyProxy 状态')
+    .action(() => {
+      const cfg = readConfig();
+      const ws = getWhistleStatus();
+      const interceptOn = cfg.interceptEnabled !== false;
+      const ruleCount = cfg.interceptRules ? Object.keys(cfg.interceptRules).length : 0;
+      title('EasyProxy 状态');
+      sep();
+      info(
+        'Whistle:         ' +
+          (ws.running ? `${c.green}✓ 运行中${c.reset}` : `${c.red}✗ 未运行${c.reset}`) +
+          (ws.port ? `（端口: ${ws.port}）` : '')
+      );
+      info(
+        `加速功能:        ${cfg.enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`}${c.reset}`
+      );
+      info(
+        '拦截规则:        ' +
+          (interceptOn ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`) +
+          c.reset +
+          '（' +
+          ruleCount +
+          ' 个域名）'
+      );
+      info(
+        'SNI 改写:        ' +
+          (cfg.sniRewrite?.enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`) +
+          c.reset
+      );
+      info(`DoH 服务器:      ${cfg.doh ? cfg.doh.host : 'dns.google'}`);
+      info(`Hosts 覆盖:      ${cfg.hosts?.length || 0} 条`);
+      info(`配置文件:        ${CONFIG_PATH}`);
+      sep();
+      info('Web 控制台:      http://local.whistlejs.com/plugin.easy-proxy/');
+      info('常用命令:        easy-proxy start --init  （启动 whistle + 代理 + 证书）');
+      info('                 easy-proxy intercept list  （查看拦截规则）');
+      info('                 easy-proxy proxy on / easy-proxy proxy off  （切换系统代理）');
+      info('                 easy-proxy cert install  （安装证书）');
+    });
+}
+
+module.exports = {
+  registerStatus,
+};

package/lib/cli/helpers.js

@@ -0,0 +1,137 @@
+const { loadConfig, saveConfig } = require('../config');
+const { debug } = require('../debug');
+
+const localW2Path = require.resolve('whistle/bin/whistle.js');
+
+// ---- Config helpers ----
+function readConfig() {
+  return loadConfig(null);
+}
+function writeConfig(config) {
+  saveConfig(null, config);
+}
+
+function ensureSni(config) {
+  if (!config.sniRewrite) config.sniRewrite = { enabled: false, defaultSni: null, sniMap: {} };
+  if (!config.sniRewrite.sniMap) config.sniRewrite.sniMap = {};
+}
+
+// ---- Output helpers ----
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  gray: '\x1b[90m',
+};
+const info = (m) => console.log(`${c.blue}ℹ${c.reset}`, m);
+const ok = (m) => console.log(`${c.green}✔${c.reset}`, m);
+const warn = (m) => console.log(`${c.yellow}⚠${c.reset}`, m);
+const err = (m) => console.error(`${c.red}✖${c.reset}`, m);
+const title = (m) => console.log(c.bold + c.blue + m + c.reset);
+const sep = () => console.log(c.gray + '─'.repeat(40) + c.reset);
+
+// ---- whistle status helper with cache ----
+let _statusCache = null;
+let _statusTs = 0;
+
+function getWhistleStatus() {
+  // 1秒缓存，避免频繁调用 execSync
+  if (Date.now() - _statusTs < 1000 && _statusCache) {
+    return _statusCache;
+  }
+
+  const { execSync } = require('node:child_process');
+  try {
+    const out = execSync(`"${localW2Path}" status 2>&1`, { encoding: 'utf-8' });
+    if (/is running/i.test(out) && !/No running/i.test(out)) {
+      let port = null;
+      const m1 = out.match(/PORT\((\d+)\)/i);
+      if (m1) port = parseInt(m1[1], 10);
+      if (!port) {
+        const m2 = out.match(/127\.0\.0\.1:(\d+)/);
+        if (m2) port = parseInt(m2[1], 10);
+      }
+      _statusCache = { running: true, port: port };
+      _statusTs = Date.now();
+      return _statusCache;
+    }
+  } catch (_e) {
+    /* w2 不存在或返回非 0 */
+  }
+  _statusCache = { running: false, port: null };
+  _statusTs = Date.now();
+  return _statusCache;
+}
+
+function checkWhistleRunning() {
+  const ws = getWhistleStatus();
+  if (!ws.running) {
+    err('whistle 未运行，请先执行 easy-proxy start --init');
+    process.exit(1);
+  }
+}
+
+function warnWhistleNotRunning() {
+  const ws = getWhistleStatus();
+  if (!ws.running) {
+    warn('whistle 未运行，规则仅本地保存，下次启动自动同步');
+  }
+  return ws.running;
+}
+
+// ---- $EDITOR helper ----
+function editInEditor(initialContent, name) {
+  const fs = require('node:fs');
+  const os = require('node:os');
+  const { execSync } = require('node:child_process');
+  const path = require('node:path');
+  const tmpFile = path.join(os.tmpdir(), `easy-proxy-rule-${name}-${Date.now()}.txt`);
+  fs.writeFileSync(tmpFile, initialContent || '', 'utf-8');
+  const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+  try {
+    execSync(`${editor} "${tmpFile}"`, { stdio: 'inherit' });
+    return fs.readFileSync(tmpFile, 'utf-8');
+  } finally {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch (e) {
+      debug('Failed to cleanup temp file:', tmpFile, e.message);
+    }
+  }
+}
+
+// ---- confirm helper ----
+function promptConfirm(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    process.stdin.setEncoding('utf-8');
+    process.stdin.resume();
+    process.stdin.once('data', (data) => {
+      process.stdin.pause();
+      resolve(data.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
+module.exports = {
+  localW2Path,
+  readConfig,
+  writeConfig,
+  ensureSni,
+  c,
+  info,
+  ok,
+  warn,
+  err,
+  title,
+  sep,
+  getWhistleStatus,
+  checkWhistleRunning,
+  warnWhistleNotRunning,
+  editInEditor,
+  promptConfirm,
+  debug,
+};

package/lib/cli/proxy-config.js

@@ -0,0 +1,41 @@
+const { loadConfig, saveConfig } = require('../config');
+const { DEFAULT_BYPASS_DOMAINS } = require('./bypass-domains');
+
+function loadProxyConfig() {
+  try {
+    const config = loadConfig(null);
+    return {
+      bypassDomains: Array.isArray(config.proxyBypassDomains) ? config.proxyBypassDomains : null,
+    };
+  } catch (e) {
+    console.warn('读取代理配置失败:', e.message);
+    return { bypassDomains: null };
+  }
+}
+
+function saveProxyConfig(proxyConfig) {
+  try {
+    const config = loadConfig(null);
+    config.proxyBypassDomains = proxyConfig.bypassDomains;
+    saveConfig(null, config);
+  } catch (e) {
+    console.warn('保存代理配置失败:', e.message);
+  }
+}
+
+function getEffectiveBypass() {
+  const { bypassDomains } = loadProxyConfig();
+  return bypassDomains?.length > 0 ? bypassDomains : DEFAULT_BYPASS_DOMAINS;
+}
+
+function getDefaultBypass() {
+  return DEFAULT_BYPASS_DOMAINS;
+}
+
+module.exports = {
+  DEFAULT_BYPASS_DOMAINS,
+  loadConfig: loadProxyConfig,
+  saveConfig: saveProxyConfig,
+  getEffectiveBypass,
+  getDefaultBypass,
+};