vibedate 0.4.1 → 0.6.0

package/README.md

@@ -9,6 +9,12 @@ Part of the **Vibe Suite** — companion tools for agentic coding CLIs. Ships as
 **CLI + npm package + MCP server**, plus a local web app. Built on
 [`@pooriaarab/vibe-core`](https://www.npmjs.com/package/@pooriaarab/vibe-core).
 
+## Demo
+
+[▶ Watch the launch video](branding/launch-video.mp4) — she matched with the man of her dreams. He was coding in a basement.
+
+https://github.com/pooriaarab/vibedating/raw/main/branding/launch-video.mp4
+
 > **Local-first.** Raw token usage is read and stored on your own machine and
 > **never leaves it.** Only the coarse league *bucket* is ever shared — never the
 > raw number, never per-project breakdowns. Live matching is peer-to-peer over a
@@ -62,8 +68,15 @@ VIBEDATING_TOKENS=23400000 vibedating connect   # also accepts 12M / 1.2B / 500k
 
 ```
 vibedating connect            Read usage, compute + print your league
-vibedating matches [--live]   List candidates in your league (live peers if any)
+                              (first run auto-assigns a memetic handle — never @you)
+vibedating matches [--live]   List candidates in your league (live peers if any,
+                              with last-message time)
 vibedating discover [--live]  Find live same-league peers over the DHT (opt-in)
+vibedating live [--keep-alive]  Live text chat (--keep-alive / non-TTY survives stdin EOF)
+vibedating handle [@name]     Print or set your handle
+vibedating daemon [start|stop|status|install|uninstall]
+                              Notify-only background daemon — alerts on NEW matches,
+                              never opens chat/video; install = run on login (launchd/systemd)
 vibedating open [--port N]    Serve the local web app (default: random free port)
 vibedating mcp                Run the stdio MCP server (tools: profile, matches)
 vibedating --version

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

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

package/dist/{chunk-43IYNWES.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";
@@ -656,6 +694,14 @@ function createPeerLink(socket, hello, initialBuffer = "", linkOpts = {}) {
   };
 }
 
+// src/untrusted.ts
+var MAX_DISPLAY_TEXT_LEN = MAX_TEXT_LEN;
+var UNSAFE_DISPLAY_CHARS = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u200E\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g;
+function sanitizePeerText(text, maxLen = MAX_DISPLAY_TEXT_LEN) {
+  const cleaned = text.replace(UNSAFE_DISPLAY_CHARS, "");
+  return cleaned.length > maxLen ? cleaned.slice(0, maxLen) : cleaned;
+}
+
 // src/p2p.ts
 var TOPIC_PREFIX = "vibedate:";
 function leagueTopic(leagueName) {
@@ -838,7 +884,9 @@ async function startDiscovery(opts) {
           try {
             notify(
               makeEvent("match", hello.harness, process.cwd(), {
-                summary: `matched with ${peer.handle} - LIVE SAME LEAGUE`,
+                // AEGIS-lite: the handle is untrusted wire data — sanitized for
+                // display (the structured `handle` field below stays verbatim).
+                summary: `matched with ${sanitizePeerText(peer.handle)} - LIVE SAME LEAGUE`,
                 handle: peer.handle,
                 league: peer.league,
                 harness: peer.harness
@@ -899,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 },
@@ -1036,12 +1282,16 @@ function matches(myLeague, candidates = CANDIDATES) {
 
 export {
   parseFrame,
+  defaultStateDir,
   connectProfile,
   loadProfile,
   grantLiveConsent,
   canShareLive,
+  DEFAULT_HANDLE,
+  MAX_HANDLE_LEN,
   sameHandle,
   normalizeHandle,
+  loadHandle,
   saveHandle,
   resolveHandle,
   loadBlocklist,
@@ -1053,6 +1303,8 @@ export {
   signHelloClaims,
   verifyHelloClaims,
   classifyHelloIdentity,
+  loadOrCreateNostrKey,
+  sanitizePeerText,
   TOPIC_PREFIX,
   leagueTopic,
   LIVE_NOTICE,
@@ -1062,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

@@ -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' | 'mcp' | 'help' | 'version' | null;
+type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'help' | 'version' | null;
 interface ParsedArgs {
     readonly command: Command;
     /** Port for `open --port`; undefined means "let the OS pick". */
@@ -15,11 +15,32 @@ interface ParsedArgs {
     readonly arg: string | undefined;
     /** `live --to <@handle>`: targeted match — auto-open that specific peer. */
     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.
  * Pure: no IO, no process access — trivially unit-testable.
  */
 declare function parseArgs(argv: readonly string[]): ParsedArgs;
+/**
+ * Compact relative time for local lists: an ISO timestamp → "just now" /
+ * "5m ago" / "3h ago" / "2d ago". Unparseable input → "unknown". Pure.
+ */
+declare function formatAgo(iso: string, now?: Date): string;
+/**
+ * Whether `live` should stay in the swarm after stdin closes. An explicit
+ * `--keep-alive` always keeps it; otherwise AUTO-detect: a non-TTY stdin
+ * (piped, `</dev/null`, backgrounded) hits EOF immediately, and exiting there
+ * would kill an unattended session — so it stays up until SIGINT/SIGTERM.
+ * Interactive TTY behavior is unchanged: Ctrl+D / EOF still exits.
+ */
+declare function shouldKeepAlive(flag: boolean, stdinIsTTY: boolean | undefined): boolean;
 
-export { type Command, type ParsedArgs, parseArgs };
+export { type Command, type ParsedArgs, formatAgo, parseArgs, shouldKeepAlive };