@gengjiawen/os-init 1.17.0 → 1.18.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.18.0](https://github.com/gengjiawen/os-init/compare/v1.17.0...v1.18.0) (2026-03-13)
+
+
+### Features
+
+* add clash config generator ([b9f46b4](https://github.com/gengjiawen/os-init/commit/b9f46b4366955a0cfb8c6337a9956d3461d673f6))
+* add optional mihomo downloader ([632d502](https://github.com/gengjiawen/os-init/commit/632d50234c2a6119f989dd39feb89b3d4d542514))
+* print pm2 command for clash setup ([c4a3a81](https://github.com/gengjiawen/os-init/commit/c4a3a81eaa992816d1d54fdd019e7479bccbc2fb))
+
+
+### Bug Fixes
+
+* stabilize mihomo download test across platforms ([#28](https://github.com/gengjiawen/os-init/issues/28)) ([006b748](https://github.com/gengjiawen/os-init/commit/006b7481fe5c0e60628547bb22bfa357c8502bea))
+
 ## [1.17.0](https://github.com/gengjiawen/os-init/compare/v1.16.0...v1.17.0) (2026-03-07)
 
 

package/README.md

@@ -72,6 +72,26 @@ Example:
 pnpx @gengjiawen/os-init set-fish
 ```
 
+### Generate Mihomo Config
+
+```bash
+pnpx @gengjiawen/os-init set-clash
+pnpx @gengjiawen/os-init set-clash --download
+pnpx @gengjiawen/os-init set-clash --target ~/mihomo/config.yml
+```
+
+Generates a Mihomo `config.yml` from the built-in template. This command will:
+
+- Write `./config.yml` in the current directory by default
+- Download the Mihomo binary to the config directory when `--download` is set
+- Support a custom output path with `-t, --target <path>`
+
+After generating the config, you can keep Mihomo running with pm2:
+
+```bash
+pm2 start mihomo --name mihomo -- -f /absolute/path/to/config.yml && pm2 save
+```
+
 ---
 
 ### Configure Claude Code

package/bin/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const { Command } = require('commander')
+const path = require('path')
 const {
   writeClaudeConfig,
   installDeps,
@@ -15,11 +16,17 @@ const {
   writeRaycastConfig,
   setupDevEnvironment,
   setupAndroidEnvironment,
+  writeMihomoConfig,
+  downloadMihomoBinary,
 } = require('../build')
 const { appendFishImportScript } = require('../build/fish-shell-utils')
 
 const program = new Command()
 
+function shellEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`
+}
+
 program
   .command('set-cc')
   .description('setup Claude Code')
@@ -255,4 +262,35 @@ program
     }
   })
 
+program
+  .command('set-clash')
+  .description('generate clash/mihomo config.yml in current directory')
+  .option('-t, --target <path>', 'Target path for mihomo config.yml')
+  .option('--download', 'Download Mihomo binary to the config directory')
+  .action(async (options) => {
+    try {
+      const { configPath } = writeMihomoConfig(options.target)
+      const resolvedConfigPath = path.resolve(configPath)
+      let mihomoCommand = 'mihomo'
+
+      if (options.download) {
+        const { binaryPath, downloadUrl, version } = await downloadMihomoBinary(
+          path.dirname(resolvedConfigPath)
+        )
+        mihomoCommand = path.resolve(binaryPath)
+        console.log(`Mihomo download URL: ${downloadUrl}`)
+        console.log(`Mihomo version: ${version}`)
+        console.log(`Mihomo binary downloaded to: ${binaryPath}`)
+      }
+
+      const pm2Command = `pm2 start ${shellEscape(mihomoCommand)} --name mihomo -- -f ${shellEscape(resolvedConfigPath)} && pm2 save`
+      console.log(`Clash config written to: ${configPath}`)
+      console.log('Run Mihomo with pm2:')
+      console.log(`  ${pm2Command}`)
+    } catch (err) {
+      console.error('Failed to generate Clash config:', err.message)
+      process.exit(1)
+    }
+  })
+
 program.parse(process.argv)

package/build/index.d.ts

@@ -8,3 +8,4 @@ export { writeOpencodeConfig, installOpencodeDeps } from './opencode';
 export { writeAllAgentsConfig, installAllAgentsDeps } from './all-agents';
 export { setupDevEnvironment } from './dev-setup';
 export { setupAndroidEnvironment } from './android-setup';
+export { writeMihomoConfig, downloadMihomoBinary } from './mihomo';

package/build/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupAndroidEnvironment = exports.setupDevEnvironment = exports.installAllAgentsDeps = exports.writeAllAgentsConfig = exports.installOpencodeDeps = exports.writeOpencodeConfig = exports.installGeminiDeps = exports.writeGeminiConfig = exports.installCodexDeps = exports.writeCodexConfig = exports.installDeps = exports.writeClaudeConfig = void 0;
+exports.downloadMihomoBinary = exports.writeMihomoConfig = exports.setupAndroidEnvironment = exports.setupDevEnvironment = exports.installAllAgentsDeps = exports.writeAllAgentsConfig = exports.installOpencodeDeps = exports.writeOpencodeConfig = exports.installGeminiDeps = exports.writeGeminiConfig = exports.installCodexDeps = exports.writeCodexConfig = exports.installDeps = exports.writeClaudeConfig = void 0;
 exports.writeRaycastConfig = writeRaycastConfig;
 const fs = require("fs");
 const path = require("path");
@@ -57,3 +57,6 @@ var dev_setup_1 = require("./dev-setup");
 Object.defineProperty(exports, "setupDevEnvironment", { enumerable: true, get: function () { return dev_setup_1.setupDevEnvironment; } });
 var android_setup_1 = require("./android-setup");
 Object.defineProperty(exports, "setupAndroidEnvironment", { enumerable: true, get: function () { return android_setup_1.setupAndroidEnvironment; } });
+var mihomo_1 = require("./mihomo");
+Object.defineProperty(exports, "writeMihomoConfig", { enumerable: true, get: function () { return mihomo_1.writeMihomoConfig; } });
+Object.defineProperty(exports, "downloadMihomoBinary", { enumerable: true, get: function () { return mihomo_1.downloadMihomoBinary; } });

package/build/mihomo.d.ts

@@ -0,0 +1,8 @@
+export declare function downloadMihomoBinary(targetDir: string): Promise<{
+    binaryPath: string;
+    downloadUrl: string;
+    version: string;
+}>;
+export declare function writeMihomoConfig(targetPath?: string): {
+    configPath: string;
+};

package/build/mihomo.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadMihomoBinary = downloadMihomoBinary;
+exports.writeMihomoConfig = writeMihomoConfig;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const zlib_1 = require("zlib");
+const unzip_url_1 = require("@gengjiawen/unzip-url");
+const utils_1 = require("./utils");
+const MIHOMO_CONFIG_TEMPLATE = `mixed-port: 7890
+mode: rule
+log-level: info
+dns:
+  enable: true
+  ipv6: false
+  default-nameserver:
+    - 1.1.1.1
+    - 223.5.5.5
+    - 119.29.29.29
+sniffer:
+  enable: true
+  sniffing:
+    - tls
+    - http
+tun:
+  enable: true
+  stack: system
+  auto-route: true
+  auto-redirect: true
+  auto-detect-interface: true
+proxies:
+  - name: socks5-proxy
+    type: socks5
+    server: your.ip
+    port: 6153
+proxy-groups:
+  - name: PROXY
+    type: select
+    proxies:
+      - socks5-proxy
+rules:
+  - IP-CIDR,127.0.0.0/8,DIRECT
+  - IP-CIDR,10.0.0.0/8,DIRECT
+  - IP-CIDR,172.16.0.0/12,DIRECT
+  - IP-CIDR,192.168.0.0/16,DIRECT
+  - IP-CIDR,169.254.0.0/16,DIRECT
+  - IP-CIDR,100.64.0.0/10,DIRECT
+  - IP-CIDR6,fc00::/7,DIRECT
+  - IP-CIDR6,fe80::/10,DIRECT
+  - DOMAIN-SUFFIX,local,DIRECT
+  - DOMAIN-SUFFIX,cn,DIRECT
+  - GEOIP,CN,DIRECT
+  - MATCH,PROXY
+`;
+const MIHOMO_LATEST_RELEASE_API_URL = 'https://api.github.com/repos/MetaCubeX/mihomo/releases/latest';
+function getMihomoBinaryFilename(platform = process.platform) {
+    return platform === 'win32' ? 'mihomo.exe' : 'mihomo';
+}
+function getMihomoPlatformToken(platform = process.platform) {
+    switch (platform) {
+        case 'linux':
+            return 'linux';
+        case 'darwin':
+            return 'darwin';
+        case 'win32':
+            return 'windows';
+        default:
+            throw new Error(`Unsupported platform for Mihomo download: ${platform}`);
+    }
+}
+function getMihomoArchTokens(arch = process.arch) {
+    switch (arch) {
+        case 'x64':
+            return ['amd64'];
+        case 'arm64':
+            return ['arm64-v8', 'arm64'];
+        case 'arm':
+            return ['armv7', 'arm'];
+        case 'ia32':
+            return ['386'];
+        default:
+            throw new Error(`Unsupported architecture for Mihomo download: ${arch}`);
+    }
+}
+function getMihomoCpuLevelTokens(platform = process.platform, arch = process.arch) {
+    if (platform !== 'linux' && platform !== 'darwin') {
+        return [];
+    }
+    if (arch !== 'x64') {
+        return [];
+    }
+    return ['v3', 'v2', 'v1'];
+}
+function findMihomoAsset(assets, platform = process.platform, arch = process.arch) {
+    const platformToken = getMihomoPlatformToken(platform);
+    const archTokens = getMihomoArchTokens(arch);
+    const cpuLevelTokens = getMihomoCpuLevelTokens(platform, arch);
+    const extension = platform === 'win32' ? '.zip' : '.gz';
+    const candidates = assets.filter((asset) => asset.name.startsWith(`mihomo-${platformToken}-`) &&
+        asset.name.endsWith(extension));
+    const sortCandidates = (left, right) => {
+        const leftHasGoTag = left.name.includes('-go');
+        const rightHasGoTag = right.name.includes('-go');
+        if (leftHasGoTag !== rightHasGoTag) {
+            return leftHasGoTag ? 1 : -1;
+        }
+        const leftCompatible = left.name.includes('compatible');
+        const rightCompatible = right.name.includes('compatible');
+        if (leftCompatible !== rightCompatible) {
+            return leftCompatible ? 1 : -1;
+        }
+        return left.name.localeCompare(right.name);
+    };
+    for (const archToken of archTokens) {
+        const archMatches = candidates.filter((asset) => asset.name.includes(`-${archToken}-`));
+        if (archMatches.length === 0) {
+            continue;
+        }
+        for (const cpuLevelToken of cpuLevelTokens) {
+            const cpuMatches = archMatches
+                .filter((asset) => asset.name.includes(`-${cpuLevelToken}-`))
+                .sort(sortCandidates);
+            if (cpuMatches.length > 0) {
+                return cpuMatches[0];
+            }
+        }
+        const fallbackMatches = archMatches.sort(sortCandidates);
+        if (fallbackMatches.length > 0) {
+            return fallbackMatches[0];
+        }
+    }
+    throw new Error(`No Mihomo binary found for platform ${platform} and architecture ${arch}.`);
+}
+function findFileRecursively(rootDir, matcher) {
+    const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = findFileRecursively(fullPath, matcher);
+            if (nested)
+                return nested;
+            continue;
+        }
+        if (matcher.test(entry.name)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+async function fetchMihomoLatestRelease() {
+    const response = await fetch(MIHOMO_LATEST_RELEASE_API_URL, {
+        headers: {
+            Accept: 'application/vnd.github+json',
+            'User-Agent': '@gengjiawen/os-init',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch Mihomo release metadata: ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+}
+async function downloadMihomoBinary(targetDir) {
+    (0, utils_1.ensureDir)(targetDir);
+    const release = await fetchMihomoLatestRelease();
+    const asset = findMihomoAsset(release.assets);
+    const binaryPath = path.join(targetDir, getMihomoBinaryFilename());
+    if (process.platform === 'win32') {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-mihomo-'));
+        try {
+            await (0, unzip_url_1.unzip)(asset.browser_download_url, tempDir);
+            const extractedBinary = findFileRecursively(tempDir, /^mihomo.*\.exe$/i);
+            if (!extractedBinary) {
+                throw new Error(`Mihomo executable was not found in asset ${asset.name}.`);
+            }
+            fs.copyFileSync(extractedBinary, binaryPath);
+        }
+        finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+    else {
+        const response = await fetch(asset.browser_download_url, {
+            headers: {
+                Accept: 'application/octet-stream',
+                'User-Agent': '@gengjiawen/os-init',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download Mihomo binary: ${response.status} ${response.statusText}`);
+        }
+        const compressedBinary = Buffer.from(await response.arrayBuffer());
+        fs.writeFileSync(binaryPath, (0, zlib_1.gunzipSync)(compressedBinary));
+        fs.chmodSync(binaryPath, 0o755);
+    }
+    return {
+        binaryPath,
+        downloadUrl: asset.browser_download_url,
+        version: release.tag_name,
+    };
+}
+function writeMihomoConfig(targetPath) {
+    const configPath = targetPath || path.join(process.cwd(), 'config.yml');
+    (0, utils_1.ensureDir)(path.dirname(configPath));
+    fs.writeFileSync(configPath, MIHOMO_CONFIG_TEMPLATE);
+    return { configPath };
+}

package/libs/index.ts

@@ -66,3 +66,6 @@ export { setupDevEnvironment } from './dev-setup'
 
 // Re-export android-setup functionality
 export { setupAndroidEnvironment } from './android-setup'
+
+// Re-export mihomo functionality
+export { writeMihomoConfig, downloadMihomoBinary } from './mihomo'

package/libs/mihomo.test.ts

@@ -0,0 +1,293 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { gzipSync } from 'zlib'
+
+jest.mock('execa', () => ({
+  execa: jest.fn(),
+}))
+
+jest.mock('@gengjiawen/unzip-url', () => ({
+  unzip: jest.fn(),
+}))
+
+import { unzip } from '@gengjiawen/unzip-url'
+import { downloadMihomoBinary, writeMihomoConfig } from './mihomo'
+
+describe('writeMihomoConfig', () => {
+  let tempHome: string
+  let tempCwd: string
+  let homedirSpy: jest.SpiedFunction<typeof os.homedir>
+  let cwdSpy: jest.SpiedFunction<typeof process.cwd>
+  let originalPlatformDescriptor: PropertyDescriptor | undefined
+  let originalArchDescriptor: PropertyDescriptor | undefined
+  let originalFetch: typeof global.fetch | undefined
+  let originalAppData: string | undefined
+  const unzipMock = unzip as jest.MockedFunction<typeof unzip>
+
+  function setProcessRuntime(
+    platform: NodeJS.Platform,
+    arch: NodeJS.Architecture
+  ): void {
+    Object.defineProperty(process, 'platform', {
+      configurable: true,
+      value: platform,
+    })
+    Object.defineProperty(process, 'arch', {
+      configurable: true,
+      value: arch,
+    })
+  }
+
+  beforeEach(() => {
+    tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-mihomo-'))
+    tempCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-mihomo-cwd-'))
+    homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome)
+    cwdSpy = jest.spyOn(process, 'cwd').mockReturnValue(tempCwd)
+    originalPlatformDescriptor = Object.getOwnPropertyDescriptor(
+      process,
+      'platform'
+    )
+    originalArchDescriptor = Object.getOwnPropertyDescriptor(process, 'arch')
+    originalFetch = global.fetch
+    originalAppData = process.env.APPDATA
+    process.env.APPDATA = path.join(tempHome, 'AppData', 'Roaming')
+    unzipMock.mockReset()
+  })
+
+  afterEach(() => {
+    homedirSpy.mockRestore()
+    cwdSpy.mockRestore()
+    if (originalAppData === undefined) {
+      delete process.env.APPDATA
+    } else {
+      process.env.APPDATA = originalAppData
+    }
+    if (originalPlatformDescriptor) {
+      Object.defineProperty(process, 'platform', originalPlatformDescriptor)
+    }
+    if (originalArchDescriptor) {
+      Object.defineProperty(process, 'arch', originalArchDescriptor)
+    }
+    if (originalFetch === undefined) {
+      global.fetch = undefined as unknown as typeof global.fetch
+    } else {
+      global.fetch = originalFetch
+    }
+    fs.rmSync(tempHome, { recursive: true, force: true })
+    fs.rmSync(tempCwd, { recursive: true, force: true })
+  })
+
+  test('writes default mihomo config.yml to current directory', () => {
+    const result = writeMihomoConfig()
+
+    expect(result.configPath).toBe(path.join(tempCwd, 'config.yml'))
+
+    const content = fs.readFileSync(result.configPath, 'utf8')
+    expect(content).toContain('mixed-port: 7890')
+    expect(content).toContain('mode: rule')
+    expect(content).toContain('type: socks5')
+    expect(content).toContain('name: socks5-proxy')
+    expect(content).toContain('server: your.ip')
+    expect(content).toContain('port: 6153')
+    expect(content).toContain('proxy-groups:')
+    expect(content).toContain('- name: PROXY')
+    expect(content).toContain('- socks5-proxy')
+    expect(content).toContain('auto-detect-interface: true')
+    expect(content).toContain('- IP-CIDR,127.0.0.0/8,DIRECT')
+    expect(content).toContain('- IP-CIDR,10.0.0.0/8,DIRECT')
+    expect(content).toContain('- IP-CIDR,172.16.0.0/12,DIRECT')
+    expect(content).toContain('- IP-CIDR,192.168.0.0/16,DIRECT')
+    expect(content).toContain('- IP-CIDR,169.254.0.0/16,DIRECT')
+    expect(content).toContain('- IP-CIDR,100.64.0.0/10,DIRECT')
+    expect(content).toContain('- IP-CIDR6,fc00::/7,DIRECT')
+    expect(content).toContain('- IP-CIDR6,fe80::/10,DIRECT')
+    expect(content).toContain('- DOMAIN-SUFFIX,local,DIRECT')
+    expect(content).toContain('- DOMAIN-SUFFIX,cn,DIRECT')
+    expect(content).toContain('- GEOIP,CN,DIRECT')
+    expect(content).toContain('- MATCH,PROXY')
+  })
+
+  test('writes mihomo config to custom target path', () => {
+    const customPath = path.join(tempHome, 'custom', 'mihomo.yml')
+    const result = writeMihomoConfig(customPath)
+
+    expect(result.configPath).toBe(customPath)
+    expect(fs.existsSync(customPath)).toBe(true)
+  })
+
+  test('downloads linux mihomo binary and prefers v3 without go tag', async () => {
+    const targetDir = path.join(tempCwd, 'mihomo-bin')
+    const fetchMock = jest.fn()
+    const binaryContent = Buffer.from('#!/bin/sh\necho mihomo\n', 'utf8')
+
+    setProcessRuntime('linux', 'x64')
+
+    fetchMock
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          tag_name: 'v1.19.13',
+          assets: [
+            {
+              name: 'mihomo-linux-amd64-v1-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v1-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-linux-amd64-v2-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v2-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-linux-amd64-v3-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v3-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-linux-amd64-v3-go120-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v3-go120-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-linux-amd64-v3-go123-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v3-go123-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-linux-amd64-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v1.19.13.gz',
+            },
+          ],
+        }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        arrayBuffer: async () => gzipSync(binaryContent),
+      })
+
+    global.fetch = fetchMock as unknown as typeof global.fetch
+
+    const result = await downloadMihomoBinary(targetDir)
+
+    expect(result.version).toBe('v1.19.13')
+    expect(result.binaryPath).toBe(path.join(targetDir, 'mihomo'))
+    expect(result.downloadUrl).toBe(
+      'https://example.com/mihomo-linux-amd64-v3-v1.19.13.gz'
+    )
+    expect(fs.existsSync(result.binaryPath)).toBe(true)
+    expect(fs.readFileSync(result.binaryPath)).toEqual(binaryContent)
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+
+  test('downloads darwin mihomo binary and selects darwin asset', async () => {
+    const targetDir = path.join(tempCwd, 'mihomo-darwin-bin')
+    const fetchMock = jest.fn()
+    const binaryContent = Buffer.from('#!/bin/sh\necho mihomo-darwin\n', 'utf8')
+
+    setProcessRuntime('darwin', 'x64')
+
+    fetchMock
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          tag_name: 'v1.19.13',
+          assets: [
+            {
+              name: 'mihomo-linux-amd64-v3-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-linux-amd64-v3-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-darwin-amd64-v3-go123-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-darwin-amd64-v3-go123-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-darwin-amd64-v2-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-darwin-amd64-v2-v1.19.13.gz',
+            },
+            {
+              name: 'mihomo-darwin-amd64-v3-v1.19.13.gz',
+              browser_download_url:
+                'https://example.com/mihomo-darwin-amd64-v3-v1.19.13.gz',
+            },
+          ],
+        }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        arrayBuffer: async () => gzipSync(binaryContent),
+      })
+
+    global.fetch = fetchMock as unknown as typeof global.fetch
+
+    const result = await downloadMihomoBinary(targetDir)
+
+    expect(result.version).toBe('v1.19.13')
+    expect(result.binaryPath).toBe(path.join(targetDir, 'mihomo'))
+    expect(result.downloadUrl).toBe(
+      'https://example.com/mihomo-darwin-amd64-v3-v1.19.13.gz'
+    )
+    expect(fs.existsSync(result.binaryPath)).toBe(true)
+    expect(fs.readFileSync(result.binaryPath)).toEqual(binaryContent)
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+
+  test('downloads windows mihomo binary and extracts zip asset', async () => {
+    const targetDir = path.join(tempCwd, 'mihomo-windows-bin')
+    const fetchMock = jest.fn()
+    const binaryContent = Buffer.from('windows-mihomo', 'utf8')
+
+    setProcessRuntime('win32', 'x64')
+
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        tag_name: 'v1.19.13',
+        assets: [
+          {
+            name: 'mihomo-linux-amd64-v3-v1.19.13.gz',
+            browser_download_url:
+              'https://example.com/mihomo-linux-amd64-v3-v1.19.13.gz',
+          },
+          {
+            name: 'mihomo-windows-amd64-go123-v1.19.13.zip',
+            browser_download_url:
+              'https://example.com/mihomo-windows-amd64-go123-v1.19.13.zip',
+          },
+          {
+            name: 'mihomo-windows-amd64-v1.19.13.zip',
+            browser_download_url:
+              'https://example.com/mihomo-windows-amd64-v1.19.13.zip',
+          },
+        ],
+      }),
+    })
+
+    unzipMock.mockImplementation(async (_url, destination) => {
+      const nestedDir = path.join(destination, 'nested')
+      fs.mkdirSync(nestedDir, { recursive: true })
+      fs.writeFileSync(path.join(nestedDir, 'mihomo.exe'), binaryContent)
+    })
+
+    global.fetch = fetchMock as unknown as typeof global.fetch
+
+    const result = await downloadMihomoBinary(targetDir)
+
+    expect(result.version).toBe('v1.19.13')
+    expect(result.binaryPath).toBe(path.join(targetDir, 'mihomo.exe'))
+    expect(result.downloadUrl).toBe(
+      'https://example.com/mihomo-windows-amd64-v1.19.13.zip'
+    )
+    expect(fs.existsSync(result.binaryPath)).toBe(true)
+    expect(fs.readFileSync(result.binaryPath)).toEqual(binaryContent)
+    expect(unzipMock).toHaveBeenCalledWith(
+      'https://example.com/mihomo-windows-amd64-v1.19.13.zip',
+      expect.any(String)
+    )
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
+})

package/libs/mihomo.ts

@@ -0,0 +1,280 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { gunzipSync } from 'zlib'
+import { unzip } from '@gengjiawen/unzip-url'
+import { ensureDir } from './utils'
+
+const MIHOMO_CONFIG_TEMPLATE = `mixed-port: 7890
+mode: rule
+log-level: info
+dns:
+  enable: true
+  ipv6: false
+  default-nameserver:
+    - 1.1.1.1
+    - 223.5.5.5
+    - 119.29.29.29
+sniffer:
+  enable: true
+  sniffing:
+    - tls
+    - http
+tun:
+  enable: true
+  stack: system
+  auto-route: true
+  auto-redirect: true
+  auto-detect-interface: true
+proxies:
+  - name: socks5-proxy
+    type: socks5
+    server: your.ip
+    port: 6153
+proxy-groups:
+  - name: PROXY
+    type: select
+    proxies:
+      - socks5-proxy
+rules:
+  - IP-CIDR,127.0.0.0/8,DIRECT
+  - IP-CIDR,10.0.0.0/8,DIRECT
+  - IP-CIDR,172.16.0.0/12,DIRECT
+  - IP-CIDR,192.168.0.0/16,DIRECT
+  - IP-CIDR,169.254.0.0/16,DIRECT
+  - IP-CIDR,100.64.0.0/10,DIRECT
+  - IP-CIDR6,fc00::/7,DIRECT
+  - IP-CIDR6,fe80::/10,DIRECT
+  - DOMAIN-SUFFIX,local,DIRECT
+  - DOMAIN-SUFFIX,cn,DIRECT
+  - GEOIP,CN,DIRECT
+  - MATCH,PROXY
+`
+
+const MIHOMO_LATEST_RELEASE_API_URL =
+  'https://api.github.com/repos/MetaCubeX/mihomo/releases/latest'
+
+interface MihomoReleaseAsset {
+  name: string
+  browser_download_url: string
+}
+
+interface MihomoRelease {
+  tag_name: string
+  assets: MihomoReleaseAsset[]
+}
+
+function getMihomoBinaryFilename(platform = process.platform): string {
+  return platform === 'win32' ? 'mihomo.exe' : 'mihomo'
+}
+
+function getMihomoPlatformToken(platform = process.platform): string {
+  switch (platform) {
+    case 'linux':
+      return 'linux'
+    case 'darwin':
+      return 'darwin'
+    case 'win32':
+      return 'windows'
+    default:
+      throw new Error(`Unsupported platform for Mihomo download: ${platform}`)
+  }
+}
+
+function getMihomoArchTokens(arch = process.arch): string[] {
+  switch (arch) {
+    case 'x64':
+      return ['amd64']
+    case 'arm64':
+      return ['arm64-v8', 'arm64']
+    case 'arm':
+      return ['armv7', 'arm']
+    case 'ia32':
+      return ['386']
+    default:
+      throw new Error(`Unsupported architecture for Mihomo download: ${arch}`)
+  }
+}
+
+function getMihomoCpuLevelTokens(
+  platform = process.platform,
+  arch = process.arch
+): string[] {
+  if (platform !== 'linux' && platform !== 'darwin') {
+    return []
+  }
+
+  if (arch !== 'x64') {
+    return []
+  }
+
+  return ['v3', 'v2', 'v1']
+}
+
+function findMihomoAsset(
+  assets: MihomoReleaseAsset[],
+  platform = process.platform,
+  arch = process.arch
+): MihomoReleaseAsset {
+  const platformToken = getMihomoPlatformToken(platform)
+  const archTokens = getMihomoArchTokens(arch)
+  const cpuLevelTokens = getMihomoCpuLevelTokens(platform, arch)
+  const extension = platform === 'win32' ? '.zip' : '.gz'
+
+  const candidates = assets.filter(
+    (asset) =>
+      asset.name.startsWith(`mihomo-${platformToken}-`) &&
+      asset.name.endsWith(extension)
+  )
+
+  const sortCandidates = (
+    left: MihomoReleaseAsset,
+    right: MihomoReleaseAsset
+  ): number => {
+    const leftHasGoTag = left.name.includes('-go')
+    const rightHasGoTag = right.name.includes('-go')
+
+    if (leftHasGoTag !== rightHasGoTag) {
+      return leftHasGoTag ? 1 : -1
+    }
+
+    const leftCompatible = left.name.includes('compatible')
+    const rightCompatible = right.name.includes('compatible')
+
+    if (leftCompatible !== rightCompatible) {
+      return leftCompatible ? 1 : -1
+    }
+
+    return left.name.localeCompare(right.name)
+  }
+
+  for (const archToken of archTokens) {
+    const archMatches = candidates.filter((asset) =>
+      asset.name.includes(`-${archToken}-`)
+    )
+
+    if (archMatches.length === 0) {
+      continue
+    }
+
+    for (const cpuLevelToken of cpuLevelTokens) {
+      const cpuMatches = archMatches
+        .filter((asset) => asset.name.includes(`-${cpuLevelToken}-`))
+        .sort(sortCandidates)
+
+      if (cpuMatches.length > 0) {
+        return cpuMatches[0]
+      }
+    }
+
+    const fallbackMatches = archMatches.sort(sortCandidates)
+
+    if (fallbackMatches.length > 0) {
+      return fallbackMatches[0]
+    }
+  }
+
+  throw new Error(
+    `No Mihomo binary found for platform ${platform} and architecture ${arch}.`
+  )
+}
+
+function findFileRecursively(rootDir: string, matcher: RegExp): string | null {
+  const entries = fs.readdirSync(rootDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const fullPath = path.join(rootDir, entry.name)
+
+    if (entry.isDirectory()) {
+      const nested = findFileRecursively(fullPath, matcher)
+      if (nested) return nested
+      continue
+    }
+
+    if (matcher.test(entry.name)) {
+      return fullPath
+    }
+  }
+
+  return null
+}
+
+async function fetchMihomoLatestRelease(): Promise<MihomoRelease> {
+  const response = await fetch(MIHOMO_LATEST_RELEASE_API_URL, {
+    headers: {
+      Accept: 'application/vnd.github+json',
+      'User-Agent': '@gengjiawen/os-init',
+    },
+  })
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch Mihomo release metadata: ${response.status} ${response.statusText}`
+    )
+  }
+
+  return (await response.json()) as MihomoRelease
+}
+
+export async function downloadMihomoBinary(targetDir: string): Promise<{
+  binaryPath: string
+  downloadUrl: string
+  version: string
+}> {
+  ensureDir(targetDir)
+
+  const release = await fetchMihomoLatestRelease()
+  const asset = findMihomoAsset(release.assets)
+  const binaryPath = path.join(targetDir, getMihomoBinaryFilename())
+
+  if (process.platform === 'win32') {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-mihomo-'))
+
+    try {
+      await unzip(asset.browser_download_url, tempDir)
+      const extractedBinary = findFileRecursively(tempDir, /^mihomo.*\.exe$/i)
+
+      if (!extractedBinary) {
+        throw new Error(
+          `Mihomo executable was not found in asset ${asset.name}.`
+        )
+      }
+
+      fs.copyFileSync(extractedBinary, binaryPath)
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  } else {
+    const response = await fetch(asset.browser_download_url, {
+      headers: {
+        Accept: 'application/octet-stream',
+        'User-Agent': '@gengjiawen/os-init',
+      },
+    })
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download Mihomo binary: ${response.status} ${response.statusText}`
+      )
+    }
+
+    const compressedBinary = Buffer.from(await response.arrayBuffer())
+    fs.writeFileSync(binaryPath, gunzipSync(compressedBinary))
+    fs.chmodSync(binaryPath, 0o755)
+  }
+
+  return {
+    binaryPath,
+    downloadUrl: asset.browser_download_url,
+    version: release.tag_name,
+  }
+}
+
+/** Write Mihomo config.yml */
+export function writeMihomoConfig(targetPath?: string): { configPath: string } {
+  const configPath = targetPath || path.join(process.cwd(), 'config.yml')
+  ensureDir(path.dirname(configPath))
+  fs.writeFileSync(configPath, MIHOMO_CONFIG_TEMPLATE)
+
+  return { configPath }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gengjiawen/os-init",
   "private": false,
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "",
   "main": "index.js",
   "bin": {