vibedate 0.4.1 → 0.6.0

package/dist/cli.js

@@ -1,15 +1,20 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-ZB56ZBAR.js";
+} from "./chunk-JIBC3OHV.js";
 import {
   CANDIDATES,
+  DEFAULT_HANDLE,
   LIVE_NOTICE,
+  MAX_HANDLE_LEN,
   TOPIC_PREFIX,
   addBlock,
   allLeagueNames,
   canShareLive,
   connectProfile,
+  createNostrPoolTransport,
+  createNostrRelayLink,
+  defaultStateDir,
   grantLiveConsent,
   isBlocked,
   league,
@@ -17,7 +22,9 @@ import {
   leagueTopic,
   leaguesWithin,
   loadBlocklist,
+  loadHandle,
   loadOrCreateIdentity,
+  loadOrCreateNostrKey,
   loadPeers,
   loadProfile,
   matches,
@@ -27,16 +34,356 @@ import {
   removeBlock,
   resolveHandle,
   sameHandle,
+  sanitizePeerText,
   saveHandle,
   signHelloClaims,
   startDiscovery
-} from "./chunk-43IYNWES.js";
+} from "./chunk-VZXPYU2C.js";
 
 // src/cli.ts
 import readline from "readline";
 import "url";
 import process2 from "process";
 
+// src/handlegen.ts
+import { randomBytes } from "crypto";
+var FIRST = [
+  "segfault",
+  "yak",
+  "vibe",
+  "null",
+  "async",
+  "await",
+  "heap",
+  "stack",
+  "sudo",
+  "regex",
+  "token",
+  "prompt",
+  "context",
+  "merge",
+  "rebase",
+  "hotfix",
+  "flaky",
+  "cursed",
+  "based",
+  "quantum",
+  "turbo",
+  "neural",
+  "agentic",
+  "kernel",
+  "docker",
+  "kube",
+  "lambda",
+  "pointer",
+  "buffer",
+  "packet",
+  "syscall",
+  "runtime",
+  "monad",
+  "borrow",
+  "cache",
+  "deadlock",
+  "localhost",
+  "darkmode",
+  "wasm",
+  "diff"
+];
+var SECOND = [
+  "sommelier",
+  "shaver",
+  "goblin",
+  "nomad",
+  "gremlin",
+  "wizard",
+  "bard",
+  "pirate",
+  "ninja",
+  "monk",
+  "prophet",
+  "oracle",
+  "smith",
+  "farmer",
+  "whisperer",
+  "tamer",
+  "connoisseur",
+  "maximalist",
+  "enjoyer",
+  "dealer",
+  "herder",
+  "wrangler",
+  "juggler",
+  "mechanic",
+  "surgeon",
+  "detective",
+  "librarian",
+  "alchemist",
+  "overlord",
+  "apprentice",
+  "sensei",
+  "chef",
+  "dj",
+  "ranger",
+  "paladin",
+  "barbarian",
+  "summoner",
+  "cartographer",
+  "archivist",
+  "plumber"
+];
+var SUFFIX = [
+  "prime",
+  "9000",
+  "3000",
+  "max",
+  "ultra",
+  "xl",
+  "mk2",
+  "777",
+  "404",
+  "1337",
+  "2077",
+  "xd"
+];
+function cryptoRand() {
+  return randomBytes(4).readUInt32BE(0) / 2 ** 32;
+}
+function pick(list, rand) {
+  return list[Math.min(list.length - 1, Math.floor(rand() * list.length))];
+}
+function generateHandle(rand = cryptoRand) {
+  const first = pick(FIRST, rand);
+  const second = pick(SECOND, rand);
+  let body = `${first}_${second}`;
+  if (rand() < 0.5) {
+    const withSuffix = `${body}_${pick(SUFFIX, rand)}`;
+    if (withSuffix.length + 1 <= MAX_HANDLE_LEN) body = withSuffix;
+  }
+  const canonical = normalizeHandle(body);
+  if (canonical === null) throw new Error(`handle generator produced an invalid handle: ${body}`);
+  return canonical;
+}
+function ensureHandle(dir = defaultStateDir()) {
+  const env = process.env["VIBEDATING_HANDLE"];
+  if (env !== void 0 && env.trim() !== "") {
+    const canonical = normalizeHandle(env);
+    if (canonical !== null) return { handle: canonical, generated: false };
+  }
+  const persisted = loadHandle(dir);
+  if (persisted !== DEFAULT_HANDLE) return { handle: persisted, generated: false };
+  const generated = generateHandle();
+  return { handle: saveHandle(generated, dir), generated: true };
+}
+
+// src/daemon.ts
+import { spawn, spawnSync } from "child_process";
+import { mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+function daemonStatePath(dir) {
+  return path.join(dir, "daemon.json");
+}
+function daemonLogPath(dir) {
+  return path.join(dir, "daemon.log");
+}
+function readDaemonState(dir = defaultStateDir()) {
+  try {
+    const raw = readFileSync(daemonStatePath(dir), "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data["pid"] !== "number" || !Number.isInteger(data["pid"]) || data["pid"] <= 0 || typeof data["startedAt"] !== "string" || typeof data["any"] !== "boolean" || typeof data["version"] !== "string") {
+      return null;
+    }
+    return { pid: data["pid"], startedAt: data["startedAt"], any: data["any"], version: data["version"] };
+  } catch {
+    return null;
+  }
+}
+function writeDaemonState(dir, state) {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(daemonStatePath(dir), JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function removeDaemonState(dir = defaultStateDir()) {
+  try {
+    rmSync(daemonStatePath(dir), { force: true });
+  } catch {
+  }
+}
+function isPidAlive(pid, kill = process.kill) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function daemonStatus(dir = defaultStateDir(), alive = isPidAlive) {
+  const state = readDaemonState(dir);
+  if (state === null) return { running: false, state: null };
+  if (alive(state.pid)) return { running: true, state };
+  removeDaemonState(dir);
+  return { running: false, state: null };
+}
+function defaultSpawn(execPath, scriptPath, args, logPath) {
+  mkdirSync(path.dirname(logPath), { recursive: true });
+  const fd = openSync(logPath, "a");
+  const child = spawn(execPath, [scriptPath, ...args], {
+    detached: true,
+    stdio: ["ignore", fd, fd]
+  });
+  child.unref();
+  if (child.pid === void 0) throw new Error("could not spawn daemon child process");
+  return child.pid;
+}
+function startDaemon(opts) {
+  const dir = opts.dir ?? defaultStateDir();
+  const status = daemonStatus(dir, opts.alive);
+  if (status.running && status.state !== null) {
+    return { started: false, reason: `already running (pid ${status.state.pid})` };
+  }
+  const execPath = opts.execPath ?? process.execPath;
+  const scriptPath = opts.scriptPath ?? process.argv[1];
+  if (scriptPath === void 0) return { started: false, reason: "cannot locate the CLI entry point" };
+  const args = ["daemon", "run", ...opts.any ? ["--any"] : []];
+  const spawnProcess = opts.spawnProcess ?? ((a, logPath) => defaultSpawn(execPath, scriptPath, [...a], logPath));
+  const pid = spawnProcess(args, daemonLogPath(dir));
+  writeDaemonState(dir, { pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), any: opts.any, version: opts.version });
+  return { started: true, pid };
+}
+async function stopDaemon(opts = {}) {
+  const dir = opts.dir ?? defaultStateDir();
+  const kill = opts.kill ?? process.kill;
+  const alive = opts.alive ?? ((pid) => isPidAlive(pid, kill));
+  const state = readDaemonState(dir);
+  if (state === null) return { stopped: false, reason: "not running" };
+  if (!alive(state.pid)) {
+    removeDaemonState(dir);
+    return { stopped: false, reason: "not running (cleaned stale pidfile)" };
+  }
+  try {
+    kill(state.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + (opts.waitMs ?? 2e3);
+  while (Date.now() < deadline && alive(state.pid)) {
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  removeDaemonState(dir);
+  return { stopped: true, pid: state.pid };
+}
+var DAEMON_SERVICE_LABEL = "ai.vibedating.daemon";
+var SYSTEMD_UNIT_NAME = "vibedating.service";
+function daemonServicePath(platform = process.platform, homeDir = os.homedir()) {
+  if (platform === "darwin") {
+    return path.join(homeDir, "Library", "LaunchAgents", `${DAEMON_SERVICE_LABEL}.plist`);
+  }
+  if (platform === "linux") {
+    return path.join(homeDir, ".config", "systemd", "user", SYSTEMD_UNIT_NAME);
+  }
+  return null;
+}
+function serviceArgv(execPath, scriptPath, any) {
+  return [execPath, scriptPath, "daemon", "run", ...any ? ["--any"] : []];
+}
+function renderLaunchdPlist(opts) {
+  const args = serviceArgv(opts.execPath, opts.scriptPath, opts.any).map((a) => `    <string>${a}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${DAEMON_SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${opts.logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${opts.logPath}</string>
+</dict>
+</plist>
+`;
+}
+function renderSystemdUnit(opts) {
+  const execStart = serviceArgv(opts.execPath, opts.scriptPath, opts.any).join(" ");
+  return `[Unit]
+Description=vibedating notify-only daemon (alerts on new matches; never opens chat/video)
+
+[Service]
+ExecStart=${execStart}
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+}
+var defaultRun = (cmd, args) => spawnSync(cmd, args, { stdio: "inherit" }).status === 0;
+function installDaemonService(opts) {
+  const platform = opts.platform ?? process.platform;
+  const homeDir = opts.homeDir ?? os.homedir();
+  const run = opts.run ?? defaultRun;
+  const servicePath = daemonServicePath(platform, homeDir);
+  if (servicePath === null) {
+    return {
+      installed: false,
+      servicePath: null,
+      detail: `unsupported platform (${platform}) \u2014 run \`vibedate daemon start\` manually instead`
+    };
+  }
+  const execPath = opts.execPath ?? process.execPath;
+  const scriptPath = opts.scriptPath ?? process.argv[1];
+  if (scriptPath === void 0) {
+    return { installed: false, servicePath, detail: "cannot locate the CLI entry point" };
+  }
+  mkdirSync(path.dirname(servicePath), { recursive: true });
+  if (platform === "darwin") {
+    const logPath = daemonLogPath(opts.dir ?? defaultStateDir());
+    writeFileSync(servicePath, renderLaunchdPlist({ execPath, scriptPath, any: opts.any, logPath }), "utf8");
+    const uid = process.getuid?.() ?? 501;
+    run("launchctl", ["bootout", `gui/${uid}`, servicePath]);
+    if (!run("launchctl", ["bootstrap", `gui/${uid}`, servicePath])) {
+      return { installed: false, servicePath, detail: "launchctl bootstrap failed \u2014 service written but not loaded" };
+    }
+    return { installed: true, servicePath, detail: "launchd agent installed \u2014 the daemon starts on login" };
+  }
+  writeFileSync(servicePath, renderSystemdUnit({ execPath, scriptPath, any: opts.any }), "utf8");
+  run("systemctl", ["--user", "daemon-reload"]);
+  if (!run("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT_NAME])) {
+    return { installed: false, servicePath, detail: "systemctl enable failed \u2014 unit written but not started" };
+  }
+  return { installed: true, servicePath, detail: "systemd --user service installed \u2014 the daemon starts on login" };
+}
+function uninstallDaemonService(opts) {
+  const platform = opts.platform ?? process.platform;
+  const homeDir = opts.homeDir ?? os.homedir();
+  const run = opts.run ?? defaultRun;
+  const servicePath = daemonServicePath(platform, homeDir);
+  if (servicePath === null) {
+    return {
+      installed: false,
+      servicePath: null,
+      detail: `unsupported platform (${platform})`
+    };
+  }
+  if (platform === "darwin") {
+    const uid = process.getuid?.() ?? 501;
+    run("launchctl", ["bootout", `gui/${uid}`, servicePath]);
+  } else {
+    run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT_NAME]);
+    run("systemctl", ["--user", "daemon-reload"]);
+  }
+  try {
+    rmSync(servicePath, { force: true });
+  } catch {
+  }
+  return { installed: false, servicePath, detail: "login service removed \u2014 the daemon no longer starts on login" };
+}
+
 // src/pairing.ts
 function createPairing() {
   const queue = [];
@@ -1499,7 +1846,7 @@ function createLiveBridge() {
       link.onMessage((m) => {
         const mb = boxes.get(handle2);
         if (!mb) return;
-        mb.messages.push(m);
+        mb.messages.push({ ...m, text: sanitizePeerText(m.text) });
         if (mb.messages.length > MAX_QUEUED_MESSAGES) {
           mb.messages.splice(0, mb.messages.length - MAX_QUEUED_MESSAGES);
         }
@@ -1768,7 +2115,7 @@ async function handle(req, res, opts) {
 }
 
 // src/cli.ts
-var VERSION = "0.4.1";
+var VERSION = "0.6.0";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -1782,7 +2129,9 @@ function parseArgs(argv) {
     dating: false,
     any: false,
     arg: void 0,
-    to: void 0
+    to: void 0,
+    keepAlive: false,
+    viaRelay: false
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -1794,7 +2143,9 @@ function parseArgs(argv) {
         dating: false,
         any: false,
         arg: void 0,
-        to: void 0
+        to: void 0,
+        keepAlive: false,
+        viaRelay: false
       };
     }
     if (a === "--help" || a === "-h") {
@@ -1805,13 +2156,23 @@ function parseArgs(argv) {
         dating: false,
         any: false,
         arg: void 0,
-        to: void 0
+        to: void 0,
+        keepAlive: false,
+        viaRelay: false
       };
     }
     if (a === "--live") {
       out = { ...out, live: true };
       continue;
     }
+    if (a === "--keep-alive") {
+      out = { ...out, keepAlive: true };
+      continue;
+    }
+    if (a === "--via-relay") {
+      out = { ...out, viaRelay: true };
+      continue;
+    }
     if (a === "--any") {
       out = { ...out, any: true };
       continue;
@@ -1847,7 +2208,7 @@ function parseArgs(argv) {
       continue;
     }
     if (a.startsWith("-")) continue;
-    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "mcp" || a === "help" ? a : null;
+    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "daemon" || a === "mcp" || a === "help" ? a : null;
     if (known !== null && out.command === null) {
       out = { ...out, command: known };
     } else if (out.arg === void 0) {
@@ -1867,6 +2228,17 @@ function formatTokens(n) {
   if (abs >= 1e3) return `${trim(n / 1e3)}k`;
   return String(n);
 }
+function formatAgo(iso, now = /* @__PURE__ */ new Date()) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return "unknown";
+  const s = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
+  if (s < 60) return "just now";
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
 function verificationText(snapshot) {
   if (snapshot.source === "real") {
     return `verified: real usage \u2014 ${formatTokens(snapshot.totalTokens)} tokens from ${snapshot.harness} logs`;
@@ -1913,7 +2285,9 @@ function idMark(peer) {
 var MARKS_LEGEND = "marks: \u2713 usage verified (real local logs) \xB7 ~ unverified (self-report/demo/legacy) \xB7 \u{1F511} identity-verified (signed hello)";
 async function cmdConnect() {
   const harness = process2.env["VIBEDATING_HARNESS"] ?? "claude-code";
-  const handle2 = resolveHandle();
+  const ensured = ensureHandle();
+  const handle2 = ensured.handle;
+  const firstConnect = loadProfile() === null;
   const snapshot = await readUsage(harness);
   const profile = connectProfile(snapshot, handle2);
   const identity = loadOrCreateIdentity();
@@ -1923,12 +2297,20 @@ async function cmdConnect() {
 `);
   process2.stdout.write(`  handle: ${profile.handle}  \xB7  harness: ${profile.harness}
 `);
+  if (ensured.generated) {
+    process2.stdout.write(`  assigned handle: ${profile.handle} \u2014 change it with: vibedate handle @name
+`);
+  }
   process2.stdout.write(`  verification: ${verificationText(snapshot)}
 `);
   process2.stdout.write(`  identity: ed25519 ${identity.publicKeyHex.slice(0, 12)}\u2026 \u2014 signs your hello (\u{1F511})
 `);
   process2.stdout.write("\n");
-  process2.stdout.write("  \u2022 raw usage stays local \xB7 only league shared\n\n");
+  process2.stdout.write("  \u2022 raw usage stays local \xB7 only league shared\n");
+  if (firstConnect) {
+    process2.stdout.write("  \u2022 optional: get notified of new matches on login \u2014 `vibedate daemon install` (undo: daemon uninstall)\n");
+  }
+  process2.stdout.write("\n");
   return 0;
 }
 async function cmdHandle(arg) {
@@ -1981,7 +2363,8 @@ async function cmdMatches(live) {
 
 `);
     for (const p of livePeers) {
-      process2.stdout.write(`  ${p.handle.padEnd(28)} ${p.league} \xB7 ${p.harness} ${usageMark(p)}${idMark(p)}
+      const lastMsg = p.lastMessageAt !== void 0 ? ` \xB7 last msg ${formatAgo(p.lastMessageAt)}` : "";
+      process2.stdout.write(`  ${p.handle.padEnd(28)} ${p.league} \xB7 ${p.harness} ${usageMark(p)}${idMark(p)}${lastMsg}
 `);
     }
     process2.stdout.write("\n");
@@ -2008,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");
@@ -2027,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,
@@ -2113,7 +2499,103 @@ async function cmdOpen(port, any) {
   await new Promise((resolve) => started.server.close(() => resolve()));
   return 0;
 }
-async function cmdLive(dating, any, to) {
+function shouldKeepAlive(flag, stdinIsTTY) {
+  return flag || stdinIsTTY !== true;
+}
+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");
@@ -2130,6 +2612,7 @@ async function cmdLive(dating, any, to) {
     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}
@@ -2148,11 +2631,11 @@ async function cmdLive(dating, any, to) {
     }
     const { qual } = peerDirection(profile.league, link.hello.league);
     process2.stdout.write(
-      `  \xB7 matched ${link.hello.handle} (${link.hello.league}${qual} \xB7 ${link.hello.harness}) ${usageMark(link.hello)}${idMark(link.hello)}
+      `  \xB7 matched ${sanitizePeerText(link.hello.handle)} (${link.hello.league}${qual} \xB7 ${link.hello.harness}) ${usageMark(link.hello)}${idMark(link.hello)}
 `
     );
     link.onMessage((m) => {
-      process2.stdout.write(`  <${link.hello.handle}> ${m.text}
+      process2.stdout.write(`  <${sanitizePeerText(link.hello.handle)}> ${sanitizePeerText(m.text)}
 `);
     });
   });
@@ -2166,14 +2649,14 @@ async function cmdLive(dating, any, to) {
       if (target !== null && !sameHandle(link.hello.handle, target)) {
         const { qual } = peerDirection(profile.league, link.hello.league);
         process2.stdout.write(
-          `  + ${link.hello.handle} (${link.hello.league}${qual}) ${usageMark(link.hello)}${idMark(link.hello)} \u2014 not your target
+          `  + ${sanitizePeerText(link.hello.handle)} (${link.hello.league}${qual}) ${usageMark(link.hello)}${idMark(link.hello)} \u2014 not your target
 `
         );
         link.close();
         return;
       }
       if (target !== null) {
-        process2.stdout.write(`  \u2605 found ${link.hello.handle} \u2014 auto-opening
+        process2.stdout.write(`  \u2605 found ${sanitizePeerText(link.hello.handle)} \u2014 auto-opening
 `);
       }
       pairing.add(link);
@@ -2191,9 +2674,13 @@ async function cmdLive(dating, any, to) {
   };
   process2.once("SIGINT", stop);
   process2.once("SIGTERM", stop);
+  let quitRequested = false;
   for await (const line of rl) {
     const text = line.trim();
-    if (text === "/quit") break;
+    if (text === "/quit") {
+      quitRequested = true;
+      break;
+    }
     if (text === "/next") {
       pairing.next();
       continue;
@@ -2214,6 +2701,13 @@ async function cmdLive(dating, any, to) {
       process2.stdout.write("  \xB7 no peer yet \u2014 waiting for a match\u2026\n");
     }
   }
+  if (!quitRequested && shouldKeepAlive(keepAlive, process2.stdin.isTTY)) {
+    process2.stdout.write("  stdin closed \u2014 staying in the swarm (Ctrl+C / SIGTERM to leave)\n");
+    await new Promise((resolve) => {
+      process2.once("SIGINT", () => resolve());
+      process2.once("SIGTERM", () => resolve());
+    });
+  }
   process2.removeListener("SIGINT", stop);
   process2.removeListener("SIGTERM", stop);
   const cur = pairing.current();
@@ -2351,18 +2845,129 @@ async function cmdBlocklist() {
 `);
   return 0;
 }
+async function cmdDaemonRun(any) {
+  const profile = loadProfile();
+  if (!profile) {
+    process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+    return 1;
+  }
+  if (!canShareLive()) grantLiveConsent();
+  const dir = defaultStateDir();
+  writeDaemonState(dir, { pid: process2.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), any, version: VERSION });
+  const hello = buildHello(profile);
+  const { topics, acceptLeague } = discoveryScope(profile.league, any);
+  const session = await startDiscovery({
+    hello,
+    topics,
+    acceptLeague,
+    isBlocked: blockedChecker(),
+    onPeer: (peer, isNew) => {
+      process2.stdout.write(
+        `  [${(/* @__PURE__ */ new Date()).toISOString()}] ${isNew ? "NEW match" : "peer seen"}: ${sanitizePeerText(peer.handle)} (${peer.league} \xB7 ${peer.harness})
+`
+      );
+    }
+  });
+  process2.stdout.write(
+    `  vibedating daemon running (pid ${process2.pid}) \u2014 notify-only${any ? " \xB7 --any" : ""}
+`
+  );
+  await new Promise((resolve) => {
+    process2.once("SIGINT", () => resolve());
+    process2.once("SIGTERM", () => resolve());
+  });
+  await session.close();
+  removeDaemonState(dir);
+  process2.stdout.write("  daemon stopped\n");
+  return 0;
+}
+async function cmdDaemon(arg, any) {
+  switch (arg) {
+    case "start": {
+      if (loadProfile() === null) {
+        process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+        return 1;
+      }
+      const r = startDaemon({ any, version: VERSION });
+      if (!r.started) {
+        process2.stdout.write(`  ${r.reason}
+`);
+        return 0;
+      }
+      process2.stdout.write(`  daemon started (pid ${r.pid}) \u2014 notify-only: alerts on NEW matches, never opens chat/video
+`);
+      process2.stdout.write(`  logs: ~/.vibedating/daemon.log \xB7 stop: vibedate daemon stop
+`);
+      return 0;
+    }
+    case "stop": {
+      const r = await stopDaemon();
+      process2.stdout.write(
+        r.stopped ? `  daemon stopped (pid ${r.pid})
+` : `  ${r.reason}
+`
+      );
+      return 0;
+    }
+    case "status": {
+      const s = daemonStatus();
+      if (s.running && s.state !== null) {
+        process2.stdout.write(
+          `  daemon running (pid ${s.state.pid}) since ${s.state.startedAt}${s.state.any ? " \xB7 --any" : ""}
+`
+        );
+      } else {
+        process2.stdout.write("  daemon not running\n");
+      }
+      return 0;
+    }
+    case "run":
+      return cmdDaemonRun(any);
+    case "install": {
+      if (loadProfile() === null) {
+        process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+        return 1;
+      }
+      const r = installDaemonService({ any });
+      process2.stdout.write(`  ${r.detail}
+`);
+      if (r.servicePath !== null) process2.stdout.write(`  service: ${r.servicePath}
+`);
+      if (r.installed) process2.stdout.write("  undo anytime: vibedate daemon uninstall\n");
+      return r.installed ? 0 : 1;
+    }
+    case "uninstall": {
+      const r = uninstallDaemonService({});
+      process2.stdout.write(`  ${r.detail}
+`);
+      return 0;
+    }
+    default:
+      process2.stderr.write("usage: vibedating daemon [start|stop|status|install|uninstall] [--any]\n");
+      return 1;
+  }
+}
 var HELP = `vibedating ${VERSION} \u2014 dating by tokens (local-first)
 
 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]  Live chat (your league + adjacent; --any = everyone; /next or --dating pick; --to targets one peer)
+  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; --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)
   vibedating unblock <@handle>  Remove a handle from the blocklist
   vibedating blocklist          List blocked handles
+  vibedating daemon [start|stop|status|install|uninstall] [--any]
+                                Manage the notify-only background daemon \u2014 alerts on
+                                NEW matches, never opens chat/video. install adds a
+                                login service (launchd on macOS, systemd on Linux);
+                                uninstall removes it.
   vibedating open [--port N] [--any]  Serve the local web app (default: random port)
                                 + live video + chat with connected peers
                                 (your league + adjacent; --any = every league)
@@ -2410,14 +3015,16 @@ async function main(argv) {
       return cmdUnblock(parsed.arg);
     case "blocklist":
       return cmdBlocklist();
+    case "daemon":
+      return cmdDaemon(parsed.arg, parsed.any);
     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);
+      return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive, parsed.viaRelay);
     case "find":
       return cmdFind(parsed.arg, parsed.any);
     case "mcp":
@@ -2448,5 +3055,7 @@ if (entryUrl !== void 0) {
   }
 }
 export {
-  parseArgs
+  formatAgo,
+  parseArgs,
+  shouldKeepAlive
 };