sportsing 0.2.0 → 0.3.0

package/src/commands/live.ts

@@ -2,11 +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 { getApiKey, getFavorites } from "../config.ts";
+import { getApiKey, getFavorites, getStreamProvider } from "../config.ts";
+import type { DaemonGame } from "../daemon.ts";
+
 import { diffEvents, type MatchEvent } from "../events.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 { matchHasTeam, matchState } from "../match-util.ts";
 import type { Match } from "../types.ts";
 
 export async function live(args: string[] = []) {
@@ -153,6 +155,34 @@ export async function fifaAlerter(): Promise<Alerter | null> {
   return { label: "FIFA", teams: favorites, poll: async () => feed(await matchesToday()) };
 }
 
+/** FIFA's favorite matches today for `sportsing daemon`; null with no FIFA
+ *  favorites. Always routed "open" via the configured provider, exactly like
+ *  `fifa watch <fav> --wait` — FIFA has no subscriptions/watchability resolver
+ *  (that's NBA/NHL only), so there's no over-the-air or unwatchable branch. */
+export async function fifaDaemonGames(): Promise<DaemonGame[] | null> {
+  const favorites = await getFavorites("fifa");
+  if (favorites.length === 0) return null;
+  if (!(await getApiKey())) throw new Error("needs an API key — run `sportsing fifa setup`");
+  const provider = (await getStreamProvider("fifa")) ?? "fubo";
+  return (await matchesToday()).flatMap((m): DaemonGame[] => {
+    const fav = favorites.find((f) => matchHasTeam(m, f.trim().toLowerCase()))?.trim();
+    if (!fav) return [];
+    return [
+      {
+        key: `fifa:${m.id}`,
+        sport: "fifa",
+        icon: "⚽",
+        fixture: `${m.homeTeam.tla ?? m.homeTeam.name} v ${m.awayTeam.tla ?? m.awayTeam.name}`,
+        start: m.utcDate,
+        state: matchState(m),
+        openArgs: ["fifa", "watch", fav, "--wait", "--supervised"],
+        clickArgs: ["fifa", "watch", fav],
+        route: { kind: "open", note: provider },
+      },
+    ];
+  });
+}
+
 /**
  * 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

package/src/commands/upgrade.ts

@@ -0,0 +1,143 @@
+import { existsSync, realpathSync } from "fs";
+import { c } from "../ansi.ts";
+import { restartDaemonIfLoaded, systemLaunchd, type Launchd } from "../daemon-io.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. */
+export 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, launchd: Launchd = systemLaunchd()): 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}`));
+
+  // A loaded daemon is still running the old code: restart it onto the new.
+  const restart = restartDaemonIfLoaded(launchd);
+  if (restart === "restarted") console.log(c.green("✓ restarted sportsing daemon on the new version"));
+  else if (restart !== "not-loaded") console.error(c.yellow(`Couldn't restart the daemon (${restart.error}) — run: sportsing daemon install`));
+}

package/src/config.ts

@@ -1,6 +1,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { mkdir, chmod } from "fs/promises";
+import { daemonModeOf, type DaemonMode } from "./daemon.ts";
 import { SUBSCRIPTIONS, HOME_MARKETS, DEFAULT_HOME_MARKET, isSubscription, type Subscription } from "./watchability.ts";
 
 const CONFIG_DIR = join(homedir(), ".config", "sportsing");
@@ -32,6 +33,8 @@ interface Config {
   subscriptions?: string[];
   /** HOME_MARKETS id for blackouts / local channels; defaults to Utah. */
   homeMarket?: string;
+  /** `sportsing daemon` settings. */
+  daemon?: { mode?: string };
 }
 
 /** Default overlay panel visibility — nothing on by default, so a fresh stream
@@ -279,4 +282,17 @@ export async function setHomeMarket(market: string): Promise<void> {
   await writeConfig(cfg);
 }
 
+// ── Daemon ───────────────────────────────────────────────────────────────────
+
+/** What the daemon does when a favorite's game starts (`open` by default). */
+export async function getDaemonMode(): Promise<DaemonMode> {
+  return daemonModeOf((await readConfig()).daemon?.mode);
+}
+
+export async function setDaemonMode(mode: DaemonMode): Promise<void> {
+  const cfg = await readConfig();
+  cfg.daemon = { ...(cfg.daemon ?? {}), mode };
+  await writeConfig(cfg);
+}
+
 export { CONFIG_FILE };

package/src/daemon-io.ts

