bridge-update-server 1.0.0

package/.github/workflows/publish.yaml

@@ -0,0 +1,86 @@
+name: Publish to npm and create GitHub Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to publish, e.g. 1.2.3"
+        required: true
+        type: string
+      prerelease:
+        description: "Mark GitHub Release as prerelease"
+        required: true
+        type: boolean
+        default: false
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Upgrade npm
+        run: npm i -g npm@latest
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Validate version
+        run: |
+          VERSION="${{ inputs.version }}"
+          if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$ ]]; then
+            echo "Invalid semver: $VERSION"
+            exit 1
+          fi
+
+      - name: Check version does not already exist on npm
+        run: |
+          PKG_NAME=$(node -p "require('./package.json').name")
+          VERSION="${{ inputs.version }}"
+          if npm view "${PKG_NAME}@${VERSION}" version >/dev/null 2>&1; then
+            echo "Version ${PKG_NAME}@${VERSION} already exists on npm"
+            exit 1
+          fi
+
+      - name: Update package version locally
+        run: npm version "${{ inputs.version }}" --no-git-tag-version
+
+      - name: Show package info
+        run: |
+          node -e "const p=require('./package.json'); console.log('Publishing:', p.name, p.version)"
+
+      - name: Build
+        run: npm run build --if-present
+
+      - name: Publish to npm
+        run: npm publish --provenance
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          VERSION="${{ inputs.version }}"
+          TAG="v$VERSION"
+
+          EXTRA_ARGS=""
+          if [ "${{ inputs.prerelease }}" = "true" ]; then
+            EXTRA_ARGS="--prerelease"
+          fi
+
+          gh release create "$TAG" \
+            --target "${{ github.sha }}" \
+            --title "$TAG" \
+            --generate-notes \
+            $EXTRA_ARGS

package/.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

package/bin/bridge-updater.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import {startServer} from '../src/server.js';
+
+const args = process.argv.slice(2);
+
+function getArg(name, defaultValue) {
+	const idx = args.indexOf(name);
+	if (idx === -1 || idx + 1 >= args.length) {
+		return defaultValue;
+	}
+	return args[idx + 1];
+}
+
+if (args.includes('--help') || args.includes('-h')) {
+	console.log([
+		'',
+		'bridge-updater - Bridge App Update Server',
+		'',
+		'用法: bridge-updater [options]',
+		'',
+		'选项:',
+		'  --port <number>       HTTP 端口 (默认: 51145)',
+		'  --mdns-host <string>  mDNS 广播的 host 覆盖值',
+		'  --mdns-port <number>  mDNS 广播的 port 覆盖值',
+		'  --mdns-path <string>  API 路径前缀 (默认: "")',
+		'  --help, -h            显示帮助信息',
+		''
+	].join('\n'));
+	process.exit(0);
+}
+
+const port = parseInt(getArg('--port', '51145'), 10);
+const mdnsHost = getArg('--mdns-host', '') || '';
+const mdnsPort = parseInt(getArg('--mdns-port', '0'), 10) || 0;
+const mdnsPath = (getArg('--mdns-path', '') || '').replace(/^\/+/, '').replace(/\/+$/, '');
+const normalizedPath = mdnsPath ? '/' + mdnsPath : '';
+
+startServer({port, mdnsHost, mdnsPort, mdnsPath: normalizedPath});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "bridge-update-server",
+  "version": "1.0.0",
+  "description": "Bridge App Update Server",
+  "type": "module",
+  "bin": {
+    "bridge-updater": "./bin/bridge-updater.js"
+  },
+  "main": "src/server.js",
+  "scripts": {
+    "start": "node bin/bridge-updater.js"
+  },
+  "repository": {
+    "url": "git+https://github.com/NXY666/bridge-update-server.git",
+    "branch": "master"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@homebridge/ciao": "^1.3.5",
+    "bonjour-service": "^1.3.0",
+    "express": "^5.2.1"
+  }
+}

package/public/index.html

