vibedate 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -238,6 +238,200 @@ interface DiscoverySession {
  */
 declare function startDiscovery(opts: DiscoveryOptions): Promise<DiscoverySession>;
 
+/**
+ * A Nostr event, reduced to the fields this module touches. Structurally
+ * compatible with `nostr-tools`'s `Event`, so a finalized/verified event can be
+ * published and a relay-delivered event can be received without conversion.
+ */
+interface RelayEvent {
+    readonly kind: number;
+    /** Sender's secp256k1 (Nostr) pubkey, hex — public; the relay sees it. */
+    readonly pubkey: string;
+    /** Ciphertext for kind-4 DMs; a presence marker for the presence kind. */
+    readonly content: string;
+    readonly tags: readonly (readonly string[])[];
+    readonly created_at: number;
+    readonly id: string;
+    readonly sig: string;
+}
+/** A subscription filter: kinds + a `#t` conversation-tag match. */
+interface RelayFilter {
+    readonly kinds?: readonly number[];
+    readonly '#t'?: readonly string[];
+}
+/**
+ * The injection point between the relay link and the wire. The production
+ * implementation is {@link createNostrPoolTransport} (real wss:// relays via
+ * `nostr-tools` `SimplePool`); tests pass an in-memory fan-out. A real relay
+ * STORES events and replays matching stored events to new subscribers (that
+ * store-and-replay semantics is what makes the presence handshake work across
+ * arrival order) — a faithful mock must do the same.
+ */
+interface RelayTransport {
+    /** Publish a signed event to the relay(s). Fire-and-forget / best-effort. */
+    publish(event: RelayEvent): void;
+    /**
+     * Subscribe to events matching `filter`. Returns an unsubscribe. A faithful
+     * relay replays matching STORED events to a brand-new subscriber before any
+     * future ones, so the presence handshake is order-independent.
+     */
+    subscribe(filter: RelayFilter, onEvent: (event: RelayEvent) => void): () => void;
+    /** Close all relay connections. Idempotent. */
+    close(): void;
+}
+/**
+ * Default public Nostr relays (the public commons — we host none of them).
+ * Overridable via {@link createNostrPoolTransport}. These are well-known,
+ * generally-open relays; any reachable public relay works.
+ */
+declare const DEFAULT_RELAYS: readonly string[];
+/** Kind for encrypted DM payloads — the standard NIP-04 sealed-direct-message kind. */
+declare const VIBEDATE_MESSAGE_KIND = 4;
+/**
+ * Kind for the presence/rendezvous ping (parameterized-replaceable range). Its
+ * content is a constant marker that reveals nothing about the conversation; its
+ * `event.pubkey` is the sender's Nostr key (public by definition), and an
+ * `ed25519` tag binds it to the sender's identity so the receiver only accepts
+ * presence from the peer it expects.
+ */
+declare const VIBEDATE_PRESENCE_KIND = 30078;
+/**
+ * Derive the deterministic conversation tag two peers rendezvous on, from BOTH
+ * ed25519 identity pubkeys (sorted, hashed). Pure: both sides compute it
+ * byte-identically from data each already holds (their own identity + the
+ * peer's advertised pubkey), so NO extra exchange is needed to agree on the
+ * rendezvous point. The hash hides the underlying identities from anyone
+ * scanning the relay by tag.
+ */
+declare function conversationTag(myEd25519Hex: string, peerEd25519Hex: string): string;
+/**
+ * A relay-fallback link with the SAME shape as {@link PeerLink}, so callers can
+ * drop it in wherever a direct P2P link is used (pairing, the `live` chat loop).
+ *
+ * Implemented in v0: `send`/`onMessage`/`onClose`/`close` + `.hello` (text chat
+ * over NIP-04). `sendMedia`/`sendSignal`/`onMedia`/`onSignal` are accepted as
+ * no-ops so the link is type-interchangeable with a direct PeerLink — chunked
+ * media + WebRTC signaling over the relay are `// ponytail:` follow-ups (a relay
+ * link is a fallback for peers who can't connect at all, where plain text chat
+ * is the priority).
+ */
+type NostrRelayLink = PeerLink;
+/** Options for {@link createNostrRelayLink}. */
+interface CreateNostrRelayLinkOptions {
+    /** This peer's Nostr secp256k1 keypair (see {@link loadOrCreateNostrKey}). */
+    readonly myNostr: {
+        readonly sk: Uint8Array;
+        readonly pubkey: string;
+    };
+    /** This peer's ed25519 identity pubkey (hex) — half of the convTag input. */
+    readonly myEd25519Hex: string;
+    /** The REMOTE peer's ed25519 identity pubkey (hex) — the other convTag half. */
+    readonly peerEd25519Hex: string;
+    /** The remote peer's identity, surfaced as the link's `.hello`. */
+    readonly hello: PeerHello;
+    /** The injected relay transport (real pool OR an in-memory mock). */
+    readonly transport: RelayTransport;
+}
+/**
+ * Build a {@link NostrRelayLink} over the injected {@link RelayTransport}. The
+ * link immediately subscribes to the conversation tag and publishes its presence
+ * so the peer can learn this side's Nostr pubkey (the bootstrap for NIP-04).
+ * Resolves once subscribed + presence published. Async only because
+ * `nostr-tools` (NIP-04 + event signing) is lazy-imported on first use.
+ */
+declare function createNostrRelayLink(opts: CreateNostrRelayLinkOptions): Promise<NostrRelayLink>;
+/**
+ * Build a real {@link RelayTransport} over public Nostr relays via
+ * `nostr-tools`'s `SimplePool`. `nostr-tools` (and its WebSocket stack) is
+ * imported lazily here. Async because constructing the pool may need the
+ * lazy module load. The returned transport:
+ *   - `publish` is fire-and-forget (publishes to all relays, awaits none);
+ *   - `subscribe` mirrors `SimplePool.subscribeMany` and returns an unsub;
+ *   - `close` tears the pool down.
+ */
+declare function createNostrPoolTransport(urls?: readonly string[]): Promise<RelayTransport>;
+
+/** Namespace prefix so room topics never collide with league topics (or anything
+ *  else on the DHT). Mirrors {@link p2p.TOPIC_PREFIX} for the 1:1 path. */
+declare const ROOM_TOPIC_PREFIX = "vibedate-room:";
+/**
+ * Derive the 32-byte DHT topic for a named room. Deterministic: everyone who
+ * joins the same room name anywhere in the world hashes to the same topic,
+ * which is the entire discovery mechanism. Pure (mirrors {@link p2p.leagueTopic}).
+ */
+declare function roomTopic(name: string): Buffer;
+/** A room member = a connected, handshaken peer. Same shape as a live peer. */
+type RoomMember = PeerHello;
+/** One group chat message: a `msg` frame's payload tagged with the sender. */
+interface RoomMessage {
+    /** Sender's handle (from the validated hello — UNTRUSTED display data). */
+    readonly from: string;
+    readonly id: string;
+    readonly text: string;
+    readonly at: number;
+}
+interface RoomOptions {
+    /** What we broadcast. Must already be consent-gated by the caller. */
+    readonly hello: PeerHello;
+    /** Room name → its own DHT topic (see {@link roomTopic}). */
+    readonly room: string;
+    /** DHT bootstrap nodes; omit for the public DHT. Tests pass a local testnet. */
+    readonly bootstrap?: ReadonlyArray<{
+        readonly host: string;
+        readonly port: number;
+    }>;
+    /** Where peers.json lives. Defaults to ~/.vibedating. */
+    readonly stateDir?: string;
+    /** Predicate over a blocked handle — a blocked peer's hello is dropped exactly
+     *  like in 1:1 discovery. Default: nothing blocked. */
+    readonly isBlocked?: (handle: string) => boolean;
+    /** Match-notification sink (tests capture with a fake). Best-effort. */
+    readonly notify?: NotifySink;
+}
+interface RoomSession {
+    /** The room name. */
+    readonly room: string;
+    /** The joined DHT topic (see {@link roomTopic}). */
+    readonly topic: Buffer;
+    /** What we broadcast. */
+    readonly hello: PeerHello;
+    /** Live member set, keyed by handle (excludes self). Mirrors the live view
+     *  semantics of {@link p2p.DiscoverySession.peers}. */
+    readonly members: ReadonlyMap<string, RoomMember>;
+    /** Resolves when the first DHT announce/lookup round completes. */
+    readonly ready: Promise<unknown>;
+    /**
+     * Broadcast a text message to ALL room members (fan-out: one `msg` frame per
+     * member's {@link PeerLink}). Returns the handles the message was sent to.
+     * Best-effort: a member whose link has just closed is skipped silently.
+     */
+    broadcast(text: string): readonly string[];
+    /** Register a callback fired for each incoming group message (with sender). */
+    onMessage(cb: (m: RoomMessage) => void): void;
+    /** Register a callback fired whenever the member roster changes (join/leave). */
+    onRoster(cb: (members: readonly RoomMember[]) => void): void;
+    /** Register a callback fired for each incoming `rtc-*` signaling frame,
+     *  tagged with the sender's handle (full-mesh video signaling). */
+    onSignal(cb: (from: string, frame: RtcFrame) => void): void;
+    /** Relay one `rtc-*` signaling frame to one member (by handle). */
+    sendSignal(handle: string, frame: RtcFrame): void;
+    /** The underlying {@link PeerLink} to a member (by handle), or undefined. */
+    linkFor(handle: string): PeerLink | undefined;
+    /** Leave the room and destroy the node. Idempotent. */
+    close(): Promise<void>;
+}
+/**
+ * Join (or create) a named room on the DHT and discover ALL members. CONSENT
+ * GATE LIVES WITH THE CALLER — never call this without the `share:live` grant
+ * (or an explicit opt-in in the same breath), exactly like
+ * {@link p2p.startDiscovery}.
+ *
+ * Resolves once the first DHT announce/lookup round completes; the returned
+ * session's {@link RoomSession.members} map + {@link RoomSession.onRoster}
+ * callback track every member that joins or leaves thereafter.
+ */
+declare function startRoom(opts: RoomOptions): Promise<RoomSession>;
+
 /**
  * Persistent ed25519 identity — binds a handle to a keypair so a peer cannot
  * impersonate it.
@@ -307,6 +501,28 @@ type IdentityVerdict = 'verified' | 'legacy' | 'drop';
  * caller (discovery) turns 'drop' into "never recorded, never paired".
  */
 declare function classifyHelloIdentity(hello: HelloClaims & Partial<IdentityProof>): IdentityVerdict;
+/**
+ * A separate secp256k1 keypair for the Nostr relay fallback (see relay.ts).
+ * Kept DISTINCT from the ed25519 {@link Identity} on purpose: NIP-04 encryption
+ * requires a secp256k1 key, and reusing or deriving the ed25519 key for that
+ * would cross two unrelated cryptographic curves. The private key is persisted
+ * at `<dir>/nostr.json` (mode 0600) and never leaves the file; only the
+ * secp256k1 public key (hex) is ever published on a relay.
+ */
+interface NostrKey {
+    /** 32-byte secp256k1 secret key — the NIP-04 decrypt/encrypt key. Never sent. */
+    readonly sk: Uint8Array;
+    /** secp256k1 public key, hex (64 chars) — safe to publish; the relay sees it. */
+    readonly pubkey: string;
+}
+/**
+ * Load the persistent secp256k1 Nostr key, generating + storing it (mode 0600)
+ * on first use. A missing or corrupt file is (re)generated — never throws on
+ * disk content. Idempotent across runs: same file → same key. `nostr-tools` is
+ * imported LAZILY (only when a key must be generated) so non-relay commands
+ * never pay for the secp256k1 stack.
+ */
+declare function loadOrCreateNostrKey(dir?: string): Promise<NostrKey>;
 
 /**
  * A usage league (volume bucket). `max` is inclusive; the top tier is open-ended
@@ -423,4 +639,4 @@ declare const CANDIDATES: readonly Candidate[];
  */
 declare function matches(myLeague: string, candidates?: readonly Candidate[]): Candidate[];
 
-export { BELOW_LEAGUE, CANDIDATES, type Candidate, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type PeerHello, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, serializeHandshake, signHelloClaims, startDiscovery, verifyHelloClaims };
+export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, type PeerHello, ROOM_TOPIC_PREFIX, type RelayEvent, type RelayFilter, type RelayTransport, type RoomMember, type RoomMessage, type RoomOptions, type RoomSession, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, roomTopic, serializeHandshake, signHelloClaims, startDiscovery, startRoom, verifyHelloClaims };

