@jonathanleelx/meddle 0.3.1 → 0.4.0-beta.2

package/bin/commands/update.js

@@ -0,0 +1,187 @@
+/**
+ * meddle update - Check for updates and upgrade meddle
+ *
+ * Usage:
+ *   meddle update                    check and upgrade to the latest version
+ *   meddle update --check            only check, print the available version
+ *   meddle update --version <x.y.z>  install a specific version
+ *   meddle update --auto on|off      enable/disable auto-update (default off)
+ *   meddle update status             show install method / versions / auto-update
+ */
+
+const os = require('os')
+const path = require('path')
+const { spawnSync } = require('child_process')
+const { resolveMeddleHome } = require('../lib/meddle-home')
+const output = require('../lib/output')
+const {
+    compareVersions,
+    getLatestVersionNpm,
+    getLatestVersionGithub,
+    getInstallMethod,
+    checkForUpdate,
+    downloadBinaryAsset,
+    getAutoUpdate,
+    setAutoUpdate,
+} = require('../lib/update-check')
+
+const PACKAGE_NAME = '@jonathanleelx/meddle'
+
+const args = process.argv.slice(2)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+const current = require(path.join(__dirname, '../../package.json')).version
+const home = resolveMeddleHome()
+const installMethod = getInstallMethod({ moduleDir: __dirname })
+
+function isNpmInstall() {
+    return installMethod === 'npm'
+}
+
+function showHelp() {
+    output.plain(`
+meddle update - 检查并升级 meddle
+
+用法:
+  meddle update                   检查并升级到最新版本
+  meddle update --check           仅检查，提示可用版本 (有新版本时退出码为 2)
+  meddle update --version <x.y.z> 安装指定版本
+  meddle update --auto on|off     启用/禁用自动更新 (默认关闭)
+  meddle update status            查看安装方式、当前版本和自动更新开关
+  meddle update --help, -h        显示帮助
+`)
+}
+
+async function resolveLatest({ force = false, notify = true } = {}) {
+    const info = await checkForUpdate({
+        home,
+        installMethod,
+        current,
+        force,
+    })
+    if (notify) {
+        if (info.outdated) {
+            output.info(`发现新版本 ${info.latest} (当前 ${info.current})`)
+        } else {
+            output.success(`已是最新版本 (${info.current})`)
+        }
+    }
+    return info
+}
+
+async function installVersion(version) {
+    if (!isNpmInstall()) {
+        const binDir = process.env.MEDDLE_BIN_DIR || path.join(home, 'bin')
+        const destFile = path.join(binDir, os.platform() === 'win32' ? 'meddle.exe' : 'meddle')
+        output.info(`下载 meddle ${version} (${os.platform()}/${os.arch()})...`)
+        try {
+            const result = await downloadBinaryAsset({
+                version,
+                destFile,
+                platform: os.platform(),
+                arch: os.arch(),
+            })
+            output.success(`已安装 meddle ${version} 到 ${result.installed}`)
+            if (result.backup) output.info(`旧版本已备份到 ${result.backup}`)
+            output.info('重启 meddle 后新版本生效')
+        } catch (err) {
+            output.error(`升级失败: ${err && err.message ? err.message : err}`)
+            process.exit(1)
+        }
+        return
+    }
+
+    output.info(`正在通过 npm 升级 ${PACKAGE_NAME}@${version}...`)
+    const child = spawnSync('npm', ['install', '-g', `${PACKAGE_NAME}@${version}`], {
+        stdio: 'inherit',
+        // On Windows `npm` resolves to npm.cmd which Node cannot spawn directly
+        // unless run through a shell (Node >=18.20.2/20.12.2/22.3.0: EINVAL; older: ENOENT).
+        shell: os.platform() === 'win32',
+    })
+    if (child.error) {
+        output.error(`npm 升级失败: ${child.error.message}`)
+        process.exit(1)
+    }
+    if (child.status !== 0) {
+        output.error(`npm 升级失败 (exit ${child.status})`)
+        process.exit(child.status || 1)
+    }
+    output.success(`已升级到 ${PACKAGE_NAME}@${version}`)
+}
+
+async function run() {
+    const flag = args.find((a) => a === '--check' || a === 'status' || a === '--help' || a === '-h')
+    const versionFlagIndex = args.indexOf('--version')
+    const autoFlagIndex = args.indexOf('--auto')
+
+    if (flag === '--help' || flag === '-h') {
+        showHelp()
+        return
+    }
+
+    if (flag === 'status') {
+        const info = await resolveLatest({ notify: false })
+        output.header('Meddle Update Status')
+        output.kv('Install method', installMethod)
+        output.kv('Current', info.current)
+        output.kv('Latest', info.latest)
+        output.kv('Auto-update', getAutoUpdate(home) ? 'on' : 'off')
+        output.info(info.outdated ? '有新版本可用，运行 meddle update 升级' : '已是最新版本')
+        return
+    }
+
+    if (autoFlagIndex >= 0) {
+        const value = args[autoFlagIndex + 1]
+        if (value !== 'on' && value !== 'off') {
+            output.error('--auto 需要 on 或 off')
+            process.exit(1)
+        }
+        setAutoUpdate(home, value === 'on')
+        if (value === 'on' && isNpmInstall()) {
+            output.success('自动更新已启用（npm 安装下仅启动时提示，仍需要运行 meddle update 升级）')
+        } else {
+            output.success(
+                `自动更新已${value === 'on' ? '启用' : '关闭'}${value === 'on' ? '（重启 meddle 后生效）' : ''}`,
+            )
+        }
+        return
+    }
+
+    if (versionFlagIndex >= 0) {
+        const version = args[versionFlagIndex + 1]
+        if (!version) {
+            output.error('--version 需要版本号')
+            process.exit(1)
+        }
+        const currentCompare = (() => {
+            try { return compareVersions(version, current) } catch (_) { return null }
+        })()
+        if (currentCompare === null) {
+            output.error(`无效版本号: ${version}`)
+            process.exit(1)
+        }
+        if (currentCompare <= 0) {
+            output.info(`当前已是 ${current}，无需降级`)
+            return
+        }
+        await installVersion(version)
+        return
+    }
+
+    if (flag === '--check') {
+        const info = await resolveLatest()
+        if (info.outdated) process.exit(2)
+        return
+    }
+
+    // default: check + upgrade
+    const info = await resolveLatest()
+    if (!info.outdated) return
+    await installVersion(info.latest)
+}
+
+run().catch((err) => {
+    output.error(`检查更新失败: ${err && err.message ? err.message : err}`)
+    process.exit(1)
+})

