vibedate 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,6 +1,188 @@
-import { Harness, UsageSnapshot } from '@pooriaarab/vibe-core';
+import { VibeEvent, Harness, UsageSnapshot } from '@pooriaarab/vibe-core';
 export { Harness, UsageSnapshot, createConsentLedger } from '@pooriaarab/vibe-core';
 
+type Frame = {
+    t: 'hello';
+    handle: string;
+    league: string;
+    harness: 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: {
+        handle: string;
+        league: string;
+        harness: string;
+    };
+    /** 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 ONLY three fields that ever leave the machine over a peer connection. */
+interface PeerHello {
+    readonly handle: string;
+    readonly league: string;
+    readonly harness: string;
+}
+/** One-line privacy notice printed before joining the swarm. */
+declare const LIVE_NOTICE = "live discovery: sharing only your handle + league + harness (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;
+}
+/** 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;
+};
+/** 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)`.
+     */
+    readonly topic?: Buffer;
+    /** 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 32-byte topic actually joined. */
+    readonly topic: 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 the topic completes. */
+    readonly ready: Promise<unknown>;
+    /** Leave the 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>;
+
 /**
  * vibedating — dating by token usage.
  *
@@ -95,4 +277,4 @@ declare const CANDIDATES: readonly Candidate[];
  */
 declare function matches(myLeague: string, candidates?: readonly Candidate[]): Candidate[];
 
-export { BELOW_LEAGUE, CANDIDATES, type Candidate, DEMO_TOTAL_TOKENS, LEAGUES, type League, TOKENS_ENV, league, leagueIndex, matches, parseTokensEnv, readUsage, tryReadVerifiedUsage };
+export { BELOW_LEAGUE, CANDIDATES, type Candidate, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, LEAGUES, LIVE_NOTICE, type League, type PeerHello, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, league, leagueIndex, leagueTopic, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, serializeHandshake, startDiscovery, tryReadVerifiedUsage };

package/dist/index.js

@@ -3,26 +3,42 @@ import {
   CANDIDATES,
   DEMO_TOTAL_TOKENS,
   LEAGUES,
+  LIVE_NOTICE,
   TOKENS_ENV,
+  TOPIC_PREFIX,
   createConsentLedger,
   league,
   leagueIndex,
+  leagueTopic,
+  loadPeers,
   matches,
+  parseHandshake,
   parseTokensEnv,
   readUsage,
+  recordPeer,
+  serializeHandshake,
+  startDiscovery,
   tryReadVerifiedUsage
-} from "./chunk-AU7FN2LY.js";
+} from "./chunk-6NWF2VD7.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,
   DEMO_TOTAL_TOKENS,
   LEAGUES,
+  LIVE_NOTICE,
   TOKENS_ENV,
+  TOPIC_PREFIX,
   createConsentLedger,
   league,
   leagueIndex,
+  leagueTopic,
+  loadPeers,
   matches,
+  parseHandshake,
   parseTokensEnv,
   readUsage,
