youpdated 0.2.0__tar.gz → 0.3.0__tar.gz

{youpdated-0.2.0 → youpdated-0.3.0}/ADDING_SOURCES.md

@@ -216,6 +216,26 @@ uid=str(index)                  # broken: shifts as items are added
 
 When an upstream gives you no id at all, fingerprint the content: hash the fields that define the item. [itch.py](youpdated/sources/itch.py) does this for game builds: filenames, sizes, and the update timestamp hash into one uid.
 
+### Tags are what users filter on
+
+`tags`: a user's `ignore:` rules match against them, so a type
+untagged is not able to be hidden. Tag each update with what it *is*,
+using the vocabulary already in use where it fits: `release`, `prerelease`,
+`tag`, `commit`, `latest`, `devlog`, `news`, `video`, `item`, and add your own
+where needed.
+
+```python
+tags=("release",) + (("prerelease",) if item["draft_or_rc"] else ())
+```
+
+Tags are additive, and an update is dropped if **any** of its tags is ignored.
+So describing an item from several angles at once is the point: tagging a
+release candidate `("release", "prerelease")` lets one user ignore every
+release and another ignore only the candidates.
+
+You do not need to handle `ignore` yourself. It is lifted off the config entry
+before `targets()` ever sees it, and applied to whatever you return.
+
 ### Filling in a label during fetch
 
 Sometimes the friendly name is only available from the response. Assign it to `target.label`; the renderers pick it up:
@@ -329,5 +349,6 @@ Users then configure it like any built-in source. A plugin that fails to import
 - [ ] Expected non-200s handled with `soft_statuses`; real failures left to raise
 - [ ] Returns `[]` rather than inventing an update
 - [ ] `published` is timezone-aware UTC (or `None`)
+- [ ] `tags` describe the update type, so `ignore:` rules can match them
 - [ ] Tests cover parsing, both config shapes, and uid stability
 - [ ] Registered — `@register` plus an import, or an entry point

youpdated-0.3.0/CHANGELOG.md