package/bin/index.js

@@ -32,6 +32,7 @@ const commands = {
   'url': './commands/url.js',
   'status': './commands/status.js',
   'version': './commands/version.js',
+  'update': './commands/update.js',
   'session': './commands/session/index.js',
   'mock': './commands/mock/index.js',
   'route': './commands/route/index.js'
@@ -77,6 +78,9 @@ Meddle - 开发代理工具
   meddle status                   查看代理状态
   meddle version                  查看版本信息
   meddle --version, -v            查看版本信息 (快捷别名)
+  meddle update                   检查并升级到最新版本
+  meddle update --check           仅检查更新
+  meddle update --auto on|off     启用/禁用自动更新 (默认关闭)
 
 Session 命令 (多实例隔离，预览功能):
   meddle session create [--name <label>] [--port <port>]

package/bin/lib/update-check.js

@@ -0,0 +1,438 @@
+/**
+ * meddle update-check — version check + update download utilities.
+ *
+ * Pure JS so it runs unmodified in the npm package and in the deno-compiled
+ * binary (bin/ is bundled at compile time). Network is injected via
+ * `fetchImpl` so specs can point at local fixtures without touching the
+ * real npm registry / GitHub.
+ *
+ * Version sources:
+ *   - npm installs  → npm registry (https://registry.npmjs.org/@jonathanleeelx/meddle/latest)
+ *   - binary installs → GitHub releases/latest redirect (same logic as scripts/install-binary.sh)
+ */
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const crypto = require('crypto')
+const { resolveMeddleHome } = require('./meddle-home')
+
+const PACKAGE_NAME = '@jonathanleelx/meddle'
+const REPO = 'JonathanLee-LX/meddle'
+const DEFAULT_NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`
+const DEFAULT_GITHUB_LATEST_URL = `https://github.com/${REPO}/releases/latest`
+const DEFAULT_DOWNLOAD_BASE_URL = `https://github.com/${REPO}/releases/download`
+const DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000
+const DEFAULT_TIMEOUT_MS = 5000
+const DEFAULT_DOWNLOAD_TIMEOUT_MS = 120 * 1000
+
+const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/
+
+/**
+ * Parse a semver-ish string. Returns { major, minor, patch, prerelease } or
+ * null when the input is not a valid version.
+ */
+function parseVersion(value) {
+    if (typeof value !== 'string') return null
+    const m = VERSION_RE.exec(value.trim())
+    if (!m) return null
+    return {
+        major: Number(m[1]),
+        minor: Number(m[2]),
+        patch: Number(m[3]),
+        prerelease: m[4] ? m[4].split('.') : [],
+    }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isValidVersion(value) {
+    return parseVersion(value) !== null
+}
+
+/**
+ * Compare two semver strings. -1 when a < b, 0 when equal, 1 when a > b.
+ * Prereleases sort before their release (0.4.0-beta.1 < 0.4.0).
+ * @throws {Error} when either argument is not a valid version.
+ */
+function compareVersions(a, b) {
+    const va = parseVersion(a)
+    const vb = parseVersion(b)
+    if (!va) throw new Error(`Invalid version: ${a}`)
+    if (!vb) throw new Error(`Invalid version: ${b}`)
+
+    const partsA = [va.major, va.minor, va.patch]
+    const partsB = [vb.major, vb.minor, vb.patch]
+    for (let i = 0; i < 3; i++) {
+        if (partsA[i] !== partsB[i]) return partsA[i] < partsB[i] ? -1 : 1
+    }
+
+    if (va.prerelease.length === 0 && vb.prerelease.length === 0) return 0
+    if (va.prerelease.length === 0) return 1
+    if (vb.prerelease.length === 0) return -1
+
+    const len = Math.max(va.prerelease.length, vb.prerelease.length)
+    for (let i = 0; i < len; i++) {
+        const pa = va.prerelease[i]
+        const pb = vb.prerelease[i]
+        if (pa === undefined) return -1
+        if (pb === undefined) return 1
+        const na = /^\d+$/.test(pa)
+        const nb = /^\d+$/.test(pb)
+        if (na && nb) {
+            if (Number(pa) !== Number(pb)) return Number(pa) < Number(pb) ? -1 : 1
+        } else if (na !== nb) {
+            // numeric identifiers always sort below non-numeric ones
+            return na ? -1 : 1
+        } else if (pa !== pb) {
+            return pa < pb ? -1 : 1
+        }
+    }
+    return 0
+}
+
+/**
+ * Fetch the latest version from the npm registry.
+ * @param {{ fetchImpl?: Function, registryUrl?: string, timeoutMs?: number }} opts
+ * @returns {Promise<string>}
+ */
+async function getLatestVersionNpm({ fetchImpl, registryUrl, timeoutMs } = {}) {
+    const doFetch = fetchImpl || fetch
+    const url = registryUrl || process.env.MEDDLE_NPM_REGISTRY_URL || DEFAULT_NPM_REGISTRY_URL
+    const response = await doFetch(url, { signal: AbortSignal.timeout(timeoutMs || DEFAULT_TIMEOUT_MS) })
+    if (!response.ok) throw new Error(`npm registry responded ${response.status}`)
+    const data = await response.json()
+    const version = data && typeof data.version === 'string' ? data.version : ''
+    if (!isValidVersion(version)) throw new Error(`npm registry returned no valid version`)
+    return version
+}
+
+/**
+ * Fetch the latest version from the GitHub releases/latest redirect.
+ * @param {{ fetchImpl?: Function, latestUrl?: string, timeoutMs?: number }} opts
+ * @returns {Promise<string>}
+ */
+async function getLatestVersionGithub({ fetchImpl, latestUrl, timeoutMs } = {}) {
+    const doFetch = fetchImpl || fetch
+    const url = latestUrl || process.env.MEDDLE_GITHUB_LATEST_URL || DEFAULT_GITHUB_LATEST_URL
+    const response = await doFetch(url, {
+        redirect: 'manual',
+        signal: AbortSignal.timeout(timeoutMs || DEFAULT_TIMEOUT_MS),
+    })
+    if (response.status < 300 || response.status >= 400) {
+        throw new Error(`GitHub latest release did not redirect (${response.status})`)
+    }
+    const location = response.headers.get('location') || ''
+    const match = /\/tag\/(v?[\d][\w.-]*)$/.exec(location)
+    if (!match) throw new Error(`Could not resolve latest release tag`)
+    return match[1].replace(/^v/, '')
+}
+
+/**
+ * Detect how meddle was installed.
+ * npm → the module lives inside a node_modules directory.
+ * binary → deno-compiled binary (bin/ bundled inside the executable).
+ * @param {{ moduleDir: string }} opts
+ * @returns {'npm' | 'binary'}
+ */
+function getInstallMethod({ moduleDir }) {
+    return /[\\/]node_modules[\\/]/.test(moduleDir) ? 'npm' : 'binary'
+}
+
+/**
+ * @param {string} home meddle home directory
+ * @returns {string} path of the update check cache file
+ */
+function updateCachePath(home) {
+    return path.join(home, '.cache', 'update-check.json')
+}
+
+/**
+ * @param {{ home: string, fetchImpl?: Function, installMethod: string, current: string,
+ *           now?: number, ttlMs?: number, force?: boolean,
+ *           registryUrl?: string, latestUrl?: string, timeoutMs?: number }} opts
+ * @returns {Promise<{ current: string, latest: string, outdated: boolean, fromCache: boolean, checkedAt: number }>}
+ */
+async function checkForUpdate(opts) {
+    const {
+        home,
+        installMethod,
+        current,
+        now = Date.now(),
+        ttlMs = DEFAULT_CACHE_TTL_MS,
+        force = false,
+        fetchImpl,
+        registryUrl,
+        latestUrl,
+        timeoutMs,
+    } = opts
+
+    const cacheFile = updateCachePath(home)
+    let cached = null
+    try {
+        cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'))
+    } catch (_) {}
+
+    if (!force && cached && typeof cached.version === 'string' && typeof cached.checkedAt === 'number') {
+        if (now - cached.checkedAt < ttlMs) {
+            return {
+                current,
+                latest: cached.version,
+                outdated: compareVersions(cached.version, current) > 0,
+                fromCache: true,
+                checkedAt: cached.checkedAt,
+            }
+        }
+    }
+
+    const latest = installMethod === 'binary'
+        ? await getLatestVersionGithub({ fetchImpl, latestUrl, timeoutMs })
+        : await getLatestVersionNpm({ fetchImpl, registryUrl, timeoutMs })
+
+    const checkedAt = now
+    try {
+        fs.mkdirSync(path.dirname(cacheFile), { recursive: true })
+        fs.writeFileSync(cacheFile, JSON.stringify({ version: latest, checkedAt }), 'utf8')
+    } catch (_) {}
+
+    return {
+        current,
+        latest,
+        outdated: compareVersions(latest, current) > 0,
+        fromCache: false,
+        checkedAt,
+    }
+}
+
+/**
+ * Map platform/arch to the GitHub release asset name.
+ * @param {{ platform: string, arch: string }} opts
+ * @returns {string}
+ */
+function getAssetName({ platform, arch }) {
+    let osTag
+    switch (platform) {
+        case 'linux': osTag = 'linux'; break
+        case 'darwin': osTag = 'darwin'; break
+        case 'win32': osTag = 'windows'; break
+        default: throw new Error(`unsupported platform: ${platform}`)
+    }
+    let archTag
+    switch (arch) {
+        case 'x64': case 'amd64': archTag = 'x64'; break
+        case 'arm64': case 'aarch64': archTag = 'arm64'; break
+        default: throw new Error(`unsupported arch: ${arch}`)
+    }
+    const ext = platform === 'win32' ? '.exe' : ''
+    return `meddle-${osTag}-${archTag}${ext}`
+}
+
+function sha256Hex(buffer) {
+    return crypto.createHash('sha256').update(buffer).digest('hex')
+}
+
+/**
+ * Download a release binary, verify its SHA256 sidecar and atomically replace
+ * the existing binary. The previous binary is kept as `<destFile>.bak`. When
+ * the final replace fails the backup is restored and a descriptive error is
+ * thrown (Windows commonly fails with EPERM on a running binary).
+ * @param {{ version: string, destFile: string, platform: string, arch: string,
+ *           baseUrl?: string, fetchImpl?: Function, timeoutMs?: number,
+ *           fsImpl?: object }} opts
+ * @returns {Promise<{ installed: string, backup: string, version: string }>}
+ */
+async function downloadBinaryAsset(opts) {
+    const { version, destFile, platform, arch } = opts
+    const baseUrl = opts.baseUrl || process.env.MEDDLE_UPDATE_BASE_URL || DEFAULT_DOWNLOAD_BASE_URL
+    const doFetch = opts.fetchImpl || fetch
+    const fsImpl = opts.fsImpl || fs
+    const payloadTimeout = opts.timeoutMs || DEFAULT_DOWNLOAD_TIMEOUT_MS
+
+    const asset = getAssetName({ platform, arch })
+    const assetUrl = `${baseUrl}/v${version}/${asset}`
+    const shaUrl = `${assetUrl}.sha256`
+
+    // The binary is large (100MB+); the checksum sidecar is tiny. Use a long
+    // timeout for the payload and the regular timeout for the metadata fetch.
+    const [binaryResponse, shaResponse] = await Promise.all([
+        doFetch(assetUrl, { signal: AbortSignal.timeout(payloadTimeout) }),
+        doFetch(shaUrl, { signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS) }),
+    ])
+    if (!binaryResponse.ok) throw new Error(`download failed (${binaryResponse.status})`)
+    if (!shaResponse.ok) throw new Error(`checksum sidecar missing (${shaResponse.status})`)
+
+    const payload = Buffer.from(await binaryResponse.arrayBuffer())
+    const shaText = await shaResponse.text()
+    const expected = shaText.trim().split(/\s+/)[0]
+    if (!/^[0-9a-f]{64}$/i.test(expected)) throw new Error(`invalid checksum sidecar`)
+    if (sha256Hex(payload) !== expected.toLowerCase()) {
+        throw new Error(`checksum mismatch for ${asset}`)
+    }
+
+    const dir = path.dirname(destFile)
+    fsImpl.mkdirSync(dir, { recursive: true })
+
+    const tmpFile = `${destFile}.tmp-${process.pid}`
+    fsImpl.writeFileSync(tmpFile, payload)
+    if (platform !== 'win32') fsImpl.chmodSync(tmpFile, 0o755)
+
+    const backup = `${destFile}.bak`
+    try {
+        if (fsImpl.existsSync(backup)) fsImpl.unlinkSync(backup)
+        if (fsImpl.existsSync(destFile)) fsImpl.renameSync(destFile, backup)
+    } catch (_) {}
+    try {
+        fsImpl.renameSync(tmpFile, destFile)
+    } catch (err) {
+        try {
+            if (fsImpl.existsSync(backup) && !fsImpl.existsSync(destFile)) {
+                fsImpl.renameSync(backup, destFile)
+            }
+        } catch (_) {}
+        try { fsImpl.unlinkSync(tmpFile) } catch (_) {}
+        const hint = process.platform === 'win32'
+            ? 'Windows 下无法替换运行中的 meddle.exe，请先停止 meddle 再运行 meddle update'
+            : '替换二进制失败，请检查文件权限'
+        throw new Error(`${hint}: ${(err && err.code) || (err && err.message) || err}`)
+    }
+
+    return { installed: destFile, backup: fsImpl.existsSync(backup) ? backup : null, version }
+}
+
+/**
+ * Read the auto-update setting. Precedence: MEDDLE_AUTO_UPDATE env var
+ * (when set) → settings.json `autoUpdate` (default false).
+ * @param {string} home
+ * @returns {boolean}
+ */
+function getAutoUpdate(home) {
+    const env = process.env.MEDDLE_AUTO_UPDATE
+    if (env !== undefined && env !== '') {
+        return env === '1' || env.toLowerCase() === 'true'
+    }
+    try {
+        const settings = JSON.parse(fs.readFileSync(path.join(home, 'settings.json'), 'utf8'))
+        return settings.autoUpdate === true
+    } catch (_) {
+        return false
+    }
+}
+
+/**
+ * Persist the auto-update setting into settings.json, preserving other keys.
+ * @param {string} home
+ * @param {boolean} value
+ */
+function setAutoUpdate(home, value) {
+    const settingsPath = path.join(home, 'settings.json')
+    let settings = {}
+    try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+    } catch (_) {}
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) settings = {}
+    settings.autoUpdate = value === true
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true })
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8')
+}
+
+function printUpdateNotice(info) {
+    const channel = process.env.MEDDLE_UPDATE_SILENT ? undefined : console
+    if (!channel) return
+    if (info.autoUpdated) {
+        channel.log(`\n[meddle] 已自动升级到 ${info.latest}（重启 meddle 后生效）`)
+        return
+    }
+    channel.log(
+        `\n[meddle] 发现新版本 ${info.latest}（当前 ${info.current}），运行 "meddle update" 升级`
+    )
+}
+
+/**
+ * Fire-and-forget startup check. Never blocks, never throws, never keeps the
+ * process alive. When auto-update is enabled (binary installs) the new binary
+ * is downloaded and verified on disk — but only when the running executable
+ * actually matches the install dir, otherwise the download would land where it
+ * can never take effect. npm installs only get a notice.
+ * @param {{ home?: string, installMethod?: string, current: string,
+ *           binDir?: string, execPath?: string, delayMs?: number,
+ *           fetchImpl?: Function, onOutdated?: Function }} opts
+ * @returns {void}
+ */
+function resolveRealPath(p) {
+    try { return fs.realpathSync(p) } catch (_) { return path.resolve(p) }
+}
+
+function isSameBinary(a, b) {
+    return resolveRealPath(a) === resolveRealPath(b)
+}
+
+function runAsyncUpdateCheck(opts) {
+    const home = opts.home || resolveMeddleHome()
+    const installMethod = opts.installMethod || getInstallMethod({ moduleDir: __dirname })
+    const binDir = opts.binDir || process.env.MEDDLE_BIN_DIR || path.join(home, 'bin')
+    const delayMs = opts.delayMs === undefined ? 1500 : opts.delayMs
+    const execPath = opts.execPath || process.execPath
+    const exeBase = path.basename(execPath).toLowerCase()
+    const isMeddleExecutable = exeBase === 'meddle' || exeBase === 'meddle.exe'
+
+    const timer = setTimeout(() => {
+        ;(async () => {
+            const info = await checkForUpdate({
+                home,
+                installMethod,
+                current: opts.current,
+                fetchImpl: opts.fetchImpl,
+            })
+            if (!info.outdated) return
+            let finalInfo = info
+            if (getAutoUpdate(home) && installMethod === 'binary') {
+                const destFile = path.join(binDir, os.platform() === 'win32' ? 'meddle.exe' : 'meddle')
+                if (isMeddleExecutable && !isSameBinary(destFile, execPath)) {
+                    finalInfo = {
+                        ...info,
+                        skipAutoUpdate: '安装路径与当前运行路径不一致，跳过自动更新',
+                    }
+                } else {
+                    try {
+                        await downloadBinaryAsset({
+                            version: info.latest,
+                            destFile,
+                            platform: os.platform(),
+                            arch: os.arch(),
+                            baseUrl: opts.baseUrl,
+                            fetchImpl: opts.fetchImpl,
+                        })
+                        finalInfo = { ...info, autoUpdated: true, destFile }
+                    } catch (err) {
+                        finalInfo = { ...info, autoUpdateFailed: err && err.message ? err.message : String(err) }
+                    }
+                }
+            }
+            if (opts.onOutdated) {
+                opts.onOutdated(finalInfo)
+            } else {
+                printUpdateNotice(finalInfo)
+            }
+        })().catch(() => {})
+    }, delayMs)
+
+    if (typeof timer.unref === 'function') timer.unref()
+}
+
+module.exports = {
+    compareVersions,
+    isValidVersion,
+    parseVersion,
+    getLatestVersionNpm,
+    getLatestVersionGithub,
+    getInstallMethod,
+    checkForUpdate,
+    getAssetName,
+    downloadBinaryAsset,
+    getAutoUpdate,
+    setAutoUpdate,
+    runAsyncUpdateCheck,
+    DEFAULT_DOWNLOAD_TIMEOUT_MS,
+}

