silver-music-notifier 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/server/index.ts
+import express from "express";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+import { dirname, join as join2 } from "path";
+
+// src/lib/musicbrainz.ts
+import { MusicBrainzApi } from "musicbrainz-api";
+
+// src/lib/db.ts
+import Database from "better-sqlite3";
+
+// src/lib/paths.ts
+import envPaths from "env-paths";
+import { mkdirSync } from "fs";
+import { join } from "path";
+function dataDir() {
+  const dir = process.env.SMN_DATA_DIR ?? envPaths("silver-music-notifier", { suffix: "" }).data;
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function dbPath() {
+  return join(dataDir(), "data.db");
+}
+
+// src/lib/db.ts
+var AppDb = class {
+  connection;
+  constructor(path = dbPath()) {
+    this.connection = new Database(path);
+    this.initialize();
+  }
+  close() {
+    this.connection.close();
+  }
+  initialize() {
+    this.connection.pragma("journal_mode = WAL");
+    this.connection.pragma("foreign_keys = ON");
+    this.connection.exec(`
+      CREATE TABLE IF NOT EXISTS artists (
+        mbid           TEXT PRIMARY KEY,
+        name           TEXT NOT NULL,
+        sort_name      TEXT,
+        disambiguation TEXT,
+        added_at       TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS release_groups (
+        mbid               TEXT PRIMARY KEY,
+        artist_mbid        TEXT NOT NULL REFERENCES artists(mbid) ON DELETE CASCADE,
+        title              TEXT NOT NULL,
+        primary_type       TEXT,
+        secondary_types    TEXT,
+        first_release_date TEXT,
+        first_seen_at      TEXT NOT NULL,
+        last_seen_at       TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_rg_artist ON release_groups(artist_mbid);
+
+      CREATE TABLE IF NOT EXISTS settings (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+  }
+};
+var appDb = null;
+function openDb(path = dbPath()) {
+  return new AppDb(path);
+}
+function getDb() {
+  appDb ??= openDb();
+  return appDb.connection;
+}
+
+// src/lib/settings.ts
+var DEFAULT_SETTINGS = {
+  notify: {
+    inPage: true,
+    desktop: true,
+    email: false
+  },
+  smtp: {
+    host: "",
+    port: 587,
+    secure: false,
+    user: "",
+    pass: "",
+    from: "",
+    to: ""
+  },
+  musicbrainz: {
+    contact: ""
+  }
+};
+var CONFIG_KEY = "config";
+var LAST_REFRESH_KEY = "last_refresh_at";
+function readRaw(key) {
+  const row = getDb().prepare("SELECT value FROM settings WHERE key = ?").get(key);
+  return row?.value;
+}
+function writeRaw(key, value) {
+  getDb().prepare(
+    "INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(key, value);
+}
+function getSettings() {
+  const raw = readRaw(CONFIG_KEY);
+  if (!raw) {
+    return structuredClone(DEFAULT_SETTINGS);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return structuredClone(DEFAULT_SETTINGS);
+  }
+  return {
+    notify: { ...DEFAULT_SETTINGS.notify, ...parsed.notify },
+    smtp: { ...DEFAULT_SETTINGS.smtp, ...parsed.smtp },
+    musicbrainz: { ...DEFAULT_SETTINGS.musicbrainz, ...parsed.musicbrainz }
+  };
+}
+function saveSettings(patch) {
+  const current = getSettings();
+  const next = {
+    notify: { ...current.notify, ...patch.notify },
+    smtp: { ...current.smtp, ...patch.smtp },
+    musicbrainz: { ...current.musicbrainz, ...patch.musicbrainz }
+  };
+  writeRaw(CONFIG_KEY, JSON.stringify(next));
+  return next;
+}
+function smtpIsConfigured(s) {
+  return Boolean(s.smtp.host && s.smtp.user && s.smtp.to);
+}
+function getLastRefreshAt() {
+  return readRaw(LAST_REFRESH_KEY) ?? null;
+}
+function setLastRefreshAt(iso) {
+  writeRaw(LAST_REFRESH_KEY, iso);
+}
+function mbContact() {
+  const s = getSettings();
+  return s.musicbrainz.contact || process.env.SMN_MB_CONTACT || "silver-music-notifier (no contact configured)";
+}
+
+// src/lib/musicbrainz.ts
+var APP_VERSION = "0.1.0";
+var client = null;
+function api() {
+  const contact = mbContact();
+  if (!client || client._contact !== contact) {
+    client = new MusicBrainzApi({
+      appName: "silver-music-notifier",
+      appVersion: APP_VERSION,
+      appContactInfo: contact
+    });
+    client._contact = contact;
+  }
+  return client;
+}
+async function searchArtist(query) {
+  const result = await api().search("artist", { query, limit: 10 });
+  return (result.artists ?? []).map((a) => ({
+    mbid: a.id,
+    name: a.name,
+    sortName: a["sort-name"],
+    disambiguation: a.disambiguation,
+    country: a.country,
+    type: a.type
+  }));
+}
+async function fetchReleaseGroups(artistMbid) {
+  const out = [];
+  const limit = 100;
+  let offset = 0;
+  for (; ; ) {
+    const res = await api().browse("release-group", {
+      artist: artistMbid,
+      limit,
+      offset
+    });
+    const groups = res["release-groups"] ?? [];
+    for (const g of groups) {
+      out.push({
+        mbid: g.id,
+        title: g.title,
+        primaryType: g["primary-type"] ?? null,
+        secondaryTypes: g["secondary-types"] ?? [],
+        firstReleaseDate: g["first-release-date"] || null
+      });
+    }
+    const total = res["release-group-count"] ?? out.length;
+    offset += groups.length;
+    if (groups.length === 0 || offset >= total) {
+      break;
+    }
+  }
+  return out;
+}
+
+// src/lib/notify.ts
+import nodemailer from "nodemailer";
+import notifier from "node-notifier";
+function summaryLine(newReleases) {
+  const n = newReleases.length;
+  const artists = [...new Set(newReleases.map((r) => r.artistName))];
+  const who = artists.length <= 3 ? artists.join(", ") : `${artists.slice(0, 3).join(", ")} +${artists.length - 3} more`;
+  return `${n} new release${n === 1 ? "" : "s"} from ${who}`;
+}
+function desktopNotify(newReleases) {
+  notifier.notify({
+    title: "New music releases",
+    message: summaryLine(newReleases)
+  });
+}
+function emailHtml(newReleases) {
+  const rows = newReleases.map((r) => {
+    const type = [r.primaryType, ...r.secondaryTypes].filter(Boolean).join(" / ");
+    const date = r.firstReleaseDate ?? "\u2014";
+    return `<tr>
+        <td style="padding:4px 12px 4px 0">${escapeHtml(r.artistName)}</td>
+        <td style="padding:4px 12px 4px 0"><strong>${escapeHtml(r.title)}</strong></td>
+        <td style="padding:4px 12px 4px 0">${escapeHtml(type)}</td>
+        <td style="padding:4px 0">${escapeHtml(date)}</td>
+      </tr>`;
+  }).join("");
+  return `<div style="font-family:system-ui,sans-serif">
+    <h2>${escapeHtml(summaryLine(newReleases))}</h2>
+    <table style="border-collapse:collapse">
+      <thead><tr>
+        <th align="left" style="padding:4px 12px 4px 0">Artist</th>
+        <th align="left" style="padding:4px 12px 4px 0">Title</th>
+        <th align="left" style="padding:4px 12px 4px 0">Type</th>
+        <th align="left" style="padding:4px 0">Released</th>
+      </tr></thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </div>`;
+}
+function escapeHtml(s) {
+  return s.replace(
+    /[&<>"']/g,
+    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]
+  );
+}
+function transport(s) {
+  return nodemailer.createTransport({
+    host: s.smtp.host,
+    port: s.smtp.port,
+    secure: s.smtp.secure,
+    auth: s.smtp.user ? { user: s.smtp.user, pass: s.smtp.pass } : void 0
+  });
+}
+async function emailNotify(newReleases, s) {
+  await transport(s).sendMail({
+    from: s.smtp.from || s.smtp.user,
+    to: s.smtp.to,
+    subject: summaryLine(newReleases),
+    html: emailHtml(newReleases)
+  });
+}
+async function notifyNewReleases(newReleases) {
+  if (newReleases.length === 0) {
+    return;
+  }
+  const s = getSettings();
+  if (s.notify.desktop && !process.env.SMN_DISABLE_DESKTOP) {
+    try {
+      desktopNotify(newReleases);
+    } catch (err) {
+      console.error("Desktop notification failed:", errMsg(err));
+    }
+  }
+  if (s.notify.email) {
+    if (!smtpIsConfigured(s)) {
+      console.warn("Email enabled but SMTP not configured \u2014 skipping email.");
+    } else {
+      try {
+        await emailNotify(newReleases, s);
+      } catch (err) {
+        console.error("Email notification failed:", errMsg(err));
+      }
+    }
+  }
+}
+async function sendTestEmail(override) {
+  const s = override ?? getSettings();
+  if (!smtpIsConfigured(s)) {
+    throw new Error(
+      "SMTP is not configured (host, user, and recipient required)."
+    );
+  }
+  await transport(s).sendMail({
+    from: s.smtp.from || s.smtp.user,
+    to: s.smtp.to,
+    subject: "silver-music-notifier test email",
+    text: "This is a test email from silver-music-notifier. SMTP is working."
+  });
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/lib/refresh.ts
+async function refresh(opts = {}) {
+  const db = getDb();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const artists = db.prepare("SELECT * FROM artists ORDER BY name COLLATE NOCASE").all();
+  const existing = db.prepare("SELECT 1 FROM release_groups WHERE mbid = ?");
+  const insert = db.prepare(`
+    INSERT INTO release_groups
+      (mbid, artist_mbid, title, primary_type, secondary_types,
+       first_release_date, first_seen_at, last_seen_at)
+    VALUES (@mbid, @artist_mbid, @title, @primary_type, @secondary_types,
+            @first_release_date, @now, @now)
+    ON CONFLICT(mbid) DO UPDATE SET
+      title = excluded.title,
+      primary_type = excluded.primary_type,
+      secondary_types = excluded.secondary_types,
+      first_release_date = excluded.first_release_date,
+      last_seen_at = excluded.last_seen_at
+  `);
+  const newReleases = [];
+  const errors = [];
+  for (let i = 0; i < artists.length; i++) {
+    const artist = artists[i];
+    opts.onProgress?.(artist, i, artists.length);
+    try {
+      const groups = await fetchReleaseGroups(artist.mbid);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const apply = db.transaction(() => {
+        for (const g of groups) {
+          const seen = existing.get(g.mbid);
+          insert.run({
+            mbid: g.mbid,
+            artist_mbid: artist.mbid,
+            title: g.title,
+            primary_type: g.primaryType,
+            secondary_types: g.secondaryTypes.join(", ") || null,
+            first_release_date: g.firstReleaseDate,
+            now
+          });
+          if (!seen) {
+            newReleases.push({
+              mbid: g.mbid,
+              artistMbid: artist.mbid,
+              artistName: artist.name,
+              title: g.title,
+              primaryType: g.primaryType,
+              secondaryTypes: g.secondaryTypes,
+              firstReleaseDate: g.firstReleaseDate
+            });
+          }
+        }
+      });
+      apply();
+    } catch (err) {
+      errors.push({
+        artist: artist.name,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  setLastRefreshAt(startedAt);
+  const summary = {
+    scannedArtists: artists.length,
+    newCount: newReleases.length,
+    newReleases,
+    errors,
+    startedAt
+  };
+  if (opts.notify !== false && newReleases.length > 0) {
+    await notifyNewReleases(newReleases);
+  }
+  return summary;
+}
+
+// src/lib/store.ts
+function listArtists() {
+  return getDb().prepare("SELECT * FROM artists ORDER BY name COLLATE NOCASE").all();
+}
+function addArtist(input) {
+  const res = getDb().prepare(
+    `INSERT INTO artists (mbid, name, sort_name, disambiguation, added_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(mbid) DO NOTHING`
+  ).run(
+    input.mbid,
+    input.name,
+    input.sortName ?? null,
+    input.disambiguation ?? null,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  return res.changes > 0;
+}
+function removeArtist(idOrName) {
+  const db = getDb();
+  const found = db.prepare("SELECT * FROM artists WHERE mbid = ?").get(idOrName) ?? db.prepare("SELECT * FROM artists WHERE name = ? COLLATE NOCASE").get(idOrName);
+  if (!found) {
+    return void 0;
+  }
+  db.prepare("DELETE FROM artists WHERE mbid = ?").run(found.mbid);
+  return found;
+}
+function listReleases(opts = {}) {
+  const lastRefresh = getLastRefreshAt();
+  const rows = getDb().prepare(
+    `SELECT rg.mbid, rg.artist_mbid, a.name AS artist_name, rg.title,
+              rg.primary_type, rg.secondary_types, rg.first_release_date,
+              rg.first_seen_at
+       FROM release_groups rg
+       JOIN artists a ON a.mbid = rg.artist_mbid
+       ORDER BY (rg.first_release_date IS NULL), rg.first_release_date DESC, rg.title`
+  ).all();
+  const items = rows.map((r) => ({
+    mbid: r.mbid,
+    artistMbid: r.artist_mbid,
+    artistName: r.artist_name,
+    title: r.title,
+    primaryType: r.primary_type,
+    secondaryTypes: r.secondary_types,
+    firstReleaseDate: r.first_release_date,
+    firstSeenAt: r.first_seen_at,
+    isNew: lastRefresh != null && r.first_seen_at >= lastRefresh
+  }));
+  const filtered = opts.onlyNew ? items.filter((i) => i.isNew) : items;
+  return opts.limit ? filtered.slice(0, opts.limit) : filtered;
+}
+
+// src/server/index.ts
+function webDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join2(here, "..", "web"),
+    // dist/cli/index.js -> dist/web
+    join2(here, "..", "..", "dist", "web")
+    // src/server/index.ts -> dist/web
+  ];
+  return candidates.find((c) => existsSync(c)) ?? null;
+}
+function asyncRoute(fn) {
+  return (req, res) => {
+    fn(req, res).catch((err) => {
+      console.error(err);
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    });
+  };
+}
+function createApp() {
+  const app = express();
+  app.use(express.json());
+  const api2 = express.Router();
+  api2.get("/artists", (_req, res) => {
+    res.json(listArtists());
+  });
+  api2.get(
+    "/artists/search",
+    asyncRoute(async (req, res) => {
+      const q = String(req.query.q ?? "").trim();
+      if (!q) {
+        res.json([]);
+        return;
+      }
+      res.json(await searchArtist(q));
+    })
+  );
+  api2.post("/artists", (req, res) => {
+    const { mbid, name, sortName, disambiguation } = req.body ?? {};
+    if (!mbid || !name) {
+      res.status(400).json({ error: "mbid and name are required" });
+      return;
+    }
+    const added = addArtist({ mbid, name, sortName, disambiguation });
+    res.json({ added });
+  });
+  api2.delete("/artists/:mbid", (req, res) => {
+    const removed = removeArtist(req.params.mbid);
+    if (!removed) {
+      res.status(404).json({ error: "artist not tracked" });
+      return;
+    }
+    res.json({ removed });
+  });
+  api2.get("/releases", (req, res) => {
+    const onlyNew = req.query.new === "1" || req.query.new === "true";
+    const limit = req.query.limit ? Number(req.query.limit) : void 0;
+    res.json(listReleases({ onlyNew, limit }));
+  });
+  api2.post(
+    "/refresh",
+    asyncRoute(async (_req, res) => {
+      const summary = await refresh();
+      res.json(summary);
+    })
+  );
+  api2.get("/settings", (_req, res) => {
+    res.json(getSettings());
+  });
+  api2.put("/settings", (req, res) => {
+    const patch = req.body;
+    res.json(saveSettings(patch));
+  });
+  api2.post(
+    "/settings/test-email",
+    asyncRoute(async (req, res) => {
+      const patch = req.body;
+      const settings = patch && Object.keys(patch).length ? saveSettings(patch) : getSettings();
+      await sendTestEmail(settings);
+      res.json({ ok: true });
+    })
+  );
+  app.use("/api", api2);
+  const dir = webDir();
+  if (dir) {
+    app.use(express.static(dir));
+    app.get("*", (_req, res) => {
+      res.sendFile(join2(dir, "index.html"));
+    });
+  }
+  return app;
+}
+function startServer(port) {
+  return new Promise((resolve) => {
+    createApp().listen(port, () => resolve());
+  });
+}
+
+// src/cli/commands/web.ts
+function registerWeb(program2) {
+  program2.command("web").description("Launch the local web UI").option("-p, --port <port>", "port to listen on", "3001").option("--no-open", "do not open a browser window").action(async (opts) => {
+    const port = Number(opts.port);
+    await startServer(port);
+    const url = `http://localhost:${port}`;
+    console.log(`silver-music-notifier web UI running at ${url}`);
+    if (opts.open) {
+      try {
+        const { default: open } = await import("open");
+        await open(url);
+      } catch {
+        console.log("(could not open browser automatically)");
+      }
+    }
+  });
+}
+
+// src/cli/commands/list.ts
+function registerList(program2) {
+  program2.command("list").description("List tracked artists").action(() => {
+    const artists = listArtists();
+    if (artists.length === 0) {
+      console.log(
+        "No artists tracked yet. Add one with: silver-music-notifier add <name>"
+      );
+      return;
+    }
+    for (const a of artists) {
+      const extra = a.disambiguation ? ` (${a.disambiguation})` : "";
+      console.log(`${a.name}${extra}  \u2014  ${a.mbid}`);
+    }
+    console.log(
+      `
+${artists.length} artist${artists.length === 1 ? "" : "s"} tracked.`
+    );
+  });
+}
+
+// src/cli/commands/add.ts
+function registerAdd(program2) {
+  program2.command("add").description("Search MusicBrainz and add an artist to track").argument("<query>", "artist name to search for").option(
+    "--mbid <mbid>",
+    "add this exact MusicBrainz artist MBID, skipping search"
+  ).option("-y, --yes", "add the top search result without prompting").action(async (query, opts) => {
+    if (opts.mbid) {
+      const added2 = addArtist({ mbid: opts.mbid, name: query });
+      console.log(added2 ? `Added ${query}.` : `${query} is already tracked.`);
+      return;
+    }
+    const results = await searchArtist(query);
+    if (results.length === 0) {
+      console.log(`No MusicBrainz artists found for "${query}".`);
+      return;
+    }
+    let chosen = results[0];
+    if (!opts.yes && results.length > 1) {
+      const { select } = await import("@inquirer/prompts");
+      const mbid = await select({
+        message: "Which artist?",
+        choices: results.map((r) => ({
+          name: [
+            r.name,
+            r.disambiguation ? `(${r.disambiguation})` : "",
+            r.type ? `\xB7 ${r.type}` : "",
+            r.country ? `\xB7 ${r.country}` : ""
+          ].filter(Boolean).join(" "),
+          value: r.mbid
+        }))
+      });
+      chosen = results.find((r) => r.mbid === mbid);
+    }
+    const added = addArtist({
+      mbid: chosen.mbid,
+      name: chosen.name,
+      sortName: chosen.sortName,
+      disambiguation: chosen.disambiguation
+    });
+    console.log(
+      added ? `Added ${chosen.name} (${chosen.mbid}).` : `${chosen.name} is already tracked.`
+    );
+  });
+}
+
+// src/cli/commands/remove.ts
+function registerRemove(program2) {
+  program2.command("remove").alias("rm").description("Stop tracking an artist (by MBID or name)").argument("<idOrName>", "MusicBrainz MBID or exact artist name").action((idOrName) => {
+    const removed = removeArtist(idOrName);
+    if (!removed) {
+      console.log(`No tracked artist matched "${idOrName}".`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`Removed ${removed.name} (${removed.mbid}).`);
+  });
+}
+
+// src/cli/commands/refresh.ts
+function registerRefresh(program2) {
+  program2.command("refresh").description(
+    "Fetch releases for all tracked artists and notify on new ones"
+  ).option("--no-notify", "skip desktop/email notifications").action(async (opts) => {
+    const summary = await refresh({
+      notify: opts.notify,
+      onProgress: (artist, i, total) => {
+        process.stdout.write(
+          `\r[${i + 1}/${total}] ${artist.name}`.padEnd(60)
+        );
+      }
+    });
+    process.stdout.write("\r".padEnd(60) + "\r");
+    console.log(
+      `Scanned ${summary.scannedArtists} artist${summary.scannedArtists === 1 ? "" : "s"}; ${summary.newCount} new release${summary.newCount === 1 ? "" : "s"}.`
+    );
+    for (const r of summary.newReleases) {
+      const type = [r.primaryType, ...r.secondaryTypes].filter(Boolean).join(" / ");
+      console.log(
+        `  + ${r.artistName} \u2014 ${r.title}` + (type ? ` [${type}]` : "") + (r.firstReleaseDate ? ` (${r.firstReleaseDate})` : "")
+      );
+    }
+    for (const e of summary.errors) {
+      console.error(`  ! ${e.artist}: ${e.message}`);
+    }
+  });
+}
+
+// src/cli/commands/releases.ts
+function registerReleases(program2) {
+  program2.command("releases").description("List known release-groups, newest first").option("--new", "only show releases discovered in the last refresh").option("-n, --limit <n>", "limit the number of rows", (v) => Number(v)).action((opts) => {
+    const items = listReleases({ onlyNew: opts.new, limit: opts.limit });
+    if (items.length === 0) {
+      console.log(
+        opts.new ? "No new releases since the last refresh." : "No releases yet. Run: silver-music-notifier refresh"
+      );
+      return;
+    }
+    for (const r of items) {
+      const date = r.firstReleaseDate ?? "\u2014".padEnd(10);
+      const type = [r.primaryType, r.secondaryTypes].filter(Boolean).join(" / ");
+      const flag = r.isNew ? "NEW " : "    ";
+      console.log(
+        `${flag}${date.padEnd(11)} ${r.artistName} \u2014 ${r.title}${type ? ` [${type}]` : ""}`
+      );
+    }
+  });
+}
+
+// src/cli/commands/config.ts
+function flatten(s) {
+  return {
+    "notify.inPage": String(s.notify.inPage),
+    "notify.desktop": String(s.notify.desktop),
+    "notify.email": String(s.notify.email),
+    "smtp.host": s.smtp.host,
+    "smtp.port": String(s.smtp.port),
+    "smtp.secure": String(s.smtp.secure),
+    "smtp.user": s.smtp.user,
+    "smtp.pass": s.smtp.pass ? "********" : "",
+    "smtp.from": s.smtp.from,
+    "smtp.to": s.smtp.to,
+    "musicbrainz.contact": s.musicbrainz.contact
+  };
+}
+function coerce(key, value) {
+  if (/^(notify\.|smtp\.secure$)/.test(key)) {
+    return value === "true" || value === "1";
+  }
+  if (key === "smtp.port") {
+    return Number(value);
+  }
+  return value;
+}
+function patchFor(key, value) {
+  const [group, field] = key.split(".");
+  return { [group]: { [field]: value } };
+}
+function registerConfig(program2) {
+  const config = program2.command("config").description("View or edit settings");
+  config.command("get", { isDefault: true }).description("Print settings (or a single key)").argument("[key]", "dotted key, e.g. notify.email").action((key) => {
+    const flat = flatten(getSettings());
+    if (key) {
+      if (!(key in flat)) {
+        console.error(`Unknown key: ${key}`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(flat[key]);
+      return;
+    }
+    for (const [k, v] of Object.entries(flat)) {
+      console.log(`${k} = ${v}`);
+    }
+  });
+  config.command("set").description("Set a settings key").argument("<key>", "dotted key, e.g. smtp.host").argument("<value>", "new value").action((key, value) => {
+    const valid = new Set(Object.keys(flatten(getSettings())));
+    if (!valid.has(key)) {
+      console.error(
+        `Unknown key: ${key}
+Valid keys: ${[...valid].join(", ")}`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    saveSettings(patchFor(key, coerce(key, value)));
+    console.log(`Set ${key}.`);
+  });
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("silver-music-notifier").description(
+  "Track artists and get notified of their new music releases from MusicBrainz."
+).version("0.1.0");
+registerWeb(program);
+registerList(program);
+registerAdd(program);
+registerRemove(program);
+registerRefresh(program);
+registerReleases(program);
+registerConfig(program);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map