@@ -0,0 +1,147 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Bridge 下载</title>
+	<style>
+		* {
+			box-sizing: border-box;
+			margin: 0;
+			padding: 0;
+		}
+
+		body {
+			font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			min-height: 100vh;
+			padding: 24px;
+			background: #F0F2F5;
+		}
+
+		.card {
+			width: 100%;
+			max-width: 400px;
+			padding: 32px 24px 24px;
+			border-radius: 12px;
+			background: #FFF;
+			box-shadow: 0 2px 12px rgba(0, 0, 0, .08);
+		}
+
+		h1 {
+			font-size: 1.6rem;
+			font-weight: 700;
+			margin-bottom: 6px;
+		}
+
+		.version-info {
+			font-size: 0.85rem;
+			color: #888;
+		}
+
+		.version-info span {
+			margin-right: 12px;
+		}
+
+		#buttons {
+			display: flex;
+			flex-direction: column;
+			margin-top: 34px;
+			gap: 18px;
+		}
+
+		.btn {
+			font-size: 0.95rem;
+			font-weight: 500;
+			display: block;
+			width: 100%;
+			padding: 13px;
+			cursor: pointer;
+			text-align: center;
+			text-decoration: none;
+			color: #FFF;
+			border: none;
+			border-radius: 8px;
+		}
+
+		.btn-cache {
+			background: #1976D2;
+		}
+
+		.btn-github {
+			background: #2E7D32;
+		}
+
+		.status {
+			font-size: 0.9rem;
+			color: #999;
+		}
+
+		.status.error {
+			color: #C62828;
+		}
+
+		#sha256 {
+			font-size: 0.75rem;
+			margin-top: 18px;
+			word-break: break-all;
+			color: #AAA;
+		}
+	</style>
+</head>
+<body>
+	<div class="card">
+		<h1>Bridge</h1>
+		<div class="version-info" id="version-info">
+			<span class="status" id="status-text">正在获取版本信息…</span>
+		</div>
+		<div id="buttons" style="display: none;">
+			<a id="btn-cache" class="btn btn-cache">本地下载</a>
+			<a id="btn-github" class="btn btn-github" target="_blank" rel="noopener">GitHub 下载</a>
+		</div>
+		<div id="sha256"></div>
+	</div>
+	<script>
+		const base = window.location.pathname.replace(/[^/]*$/, '');
+		fetch(base + 'version')
+		.then(r => r.json())
+		.then(res => {
+			if (!res.state) {
+				document.getElementById('status-text').textContent = '版本信息不可用：' + res.message;
+				document.getElementById('status-text').className = 'status error';
+				return;
+			}
+
+			const {versionName, versionCode, downUrl, sha256} = res.data;
+
+			const versionInfo = document.getElementById('version-info');
+			versionInfo.innerHTML =
+				'<span>版本 ' + versionName + ' (' + versionCode + ')</span>';
+
+			const btnCache = document.getElementById('btn-cache');
+			const btnGithub = document.getElementById('btn-github');
+
+			if (downUrl.local) {
+				btnCache.href = base + 'download';
+			} else {
+				btnCache.removeAttribute('href');
+				btnCache.classList.add('btn-disabled');
+			}
+
+			btnGithub.href = downUrl.github;
+
+			if (sha256) {
+				document.getElementById('sha256').textContent = 'SHA-256: ' + sha256;
+			}
+
+			document.getElementById('buttons').style.display = '';
+		})
+		.catch(() => {
+			document.getElementById('status-text').textContent = '无法连接到服务器';
+			document.getElementById('status-text').className = 'status error';
+		});
+	</script>
+</body>
+</html>

package/scan.js

