sportsing 0.1.0

package/src/commands/stats.ts

@@ -0,0 +1,82 @@
+import { c } from "../ansi.ts";
+import { findEvent, getMatchStats, type EspnTeamStats } from "../espn.ts";
+
+// `sportsing fifa stats <team> [team] [--json]` — per-match statistics
+// (possession, shots, passes, cards…) from ESPN. Resolves the most recent
+// played match for the given team(s). --json emits the raw structured data
+// for a Claude agent to analyze.
+
+// Curated display order + labels for the stats we surface (ESPN stat `name` →
+// human label). Anything not listed is omitted from the table view (but kept
+// in --json).
+const ROWS: { name: string; label: string; suffix?: string }[] = [
+  { name: "possessionPct", label: "Possession", suffix: "%" },
+  { name: "totalShots", label: "Shots" },
+  { name: "shotsOnTarget", label: "On target" },
+  { name: "wonCorners", label: "Corners" },
+  { name: "foulsCommitted", label: "Fouls" },
+  { name: "yellowCards", label: "Yellow cards" },
+  { name: "redCards", label: "Red cards" },
+  { name: "offsides", label: "Offsides" },
+  { name: "saves", label: "Saves" },
+  { name: "accuratePasses", label: "Accurate passes" },
+  { name: "totalPasses", label: "Total passes" },
+];
+
+export async function stats(args: string[]) {
+  const json = args.includes("--json");
+  const terms = args.filter((a) => !a.startsWith("--"));
+  if (terms.length === 0) {
+    console.error(c.red("Usage: sportsing fifa stats <team> [team] [--json]"));
+    process.exitCode = 1;
+    return;
+  }
+
+  const ev = await findEvent(terms, { playedOnly: true });
+  if (!ev) {
+    console.log(c.dim(`No played match found for "${terms.join(" ")}". Stats appear once a match kicks off.`));
+    return;
+  }
+
+  const teamStats = await getMatchStats(ev.id);
+
+  if (json) {
+    console.log(JSON.stringify({ event: ev, teams: teamStats }, null, 2));
+    return;
+  }
+
+  if (teamStats.length < 2) {
+    console.log(c.dim("No statistics available for this match yet."));
+    return;
+  }
+
+  const home = ev.competitors.find((t) => t.homeAway === "home");
+  const away = ev.competitors.find((t) => t.homeAway === "away");
+  const homeStats = byAbbr(teamStats, home?.abbreviation) ?? teamStats[0]!;
+  const awayStats = byAbbr(teamStats, away?.abbreviation) ?? teamStats[1]!;
+
+  const score = home && away ? `${home.score} – ${away.score}` : "";
+  console.log(
+    c.bold(c.cyan(`⚽ ${homeStats.team} ${score} ${awayStats.team}`)) + "  " + c.dim(ev.detail),
+  );
+  console.log();
+
+  const W = 16;
+  const col = (s: string) => s.padStart(7);
+  console.log(c.dim("".padEnd(W)) + col(homeStats.abbreviation) + "  " + col(awayStats.abbreviation));
+  for (const row of ROWS) {
+    const h = lookup(homeStats, row.name);
+    const a = lookup(awayStats, row.name);
+    if (h === null && a === null) continue;
+    const fmt = (v: string | null) => (v === null ? "—" : v + (row.suffix ?? ""));
+    console.log(row.label.padEnd(W) + col(fmt(h)) + "  " + col(fmt(a)));
+  }
+}
+
+function byAbbr(all: EspnTeamStats[], abbr?: string): EspnTeamStats | undefined {
+  return abbr ? all.find((t) => t.abbreviation === abbr) : undefined;
+}
+
+function lookup(t: EspnTeamStats, name: string): string | null {
+  return t.stats.find((s) => s.name === name)?.value ?? null;
+}

package/src/commands/table.ts

