xwatch 0.1.0__tar.gz

xwatch-0.1.0/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "xwatch",
+  "interface": { "displayName": "xwatch" },
+  "plugins": [
+    {
+      "name": "xwatch",
+      "source": { "source": "local", "path": "./plugins/xwatch" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Productivity"
+    }
+  ]
+}

xwatch-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,17 @@
+{
+  "name": "xwatch",
+  "owner": { "name": "seokhoonj" },
+  "description": "Watch X (Twitter) accounts and collect their new posts via the official API",
+  "plugins": [
+    {
+      "name": "xwatch",
+      "displayName": "xwatch",
+      "source": "./plugins/xwatch",
+      "description": "Watch X (Twitter) accounts and collect their new posts",
+      "author": { "name": "seokhoonj" },
+      "homepage": "https://github.com/seokhoonj/xwatch",
+      "category": "Productivity",
+      "keywords": ["x", "twitter", "posts", "watch", "collect"]
+    }
+  ]
+}

xwatch-0.1.0/.github/workflows/check.yml

@@ -0,0 +1,24 @@
+name: check
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+  pull_request:
+
+# A newer push to the same branch or PR makes the older run's result obsolete,
+# so cancel it rather than let both run to completion.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+# The check only reads the code to lint, type, and test it -- it never writes to the
+# repo -- so it runs with the least privilege that still allows a checkout.
+permissions:
+  contents: read
+
+jobs:
+  check:
+    # The full check lives in reusable-check.yml so the release gate in
+    # publish.yml runs the identical job.
+    uses: ./.github/workflows/reusable-check.yml