@@ -0,0 +1,395 @@
+// mdns-scan.js
+// 用法: node mdns-scan.js
+// 说明: 监听本地 mDNS 流量并主动做 DNS-SD 枚举（IPv4）
+// 需要 Node.js 18+（建议用最新 LTS）
+
+import dgram from "node:dgram";
+import os from "node:os";
+
+const MDNS_ADDR = '224.0.0.251';
+const MDNS_PORT = 5353;
+
+const TYPE = {
+	A: 1,
+	PTR: 12,
+	TXT: 16,
+	AAAA: 28,
+	SRV: 33,
+	ANY: 255
+};
+
+const CLASS_IN = 1;
+
+const knownServiceTypes = new Set();
+const queriedNames = new Set();
+
+function labelsToName(name) {
+	return name.endsWith('.') ? name : `${name}.`;
+}
+
+function encodeName(name) {
+	const fqdn = labelsToName(name);
+	const parts = fqdn.split('.').filter(Boolean);
+	const out = [];
+	for (const p of parts) {
+		const b = Buffer.from(p, 'utf8');
+		if (b.length > 63) {
+			throw new Error(`label too long: ${p}`);
+		}
+		out.push(Buffer.from([b.length]));
+		out.push(b);
+	}
+	out.push(Buffer.from([0]));
+	return Buffer.concat(out);
+}
+
+function buildQueryPacket({id = 0, questions = []}) {
+	// 标准 DNS 头 12 字节
+	const header = Buffer.alloc(12);
+	header.writeUInt16BE(id & 0xffff, 0);     // ID（mDNS 中通常忽略）
+	header.writeUInt16BE(0x0000, 2);          // Flags = query
+	header.writeUInt16BE(questions.length, 4); // QDCOUNT
+	header.writeUInt16BE(0, 6);               // ANCOUNT
+	header.writeUInt16BE(0, 8);               // NSCOUNT
+	header.writeUInt16BE(0, 10);              // ARCOUNT
+
+	const qbufs = [];
+	for (const q of questions) {
+		qbufs.push(encodeName(q.name));
+		const tail = Buffer.alloc(4);
+		tail.writeUInt16BE(q.type, 0);
+		tail.writeUInt16BE(q.class || CLASS_IN, 2);
+		qbufs.push(tail);
+	}
+
+	return Buffer.concat([header, ...qbufs]);
+}
+
+function readName(buf, offset, depth = 0) {
+	if (depth > 20) {
+		throw new Error('DNS name compression too deep');
+	}
+
+	const labels = [];
+	let pos = offset;
+	let consumed = 0;
+	let jumped = false;
+
+	while (true) {
+		if (pos >= buf.length) {
+			throw new Error('readName out of bounds');
+		}
+		const len = buf[pos];
+
+		// pointer: 11xxxxxx xxxxxxxx
+		if ((len & 0xc0) === 0xc0) {
+			if (pos + 1 >= buf.length) {
+				throw new Error('bad compression pointer');
+			}
+			const ptr = ((len & 0x3f) << 8) | buf[pos + 1];
+			if (!jumped) {
+				consumed += 2;
+			}
+			const rec = readName(buf, ptr, depth + 1);
+			labels.push(rec.name.replace(/\.$/, ''));
+			pos += 2;
+			jumped = true;
+			break;
+		}
+
+		if (len === 0) {
+			if (!jumped) {
+				consumed += 1;
+			}
+			pos += 1;
+			break;
+		}
+
+		const start = pos + 1;
+		const end = start + len;
+		if (end > buf.length) {
+			throw new Error('label out of bounds');
+		}
+
+		labels.push(buf.slice(start, end).toString('utf8'));
+		pos = end;
+		if (!jumped) {
+			consumed += 1 + len;
+		}
+	}
+
+	return {
+		name: labels.filter(Boolean).join('.') + '.',
+		bytes: consumed
+	};
+}
+
+function parseTXT(rdata) {
+	const out = [];
+	let i = 0;
+	while (i < rdata.length) {
+		const n = rdata[i];
+		i += 1;
+		if (i + n > rdata.length) {
+			break;
+		}
+		out.push(rdata.slice(i, i + n).toString('utf8'));
+		i += n;
+	}
+	return out;
+}
+
+function parseIPv6(buf) {
+	const parts = [];
+	for (let i = 0; i < 16; i += 2) {
+		parts.push(buf.readUInt16BE(i).toString(16));
+	}
+	return parts.join(':').replace(/\b:?(?:0:){2,}/, '::');
+}
+
+function parseRRData(type, rdata, fullBuf, rdataOffset) {
+	try {
+		switch (type) {
+			case TYPE.A:
+				if (rdata.length !== 4) {
+					return {raw: rdata.toString('hex')};
+				}
+				return {address: `${rdata[0]}.${rdata[1]}.${rdata[2]}.${rdata[3]}`};
+
+			case TYPE.AAAA:
+				if (rdata.length !== 16) {
+					return {raw: rdata.toString('hex')};
+				}
+				return {address: parseIPv6(rdata)};
+
+			case TYPE.PTR: {
+				const n = readName(fullBuf, rdataOffset);
+				return {ptrdname: n.name};
+			}
+
+			case TYPE.SRV: {
+				if (rdata.length < 6) {
+					return {raw: rdata.toString('hex')};
+				}
+				const priority = rdata.readUInt16BE(0);
+				const weight = rdata.readUInt16BE(2);
+				const port = rdata.readUInt16BE(4);
+				const target = readName(fullBuf, rdataOffset + 6).name;
+				return {priority, weight, port, target};
+			}
+
+			case TYPE.TXT:
+				return {txt: parseTXT(rdata)};
+
+			default:
+				return {raw: rdata.toString('hex')};
+		}
+	} catch (e) {
+		return {parseError: String(e.message || e), raw: rdata.toString('hex')};
+	}
+}
+
+function parsePacket(buf) {
+	if (buf.length < 12) {
+		throw new Error('packet too short');
+	}
+
+	const header = {
+		id: buf.readUInt16BE(0),
+		flags: buf.readUInt16BE(2),
+		qd: buf.readUInt16BE(4),
+		an: buf.readUInt16BE(6),
+		ns: buf.readUInt16BE(8),
+		ar: buf.readUInt16BE(10)
+	};
+
+	let off = 12;
+
+	const questions = [];
+	for (let i = 0; i < header.qd; i++) {
+		const qn = readName(buf, off);
+		off += qn.bytes;
+		if (off + 4 > buf.length) {
+			throw new Error('question tail out of bounds');
+		}
+		const qtype = buf.readUInt16BE(off);
+		const qclass = buf.readUInt16BE(off + 2);
+		off += 4;
+		questions.push({name: qn.name, type: qtype, class: qclass});
+	}
+
+	function parseRRSection(count) {
+		const arr = [];
+		for (let i = 0; i < count; i++) {
+			const nn = readName(buf, off);
+			off += nn.bytes;
+			if (off + 10 > buf.length) {
+				throw new Error('RR header out of bounds');
+			}
+
+			const type = buf.readUInt16BE(off);
+			const rrclass = buf.readUInt16BE(off + 2);
+			const ttl = buf.readUInt32BE(off + 4);
+			const rdlen = buf.readUInt16BE(off + 8);
+			off += 10;
+
+			const rdataOffset = off;
+			const rdataEnd = off + rdlen;
+			if (rdataEnd > buf.length) {
+				throw new Error('RDATA out of bounds');
+			}
+			const rdata = buf.slice(rdataOffset, rdataEnd);
+
+			const data = parseRRData(type, rdata, buf, rdataOffset);
+			off = rdataEnd;
+
+			arr.push({
+				name: nn.name,
+				type,
+				class: rrclass & 0x7fff,
+				cacheFlush: Boolean(rrclass & 0x8000),
+				ttl,
+				data
+			});
+		}
+		return arr;
+	}
+
+	const answers = parseRRSection(header.an);
+	const authorities = parseRRSection(header.ns);
+	const additionals = parseRRSection(header.ar);
+
+	return {header, questions, answers, authorities, additionals};
+}
+
+function rrTypeName(t) {
+	return Object.entries(TYPE).find(([, v]) => v === t)?.[0] || `TYPE${t}`;
+}
+
+function logRR(prefix, rr) {
+	const base = `${prefix} ${rr.name} ${rrTypeName(rr.type)} ttl=${rr.ttl}`;
+	const d = rr.data;
+
+	if (d.ptrdname) {
+		console.log(`${base} -> ${d.ptrdname}`);
+	} else if (d.address) {
+		console.log(`${base} -> ${d.address}`);
+	} else if (d.port !== undefined) {
+		console.log(`${base} -> ${d.target}:${d.port} (pri=${d.priority}, w=${d.weight})`);
+	} else if (d.txt) {
+		console.log(`${base} -> TXT ${JSON.stringify(d.txt)}`);
+	} else {
+		console.log(`${base} -> ${JSON.stringify(d)}`);
+	}
+}
+
+function sendPTRQuery(sock, name) {
+	const fqdn = labelsToName(name);
+	if (queriedNames.has(fqdn)) {
+		return;
+	}
+	queriedNames.add(fqdn);
+
+	const packet = buildQueryPacket({
+		questions: [{name: fqdn, type: TYPE.PTR, class: CLASS_IN}]
+	});
+
+	sock.send(packet, MDNS_PORT, MDNS_ADDR, (err) => {
+		if (err) {
+			console.error(`[send query error] ${fqdn}`, err.message);
+		} else {
+			console.log(`\n[QUERY] PTR ${fqdn}`);
+		}
+	});
+}
+
+function getIPv4Interfaces() {
+	const nets = os.networkInterfaces();
+	const out = [];
+	for (const [ifname, addrs] of Object.entries(nets)) {
+		for (const a of addrs || []) {
+			if (a.family === 'IPv4' && !a.internal) {
+				out.push({ifname, address: a.address});
+			}
+		}
+	}
+	return out;
+}
+
+function main() {
+	const sock = dgram.createSocket({type: 'udp4', reuseAddr: true});
+
+	sock.on('error', (err) => {
+		console.error('[socket error]', err);
+	});
+
+	sock.on('message', (msg, rinfo) => {
+		let pkt;
+		try {
+			pkt = parsePacket(msg);
+		} catch (e) {
+			console.error(`[parse error] from ${rinfo.address}:${rinfo.port}:`, e.message);
+			return;
+		}
+
+		const isQuery = (pkt.header.flags & 0x8000) === 0;
+		const qr = isQuery ? 'Q' : 'R';
+		console.log(`\n[${qr}] ${rinfo.address}:${rinfo.port} len=${msg.length} qd=${pkt.header.qd} an=${pkt.header.an} ns=${pkt.header.ns} ar=${pkt.header.ar}`);
+
+		for (const q of pkt.questions) {
+			console.log(`  ? ${q.name} ${rrTypeName(q.type)}`);
+		}
+
+		for (const rr of [...pkt.answers, ...pkt.authorities, ...pkt.additionals]) {
+			logRR('  *', rr);
+
+			// 如果是服务类型枚举返回的 PTR（_services._dns-sd._udp.local -> _http._tcp.local）
+			if (
+				rr.type === TYPE.PTR &&
+				rr.name.toLowerCase() === '_services._dns-sd._udp.local.' &&
+				rr.data?.ptrdname
+			) {
+				const serviceType = rr.data.ptrdname.toLowerCase();
+				if (!knownServiceTypes.has(serviceType)) {
+					knownServiceTypes.add(serviceType);
+					console.log(`    [+] 发现服务类型: ${serviceType}`);
+					// 继续枚举这个服务类型下的实例
+					sendPTRQuery(sock, serviceType);
+				}
+			}
+		}
+	});
+
+	sock.bind(MDNS_PORT, () => {
+		try {
+			sock.addMembership(MDNS_ADDR);
+			sock.setMulticastTTL(255); // mDNS 常用 hop limit/TTL 255
+			sock.setMulticastLoopback(true);
+		} catch (e) {
+			console.error('[multicast setup error]', e.message);
+		}
+
+		const ifs = getIPv4Interfaces();
+		console.log('[mDNS listener started]');
+		console.log(`  bind: 0.0.0.0:${MDNS_PORT}`);
+		console.log(`  multicast: ${MDNS_ADDR}:${MDNS_PORT}`);
+		console.log(`  interfaces: ${ifs.map(i => `${i.ifname}(${i.address})`).join(', ') || '(none)'}`);
+
+		// 先做服务类型枚举（RFC 6763 Section 9）
+		sendPTRQuery(sock, '_services._dns-sd._udp.local');
+
+		// 可选：顺便查询常见服务类型（加快看到结果）
+		setTimeout(() => sendPTRQuery(sock, '_http._tcp.local'), 500);
+		setTimeout(() => sendPTRQuery(sock, '_ipp._tcp.local'), 700);
+		setTimeout(() => sendPTRQuery(sock, '_airplay._tcp.local'), 900);
+		setTimeout(() => sendPTRQuery(sock, '_googlecast._tcp.local'), 1100);
+	});
+
+	process.on('SIGINT', () => {
+		console.log('\n[exit]');
+		try { sock.close(); } catch {}
+		process.exit(0);
+	});
+}
+
+main();