package/dist/index.js

@@ -1,20 +1,28 @@
 import {
   BELOW_LEAGUE,
   CANDIDATES,
+  DEFAULT_RELAYS,
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
+  ROOM_TOPIC_PREFIX,
   TOKENS_ENV,
   TOPIC_PREFIX,
+  VIBEDATE_MESSAGE_KIND,
+  VIBEDATE_PRESENCE_KIND,
   allLeagueNames,
   canonicalHelloClaims,
   classifyHelloIdentity,
+  conversationTag,
   createConsentLedger,
+  createNostrPoolTransport,
+  createNostrRelayLink,
   league,
   leagueIndex,
   leagueTopic,
   leaguesWithin,
   loadOrCreateIdentity,
+  loadOrCreateNostrKey,
   loadPeers,
   matches,
   parseHandshake,
@@ -22,28 +30,38 @@ import {
   readUsage,
   recordPeer,
   recordPeerMessage,
+  roomTopic,
   serializeHandshake,
   signHelloClaims,
   startDiscovery,
+  startRoom,
   verifyHelloClaims
-} from "./chunk-KKWP4DLY.js";
+} from "./chunk-HDHJLZZG.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,
+  DEFAULT_RELAYS,
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
+  ROOM_TOPIC_PREFIX,
   TOKENS_ENV,
   TOPIC_PREFIX,
