@steve02081504/fount-p2p 0.0.0

package/dag/storage.mjs

@@ -0,0 +1,333 @@
+import { Buffer } from 'node:buffer'
+import { randomUUID } from 'node:crypto'
+import { createReadStream, createWriteStream } from 'node:fs'
+import { appendFile, mkdir, open, readFile, rename, unlink, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { createInterface } from 'node:readline'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { setTimeout as sleep } from 'node:timers/promises'
+
+import { withAsyncMutex } from '../utils/async_mutex.mjs'
+
+/** 流式重写 JSONL 时分块写入的行数上限 */
+const WRITE_JSONL_CHUNK_LINES = 1000
+/** Windows 上 rename 可能被短暂占用，做几次短退避重试。 */
+const ATOMIC_RENAME_RETRY_DELAYS_MS = [0, 10, 25, 50, 100]
+const ATOMIC_RENAME_RETRY_CODES = new Set(['EPERM', 'EBUSY', 'EACCES'])
+
+/**
+ * @param {string} filePath 目标路径
+ * @returns {string} 唯一临时文件路径
+ */
+function atomicTmpPath(filePath) {
+	return `${filePath}.tmp.${process.pid}.${randomUUID()}`
+}
+
+/**
+ * @param {string} tmp 临时文件路径
+ * @returns {Promise<void>}
+ */
+async function cleanupAtomicTmp(tmp) {
+	try { await unlink(tmp) } catch { /* ok */ }
+}
+
+/**
+ * 完成原子写的最终 rename；若目标目录已在 cleanup 中消失，则清理残余 tmp 后静默返回。
+ * @param {string} tmp 临时文件路径
+ * @param {string} filePath 最终目标路径
+ * @returns {Promise<boolean>} 是否已成功落到目标路径
+ */
+export async function finalizeAtomicRename(tmp, filePath) {
+	/** @type {NodeJS.ErrnoException | undefined} */
+	let lastError
+	for (const delayMs of ATOMIC_RENAME_RETRY_DELAYS_MS) {
+		if (delayMs) await sleep(delayMs)
+		try {
+			await rename(tmp, filePath)
+			return true
+		}
+		catch (err) {
+			lastError = err
+			if (ATOMIC_RENAME_RETRY_CODES.has(err?.code)) continue
+			break
+		}
+	}
+	await cleanupAtomicTmp(tmp)
+	if (lastError?.code === 'ENOENT') return false
+	throw lastError
+}
+
+/**
+ * @param {string} line JSONL 单行
+ * @param {(row: object) => object} sanitize 行净化
+ * @returns {object | null} 解析后的对象；坏行/空行返回 null
+ */
+function parseJsonlLine(line, sanitize) {
+	const trimmed = String(line).trim()
+	if (!trimmed) return null
+	try {
+		return sanitize(JSON.parse(trimmed))
+	}
+	catch {
+		return null
+	}
+}
+
+/**
+ * 读取 JSONL 文件并解析为对象数组；缺失或读失败时返回空数组。
+ * @param {string} filePath 文件系统路径
+ * @param {{ sanitize?: (row: object) => object }} [options] 可选净化函数
+ * @returns {Promise<object[]>} 各行解析后的对象列表
+ */
+export async function readJsonl(filePath, options = {}) {
+	try {
+		const text = await readFile(filePath, 'utf8')
+		const sanitize = options.sanitize ?? (row => row)
+		/** @type {object[]} */
+		const rows = []
+		for (const line of text.split('\n')) {
+			const row = parseJsonlLine(line, sanitize)
+			if (row) rows.push(row)
+		}
+		return rows
+	}
+	catch {
+		return []
+	}
+}
+
+/**
+ * 流式读取 JSONL（避免整文件读入内存）。文件缺失（ENOENT）视为空流，
+ * 兼容 cleanup 竞态：群目录被删后台仍在尾巴上读它。
+ * @param {string} filePath 文件路径
+ * @param {{ sanitize?: (row: object) => object }} [options] 行净化
+ * @returns {AsyncGenerator<object>} 逐行事件
+ */
+export async function* readJsonlStream(filePath, options = {}) {
+	const sanitize = options.sanitize ?? (row => row)
+	const input = createReadStream(filePath, { encoding: 'utf8' })
+	// stream 内部异步 open 失败会触发 'error' 事件；提前订阅避免 unhandled error，
+	// 真实错误仍由下方 for-await 抛出，被外层 try/catch 收口。
+	input.on('error', () => { })
+	const lines = createInterface({ input, crlfDelay: Infinity })
+	try {
+		for await (const line of lines) {
+			const row = parseJsonlLine(line, sanitize)
+			if (row) yield row
+		}
+	}
+	catch (error) {
+		if (error?.code !== 'ENOENT') throw error
+	}
+}
+
+/**
+ * 流式过滤重写 JSONL：保留 `keep(row)===true` 的行。
+ * @param {string} filePath 目标路径
+ * @param {(row: object) => boolean} keep 保留谓词
+ * @param {{ sanitize?: (row: object) => object }} [options] 读行净化
+ * @returns {Promise<{ kept: number, dropped: number }>} 统计
+ */
+export async function rewriteJsonlKeeping(filePath, keep, options = {}) {
+	const dir = dirname(filePath)
+	await mkdir(dir, { recursive: true })
+	const tmp = atomicTmpPath(filePath)
+	/** @type {object[]} */
+	const buffer = []
+	let kept = 0
+	let dropped = 0
+	/** @returns {Promise<void>} */
+	const flush = async () => {
+		if (!buffer.length) return
+		let block = ''
+		for (const row of buffer)
+			block += `${JSON.stringify(row)}\n`
+		await appendFile(tmp, block, 'utf8')
+		buffer.length = 0
+	}
+	try {
+		for await (const row of readJsonlStream(filePath, options))
+			if (keep(row)) {
+				buffer.push(row)
+				kept++
+				if (buffer.length >= WRITE_JSONL_CHUNK_LINES)
+					await flush()
+			}
+			else dropped++
+		await flush()
+	}
+	catch { /* source missing */ }
+	if (kept > 0 || dropped > 0)
+		await finalizeAtomicRename(tmp, filePath)
+	else
+		try { await writeFile(filePath, '', 'utf8') }
+		catch { /* ok */ }
+
+	return { kept, dropped }
+}
+
+/**
+ * 读取 JSONL 末行事件的 `id`（DAG tip）；空文件为 null。
+ * @param {string} filePath 文件路径
+ * @returns {Promise<string | null>} tip event id
+ */
+export async function readJsonlTipId(filePath) {
+	try {
+		const fh = await open(filePath, 'r')
+		try {
+			const { size } = await fh.stat()
+			if (!size) return null
+			const chunk = Math.min(size, 65_536)
+			const buf = Buffer.alloc(chunk)
+			await fh.read(buf, 0, chunk, size - chunk)
+			const lines = buf.toString('utf8').split('\n').filter(Boolean)
+			const last = lines[lines.length - 1]
+			if (!last) return null
+			const row = JSON.parse(last)
+			return row?.id != null ? String(row.id) : null
+		}
+		finally {
+			await fh.close()
+		}
+	}
+	catch {
+		return null
+	}
+}
+
+/**
+ * 将单个 JSON 对象作为一行追加写入 JSONL（必要时创建父目录）。
+ * @param {string} filePath 目标文件路径
+ * @param {object} record 要序列化写入的对象
+ * @returns {Promise<void>}
+ */
+export async function appendJsonl(filePath, record) {
+	await mkdir(dirname(filePath), { recursive: true })
+	await appendFile(filePath, `${JSON.stringify(record)}\n`, 'utf8')
+}
+
+/**
+ * 流式重写 JSONL（临时文件 + rename），避免大数组 join 的内存峰值。
+ * @param {string} filePath 目标路径
+ * @param {object[]} records 行对象列表
+ * @returns {Promise<void>}
+ */
+export async function writeJsonl(filePath, records) {
+	const dir = dirname(filePath)
+	await mkdir(dir, { recursive: true })
+	const tmp = atomicTmpPath(filePath)
+	/** @returns {Generator<string>} JSONL 行 */
+	function* lines() {
+		for (const rec of records)
+			yield `${JSON.stringify(rec)}\n`
+	}
+	await pipeline(Readable.from(lines()), createWriteStream(tmp, { encoding: 'utf8' }))
+	await finalizeAtomicRename(tmp, filePath)
+}
+
+/**
+ * @param {string} filePath JSONL 路径
+ * @returns {string} 进程内互斥键
+ */
+export function jsonlMutexKey(filePath) {
+	return `jsonl:${filePath}`
+}
+
+/**
+ * 在 per-file 互斥锁内流式重写 JSONL（Social / Mailbox 等非 Chat 群锁域）。
+ * @param {string} filePath 目标路径
+ * @param {object[]} records 行对象列表
+ * @returns {Promise<void>}
+ */
+export async function writeJsonlSynced(filePath, records) {
+	return withAsyncMutex(jsonlMutexKey(filePath), () => writeJsonl(filePath, records))
+}
+
+/**
+ * 在 per-file 互斥锁内过滤重写 JSONL。
+ * @param {string} filePath 目标路径
+ * @param {(row: object) => boolean} keep 保留谓词
+ * @param {{ sanitize?: (row: object) => object }} [options] 读行净化
+ * @returns {Promise<{ kept: number, dropped: number }>} 统计
+ */
+export async function rewriteJsonlKeepingSynced(filePath, keep, options = {}) {
+	return withAsyncMutex(jsonlMutexKey(filePath), () => rewriteJsonlKeeping(filePath, keep, options))
+}
+
+/**
+ * 追加一行 JSONL 并 `fsync`。
+ * @param {string} filePath 目标路径
+ * @param {object} record 记录对象
+ * @returns {Promise<void>}
+ */
+export async function appendJsonlSynced(filePath, record) {
+	await mkdir(dirname(filePath), { recursive: true })
+	const fh = await open(filePath, 'a')
+	try {
+		await fh.appendFile(`${JSON.stringify(record)}\n`, 'utf8')
+		await fh.sync()
+	}
+	finally {
+		await fh.close()
+	}
+}
+
+/**
+ * 写入原子临时文件；若父目录已在 cleanup 竞态中消失（ENOENT）则返回 false。
+ * @param {string} tmp 临时文件路径
+ * @param {string} data 文件内容
+ * @returns {Promise<boolean>} 是否已写入
+ */
+async function writeAtomicTmp(tmp, data) {
+	try {
+		await writeFile(tmp, data, 'utf8')
+		return true
+	}
+	catch (err) {
+		if (err?.code === 'ENOENT') return false
+		throw err
+	}
+}
+
+/**
+ * 原子写入 JSON 文件（临时文件 + rename）。
+ * @param {string} filePath 目标路径
+ * @param {object} obj 可 JSON 序列化对象
+ * @returns {Promise<void>}
+ */
+export async function writeJsonAtomic(filePath, obj) {
+	const dir = dirname(filePath)
+	await mkdir(dir, { recursive: true })
+	const tmp = atomicTmpPath(filePath)
+	if (!await writeAtomicTmp(tmp, JSON.stringify(obj, null, '\t'))) return
+	await finalizeAtomicRename(tmp, filePath)
+}
+
+/**
+ * 原子写入 JSON 并对目标文件 `fsync`。
+ * @param {string} filePath 目标路径
+ * @param {object} obj 可序列化对象
+ * @returns {Promise<void>}
+ */
+export async function writeJsonAtomicSynced(filePath, obj) {
+	const dir = dirname(filePath)
+	await mkdir(dir, { recursive: true })
+	const tmp = atomicTmpPath(filePath)
+	if (!await writeAtomicTmp(tmp, JSON.stringify(obj, null, '\t'))) return
+	const fh = await open(tmp, 'r+')
+	try {
+		await fh.sync()
+	}
+	finally {
+		await fh.close()
+	}
+	if (!await finalizeAtomicRename(tmp, filePath)) return
+	const outFh = await open(filePath, 'r+')
+	try {
+		await outFh.sync()
+	}
+	finally {
+		await outFh.close()
+	}
+}

package/dag/strip_extensions.mjs

@@ -0,0 +1,18 @@
+/**
+ * DAG 事件行读盘时剥离的本地扩展键（不得进入验签域 / 联邦 wire）。
+ */
+import { isPlainObject } from '../wire/ingress.mjs'
+
+/** 落盘后 trusted 读路径仍须剥除的 sidecar 键。 */
+export const DAG_EVENT_LOCAL_EXTENSION_KEYS = new Set(['receivedAt', 'isRemote'])
+
+/**
+ * @param {unknown} row JSONL 行
+ * @returns {object} 剥离扩展键后的副本
+ */
+export function stripDagEventLocalExtensions(row) {
+	if (!isPlainObject(row)) return row
+	const out = { ...row }
+	for (const key of DAG_EVENT_LOCAL_EXTENSION_KEYS) delete out[key]
+	return out
+}

package/dag/tunables.json

@@ -0,0 +1,6 @@
+{
+	"archiveQuorumPeerMinFloor": 2,
+	"archiveQuorumPeerMinRatio": 0.25,
+	"archiveQuorumPeerStrictMinFloor": 2,
+	"archiveQuorumPeerStrictMinRatio": 0.5
+}

package/discovery/bt.mjs

@@ -0,0 +1,260 @@
+import { Buffer } from 'node:buffer'
+import process from 'node:process'
+
+const BT_SERVICE_UUID = 'f017f017f017f017f017f017f017f017'
+const BT_CHARACTERISTIC_UUID = 'f017f017f017f017f017f017f017f018'
+const BT_DEVICE_NAME = 'fount-bt'
+const MAX_ADVERT_BLOB_BYTES = 12 * 1024
+const PERIPHERAL_RESCAN_MS = 15_000
+
+/**
+ * 解析 Bluetooth 发现角色（scan / dual）。
+ * @returns {'scan' | 'dual'} 当前平台或环境变量指定的角色
+ */
+function resolveBtRole() {
+	const override = String(process.env.FOUNT_BT_DISCOVERY_ROLE || '').trim().toLowerCase()
+	if (override === 'dual') return 'dual'
+	if (override === 'scan') return 'scan'
+	return process.platform === 'win32' ? 'scan' : 'dual'
+}
+
+/**
+ * 加载 Noble BLE central 库。
+ * @returns {Promise<any>} Noble 运行时实例
+ */
+async function loadNoble() {
+	const mod = await import('@stoprocent/noble')
+	if (typeof mod.withBindings === 'function') return mod.withBindings('default')
+	return mod.default ?? mod
+}
+
+/**
+ * 加载 Bleno BLE peripheral 库。
+ * @returns {Promise<any>} Bleno 运行时实例
+ */
+async function loadBleno() {
+	const mod = await import('@stoprocent/bleno')
+	if (typeof mod.withBindings === 'function') return mod.withBindings('default')
+	return mod.default ?? mod
+}
+
+/**
+ * 将 advert 映射序列化为可读 characteristic blob。
+ * @param {Map<string, Uint8Array>} adverts topic → payload 映射
+ * @returns {Buffer} JSON 序列化后的 advert blob
+ */
+function serializeAdvertBlob(adverts) {
+	const entries = [...adverts.entries()].map(([topic, bytes]) => ({
+		topic,
+		data: Buffer.from(bytes).toString('base64'),
+	}))
+	const blob = Buffer.from(JSON.stringify({ entries }), 'utf8')
+	if (blob.byteLength > MAX_ADVERT_BLOB_BYTES)
+		throw new Error(`p2p: bluetooth advert blob exceeds ${MAX_ADVERT_BLOB_BYTES} bytes`)
+	return blob
+}
+
+/**
+ * 从 characteristic blob 解析 advert 列表。
+ * @param {Uint8Array | Buffer} raw 原始 blob 字节
+ * @returns {Array<{ topic: string, bytes: Uint8Array }>} 解析出的 advert 条目
+ */
+function parseAdvertBlob(raw) {
+	try {
+		const parsed = JSON.parse(Buffer.from(raw).toString('utf8'))
+		if (!Array.isArray(parsed?.entries)) return []
+		return parsed.entries.map(entry => ({
+			topic: String(entry?.topic || ''),
+			bytes: Uint8Array.from(Buffer.from(String(entry?.data || ''), 'base64')),
+		})).filter(entry => entry.topic && entry.bytes.byteLength)
+	}
+	catch {
+		return []
+	}
+}
+
+/**
+ * 向 topic bucket 注册监听器。
+ * @param {Map<string, Set<Function>>} bucket topic → 监听器集合
+ * @param {string} topic 订阅 topic
+ * @param {Function} listener advert 回调
+ * @returns {() => void} 取消订阅函数
+ */
+function addListener(bucket, topic, listener) {
+	if (!bucket.has(topic)) bucket.set(topic, new Set())
+	bucket.get(topic).add(listener)
+	return () => {
+		const set = bucket.get(topic)
+		if (!set) return
+		set.delete(listener)
+		if (!set.size) bucket.delete(topic)
+	}
+}
+
+/**
+ * 蓝牙发现提供者：
+ * - 默认在 Windows 上只启用 scan 侧发现（单适配器 central+peripheral 常冲突）
+ * - 其他平台默认 dual：advertise + scan
+ * - 通过固定 BLE service + read characteristic 传输完整 advert 列表，避免 31-byte 广告包限制
+ *
+ * @returns {import('./index.mjs').DiscoveryProvider} Bluetooth 发现提供者
+ */
+export function createBluetoothDiscoveryProvider() {
+	const role = resolveBtRole()
+	/** @type {Map<string, Uint8Array>} */
+	const adverts = new Map()
+	/** @type {Map<string, Set<Function>>} */
+	const advertListeners = new Map()
+	/** @type {Map<string, number>} */
+	const inspectedAt = new Map()
+	let nobleRuntime = null
+	let blenoRuntime = null
+	let scanningStarted = false
+	let advertisingStarted = false
+
+	/**
+	 * 初始化 peripheral（Bleno）运行时。
+	 * @returns {Promise<any|null>} Bleno 实例；scan 模式下为 null
+	 */
+	async function ensurePeripheralRuntime() {
+		if (role === 'scan') return null
+		if (blenoRuntime) return blenoRuntime
+		const bleno = await loadBleno()
+		const characteristic = new bleno.Characteristic({
+			uuid: BT_CHARACTERISTIC_UUID,
+			properties: ['read'],
+			/**
+			 * BLE characteristic 读请求回调。
+			 * @param {*} _handle Bleno handle（未使用）
+			 * @param {number} offset 读取偏移
+			 * @param {Function} callback Bleno 结果回调
+			 * @returns {void}
+			 */
+			onReadRequest(_handle, offset, callback) {
+				try {
+					const blob = serializeAdvertBlob(adverts)
+					if (offset > blob.length) {
+						callback(bleno.Characteristic.RESULT_INVALID_OFFSET)
+						return
+					}
+					callback(bleno.Characteristic.RESULT_SUCCESS, blob.subarray(offset))
+				}
+				catch {
+					callback(bleno.Characteristic.RESULT_UNLIKELY_ERROR)
+				}
+			},
+		})
+		await bleno.waitForPoweredOnAsync(5_000)
+		await bleno.setServicesAsync([
+			new bleno.PrimaryService({
+				uuid: BT_SERVICE_UUID,
+				characteristics: [characteristic],
+			}),
+		])
+		blenoRuntime = bleno
+		return bleno
+	}
+
+	/**
+	 * 刷新 BLE 广播状态。
+	 * @returns {Promise<void>}
+	 */
+	async function refreshAdvertising() {
+		if (role === 'scan') return
+		const bleno = await ensurePeripheralRuntime()
+		if (!bleno) return
+		if (!adverts.size) {
+			if (advertisingStarted) {
+				await bleno.stopAdvertisingAsync().catch(() => { })
+				advertisingStarted = false
+			}
+			return
+		}
+		serializeAdvertBlob(adverts)
+		if (!advertisingStarted) {
+			await bleno.startAdvertisingAsync(BT_DEVICE_NAME, [BT_SERVICE_UUID])
+			advertisingStarted = true
+		}
+	}
+
+	/**
+	 * 连接并读取远端 peripheral 的 advert characteristic。
+	 * @param {*} peripheral Noble peripheral 对象
+	 * @returns {Promise<void>}
+	 */
+	async function inspectPeripheral(peripheral) {
+		const inspectKey = String(peripheral?.id || peripheral?.address || '')
+		if (!inspectKey) return
+		const lastSeenAt = inspectedAt.get(inspectKey) || 0
+		if (Date.now() - lastSeenAt < PERIPHERAL_RESCAN_MS) return
+		inspectedAt.set(inspectKey, Date.now())
+		try {
+			await peripheral.connectAsync()
+			const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync(
+				[BT_SERVICE_UUID],
+				[BT_CHARACTERISTIC_UUID],
+			)
+			if (!characteristics?.length) return
+			const raw = await characteristics[0].readAsync()
+			for (const { topic, bytes } of parseAdvertBlob(raw)) {
+				const listeners = advertListeners.get(topic)
+				if (!listeners?.size) continue
+				for (const listener of listeners)
+					listener(bytes, { provider: 'bt', peripheralId: inspectKey })
+			}
+		}
+		catch {
+			/* ignore transient bluetooth failures */
+		}
+		finally {
+			try { await peripheral.disconnectAsync() } catch { /* ignore */ }
+		}
+	}
+
+	/**
+	 * 启动 Noble 扫描运行时。
+	 * @returns {Promise<void>}
+	 */
+	async function ensureScanRuntime() {
+		if (scanningStarted) return
+		const noble = await loadNoble()
+		await noble.waitForPoweredOnAsync()
+		noble.on('discover', peripheral => {
+			void inspectPeripheral(peripheral).catch(() => { })
+		})
+		await noble.startScanningAsync([BT_SERVICE_UUID], true)
+		nobleRuntime = noble
+		scanningStarted = true
+	}
+
+	return {
+		id: 'bt',
+		priority: 20,
+		caps: { canDiscover: true, canSignal: false, canRelay: false },
+		/**
+		 * 广播指定 topic 的 advert。
+		 * @param {string} topic advert 主题
+		 * @param {Uint8Array} bytes advert 载荷
+		 * @returns {Promise<() => void>} 取消广播函数
+		 */
+		async advertise(topic, bytes) {
+			if (role === 'scan') return () => { }
+			adverts.set(String(topic), Uint8Array.from(bytes))
+			await refreshAdvertising()
+			return () => {
+				adverts.delete(String(topic))
+				void refreshAdvertising().catch(() => { })
+			}
+		},
+		/**
+		 * 订阅指定 topic 的远端 advert。
+		 * @param {string} topic advert 主题
+		 * @param {Function} onAdvert advert 回调
+		 * @returns {Promise<() => void>} 取消订阅函数
+		 */
+		async subscribe(topic, onAdvert) {
+			await ensureScanRuntime()
+			return addListener(advertListeners, String(topic), onAdvert)
+		},
+	}
+}