package/src/cache.js

@@ -0,0 +1,171 @@
+import {createReadStream, createWriteStream, existsSync} from 'node:fs';
+import {mkdir, rename, stat, unlink} from 'node:fs/promises';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import {createHash} from 'node:crypto';
+import {pipeline} from 'node:stream/promises';
+import {Readable} from 'node:stream';
+import {getVersionInfo} from './github.js';
+
+const CACHE_DIR = join(tmpdir(), 'bridge-updater', 'apk');
+const APK_FILENAME = 'latest-app.apk';
+let downloading = false;
+
+// 获取已缓存APK的文件路径
+export function getCachedApkPath() {
+	const filePath = join(CACHE_DIR, APK_FILENAME);
+	return existsSync(filePath) ? filePath : null;
+}
+
+// 是否已有APK缓存
+export function hasCachedApk() {
+	return getCachedApkPath() !== null;
+}
+
+// 获取APK文件流
+export function getCachedApkStream() {
+	const filePath = getCachedApkPath();
+	if (!filePath) {
+		return null;
+	}
+	return createReadStream(filePath);
+}
+
+// 获取APK文件大小
+export async function getCachedApkSize() {
+	const filePath = getCachedApkPath();
+	if (!filePath) {
+		return 0;
+	}
+	const s = await stat(filePath);
+	return s.size;
+}
+
+function computeSha256(filePath) {
+	return new Promise((resolve, reject) => {
+		const hash = createHash('sha256');
+		const stream = createReadStream(filePath);
+		stream.on('data', chunk => hash.update(chunk));
+		stream.on('end', () => resolve(hash.digest('hex')));
+		stream.on('error', reject);
+	});
+}
+
+// 验证本地缓存文件的SHA256是否匹配
+export async function verifyCachedApk() {
+	const info = getVersionInfo();
+	const filePath = getCachedApkPath();
+	if (!filePath || !info?.sha256) {
+		return false;
+	}
+	const actual = await computeSha256(filePath);
+	return actual === info.sha256;
+}
+
+async function downloadFromUrl(url, destPath) {
+	const res = await fetch(url, {
+		headers: {'User-Agent': 'bridge-update-server'}
+	});
+	if (!res.ok) {
+		throw new Error('下载失败: ' + res.status);
+	}
+	await mkdir(join(destPath, '..'), {recursive: true});
+	const fileStream = createWriteStream(destPath);
+	await pipeline(Readable.fromWeb(res.body), fileStream);
+}
+
+// 强制重新下载APK并替换本地缓存
+export async function triggerRebuild(discoverPeers) {
+	const info = getVersionInfo();
+	if (!info || downloading) {
+		return;
+	}
+
+	downloading = true;
+	const tempPath = join(CACHE_DIR, APK_FILENAME + '.tmp');
+	const finalPath = join(CACHE_DIR, APK_FILENAME);
+
+	try {
+		await mkdir(CACHE_DIR, {recursive: true});
+		await unlink(finalPath).catch(() => {});
+		let downloaded = false;
+
+		// 优先从局域网peer下载
+		if (discoverPeers) {
+			try {
+				const peers = await discoverPeers();
+				for (const peer of peers) {
+					try {
+						const peerVersionRes = await fetch(peer.versionUrl, {
+							signal: AbortSignal.timeout(5000)
+						});
+						if (!peerVersionRes.ok) {
+							continue;
+						}
+
+						const peerVersion = await peerVersionRes.json();
+						if (!peerVersion.state || peerVersion.data?.versionCode !== info.versionCode) {
+							continue;
+						}
+
+						console.log('[Cache]', '从局域网peer下载', 'peer=', peer.downloadUrl);
+						await downloadFromUrl(peer.downloadUrl, tempPath);
+						downloaded = true;
+						break;
+					} catch {
+						// peer不可用，继续尝试下一个
+					}
+				}
+			} catch {
+				// peer发现失败
+			}
+		}
+
+		// 从GitHub下载
+		if (!downloaded) {
+			console.log('[Cache]', '从GitHub下载', 'url=', info.apkUrl);
+			await downloadFromUrl(info.apkUrl, tempPath);
+		}
+
+		// 验证SHA256
+		if (info.sha256) {
+			const actual = await computeSha256(tempPath);
+			if (actual !== info.sha256) {
+				console.warn('[Cache]', 'SHA256验证失败', 'expected=', info.sha256, 'actual=', actual);
+				await unlink(tempPath).catch(() => {});
+				return;
+			}
+			console.log('[Cache]', 'SHA256验证成功');
+		}
+
+		await rename(tempPath, finalPath);
+		console.log('[Cache]', 'APK缓存完成');
+	} catch (err) {
+		console.warn('[Cache]', '下载失败', 'error=', err.message);
+		await unlink(tempPath).catch(() => {});
+	} finally {
+		downloading = false;
+	}
+}
+
+// 确保APK缓存可用。返回true表示已就绪，false表示正在同步中
+export async function syncApk(discoverPeers) {
+	const info = getVersionInfo();
+	if (!info || downloading) return false;
+
+	const filePath = getCachedApkPath();
+	if (!filePath) {
+		triggerRebuild(discoverPeers);
+		return false;
+	}
+
+	if (info.sha256) {
+		const actual = await computeSha256(filePath);
+		if (actual !== info.sha256) {
+			console.warn('[Cache]', 'SHA256不匹配', 'expected=', info.sha256, 'actual=', actual);
+			triggerRebuild(discoverPeers);
+			return false;
+		}
+	}
+	return true;
+}