@@ -0,0 +1,47 @@
+import { c } from "../ansi.ts";
+import { getStandings, NoKeyError } from "../api.ts";
+import { standingsTable, groupName } from "../format.ts";
+
+export async function table(args: string[]) {
+  const filter = args.find((a) => !a.startsWith("--"))?.toUpperCase() ?? null;
+
+  let standings;
+  try {
+    standings = (await getStandings()).standings;
+  } catch (e) {
+    if (e instanceof NoKeyError) {
+      console.error(
+        c.yellow("Group tables need live data. Run `sportsing setup` to add a free API key."),
+      );
+      return;
+    }
+    throw e;
+  }
+
+  const groups = standings.filter((s) => s.type === "TOTAL" && s.group);
+
+  if (groups.length === 0) {
+    console.log(
+      c.dim(
+        "No standings yet — the group stage hasn't produced results. Check back after kickoff (Jun 11).",
+      ),
+    );
+    return;
+  }
+
+  console.log(c.bold(c.cyan("⚽ World Cup 2026 — Group Standings")));
+  console.log(c.dim("Green = advancing (top 2 per group)\n"));
+
+  const wanted = groups.filter((g) => {
+    if (!filter) return true;
+    const letter = g.group?.replace("GROUP_", "");
+    return letter === filter || groupName(g.group).toUpperCase().includes(filter);
+  });
+
+  if (wanted.length === 0) {
+    console.log(c.yellow(`No group "${filter}". Groups run A–L.`));
+    return;
+  }
+
+  console.log(wanted.map((g) => standingsTable(g.group, g.table)).join("\n\n"));
+}

package/src/commands/teams.ts

@@ -0,0 +1,66 @@
+import { c } from "../ansi.ts";
+import { getMatches } from "../api.ts";
+import { groupName } from "../format.ts";
+import { withFallback, getFlag } from "./_lib.ts";
+
+// `sportsing fifa teams [--group A] [--json]` — the teams in the tournament,
+// grouped by group. Derived from the fixture list (so it works with or without
+// an API key), keyed by name; group + TLA filled in from group-stage matches.
+interface TeamInfo {
+  name: string;
+  tla: string | null;
+  group: string | null; // e.g. "GROUP_A"
+}
+
+export async function teams(args: string[]) {
+  const json = args.includes("--json");
+  const groupArg = getFlag(args, "--group"); // throws if --group has no value
+
+  const matches = await withFallback(
+    async () => (await getMatches({})).matches,
+    (all) => all,
+  );
+
+  const byName = new Map<string, TeamInfo>();
+  for (const m of matches) {
+    const g = m.stage === "GROUP_STAGE" ? m.group : null;
+    for (const t of [m.homeTeam, m.awayTeam]) {
+      if (!t.name) continue;
+      const cur = byName.get(t.name) ?? { name: t.name, tla: null, group: null };
+      if (!cur.tla && t.tla) cur.tla = t.tla;
+      if (!cur.group && g) cur.group = g;
+      byName.set(t.name, cur);
+    }
+  }
+
+  let list = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+
+  if (groupArg) {
+    const want = `GROUP_${groupArg.toUpperCase()}`;
+    list = list.filter((t) => t.group === want);
+    if (list.length === 0) {
+      console.log(c.yellow(`No teams found in group ${groupArg.toUpperCase()}.`));
+      return;
+    }
+  }
+
+  if (json) {
+    console.log(JSON.stringify(list, null, 2));
+    return;
+  }
+
+  console.log(c.bold(c.cyan(`⚽ World Cup 2026 — Teams (${list.length})`)));
+
+  const groups = new Map<string, TeamInfo[]>();
+  for (const t of list) {
+    const key = t.group ?? "ZZZ_unknown"; // sort unknowns last
+    (groups.get(key) ?? groups.set(key, []).get(key)!).push(t);
+  }
+  for (const key of [...groups.keys()].sort()) {
+    const label = key === "ZZZ_unknown" ? "Unknown group" : groupName(key);
+    console.log("\n" + c.bold(label));
+    for (const t of groups.get(key)!) {
+      console.log("  " + t.name + (t.tla ? c.dim(` (${t.tla})`) : ""));
+    }
+  }
+}

package/src/commands/today.ts

