vibedate 0.4.1 → 0.5.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-I5U3O4RH.js}

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

package/dist/{chunk-43IYNWES.js → chunk-KKWP4DLY.js}

@@ -656,6 +656,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 +846,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
@@ -1036,12 +1046,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 +1067,7 @@ export {
   signHelloClaims,
   verifyHelloClaims,
   classifyHelloIdentity,
+  sanitizePeerText,
   TOPIC_PREFIX,
   leagueTopic,
   LIVE_NOTICE,

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,26 @@ 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;
 }
 /**
  * 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 };

package/dist/cli.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-ZB56ZBAR.js";
+} from "./chunk-I5U3O4RH.js";
 import {
   CANDIDATES,
+  DEFAULT_HANDLE,
   LIVE_NOTICE,
+  MAX_HANDLE_LEN,
   TOPIC_PREFIX,
   addBlock,
   allLeagueNames,
   canShareLive,
   connectProfile,
+  defaultStateDir,
   grantLiveConsent,
   isBlocked,
   league,
@@ -17,6 +20,7 @@ import {
   leagueTopic,
   leaguesWithin,
   loadBlocklist,
+  loadHandle,
   loadOrCreateIdentity,
   loadPeers,
   loadProfile,
@@ -27,16 +31,356 @@ import {
   removeBlock,
   resolveHandle,
   sameHandle,
+  sanitizePeerText,
   saveHandle,
   signHelloClaims,
   startDiscovery
-} from "./chunk-43IYNWES.js";
+} from "./chunk-KKWP4DLY.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 +1843,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 +2112,7 @@ async function handle(req, res, opts) {
 }
 
 // src/cli.ts
-var VERSION = "0.4.1";
+var VERSION = "0.5.0";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -1782,7 +2126,8 @@ function parseArgs(argv) {
     dating: false,
     any: false,
     arg: void 0,
-    to: void 0
+    to: void 0,
+    keepAlive: false
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -1794,7 +2139,8 @@ function parseArgs(argv) {
         dating: false,
         any: false,
         arg: void 0,
-        to: void 0
+        to: void 0,
+        keepAlive: false
       };
     }
     if (a === "--help" || a === "-h") {
@@ -1805,13 +2151,18 @@ function parseArgs(argv) {
         dating: false,
         any: false,
         arg: void 0,
-        to: void 0
+        to: void 0,
+        keepAlive: false
       };
     }
     if (a === "--live") {
       out = { ...out, live: true };
       continue;
     }
+    if (a === "--keep-alive") {
+      out = { ...out, keepAlive: true };
+      continue;
+    }
     if (a === "--any") {
       out = { ...out, any: true };
       continue;
@@ -1847,7 +2198,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 +2218,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 +2275,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 +2287,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 +2353,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");
@@ -2113,7 +2486,10 @@ 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 cmdLive(dating, any, to, keepAlive) {
   const profile = loadProfile();
   if (!profile) {
     process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
@@ -2148,11 +2524,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 +2542,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 +2567,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 +2594,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 +2738,128 @@ 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]  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)
   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,6 +2907,8 @@ 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":
@@ -2417,7 +2916,7 @@ async function main(argv) {
     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);
     case "find":
       return cmdFind(parsed.arg, parsed.any);
     case "mcp":
@@ -2448,5 +2947,7 @@ if (entryUrl !== void 0) {
   }
 }
 export {
-  parseArgs
+  formatAgo,
+  parseArgs,
+  shouldKeepAlive
 };

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   signHelloClaims,
   startDiscovery,
   verifyHelloClaims
-} from "./chunk-43IYNWES.js";
+} from "./chunk-KKWP4DLY.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   runMcp
-} from "./chunk-ZB56ZBAR.js";
-import "./chunk-43IYNWES.js";
+} from "./chunk-I5U3O4RH.js";
+import "./chunk-KKWP4DLY.js";
 export {
   runMcp
 };

package/package.json

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