vibedate 0.5.0 → 0.7.0

package/dist/{chunk-KKWP4DLY.js → chunk-HDHJLZZG.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,301 @@ 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/room.ts
+import { createHash as createHash3 } from "crypto";
+var ROOM_TOPIC_PREFIX = "vibedate-room:";
+function roomTopic(name) {
+  return createHash3("sha256").update(`${ROOM_TOPIC_PREFIX}${name}`, "utf8").digest();
+}
+async function startRoom(opts) {
+  const topic = roomTopic(opts.room);
+  const entries = /* @__PURE__ */ new Map();
+  const memberHellos = /* @__PURE__ */ new Map();
+  const messageCbs = /* @__PURE__ */ new Set();
+  const rosterCbs = /* @__PURE__ */ new Set();
+  const signalCbs = /* @__PURE__ */ new Set();
+  const fireRoster = () => {
+    const snapshot = [...memberHellos.values()];
+    for (const cb of rosterCbs) cb(snapshot);
+  };
+  let discovery;
+  const ready = startDiscovery({
+    hello: opts.hello,
+    // ONE topic — the room's own. Rooms are intentionally cross-league, so
+    // every member of the room is accepted regardless of advertised league.
+    topics: [topic],
+    acceptLeague: () => true,
+    ...opts.isBlocked === void 0 ? {} : { isBlocked: opts.isBlocked },
+    ...opts.bootstrap === void 0 ? {} : { bootstrap: opts.bootstrap },
+    ...opts.stateDir === void 0 ? {} : { stateDir: opts.stateDir },
+    ...opts.notify === void 0 ? {} : { notify: opts.notify },
+    onLink: (link) => {
+      const handle = link.hello.handle;
+      entries.set(handle, { hello: link.hello, link });
+      memberHellos.set(handle, link.hello);
+      fireRoster();
+      link.onMessage((m) => {
+        for (const cb of messageCbs) cb({ from: handle, ...m });
+      });
+      link.onSignal((frame) => {
+        for (const cb of signalCbs) cb(handle, frame);
+      });
+      link.onClose(() => {
+        const cur = entries.get(handle);
+        if (cur && cur.link === link) {
+          entries.delete(handle);
+          memberHellos.delete(handle);
+          fireRoster();
+        }
+      });
+    }
+  }).then((s) => {
+    discovery = s;
+    return s.ready;
+  });
+  const session = {
+    room: opts.room,
+    topic,
+    hello: opts.hello,
+    members: memberHellos,
+    ready,
+    broadcast(text) {
+      const reached = [];
+      for (const [handle, entry] of entries) {
+        entry.link.send(text);
+        reached.push(handle);
+      }
+      return reached;
+    },
+    onMessage(cb) {
+      messageCbs.add(cb);
+    },
+    onRoster(cb) {
+      rosterCbs.add(cb);
+    },
+    onSignal(cb) {
+      signalCbs.add(cb);
+    },
+    sendSignal(handle, frame) {
+      entries.get(handle)?.link.sendSignal(frame);
+    },
+    linkFor(handle) {
+      return entries.get(handle)?.link;
+    },
+    async close() {
+      await ready.catch(() => void 0);
+      for (const entry of entries.values()) {
+        try {
+          entry.link.close();
+        } catch {
+        }
+      }
+      entries.clear();
+      memberHellos.clear();
+      if (discovery !== void 0) await discovery.close();
+    }
+  };
+  return session;
+}
+
 // src/index.ts
 var LEAGUES = [
   { name: "1M", min: 1e6, max: 4999999 },
@@ -1067,6 +1400,7 @@ export {
   signHelloClaims,
   verifyHelloClaims,
   classifyHelloIdentity,
+  loadOrCreateNostrKey,
   sanitizePeerText,
   TOPIC_PREFIX,
   leagueTopic,
@@ -1077,6 +1411,15 @@ export {
   recordPeer,
   recordPeerMessage,
   startDiscovery,
+  DEFAULT_RELAYS,
+  VIBEDATE_MESSAGE_KIND,
+  VIBEDATE_PRESENCE_KIND,
+  conversationTag,
+  createNostrRelayLink,
+  createNostrPoolTransport,
+  ROOM_TOPIC_PREFIX,
+  roomTopic,
+  startRoom,
   LEAGUES,
   BELOW_LEAGUE,
   league,

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

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

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /** Recognized top-level commands, plus the synthetic help/version. */
-type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'help' | 'version' | null;
+type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'room' | 'help' | 'version' | null;
 interface ParsedArgs {
     readonly command: Command;
     /** Port for `open --port`; undefined means "let the OS pick". */
@@ -17,6 +17,14 @@ 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;
+    /** `room <name>` positional, or `--room <name>`: join/create a named room. */
+    readonly room: string | undefined;
 }
 /**
  * Parse argv (the slice AFTER the program name) into a command + options.