sportsing 0.1.2 → 0.2.1

package/src/commands/live.ts

@@ -2,14 +2,13 @@ import { c } from "../ansi.ts";
 import { getMatches, NoKeyError } from "../api.ts";
 import { matchLine, fmtTimeOnly, stageLabel } from "../format.ts";
 import { ymd, addDays, localDateOf, sortByDate } from "./_lib.ts";
-import { getFavorites } from "../config.ts";
+import { getApiKey, getFavorites } from "../config.ts";
 import { diffEvents, type MatchEvent } from "../events.ts";
-import { notify } from "../notify.ts";
+import { LIVE_REFRESH_MS, raise, type Alert, type Alerter } from "../alerts.ts";
+import { inTerminal, selfInvocation, watchCommand } from "../click-to-watch.ts";
 import { matchHasTeam } from "../match-util.ts";
 import type { Match } from "../types.ts";
 
-const REFRESH_MS = 60_000; // free tier note: scores are delayed; 60s is plenty.
-
 export async function live(args: string[] = []) {
   const wantNotify = args.includes("--notify");
   const wantQuiet = args.includes("--quiet");
@@ -27,7 +26,7 @@ export async function live(args: string[] = []) {
     await getMatches({ status: "IN_PLAY" }, 0);
   } catch (e) {
     if (e instanceof NoKeyError) {
-      console.error(c.yellow("Live scores need an API key. Run `sportsing setup` first."));
+      console.error(c.yellow("Live scores need an API key. Run `sportsing fifa setup` first."));
       return;
     }
     throw e;
@@ -35,7 +34,7 @@ export async function live(args: string[] = []) {
 
   let favorites: string[] = [];
   if (wantNotify) {
-    favorites = await getFavorites();
+    favorites = await getFavorites("fifa");
     if (favorites.length === 0) {
       // --notify with no favourites would silently never alert; say so once.
       // All on stderr so --quiet keeps stdout clean for backgrounding.
@@ -52,21 +51,10 @@ export async function live(args: string[] = []) {
     console.error(c.dim(`Favorite-team alerts running (${who}) — Ctrl-C to stop.`));
   }
 
-  // Previous tick's full snapshot of today's matches, for fav-event diffing.
-  // diffEvents only emits transitions between prev→cur, so an event fires once
-  // and never re-alerts on a later unchanged tick (AGT-507 idempotency).
-  let prevSnapshot: Match[] = [];
+  const feed = wantNotify ? fifaFeed(favorites, selfInvocation()) : null;
 
   const tick = async () => {
-    const now = new Date();
-    const today = ymd(now);
-    // Query ±1 UTC day, then keep only matches on today's local calendar date
-    // (a local day straddles two UTC days — see today.ts).
-    const { matches: raw } = await getMatches(
-      { dateFrom: ymd(addDays(now, -1)), dateTo: ymd(addDays(now, 1)) },
-      20_000,
-    );
-    const matches = raw.filter((m) => localDateOf(m.utcDate) === today);
+    const matches = await matchesToday();
 
     // Full-screen scoreboard — skipped in --quiet so the command can be
     // backgrounded without alt-screen clears corrupting the parent shell.
@@ -102,26 +90,13 @@ export async function live(args: string[] = []) {
       }
     }
 
-    if (wantNotify) {
-      // Diff this snapshot against the previous tick's and alert on new fav
-      // events. The first tick has an empty prevSnapshot, so it only establishes
-      // a baseline (a match already in play when you start raises no kickoff).
-      for (const e of diffEvents(prevSnapshot, matches, favorites)) {
-        const { title, body } = formatEvent(e);
-        // Kickoff alerts are click-to-watch: clicking launches `watch <fav team>`
-        // (terminal-notifier -execute). notify() degrades to a plain, non-clickable
-        // notification when terminal-notifier is absent. Goal/full-time stay informational.
-        // process.execPath is the sportsing binary when distributed (compiled); under
-        // `bun run` dev it's the Bun runtime, so the click command only works compiled.
-        const onClick = kickoffWatchCommand(e, matches, favorites, process.execPath);
-        notify(title, body, { group: `sportsing-${e.matchId}`, sound: e.kind === "goal", onClick });
-      }
-      prevSnapshot = matches;
-    }
+    // The first tick only establishes a baseline (a match already in play when
+    // you start raises no kickoff).
+    if (feed) for (const a of feed(matches)) raise(a);
   };
 
   await tick();
-  const interval = setInterval(() => tick().catch((e) => console.error(c.red(String(e)))), REFRESH_MS);
+  const interval = setInterval(() => tick().catch((e) => console.error(c.red(String(e)))), LIVE_REFRESH_MS); // free tier: scores are delayed; 60s is plenty
   process.on("SIGINT", () => {
     clearInterval(interval);
     process.stdout.write("\n");
@@ -133,14 +108,54 @@ function stageTag(m: Match): string {
   return c.dim("  " + stageLabel(m));
 }
 
-/** POSIX single-quote a string so it's safe as one shell argument. */
-function shQuote(s: string): string {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
+/** Today's matches (local calendar day). football-data filters by UTC date, so
+ *  query ±1 UTC day and keep the local day (a local day straddles two UTC days). */
+async function matchesToday(): Promise<Match[]> {
+  const now = new Date();
+  const today = ymd(now);
+  const { matches } = await getMatches({ dateFrom: ymd(addDays(now, -1)), dateTo: ymd(addDays(now, 1)) }, 20_000);
+  return matches.filter((m) => localDateOf(m.utcDate) === today);
+}
+
+/**
+ * A stateful fav-alert feed: hand it each tick's matches and it returns the
+ * alerts for new favourite events since the previous tick. diffEvents only
+ * emits prev→cur transitions, so an event fires once and never re-alerts on a
+ * later unchanged tick (AGT-507 idempotency); the first tick is the baseline.
+ *
+ * Kickoff alerts are click-to-watch: clicking opens a Terminal running
+ * `fifa watch <fav team>` (terminal-notifier -execute; notify() drops the click
+ * when terminal-notifier is absent). Goal/full-time stay informational.
+ */
+export function fifaFeed(favorites: string[], exe: string[]): (matches: Match[]) => Alert[] {
+  let prev: Match[] = [];
+  return (matches) => {
+    const alerts = diffEvents(prev, matches, favorites).map((e): Alert => {
+      const { title, body } = formatEvent(e);
+      const onClick = kickoffWatchCommand(e, matches, favorites, exe);
+      return {
+        title,
+        body,
+        options: { group: `sportsing-${e.matchId}`, sound: e.kind === "goal", onClick: onClick && inTerminal(onClick) },
+      };
+    });
+    prev = matches;
+    return alerts;
+  };
+}
+
+/** FIFA's alerter for bare `sportsing live --notify`; null with no FIFA favorites. */
+export async function fifaAlerter(): Promise<Alerter | null> {
+  const favorites = await getFavorites("fifa");
+  if (favorites.length === 0) return null;
+  if (!(await getApiKey())) throw new Error("FIFA alerts need an API key — run `sportsing fifa setup`.");
+  const feed = fifaFeed(favorites, selfInvocation());
+  return { label: "FIFA", teams: favorites, poll: async () => feed(await matchesToday()) };
 }
 
 /**
  * The click-to-watch command for a kickoff event, or undefined when none applies.
- * Returns `<exe> fifa watch <fav>` (shell-quoted) where `fav` is the favourite
+ * Returns `<exe…> fifa watch <fav>` (shell-quoted) where `fav` is the favourite
  * term that put this match on the alert list — so clicking the kickoff alert opens
  * that team's broadcast. Only kickoff events are clickable (goal/full-time are
  * informational); returns undefined if the match or a matching favourite is gone.
@@ -149,14 +164,14 @@ export function kickoffWatchCommand(
   e: MatchEvent,
   matches: Match[],
   favorites: string[],
-  exe: string,
+  exe: string[],
 ): string | undefined {
   if (e.kind !== "kickoff") return undefined;
   const match = matches.find((m) => m.id === e.matchId);
   if (!match) return undefined;
   const fav = favorites.find((f) => matchHasTeam(match, f.trim().toLowerCase()));
   if (!fav) return undefined;
-  return `${shQuote(exe)} fifa watch ${shQuote(fav.trim())}`;
+  return watchCommand(exe, "fifa", fav.trim());
 }
 
 /** Notification title + body for a fav match event. */

package/src/commands/me.ts

@@ -8,7 +8,7 @@ import type { Match, StandingsTable } from "../types.ts";
 // `sportsing fifa me` — a personalized dashboard for your favorite teams:
 // last result, next match + countdown, and current group position.
 export async function me(_args: string[]): Promise<void> {
-  const favorites = await getFavorites();
+  const favorites = await getFavorites("fifa");
   if (favorites.length === 0) return noFavoritesHint();
 
   const matches = await withFallback(

package/src/commands/predict.ts

@@ -49,7 +49,7 @@ export async function predict(args: string[]) {
   }
 
   process.stderr.write(c.dim("Posted to the ask bus — waiting for your Claude agent to answer…\n"));
-  process.stderr.write(c.dim("(keep one serving:  /loop sportsing serve)\n"));
+  process.stderr.write(c.dim("(keep one serving:  /loop sportsing fifa serve)\n"));
   const id = await postQuestion({
     source: "predict",
     question: prompt,
@@ -60,7 +60,7 @@ export async function predict(args: string[]) {
   const prediction = await waitForAnswer(id, 180_000);
   if (prediction === null) {
     console.error(c.yellow("No Claude agent answered within 3 minutes."));
-    console.error(c.dim("Start a serving agent in another Claude session, then retry:  /loop sportsing serve"));
+    console.error(c.dim("Start a serving agent in another Claude session, then retry:  /loop sportsing fifa serve"));
     console.error(c.dim("Or run with --prompt to predict elsewhere."));
     process.exitCode = 1;
     return;

package/src/commands/scorers.ts

@@ -8,7 +8,7 @@ export async function scorers() {
     list = (await getScorers()).scorers;
   } catch (e) {
     if (e instanceof NoKeyError) {
-      console.error(c.yellow("Top scorers need live data. Run `sportsing setup` to add a free API key."));
+      console.error(c.yellow("Top scorers need live data. Run `sportsing fifa setup` to add a free API key."));
       return;
     }
     throw e;

package/src/commands/setup.ts

@@ -2,10 +2,10 @@ import { c } from "../ansi.ts";
 import { setApiKey, getApiKey, CONFIG_FILE } from "../config.ts";
 
 export async function setup(args: string[]) {
-  // Non-interactive: `sportsing setup <key>`
+  // Non-interactive: `sportsing fifa setup <key>`
   const inline = args.find((a) => !a.startsWith("--"));
 
-  console.log(c.bold(c.cyan("⚽ sportsing setup")));
+  console.log(c.bold(c.cyan("⚽ sportsing fifa setup")));
   console.log(
     "\nLive data comes from " +
       c.underline("football-data.org") +
@@ -36,5 +36,5 @@ export async function setup(args: string[]) {
   console.log(c.green("ok ✓"));
   await setApiKey(key);
   console.log(c.dim(`Saved to ${CONFIG_FILE}`));
-  console.log("\nTry: " + c.bold("sportsing today") + " · " + c.bold("sportsing next") + " · " + c.bold("sportsing bracket"));
+  console.log("\nTry: " + c.bold("sportsing fifa today") + " · " + c.bold("sportsing fifa next") + " · " + c.bold("sportsing fifa bracket"));
 }

package/src/commands/subscriptions.ts

@@ -0,0 +1,66 @@
+import { c } from "../ansi.ts";
+import {
+  getSubscriptions,
+  setSubscriptions,
+  getHomeMarket,
+  setHomeMarket,
+  parseSubscriptions,
+  parseHomeMarket,
+  CONFIG_FILE,
+} from "../config.ts";
+import { SUBSCRIPTIONS, SUBSCRIPTION_LABELS, HOME_MARKETS } from "../watchability.ts";
+
+// `sportsing subscriptions [set <ids…> | market <id>]` — what you can watch
+// with, and where you live (for blackouts and local channels). Cross-sport:
+// the same Fubo / antenna covers every league.
+export async function subscriptions(args: string[]): Promise<void> {
+  const [sub, ...rest] = args;
+
+  if (!sub || sub === "list" || sub === "show") return show();
+
+  if (sub === "set") {
+    if (rest.length === 0) return usage("subscriptions set <" + SUBSCRIPTIONS.join("|") + "|none>…");
+    const none = rest.length === 1 && rest[0]!.trim().toLowerCase() === "none";
+    const { subscriptions: subs, invalid } = none ? { subscriptions: [], invalid: [] } : parseSubscriptions(rest);
+    if (invalid.length) {
+      console.error(c.red(`Unknown subscription: ${invalid.join(", ")}`) + c.dim(` (choose from ${SUBSCRIPTIONS.join(", ")})`));
+      process.exitCode = 1;
+      return;
+    }
+    await setSubscriptions(subs);
+    console.log(c.green("✓ Saved.") + c.dim(` (${CONFIG_FILE})`));
+    return show();
+  }
+
+  if (sub === "market") {
+    const input = rest.join(" ").trim();
+    if (!input) return usage("subscriptions market <" + Object.keys(HOME_MARKETS).join("|") + ">");
+    const market = parseHomeMarket(input);
+    if (!market) {
+      console.error(c.red(`Unknown home market: ${input}`) + c.dim(` (choose from ${Object.keys(HOME_MARKETS).join(", ")})`));
+      process.exitCode = 1;
+      return;
+    }
+    await setHomeMarket(market);
+    console.log(c.green("✓ Saved.") + c.dim(` (${CONFIG_FILE})`));
+    return show();
+  }
+
+  usage("subscriptions [set <ids…> | market <id>]");
+}
+
+async function show(): Promise<void> {
+  const [subs, market] = await Promise.all([getSubscriptions(), getHomeMarket()]);
+  console.log(c.bold(c.cyan("📺 Subscriptions")));
+  if (subs.length === 0) {
+    console.log(c.dim("  none yet — e.g. ") + c.bold("sportsing subscriptions set fubo nba-league-pass local-ota"));
+  } else {
+    for (const s of subs) console.log(`  ${s} ${c.dim("— " + SUBSCRIPTION_LABELS[s])}`);
+  }
+  console.log(c.bold("Home market: ") + (HOME_MARKETS[market]?.name ?? market) + c.dim(`  (${Object.keys(HOME_MARKETS).join(", ")})`));
+}
+
+function usage(form: string): void {
+  console.error(c.red(`Usage: sportsing ${form}`));
+  process.exitCode = 1;
+}

package/src/commands/table.ts

@@ -11,7 +11,7 @@ export async function table(args: string[]) {
   } catch (e) {
     if (e instanceof NoKeyError) {
       console.error(
-        c.yellow("Group tables need live data. Run `sportsing setup` to add a free API key."),
+        c.yellow("Group tables need live data. Run `sportsing fifa setup` to add a free API key."),
       );
       return;
     }

package/src/commands/upgrade.ts

@@ -0,0 +1,137 @@
+import { existsSync, realpathSync } from "fs";
+import { c } from "../ansi.ts";
+import {
+  REGISTRY_LATEST_URL,
+  canSelfUpgrade,
+  compareVersions,
+  describeInstall,
+  detectInstall,
+  installCommand,
+  manualUpgradeHint,
+  parseRegistryLatest,
+  parseVersionOutput,
+} from "../upgrade.ts";
+
+const FETCH_TIMEOUT_MS = 10_000;
+
+function usage(): void {
+  console.log(`${c.bold("sportsing upgrade")} — install the latest npm release
+
+  sportsing upgrade            reinstall sportsing@latest with the package manager that installed it
+  sportsing upgrade --check    just report current vs latest; installs nothing`);
+}
+
+function fail(msg: string): void {
+  console.error(c.red(msg));
+  process.exitCode = 1;
+}
+
+async function fetchLatest(): Promise<string> {
+  let res: Response;
+  try {
+    res = await fetch(REGISTRY_LATEST_URL, {
+      headers: { "User-Agent": "sportsing", Accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+  } catch (e) {
+    const why = e instanceof Error && e.name === "TimeoutError" ? `timed out after ${FETCH_TIMEOUT_MS / 1000}s` : String((e as Error)?.message ?? e);
+    throw new Error(`Couldn't reach the npm registry (${why}).`);
+  }
+  if (!res.ok) throw new Error(`npm registry returned ${res.status} ${res.statusText}.`);
+  return parseRegistryLatest(await res.json());
+}
+
+/** Realpath of the running entry script, so npm/bun bin symlinks resolve to the package. */
+function runningScript(): string {
+  try {
+    return realpathSync(Bun.main);
+  } catch {
+    return Bun.main; // compiled binaries report a virtual /$bunfs path
+  }
+}
+
+/** Ask the freshly installed copy its version (falls back to null if it can't be run). */
+function installedVersion(bin: string): string | null {
+  if (!existsSync(bin)) return null;
+  try {
+    // Run it under this same Bun so the bin's `#!/usr/bin/env bun` shebang doesn't matter.
+    const r = Bun.spawnSync([process.execPath, realpathSync(bin), "--version"], { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+    return r.exitCode === 0 ? parseVersionOutput(r.stdout.toString()) : null;
+  } catch {
+    return null;
+  }
+}
+
+// `sportsing upgrade [--check]` — self-update to the latest npm release.
+export async function upgrade(args: string[], current: string): Promise<void> {
+  if (args.includes("--help") || args.includes("-h") || args[0] === "help") return usage();
+  const unknown = args.filter((a) => a !== "--check");
+  if (unknown.length) {
+    usage();
+    return fail(`Unknown argument: ${unknown.join(" ")}`);
+  }
+  const check = args.includes("--check");
+  const install = detectInstall(runningScript());
+
+  // Refuse unsupported installs up front — no network needed to say "not from here".
+  if (!check && !canSelfUpgrade(install)) {
+    console.error(c.yellow(`sportsing upgrade can't update a ${describeInstall(install)}.`));
+    console.error(manualUpgradeHint(install));
+    process.exitCode = 1;
+    return;
+  }
+
+  let latest: string;
+  try {
+    latest = await fetchLatest();
+  } catch (e) {
+    return fail(`Error: ${(e as Error).message} Nothing was changed.`);
+  }
+
+  const cmp = compareVersions(current, latest);
+  const status =
+    cmp < 0
+      ? c.yellow(`update available: ${current} → ${latest}`)
+      : cmp === 0
+        ? c.green(`up to date (${current})`)
+        : c.dim(`running ${current}, ahead of the latest release ${latest}`);
+
+  if (check) {
+    console.log(`sportsing ${current}  ${c.dim("latest")} ${latest}  — ${status}`);
+    console.log(c.dim(`installed as: ${describeInstall(install)}`));
+    if (cmp < 0) {
+      console.log(canSelfUpgrade(install) ? c.dim("run `sportsing upgrade` to install it") : c.dim(manualUpgradeHint(install)));
+    }
+    return;
+  }
+
+  if (cmp >= 0) {
+    console.log(`sportsing is ${status}.`);
+    return;
+  }
+  if (!canSelfUpgrade(install)) return; // narrowed above; keeps the type checker honest
+
+  const { cmd, bin } = installCommand(install, existsSync);
+  console.log(c.dim(`Upgrading sportsing ${current} → ${latest} via: ${cmd.join(" ")}`));
+  let code: number;
+  try {
+    const proc = Bun.spawn(cmd, { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+    code = await proc.exited;
+  } catch (e) {
+    return fail(`Error: couldn't run ${cmd[0]} (${(e as Error).message}). Nothing was changed.`);
+  }
+  if (code !== 0) {
+    return fail(`Error: ${cmd.join(" ")} exited ${code}. The upgrade failed; your existing install was left as-is.`);
+  }
+
+  const now = installedVersion(bin);
+  if (!now) {
+    console.error(c.yellow(`Install finished, but couldn't confirm the new version from ${bin}. Check with: sportsing --version`));
+    process.exitCode = 1;
+    return;
+  }
+  if (compareVersions(now, current) <= 0) {
+    return fail(`Install finished, but ${bin} still reports ${now}. Check which sportsing is on your PATH.`);
+  }
+  console.log(c.green(`✓ sportsing ${current} → ${now}`));
+}

package/src/commands/watch.ts

@@ -1,7 +1,7 @@
 import { c } from "../ansi.ts";
 import { findCurrentMatch, resolveWatchTarget, type EspnEvent } from "../espn.ts";
 import { getStreamProvider } from "../config.ts";
-import { PROVIDERS, launchStream, spawnStreamWindow } from "../stream.ts";
+import { launchStream, pickProvider, spawnStreamWindow } from "../stream.ts";
 import { runOverlayStream, type WatchLang } from "../overlay.ts";
 import { freePort, attachToPage } from "../cdp.ts";
 import { writeWatchPidfile } from "../liveness.ts";
@@ -47,13 +47,13 @@ export async function watch(args: string[]) {
   const terms = positionalTerms(args);
 
   // Default to Fubo (English/Fox). Peacock is Spanish-only (Telemundo).
-  const key = (providerFlag ?? (await getStreamProvider()) ?? "fubo").toLowerCase();
-  const provider = PROVIDERS[key];
-  if (!provider) {
-    console.error(c.red(`Unknown provider "${key}". Known: ${Object.keys(PROVIDERS).join(", ")}.`));
+  const pick = pickProvider(providerFlag ?? (await getStreamProvider("fifa")) ?? "fubo", "fifa");
+  if (!pick.ok) {
+    console.error(c.red(pick.error));
     process.exitCode = 1;
     return;
   }
+  const provider = pick;
 
   // `watch` opens a window and BLOCKS until you close it (or Ctrl-C). With no
   // controlling TTY — an agent/build smoke-test, `< /dev/null` — nothing ever
@@ -167,15 +167,23 @@ async function waitForLive(terms: string[]): Promise<EspnEvent> {
       const ms = Date.parse(target.date) - Date.now();
       const eta = ms > 0 ? `kicks off in ${fmtEta(ms)}` : "at/just past kickoff — waiting for it to flip live";
       console.log(c.dim(`  ${eta}.`));
-      if (ms <= 5 * 60_000) pollMs = 15_000; // tighten near kickoff (and once past it)
-      else if (ms <= 15 * 60_000) pollMs = 30_000;
+      pollMs = waitPollMs(ms);
     }
     await new Promise((r) => setTimeout(r, pollMs));
   }
 }
 
+/** How long `watch --wait` sleeps between polls, given the ms until the target
+ *  starts: 60s normally, tightening to 30s inside 15 minutes and 15s inside 5
+ *  (and once past the start, while waiting for the game to flip live). */
+export function waitPollMs(msToStart: number): number {
+  if (msToStart <= 5 * 60_000) return 15_000;
+  if (msToStart <= 15 * 60_000) return 30_000;
+  return 60_000;
+}
+
 /** Coarse human ETA: "1h 4m", "12m 30s", or "45s". */
-function fmtEta(ms: number): string {
+export function fmtEta(ms: number): string {
   const s = Math.max(0, Math.floor(ms / 1000));
   const h = Math.floor(s / 3600);
   const m = Math.floor((s % 3600) / 60);
@@ -189,7 +197,7 @@ function fmtEta(ms: number): string {
  * then tears it down and exits. Bounded (CDP attach has its own timeout) and
  * leaves no survivors — win.close() reaps the ui-leaf/Chrome tree.
  */
-async function smokeWatch(url: string, label: string, windowSize: { width: number; height: number } | undefined): Promise<void> {
+export async function smokeWatch(url: string, label: string, windowSize: { width: number; height: number } | undefined): Promise<void> {
   const port = await freePort();
   const win = await spawnStreamWindow(url, label, { debugPort: port, windowSize });
   if (!win) {
@@ -209,13 +217,13 @@ async function smokeWatch(url: string, label: string, windowSize: { width: numbe
 }
 
 /** Parse a `WxH` size string into a window size, or undefined if absent/invalid. */
-function parseSize(s: string | null): { width: number; height: number } | undefined {
+export function parseSize(s: string | null): { width: number; height: number } | undefined {
   const m = s?.match(/^(\d+)x(\d+)$/);
   return m ? { width: Number(m[1]), height: Number(m[2]) } : undefined;
 }
 
 /** Positional args, dropping flags and the values consumed by --url / --provider / --size. */
-function positionalTerms(args: string[]): string[] {
+export function positionalTerms(args: string[]): string[] {
   const out: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const a = args[i]!;