@@ -0,0 +1,58 @@
+import { c } from "../ansi.ts";
+import { getMatches } from "../api.ts";
+import { matchLine, stageLabel, heading } from "../format.ts";
+import { ymd, addDays, localDateOf, withFallback, sortByDate, applyMine, noFavoritesHint } from "./_lib.ts";
+import type { Match } from "../types.ts";
+
+export async function today(args: string[]) {
+  const offset = parseOffset(args);
+  const day = new Date();
+  day.setDate(day.getDate() + offset);
+  const date = ymd(day);
+
+  // A local calendar day straddles two UTC days, so query ±1 day and then
+  // filter to matches whose *local* date is the one we want. The API filters
+  // by UTC date, which would otherwise pull in late games from the day before.
+  const fetched = await withFallback(
+    async () =>
+      (await getMatches({ dateFrom: ymd(addDays(day, -1)), dateTo: ymd(addDays(day, 1)) })).matches.filter(
+        (m) => localDateOf(m.utcDate) === date,
+      ),
+    (all) => all.filter((m) => localDateOf(m.utcDate) === date),
+  );
+
+  const mine = await applyMine(fetched, args);
+  if (mine === "no-favorites") return noFavoritesHint();
+  const matches = mine;
+
+  const label =
+    offset === 0 ? "Today" : offset === 1 ? "Tomorrow" : offset === -1 ? "Yesterday" : date;
+  console.log(c.bold(c.cyan(`⚽ World Cup 2026 — ${label} (${date})`)));
+
+  if (matches.length === 0) {
+    console.log(c.dim("\nNo matches scheduled."));
+    return;
+  }
+  printGrouped(matches);
+}
+
+/** Group matches by stage/group and print, sorted by kickoff. */
+export function printGrouped(matches: Match[]) {
+  const buckets = new Map<string, Match[]>();
+  for (const m of matches) {
+    const key = stageLabel(m);
+    (buckets.get(key) ?? buckets.set(key, []).get(key)!).push(m);
+  }
+  for (const [name, ms] of buckets) {
+    console.log(heading(name));
+    for (const m of ms.sort(sortByDate)) console.log("  " + matchLine(m));
+  }
+}
+
+function parseOffset(args: string[]): number {
+  if (args.includes("--tomorrow")) return 1;
+  if (args.includes("--yesterday")) return -1;
+  const i = args.indexOf("--offset");
+  if (i >= 0 && args[i + 1]) return parseInt(args[i + 1]!, 10) || 0;
+  return 0;
+}

package/src/commands/watch.ts

