@steve02081504/fount-p2p 0.0.14 → 0.0.16

package/link/providers/nostr.mjs

@@ -0,0 +1,280 @@
+import { Buffer } from 'node:buffer'
+import { randomBytes } from 'node:crypto'
+
+import { base64ToBytes, bytesToBase64 } from '../../core/bytes_codec.mjs'
+import { normalizeHex64 } from '../../core/hexIds.mjs'
+import { getDiscoveryProvider, sendNodeSignalPacket } from '../../discovery/index.mjs'
+import { mergeSignalingRelayUrls } from '../../discovery/nostr.mjs'
+import { getNodeTransportSettings } from '../../node/identity.mjs'
+import { getSignalingRuntimeConfig } from '../../node/instance.mjs'
+import { ms } from '../../utils/duration.mjs'
+import { createLruMap } from '../../utils/lru.mjs'
+import { asLinkHandle } from '../pipe.mjs'
+
+import { LINK_LEVEL_NOSTR } from './levels.mjs'
+import { createLinkIdBoundPipe } from './link_id_pipe.mjs'
+
+/** 单包 payload（UTF-8 / base64）上限，避免撞 relay content 限制。 */
+const MAX_LINK_PAYLOAD_CHARS = 12 * 1024
+/** open 到达前为同一 linkId 暂存的 c/b 包上限。 */
+const PENDING_PACKETS_MAX = 32
+/** Nostr 链握手超时（relay RTT 更慢）。 */
+const NOSTR_HANDSHAKE_TIMEOUT_MS = ms('30s')
+/** Nostr 链心跳间隔。 */
+const NOSTR_HEARTBEAT_MS = ms('60s')
+/** Nostr 链空闲超时。 */
+const NOSTR_IDLE_TIMEOUT_MS = ms('3m')
+
+/**
+ * @returns {string[]} 当前可用中继 URL
+ */
+function resolveDefaultRelayUrls() {
+	return getSignalingRuntimeConfig().relayOverride
+		?? mergeSignalingRelayUrls(getNodeTransportSettings().relayUrls)
+}
+
+/**
+ * @param {string} remoteNodeHash 对端
+ * @param {object} packet link 包
+ * @returns {Promise<void>}
+ */
+async function publishLinkPacket(remoteNodeHash, packet) {
+	await sendNodeSignalPacket(remoteNodeHash, packet)
+}
+
+/**
+ * 创建 Nostr 末位数据链路 provider（level = -∞）。
+ * @param {{ getRelayUrls?: () => string[] }} [options] 中继解析（测试可注入）
+ * @returns {import('./index.mjs').LinkProvider & { deliverPacket: (packet: object) => void }} provider
+ */
+export function createNostrLinkProvider(options = {}) {
+	const resolveRelayUrls = typeof options.getRelayUrls === 'function'
+		? options.getRelayUrls
+		: resolveDefaultRelayUrls
+
+	/** @type {((link: import('./index.mjs').LinkHandle) => void) | null} */
+	let onInbound = null
+	/** @type {object | null} */
+	let localIdentity = null
+	/**
+	 * @typedef {{
+	 *   pipe: ReturnType<typeof createLinkIdBoundPipe>,
+	 *   remoteNodeHash: string,
+	 *   initiator: boolean,
+	 * }} NostrLinkSession
+	 */
+	/** @type {Map<string, NostrLinkSession>} */
+	const sessions = new Map()
+	/** @type {Map<string, object[]> & { touch: (key: string, value: object[]) => void }} */
+	const pendingByLinkId = createLruMap(64)
+
+	/**
+	 * @returns {boolean} discovery nostr 已注册且有中继
+	 */
+	function isAvailable() {
+		if (!getDiscoveryProvider('nostr')) return false
+		return resolveRelayUrls().length > 0
+	}
+
+	/**
+	 * @param {NostrLinkSession} session 会话
+	 * @param {object} packet link 包
+	 * @returns {void}
+	 */
+	function applySessionPacket(session, packet) {
+		const op = String(packet.op || '')
+		if (op === 'close') {
+			void session.pipe.close('remote-close')
+			return
+		}
+		if (op === 'c') {
+			if (typeof packet.payload !== 'string') return
+			session.pipe.handleInbound(packet.payload)
+			return
+		}
+		if (op === 'b') {
+			if (typeof packet.payload !== 'string') return
+			try {
+				session.pipe.handleInbound(Buffer.from(base64ToBytes(packet.payload)))
+			}
+			catch { /* drop malformed */ }
+		}
+	}
+
+	/**
+	 * @param {string} linkId 链路 id
+	 * @param {object} packet 暂存包
+	 * @returns {void}
+	 */
+	function bufferPending(linkId, packet) {
+		let list = pendingByLinkId.get(linkId)
+		if (!list) {
+			list = []
+			pendingByLinkId.touch(linkId, list)
+		}
+		if (list.length >= PENDING_PACKETS_MAX) list.shift()
+		list.push(packet)
+	}
+
+	/**
+	 * @param {string} remoteNodeHash 对端
+	 * @param {string} linkId 链路 id
+	 * @param {string} op open|c|b|close
+	 * @param {string} [payload] 可选载荷
+	 * @returns {Promise<void>}
+	 */
+	async function sendOp(remoteNodeHash, linkId, op, payload) {
+		if (payload != null && payload.length > MAX_LINK_PAYLOAD_CHARS)
+			throw new Error('p2p: nostr link payload too large')
+		const packet = {
+			type: 'link',
+			op,
+			from: localIdentity?.nodeHash || '',
+			linkId,
+		}
+		if (payload != null) packet.payload = payload
+		await publishLinkPacket(remoteNodeHash, packet)
+	}
+
+	/**
+	 * @param {object} opts 会话选项
+	 * @returns {ReturnType<typeof createLinkIdBoundPipe>} pipe
+	 */
+	function openPipe(opts) {
+		const { linkId, remoteNodeHash, initiator } = opts
+		const pipe = createLinkIdBoundPipe({
+			providerId: 'nostr',
+			level: LINK_LEVEL_NOSTR,
+			initiator: !!initiator,
+			linkId,
+			nodeHash: remoteNodeHash,
+			localIdentity: opts.localIdentity || localIdentity,
+			handshakeTimeoutMs: NOSTR_HANDSHAKE_TIMEOUT_MS,
+			heartbeatMs: NOSTR_HEARTBEAT_MS,
+			idleTimeoutMs: NOSTR_IDLE_TIMEOUT_MS,
+			/**
+			 * @param {string} text control JSON
+			 * @returns {Promise<void>}
+			 */
+			async sendControlText(text) {
+				await sendOp(remoteNodeHash, linkId, 'c', text)
+			},
+			/**
+			 * @param {string} _action action
+			 * @param {Uint8Array} frame 帧
+			 * @returns {Promise<void>}
+			 */
+			async sendFrame(_action, frame) {
+				await sendOp(remoteNodeHash, linkId, 'b', bytesToBase64(frame))
+			},
+			/**
+			 * @returns {Promise<void>}
+			 */
+			async closeTransport() {
+				sessions.delete(linkId)
+				try {
+					await sendOp(remoteNodeHash, linkId, 'close')
+				}
+				catch { /* ignore */ }
+			},
+		})
+		sessions.set(linkId, { pipe, remoteNodeHash, initiator: !!initiator })
+		pipe.onDown(() => { sessions.delete(linkId) })
+		return pipe
+	}
+
+	/**
+	 * 入站已解密的 link 包（由信令 demux 调用）。
+	 * @param {object} packet link 包
+	 * @returns {void}
+	 */
+	function deliverPacket(packet) {
+		if (packet?.type !== 'link') return
+		const linkId = normalizeHex64(packet.linkId)
+		const from = normalizeHex64(packet.from)
+		if (!linkId || !from) return
+		if (localIdentity?.nodeHash && from === localIdentity.nodeHash) return
+
+		const op = String(packet.op || '')
+		if (op === 'open') {
+			if (sessions.has(linkId)) return
+			if (!onInbound || !localIdentity) return
+			const pipe = openPipe({
+				linkId,
+				remoteNodeHash: from,
+				initiator: false,
+				localIdentity,
+			})
+			onInbound(asLinkHandle(pipe))
+			void pipe.startHandshake().catch(() => {
+				sessions.delete(linkId)
+				void pipe.close('accept-failed')
+			})
+			const pending = pendingByLinkId.get(linkId) || []
+			pendingByLinkId.delete(linkId)
+			const session = sessions.get(linkId)
+			if (session)
+				for (const queued of pending)
+					applySessionPacket(session, queued)
+			return
+		}
+
+		const session = sessions.get(linkId)
+		if (!session) {
+			if (op === 'c' || op === 'b' || op === 'close')
+				bufferPending(linkId, packet)
+			return
+		}
+		applySessionPacket(session, packet)
+	}
+
+	return {
+		id: 'nostr',
+		level: LINK_LEVEL_NOSTR,
+		caps: { needsOfferAnswer: false, needsDiscoverySignal: false, probe: 'sync' },
+		isAvailable,
+		/**
+		 * @returns {boolean} 有中继即可
+		 */
+		canReach() {
+			return isAvailable()
+		},
+		deliverPacket,
+		/**
+		 * @param {object} dialOptions dial 选项
+		 * @returns {Promise<import('./index.mjs').LinkHandle | null>} link
+		 */
+		async dial(dialOptions) {
+			if (!isAvailable()) return null
+			const remoteNodeHash = normalizeHex64(dialOptions.nodeHash)
+			if (!remoteNodeHash) return null
+			localIdentity = dialOptions.localIdentity || localIdentity
+			if (!localIdentity?.nodeHash) throw new Error('p2p: nostr dial requires localIdentity')
+			const linkId = randomBytes(32).toString('hex')
+			const pipe = openPipe({
+				linkId,
+				remoteNodeHash,
+				initiator: true,
+				localIdentity,
+			})
+			await sendOp(remoteNodeHash, linkId, 'open')
+			await pipe.startHandshake()
+			return asLinkHandle(pipe)
+		},
+		/**
+		 * @param {{ onInbound: (link: import('./index.mjs').LinkHandle) => void, localIdentity: object }} handlers 回调
+		 * @returns {() => void} 停止 listening
+		 */
+		ensureListening(handlers) {
+			onInbound = handlers.onInbound
+			localIdentity = handlers.localIdentity
+			return () => {
+				onInbound = null
+				for (const session of sessions.values())
+					void session.pipe.close('listen-stop')
+				sessions.clear()
+				pendingByLinkId.clear()
+			}
+		},
+	}
+}