@@ -0,0 +1,244 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.0] — 2026-10-07
+
+### Added
+
+- **`ignore:` rules drop update types** (#11). Every update already
+  carried tags describing what it is; those are now filterable. A bare list
+  applies everywhere, a mapping narrows it to one source (`'*'` for all), and a per-entry
+  `ignore:` adds to whichever applies:
+
+  ```yaml
+  ignore:
+    '*': [prerelease]
+    github: [commit]
+
+  sources:
+    github:
+      - repo: astral-sh/uv
+        ignore: [tag]        # global rules + `tag`
+  ```
+
+  An update is dropped if it carries any listed tag. Ignored items are not
+  recorded as seen, so removing a rule later shows what it was hiding.
+  The run summary and `--json` both count what was dropped.
+  See [Ignoring update types](README.md#ignoring-update-types) for the tag vocabulary per source.
+
+- **GitHub prereleases are tagged without a token.** `prerelease` previously came only from the
+  REST API, which needs `GITHUB_TOKEN`, so on the anonymous `.atom` path nothing was tagged.
+  It is now inferred from the tag name (`v3.15.0rc2`, `1.2.0-beta.1`, `0.12.0-alpha`), and a
+  token takes precedence. Platform and build suffixes (`v1.0.0-linux`, `v4.2.0+build.7`)
+  are untouched.
+
+- **npm prereleases are tagged.** Any semver version with a prerelease suffix now carries
+  `prerelease`. Build metadata (`+build-7`) does not count, even with a hyphen in it.
+
+- **Runs report progress instead of going quiet.** A check printed nothing until the last target
+  landed, so a slow source was indistinguishable from a hang. Interactive runs now show a live
+  line naming the targets still in flight, with a count and elapsed time. It is suppressed under
+  `-v`, `--test`, and when output is not a terminal.
+
+- **A desktop example app** (#13), in `examples/desktop/`. A simple window checks on a schedule,
+  sends a notification, and lists what changed.
+  Uses standard library and youpdated. It reads the same config and
+  history as the CLI, and prompts for a passphrase when either is encrypted.
+  Its own CI covers Linux, macOS, and Windows, and runs only when `examples/` changes
+
+### Changed
+
+- **Install docs now with `pipx install youpdated`.** The package has been on PyPI since 0.1.0,
+  but the README still told people to clone the repo and install from the working tree.
+  Installing from source is now a subsection.
+  The scheduling examples point at a `pipx` path rather than a repo virtualenv.
+- **itch builds are tagged `build`, and page-only changes `page`,** instead of both being
+  `release`. The tags say what changed, so `ignore:` can tell them apart. Anything filtering
+  `--json` or `--rss` output on `release` for itch should use `build`.
+
+### Fixed
+
+- **A host's pacing lock is no longer held across its own wait.** `_pace` slept while holding the
+  per-host lock, so every other thread bound for that host blocked in `acquire` for the whole
+  gap, with no way to be interrupted, and a thread waiting its turn could be scheduled
+  ahead of one ready to do real work. Each caller now reserves a slot under the lock and waits
+  outside it. The spacing between requests to one host is unchanged.
+- **Progress bar moved around** (#14). The target names led the line, so the bar
+  and counter shifted sideways every time they changed, and a long name squeezed the bar out.
+  The spinner, bar, count, elapsed time and failure count now come first at a fixed
+  width, and the names fill what is left of the line, truncated with an ellipsis. Names are
+  shown literally, so one containing brackets (`[/x]`) no longer crashes the bar.
+- **Rate-limit retries honor `Retry-After`** (#17). A 429 or 503 was retried on a fixed
+  rate ignoring any potential 'Retry-After' sent. The wait now follows the header (seconds or an HTTP-date) 
+  and holds the whole host, so other targets on that site wait too. 
+  A server asking for more than 60s fails that request at once instead of stalling the run. 
+  Without the header, the fixed backoff applies as before.
+- **The history database is pruned** (#18). Seen items were added, so the
+  database grew, including for targets removed from the config, and with
+  encryption, the whole thing is decrypted and re-encrypted each run. An item missing from
+  every fetch for longer than the new top-level `expiry:` (default `1y`, `never` to keep
+  everything) is now forgotten, and the file is compacted. Items still listed by their source are
+  never pruned, and stored validators older than half the expiry are skipped once to
+  force a full fetch. Targets that failed or were left out with `--source` keep their history.
+  A removed target's baseline expires with its history, so re-adding it later records a new
+  baseline instead of reporting everything it has.
+  `--json` counts what was pruned, and `--since` now also accepts years (`1y`).
+- **A target added later no longer dumps a backlog.** The first run baseline applied to the
+  whole state, so after it, a newly added target reported every item it had as new. Same
+  for a target that failed the first run, or `-s`. Baselines are now
+  recorded per target on its first successful fetch, and the run names those targets. State
+  from earlier versions is read as already baselined, so nothing is swallowed on upgrade.
+  A target's first fetch sends no stored validators, so a new channel on a document another
+  target already watches (Brave, Firefox, Edge) records a real baseline instead of a 304.
+- **`--test` lines read `[test] GET`**, not `[test]] GET`.
+
+## [0.2.1] — 2026-08-25
+
+### Fixed
+
+- **The release workflow's `attach` job failed on v0.2.0 and has been removed.** It copied the
+  built artifacts onto the GitHub Release, but this repo has immutable releases enabled, which
+  freezes assets when the release is published — and the job runs after that, so it could only ever
+  fail (`HTTP 422: Cannot upload assets to an immutable release`). Publishing to PyPI was
+  unaffected; 0.2.0 shipped correctly. Releases from now on will not carry attached `.whl`/`.tar.gz`
+  files. Get them from PyPI, where they are covered by a signed PEP 740 attestation binding each
+  digest to this repository and workflow — a stronger guarantee than the copy the job was making.
+
+- **Targets sharing one upstream document lost their updates**
+  Every Brave channel is served by one GitHub releases document, and every Firefox channel by one
+  Mozilla JSON. Each channel fetched it separately, so the first stored an ETag and the rest were
+  answered `304 Not Modified` against that ETag moments later and reported *nothing*. With the
+  default `jitter`, per-host pacing serializes those requests, which is the case that loses: a
+  config watching five Firefox channels and three Brave channels reported 2 of 8. Under
+  concurrency it was non-deterministic: is a channel reported depended on thread timing, so a
+  loaded machine changed the result.
+
+  A run now reuses each document across the targets that share it (`Client.run_scope()`), so the
+  document is fetched once and every target sees it. The same config went from 8 requests
+  reporting 2 of 8 targets, to 2 requests reporting 8 of 8. (And 147 ms to 43 ms of wall time)
+  Outside a run the client is unchanged: one GET per call, and a 304 still means "nothing new".
+
+- **The YouTube official-feed path never set the channel label.** `_label_and_parse` did not do
+  the labelling it was supposed to, so a channel that answered on the primary path was reported by
+  its raw `@handle` while the Invidious and Data API fallbacks named it properly. The label now
+  comes from the feed on all three paths.
+
+- **`feed` sources parsed every feed twice**
+  A `feed:` entry given as a bare URL had no label, so `FeedSource.fetch` parsed the document once
+  to read the feed's own `<title>` and then handed the same bytes to `parse_feed`, which parsed
+  them again. Feed parsing is the most expensive part of a run, so this ~doubled the
+  CPU cost of every bare-URL feed. One parse now feeds both the label and the entries.
+
+  `parse_feed()` is unchanged for callers that only need entries; it is now a wrapper over the new
+  `parse_document()` / `parse_entries()` split in `youpdated.sources.feed`.
+
+## [0.2.0] — 2026-08-19
+
+### Added
+
+- **Encryption at rest for the config and history** ([#5](https://github.com/Void1-1/youpdated/issues/5)).
+  `youpdated encrypt` (alias `set-encrypted`) converts an existing setup in place; `youpdated decrypt`
+  converts it back. Every command detects an encrypted setup on its own and asks for the passphrase
+  once, or reads it from `YOUPDATED_PASSPHRASE` for unattended runs.
+
+  Files are encrypted whole with AES-256-GCM under a scrypt-derived key (n=2¹⁶, r=8, p=1), with the
+  KDF parameters authenticated as additional data so they cannot be downgraded. Decryption happens
+  **in memory**: the config is parsed from a decrypted buffer and the SQLite database is
+  deserialized into an in-memory database and written back encrypted when the run ends, so no
+  plaintext copy is put on disk even mid-run. A read-only run leaves the file byte-for-byte alone.
+
+  Needs the `cryptography` package: `pip install 'youpdated[encryption]'`. Installs without it
+  behave exactly as before.
+
+- **`youpdated init --encrypt`** writes the starter config already encrypted, so a setup that is
+  meant to be private never has a plaintext config on disk at all — unlike `init` then `encrypt`,
+  which leaves the original blocks in free space.
+
+- **A proxy preflight.** When `privacy.proxy` is set, the proxy is checked before the run starts
+  and the run is refused with exit `1` if it is unreachable. `--test` reports it instead of
+  aborting.
+
+- **`youpdated.crypto` is a documented standalone module.** `from youpdated import crypto` gives
+  you the container directly; everything in its `__all__` is a supported surface. It stays an
+  optional *dependency* rather than a separate distribution on purpose: nothing in it imports
+  `cryptography` at module scope, so a plain install already pays nothing for it, and shipping the
+  container format apart from the code that reads it would risk version skew on files that are the
+  user's only copy.
+
+### Changed
+
+- **A dead proxy now stops the run instead of failing every target.** Requests already failed
+  closed (httpx routes everything through the proxy and never falls back to a direct connection)
+  but with Tor off, a run would fail each target separately, record an empty baseline, and still
+  exit `0`. In a cron log that is indistinguishable from "nothing new". It now exits `1` before the
+  state database is even opened, so nothing is recorded.
+
+### Fixed
+
+- **A broken SOCKS handshake escaped the retry path.** `socksio` raises `ProtocolError`, which is
+  not an `httpx.HTTPError`, so a proxy port answering with something that is not SOCKS5 bypassed
+  the retries and surfaced as a raw exception rather than a `FetchError`. The client now treats
+  `SOCKSError` as a network error like any other.
+
+- **`tests/test_cleanup.py` could delete a real `./youpdated.yaml`.** The fixture redirected the
+  config and data directories but not the working directory, so `find_traces()` picked up the
+  project config of whoever ran the suite from a directory that had one, and `remove_traces()`
+  deleted it. The fixture now chdirs to the temp directory.
+
+## [0.1.1] — 2026-08-18
+
+### Fixed
+
+- **`browser` / Brave: a server error killed the target instead of falling back.** The Brave source
+  reads the GitHub REST API and keeps the `.atom` feed as a fallback, but only a 403 or 429 reached
+  it. A 5xx: a timeout, or a DNS failure, was retried, then raised, and the whole target was
+  reported as failed. Observed against `api.github.com` returning 504. Any failure the HTTP client
+  gives up on now falls back to the atom feed; a genuine outage of *both* still reports an error.
+
+### Changed
+
+- Retry backoff is configurable on the HTTP client (`retry_backoff`), so the test suite no longer spends real seconds exercising retry paths. The suite went from ~4.9s to ~0.4s.
+
+### Added
+
+- A `release` workflow that publishes to PyPI via trusted publishing when a GitHub Release is
+  published, gated on the full 13-job test matrix and on the tag matching the version in
+  `pyproject.toml`.
+
+## [0.1.0] — 2026-08-18
+
+First release.
+
+### Added
+
+- **Seven sources**, all working without accounts or API keys:
+  - `github` — releases, tags, and commits via `.atom` feeds
+  - `npm` — newly published versions from public registry
+  - `steam` — patch notes and news; resolves the store name from a bare appid
+  - `itch` — devlog posts and new builds, fingerprinted from the game page
+  - `youtube` — channels and playlists, with Invidious and Data API fallback
+  - `browser` — Chrome, Brave, Firefox, and Edge releases across platforms and channels
+  - `feed` — any RSS/Atom URL, for apps without a dedicated source
+- **Plugin architecture**: sources register in-tree with `@register` or ship from a third-party package through a `youpdated.sources` entry point.
+- **Config**: every source entry takes a bare value for the common case or a
+  mapping for advanced options
+- **Incremental reporting**: a SQLite history so each run reports what changed. First run records a baseline.
+- **Three output formats**: terminal report, `--json`, and `--rss`
+- **Privacy controls**: optional SOCKS/HTTP proxy covering every request, user-agent rotation, per-host request pacing with jitter, per-request cookie clearing, and conditional GETs. `--test` prints URLs without sending
+- **`youpdated uninstall`** to remove every file from the tool. Refuses directories it didn't create or have other files.
+
+### Known issues
+
+- YouTube's RSS endpoint throttles occassionaly and 404s valid URLs; fallback covers, but a run can still fail all three. Retry or set `privacy.proxy`.
+- Some itch games publish no "Updated" timestamp, so build updates are reported undated.
+- Firefox publishes current versions, so it reports one item per channel.
+- Edge exposes release notes only for the stable and beta channels. (But like, it's Edge, why do you want to know when it updates?)
+
+[0.3.0]: https://github.com/Void1-1/youpdated/releases/tag/v0.3.0
+[0.2.1]: https://github.com/Void1-1/youpdated/releases/tag/v0.2.1
+[0.2.0]: https://github.com/Void1-1/youpdated/releases/tag/v0.2.0
+[0.1.1]: https://github.com/Void1-1/youpdated/releases/tag/v0.1.1
+[0.1.0]: https://github.com/Void1-1/youpdated/releases/tag/v0.1.0

{youpdated-0.2.0 → youpdated-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: youpdated
-Version: 0.2.0
+Version: 0.3.0
 Summary: Simple update tracker for games, apps, and packages
 Author-email: Void1-1 <161782542+Void1-1@users.noreply.github.com>
 License-Expression: MIT
@@ -84,7 +84,35 @@ Requires **Python 3.11 or newer** (`python3 --version` to check). CI runs the fu
 **Linux, macOS, and Windows** across Python 3.11–3.14.
 
 ```sh
-cd /path/to/Youpdated
+pipx install youpdated
+```
+
+[pipx](https://pipx.pypa.io) puts the `youpdated` command on your `PATH` in its own isolated
+environment. Plain `pip` works too, but it installs into whatever environment is active:
+
+```sh
+pip install youpdated
+```
+
+Add encryption support (see [Encryption at rest](#encryption-at-rest)) with either installer:
+
+```sh
+pipx install 'youpdated[encryption]'
+```
+
+Verify:
+
+```sh
+youpdated --version                          # -> youpdated 0.2.1
+```
+
+### From source
+
+To run an unreleased version or work on the tool itself:
+
+```sh
+git clone https://github.com/Void1-1/youpdated
+cd youpdated
 python3 -m venv .venv
 .venv/bin/pip install .
 ```
@@ -96,24 +124,17 @@ python -m venv .venv
 .venv\Scripts\pip install .
 ```
 
-That installs a `youpdated` command inside the virtualenv, at `.venv/bin/youpdated` on
-macOS/Linux and `.venv\Scripts\youpdated.exe` on Windows. Either call it by that full path, or put
-it on your `PATH`:
+Puts the command at `.venv/bin/youpdated` on macOS/Linux and `.venv\Scripts\youpdated.exe` on
+Windows. Call it by that full path, or put the directory on your `PATH`:
 
 ```sh
 export PATH="$PWD/.venv/bin:$PATH"           # macOS / Linux
-youpdated --version                          # -> youpdated 0.2.0
 ```
 
 ```powershell
 $env:PATH = "$PWD\.venv\Scripts;$env:PATH"   # Windows
-youpdated --version
 ```
 
-To make that permanent, add the `export` line to your `~/.zshrc`, or the `$env:PATH` line to your
-PowerShell profile. Examples assume `youpdated` is on your `PATH`; if it isn't, substitute the full
-path above.
-
 ## 2. Create your config
 
 ```sh
@@ -172,12 +193,19 @@ privacy:
   concurrency: 4
   timeout: 20
 
+ignore:                              # update types you never want reported
+  '*': [prerelease]                  # '*' is every source
+  github: [commit]
+
+expiry: 1y                           # forget items missing from every fetch this long
+
 sources:
   github:
     - python/cpython                 # easy
     - repo: astral-sh/uv             # advanced:
       watch: [releases, commits]     # releases | tags | commits
       branch: main                   # for `commits`
+      ignore: [tag]                  # adds to the rules above, this entry only
 
   npm:
     - express
@@ -214,6 +242,73 @@ sources:
       limit: 5
 ```
 
+### Ignoring update types
+
+Every update carries one or more **tags** describing what it is. An `ignore:`
+rule drops any update carrying a tag you list.
+
+```yaml
+ignore: [prerelease]          # shorthand: applies to every source
+```
+
+```yaml
+ignore:
+  '*': [prerelease]           # every source
+  github: [commit, tag]       # just this source
+```
+
+Either form can be combined with a per-entry rule, which **adds** to it:
+
+```yaml
+sources:
+  github:
+    - python/cpython                    # global rules only
+    - repo: astral-sh/uv
+      ignore: [tag]                     # global rules + `tag`
+```
+
+These are the tags each source sets:
+
+| Source | Tags |
+| --- | --- |
+| `github` | `release`, `prerelease`, `tag`, `commit` |
+| `npm` | `release`, `prerelease`, `latest` |
+| `itch` | `devlog`, `build`, `page` |
+| `browser` | `release`, plus the channel (`stable`, `beta`, `dev`, `canary`, `esr`, `nightly`) |
+| `youtube` | `video` |
+| `steam` | `news` |
+| `feed` | `item` |
+
+An update is dropped if it carries **any** tag listed. A GitHub release
+candidate is tagged both `release` and `prerelease`, so ignoring `prerelease`
+drops it while ordinary releases stay.
+
+An itch build is tagged `build`, not `release`. It is a fingerprint of the
+game page, not a published release. A page whose date moved with no new
+files is tagged `page`. So `ignore: [build]` drops new builds while keeping
+devlog posts, and ignoring `release` everywhere leaves itch alone.
+(`watch: [devlog]` on an itch entry still turns builds off outright)
+
+Without a `GITHUB_TOKEN`, `prerelease` is inferred from the tag name
+(`v3.15.0rc2`, `1.2.0-beta.1`), since the anonymous `.atom` feeds carry no
+prerelease flag. With a token set, GitHub's own flag is used instead.
+
+### How long history is kept
+
+The history database remembers every item it has reported so nothing shows up again.
+To bound its growth, an item that hasn't appeared in any fetch for a year is
+forgotten, along with everything from targets you've removed from the config. Change the
+window with `expiry:`, or turn pruning off:
+
+```yaml
+expiry: 180d      # 30d, 52w, 2y, ... (at least 1d)
+# expiry: never   # keep everything
+```
+
+Pruning is safe: an item still listed by its source is never forgotten, however old,
+so nothing is reported a second time. Targets that failed this run, or were left out
+with `--source`, keep their history until they next fetch cleanly.
+
 Check your config without sending a request:
 
 ```sh
@@ -246,6 +341,12 @@ youpdated check --all
 
 From then on, `youpdated check` prints only what changed since the previous run.
 
+The same goes for a target you add later. Its first check records a baseline for that target, and the rest of the run reports as usual:
+
+```text
+Baseline recorded for 1 new target(s): npm:react. Their existing items were not reported.
+```
+
 ---
 
 ## Command reference
@@ -253,7 +354,7 @@ From then on, `youpdated check` prints only what changed since the previous run.
 ```sh
 youpdated check                       # what's new since last run (the default command)
 youpdated check --all                 # everything currently published, ignoring history
-youpdated check --since 7d            # only items from the last week (30m, 12h, 7d, 2w)
+youpdated check --since 7d            # only items from the last week (30m, 12h, 7d, 2w, 1y)
 youpdated check -s github -s npm      # limit to some sources
 youpdated check --json                # machine-readable output
 youpdated check --rss ~/feeds/you.xml # aggregated Atom feed for a reader
@@ -282,18 +383,18 @@ Exit codes: `0` success, `1` config, encryption, or proxy error, `2` with `--fai
 
 ## Running it on schedule
 
-Once a day is plenty, most of these sources change slowly, and conditional requests make repeat runs cheap. Use absolute paths, since cron and launchd don't inherit your shell's `PATH`.
+Once a day is plenty, most of these sources change slowly, and conditional requests make repeat runs cheap. Use absolute paths, since cron and launchd don't inherit your shell's `PATH`; `which youpdated` prints yours.
 
 **cron** (`crontab -e`) run at 9am and append to a log:
 
 ```cron
-0 9 * * * /path/to/Youpdated/.venv/bin/youpdated check >> ~/youpdated.log 2>&1
+0 9 * * * /home/you/.local/bin/youpdated check >> ~/youpdated.log 2>&1
 ```
 
 **Keep an RSS feed fresh** for a reader to poll. Note that `--rss` writes that run's items, so a plain `check --rss` leaves almost an empty file. For a feed that always holds a rolling window, ask for it. `--no-save` keeps this from interfering with your daily incremental run:
 
 ```cron
-0 * * * * /path/to/Youpdated/.venv/bin/youpdated check --all --since 30d --no-save --rss ~/feeds/youpdated.xml
+0 * * * * /home/you/.local/bin/youpdated check --all --since 30d --no-save --rss ~/feeds/youpdated.xml
 ```
 
 **macOS launchd**: save as `~/Library/LaunchAgents/com.youpdated.check.plist`, then `launchctl load ~/Library/LaunchAgents/com.youpdated.check.plist`:
@@ -304,7 +405,7 @@ Once a day is plenty, most of these sources change slowly, and conditional reque
   <key>Label</key><string>com.youpdated.check</string>
   <key>ProgramArguments</key>
   <array>
-    <string>/path/to/Youpdated/.venv/bin/youpdated</string>
+    <string>/Users/you/.local/bin/youpdated</string>
     <string>check</string>
     <string>--rss</string>
     <string>/Users/you/feeds/youpdated.xml</string>
@@ -320,7 +421,8 @@ Once a day is plenty, most of these sources change slowly, and conditional reque
 | Symptom | Cause and fix |
 | --- | --- |
 | `Config error: no config file found` | Run `youpdated init`, or pass `--config PATH`. |
-| First run printed nothing | Working as intended — it recorded a baseline. Run `youpdated check --all` to see current items. |
+| First run printed nothing | Working as intended: it recorded a baseline. Run `youpdated check --all` to see current items. |
+| A newly added target printed nothing | Same as above, for that one target. `youpdated check --all -s <source>` shows its current items. |
 | `--all` shows fewer items than expected | Nothing is wrong; sources cap how much history they expose (10–20 items each). |
 | A source appears in the yellow `problems` panel | That one source failed; the rest of the run still completed. Re-run with `-v` to see the request and status. |
 | `unknown source 'X'` | Check spelling against `youpdated sources`. |