vibedate 0.5.0 → 0.6.0

package/dist/{chunk-I5U3O4RH.js → chunk-JIBC3OHV.js}

@@ -2,7 +2,7 @@ import {
   CANDIDATES,
   loadProfile,
   matches
-} from "./chunk-KKWP4DLY.js";
+} from "./chunk-VZXPYU2C.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/{chunk-KKWP4DLY.js → chunk-VZXPYU2C.js}

@@ -388,6 +388,44 @@ function classifyHelloIdentity(hello) {
   if (hello.nonce === void 0 || hello.sig === void 0) return "drop";
   return verifyHelloClaims(hello, { pubkey: hello.pubkey, nonce: hello.nonce, sig: hello.sig }) ? "verified" : "drop";
 }
+var NOSTR_FILE = "nostr.json";
+function nostrPath(dir) {
+  return path2.join(dir, NOSTR_FILE);
+}
+function isStoredNostrKey(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const r = data;
+  return typeof r["sk"] === "string" && /^[0-9a-f]{64}$/.test(r["sk"]) && typeof r["pubkey"] === "string" && /^[0-9a-f]{64}$/.test(r["pubkey"]) && typeof r["createdAt"] === "string";
+}
+async function loadOrCreateNostrKey(dir = defaultStateDir()) {
+  try {
+    const raw = readFileSync2(nostrPath(dir), "utf8");
+    const data = JSON.parse(raw);
+    if (isStoredNostrKey(data)) {
+      try {
+        chmodSync(nostrPath(dir), 384);
+      } catch {
+      }
+      return { sk: Buffer.from(data.sk, "hex"), pubkey: data.pubkey };
+    }
+  } catch {
+  }
+  const { generateSecretKey, getPublicKey } = await import("nostr-tools");
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+  const skHex = Buffer.from(sk).toString("hex");
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(
+    nostrPath(dir),
+    JSON.stringify({ sk: skHex, pubkey, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
+    { encoding: "utf8", mode: 384 }
+  );
+  try {
+    chmodSync(nostrPath(dir), 384);
+  } catch {
+  }
+  return { sk, pubkey };
+}
 
 // src/link.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -909,6 +947,204 @@ async function startDiscovery(opts) {
   };
 }
 