package/link/providers/webrtc.mjs

@@ -34,6 +34,13 @@ function formatErrorReason(error) {
 
 let cachedAvailable = null
 
+/**
+ * @returns {boolean} 是否跑在 Deno
+ */
+function isDenoRuntime() {
+	return typeof globalThis.Deno !== 'undefined'
+}
+
 /**
  * 探测 WebRTC（node-datachannel）是否可用。
  * @returns {Promise<boolean>} 可用为 true
@@ -46,7 +53,12 @@ export async function canUseWebRtcLink() {
 	}
 	catch (error) {
 		cachedAvailable = false
-		nodeDebug('p2p:webrtc unavailable', { err: formatErrorReason(error) })
+		const reason = formatErrorReason(error)
+		nodeDebug('p2p:webrtc unavailable', {
+			err: isDenoRuntime()
+				? `${reason} | deno: see docs/runtime.md (node-datachannel scripts only)`
+				: reason,
+		})
 	}
 	return cachedAvailable
 }

package/link/rtc.mjs

@@ -4,15 +4,23 @@ import { toBytes } from '../core/bytes_codec.mjs'
 import { getSignalingRuntimeConfig } from '../node/instance.mjs'
 import { wrapRtcPeerConnectionForIceLocalHostname } from '../transport/rtc_ice_local_hostname.mjs'
 
+/** @type {boolean} */
+let exitCleanupHooked = false
+
 /**
- * 注册进程退出时销毁 libdatachannel 全部原生资源（仅一次）。
+ * 注册进程退出时销毁 libdatachannel 原生资源（首次成功加载后挂一次）。
  * libdatachannel 的原生线程在 pc.close() 后仍需时间回收；进程退出时若原生资源未同步销毁，
  * Windows 上会触发堆损坏（退出码 0xC0000374）。
+ * @returns {Promise<void>}
  */
-const { cleanup = undefined } = await import('node-datachannel').catch(() => ({}))
-process.on('exit', () => {
-	try { cleanup?.() } catch { /* already torn down */ }
-})
+async function ensureNodeDatachannelExitCleanup() {
+	if (exitCleanupHooked) return
+	exitCleanupHooked = true
+	const { cleanup = undefined } = await import('node-datachannel').catch(() => ({}))
+	process.on('exit', () => {
+		try { cleanup?.() } catch { /* already torn down */ }
+	})
+}
 
 /**
  * 加载 node-datachannel polyfill，并按配置包装 RTCPeerConnection。
@@ -20,6 +28,7 @@ process.on('exit', () => {
  */
 export async function loadNodeRtcPolyfill() {
 	const mod = await import('node-datachannel/polyfill')
+	await ensureNodeDatachannelExitCleanup()
 	const { iceLocalHostnamePolicy } = getSignalingRuntimeConfig()
 	return {
 		RTCPeerConnection: wrapRtcPeerConnectionForIceLocalHostname(mod.RTCPeerConnection, mod.RTCIceCandidate, iceLocalHostnamePolicy),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.14",
+	"version": "0.0.16",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",

package/transport/link_registry.mjs

@@ -3,11 +3,13 @@ import { Buffer } from 'node:buffer'
 import { compareHex64Asc, normalizeHex64 } from '../core/hexIds.mjs'
 import { keyPairFromSeed } from '../crypto/crypto.mjs'
 import { watchVerifiedNodeAdvert, setDiscoveryLinkDialer, prepareConnectToNode } from '../discovery/index.mjs'
+import { setDiscoveryPeerClueListener } from '../discovery/peer_clue.mjs'
 import { listLinkProviders } from '../link/providers/index.mjs'
 import { ensureNodeSeed, getNodeHash } from '../node/identity.mjs'
 import { nodeDebug, shortHash } from '../node/log.mjs'
 import { loadPeerPoolView } from '../node/network.mjs'
 import { createOverlayRouter } from '../overlay/index.mjs'
+import { ms } from '../utils/duration.mjs'
 import { emitSafe } from '../utils/emit_safe.mjs'
 import { createLruMap } from '../utils/lru.mjs'
 
@@ -18,6 +20,11 @@ import { createOfferAnswerDial } from './offer_answer.mjs'
 import { pickMeshEvictionVictim } from './peer_pool.mjs'
 import { createRuntimeBootstrap } from './runtime_bootstrap.mjs'
 
+/** dial exhausted 后的初始冷却。 */
+const DIAL_COOLDOWN_BASE_MS = ms('30s')
+/** dial 冷却上限。 */
+const DIAL_COOLDOWN_MAX_MS = ms('10m')
+
 /**
  * 解析或从节点种子推导本地身份。
  * @param {{ nodeHash?: string, nodePubKey?: string, secretKey?: Uint8Array } | undefined} localIdentity 可选的预置身份
@@ -84,6 +91,8 @@ export function createLinkRegistry(options = {}) {
 	const links = new Map()
 	/** @type {Map<string, Promise<object | null>>} */
 	const inflights = new Map()
+	/** @type {Map<string, { until: number, failures: number }> & { touch: (key: string, value: { until: number, failures: number }) => void }} */
+	const dialCooldown = createLruMap(1024)
 	/** @type {Map<string, ReturnType<typeof import('./offer_answer.mjs').createBufferedSignalSession>>} */
 	const signalSessions = new Map()
 	/** @type {Map<string, Set<string>>} */
@@ -265,6 +274,19 @@ export function createLinkRegistry(options = {}) {
 		if (!normalized || normalized === localIdentity.nodeHash) return null
 		if (links.has(normalized)) return links.get(normalized)
 		if (inflights.has(normalized)) return await inflights.get(normalized)
+		const cool = dialCooldown.get(normalized)
+		const now = Date.now()
+		if (cool) {
+			if (now < cool.until) {
+				nodeDebug('p2p:dial cooldown', {
+					peer: shortHash(normalized),
+					failures: cool.failures,
+					retryInMs: cool.until - now,
+				})
+				return null
+			}
+			dialCooldown.delete(normalized)
+		}
 		const task = (async () => {
 			nodeDebug('p2p:dial start', { peer: shortHash(normalized) })
 			await prepareConnectToNode(normalized)
@@ -289,6 +311,7 @@ export function createLinkRegistry(options = {}) {
 					if (provider.caps?.needsOfferAnswer) {
 						const link = await dialOfferAnswer(provider, normalized)
 						if (link) {
+							dialCooldown.delete(normalized)
 							nodeDebug('p2p:dial ok', { peer: shortHash(normalized), provider: provider.id })
 							return link
 						}
@@ -297,6 +320,7 @@ export function createLinkRegistry(options = {}) {
 					}
 					const link = await dialProvider(provider, normalized)
 					if (link) {
+						dialCooldown.delete(normalized)
 						nodeDebug('p2p:dial ok', { peer: shortHash(normalized), provider: provider.id })
 						return link
 					}
@@ -310,7 +334,10 @@ export function createLinkRegistry(options = {}) {
 					})
 				}
 
-			nodeDebug('p2p:dial exhausted', { peer: shortHash(normalized) })
+			const failures = (cool?.failures || 0) + 1
+			const delay = Math.min(DIAL_COOLDOWN_MAX_MS, DIAL_COOLDOWN_BASE_MS * (2 ** Math.min(failures - 1, 5)))
+			dialCooldown.touch(normalized, { until: Date.now() + delay, failures })
+			nodeDebug('p2p:dial exhausted', { peer: shortHash(normalized), cooldownMs: delay, failures })
 			return null
 		})().finally(() => inflights.delete(normalized))
 		inflights.set(normalized, task)
@@ -351,6 +378,12 @@ export function createLinkRegistry(options = {}) {
 	})
 	exploreLinkHashes = meshKeepalive.exploreLinkHashes
 	setDiscoveryLinkDialer(ensureDirectLinkToNode)
+	setDiscoveryPeerClueListener(nodeHash => {
+		const hash = normalizeHex64(nodeHash)
+		if (!hash) return
+		dialCooldown.delete(hash)
+		recentAdverts.touch(hash, Date.now())
+	})
 
 	/**
 	 *
@@ -619,6 +652,7 @@ export function createLinkRegistry(options = {}) {
 			return await watchVerifiedNodeAdvert(hash, async (verifiedNodeHash, body, meta) => {
 				applyAdvertPeerHints(verifiedNodeHash, body, meta)
 				recentAdverts.touch(verifiedNodeHash, Date.now())
+				dialCooldown.delete(verifiedNodeHash)
 				await Promise.resolve(onAdvert(verifiedNodeHash, body))
 			})
 		},
@@ -631,6 +665,7 @@ export function createLinkRegistry(options = {}) {
 		async shutdown() {
 			await meshKeepalive?.stop()
 			setDiscoveryLinkDialer(null)
+			setDiscoveryPeerClueListener(null)
 			await bootstrap.shutdown()
 			overlayRouter?.close()
 			overlayRouter = null
@@ -638,6 +673,7 @@ export function createLinkRegistry(options = {}) {
 				await link.close('registry-shutdown')
 			links.clear()
 			inflights.clear()
+			dialCooldown.clear()
 			for (const session of signalSessions.values()) session.clear()
 			signalSessions.clear()
 		},

package/transport/offer_answer.mjs

@@ -150,11 +150,10 @@ export function createOfferAnswerDial(deps) {
 	}
 
 	/**
-	 * @param {Uint8Array} bytes 加密信令
+	 * @param {object} packet 已解密的 signal 包
 	 * @returns {Promise<void>}
 	 */
-	async function handleIncomingSignal(bytes) {
-		const packet = decryptNodeSignalPacket(localIdentity.nodeHash, bytes)
+	async function handleSignalPacket(packet) {
 		if (packet?.type !== 'signal') return
 		const remoteNodeHash = normalizeHex64(packet.from)
 		const connId = String(packet.connId || '')
@@ -175,6 +174,21 @@ export function createOfferAnswerDial(deps) {
 		session.deliver(packet.body)
 	}
 
+	/**
+	 * @param {Uint8Array} bytes 加密信令
+	 * @returns {Promise<void>}
+	 */
+	async function handleIncomingSignal(bytes) {
+		const packet = decryptNodeSignalPacket(localIdentity.nodeHash, bytes)
+		if (!packet) return
+		if (packet.type === 'link') {
+			const provider = listLinkProviders().find(entry => entry.id === 'nostr')
+			provider?.deliverPacket?.(packet)
+			return
+		}
+		await handleSignalPacket(packet)
+	}
+
 	/**
 	 * @param {import('../link/providers/index.mjs').LinkProvider} provider 链路提供者
 	 * @param {string} remoteNodeHash 远端 nodeHash
@@ -187,5 +201,5 @@ export function createOfferAnswerDial(deps) {
 		return await buildConnLink({ provider, remoteNodeHash, connId, session, initiator: true })
 	}
 
-	return { handleIncomingSignal, dialOfferAnswer }
+	return { handleIncomingSignal, handleSignalPacket, dialOfferAnswer }
 }

package/transport/runtime_bootstrap.mjs

@@ -18,6 +18,7 @@ import {
 	unregisterLinkProvider,
 } from '../link/providers/index.mjs'
 import { createLanTcpLinkProvider } from '../link/providers/lan_tcp.mjs'
+import { createNostrLinkProvider } from '../link/providers/nostr.mjs'
 import { createWebRtcLinkProvider } from '../link/providers/webrtc.mjs'
 import { getNodeTransportSettings } from '../node/identity.mjs'
 import { getSignalingRuntimeConfig, onNodeChange } from '../node/instance.mjs'
@@ -116,7 +117,9 @@ export function createRuntimeBootstrap(deps) {
 	function registerDiscoveryDefaults() {
 		const providerIds = new Set(listDiscoveryProviders().map(provider => provider.id))
 		if (!providerIds.has('lan'))
-			registerDiscoveryProvider(createLanDiscoveryProvider())
+			registerDiscoveryProvider(createLanDiscoveryProvider({
+				localNodeHash: localIdentity.nodeHash,
+			}))
 		if (!providerIds.has('nostr'))
 			registerNostrProvider()
 	}
@@ -128,6 +131,7 @@ export function createRuntimeBootstrap(deps) {
 		unregisterDiscoveryProvider('nostr')
 		registerDiscoveryProvider(createNostrDiscoveryProvider({
 			getRelayUrls: resolveNostrRelayUrls,
+			localNodeHash: localIdentity.nodeHash,
 		}))
 	}
 
@@ -154,6 +158,8 @@ export function createRuntimeBootstrap(deps) {
 		const ids = new Set(listLinkProviders().map(provider => provider.id))
 		if (!ids.has('webrtc'))
 			registerLinkProvider(createWebRtcLinkProvider())
+		if (!ids.has('nostr'))
+			registerLinkProvider(createNostrLinkProvider({ getRelayUrls: resolveNostrRelayUrls }))
 	}
 
 	/**