package/src/github.js

@@ -0,0 +1,135 @@
+import {mkdir, readFile, writeFile} from 'node:fs/promises';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+
+const REPO = 'NXY666/bridge-app';
+const API_URL = `https://api.github.com/repos/${REPO}/releases/latest`;
+const CACHE_DIR = join(tmpdir(), 'bridge-updater');
+const VERSION_FILE = join(CACHE_DIR, 'version.json');
+const POLL_INTERVAL = 60 * 60 * 1000;
+
+let versionInfo = null;
+let afterPollCallback = null;
+
+async function fetchLatestRelease() {
+	const res = await fetch(API_URL, {
+		headers: {
+			'Accept': 'application/vnd.github+json',
+			'User-Agent': 'bridge-update-server'
+		}
+	});
+	if (!res.ok) {
+		console.warn('[GitHub]', '获取最新发布失败', 'status=', res.status);
+		return null;
+	}
+	const release = await res.json();
+
+	// 查找APK资源
+	const apkAsset = release.assets.find(a => /^Bridge_v.*\.apk$/.test(a.name));
+	if (!apkAsset) {
+		console.warn('[GitHub]', '未找到APK资源');
+		return null;
+	}
+
+	// 查找metadata.json资源
+	const metadataAsset = release.assets.find(a => a.name === 'metadata.json');
+	if (!metadataAsset) {
+		console.warn('[GitHub]', '未找到metadata.json资源');
+		return null;
+	}
+
+	// 下载metadata.json
+	const metaRes = await fetch(metadataAsset.browser_download_url, {
+		headers: {'User-Agent': 'bridge-update-server'}
+	});
+	if (!metaRes.ok) {
+		console.warn('[GitHub]', '下载metadata.json失败', 'status=', metaRes.status);
+		return null;
+	}
+	const metadata = await metaRes.json();
+
+	// 从GitHub API的digest字段获取SHA256
+	const sha256 = apkAsset.digest ? apkAsset.digest.replace(/^sha256:/, '') : '';
+
+	return {
+		versionName: String(metadata.name),
+		versionCode: Number(metadata.code),
+		apkUrl: apkAsset.browser_download_url,
+		apkFileName: apkAsset.name,
+		sha256,
+		size: apkAsset.size,
+		cachedAt: Date.now()
+	};
+}
+
+async function loadCachedVersion() {
+	try {
+		const data = await readFile(VERSION_FILE, 'utf8');
+		const parsed = JSON.parse(data);
+		if (Date.now() - parsed.cachedAt < POLL_INTERVAL) {
+			return parsed;
+		}
+	} catch {
+		// 无可用缓存
+	}
+	return null;
+}
+
+async function saveVersionCache(info) {
+	await mkdir(CACHE_DIR, {recursive: true});
+	await writeFile(VERSION_FILE, JSON.stringify(info, null, 2));
+}
+
+async function poll() {
+	try {
+		const info = await fetchLatestRelease();
+		if (info) {
+			versionInfo = info;
+			await saveVersionCache(info);
+			console.log('[GitHub]', '版本信息已更新', 'version=', info.versionName, 'code=', info.versionCode);
+			if (afterPollCallback) {
+				afterPollCallback(info);
+			}
+		}
+	} catch (err) {
+		console.warn('[GitHub]', '轮询失败', 'error=', err.message);
+	}
+}
+
+// 获取当前版本信息
+export function getVersionInfo() {
+	return versionInfo;
+}
+
+// 获取APK的GitHub直链
+export function getApkUrl() {
+	return versionInfo?.apkUrl || '';
+}
+
+// 注册每次轮询成功后的回调
+export function onPollComplete(cb) {
+	afterPollCallback = cb;
+}
+
+// 启动GitHub轮询
+export async function startGithubPolling() {
+	const cached = await loadCachedVersion();
+	if (cached) {
+		versionInfo = cached;
+
+		if (afterPollCallback) {
+			afterPollCallback(cached);
+		}
+
+		// 等待缓存过期后再开始轮询
+		setTimeout(async () => {
+			await poll();
+			setInterval(poll, POLL_INTERVAL);
+		}, POLL_INTERVAL - (Date.now() - cached.cachedAt));
+
+		console.log('[GitHub]', '使用缓存的版本信息', 'version=', cached.versionName);
+	} else {
+		await poll();
+		setInterval(poll, POLL_INTERVAL);
+	}
+}

