@agent-p2p/peer 0.0.1

package/src/radio-peer.ts

@@ -0,0 +1,187 @@
+import {
+	type SignalEnvelope,
+	type Keypair,
+	generateKeypair,
+	peerId,
+	SignalBuilder,
+} from "@agent-p2p/core";
+import type { IndexeddbPersistence } from "y-indexeddb";
+import { TypedEmitter } from "./events.js";
+import type { PeerEventMap, PeerInfo, RadioPeerOptions } from "./types.js";
+import { DocManager } from "./yjs/doc-manager.js";
+import { setLocalPeer, getConnectedPeers } from "./yjs/awareness.js";
+import { TrysteroProvider } from "./transport/trystero-provider.js";
+import { createIndexedDBProvider } from "./transport/indexeddb.js";
+import { RoomPermissions } from "./permissions/room-permissions.js";
+
+const DEFAULT_OPTIONS: Required<Omit<RadioPeerOptions, "keypair">> = {
+	password: "",
+	maxSignalsPerChannel: 1000,
+	enablePersistence: true,
+	transport: { backend: "torrent" },
+};
+
+export class RadioPeer extends TypedEmitter<PeerEventMap> {
+	readonly stationId: string;
+	private _keypair!: Keypair;
+	private _peerId!: string;
+	private _opts: Required<Omit<RadioPeerOptions, "keypair">> & { keypair?: Keypair };
+	private _docManager!: DocManager;
+	private _provider!: TrysteroProvider;
+	private _idb: IndexeddbPersistence | null = null;
+	private _subscriptions = new Map<string, () => void>();
+	private _readyPromise: Promise<void>;
+	private _knownPeers = new Set<string>();
+	private _permissions!: RoomPermissions;
+	private _unsubRoles: (() => void) | null = null;
+
+	constructor(stationId: string, opts: RadioPeerOptions = {}) {
+		super();
+		this.stationId = stationId;
+		const { keypair, ...rest } = opts;
+		this._opts = { ...DEFAULT_OPTIONS, ...rest, keypair };
+		this._readyPromise = this._init();
+	}
+
+	private async _init(): Promise<void> {
+		this.emit("status", "connecting");
+
+		if (this._opts.keypair) {
+			this._keypair = this._opts.keypair;
+		} else {
+			this._keypair = await generateKeypair();
+		}
+		this._peerId = peerId(this._keypair.publicKey);
+
+		const guard = (pid: string, topic: string) => {
+			return this._permissions.canPublish(pid, topic);
+		};
+
+		this._docManager = new DocManager(this._opts.maxSignalsPerChannel, guard);
+
+		this._permissions = new RoomPermissions(this._docManager.doc);
+
+		const roomName = `agent-p2p:${this.stationId}`;
+
+		const transport = this._opts.transport;
+		this._provider = new TrysteroProvider(this._docManager.doc, roomName, {
+			backend: transport.backend,
+			password: this._opts.password || undefined,
+			relayUrls: transport.relayUrls,
+		});
+
+		await this._provider.connected;
+
+		if (this._opts.enablePersistence) {
+			try {
+				this._idb = createIndexedDBProvider(this._docManager.doc, roomName);
+			} catch {
+				// IndexedDB not available (e.g. Node.js) — skip
+			}
+		}
+
+		setLocalPeer(this._provider.awareness, this._peerId);
+
+		// TOFU: first peer becomes owner, later peers become members
+		if (!this._permissions.isInitialized) {
+			this._permissions.initializeAsOwner(this._peerId);
+		} else {
+			this._permissions.acceptExisting(this._peerId);
+		}
+
+		// Forward role changes as events
+		this._unsubRoles = this._permissions.observeRoles((pid, role) => {
+			this.emit("roles:changed", { peerId: pid, role });
+		});
+
+		this._provider.awareness.on("change", () => {
+			const current = getConnectedPeers(this._provider.awareness);
+			const currentIds = new Set(current.map((p) => p.peerId));
+
+			for (const p of current) {
+				if (!this._knownPeers.has(p.peerId)) {
+					this._knownPeers.add(p.peerId);
+					this.emit("peer:join", p);
+				}
+			}
+			for (const id of this._knownPeers) {
+				if (!currentIds.has(id)) {
+					this._knownPeers.delete(id);
+					this.emit("peer:leave", { peerId: id, joinedAt: 0 });
+				}
+			}
+		});
+
+		this.emit("status", "connected");
+	}
+
+	async ready(): Promise<void> {
+		return this._readyPromise;
+	}
+
+	get peerId(): string {
+		return this._peerId;
+	}
+
+	get keypair(): Keypair {
+		return this._keypair;
+	}
+
+	get permissions(): RoomPermissions {
+		return this._permissions;
+	}
+
+	async publish(topic: string, body: unknown): Promise<SignalEnvelope> {
+		await this._readyPromise;
+
+		if (!this._permissions.canPublish(this._peerId, topic)) {
+			this.emit("permission:denied", { topic, action: "publish" });
+			throw new Error(`Permission denied: cannot publish to "${topic}"`);
+		}
+
+		const signal = await new SignalBuilder()
+			.channel(topic)
+			.peer(this._peerId)
+			.body(body)
+			.buildSigned(this._keypair.privateKey, this._keypair.publicKey);
+
+		this._docManager.getChannel(topic).push(signal);
+		return signal;
+	}
+
+	subscribe(topic: string, fn: (signal: SignalEnvelope) => void): () => void {
+		const channel = this._docManager.getChannel(topic);
+		const readFilter = (signal: SignalEnvelope) => {
+			return this._permissions.canRead(this._peerId, signal.channel_topic);
+		};
+		const unsub = channel.observe((signals) => {
+			for (const s of signals) {
+				fn(s);
+				this.emit("signal", s);
+			}
+		}, readFilter);
+		this._subscriptions.set(topic, unsub);
+		return unsub;
+	}
+
+	getHistory(topic: string): SignalEnvelope[] {
+		return this._docManager.getChannel(topic).getAll();
+	}
+
+	getPeers(): PeerInfo[] {
+		return getConnectedPeers(this._provider.awareness);
+	}
+
+	disconnect(): void {
+		this.emit("status", "disconnected");
+		for (const unsub of this._subscriptions.values()) {
+			unsub();
+		}
+		this._subscriptions.clear();
+		this._unsubRoles?.();
+		this._provider.destroy();
+		this._idb?.destroy();
+		this._docManager.destroy();
+		this.removeAllListeners();
+	}
+}