@@ -0,0 +1,114 @@
+// The daemon's IO edge: where its files live, its state file (written
+// atomically), and launchd. Kept apart from src/commands/daemon.ts so the
+// bare today/next/me footer and `sportsing upgrade` can use it without pulling
+// in the sport registry. launchctl is behind the `Launchd` interface so tests
+// and smokes use fakes — nothing in the test suite ever talks to launchd.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { CACHE_DIR } from "./config.ts";
+import {
+  DAEMON_LABEL,
+  evaluateStatus,
+  footerLine,
+  parseDaemonState,
+  parseLaunchctlPrint,
+  type DaemonState,
+  type DaemonStatus,
+  type ServiceInfo,
+} from "./daemon.ts";
+import { pidAlive } from "./liveness.ts";
+
+export const PLIST_PATH = join(homedir(), "Library", "LaunchAgents", `${DAEMON_LABEL}.plist`);
+export const LOG_DIR = join(homedir(), "Library", "Logs", "sportsing");
+export const LOG_FILE = join(LOG_DIR, "daemon.log");
+export const STATE_FILE = join(CACHE_DIR, "daemon-state.json");
+
+/** The daemon's state file, or null if absent/malformed. */
+export function readState(file = STATE_FILE): DaemonState | null {
+  try {
+    return parseDaemonState(JSON.parse(readFileSync(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+/** Write the state file atomically (temp file + rename), so a reader never
+ *  sees a half-written file and a crash mid-write leaves the old one. */
+export function writeState(s: DaemonState, file = STATE_FILE): void {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(s, null, 2) + "\n");
+  renameSync(tmp, file);
+}
+
+/** launchctl, injectable. All calls target the `gui/<uid>` domain. */
+export interface Launchd {
+  /** The job's launchd info, or `{ loaded: false }` when it isn't loaded. */
+  print(label: string): ServiceInfo;
+  /** Load and start a plist. Throws on failure. */
+  bootstrap(plistPath: string): void;
+  /** Unload a job. Throws on failure. */
+  bootout(label: string): void;
+  /** Kill and restart a loaded job. Throws on failure. */
+  kickstart(label: string): void;
+}
+
+function launchctl(args: string[]): { code: number; out: string } {
+  const r = Bun.spawnSync(["launchctl", ...args], { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  return { code: r.exitCode ?? 1, out: r.stdout.toString() + r.stderr.toString() };
+}
+
+function must(args: string[]): void {
+  const r = launchctl(args);
+  if (r.code !== 0) throw new Error(`launchctl ${args.join(" ")} failed (${r.code}): ${r.out.trim()}`);
+}
+
+/** The real launchctl. */
+export function systemLaunchd(uid = process.getuid?.() ?? 501): Launchd {
+  const domain = `gui/${uid}`;
+  return {
+    print(label) {
+      const r = launchctl(["print", `${domain}/${label}`]);
+      return r.code === 0 ? parseLaunchctlPrint(r.out) : { loaded: false };
+    },
+    bootstrap: (plistPath) => must(["bootstrap", domain, plistPath]),
+    bootout: (label) => must(["bootout", `${domain}/${label}`]),
+    kickstart: (label) => must(["kickstart", "-k", `${domain}/${label}`]),
+  };
+}
+
+/** The daemon's status. With `launchd`, it's the authority on whether the job
+ *  runs; without it (the cheap footer) the state file's pid is probed. */
+export function gatherStatus(launchd: Launchd | null, now = Date.now()): DaemonStatus {
+  const state = readState();
+  const installed = existsSync(PLIST_PATH);
+  let service: ServiceInfo;
+  if (launchd) service = launchd.print(DAEMON_LABEL);
+  else service = state && pidAlive(state.pid) ? { loaded: true, pid: state.pid } : { loaded: false };
+  return evaluateStatus({ installed, service, state, now });
+}
+
+/** The one-line footer for bare today / next / me. Never throws. */
+export function daemonFooter(): string | null {
+  try {
+    return footerLine(gatherStatus(null), Date.now());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * After `sportsing upgrade`: restart a loaded daemon so it runs the new code.
+ * Returns what happened, for the upgrade's output.
+ */
+export function restartDaemonIfLoaded(launchd: Launchd): "restarted" | "not-loaded" | { error: string } {
+  if (!launchd.print(DAEMON_LABEL).loaded) return "not-loaded";
+  try {
+    launchd.kickstart(DAEMON_LABEL);
+    return "restarted";
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+}