+  VIBEDATE_MESSAGE_KIND,
+  VIBEDATE_PRESENCE_KIND,
   allLeagueNames,
   canonicalHelloClaims,
   classifyHelloIdentity,
+  conversationTag,
   createConsentLedger,
+  createNostrPoolTransport,
+  createNostrRelayLink,
   league,
   leagueIndex,
   leagueTopic,
   leaguesWithin,
   loadOrCreateIdentity,
+  loadOrCreateNostrKey,
   loadPeers,
   matches,
   parseHandshake,
@@ -51,8 +69,10 @@ export {
   readUsage,
   recordPeer,
   recordPeerMessage,
+  roomTopic,
   serializeHandshake,
   signHelloClaims,
   startDiscovery,
+  startRoom,
   verifyHelloClaims
 };

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   runMcp
-} from "./chunk-I5U3O4RH.js";
-import "./chunk-KKWP4DLY.js";
+} from "./chunk-ZD6JBWEW.js";
+import "./chunk-HDHJLZZG.js";
 export {
   runMcp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibedate",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Dating by tokens — matched by usage league across agentic CLIs. Raw usage stays local; only your league is shared. CLI + local web app + MCP. Local-first.",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@pooriaarab/vibe-core": "^0.3.0",
-    "hyperswarm": "^4.17.0"
+    "hyperswarm": "^4.17.0",
+    "nostr-tools": "^2.24.1"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",