+// src/relay.ts
+import { createHash as createHash2 } from "crypto";
+var DEFAULT_RELAYS = [
+  "wss://relay.damus.io",
+  "wss://nostr.mom",
+  "wss://relay.snort.social"
+];
+var VIBEDATE_MESSAGE_KIND = 4;
+var VIBEDATE_PRESENCE_KIND = 30078;
+var PRESENCE_D_TAG = "vibedating";
+var PRESENCE_MARKER = JSON.stringify({ app: "vibedating", v: 1 });
+var ED25519_TAG = "ed25519";
+function conversationTag(myEd25519Hex, peerEd25519Hex) {
+  const lo = myEd25519Hex < peerEd25519Hex ? myEd25519Hex : peerEd25519Hex;
+  const hi = myEd25519Hex < peerEd25519Hex ? peerEd25519Hex : myEd25519Hex;
+  return createHash2("sha256").update(`vibedate:nostr:${lo}:${hi}`, "utf8").digest("hex");
+}
+var nostrPromise;
+function nostr() {
+  if (!nostrPromise) nostrPromise = import("nostr-tools");
+  return nostrPromise;
+}
+function tagValue(event, name) {
+  for (const tag of event.tags) {
+    if (tag[0] === name && typeof tag[1] === "string") return tag[1];
+  }
+  return void 0;
+}
+async function createNostrRelayLink(opts) {
+  const { finalizeEvent, nip04 } = await nostr();
+  const { myNostr, myEd25519Hex, peerEd25519Hex, hello, transport } = opts;
+  const convTag = conversationTag(myEd25519Hex, peerEd25519Hex);
+  const messageCbs = /* @__PURE__ */ new Set();
+  const closeCbs = /* @__PURE__ */ new Set();
+  const mediaCbs = /* @__PURE__ */ new Set();
+  const signalCbs = /* @__PURE__ */ new Set();
+  let closed = false;
+  let peerNostrPubkey;
+  const pending = [];
+  const publish = (template) => {
+    let event;
+    try {
+      event = finalizeEvent(
+        { ...template, created_at: Math.floor(Date.now() / 1e3) },
+        myNostr.sk
+      );
+    } catch {
+      return;
+    }
+    try {
+      transport.publish(event);
+    } catch {
+    }
+  };
+  const publishPresence = () => {
+    publish({
+      kind: VIBEDATE_PRESENCE_KIND,
+      content: PRESENCE_MARKER,
+      tags: [
+        ["d", PRESENCE_D_TAG],
+        ["t", convTag],
+        [ED25519_TAG, myEd25519Hex]
+      ]
+    });
+  };
+  const sendEncrypted = (text, recipientPubkey) => {
+    let ciphertext;
+    try {
+      ciphertext = nip04.encrypt(myNostr.sk, recipientPubkey, text);
+    } catch {
+      return;
+    }
+    publish({
+      kind: VIBEDATE_MESSAGE_KIND,
+      content: ciphertext,
+      tags: [
+        ["t", convTag],
+        ["p", recipientPubkey],
+        [ED25519_TAG, myEd25519Hex]
+      ]
+    });
+  };
+  const flushPending = () => {
+    if (peerNostrPubkey === void 0) return;
+    while (pending.length > 0) {
+      const text = pending.shift();
+      if (text !== void 0) sendEncrypted(text, peerNostrPubkey);
+    }
+  };
+  const unsubscribe = transport.subscribe({ "#t": [convTag] }, (event) => {
+    if (closed) return;
+    if (event.pubkey === myNostr.pubkey) return;
+    if (event.kind === VIBEDATE_PRESENCE_KIND) {
+      const claimedEd = tagValue(event, ED25519_TAG);
+      if (claimedEd !== peerEd25519Hex) return;
+      peerNostrPubkey = event.pubkey;
+      flushPending();
+      return;
+    }
+    if (event.kind === VIBEDATE_MESSAGE_KIND) {
+      let plaintext;
+      try {
+        const sender = peerNostrPubkey ?? event.pubkey;
+        plaintext = nip04.decrypt(myNostr.sk, sender, event.content);
+      } catch {
+        return;
+      }
+      peerNostrPubkey = event.pubkey;
+      const msg = { id: event.id, text: plaintext, at: event.created_at * 1e3 };
+      for (const cb of messageCbs) cb(msg);
+      return;
+    }
+  });
+  publishPresence();
+  return {
+    hello,
+    send(text) {
+      if (closed) return;
+      if (peerNostrPubkey === void 0) {
+        pending.push(text);
+        return;
+      }
+      sendEncrypted(text, peerNostrPubkey);
+    },
+    // ponytail: chunked media over the relay (mirror link.ts media frames as
+    // kind-4 payloads). For v0 a relay link carries text only.
+    async sendMedia() {
+      return { id: "", size: 0 };
+    },
+    // ponytail: relay WebRTC signaling (rtc-offer/answer/ice as kind-4 payloads)
+    // so A/V could also fall back through the relay. v0: text only.
+    sendSignal() {
+    },
+    onMessage(cb) {
+      messageCbs.add(cb);
+    },
+    onMedia(cb) {
+      mediaCbs.add(cb);
+    },
+    onSignal(cb) {
+      signalCbs.add(cb);
+    },
+    onClose(cb) {
+      closeCbs.add(cb);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      try {
+        unsubscribe();
+      } catch {
+      }
+      try {
+        transport.close();
+      } catch {
+      }
+    }
+  };
+}
+async function createNostrPoolTransport(urls = DEFAULT_RELAYS) {
+  const { SimplePool } = await nostr();
+  const pool = new SimplePool();
+  const relays = [...urls];
+  return {
+    publish(event) {
+      try {
+        const results = pool.publish(relays, event);
+        Promise.allSettled(results).catch(() => {
+        });
+      } catch {
+      }
+    },
+    subscribe(filter, onEvent) {
+      const closer = pool.subscribeMany(
+        relays,
+        filter,
+        { onevent: (e) => onEvent(e) }
+      );
+      return () => {
+        try {
+          closer.close();
+        } catch {
+        }
+      };
+    },
+    close() {
+      try {
+        pool.close(relays);
+      } catch {
+      }
+      try {
+        pool.destroy();
+      } catch {
+      }
+    }
+  };
+}
+
 // src/index.ts
 var LEAGUES = [
   { name: "1M", min: 1e6, max: 4999999 },
@@ -1067,6 +1303,7 @@ export {
   signHelloClaims,
   verifyHelloClaims,
   classifyHelloIdentity,
+  loadOrCreateNostrKey,
   sanitizePeerText,
   TOPIC_PREFIX,
   leagueTopic,
@@ -1077,6 +1314,12 @@ export {
   recordPeer,
   recordPeerMessage,
   startDiscovery,
+  DEFAULT_RELAYS,
+  VIBEDATE_MESSAGE_KIND,
+  VIBEDATE_PRESENCE_KIND,
+  conversationTag,
+  createNostrRelayLink,
+  createNostrPoolTransport,
   LEAGUES,
   BELOW_LEAGUE,
   league,

package/dist/cli.d.ts

@@ -17,6 +17,12 @@ interface ParsedArgs {
     readonly to: string | undefined;
     /** `live --keep-alive`: stay in the swarm after stdin EOF. Default false. */
     readonly keepAlive: boolean;
+    /**
+     * `live --via-relay` / `discover --via-relay`: route through public Nostr relays
+     * (NIP-04 e2e) when direct hyperdht hole-punching fails. v0 explicit opt-in;
+     * auto-fallback-on-timeout is a follow-up. Default false.
+     */
+    readonly viaRelay: boolean;
 }
 /**
  * Parse argv (the slice AFTER the program name) into a command + options.

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-I5U3O4RH.js";
+} from "./chunk-JIBC3OHV.js";
 import {
   CANDIDATES,
   DEFAULT_HANDLE,
@@ -12,6 +12,8 @@ import {
   allLeagueNames,
   canShareLive,
   connectProfile,
+  createNostrPoolTransport,
+  createNostrRelayLink,
   defaultStateDir,
   grantLiveConsent,
   isBlocked,
@@ -22,6 +24,7 @@ import {
   loadBlocklist,
   loadHandle,
   loadOrCreateIdentity,
+  loadOrCreateNostrKey,
   loadPeers,
   loadProfile,
   matches,
@@ -35,7 +38,7 @@ import {
   saveHandle,
   signHelloClaims,
   startDiscovery
-} from "./chunk-KKWP4DLY.js";
+} from "./chunk-VZXPYU2C.js";
 
 // src/cli.ts
 import readline from "readline";
@@ -2112,7 +2115,7 @@ async function handle(req, res, opts) {
 }
 
 // src/cli.ts
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -2127,7 +2130,8 @@ function parseArgs(argv) {
     any: false,
     arg: void 0,
     to: void 0,
-    keepAlive: false
+    keepAlive: false,
+    viaRelay: false
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -2140,7 +2144,8 @@ function parseArgs(argv) {
         any: false,
         arg: void 0,
         to: void 0,
-        keepAlive: false
+        keepAlive: false,
+        viaRelay: false
       };
     }
     if (a === "--help" || a === "-h") {
@@ -2152,7 +2157,8 @@ function parseArgs(argv) {
         any: false,
         arg: void 0,
         to: void 0,
-        keepAlive: false
+        keepAlive: false,
+        viaRelay: false
       };
     }
     if (a === "--live") {
@@ -2163,6 +2169,10 @@ function parseArgs(argv) {
       out = { ...out, keepAlive: true };
       continue;
     }
+    if (a === "--via-relay") {
+      out = { ...out, viaRelay: true };
+      continue;
+    }
     if (a === "--any") {
       out = { ...out, any: true };
       continue;
@@ -2381,7 +2391,7 @@ async function cmdMatches(live) {
   process2.stdout.write("\n");
   return 0;
 }
-async function cmdDiscover(live, any) {
+async function cmdDiscover(live, any, viaRelay) {
   const profile = loadProfile();
   if (!profile) {
     process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
@@ -2400,6 +2410,9 @@ async function cmdDiscover(live, any) {
 `);
   process2.stdout.write(`  ${MARKS_LEGEND}
 `);
+  if (viaRelay) {
+    process2.stdout.write("  \u2022 --via-relay: the relay fallback reaches a KNOWN peer over Nostr \u2014 use `live --via-relay --to @handle`\n");
+  }
   const { topics, acceptLeague } = discoveryScope(profile.league, any);
   const session = await startDiscovery({
     hello,
@@ -2489,7 +2502,100 @@ async function cmdOpen(port, any) {
 function shouldKeepAlive(flag, stdinIsTTY) {
   return flag || stdinIsTTY !== true;
 }
-async function cmdLive(dating, any, to, keepAlive) {
+async function cmdLiveViaRelay(profile, to) {
+  const target = to !== void 0 ? normalizeHandle(to) : null;
+  if (to !== void 0 && target === null) {
+    process2.stderr.write(`invalid target handle: ${to}
+`);
+    return 1;
+  }
+  if (target === null) {
+    process2.stderr.write(
+      "relay mode (v0) targets one known peer \u2014 use: vibedating live --via-relay --to <@handle>\n(discover the peer first with `vibedating discover --live`, then reach them over the relay).\n"
+    );
+    return 1;
+  }
+  const peer = loadPeers().find((p) => sameHandle(p.handle, target) && typeof p.pubkey === "string");
+  if (peer === void 0 || peer.pubkey === void 0) {
+    process2.stderr.write(
+      `${target} is not a known peer with an identity pubkey. Run \`vibedating discover --live\` first to meet them over the DHT, then retry --via-relay.
+`
+    );
+    return 1;
+  }
+  const identity = loadOrCreateIdentity();
+  process2.stdout.write("\n");
+  process2.stdout.write(`  ${LIVE_NOTICE}
+`);
+  process2.stdout.write(
+    `  routing e2e chat to ${sanitizePeerText(peer.handle)} through public Nostr relays (direct hole-punch fallback)
+`
+  );
+  process2.stdout.write("  \u2022 the relay stores only ciphertext \u2014 it cannot read your chat\n");
+  const myNostr = await loadOrCreateNostrKey();
+  const transport = await createNostrPoolTransport();
+  const link = await createNostrRelayLink({
+    myNostr,
+    myEd25519Hex: identity.publicKeyHex,
+    peerEd25519Hex: peer.pubkey,
+    hello: peer,
+    transport
+  });
+  const pairing = createPairing();
+  pairing.onMatch((l) => {
+    if (l === void 0) {
+      process2.stdout.write("  \xB7 relay peer gone\n");
+      return;
+    }
+    const { qual } = peerDirection(profile.league, l.hello.league);
+    process2.stdout.write(
+      `  \xB7 relayed to ${sanitizePeerText(l.hello.handle)} (${l.hello.league}${qual} \xB7 ${l.hello.harness}) ${usageMark(l.hello)}${idMark(l.hello)}
+`
+    );
+    l.onMessage((m) => {
+      process2.stdout.write(`  <${sanitizePeerText(l.hello.handle)}> ${sanitizePeerText(m.text)}
+`);
+    });
+  });
+  pairing.add(link);
+  process2.stdout.write("  type to chat \xB7 /quit\n");
+  process2.stdout.write("  (Ctrl+C to stop)\n\n");
+  const rl = readline.createInterface({ input: process2.stdin, terminal: false });
+  const stop = () => {
+    rl.close();
+  };
+  process2.once("SIGINT", stop);
+  process2.once("SIGTERM", stop);
+  let quitRequested = false;
+  for await (const line of rl) {
+    const text = line.trim();
+    if (text === "/quit") {
+      quitRequested = true;
+      break;
+    }
+    if (text === "/next") {
+      process2.stdout.write("  \xB7 relay mode targets one peer \u2014 /next re-announces presence\n");
+      continue;
+    }
+    if (text === "") continue;
+    const cur2 = pairing.current();
+    if (cur2 !== void 0) {
+      cur2.send(text);
+    } else {
+      process2.stdout.write("  \xB7 no relay peer yet \u2014 waiting for the presence exchange\u2026\n");
+    }
+  }
+  process2.removeListener("SIGINT", stop);
+  process2.removeListener("SIGTERM", stop);
+  void quitRequested;
+  const cur = pairing.current();
+  if (cur !== void 0) cur.close();
+  process2.stdout.write("\n  closing relay link\u2026\n");
+  link.close();
+  process2.stdout.write("\n");
+  return 0;
+}
+async function cmdLive(dating, any, to, keepAlive, viaRelay) {
   const profile = loadProfile();
   if (!profile) {
     process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
@@ -2506,6 +2612,7 @@ async function cmdLive(dating, any, to, keepAlive) {
     process2.stderr.write("Could not enable live discovery. Try `vibedating discover --live`.\n");
     return 1;
   }
+  if (viaRelay) return cmdLiveViaRelay(profile, to);
   const hello = buildHello(profile);
   process2.stdout.write("\n");
   process2.stdout.write(`  ${LIVE_NOTICE}
@@ -2846,10 +2953,11 @@ Usage:
   vibedating connect            Read your usage, compute + print your league
   vibedating matches [--live]   List candidates in your league (live peers if any)
   vibedating discover [--live] [--any]  Find live peers over the DHT (your league + adjacent; --any = everyone)
-  vibedating live [--dating] [--any] [--to @handle] [--keep-alive]  Live chat (your league
+  vibedating live [--dating] [--any] [--to @handle] [--keep-alive] [--via-relay]  Live chat (your league
                                 + adjacent; --any = everyone; /next or --dating pick;
                                 --to targets one peer; --keep-alive survives stdin EOF \u2014
-                                automatic when stdin is not a TTY)
+                                automatic when stdin is not a TTY; --via-relay routes e2e chat
+                                through public Nostr relays when direct hole-punching fails)
   vibedating find <@handle> [--any]  Search the DHT for one specific handle (\u2605 highlights a match)
   vibedating handle [@name]     Print or set your handle (persisted; a leading '@' is optional)
   vibedating block <@handle>    Block a handle \u2014 their hello is dropped (never recorded/paired)
@@ -2912,11 +3020,11 @@ async function main(argv) {
     case "matches":
       return cmdMatches(parsed.live);
     case "discover":
-      return cmdDiscover(parsed.live, parsed.any);
+      return cmdDiscover(parsed.live, parsed.any, parsed.viaRelay);
     case "open":
       return cmdOpen(parsed.port, parsed.any);
     case "live":
-      return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive);
+      return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive, parsed.viaRelay);
     case "find":
       return cmdFind(parsed.arg, parsed.any);
     case "mcp":

package/dist/index.d.ts

@@ -238,6 +238,119 @@ 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>;
+
 /**
  * Persistent ed25519 identity — binds a handle to a keypair so a peer cannot
  * impersonate it.
@@ -307,6 +420,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 +558,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, type RelayEvent, type RelayFilter, type RelayTransport, 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, serializeHandshake, signHelloClaims, startDiscovery, verifyHelloClaims };

package/dist/index.js

@@ -1,20 +1,27 @@
 import {
   BELOW_LEAGUE,
   CANDIDATES,
+  DEFAULT_RELAYS,
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
   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,
@@ -26,24 +33,31 @@ import {
   signHelloClaims,
   startDiscovery,
   verifyHelloClaims
-} from "./chunk-KKWP4DLY.js";
+} from "./chunk-VZXPYU2C.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,
+  DEFAULT_RELAYS,
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
   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,

package/dist/mcp.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibedate",
-  "version": "0.5.0",
+  "version": "0.6.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",