package/src/transport/index.ts

@@ -0,0 +1,2 @@
+export { TrysteroProvider, type TrysteroConfig } from "./trystero-provider.js";
+export { createIndexedDBProvider } from "./indexeddb.js";

package/src/transport/indexeddb.ts

@@ -0,0 +1,9 @@
+import { IndexeddbPersistence } from "y-indexeddb";
+import type * as Y from "yjs";
+
+export function createIndexedDBProvider(
+	doc: Y.Doc,
+	roomName: string,
+): IndexeddbPersistence {
+	return new IndexeddbPersistence(roomName, doc);
+}

package/src/transport/trystero-provider.ts

@@ -0,0 +1,173 @@
+import * as Y from "yjs";
+import { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } from "y-protocols/awareness";
+import * as syncProtocol from "y-protocols/sync";
+import * as encoding from "lib0/encoding";
+import * as decoding from "lib0/decoding";
+import type { BaseRoomConfig, RelayConfig, Room, ActionSender, ActionReceiver } from "trystero";
+import type { SignalingBackend } from "../types.js";
+
+const MSG_SYNC = 0;
+const MSG_AWARENESS = 1;
+
+export interface TrysteroConfig {
+	backend?: SignalingBackend;
+	password?: string;
+	appId?: string;
+	relayUrls?: string[];
+}
+
+type JoinRoomFn = (config: BaseRoomConfig & RelayConfig, roomId: string) => Room;
+
+export class TrysteroProvider {
+	readonly doc: Y.Doc;
+	readonly awareness: Awareness;
+	readonly roomName: string;
+	readonly connected: Promise<void>;
+
+	private _room: Room | null = null;
+	private _send: ActionSender<ArrayBuffer> | null = null;
+	private _peers = new Set<string>();
+	private _destroyed = false;
+	private _onDocUpdate: (update: Uint8Array, origin: unknown) => void;
+
+	constructor(doc: Y.Doc, roomName: string, config: TrysteroConfig = {}) {
+		this.doc = doc;
+		this.roomName = roomName;
+		this.awareness = new Awareness(doc);
+
+		this._onDocUpdate = (update: Uint8Array, origin: unknown) => {
+			if (origin === this) return;
+			const encoder = encoding.createEncoder();
+			encoding.writeVarUint(encoder, MSG_SYNC);
+			syncProtocol.writeUpdate(encoder, update);
+			this._broadcast(encoding.toUint8Array(encoder));
+		};
+
+		this.connected = this._connect(config);
+	}
+
+	private async _connect(config: TrysteroConfig): Promise<void> {
+		const backend = config.backend ?? "torrent";
+
+		let joinRoom: JoinRoomFn;
+		switch (backend) {
+			case "torrent": {
+				const mod = await import("trystero/torrent");
+				joinRoom = mod.joinRoom;
+				break;
+			}
+			case "nostr": {
+				const mod = await import("trystero/nostr");
+				joinRoom = mod.joinRoom;
+				break;
+			}
+			case "mqtt": {
+				const mod = await import("trystero/mqtt");
+				joinRoom = mod.joinRoom;
+				break;
+			}
+		}
+
+		const roomConfig: BaseRoomConfig & RelayConfig = {
+			appId: config.appId ?? "agent-p2p",
+		};
+		if (config.password) roomConfig.password = config.password;
+		if (config.relayUrls) roomConfig.relayUrls = config.relayUrls;
+
+		if (this._destroyed) return;
+
+		const room = joinRoom(roomConfig, this.roomName);
+		this._room = room;
+
+		const [send, receive] = room.makeAction<ArrayBuffer>("yjs-sync");
+		this._send = send;
+
+		(receive as ActionReceiver<ArrayBuffer>)((data: ArrayBuffer, peerId: string) => {
+			this._handleMessage(new Uint8Array(data), peerId);
+		});
+
+		room.onPeerJoin((peerId) => {
+			this._peers.add(peerId);
+			this._sendSyncStep1(peerId);
+			this._sendAwareness(peerId);
+		});
+
+		room.onPeerLeave((peerId) => {
+			this._peers.delete(peerId);
+		});
+
+		this.doc.on("update", this._onDocUpdate);
+
+		this.awareness.on(
+			"update",
+			({ added, updated, removed }: { added: number[]; updated: number[]; removed: number[] }) => {
+				const changedClients = [...added, ...updated, ...removed];
+				const encoder = encoding.createEncoder();
+				encoding.writeVarUint(encoder, MSG_AWARENESS);
+				encoding.writeVarUint8Array(encoder, encodeAwarenessUpdate(this.awareness, changedClients));
+				this._broadcast(encoding.toUint8Array(encoder));
+			},
+		);
+	}
+
+	private _sendSyncStep1(peerId: string): void {
+		const encoder = encoding.createEncoder();
+		encoding.writeVarUint(encoder, MSG_SYNC);
+		syncProtocol.writeSyncStep1(encoder, this.doc);
+		this._sendTo(encoding.toUint8Array(encoder), peerId);
+	}
+
+	private _sendAwareness(peerId: string): void {
+		const clients = Array.from(this.awareness.getStates().keys());
+		if (clients.length === 0) return;
+		const encoder = encoding.createEncoder();
+		encoding.writeVarUint(encoder, MSG_AWARENESS);
+		encoding.writeVarUint8Array(encoder, encodeAwarenessUpdate(this.awareness, clients));
+		this._sendTo(encoding.toUint8Array(encoder), peerId);
+	}
+
+	private _handleMessage(data: Uint8Array, peerId: string): void {
+		const decoder = decoding.createDecoder(data);
+		const msgType = decoding.readVarUint(decoder);
+
+		switch (msgType) {
+			case MSG_SYNC: {
+				const encoder = encoding.createEncoder();
+				encoding.writeVarUint(encoder, MSG_SYNC);
+				syncProtocol.readSyncMessage(decoder, encoder, this.doc, this);
+				if (encoding.length(encoder) > 1) {
+					this._sendTo(encoding.toUint8Array(encoder), peerId);
+				}
+				break;
+			}
+			case MSG_AWARENESS: {
+				const update = decoding.readVarUint8Array(decoder);
+				applyAwarenessUpdate(this.awareness, update, peerId);
+				break;
+			}
+		}
+	}
+
+	private _broadcast(data: Uint8Array): void {
+		if (this._send && this._peers.size > 0) {
+			this._send(data.buffer as ArrayBuffer);
+		}
+	}
+
+	private _sendTo(data: Uint8Array, peerId: string): void {
+		if (this._send) {
+			this._send(data.buffer as ArrayBuffer, peerId);
+		}
+	}
+
+	destroy(): void {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		removeAwarenessStates(this.awareness, [this.doc.clientID], "provider destroyed");
+		this.doc.off("update", this._onDocUpdate);
+		this._room?.leave();
+		this._room = null;
+		this._send = null;
+		this._peers.clear();
+	}
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+import type { SignalEnvelope, Keypair } from "@agent-p2p/core";
+
+export type SignalingBackend = "torrent" | "nostr" | "mqtt";
+
+export interface TransportConfig {
+	backend?: SignalingBackend;
+	/** Relay/tracker URLs (BitTorrent trackers, Nostr relays, or MQTT brokers) */
+	relayUrls?: string[];
+}
+
+export interface RadioPeerOptions {
+	password?: string;
+	maxSignalsPerChannel?: number;
+	enablePersistence?: boolean;
+	keypair?: Keypair;
+	transport?: TransportConfig;
+}
+
+export interface PeerInfo {
+	peerId: string;
+	joinedAt: number;
+}
+
+export type PeerEventMap = {
+	signal: SignalEnvelope;
+	"peer:join": PeerInfo;
+	"peer:leave": PeerInfo;
+	"permission:denied": { topic: string; action: "publish" | "read" };
+	"roles:changed": { peerId: string; role: string };
+	status: "connecting" | "connected" | "disconnected";
+};

package/src/yjs/awareness.ts

@@ -0,0 +1,25 @@
+import type { PeerInfo } from "../types.js";
+
+export interface AwarenessLike {
+	setLocalStateField(field: string, value: unknown): void;
+	getStates(): Map<number, Record<string, unknown>>;
+	on(event: string, fn: (...args: unknown[]) => void): void;
+}
+
+export function setLocalPeer(awareness: AwarenessLike, peerId: string): void {
+	awareness.setLocalStateField("peer", {
+		peerId,
+		joinedAt: Date.now(),
+	});
+}
+
+export function getConnectedPeers(awareness: AwarenessLike): PeerInfo[] {
+	const peers: PeerInfo[] = [];
+	for (const [, state] of awareness.getStates()) {
+		const peer = state.peer as PeerInfo | undefined;
+		if (peer) {
+			peers.push(peer);
+		}
+	}
+	return peers;
+}

package/src/yjs/channel-array.ts

@@ -0,0 +1,60 @@
+import * as Y from "yjs";
+import type { SignalEnvelope } from "@agent-p2p/core";
+
+export type PublishGuard = (peerId: string, topic: string) => boolean;
+
+export class ChannelArray {
+	readonly array: Y.Array<SignalEnvelope>;
+	readonly topic: string;
+	private _maxSignals: number;
+	private _guard?: PublishGuard;
+
+	constructor(array: Y.Array<SignalEnvelope>, topic: string, maxSignals = 1000, guard?: PublishGuard) {
+		this.array = array;
+		this.topic = topic;
+		this._maxSignals = maxSignals;
+		this._guard = guard;
+	}
+
+	push(signal: SignalEnvelope): void {
+		if (this._guard && !this._guard(signal.provenance.peer_id, this.topic)) {
+			throw new Error(`Permission denied: cannot publish to "${this.topic}"`);
+		}
+		this.array.push([signal]);
+		this.trim();
+	}
+
+	getAll(): SignalEnvelope[] {
+		return this.array.toArray();
+	}
+
+	get length(): number {
+		return this.array.length;
+	}
+
+	observe(fn: (signals: SignalEnvelope[]) => void, filter?: (signal: SignalEnvelope) => boolean): () => void {
+		const handler = (event: Y.YArrayEvent<SignalEnvelope>) => {
+			const added: SignalEnvelope[] = [];
+			for (const item of event.changes.added) {
+				for (const content of item.content.getContent()) {
+					const signal = content as SignalEnvelope;
+					if (!filter || filter(signal)) {
+						added.push(signal);
+					}
+				}
+			}
+			if (added.length > 0) {
+				fn(added);
+			}
+		};
+		this.array.observe(handler);
+		return () => this.array.unobserve(handler);
+	}
+
+	private trim(): void {
+		if (this.array.length > this._maxSignals) {
+			const excess = this.array.length - this._maxSignals;
+			this.array.delete(0, excess);
+		}
+	}
+}

package/src/yjs/doc-manager.ts

@@ -0,0 +1,35 @@
+import * as Y from "yjs";
+import type { SignalEnvelope } from "@agent-p2p/core";
+import { ChannelArray, type PublishGuard } from "./channel-array.js";
+
+export class DocManager {
+	readonly doc: Y.Doc;
+	private _channels = new Map<string, ChannelArray>();
+	private _maxSignals: number;
+	private _guard?: PublishGuard;
+
+	constructor(maxSignals = 1000, guard?: PublishGuard) {
+		this.doc = new Y.Doc();
+		this._maxSignals = maxSignals;
+		this._guard = guard;
+	}
+
+	getChannel(topic: string): ChannelArray {
+		let ch = this._channels.get(topic);
+		if (!ch) {
+			const arr = this.doc.getArray<SignalEnvelope>(`ch:${topic}`);
+			ch = new ChannelArray(arr, topic, this._maxSignals, this._guard);
+			this._channels.set(topic, ch);
+		}
+		return ch;
+	}
+
+	getTopics(): string[] {
+		return Array.from(this._channels.keys());
+	}
+
+	destroy(): void {
+		this._channels.clear();
+		this.doc.destroy();
+	}
+}

package/src/yjs/index.ts

@@ -0,0 +1,3 @@
+export { DocManager } from "./doc-manager.js";
+export { ChannelArray, type PublishGuard } from "./channel-array.js";
+export { setLocalPeer, getConnectedPeers } from "./awareness.js";