xwatch-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,71 @@
+name: publish
+
+# Publish to PyPI on a GitHub Release, via PyPI Trusted Publishing (OIDC): no API
+# token or password is stored anywhere -- GitHub mints a short-lived identity token
+# that PyPI verifies against the publisher registered for this repo (owner seokhoonj
+# / repo xwatch / this workflow / environment "pypi").
+#
+# Three jobs. `gate` runs the same reusable check that check.yml runs, on the
+# release commit, so a red build (a lint/type error, a broken
+# test, a lost py.typed or console script) cannot reach an upload. `build` builds
+# the sdist and wheel and hands them to `publish` as an artifact. `publish` -- the
+# only job holding the OIDC token -- downloads that artifact and uploads it, and
+# checks out no source, so the privileged step runs the least code.
+
+on:
+  release:
+    types: [published]
+
+# Workflow-level floor: any job without its own `permissions:` block still gets a
+# read-only token, so a job added later cannot silently inherit a write-capable
+# default. The build and publish jobs narrow it further below.
+permissions:
+  contents: read
+
+jobs:
+  gate:
+    uses: ./.github/workflows/reusable-check.yml
+
+  build:
+    needs: gate
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+      - name: Assert the release tag matches the package version
+        # A release tagged v0.2.0 while pyproject still says 0.1.0 would publish the wrong
+        # version -- and a PyPI version number can never be reused. Fail before the build.
+        # The tag is passed through env, never interpolated into the script, so a crafted
+        # tag name cannot inject shell.
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+        run: |
+          version=$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          test "${TAG#v}" = "$version" || { echo "release tag '$TAG' does not match package version '$version'"; exit 1; }
+      - name: Build sdist and wheel, then check the metadata
+        run: |
+          uv build
+          uvx twine check dist/*
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    environment: pypi
+    permissions:
+      id-token: write   # OIDC; this is what replaces a stored token
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@ba38be9e461d3875417946c167d0b5f3d385a247 # v1.14.1

xwatch-0.1.0/.github/workflows/reusable-check.yml

@@ -0,0 +1,102 @@
+name: reusable check
+
+# The full check -- tests, lint, types, and the packaging assertions -- factored
+# into one reusable job so both `check.yml` (on push / PR) and the release gate in
+# `publish.yml` run the *identical* thing. One definition is what makes "publish
+# gates on the full check" true; a second hand-maintained copy would drift, and a
+# check added here silently would not gate releases.
+
+on:
+  workflow_call:
+
+# The floor lives on the shared body, not only on `check.yml`: `publish.yml`'s gate
+# calls this same workflow, and if the floor were only on `check.yml` the gate would
+# run this check with the repo-default (possibly write) token. Declared here, the
+# check is read-only from every caller. A reusable workflow can only downscope from
+# the caller, so this never widens anyone's token.
+permissions:
+  contents: read
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    strategy:
+      fail-fast: false
+      matrix:
+        # The floor and the current release. requires-python says >=3.11, so 3.11 is
+        # the version that claim has to actually hold on; the upper end tracks whatever
+        # CPython currently ships, since >=3.11 promises every release above it.
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+
+      - name: Install
+        # A venv per matrix version, not `uv pip --system`: the runner's system Python
+        # is externally managed and is one fixed version whatever the matrix says. This
+        # is also what the README tells a person to run.
+        run: |
+          uv venv --python ${{ matrix.python-version }}
+          uv pip install -e ".[dev]"
+          .venv/bin/python -c "import sys; print('testing on', sys.version)"
+
+      - name: Test
+        run: .venv/bin/pytest -q
+
+      - name: Lint
+        run: .venv/bin/ruff check src tests
+
+      - name: Types
+        run: .venv/bin/mypy
+
+      - name: Confirm the runtime dependencies are exactly what is declared
+        # xwatch's runtime dependencies are pushpush (delivery to Telegram / Slack /
+        # Discord), requests (the X API), and thinchat (the LLM layer behind summary /
+        # classify / translate) -- so a bare `pip install xwatch` collects, notifies, and
+        # runs the LLM features with no extras. A dependency that crept in -- or one
+        # dropping out of the built metadata -- would change what that install pulls, so it
+        # is asserted here rather than trusted.
+        run: |
+          uv venv /tmp/bare --python ${{ matrix.python-version }}
+          uv pip install --python /tmp/bare/bin/python .
+          /tmp/bare/bin/python -c "
+          import importlib.metadata as md, re
+          requires = md.requires('xwatch') or []
+          runtime = [r for r in requires if 'extra ==' not in r]
+          names = sorted(re.match(r'[A-Za-z0-9._-]+', r).group(0).lower() for r in runtime)
+          assert names == ['pushpush', 'requests', 'thinchat'], f'unexpected runtime dependencies: {runtime}'
+          import xwatch
+          print('xwatch', xwatch.__version__, 'runtime deps:', names)
+          "
+
+      - name: Confirm the console script installed
+        # pyproject declares an `xwatch` entry point; a wheel that dropped it would
+        # leave the CLI, the skill, and the docs pointing at a command that is not
+        # there. `--help` is the cheapest call that proves it runs.
+        run: |
+          uv venv /tmp/cli --python ${{ matrix.python-version }}
+          uv pip install --python /tmp/cli/bin/python .
+          /tmp/cli/bin/xwatch --help > /dev/null
+
+      - name: Confirm a user's type checker can see the hints
+        # Every hint in this package is invisible to a user unless py.typed ships
+        # alongside it (PEP 561), and the source cannot answer whether it did:
+        # src/xwatch/py.typed can sit in git while the built wheel omits it. So ask it
+        # the way a user does -- install the built package into a clean environment and
+        # run their checker over their code.
+        run: |
+          uv venv /tmp/typed --python ${{ matrix.python-version }}
+          uv pip install --python /tmp/typed/bin/python . mypy
+          cat > /tmp/user_code.py <<'PY'
+          from xwatch import normalize_handle
+
+          normalize_handle(123)  # raw is str; 123 is not one
+          PY
+          /tmp/typed/bin/mypy /tmp/user_code.py > /tmp/mypy_out 2>&1 || true
+          cat /tmp/mypy_out
+          grep -q 'incompatible type "int"' /tmp/mypy_out
+          grep -q '"str"' /tmp/mypy_out

xwatch-0.1.0/.gitignore

@@ -0,0 +1,33 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.env
+
+# uv
+uv.lock
+
+# Tooling caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# Local scratch (never tracked)
+dev/
+refs/
+
+# AI coding agents
+CLAUDE.md
+.claude/
+AGENTS.md
+AGENT.md
+.codex/
+GEMINI.md
+.gemini/

xwatch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 seokhoonj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xwatch-0.1.0/PKG-INFO

@@ -0,0 +1,297 @@
+Metadata-Version: 2.4
+Name: xwatch
+Version: 0.1.0
+Summary: Collect new posts from watched X (Twitter) accounts via the official API.
+Project-URL: Homepage, https://github.com/seokhoonj/xwatch
+Project-URL: Repository, https://github.com/seokhoonj/xwatch
+Project-URL: Issues, https://github.com/seokhoonj/xwatch/issues
+Author-email: seokhoonj <seokhoonj@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: collect,digest,notify,posts,twitter,watch,x
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Communications
+Classifier: Topic :: Internet
+Requires-Python: >=3.11
+Requires-Dist: pushpush>=0.2
+Requires-Dist: requests>=2.31
+Requires-Dist: thinchat<0.2,>=0.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: types-requests; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# xwatch
+
+[![check](https://github.com/seokhoonj/xwatch/actions/workflows/check.yml/badge.svg)](https://github.com/seokhoonj/xwatch/actions/workflows/check.yml)
+[![PyPI](https://img.shields.io/pypi/v/xwatch)](https://pypi.org/project/xwatch/)
+[![Python](https://img.shields.io/pypi/pyversions/xwatch)](https://pypi.org/project/xwatch/)
+[![License](https://img.shields.io/pypi/l/xwatch)](https://github.com/seokhoonj/xwatch/blob/main/LICENSE)
+
+**English** | [한국어](README.ko.md)
+
+Collect new posts from watched X (Twitter) accounts via the official X API v2.
+
+xwatch polls the accounts you follow, keeps only the posts each one's text filter
+admits, archives them, and can notify you when something new appears. It reads only
+*new* posts — the last post id seen per account is passed to the API as `since_id`,
+so a poll with nothing new reads (and bills) nothing.
+
+## 1. Cost
+
+xwatch reads the **official X API, which is pay-per-use** — about **$0.005 per post**
+returned (as of 2026-07-28; a 2M-read monthly cap). What that means in practice:
+
+- **Watching** a handful of accounts costs a few dollars a month: a poll reads only posts
+  newer than the last one seen, so an idle account costs nothing, and dropping
+  replies/retweets at the API cuts the read further.
+- **Backfilling** an account reads up to its most recent ~3,200 posts once — about **$16** at
+  the cap; `--max-posts N` bounds it.
+- The **LLM features** (summary, classification, translation) run on Gemini's free tier by
+  default — no charge — and **downloading media** is a plain HTTP fetch, not the X API, so it
+  is free too.
+
+Client-side filtering (keywords, the ad filter) does **not** save reads — you already paid to
+read the post; only `--no-replies` / `--no-retweets` avoid the read at the API. Prices change,
+so check the current rates in the X developer portal (<https://developer.x.com/en/portal/products>).
+
+## 2. Install
+
+```sh
+pip install xwatch
+```
+
+That is everything — collecting and archiving, notifying to Telegram / Slack / Discord
+(via pushpush), and the LLM features (summary, classification, translation). No extras to
+pick.
+
+## 3. Set up
+
+xwatch talks to the X API with a **bearer token**. Create a project and app in the X
+developer portal — <https://developer.x.com/en/portal/dashboard> — and copy its Bearer
+Token (the "Keys and tokens" tab).
+
+Store the token where xwatch looks for it — a 0600 JSON file beside its config, or
+the environment:
+
+```sh
+mkdir -p ~/.config/xwatch
+printf '{"X_BEARER_TOKEN": "%s"}\n' "$YOUR_TOKEN" > ~/.config/xwatch/credentials.json
+chmod 600 ~/.config/xwatch/credentials.json
+# or, one-off:  export X_BEARER_TOKEN=...
+```
+
+## 4. Command-line usage
+
+```sh
+xwatch @nasa                       # print @nasa's latest posts (no store)
+xwatch add nasa                    # start watching an account (from now on)
+xwatch add BTS_twt --no-replies    # skip that account's replies (drop conversational noise)
+xwatch add realDonaldTrump --route telegram # deliver this account's posts to a channel
+xwatch accounts                    # list watched accounts
+xwatch poll                        # collect every account's new posts once
+xwatch poll --translate Korean     # deliver each post translated, above the original
+xwatch poll --filter-ads           # drop promotional posts from delivery (still archived)
+xwatch poll --no-notify            # archive new posts without sending any notification
+xwatch watch --every 10            # poll every 10 minutes in the foreground
+xwatch posts --handle nasa --since 2026-07-01
+xwatch schedule install --every 15 # run `xwatch poll` from cron every 15 min
+```
+
+`add` starts watching **from now**: it marks the account's current newest post as the
+starting point, so the first `poll` collects only posts published afterwards, not a
+backfill of the recent timeline. Pass `--backfill` to opt into collecting recent posts
+on the first poll instead.
+
+**Delivery is opt-in per account.** A `--route` names a route you set up in pushpush — a
+channel on Telegram, Slack, or Discord, named whatever you called it there. That account's
+new posts are sent to it; an account with no route is archive-only, collected and stored but
+never sent. So a plain `xwatch add nasa` watches and archives quietly, and you add a route
+(e.g. `--route telegram`) to the accounts you want pushed to you.
+
+## 5. Coding agents
+
+xwatch is also an installable plugin for **Claude Code** and **Codex** — this repo doubles
+as a plugin marketplace. The plugin only shells out to the `xwatch` command, so install the
+CLI first; your token stays in your own credentials file.
+
+**Claude Code**
+
+```
+/plugin marketplace add seokhoonj/xwatch
+/plugin install xwatch@xwatch
+```
+
+**Codex**
+
+```
+codex plugin marketplace add seokhoonj/xwatch
+codex plugin add xwatch@xwatch
+```
+
+Then just ask — "watch @nasa and show its new posts". The skill confirms any billed X API
+read before it runs.
+
+## 6. Python usage
+
+The CLI is a thin shell over the library, so you can drive the same pipeline directly:
+
+```python
+from xwatch import make_client, load_accounts, poll_accounts, read_state, FileStore
+
+client = make_client()                       # bearer token from the credentials store
+report = poll_accounts(load_accounts(), client, read_state(), store=FileStore())   # collect, archive, advance watermarks
+for post in report.deliverable:
+    print(post.author, post.text[:80])
+```
+
+A collected `Post` carries the full text and its captured payload; small helpers read the parts:
+
+```python
+from xwatch import cashtags, media_urls, translate_post, classify_ad
+
+for post in report.deliverable:
+    print(cashtags(post))                                # ("MU", "DRAM") -- tickers, bare
+    print(media_urls(post))                              # image / video-thumbnail URLs
+    print(translate_post(post, target_language="Korean").text)
+    print(classify_ad(post).is_ad)                       # LLM ad judgment
+```
+
+For a one-off pull without watching, `make_client()` gives a `Client` with `resolve_user`
+and `fetch_new_posts`; the archive is a `FileStore` you can query. `import xwatch;
+help(xwatch)` lists the full surface.
+
+## 7. Filtering an account's posts
+
+Each account can narrow what it collects:
+
+- `--no-replies` / `--no-retweets` drop that kind **at the API**, so they are never
+  fetched (cheaper and cleaner than discarding them after).
+- `--include WORD` keeps only posts whose text contains every listed word;
+  `--exclude WORD` drops any post whose text contains a listed word (both
+  case-insensitive, repeatable). Good for cutting promotional posts:
+
+```sh
+xwatch add BTS_twt --no-replies --exclude sponsored --exclude ad
+```
+
+These live in `accounts.toml`, so you can also edit them by hand:
+
+```toml
+[[account]]
+handle          = "BTS_twt"
+include_replies = false
+excludes        = ["sponsored", "ad"]
+```
+
+Note: the `--include`/`--exclude` **text** filters trim only *delivery* — every fetched
+post is archived regardless, and the read is unchanged (the timeline fetch still carries
+those posts; the X API has no server-side text filter), which for a handful of accounts is
+negligible. `--no-replies`/`--no-retweets`, by contrast, drop at the API and so cut both
+the read and what is archived.
+
+## 8. Ad classification with an LLM
+
+The keyword filter only catches words you listed, so a heavily-promoting account
+defeats it both ways: its ad vocabulary is product names and calls to action rather
+than a fixed keyword set, so real ads slip through while an ordinary post that happens
+to contain a listed word is wrongly dropped. `xwatch classify` judges each archived
+post by its meaning instead — a small model returns is-ad plus a one-line reason — and
+saves the verdict to the post's record, so the judgment is made (and billed) once and
+reused:
+
+```sh
+xwatch classify --handle trader        # judge this account's archived posts, save the verdicts
+xwatch classify --limit 200            # only the most recent 200 (one LLM call each)
+xwatch classify --reclassify           # re-judge posts that already have a verdict
+xwatch classify --provider claude      # use Claude instead of the default (Gemini)
+xwatch posts --handle trader --no-ads  # hide the ads; --ads shows only them
+```
+
+A post already classified is skipped on the next run, so re-running `classify` only
+spends on newly collected posts. `posts --ads`/`--no-ads` uses a post's stored verdict
+when it has one and falls back to the account's keyword filter otherwise — so you can
+classify only the accounts that need it and leave the rest on keywords.
+
+The backend is pluggable (it runs on the thinchat library): the default is Google's Gemini
+free tier (no per-call charge); `--provider claude` (or `openai`, `ollama`) switches, and
+`--model` overrides the model. Classifying needs an API key for the chosen provider
+(`GEMINI_API_KEY`, `CLAUDE_API_KEY`, ..., the same keys the `summary` feature uses), set in
+the environment or the credentials file. On a paid backend each post is one small call, so
+`--limit` bounds the spend; on the free tier the daily request cap does.
+
+## 9. Translated, ad-filtered delivery
+
+A poll can reshape each notification as it goes out, both opt-in and both running on the
+same LLM backend as `classify`:
+
+- `--translate LANGUAGE` renders each post into a language, shown above the original so
+  the source stays for reference:
+
+  ```
+  @trader
+
+  시장이 조정 국면에 들어섰습니다. 현금 비중을 높이세요.
+  ──────────
+  The market has entered a correction. Raise cash.
+  https://x.com/trader/status/…
+  ```
+
+- `--filter-ads` runs the ad judgment at send time and does not deliver a post it judges
+  promotional. The post is still archived and its verdict stored — nothing is lost, the
+  notifications are just quieter.
+
+Both degrade safely: a translation or classification failure delivers the original post
+rather than dropping it, so an LLM outage never stalls a watch. Turn either on permanently
+for a scheduled poll via config.toml, so a cron `xwatch poll` picks it up with no flags:
+
+```toml
+translate  = "Korean"    # any language name -- "Spanish", "Japanese", ...
+filter_ads = true
+```
+
+## 10. What each post keeps
+
+The archive stores the whole post, not just its visible text: the full body of a long
+"note" tweet (not the truncated preview), a retweet's original text, and the post's media,
+engagement metrics, and entities — cashtags ($MU, $DRAM), hashtags, mentions, and the
+expanded links behind its t.co shorteners. Downloaded image and video-thumbnail files live
+beside the posts under `archive/media/`, keyed so an image shared across a retweet is stored
+once.
+
+## 11. How it stays cheap and correct
+
+- **`since_id` bounds every fetch.** Only posts newer than the last one seen come
+  back; an idle account costs nothing. Dropping replies/retweets at the API keeps
+  even a chatty account cheap.
+- **The watermark advances past every fetched post**, even ones the text filter
+  drops — so a filtered-out post is never re-fetched, and no post is delivered twice.
+- **The resolved user id is cached** per handle, so a poll never re-pays to look up
+  an account it already knows.
+- **Files are split by kind** (the XDG layout): hand-editable config and the token in
+  `~/.config/xwatch`, the archive in `~/.local/share/xwatch`, run state in
+  `~/.local/state/xwatch`. Resetting settings never touches the archive.
+
+## 12. Where things live
+
+| Path | What |
+|---|---|
+| `~/.config/xwatch/accounts.toml` | the watched accounts (hand-editable) |
+| `~/.config/xwatch/config.toml` | non-secret settings (`translate`, `filter_ads`, data dir) |
+| `~/.config/xwatch/credentials.json` | the bearer token, and any LLM provider keys (0600) |
+| `~/.local/share/xwatch/archive/posts/` | the collected posts, one JSON file each |
+| `~/.local/share/xwatch/archive/media/` | downloaded image / video-thumbnail files |
+| `~/.local/state/xwatch/state.json` | the per-account since-id watermarks and user-id cache |
+
+## 13. License
+
+MIT