package/index.js

@@ -21,6 +21,7 @@ const {
     pluginClientIdentity,
 } = require('./dist/core/client-identity')
 const { createApplicationIdentityResolver } = require('./dist/core/application-identity')
+const { runAsyncUpdateCheck } = require('./bin/lib/update-check')
 const {
     authorizeProxyClient,
     buildRemoteAccessConfig,
@@ -493,6 +494,8 @@ localWSServer.on('connection', (client, req) => {})
 
 // ===== 启动 =====
 ;(async () => {
+    // 非阻塞异步版本检查：不会阻塞启动，失败静默，1.5s 后发起且 timer unref
+    runAsyncUpdateCheck({ current: require('./package.json').version })
     await ensureRootCA()
     await pluginBoot.bootstrapBuiltinPlugins()
     const port = await getFreePort()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jonathanleelx/meddle",
-  "version": "0.3.1",
+  "version": "0.4.0-beta.2",
   "description": "A simple development proxy server with custom routing rules, mock responses, HTTPS interception, and a plugin system",
   "type": "commonjs",
   "main": "index.js",
@@ -20,6 +20,7 @@
     "test:identity": "pnpm run build && node scripts/application-identity-smoke.js",
     "test:e2e": "npm run build:web && npm run build && node tests/e2e/interactions.e2e.cjs",
     "test:e2e:rule-drag": "npm run build:web && npm run build && node tests/e2e/rule-drag.e2e.cjs",
+    "test:e2e:update": "node tests/e2e/update.e2e.cjs",
     "test:watch": "vitest",
     "test:refactor": "npm run build && node -c index.js && npm test",
     "bench:logs": "node scripts/log-performance-benchmark.js",