mihomo-cli 1.0.0-alpha.1

package/src/config.js

@@ -0,0 +1,328 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const IS_PKG = typeof process.pkg !== 'undefined';
+
+let PROJECT_ROOT;
+if (IS_PKG) {
+  PROJECT_ROOT = path.dirname(process.execPath);
+} else {
+  PROJECT_ROOT = path.join(__dirname, '..');
+}
+
+function getUserDataDir() {
+  if (process.env.MIHOMO_CLI_DIR) {
+    return process.env.MIHOMO_CLI_DIR;
+  }
+  return path.join(os.homedir(), '.mihomo-cli');
+}
+
+const USER_DATA_DIR = getUserDataDir();
+
+const DIRS = {
+  root: PROJECT_ROOT,
+  core: path.join(USER_DATA_DIR, 'core'),
+  subs: path.join(USER_DATA_DIR, 'subs'),
+  logs: path.join(USER_DATA_DIR, 'logs'),
+  data: path.join(USER_DATA_DIR, 'data'),
+  runtime: path.join(USER_DATA_DIR, '.runtime'),
+};
+
+const PATHS = {
+  root: DIRS.root,
+  data: DIRS.data,
+  userDataDir: USER_DATA_DIR,
+  mihomoBinary: path.join(DIRS.core, 'mihomo'),
+  settingsFile: path.join(USER_DATA_DIR, 'settings.json'),
+  configFile: path.join(DIRS.runtime, 'config.yaml'),
+  logFile: path.join(DIRS.logs, 'mihomo.log'),
+  pidFile: path.join(DIRS.runtime, 'pid'),
+};
+
+function ensureDirs() {
+  Object.values(DIRS).forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+  });
+}
+
+function maskUrl(url) {
+  if (!url) return url;
+  try {
+    const parsed = new URL(url);
+    const tokenKeys = ['token', 'key', 'secret', 'pass', 'password', 'auth', 'access_token', 'api_key'];
+    for (const key of tokenKeys) {
+      if (parsed.searchParams.has(key)) {
+        parsed.searchParams.set(key, '***');
+      }
+    }
+    if (parsed.username) {
+      parsed.username = '***';
+    }
+    if (parsed.password) {
+      parsed.password = '***';
+    }
+    return parsed.toString();
+  } catch {
+    if (url.length > 30) {
+      return url.slice(0, 15) + '...' + url.slice(-10);
+    }
+    return url;
+  }
+}
+
+function readSettings() {
+  ensureDirs();
+  if (fs.existsSync(PATHS.settingsFile)) {
+    try {
+      const content = fs.readFileSync(PATHS.settingsFile, 'utf8');
+      return JSON.parse(content);
+    } catch (e) {
+      return {};
+    }
+  }
+  return {};
+}
+
+function writeSettings(settings) {
+  ensureDirs();
+  const existing = readSettings();
+  const merged = { ...existing, ...settings };
+  fs.writeFileSync(PATHS.settingsFile, JSON.stringify(merged, null, 2), { mode: 0o600 });
+  return merged;
+}
+
+function getSubscriptions() {
+  const settings = readSettings();
+  return settings.subscriptions || [];
+}
+
+function addSubscription(url, name) {
+  if (name === undefined) name = 'default';
+  const settings = readSettings();
+  const subs = settings.subscriptions || [];
+  const existingIndex = subs.findIndex(s => s.name === name);
+  if (existingIndex >= 0) {
+    subs[existingIndex] = { name, url, updatedAt: new Date().toISOString() };
+  } else {
+    subs.push({ name, url, updatedAt: null });
+  }
+  writeSettings({ subscriptions: subs });
+}
+
+function getSubRawConfigPath(subName) {
+  return path.join(DIRS.subs, subName + '.yaml');
+}
+
+function saveSubRawConfig(subName, content) {
+  ensureDirs();
+  const filePath = getSubRawConfigPath(subName);
+  fs.writeFileSync(filePath, content, { mode: 0o600 });
+}
+
+function readSubRawConfig(subName) {
+  const filePath = getSubRawConfigPath(subName);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function hasKernel() {
+  return fs.existsSync(PATHS.mihomoBinary);
+}
+
+function getKernelVersion() {
+  if (!hasKernel()) {
+    return null;
+  }
+  try {
+    const output = execSync('"' + PATHS.mihomoBinary + '" -v 2>&1 || true', {
+      encoding: 'utf8',
+    }).trim();
+    if (output) {
+      const match = output.match(/v?[\d]+\.[\d]+\.[\d]+/);
+      if (match) {
+        return match[0];
+      }
+      return output;
+    }
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+const TUN_CONFIG = {
+  tun: {
+    enable: true,
+    stack: 'mixed',
+    'dns-hijack': ['0.0.0.0:53'],
+    'auto-route': true,
+    'auto-detect-interface': true,
+    'strict-route': true,
+  },
+  ipv6: false,
+};
+
+const BASE_CONFIG = {
+  'log-level': 'warning',
+  'geodata-mode': true,
+  'geo-update-interval': 24,
+  'geox-url': {
+    geoip: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geoip-lite.dat',
+    geosite: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite-lite.dat',
+    mmdb: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/country-lite.mmdb',
+    asn: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/GeoLite2-ASN.mmdb',
+  },
+};
+
+function buildConfig(subRawContent, mode) {
+  const yaml = require('js-yaml');
+
+  let baseConfig;
+  try {
+    baseConfig = yaml.load(subRawContent);
+  } catch (e) {
+    try {
+      baseConfig = JSON.parse(subRawContent);
+    } catch (e2) {
+      throw new Error('订阅内容格式错误，无法解析为 YAML 或 JSON');
+    }
+  }
+
+  if (!baseConfig) {
+    throw new Error('订阅内容为空');
+  }
+
+  const merged = { ...baseConfig, ...BASE_CONFIG };
+
+  if (mode === 'tun') {
+    // 合并 TUN 配置
+    merged.tun = TUN_CONFIG.tun;
+    merged.ipv6 = TUN_CONFIG.ipv6;
+
+    // 确保 DNS 配置与 TUN 模式兼容（保留订阅的 DNS 服务器）
+    merged.dns = merged.dns || {};
+    merged.dns.enable = true;
+    merged.dns['enhanced-mode'] = 'fake-ip';
+    merged.dns['fake-ip-range'] = merged.dns['fake-ip-range'] || '198.18.0.1/16';
+  }
+
+  return merged;
+}
+
+function writeMihomoConfig(configObj) {
+  const yaml = require('js-yaml');
+  ensureDirs();
+  const content = yaml.dump(configObj, {
+    indent: 2,
+    lineWidth: -1,
+    noCompat: true,
+  });
+  fs.writeFileSync(PATHS.configFile, content, { mode: 0o600 });
+}
+
+function hasConfig() {
+  return fs.existsSync(PATHS.configFile);
+}
+
+function getConfigInfo() {
+  if (!hasConfig()) {
+    return null;
+  }
+
+  try {
+    const yaml = require('js-yaml');
+    const content = fs.readFileSync(PATHS.configFile, 'utf8');
+    const cfg = yaml.load(content);
+
+    if (!cfg) return null;
+
+    return {
+      proxies: cfg.proxies ? cfg.proxies.length : 0,
+      proxyGroups: cfg['proxy-groups'] ? cfg['proxy-groups'].length : 0,
+      mode: cfg.mode || 'rule',
+      port: cfg.port || cfg['mixed-port'] || '未知',
+      tun: cfg.tun ? cfg.tun.enable : false,
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+function rmrf(dir) {
+  if (!fs.existsSync(dir)) return;
+  const stat = fs.statSync(dir);
+  if (stat.isDirectory()) {
+    const files = fs.readdirSync(dir);
+    for (const f of files) {
+      rmrf(path.join(dir, f));
+    }
+    fs.rmdirSync(dir);
+  } else {
+    fs.unlinkSync(dir);
+  }
+}
+
+function resetUserData(options) {
+  if (options === undefined) options = {};
+  const keepKernel = options.keepKernel !== false;
+
+  const itemsToRemove = [
+    PATHS.settingsFile,
+    DIRS.subs,
+    DIRS.logs,
+    DIRS.data,
+    DIRS.runtime,
+  ];
+
+  if (!keepKernel) {
+    itemsToRemove.push(DIRS.core);
+  }
+
+  let removedCount = 0;
+  for (const item of itemsToRemove) {
+    if (fs.existsSync(item)) {
+      try {
+        rmrf(item);
+        removedCount++;
+      } catch (e) {
+        console.warn('  警告: 无法删除 ' + item + ': ' + e.message);
+      }
+    }
+  }
+
+  ensureDirs();
+  return removedCount;
+}
+
+module.exports = {
+  PATHS,
+  DIRS,
+  PROJECT_ROOT,
+  USER_DATA_DIR,
+  IS_PKG,
+  ensureDirs,
+  readSettings,
+  writeSettings,
+  maskUrl,
+  getSubscriptions,
+  addSubscription,
+  getSubRawConfigPath,
+  saveSubRawConfig,
+  readSubRawConfig,
+  hasKernel,
+  getKernelVersion,
+  TUN_CONFIG,
+  BASE_CONFIG,
+  buildConfig,
+  writeMihomoConfig,
+  hasConfig,
+  getConfigInfo,
+  resetUserData,
+  rmrf,
+};

package/src/kernel.js

@@ -0,0 +1,297 @@
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { compareVersions } = require('compare-versions');
+const config = require('./config');
+
+const GITHUB_REPO = 'MetaCubeX/mihomo';
+const GEODATA_REPO = 'MetaCubeX/meta-rules-dat';
+
+const GITHUB_DOWNLOAD_MIRROR = 'https://gh-proxy.org/';
+
+function withMirror(url) {
+  if (GITHUB_DOWNLOAD_MIRROR && url.startsWith('https://github.com/')) {
+    return GITHUB_DOWNLOAD_MIRROR + url;
+  }
+  return url;
+}
+
+const HTTP_CLIENT = axios.create({
+  timeout: 120000,
+  headers: { 'User-Agent': 'mihomo-cli' },
+  maxContentLength: 200 * 1024 * 1024,
+});
+
+const GEODATA_FILES = [
+  { name: 'geosite-lite.dat', targetName: 'geosite.dat', url: 'https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite-lite.dat' },
+  { name: 'country-lite.mmdb', targetName: 'Country.mmdb', url: 'https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/country-lite.mmdb' },
+];
+
+function getArch() {
+  const arch = process.arch;
+  if (arch === 'arm64') return 'arm64';
+  if (arch === 'x64') return 'amd64';
+  return arch;
+}
+
+function findMatchingAsset(assets, platform, arch) {
+  const prefix = 'mihomo-' + platform + '-' + arch;
+  const matchingAssets = assets.filter(a => {
+    return (a.name.startsWith(prefix) && a.name.endsWith('.gz')) ||
+           (a.name.startsWith(prefix + '-') && a.name.endsWith('.gz'));
+  });
+
+  if (matchingAssets.length === 0) {
+    return null;
+  }
+
+  if (matchingAssets.length === 1) {
+    return matchingAssets[0];
+  }
+
+  const standardAsset = matchingAssets.find(a => {
+    const nameWithoutGz = a.name.slice(0, -3);
+    const parts = nameWithoutGz.split('-');
+    const lastPart = parts[parts.length - 1];
+    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes('-go');
+  });
+
+  if (standardAsset) {
+    return standardAsset;
+  }
+
+  return matchingAssets[0];
+}
+
+async function getLatestRelease(repo) {
+  const url = 'https://api.github.com/repos/' + repo + '/releases';
+  const response = await HTTP_CLIENT.get(url);
+
+  const releases = response.data;
+
+  if (!Array.isArray(releases) || releases.length === 0) {
+    throw new Error('无法获取版本信息');
+  }
+
+  const stableReleases = releases.filter(r =>
+    !r.prerelease &&
+    !r.tag_name.toLowerCase().includes('alpha') &&
+    !r.tag_name.toLowerCase().includes('beta') &&
+    !r.tag_name.toLowerCase().includes('prerelease')
+  );
+
+  if (stableReleases.length > 0) {
+    return stableReleases[0];
+  }
+
+  return releases[0];
+}
+
+async function downloadFile(url, destPath, progressCallback) {
+  if (progressCallback) {
+    progressCallback('下载 ' + path.basename(destPath));
+  }
+
+  const response = await HTTP_CLIENT({
+    method: 'get',
+    url: url,
+    responseType: 'stream',
+    timeout: 180000,
+  });
+
+  const writer = fs.createWriteStream(destPath);
+  response.data.pipe(writer);
+
+  await new Promise((resolve, reject) => {
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+  });
+
+  return destPath;
+}
+
+async function downloadGeodata(progressCallback) {
+  config.ensureDirs();
+  const dataDir = config.DIRS.data;
+
+  const results = [];
+  for (const file of GEODATA_FILES) {
+    const destPath = path.join(dataDir, file.name);
+    const targetPath = file.targetName ? path.join(dataDir, file.targetName) : destPath;
+    try {
+      await downloadFile(file.url, destPath, progressCallback);
+
+      if (file.targetName && destPath !== targetPath) {
+        if (fs.existsSync(targetPath)) {
+          fs.unlinkSync(targetPath);
+        }
+        fs.renameSync(destPath, targetPath);
+        results.push({ name: file.targetName, success: true });
+      } else {
+        results.push({ name: file.name, success: true });
+      }
+    } catch (e) {
+      results.push({ name: file.name, success: false, error: e.message });
+    }
+  }
+
+  return results;
+}
+
+async function checkUpdate() {
+  const currentVersion = config.getKernelVersion();
+  const latest = await getLatestRelease(GITHUB_REPO);
+  const latestVersion = latest.tag_name;
+
+  let needsUpdate = false;
+  let currentDisplay = currentVersion || '未安装';
+
+  if (!currentVersion) {
+    needsUpdate = true;
+  } else {
+    try {
+      needsUpdate = compareVersions(latestVersion.replace(/^v/, ''), currentVersion.replace(/^v/, '')) > 0;
+    } catch (e) {
+      needsUpdate = latestVersion !== currentVersion;
+    }
+  }
+
+  return {
+    current: currentDisplay,
+    latest: latestVersion,
+    needsUpdate,
+    assets: latest.assets,
+    htmlUrl: latest.html_url,
+  };
+}
+
+function findBinaryInDir(dir) {
+  const files = fs.readdirSync(dir);
+
+  for (const f of files) {
+    const fullPath = path.join(dir, f);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      const found = findBinaryInDir(fullPath);
+      if (found) return found;
+      continue;
+    }
+
+    if (f === 'mihomo') {
+      return fullPath;
+    }
+    if (f.includes('mihomo') && !f.endsWith('.gz')) {
+      return fullPath;
+    }
+  }
+
+  return null;
+}
+
+async function downloadKernel(progressCallback) {
+  config.ensureDirs();
+
+  const latest = await getLatestRelease(GITHUB_REPO);
+  const arch = getArch();
+  const platform = 'darwin';
+
+  const asset = findMatchingAsset(latest.assets, platform, arch);
+
+  if (!asset) {
+    const available = latest.assets.map(a => a.name).join(', ');
+    let hint = '';
+    if (available) {
+      hint = '\n  可用版本: ' + available;
+    }
+    throw new Error('未找到匹配的内核文件\n  平台: ' + platform + ', 架构: ' + arch + hint);
+  }
+
+  const downloadUrl = withMirror(asset.browser_download_url);
+  const tempPath = path.join(config.DIRS.core, asset.name);
+
+  if (progressCallback) {
+    const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
+    progressCallback('下载内核: ' + asset.name + ' (' + sizeMB + ' MB)');
+  }
+
+  const response = await HTTP_CLIENT({
+    method: 'get',
+    url: downloadUrl,
+    responseType: 'stream',
+    timeout: 180000,
+  });
+
+  const writer = fs.createWriteStream(tempPath);
+  response.data.pipe(writer);
+
+  await new Promise((resolve, reject) => {
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+  });
+
+  if (progressCallback) {
+    progressCallback('解压内核...');
+  }
+
+  const extractPath = config.DIRS.core;
+  let extractedBinary = null;
+
+  try {
+    if (tempPath.endsWith('.tar.gz') || tempPath.endsWith('.tgz')) {
+      execSync('tar -xzf "' + tempPath + '" -C "' + extractPath + '"', {
+        stdio: ['pipe', 'pipe', 'inherit'],
+      });
+    } else if (tempPath.endsWith('.gz')) {
+      const baseName = path.basename(tempPath, '.gz');
+      const outputPath = path.join(extractPath, baseName);
+      execSync('gzip -dc "' + tempPath + '" > "' + outputPath + '"', {
+        stdio: ['pipe', 'pipe', 'inherit'],
+      });
+      extractedBinary = outputPath;
+    }
+  } catch (e) {
+    try { fs.unlinkSync(tempPath); } catch {}
+    throw new Error('解压失败: ' + e.message);
+  }
+
+  const foundBinary = extractedBinary || findBinaryInDir(extractPath);
+
+  if (!foundBinary) {
+    try { fs.unlinkSync(tempPath); } catch {}
+    throw new Error('解压后未找到可执行文件');
+  }
+
+  const targetPath = config.PATHS.mihomoBinary;
+
+  if (foundBinary !== targetPath) {
+    if (fs.existsSync(targetPath)) {
+      fs.chmodSync(targetPath, 0o755);
+      try {
+        fs.unlinkSync(targetPath);
+      } catch {}
+    }
+    fs.renameSync(foundBinary, targetPath);
+  }
+
+  fs.chmodSync(targetPath, 0o755);
+
+  try {
+    fs.unlinkSync(tempPath);
+  } catch (e) {}
+
+  return {
+    version: latest.tag_name,
+    path: targetPath,
+  };
+}
+
+module.exports = {
+  getArch,
+  getLatestRelease,
+  findMatchingAsset,
+  checkUpdate,
+  downloadKernel,
+  downloadGeodata,
+};