package/src/mdns.js

@@ -0,0 +1,78 @@
+import ciao from '@homebridge/ciao';
+import {Bonjour} from 'bonjour-service';
+import {randomUUID} from 'node:crypto';
+
+const SERVICE_NAME = 'Bridge Updater';
+const SERVICE_TYPE = 'bridge-updater';
+
+let bonjourInstance = null;
+let ciaoResponder = null;
+let publishedService = null;
+const instanceId = randomUUID();
+
+// 启动mDNS广播
+export async function startMdns(port, mdnsHost, mdnsPort, mdnsPath) {
+	bonjourInstance = new Bonjour();
+	ciaoResponder = ciao.getResponder();
+
+	const txt = {instance: instanceId};
+	if (mdnsPath) {
+		txt.path = mdnsPath;
+	}
+	if (mdnsHost) {
+		txt.host = mdnsHost;
+	}
+	if (mdnsPort) {
+		txt.port = String(mdnsPort);
+	}
+
+	publishedService = ciaoResponder.createService({
+		name: SERVICE_NAME,
+		type: SERVICE_TYPE,
+		port,
+		txt
+	});
+	await publishedService.advertise();
+
+	console.log('[mDNS]', '服务已发布', 'type=', SERVICE_TYPE, 'port=', port);
+}
+
+// 扫描局域网内的其它update-server
+export function discoverPeers() {
+	return new Promise((resolve) => {
+		if (!bonjourInstance) {
+			resolve([]);
+			return;
+		}
+
+		const peers = [];
+		const browser = bonjourInstance.find({type: SERVICE_TYPE});
+
+		browser.on('up', (service) => {
+			// 过滤自身
+			if (service.txt?.instance === instanceId) {
+				return;
+			}
+
+			const txtPath = service.txt?.path || '';
+			const txtHost = service.txt?.host;
+			const txtPort = service.txt?.port;
+
+			const host = txtHost || service.host;
+			const port = txtPort ? parseInt(txtPort) : service.port;
+
+			peers.push({
+				name: service.name,
+				host,
+				port,
+				versionUrl: `http://${host}:${port}${txtPath}/version`,
+				downloadUrl: `http://${host}:${port}${txtPath}/download`
+			});
+		});
+
+		setTimeout(() => {
+			browser.stop();
+			resolve(peers);
+		}, 10000);
+	});
+}