+  recordPeer,
+  serializeHandshake,
+  startDiscovery,
   tryReadVerifiedUsage
 };

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   runMcp
-} from "./chunk-64ME4THO.js";
-import "./chunk-AU7FN2LY.js";
+} from "./chunk-5ZJIPMU6.js";
+import "./chunk-6NWF2VD7.js";
 export {
   runMcp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibedate",
-  "version": "0.1.0",
+  "version": "0.2.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",
@@ -26,11 +26,13 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@pooriaarab/vibe-core": "^0.1.0",
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@pooriaarab/vibe-core": "^0.2.0",
+    "hyperswarm": "^4.17.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
+    "hyperdht": "^6.33.0",
     "tsup": "^8.0.0",
     "typescript": "^5.4.0",
     "vitest": "^1.6.0"

package/dist/chunk-AU7FN2LY.js

@@ -1,133 +0,0 @@
-// src/index.ts
-import { createConsentLedger } from "@pooriaarab/vibe-core";
-var LEAGUES = [
-  { name: "1M", min: 1e6, max: 4999999 },
-  { name: "5M", min: 5e6, max: 9999999 },
-  { name: "10M", min: 1e7, max: 99999999 },
-  { name: "100M", min: 1e8, max: 999999999 },
-  { name: "1B+", min: 1e9, max: Number.POSITIVE_INFINITY }
-];
-var BELOW_LEAGUE = "below-1M";
-function league(totalTokens) {
-  const n = Math.max(0, Math.floor(totalTokens));
-  for (const l of LEAGUES) {
-    if (n >= l.min && n <= l.max) {
-      return { name: l.name, min: l.min };
-    }
-  }
-  return { name: BELOW_LEAGUE, min: 0 };
-}
-function leagueIndex(name) {
-  if (name === BELOW_LEAGUE) return -1;
-  return LEAGUES.findIndex((l) => l.name === name);
-}
-var TOKENS_ENV = "VIBEDATING_TOKENS";
-var DEMO_TOTAL_TOKENS = 234e5;
-var MS_PER_DAY = 864e5;
-async function readUsage(harness = "claude-code") {
-  const verified = await tryReadVerifiedUsage(harness);
-  if (verified) return verified;
-  const injected = parseTokensEnv(process.env[TOKENS_ENV]);
-  const totalTokens = injected ?? DEMO_TOTAL_TOKENS;
-  const now = /* @__PURE__ */ new Date();
-  return {
-    harness,
-    totalTokens,
-    verified: false,
-    windowStart: new Date(now.getTime() - 30 * MS_PER_DAY).toISOString(),
-    windowEnd: now.toISOString()
-  };
-}
-async function tryReadVerifiedUsage(_harness) {
-  return null;
-}
-var TOKEN_MULT = {
-  "": 1,
-  k: 1e3,
-  K: 1e3,
-  m: 1e6,
-  M: 1e6,
-  b: 1e9,
-  B: 1e9
-};
-function parseTokensEnv(raw) {
-  if (raw === void 0) return void 0;
-  const trimmed = raw.trim();
-  if (trimmed === "") return void 0;
-  const match = /^([0-9]*\.?[0-9]+)\s*([kKmMbB]?)$/.exec(trimmed);
-  if (!match) return void 0;
-  const num = Number(match[1]);
-  if (!Number.isFinite(num) || num < 0) return void 0;
-  const mult = TOKEN_MULT[match[2] ?? ""] ?? 1;
-  return Math.floor(num * mult);
-}
-var CANDIDATES = [
-  {
-    handle: "@merge_conflict_therapist",
-    league: "10M",
-    bio: ["Resolves conflicts for a living \u2014 code and otherwise.", "Currently: 47 tabs open, 3 are Stack Overflow."]
-  },
-  {
-    handle: "@rebase_romantic",
-    league: "5M",
-    bio: ["Rewrites history for a living, git and otherwise.", "Looking for someone who squashes commits and grudges."]
-  },
-  {
-    handle: "@0xInsomniac",
-    league: "1B+",
-    bio: ["Token count is classified. Ask my therapist.", "Has never once respected a rate limit."]
-  },
-  {
-    handle: "@yolo_to_main",
-    league: "1M",
-    bio: ["No branches, no regrets, no CI.", "A green checkmark is a state of mind."]
-  },
-  {
-    handle: "@async_awaits_you",
-    league: "10M",
-    bio: ["Promises kept, unlike my sleep schedule.", "DMs are non-blocking. Replies eventually resolve."]
-  },
-  {
-    handle: "@nullish_and_void",
-    league: "5M",
-    bio: ["Coalescing since 2019.", "My love language is optional chaining."]
-  },
-  {
-    handle: "@ctrl_z_daddy",
-    league: "100M",
-    bio: ["Undo is my safe word.", "Refactors everything, including this bio, twice."]
-  },
-  {
-    handle: "@segfault_sonnet",
-    league: "1M",
-    bio: ["Writes poetry in stack traces.", "Core dumped. Heart, mostly, open."]
-  },
-  {
-    handle: "@the_lint_whisperer",
-    league: "10M",
-    bio: ["Zero warnings, zero regrets, zero chill.", "Will fix your semicolons without being asked."]
-  }
-];
-function matches(myLeague, candidates = CANDIDATES) {
-  const myIdx = leagueIndex(myLeague);
-  return candidates.filter((c) => {
-    const idx = leagueIndex(c.league);
-    if (idx < 0) return false;
-    return Math.abs(idx - myIdx) <= 1;
-  });
-}
-
-export {
-  LEAGUES,
-  BELOW_LEAGUE,
-  league,
-  leagueIndex,
-  TOKENS_ENV,
-  DEMO_TOTAL_TOKENS,
-  readUsage,
-  tryReadVerifiedUsage,
-  parseTokensEnv,
-  CANDIDATES,
-  matches,
-  createConsentLedger
-};