sportsing 0.1.0

package/src/liveness.ts

@@ -0,0 +1,82 @@
+// Liveness primitive for a running `watch --wait`: a pidfile so a supervisor
+// (the agent-setup --check status + the /loop agent-setup skill) can tell whether
+// the watcher is alive and restart it after a silent death. Zero-dep — plain fs
+// over the sportsing cache dir.
+
+import { mkdirSync, writeFileSync, unlinkSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { CACHE_DIR } from "./config.ts";
+
+/** Stable, documented pidfile path for a `watch --wait` process. Other commands
+ *  (e.g. `agent-setup --check`) locate the watcher here without guessing:
+ *  `~/.cache/sportsing/watch-wait.pid` (CACHE_DIR/watch-wait.pid). */
+export const WATCH_PIDFILE = join(CACHE_DIR, "watch-wait.pid");
+
+/** True if `pid` names a process that currently exists. Uses signal 0, which does
+ *  no actual signalling — it only probes existence (throws ESRCH if gone). */
+export function pidAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false; // ESRCH (no such process) → not alive
+  }
+}
+
+/**
+ * Record this process's PID in the watch pidfile and arrange its removal on a
+ * clean exit and on SIGINT/SIGTERM. Call once at the start of a `watch --wait`.
+ * Writes nothing to stdout (preserves the backgroundable `--quiet &` contract).
+ */
+export function writeWatchPidfile(): void {
+  mkdirSync(dirname(WATCH_PIDFILE), { recursive: true });
+  writeFileSync(WATCH_PIDFILE, String(process.pid));
+
+  let removed = false;
+  const cleanup = () => {
+    if (removed) return;
+    removed = true;
+    try {
+      unlinkSync(WATCH_PIDFILE);
+    } catch {
+      /* already gone */
+    }
+  };
+  process.on("exit", cleanup); // covers normal return + any process.exit()
+
+  // Remove the pidfile on signals too. We must NOT process.exit() here when
+  // another handler is already registered (the overlay installs a SIGINT handler
+  // that closes the Chrome window before exiting) — exiting first would orphan
+  // that window. So: clean up the pidfile, and only when we're the sole listener
+  // (the pre-overlay wait phase) re-raise the signal to terminate normally.
+  for (const sig of ["SIGINT", "SIGTERM"] as const) {
+    const handler = () => {
+      cleanup();
+      if (process.listenerCount(sig) <= 1) {
+        process.removeListener(sig, handler);
+        process.kill(process.pid, sig);
+      }
+    };
+    process.on(sig, handler);
+  }
+}
+
+/** The PID recorded in the pidfile, or null if absent/malformed. */
+export function readWatchPid(): number | null {
+  try {
+    const pid = Number(readFileSync(WATCH_PIDFILE, "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Whether a `watch --wait` is currently alive: the pidfile must exist AND name a
+ *  live process. A stale pidfile (process gone) reports false — never a false
+ *  "running". Scope: only `watch --wait` writes the pidfile, so a live *non*-wait
+ *  `watch` (e.g. a one-shot hub open) correctly reports false here. */
+export function isWatchAlive(): boolean {
+  const pid = readWatchPid();
+  return pid != null && pidAlive(pid);
+}

package/src/match-detect.ts

@@ -0,0 +1,136 @@
+// Detect which match the user is on from the stream page's document.title, so
+// the overlay can follow them. Peacock/Telemundo titles are Spanish
+// ("Catar v. Suiza - Peacock"); Fubo/Fox are English. We canonicalize each
+// side to an ESPN team abbreviation (TLA) when we know the Spanish alias, else
+// pass the raw token through (English names resolve by name match downstream).
+
+/** Normalized Spanish (and a few English) team names → ESPN TLA. */
+const NAME_TO_TLA: Record<string, string> = {
+  "estados unidos": "USA",
+  catar: "QAT",
+  suiza: "SUI",
+  brasil: "BRA",
+  marruecos: "MAR",
+  turquia: "TUR",
+  "corea del sur": "KOR",
+  sudafrica: "RSA",
+  mexico: "MEX",
+  chequia: "CZE",
+  "republica checa": "CZE",
+  "bosnia y herzegovina": "BIH",
+  canada: "CAN",
+  haiti: "HAI",
+  escocia: "SCO",
+  argelia: "ALG",
+  belgica: "BEL",
+  alemania: "GER",
+  espana: "ESP",
+  inglaterra: "ENG",
+  francia: "FRA",
+  croacia: "CRO",
+  "paises bajos": "NED",
+  holanda: "NED",
+  japon: "JPN",
+  // identical or near-identical across languages (still useful as explicit hits)
+  paraguay: "PAR",
+  australia: "AUS",
+  argentina: "ARG",
+  portugal: "POR",
+  uruguay: "URU",
+  colombia: "COL",
+  senegal: "SEN",
+  ecuador: "ECU",
+};
+
+/** Lowercase + strip accents/punctuation for forgiving lookup. */
+function normalize(s: string): string {
+  return s
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .replace(/[^a-z ]/g, "")
+    .trim();
+}
+
+function canonical(token: string): string {
+  const n = normalize(token);
+  return NAME_TO_TLA[n] ?? n; // TLA when known, else the normalized token
+}
+
+export type StreamLang = "english" | "spanish";
+
+export type PageContext =
+  | { kind: "match"; teams: [string, string]; lang?: StreamLang }
+  | { kind: "today" }
+  | { kind: "unknown" };
+
+// Team names that are *distinctively* one language (the normalized form differs
+// across English/Spanish), so seeing one in a title reveals the broadcast cast.
+// These are EXPLICIT (not derived from NAME_TO_TLA) on purpose: NAME_TO_TLA is a
+// lookup table whose keys could gain English-form entries, which would silently
+// corrupt language inference. Language-neutral names (Mexico, Paraguay, Australia,
+// Argentina, Portugal, Uruguay, Colombia, Senegal, Ecuador, Canada, Haiti) carry
+// no signal and appear in neither set.
+const SPANISH_NAMES = new Set([
+  "estados unidos", "catar", "suiza", "brasil", "marruecos", "turquia", "corea del sur",
+  "sudafrica", "chequia", "republica checa", "bosnia y herzegovina", "escocia", "argelia",
+  "belgica", "alemania", "espana", "inglaterra", "francia", "croacia", "paises bajos",
+  "holanda", "japon",
+]);
+const ENGLISH_NAMES = new Set([
+  "united states", "qatar", "switzerland", "brazil", "morocco", "turkey", "turkiye",
+  "south korea", "south africa", "czechia", "czech republic", "bosnia and herzegovina",
+  "scotland", "algeria", "belgium", "germany", "spain", "england", "france", "croatia",
+  "netherlands", "holland", "japan",
+]);
+
+/** Infer the broadcast language from the two team tokens + provider suffix.
+ *  Conservative: returns undefined when undeterminable (so callers never warn on
+ *  a guess). A distinctive team name decides it — Spanish is checked first, so a
+ *  mixed title (one Spanish, one English token — not expected in a real cast)
+ *  resolves to spanish. Otherwise Peacock's World Cup feed is Telemundo (Spanish). */
+function inferLang(a: string, b: string, isPeacock: boolean): StreamLang | undefined {
+  const na = normalize(a);
+  const nb = normalize(b);
+  if (SPANISH_NAMES.has(na) || SPANISH_NAMES.has(nb)) return "spanish";
+  if (ENGLISH_NAMES.has(na) || ENGLISH_NAMES.has(nb)) return "english";
+  if (isPeacock) return "spanish";
+  return undefined; // e.g. Fubo + only language-neutral names — can't tell
+}
+
+/**
+ * Classify a stream page from its title.
+ *  - "<A> v. <B> - Provider"  → match (teams canonicalized to TLA/name; lang when known)
+ *  - World Cup hub / home     → today
+ *  - anything else            → unknown (overlay keeps its current match)
+ */
+export function detectFromTitle(title: string): PageContext {
+  const raw = title || "";
+  const isPeacock = /peacock/i.test(raw);
+  const t = raw.replace(/\s*[-|]\s*(Peacock|Fubo|fubo\.tv).*$/i, "").trim();
+
+  const vs = t.match(/^(.+?)\s+(?:v\.?|vs\.?|versus)\s+(.+)$/i);
+  if (vs && vs[1] && vs[2]) {
+    const lang = inferLang(vs[1], vs[2], isPeacock);
+    const teams: [string, string] = [canonical(vs[1]), canonical(vs[2])];
+    return lang ? { kind: "match", teams, lang } : { kind: "match", teams };
+  }
+
+  const n = normalize(t);
+  if (/(copa mundial|world cup|fifa|home|inicio)/.test(n)) return { kind: "today" };
+
+  return { kind: "unknown" };
+}
+
+/** Candidate substrings to recognize a team on a provider page (English name,
+ *  abbreviation, and any Spanish aliases) — for finding a game tile to click. */
+export function searchTerms(name: string, abbr: string): string[] {
+  const out = new Set<string>();
+  if (name) out.add(normalize(name));
+  if (abbr) out.add(abbr.toLowerCase());
+  const tla = abbr.toUpperCase();
+  for (const [alias, t] of Object.entries(NAME_TO_TLA)) {
+    if (t === tla) out.add(alias);
+  }
+  return [...out].filter(Boolean);
+}

package/src/match-util.ts

@@ -0,0 +1,19 @@
+// Pure, dependency-light helpers over the Match shape. Lives at the top level
+// (not under commands/) so both the command layer (_lib.ts) and pure modules
+// like events.ts can share one source of truth without events.ts taking a
+// dependency on the I/O-bearing command layer.
+
+import type { Match } from "./types.ts";
+
+/** True if either side of the match matches `needle` (lowercased) by name/tla/shortName. */
+export function matchHasTeam(m: Match, needle: string): boolean {
+  const fields = [
+    m.homeTeam.name,
+    m.homeTeam.tla,
+    m.homeTeam.shortName,
+    m.awayTeam.name,
+    m.awayTeam.tla,
+    m.awayTeam.shortName,
+  ];
+  return fields.some((f) => f?.toLowerCase().includes(needle));
+}

package/src/notify.ts

@@ -0,0 +1,94 @@
+// Zero-dep OS-notification helper. Raises a desktop notification via the best
+// available backend, optionally clickable to run a command, and degrades
+// gracefully (terminal bell, never throws) where no notifier binary exists.
+//
+// Backend preference:
+//   macOS   terminal-notifier (supports -execute on-click) → osascript (no click)
+//   Linux   notify-send (no click)
+//   any     terminal bell (\a) when nothing else is available
+//
+// Mirrors the Bun.which-guard pattern used for the `ui-leaf` CLI in
+// src/stream.ts. Fire-and-forget: spawns the notifier without blocking and
+// swallows spawn errors so a missing/odd binary never breaks a live tick.
+
+export interface NotifyOptions {
+  /** Smaller line shown under the title (macOS only). */
+  subtitle?: string;
+  /** Play a sound: `true` for the default, or a named system sound (e.g. "Ping"). macOS only. */
+  sound?: boolean | string;
+  /** Collapse repeated alerts: notifications sharing a group replace each other. macOS + terminal-notifier only. */
+  group?: string;
+  /** Shell command run when the notification is clicked. macOS + terminal-notifier only. */
+  onClick?: string;
+}
+
+export type NotifyBackend = "terminal-notifier" | "osascript" | "notify-send" | "bell";
+
+/**
+ * Which notifier backend `notify` would use right now. On macOS, prefer
+ * terminal-notifier (the only backend that supports `onClick` via -execute);
+ * when it's absent, osascript still raises the notification but silently drops
+ * any click action. Callers that need click support can check for the
+ * "terminal-notifier" result before relying on `onClick`.
+ */
+export function notifierBackend(): NotifyBackend {
+  if (process.platform === "darwin") {
+    if (Bun.which("terminal-notifier")) return "terminal-notifier";
+    if (Bun.which("osascript")) return "osascript";
+  } else if (process.platform === "linux") {
+    if (Bun.which("notify-send")) return "notify-send";
+  }
+  return "bell";
+}
+
+/** Escape a string for embedding in an AppleScript double-quoted literal. */
+function osaEscape(s: string): string {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function spawnQuiet(cmd: string[]): void {
+  try {
+    Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore" });
+  } catch {
+    // A flaky/missing binary must never break the caller — fall through silently.
+  }
+}
+
+/**
+ * Raise a desktop notification. Returns the backend that handled it; "bell" means
+ * no notifier binary was available and a terminal bell was emitted instead. Never throws.
+ */
+export function notify(title: string, body: string, opts: NotifyOptions = {}): NotifyBackend {
+  const backend = notifierBackend();
+
+  if (backend === "terminal-notifier") {
+    const cmd = ["terminal-notifier", "-title", title, "-message", body];
+    if (opts.subtitle) cmd.push("-subtitle", opts.subtitle);
+    if (opts.group) cmd.push("-group", opts.group);
+    if (opts.onClick) cmd.push("-execute", opts.onClick);
+    if (opts.sound) cmd.push("-sound", opts.sound === true ? "default" : opts.sound);
+    spawnQuiet(cmd);
+    return backend;
+  }
+
+  if (backend === "osascript") {
+    let script = `display notification "${osaEscape(body)}" with title "${osaEscape(title)}"`;
+    if (opts.subtitle) script += ` subtitle "${osaEscape(opts.subtitle)}"`;
+    if (opts.sound) script += ` sound name "${osaEscape(opts.sound === true ? "default" : opts.sound)}"`;
+    spawnQuiet(["osascript", "-e", script]);
+    return backend;
+  }
+
+  if (backend === "notify-send") {
+    spawnQuiet(["notify-send", title, body]);
+    return backend;
+  }
+
+  // Last resort: a terminal bell. Never throws.
+  try {
+    process.stderr.write("\x07");
+  } catch {
+    /* even the bell is best-effort */
+  }
+  return "bell";
+}