package/src/router.js

@@ -0,0 +1,72 @@
+import {fileURLToPath} from 'node:url';
+import {dirname, join} from 'node:path';
+import express, {Router} from 'express';
+import {getVersionInfo} from './github.js';
+import {getCachedApkSize, getCachedApkStream, hasCachedApk, syncApk} from './cache.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// 创建REST API路由
+export function createRouter(mdnsPath, discoverPeers) {
+	const router = Router();
+
+	// 静态文件
+	router.use(express.static(join(__dirname, '../public')));
+
+	// 获取最新版本信息
+	router.get('/version', (req, res) => {
+		const info = getVersionInfo();
+		if (!info) {
+			return res.status(503).json({
+				state: false,
+				message: '版本信息尚未获取'
+			});
+		}
+
+		let localUrl = null;
+		if (hasCachedApk()) {
+			const proto = req.get('X-Forwarded-Proto') || req.protocol || 'http';
+			const host = req.get('X-Forwarded-Host') || req.get('Host');
+			localUrl = `${proto}://${host}${mdnsPath}/download`;
+		}
+
+		res.json({
+			state: true,
+			data: {
+				versionName: info.versionName,
+				versionCode: info.versionCode,
+				downUrl: {
+					local: localUrl,
+					github: info.apkUrl
+				},
+				sha256: info.sha256
+			}
+		});
+	});
+
+	// 下载APK
+	router.get('/download', async (req, res) => {
+		const ready = await syncApk(discoverPeers);
+		if (ready) {
+			const size = await getCachedApkSize();
+			const filename = 'Bridge_v' + getVersionInfo().versionName + '.apk';
+			res.set('Content-Type', 'application/vnd.android.package-archive');
+			res.set('Content-Disposition', 'attachment; filename="' + filename + '"');
+			if (size > 0) {
+				res.set('Content-Length', String(size));
+			}
+			getCachedApkStream().pipe(res);
+			return;
+		}
+		const apkUrl = getVersionInfo()?.apkUrl;
+		if (!apkUrl) {
+			return res.status(503).json({
+				state: false,
+				message: 'APK尚未可用'
+			});
+		}
+		res.redirect(302, apkUrl);
+	});
+
+	return router;
+}

package/src/server.js

@@ -0,0 +1,37 @@
+import express from 'express';
+import {createServer} from 'node:http';
+import {createRouter} from './router.js';
+import {onPollComplete, startGithubPolling} from './github.js';
+import {syncApk} from './cache.js';
+import {discoverPeers, startMdns} from './mdns.js';
+
+export async function startServer(options) {
+	const {port, mdnsHost, mdnsPort, mdnsPath} = options;
+
+	const app = express();
+	const server = createServer(app);
+
+	// 挂载路由
+	const router = createRouter(mdnsPath, discoverPeers);
+	if (mdnsPath) {
+		app.use(mdnsPath, router);
+	} else {
+		app.use(router);
+	}
+
+	// 每次轮询成功后同步APK
+	onPollComplete(() => syncApk(discoverPeers));
+
+	// 启动GitHub轮询
+	await startGithubPolling();
+
+	// 启动HTTP服务
+	server.listen(port, () => {
+		console.log('[Server]', '服务已启动', 'port=', port);
+	});
+
+	// 启动mDNS广播
+	await startMdns(port, mdnsHost, mdnsPort, mdnsPath);
+
+	return server;
+}