@@ -0,0 +1,230 @@
+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 { runOverlayStream, type WatchLang } from "../overlay.ts";
+import { freePort, attachToPage } from "../cdp.ts";
+import { writeWatchPidfile } from "../liveness.ts";
+import { getFlag } from "./_lib.ts";
+
+// `sportsing fifa watch [team] [team] [--wait] [--provider peacock|fubo] [--url <link>] [--overlay] [--lang english|spanish]`
+// Opens the broadcast in a persistent-profile Chrome window via ui-leaf.
+//   --wait      block until the match is live, then open it (deep-links to the
+//               game with the overlay). With no team, waits for the NEXT match —
+//               i.e. `sportsing fifa watch --wait` = "open the next game when it
+//               goes live". Polls ESPN's state (the prompt live signal), not the
+//               lagging football-data feed behind `live`.
+//   --url       jump straight to a specific game link (skips the hub)
+//   --provider  override the configured default (config.streamProvider, else fubo)
+//   --overlay   inject a live-stats panel onto the page via CDP (interactive; needs ui-leaf >=1.5)
+//   --lang      preferred broadcast language (english|spanish, default english) — biases
+//               deep-linking on providers (Fubo) that carry both Fox & Telemundo airings
+export async function watch(args: string[]) {
+  const url = getFlag(args, "--url"); // throws if --url has no value
+  const providerFlag = getFlag(args, "--provider");
+  const overlay = args.includes("--overlay");
+  const wait = args.includes("--wait");
+  const sizeFlag = getFlag(args, "--size"); // e.g. --size 660x500
+  const windowSize = parseSize(sizeFlag);
+  if (sizeFlag && !windowSize) {
+    console.warn(c.yellow(`Ignoring --size "${sizeFlag}" — expected WxH, e.g. 660x500. Opening at the default size.`));
+  }
+
+  // Preferred broadcast language (default english). Validated like --provider.
+  const langFlag = getFlag(args, "--lang"); // throws if --lang has no value
+  let lang: WatchLang = "english";
+  if (langFlag) {
+    const v = langFlag.toLowerCase();
+    if (v === "english" || v === "spanish") {
+      lang = v; // positive check narrows v to WatchLang
+    } else {
+      console.error(c.red(`Unknown language "${langFlag}". Known: english, spanish.`));
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  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(", ")}.`));
+    process.exitCode = 1;
+    return;
+  }
+
+  // `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
+  // closes it, so it would hang forever holding a Chrome + ui-leaf process tree.
+  // Guard that: without a TTY, either run a bounded --smoke (open → confirm → tear
+  // down → exit 0) or refuse with a message naming the alternatives.
+  // --smoke is bounded (open → confirm → tear down → exit) and works in ANY
+  // context, TTY or not — an operator in a terminal can smoke-test too.
+  if (args.includes("--smoke")) return smokeWatch(url ?? provider.hub, provider.label, windowSize);
+  // With no controlling TTY, watch would block forever with nothing to close it —
+  // refuse, UNLESS `--supervised --wait`: the agent-setup supervisor deliberately
+  // backgrounds `watch --wait --supervised` and reaps it via the pidfile, so the
+  // long block is intentional and managed. We require --wait too because only the
+  // --wait path writes the pidfile — `--supervised` without it would still hang
+  // unreaped, so it doesn't earn the bypass. The guard otherwise catches ACCIDENTAL
+  // non-interactive hangs (a build smoke-test).
+  const supervised = args.includes("--supervised") && wait;
+  if (process.stdin.isTTY !== true && !supervised) {
+    console.error(c.yellow("`watch` is interactive — it opens a stream window and blocks until you close it, so it isn't usable in scripts or smoke-tests."));
+    console.error(c.dim("Run it in a terminal; use `--smoke` to just confirm the window opens; or `--supervised` for a pidfile-managed background watcher (what `/loop agent-setup` uses)."));
+    process.exitCode = 1;
+    return;
+  }
+
+  // --wait: block until a match is live, then open it. The whole point is to
+  // open THE GAME, which needs the deep-link path (overlay), so --wait always
+  // opens with the overlay + auto-navigation regardless of --overlay.
+  if (wait) {
+    // Record liveness so a supervisor (agent-setup --check / /loop agent-setup)
+    // can detect a silent death and restart. Removed on exit/SIGINT/SIGTERM.
+    writeWatchPidfile();
+    const ev = await waitForLive(terms);
+    await runOverlayStream(url ?? provider.hub, provider.label, ev, { deepLink: !url, windowSize, lang });
+    return;
+  }
+
+  // --overlay needs a resolved match (for the panel's stats + head-to-head).
+  if (overlay) {
+    if (terms.length === 0) {
+      console.error(c.red("Usage: sportsing fifa watch <team> [team] --overlay [--provider] [--url]   (or add --wait to wait for the next game)"));
+      process.exitCode = 1;
+      return;
+    }
+    const ev = await findCurrentMatch(terms);
+    if (!ev) {
+      console.error(c.yellow(`No match found for "${terms.join(" ")}".`));
+      process.exitCode = 1;
+      return;
+    }
+    // deep-link only when we opened the hub (no explicit --url to honor).
+    await runOverlayStream(url ?? provider.hub, provider.label, ev, { deepLink: !url, windowSize, lang });
+    return;
+  }
+
+  // Direct link wins — open it straight away (no match lookup needed).
+  if (url) {
+    await launchStream(url, provider.label, { windowSize });
+    return;
+  }
+
+  if (terms.length === 0) {
+    console.error(c.red("Usage: sportsing fifa watch <team> [team] [--wait] [--provider peacock|fubo] [--url <link>] [--overlay] [--lang english|spanish] [--smoke] [--supervised]"));
+    console.error(c.dim("For a hands-off agent-driven session (open the game + answer Ask Claude / catchup), use  /loop agent-setup  — see  sportsing fifa agent-setup"));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Resolve the match for context (and to fail clearly on a bad team name).
+  const ev = await findCurrentMatch(terms);
+  if (!ev) {
+    console.error(c.yellow(`No match found for "${terms.join(" ")}".`));
+    process.exitCode = 1;
+    return;
+  }
+
+  // No per-game deep-link API exists for these providers, so open the provider's
+  // hub and let the user pick the game (use --url for a known direct link).
+  console.log(c.dim(`${ev.name} — opening ${provider.label}'s hub (use --url for a direct game link).`));
+  await launchStream(provider.hub, provider.label, { windowSize });
+}
+
+/** Poll ESPN until the target match goes live, then return it. The target is the
+ *  live-or-soonest match for `terms` (or any match if `terms` is empty). Polls
+ *  faster as kickoff nears. Blocks indefinitely (Ctrl-C to stop) — meant to be
+ *  left running. */
+async function waitForLive(terms: string[]): Promise<EspnEvent> {
+  const who = terms.length ? `"${terms.join(" ")}"` : "the next match";
+  console.log(c.bold(c.cyan(`⌛ Waiting for ${who} to go live…`)) + c.dim("  (Ctrl-C to stop)"));
+  let lastName = "";
+  for (;;) {
+    let target: EspnEvent | null = null;
+    try {
+      target = await resolveWatchTarget(terms);
+    } catch (e) {
+      console.error(c.dim("  (data fetch failed, retrying) " + (e instanceof Error ? e.message : String(e))));
+    }
+
+    if (target?.state === "in") {
+      console.log(c.green(`● ${target.name} is LIVE — opening…`));
+      return target;
+    }
+
+    let pollMs = 60_000;
+    if (!target) {
+      console.log(c.dim(`  Nothing scheduled for ${who} yet — checking again in 60s.`));
+    } else {
+      if (target.name !== lastName) {
+        console.log(c.dim(`  Next up: ${target.name}`));
+        lastName = target.name;
+      }
+      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;
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+}
+
+/** Coarse human ETA: "1h 4m", "12m 30s", or "45s". */
+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);
+  const ss = s % 60;
+  return h ? `${h}h ${m}m` : m ? `${m}m ${ss}s` : `${ss}s`;
+}
+
+/**
+ * `watch --smoke`: prove the window-launch path works without blocking. Opens the
+ * stream window with a debug port, confirms Chrome came up + CDP is reachable,
+ * 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> {
+  const port = await freePort();
+  const win = await spawnStreamWindow(url, label, { debugPort: port, windowSize });
+  if (!win) {
+    process.exitCode = 1; // ui-leaf missing — spawnStreamWindow already explained
+    return;
+  }
+  try {
+    const session = await attachToPage(port, 15_000); // confirms the window + CDP came up
+    session.close();
+    console.log(c.green(`✓ watch --smoke: ${label} window opened and CDP attached — tearing it down.`));
+  } catch (e) {
+    console.error(c.yellow(`watch --smoke: the window/CDP didn't come up in time — ${e instanceof Error ? e.message : String(e)}`));
+    process.exitCode = 1;
+  } finally {
+    win.close();
+  }
+}
+
+/** Parse a `WxH` size string into a window size, or undefined if absent/invalid. */
+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[] {
+  const out: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    if (a === "--url" || a === "--provider" || a === "--size" || a === "--lang") {
+      i++; // skip its value
+      continue;
+    }
+    if (a.startsWith("--")) continue;
+    out.push(a);
+  }
+  return out;
+}

package/src/config.ts

@@ -0,0 +1,144 @@
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, chmod } from "fs/promises";
+
+const CONFIG_DIR = join(homedir(), ".config", "sportsing");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export const CACHE_DIR = join(homedir(), ".cache", "sportsing");
+
+// Pre-rebrand location (was `sportsball`). Read as a one-time fallback so existing
+// favorites / API key survive the rename; the next writeConfig() persists forward
+// to CONFIG_FILE. Cache (bus/pidfile/ESPN) is ephemeral, so it isn't migrated.
+const LEGACY_CONFIG_FILE = join(homedir(), ".config", "sportsball", "config.json");
+
+interface Config {
+  apiKey?: string;
+  favorites?: string[];
+  /** Preferred streaming provider for `fifa watch` (peacock | fubo). */
+  streamProvider?: 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 }. */
+  overlayPanels?: Record<string, Record<string, boolean>>;
+}
+
+/** Default overlay panel visibility — nothing on by default, so a fresh stream
+ *  shows JUST the floating gear; every panel is opt-in via the settings modal. */
+export const OVERLAY_PANEL_DEFAULTS: Record<string, boolean> = {
+  score: false, // score · clock · favorite win%
+  stats: false, // possession / shots / on-target
+  winprob: false, // 3-way win-probability breakdown
+  odds: false, // raw 3-way odds line
+  h2h: false, // head-to-head button
+  events: false, // live match events (goals/cards/subs)
+  scores: false, // other live matches
+  ask: false, // "Ask Claude" — routed through the external agent bus
+  catchup: false, // "Get caught up" recap button — routed through the external agent bus
+};
+
+async function readConfig(): Promise<Config> {
+  try {
+    return await Bun.file(CONFIG_FILE).json();
+  } catch {
+    try {
+      // One-time fallback to the pre-rebrand config; writeConfig migrates it forward.
+      return await Bun.file(LEGACY_CONFIG_FILE).json();
+    } catch {
+      return {};
+    }
+  }
+}
+
+async function writeConfig(cfg: Config): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await Bun.write(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n");
+  // The config holds the user's football-data.org API key — keep it owner-only
+  // (0600) so other local users can't read it. Best-effort (no-op on Windows).
+  await chmod(CONFIG_FILE, 0o600).catch(() => {});
+}
+
+/** Resolve the football-data.org API key from env or config file. */
+export async function getApiKey(): Promise<string | null> {
+  const env = process.env.FOOTBALL_DATA_API_KEY?.trim();
+  if (env) return env;
+  const cfg = await readConfig();
+  return cfg.apiKey?.trim() || null;
+}
+
+export async function setApiKey(key: string): Promise<void> {
+  const cfg = await readConfig();
+  cfg.apiKey = key.trim();
+  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;
+}
+
+export async function setStreamProvider(provider: string): Promise<void> {
+  const cfg = await readConfig();
+  cfg.streamProvider = provider.trim().toLowerCase();
+  await writeConfig(cfg);
+}
+
+/** Calibrated overlay delay (seconds) for a provider, or null if not set. */
+export async function getStreamDelay(provider: string): Promise<number | null> {
+  const cfg = await readConfig();
+  const v = cfg.streamDelay?.[provider.trim().toLowerCase()];
+  return typeof v === "number" ? v : null;
+}
+
+export async function setStreamDelay(provider: string, seconds: number): Promise<void> {
+  const cfg = await readConfig();
+  cfg.streamDelay = { ...(cfg.streamDelay ?? {}), [provider.trim().toLowerCase()]: Math.max(0, Math.round(seconds)) };
+  await writeConfig(cfg);
+}
+
+/** Overlay panel visibility for a provider (defaults merged with saved choices). */
+export async function getOverlayPanels(provider: string): Promise<Record<string, boolean>> {
+  const cfg = await readConfig();
+  const saved = cfg.overlayPanels?.[provider.trim().toLowerCase()] ?? {};
+  return { ...OVERLAY_PANEL_DEFAULTS, ...saved };
+}
+
+export async function setOverlayPanel(provider: string, key: string, on: boolean): Promise<void> {
+  const cfg = await readConfig();
+  const p = provider.trim().toLowerCase();
+  const all = cfg.overlayPanels ?? {};
+  cfg.overlayPanels = { ...all, [p]: { ...(all[p] ?? {}), [key]: on } };
+  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 ?? [];
+}
+
+/** 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 name = team.trim();
+  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;
+  await writeConfig(cfg);
+  return { added: !exists, favorites };
+}
+
+/** Remove a favorite team (case-insensitive). removed=false if it wasn't there. */
+export async function removeFavorite(team: string): Promise<{ removed: boolean; favorites: string[] }> {
+  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;
+  await writeConfig(cfg);
+  return { removed, favorites };
+}
+
+export { CONFIG_FILE };