@steve02081504/fount-p2p 0.0.12 → 0.0.13

package/wire/part_query.mjs

@@ -9,9 +9,9 @@ import {
 	parsePartQueryReq,
 	parsePartQueryRes,
 } from '../schemas/part_query.mjs'
+import { sendToNodeLink } from '../transport/link_registry.mjs'
 import { buildMergedGraph } from '../trust_graph/build.mjs'
 import { pickTopFromGraph } from '../trust_graph/engine.mjs'
-import { DEFAULT_TRUST_GRAPH_OWNER, requireTrustGraphProvider } from '../trust_graph/registry.mjs'
 import { resolveFederationFanoutTopK } from '../trust_graph/resolve.mjs'
 import trustGraphTunables from '../trust_graph/tunables.json' with { type: 'json' }
 
@@ -210,8 +210,9 @@ async function selectQueryNeighbors(username, exclude, dependencies) {
  * @returns {Promise<boolean>} 是否发出
  */
 async function deliverQuery(username, nodeHash, action, payload, dependencies) {
+	void username
 	if (dependencies.deliver) return Boolean(await dependencies.deliver(nodeHash, action, payload))
-	return requireTrustGraphProvider(DEFAULT_TRUST_GRAPH_OWNER).sendToNode(username, nodeHash, action, payload)
+	return sendToNodeLink(nodeHash, { scope: 'node', action, payload })
 }
 
 /**
@@ -326,27 +327,32 @@ async function processIncomingRequest(wireContext, wire, request, peerId, depend
  * @param {{ replicaUsername?: string }} wireContext 入站上下文
  * @param {PartWireAdapter} wire wire
  * @param {PartQueryDependencies} [dependencies] 可注入依赖（含 per-node state）
- * @returns {void}
+ * @returns {() => void} 取消挂载的 dispose
  */
 export function attachPartQueryWire(wireContext, wire, dependencies = {}) {
 	const state = resolveState(dependencies)
-	wire.on('part_query_req', (data, peerId) => {
-		if (!isPlainObject(data)) return
-		const request = parsePartQueryReq(data)
-		if (!request) return
-		if (!state.takeDedupe(request.requestId)) return
-		const source = String(peerId || request.originNodeHash || '').trim().toLowerCase()
-		if (source && !consumeWireRateBucket(`part_query:${source}`, {
-			maxCount: partQueryTunables.ratePerSourcePerMin,
-		})) return
-		void processIncomingRequest(wireContext, wire, request, String(peerId || ''), dependencies)
-	})
-
-	wire.on('part_query_res', (data, peerId) => {
-		const response = parsePartQueryRes(data)
-		if (!response) return
-		handleIncomingPartQueryResponse(response, String(peerId || ''), dependencies)
-	})
+	const offs = [
+		wire.on('part_query_req', (data, peerId) => {
+			if (!isPlainObject(data)) return
+			const request = parsePartQueryReq(data)
+			if (!request) return
+			if (!state.takeDedupe(request.requestId)) return
+			const source = String(peerId || request.originNodeHash || '').trim().toLowerCase()
+			if (source && !consumeWireRateBucket(`part_query:${source}`, {
+				maxCount: partQueryTunables.ratePerSourcePerMin,
+			})) return
+			void processIncomingRequest(wireContext, wire, request, String(peerId || ''), dependencies)
+		}),
+		wire.on('part_query_res', (data, peerId) => {
+			const response = parsePartQueryRes(data)
+			if (!response) return
+			handleIncomingPartQueryResponse(response, String(peerId || ''), dependencies)
+		}),
+	]
+	return () => {
+		for (const off of offs)
+			try { off?.() } catch { /* ignore */ }
+	}
 }
 
 /**

package/discovery/mdns.mjs

@@ -1,197 +0,0 @@
-import { Buffer } from 'node:buffer'
-import dgram from 'node:dgram'
-
-const DEFAULT_PORT = 53531
-const DEFAULT_GROUP = '239.255.42.99'
-
-/**
- * 轻量 multicast 发现插件：不做完整 DNS-SD，只复用 mDNS 的 LAN multicast 发现思路。
- * 引用计数为 0 时关闭 UDP socket，避免 shutdown 后句柄拖住进程。
- *
- * @param {{ port?: number, group?: string }} [options] 组播端口与组地址
- * @returns {import('./index.mjs').DiscoveryProvider} mDNS 发现提供者
- */
-export function createMdnsDiscoveryProvider(options = {}) {
-	const port = Number(options.port) || DEFAULT_PORT
-	const group = String(options.group || DEFAULT_GROUP)
-	/** @type {import('node:dgram').Socket | null} */
-	let socket = null
-	let bound = false
-	let bindPromise = null
-	let refs = 0
-	/** @type {Map<string, Set<Function>>} */
-	const advertListeners = new Map()
-	/** @type {Map<string, Set<Function>>} */
-	const signalListeners = new Map()
-
-	/**
-	 * 懒创建或返回当前 UDP socket。
-	 * @returns {import('node:dgram').Socket} 用于组播 bind/send 的 socket
-	 */
-	function getSocket() {
-		return socket ||= dgram.createSocket({ type: 'udp4', reuseAddr: true })
-	}
-
-	/**
-	 * 绑定 UDP socket 并注册组播消息处理器。
-	 * @returns {Promise<void>}
-	 */
-	async function ensureBound() {
-		if (bound) return
-		if (!bindPromise)
-			bindPromise = (async () => {
-				const sock = getSocket()
-				await new Promise((resolve, reject) => {
-					sock.once('error', reject)
-					sock.bind(port, '0.0.0.0', () => {
-						sock.off('error', reject)
-						sock.addMembership(group)
-						sock.setMulticastTTL(1)
-						resolve()
-					})
-				})
-				// acquire 已全部释放：关掉刚 bind 的 socket，避免泄漏句柄。
-				if (refs <= 0) {
-					try { sock.close() } catch { /* ignore */ }
-					if (socket === sock) socket = null
-					bound = false
-					return
-				}
-				sock.on('message', (raw, rinfo) => {
-					let packet
-					try { packet = JSON.parse(String(raw)) } catch { return }
-					const listeners = packet.type === 'advert'
-						? advertListeners.get(String(packet.topic || ''))
-						: signalListeners.get(String(packet.topic || ''))
-					if (!listeners?.size) return
-					const bytes = Uint8Array.from(Buffer.from(String(packet.data || ''), 'base64'))
-					const meta = {
-						provider: 'mdns',
-						address: String(rinfo?.address || ''),
-					}
-					for (const listener of listeners)
-						listener(bytes, meta)
-				})
-				bound = true
-			})()
-				.finally(() => {
-					if (!bound) bindPromise = null
-				})
-		await bindPromise
-	}
-
-	/**
-	 * 向组播组发送 advert 或 signal 包。
-	 * @param {'advert' | 'signal'} type 包类型
-	 * @param {string} topic topic 名称
-	 * @param {Uint8Array} bytes 载荷字节
-	 * @returns {Promise<void>}
-	 */
-	async function multicast(type, topic, bytes) {
-		await ensureBound()
-		const sock = getSocket()
-		const packet = Buffer.from(JSON.stringify({
-			type,
-			topic,
-			data: Buffer.from(bytes).toString('base64'),
-		}))
-		await new Promise((resolve, reject) => {
-			sock.send(packet, port, group, error => error ? reject(error) : resolve())
-		})
-	}
-
-	/**
-	 * 占用 socket；归还后若无引用则关闭。
-	 * @returns {() => void} 释放函数
-	 */
-	function acquire() {
-		refs++
-		void ensureBound().catch(() => { })
-		return () => {
-			refs = Math.max(0, refs - 1)
-			if (refs > 0 || !socket) return
-			try { socket.close() } catch { /* ignore */ }
-			socket = null
-			bound = false
-			bindPromise = null
-		}
-	}
-
-	/**
-	 * 向 topic bucket 注册监听器。
-	 * @param {Map<string, Set<Function>>} bucket topic → 监听器集合
-	 * @param {string} topic 订阅 topic
-	 * @param {Function} listener 回调函数
-	 * @returns {() => void} 取消订阅函数
-	 */
-	function addListener(bucket, topic, listener) {
-		if (!bucket.has(topic)) bucket.set(topic, new Set())
-		bucket.get(topic).add(listener)
-		const release = acquire()
-		return () => {
-			const set = bucket.get(topic)
-			if (!set) {
-				release()
-				return
-			}
-			set.delete(listener)
-			if (!set.size) bucket.delete(topic)
-			release()
-		}
-	}
-
-	return {
-		id: 'mdns',
-		priority: 10,
-		caps: { canDiscover: true, canSignal: true, canRelay: false },
-		/**
-		 * 周期性组播广播 advert（首发后台，不阻塞调用方）。
-		 * @param {string} topic advert 主题
-		 * @param {Uint8Array} bytes advert 载荷
-		 * @returns {Promise<() => void>} 取消广播函数
-		 */
-		async advertise(topic, bytes) {
-			const release = acquire()
-			void multicast('advert', topic, bytes).catch(() => { })
-			const timer = setInterval(() => { void multicast('advert', topic, bytes).catch(() => { }) }, 30_000)
-			return () => {
-				clearInterval(timer)
-				release()
-			}
-		},
-		/**
-		 * 订阅组播 advert（立即返回；UDP bind 后台完成）。
-		 * @param {string} topic advert 主题
-		 * @param {Function} onAdvert advert 回调
-		 * @returns {Promise<() => void>} 取消订阅函数
-		 */
-		async subscribe(topic, onAdvert) {
-			return addListener(advertListeners, topic, onAdvert)
-		},
-		/**
-		 * 组播发送信令（忽略单播目标）。
-		 * @param {string} topic 信令 topic
-		 * @param {string} _to 目标标识（未使用）
-		 * @param {Uint8Array} bytes 信令载荷
-		 * @returns {Promise<void>}
-		 */
-		async sendSignal(topic, _to, bytes) {
-			const release = acquire()
-			try {
-				await multicast('signal', topic, bytes)
-			}
-			finally {
-				release()
-			}
-		},
-		/**
-		 * 订阅组播信令（立即返回；UDP bind 后台完成）。
-		 * @param {string} topic 信令 topic
-		 * @param {Function} onSignal 信令回调
-		 * @returns {Promise<() => void>} 取消订阅函数
-		 */
-		async onSignal(topic, onSignal) {
-			return addListener(signalListeners, topic, onSignal)
-		},
-	}
-}

package/transport/signal_crypto.mjs

@@ -1,104 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto'
-
-import { normalizeHex64 } from '../core/hexIds.mjs'
-import { sha256Hex } from '../crypto/crypto.mjs'
-import { createLruMap } from '../utils/lru.mjs'
-
-const SIGNAL_DOMAIN = 'fount-signal'
-const NODE_TOPIC_DOMAIN = 'fount-rdv-node:'
-const GROUP_TOPIC_DOMAIN = 'fount-rdv-group:'
-
-/** topic → AES-256 密钥缓存上限（群/节点 topic 会随时间增长，须有界） */
-export const SIGNAL_KEY_CACHE_MAX = 512
-
-/**
- * 由 nodeHash 派生节点 rendezvous topic。
- * @param {string} nodeHash 节点 64 hex
- * @returns {string} rendezvous topic 哈希
- */
-export function nodeRendezvousTopic(nodeHash) {
-	return sha256Hex(`${NODE_TOPIC_DOMAIN}${normalizeHex64(nodeHash)}`)
-}
-
-/**
- * 由房间密钥派生群组 rendezvous topic。
- * @param {string} roomSecret 房间密钥
- * @returns {string} rendezvous topic 哈希
- */
-export function groupRendezvousTopic(roomSecret) {
-	return sha256Hex(`${GROUP_TOPIC_DOMAIN}${roomSecret}`)
-}
-
-/** topic → AES-256 密钥 LRU */
-const signalKeysByTopic = createLruMap(SIGNAL_KEY_CACHE_MAX)
-
-/**
- * 由 topic 派生信令 AES 密钥（同 topic 复用，避免每包 SHA-256）。
- * @param {string} topic rendezvous 主题
- * @returns {Buffer} AES-256 密钥
- */
-function signalKeyForTopic(topic) {
-	let cached = signalKeysByTopic.get(topic)
-	if (cached) {
-		signalKeysByTopic.touch(topic, cached)
-		return cached
-	}
-	cached = createHash('sha256').update(`${SIGNAL_DOMAIN}:${topic}`).digest()
-	signalKeysByTopic.touch(topic, cached)
-	return cached
-}
-
-/**
- * 当前密钥缓存条目数（测试用）。
- * @returns {number} 缓存大小
- */
-export function signalKeyCacheSize() {
-	return signalKeysByTopic.size
-}
-
-/**
- * 加密信令包为 AES-GCM 字节序列。
- * @param {string} topic rendezvous 主题
- * @param {unknown} packet 待加密 JSON 对象
- * @returns {Uint8Array} 加密后的字节
- */
-export function encryptSignalPacket(topic, packet) {
-	const iv = randomBytes(12)
-	const cipher = createCipheriv('aes-256-gcm', signalKeyForTopic(topic), iv)
-	const ciphertext = Buffer.concat([
-		cipher.update(Buffer.from(JSON.stringify(packet), 'utf8')),
-		cipher.final(),
-	])
-	return Buffer.from(JSON.stringify({
-		iv: iv.toString('base64'),
-		authTag: cipher.getAuthTag().toString('base64'),
-		ciphertext: ciphertext.toString('base64'),
-	}))
-}
-
-/**
- * 解密信令包；失败时返回 null。
- * @param {string} topic rendezvous 主题
- * @param {Uint8Array} bytes 加密字节
- * @returns {object | null} 解密后的 JSON 对象
- */
-export function decryptSignalPacket(topic, bytes) {
-	try {
-		const payload = JSON.parse(Buffer.from(bytes).toString('utf8'))
-		const decipher = createDecipheriv(
-			'aes-256-gcm',
-			signalKeyForTopic(topic),
-			Buffer.from(payload.iv, 'base64'),
-		)
-		decipher.setAuthTag(Buffer.from(payload.authTag, 'base64'))
-		const plain = Buffer.concat([
-			decipher.update(Buffer.from(payload.ciphertext, 'base64')),
-			decipher.final(),
-		])
-		return JSON.parse(plain.toString('utf8'))
-	}
-	catch {
-		return null
-	}
-}