vibedate 0.7.1 → 0.8.0

package/dist/room-BStsMaeT.d.ts

@@ -0,0 +1,320 @@
+import { VibeEvent } from '@pooriaarab/vibe-core';
+
+type Frame = {
+    t: 'hello';
+    handle: string;
+    league: string;
+    harness: string;
+    verified?: boolean;
+    pubkey?: string;
+    nonce?: string;
+    sig?: string;
+} | {
+    t: 'msg';
+    id: string;
+    text: string;
+    at: number;
+} | {
+    t: 'typing';
+} | {
+    t: 'bye';
+} | {
+    t: 'media-start';
+    id: string;
+    mime: string;
+    size: number;
+    name: string;
+} | {
+    t: 'media-chunk';
+    id: string;
+    seq: number;
+    b64: string;
+} | {
+    t: 'media-end';
+    id: string;
+} | {
+    t: 'rtc-offer';
+    sdp: string;
+} | {
+    t: 'rtc-answer';
+    sdp: string;
+} | {
+    t: 'rtc-ice';
+    candidate: string;
+};
+/** Convenience union of the three WebRTC signaling frame types (offer / answer
+ *  / ice). Live A/V runs in the BROWSER via a native RTCPeerConnection; these
+ *  frames only RELAY signaling over the P2P socket — no media bytes, no native
+ *  WebRTC dependency in the CLI. */
+type RtcFrame = Extract<Frame, {
+    t: `rtc-${string}`;
+}>;
+
+interface ReceivedMedia {
+    readonly mime: string;
+    readonly name: string;
+    /** Temp file path holding the reassembled bytes. */
+    readonly path: string;
+    readonly size: number;
+}
+
+interface PeerLink {
+    /** The validated identity of the remote peer (from the hello handshake). */
+    readonly hello: PeerHello;
+    /** Send a line of text as a `msg` frame. */
+    send(text: string): void;
+    /** Read a file from disk and send it as a chunked media transfer. */
+    sendMedia(filePath: string, opts?: {
+        mime?: string;
+        name?: string;
+    }): Promise<{
+        id: string;
+        size: number;
+    }>;
+    /** Relay one `rtc-*` signaling frame (offer / answer / ice) to the peer.
+     *  Live media never touches this socket — only SDP / ICE strings do. */
+    sendSignal(frame: RtcFrame): void;
+    /** Register a callback for each incoming `msg` frame. */
+    onMessage(cb: (m: {
+        id: string;
+        text: string;
+        at: number;
+    }) => void): void;
+    /** Register a callback fired for each fully-reassembled incoming media file. */
+    onMedia(cb: (m: ReceivedMedia) => void): void;
+    /** Register a callback fired for each incoming `rtc-*` signaling frame. */
+    onSignal(cb: (f: RtcFrame) => void): void;
+    /** Register a callback fired once when the peer closes the link. */
+    onClose(cb: () => void): void;
+    /** Omegle "next": write a `bye` frame, then end the socket. */
+    close(): void;
+}
+
+/** Namespace prefix so vibedating topics never collide with other DHT traffic. */
+declare const TOPIC_PREFIX = "vibedate:";
+/**
+ * Derive the 32-byte DHT topic for a league bucket. Deterministic: everyone in
+ * the same league anywhere in the world hashes to the same topic, which is the
+ * entire discovery mechanism. Pure.
+ */
+declare function leagueTopic(leagueName: string): Buffer;
+/**
+ * The fields that ever leave the machine over a peer connection: handle, league,
+ * harness, and (optionally) the self-asserted usage-verification flag plus the
+ * identity proof (pubkey/nonce/sig). NEVER raw usage — no token totals, no logs.
+ * `verified`/`pubkey` are undefined for legacy peers that predate them; both
+ * `undefined` and `false` display as unverified (~).
+ */
+interface PeerHello {
+    readonly handle: string;
+    readonly league: string;
+    readonly harness: string;
+    /**
+     * Self-asserted: the sender's usage came from real local logs (see readUsage).
+     * Bound to the sender's key by the identity signature when `pubkey` is present.
+     */
+    readonly verified?: boolean;
+    /** Raw ed25519 public key (64 hex) — the persistent identity this hello signs. */
+    readonly pubkey?: string;
+    /** Random per-hello nonce (hex) covered by the signature. */
+    readonly nonce?: string;
+    /** ed25519 signature (128 hex) over `handle|league|harness|verified|nonce`. */
+    readonly sig?: string;
+    /**
+     * LOCAL-DERIVED, never on the wire: true when this hello's signature verified
+     * against its pubkey (see classifyHelloIdentity). Marked 🔑 in the UI.
+     */
+    readonly identityVerified?: boolean;
+}
+/** One-line privacy notice printed before joining the swarm. */
+declare const LIVE_NOTICE = "live discovery: sharing only your handle + league + harness + verified flag + identity pubkey (never raw usage) with same-league peers on the public DHT";
+/**
+ * Serialize a hello to the single JSON line sent on connect. Built key-by-key
+ * from the allowlist — even if a caller sneaks extra properties onto the
+ * object, they cannot leak into the wire format.
+ */
+declare function serializeHandshake(hello: PeerHello): string;
+/**
+ * Parse one incoming handshake line. Returns `null` for anything malformed
+ * (bad JSON, non-object, missing/oversized handle or league). The result is
+ * constructed from an allowlist of keys, so any extra fields a peer sends —
+ * in particular any raw-usage field — are ignored and never retained.
+ */
+declare function parseHandshake(raw: string | Buffer): PeerHello | null;
+/** A peer we've shaken hands with, persisted locally. */
+interface StoredPeer extends PeerHello {
+    readonly firstSeenAt: string;
+    readonly lastSeenAt: string;
+    /** LOCAL metadata: when the last `msg` from this peer arrived (never on the wire). */
+    readonly lastMessageAt?: string;
+}
+/** Load persisted live peers, or `[]` if none/corrupt. Local-only data. */
+declare function loadPeers(dir?: string): StoredPeer[];
+/**
+ * Record a successfully handshaken peer, keyed by handle (a peer may reconnect
+ * from a different key). Returns whether this handle is NEW (first time seen).
+ */
+declare function recordPeer(hello: PeerHello, dir?: string, now?: Date): {
+    peer: StoredPeer;
+    isNew: boolean;
+};
+/**
+ * Stamp `lastMessageAt` on a stored peer (a `msg` just arrived from them).
+ * Local metadata only; never on the wire. Returns false when the handle isn't
+ * a known peer. Never throws — best-effort bookkeeping.
+ */
+declare function recordPeerMessage(handle: string, dir?: string, now?: Date): boolean;
+/** Injection point for the match notification (defaults to vibe-core notify). */
+type NotifySink = (event: VibeEvent) => void;
+interface DiscoveryOptions {
+    /** What we broadcast. Must already be consent-gated by the caller. */
+    readonly hello: PeerHello;
+    /**
+     * Override the joined topic (tests pass a random one on an isolated DHT).
+     * Defaults to {@link leagueTopic}`(hello.league)`. Ignored when {@link topics}
+     * is set.
+     */
+    readonly topic?: Buffer;
+    /**
+     * ALL topics to join on the one swarm (e.g. your league + adjacent leagues),
+     * so thin pools and cross-league friends still connect. Every topic is
+     * joined, refreshed, and left on close. Defaults to `[topic]` — i.e. a single
+     * own-league topic (the legacy behavior).
+     */
+    readonly topics?: readonly Buffer[];
+    /**
+     * Predicate over an incoming peer's advertised league. Defaults to EXACT
+     * match against `hello.league` — the same privacy invariant as before. Widen
+     * it (e.g. ±1 adjacency via {@link leaguesWithin}) to accept cross-league
+     * peers that arrive on a shared topic.
+     */
+    readonly acceptLeague?: (peerLeague: string) => boolean;
+    /**
+     * Predicate over an incoming peer's advertised handle. A blocked peer's hello
+     * is DROPPED exactly like a wrong-league one — never recorded to peers.json,
+     * never notified, never handed to `onLink`/pairing. Default: nothing blocked.
+     * The CLI passes one backed by the persisted blocklist (~/.vibedating).
+     */
+    readonly isBlocked?: (handle: string) => boolean;
+    /** 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;
+    /** Called after each accepted handshake; `isNew` = first time this handle is seen. */
+    readonly onPeer?: (peer: PeerHello, isNew: boolean) => void;
+    /**
+     * Called once per connection with a live {@link PeerLink} over the same socket
+     * (the hello was frame #1; subsequent frames flow to the link). Omit for the
+     * plain `discover` behavior (no live chat). Existing discovery behavior is
+     * unchanged when this is absent.
+     */
+    readonly onLink?: (link: PeerLink) => void;
+    /** Match-notification sink (tests capture with a fake). Best-effort. */
+    readonly notify?: NotifySink;
+}
+interface DiscoverySession {
+    /** The primary (first) joined topic. See {@link topics} for the full set. */
+    readonly topic: Buffer;
+    /** Every topic this session joined (primary first). */
+    readonly topics: readonly Buffer[];
+    /** What we broadcast on every connection. */
+    readonly hello: PeerHello;
+    /** Live peer set, keyed by the remote's public key (hex). */
+    readonly peers: ReadonlyMap<string, PeerHello>;
+    /** Resolves when the first DHT announce/lookup round for every topic completes. */
+    readonly ready: Promise<unknown>;
+    /** Leave every topic and destroy the node. Idempotent. */
+    close(): Promise<void>;
+}
+/**
+ * Join the swarm on the league topic and handshake with every peer that
+ * connects. CONSENT GATE LIVES WITH THE CALLER — never call this without the
+ * `share:live` grant (or an explicit `--live` opt-in in the same breath).
+ */
+declare function startDiscovery(opts: DiscoveryOptions): Promise<DiscoverySession>;
+
+/** 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>;
+
+export { type DiscoveryOptions as D, LIVE_NOTICE as L, type PeerHello as P, ROOM_TOPIC_PREFIX as R, type StoredPeer as S, TOPIC_PREFIX as T, type PeerLink as a, type DiscoverySession as b, type RoomMember as c, type RoomMessage as d, type RoomOptions as e, type RoomSession as f, loadPeers as g, recordPeerMessage as h, roomTopic as i, startDiscovery as j, startRoom as k, leagueTopic as l, parseHandshake as p, recordPeer as r, serializeHandshake as s };

package/package.json

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

package/dist/chunk-ZD6JBWEW.js

@@ -1,63 +0,0 @@
-import {
-  CANDIDATES,
-  loadProfile,
-  matches
-} from "./chunk-HDHJLZZG.js";
-
-// src/mcp.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-function textBlock(text) {
-  return { type: "text", text };
-}
-var VERSION = "0.1.0";
-async function runMcp() {
-  const mcp = new McpServer({ name: "vibedating", version: VERSION });
-  mcp.tool(
-    "profile",
-    "Your vibedating league, computed locally from your token usage. Raw usage never leaves the machine \u2014 only the league bucket is shared. Requires `vibedating connect` to have run.",
-    () => {
-      const p = loadProfile();
-      if (!p) {
-        return {
-          content: [
-            textBlock("Not connected. Run `vibedating connect` first to compute your league.")
-          ]
-        };
-      }
-      const lines = [
-        `handle: ${p.handle}`,
-        `harness: ${p.harness}`,
-        `league: ${p.league} League`,
-        `verified: ${p.verified ? "true (real local usage)" : "false (self-reported or demo)"}`,
-        "privacy: raw token usage is local-only; only the league bucket is shared."
-      ];
-      return { content: [textBlock(lines.join("\n"))] };
-    }
-  );
-  mcp.tool(
-    "matches",
-    "Candidates in your league (same or adjacent tier) from the local seeded demo pool. No central directory in v0.",
-    () => {
-      const p = loadProfile();
-      if (!p) {
-        return {
-          content: [textBlock("Not connected. Run `vibedating connect` first.")]
-        };
-      }
-      const list = matches(p.league, CANDIDATES);
-      if (list.length === 0) {
-        return { content: [textBlock(`No candidates in range for the ${p.league} League.`)] };
-      }
-      const body = [`Matches for ${p.league} League (${list.length}):`];
-      for (const c of list) body.push(`- ${c.handle} (${c.league} League)`);
-      return { content: [textBlock(body.join("\n"))] };
-    }
-  );
-  const transport = new StdioServerTransport();
-  await mcp.connect(transport);
-}
-
-export {
-  runMcp
-};