sportsing 0.1.2 → 0.2.0

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/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]!;

package/src/config.ts

@@ -1,6 +1,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { mkdir, chmod } from "fs/promises";
+import { SUBSCRIPTIONS, HOME_MARKETS, DEFAULT_HOME_MARKET, isSubscription, type Subscription } from "./watchability.ts";
 
 const CONFIG_DIR = join(homedir(), ".config", "sportsing");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
@@ -13,13 +14,24 @@ const LEGACY_CONFIG_FILE = join(homedir(), ".config", "sportsball", "config.json
 
 interface Config {
   apiKey?: string;
+  /** Sport-scoped favorites, `<sport>:<team>` (e.g. `nba:UTAH`, `fifa:USA`).
+   *  Legacy unprefixed entries (pre-NBA/NHL) read as `fifa:<team>`. */
   favorites?: string[];
-  /** Preferred streaming provider for `fifa watch` (peacock | fubo). */
+  /** Preferred streaming provider for `fifa watch` (peacock | fubo). Predates
+   *  per-sport providers, so it only ever applies to fifa. */
   streamProvider?: string;
+  /** Preferred streaming provider per sport for `<sport> watch`, e.g.
+   *  `{ "nba": "fubo" }`. Overrides the sport's built-in default. */
+  streamProviders?: Record<string, string>;
   /** Calibrated overlay delay (seconds) per provider, to sync stats to the stream. */
   streamDelay?: Record<string, number>;
-  /** Overlay panel choices (the gear/settings) — per provider → { panel: on }. */
+  /** Overlay panel choices (the gear/settings) — per provider (FIFA) or
+   *  provider:sport (e.g. "fubo:nba") → { panel: on }. */
   overlayPanels?: Record<string, Record<string, boolean>>;
+  /** What the user can watch with (see SUBSCRIPTIONS in watchability.ts). */
+  subscriptions?: string[];
+  /** HOME_MARKETS id for blackouts / local channels; defaults to Utah. */
+  homeMarket?: string;
 }
 
 /** Default overlay panel visibility — nothing on by default, so a fresh stream
@@ -71,10 +83,18 @@ export async function setApiKey(key: string): Promise<void> {
   await writeConfig(cfg);
 }
 
-/** Preferred streaming provider for `fifa watch`, or null if unset. */
-export async function getStreamProvider(): Promise<string | null> {
-  const cfg = await readConfig();
-  return cfg.streamProvider?.trim().toLowerCase() || null;
+/** A sport's configured streaming provider (lowercased), or null if unset:
+ *  `streamProviders[sport]`, falling back to the legacy `streamProvider` for
+ *  fifa only. Pure over the parsed config. */
+export function streamProviderFor(cfg: Pick<Config, "streamProvider" | "streamProviders">, sport: string): string | null {
+  const s = sport.trim().toLowerCase();
+  const v = cfg.streamProviders?.[s] ?? (s === "fifa" ? cfg.streamProvider : undefined);
+  return v?.trim().toLowerCase() || null;
+}
+
+/** Preferred streaming provider for `<sport> watch`, or null if unset. */
+export async function getStreamProvider(sport: string): Promise<string | null> {
+  return streamProviderFor(await readConfig(), sport);
 }
 
 export async function setStreamProvider(provider: string): Promise<void> {
@@ -96,11 +116,16 @@ export async function setStreamDelay(provider: string, seconds: number): Promise
   await writeConfig(cfg);
 }
 
-/** Overlay panel visibility for a provider (defaults merged with saved choices). */
-export async function getOverlayPanels(provider: string): Promise<Record<string, boolean>> {
+/** Overlay panel visibility for a provider (defaults merged with saved choices).
+ *  `provider` is the overlayPanels key: the provider (FIFA, e.g. "fubo") or
+ *  provider:sport for the league overlays (e.g. "fubo:nba"), whose panels differ. */
+export async function getOverlayPanels(
+  provider: string,
+  defaults: Record<string, boolean> = OVERLAY_PANEL_DEFAULTS,
+): Promise<Record<string, boolean>> {
   const cfg = await readConfig();
   const saved = cfg.overlayPanels?.[provider.trim().toLowerCase()] ?? {};
-  return { ...OVERLAY_PANEL_DEFAULTS, ...saved };
+  return { ...defaults, ...saved };
 }
 
 export async function setOverlayPanel(provider: string, key: string, on: boolean): Promise<void> {
@@ -111,34 +136,147 @@ export async function setOverlayPanel(provider: string, key: string, on: boolean
   await writeConfig(cfg);
 }
 
-/** Favorite teams, in the order they were added (as the user typed them). */
-export async function getFavorites(): Promise<string[]> {
-  const cfg = await readConfig();
-  return cfg.favorites ?? [];
+// ── Favorites ────────────────────────────────────────────────────────────────
+// Stored as `<sport>:<team>` because team abbreviations collide across sports
+// (the Jazz and the Mammoth are both ESPN `UTAH`). Entries written before
+// sports were scoped are bare team names and are read as `fifa:<team>`; the
+// next write rewrites them in prefixed form.
+
+/** The sport a legacy (unprefixed) favorite belongs to. */
+export const LEGACY_FAVORITE_SPORT = "fifa";
+
+/** A stored favorite entry, split into its sport and team. */
+export interface Favorite {
+  sport: string;
+  team: string;
+}
+
+/** Sport prefixes are short lowercase ids (`fifa`, `nba`, `nhl`). */
+const PREFIXED = /^([a-z][a-z0-9]*):(.+)$/;
+
+/** Parse a stored entry; unprefixed (legacy) entries are FIFA teams. */
+export function parseFavorite(entry: string): Favorite {
+  const m = PREFIXED.exec(entry.trim());
+  if (m) return { sport: m[1]!, team: m[2]!.trim() };
+  return { sport: LEGACY_FAVORITE_SPORT, team: entry.trim() };
+}
+
+/** Serialize a favorite to its stored `<sport>:<team>` form. */
+export function formatFavorite(f: Favorite): string {
+  return `${f.sport}:${f.team}`;
 }
 
-/** Add a favorite team. No-op (added=false) if an equal name already exists. */
-export async function addFavorite(team: string): Promise<{ added: boolean; favorites: string[] }> {
+const normSport = (sport: string) => sport.trim().toLowerCase();
+const sameTeam = (a: string, b: string) => a.toLowerCase() === b.trim().toLowerCase();
+
+// Pure helpers over the stored entry list (unit-tested without touching disk).
+
+/** A sport's team names from stored entries, in insertion order. */
+export function favoritesFor(entries: string[], sport: string): string[] {
+  const s = normSport(sport);
+  return entries
+    .filter((e) => e.trim())
+    .map(parseFavorite)
+    .filter((f) => f.sport === s)
+    .map((f) => f.team);
+}
+
+/** Stored entries with `team` added for `sport` (unless an equal name exists in
+ *  that sport, case-insensitive). Output is fully prefixed — legacy migrates. */
+export function withFavorite(entries: string[], sport: string, team: string): { added: boolean; entries: string[] } {
+  const s = normSport(sport);
   const name = team.trim();
+  const all = entries.filter((e) => e.trim()).map(parseFavorite);
+  const exists = all.some((f) => f.sport === s && sameTeam(f.team, name));
+  if (!exists) all.push({ sport: s, team: name });
+  return { added: !exists, entries: all.map(formatFavorite) };
+}
+
+/** Stored entries with `sport`'s `team` removed (case-insensitive); other
+ *  sports are untouched. Output is fully prefixed — legacy migrates. */
+export function withoutFavorite(entries: string[], sport: string, team: string): { removed: boolean; entries: string[] } {
+  const s = normSport(sport);
+  const all = entries.filter((e) => e.trim()).map(parseFavorite);
+  const i = all.findIndex((f) => f.sport === s && sameTeam(f.team, team));
+  if (i >= 0) all.splice(i, 1);
+  return { removed: i >= 0, entries: all.map(formatFavorite) };
+}
+
+/** A sport's favorite team names, in the order they were added (as typed). */
+export async function getFavorites(sport: string): Promise<string[]> {
+  const cfg = await readConfig();
+  return favoritesFor(cfg.favorites ?? [], sport);
+}
+
+/** Add a favorite team for a sport. No-op (added=false) if that sport already
+ *  has an equal name. Returns that sport's favorites. */
+export async function addFavorite(sport: string, team: string): Promise<{ added: boolean; favorites: string[] }> {
   const cfg = await readConfig();
-  const favorites = cfg.favorites ?? [];
-  const exists = favorites.some((f) => f.toLowerCase() === name.toLowerCase());
-  if (!exists) favorites.push(name);
-  cfg.favorites = favorites;
+  const { added, entries } = withFavorite(cfg.favorites ?? [], sport, team);
+  cfg.favorites = entries;
   await writeConfig(cfg);
-  return { added: !exists, favorites };
+  return { added, favorites: favoritesFor(entries, sport) };
+}
+
+/** Remove a sport's favorite team (case-insensitive). removed=false if it
+ *  wasn't there. Returns that sport's favorites. */
+export async function removeFavorite(sport: string, team: string): Promise<{ removed: boolean; favorites: string[] }> {
+  const cfg = await readConfig();
+  const { removed, entries } = withoutFavorite(cfg.favorites ?? [], sport, team);
+  cfg.favorites = entries;
+  await writeConfig(cfg);
+  return { removed, favorites: favoritesFor(entries, sport) };
+}
+
+// ── Subscriptions + home market ──────────────────────────────────────────────
+// Pure helpers over raw input / stored values (unit-tested without touching
+// disk); the async get/set pair below is the IO edge.
+
+/** Parse user input (space- and/or comma-separated ids, any case) into
+ *  subscriptions in canonical order, deduped, plus anything unrecognized. */
+export function parseSubscriptions(input: string[]): { subscriptions: Subscription[]; invalid: string[] } {
+  const tokens = input.flatMap((a) => a.split(",")).map((t) => t.trim().toLowerCase()).filter(Boolean);
+  const invalid = [...new Set(tokens.filter((t) => !isSubscription(t)))];
+  const subscriptions = SUBSCRIPTIONS.filter((s) => tokens.includes(s));
+  return { subscriptions, invalid };
+}
+
+/** Stored subscriptions, dropping anything no longer recognized. */
+export function subscriptionsOf(stored: unknown): Subscription[] {
+  if (!Array.isArray(stored)) return [];
+  return parseSubscriptions(stored.filter((s): s is string => typeof s === "string")).subscriptions;
+}
+
+/** Normalize a home-market id; null if it isn't a known market. */
+export function parseHomeMarket(input: string): string | null {
+  const id = input.trim().toLowerCase();
+  return Object.hasOwn(HOME_MARKETS, id) ? id : null;
+}
+
+/** Stored home market, falling back to the default for unset/unknown values. */
+export function homeMarketOf(stored: unknown): string {
+  return (typeof stored === "string" && parseHomeMarket(stored)) || DEFAULT_HOME_MARKET;
+}
+
+export async function getSubscriptions(): Promise<Subscription[]> {
+  return subscriptionsOf((await readConfig()).subscriptions);
+}
+
+export async function setSubscriptions(subscriptions: Subscription[]): Promise<void> {
+  const cfg = await readConfig();
+  cfg.subscriptions = [...subscriptions];
+  await writeConfig(cfg);
+}
+
+export async function getHomeMarket(): Promise<string> {
+  return homeMarketOf((await readConfig()).homeMarket);
 }
 
-/** Remove a favorite team (case-insensitive). removed=false if it wasn't there. */
-export async function removeFavorite(team: string): Promise<{ removed: boolean; favorites: string[] }> {
+/** `market` must be a known HOME_MARKETS id (see parseHomeMarket). */
+export async function setHomeMarket(market: string): Promise<void> {
   const cfg = await readConfig();
-  const favorites = cfg.favorites ?? [];
-  const i = favorites.findIndex((f) => f.toLowerCase() === team.trim().toLowerCase());
-  const removed = i >= 0;
-  if (removed) favorites.splice(i, 1);
-  cfg.favorites = favorites;
+  cfg.homeMarket = market;
   await writeConfig(cfg);
-  return { removed, favorites };
 }
 
 export { CONFIG_FILE };