@goose-plugins/crypto 1.0.0

package/README.md

@@ -0,0 +1,71 @@
+# @goose-plugins/crypto
+
+Crypto price tracking for [Goose](https://github.com/rorystandley/goose) — spot prices, market stats, a persisted watchlist, and a command-centre tile.
+
+Uses the [CoinGecko](https://www.coingecko.com/en/api) API. No API key is required for light personal use; set `COINGECKO_API_KEY` if you hit rate limits.
+
+## Setup
+
+From your Goose checkout, with this package in the sibling `goose-plugins` checkout:
+
+```sh
+npm install --ignore-scripts ../goose-plugins/crypto
+npm run link-plugins
+```
+
+Or add to Goose `package.json`:
+
+```json
+"@goose-plugins/crypto": "file:../goose-plugins/crypto"
+```
+
+Optional env vars:
+
+```dotenv
+# Demo or Pro key — raises CoinGecko rate limits
+COINGECKO_API_KEY=
+# Set to 1 when using a Pro key (pro-api.coingecko.com)
+COINGECKO_PRO=0
+# Request timeout in ms (default 15000)
+COINGECKO_TIMEOUT_MS=15000
+# Override watchlist file path (default ./data/crypto-watchlist.json)
+CRYPTO_WATCHLIST_PATH=./data/crypto-watchlist.json
+```
+
+Restart Goose and `goose-scheduler`. Configuration is lazy: importing the plugin needs no network and no key.
+
+## Command centre
+
+- **Plugins:** tools appear via Goose’s plugin metadata endpoint after restart.
+- **Chat:** ask for prices, market stats, or watchlist changes. Tool activity shows in the Chat stream.
+- **Tiles:** exports a `watchlist` tile. Once Goose supports plugin tiles, it shows live watchlist prices on the Overview.
+- **Missions:** merge `mission.example.json` into `data/missions.json` for a morning price digest.
+
+## Tools
+
+| Tool | Purpose | Risk |
+|---|---|---|
+| `crypto_status` | Config + CoinGecko connectivity check | safe |
+| `crypto_get_price` | Spot price + 24h change for symbols/ids | safe |
+| `crypto_get_market` | Price, volume, market cap, rank | safe |
+| `crypto_list_watchlist` | Show persisted watchlist | safe |
+| `crypto_add_watchlist` | Track an asset | moderate |
+| `crypto_remove_watchlist` | Stop tracking an asset | moderate |
+
+Symbols like `BTC` / `ETH` are mapped to CoinGecko ids. You can also pass ids directly (`bitcoin`, `ethereum`).
+
+## Examples
+
+- “What’s BTC and ETH trading at?”
+- “Give me market stats for SOL.”
+- “Add DOGE to my crypto watchlist.”
+- “What’s on my crypto watchlist?”
+
+## Development
+
+```sh
+npm ci
+npm test
+```
+
+Tests mock HTTP; nothing hits CoinGecko live. Publish with the repo’s `crypto-v<semver>` tag workflow when ready.

package/client.js

@@ -0,0 +1,161 @@
+/**
+ * Lazy CoinGecko client for the crypto plugin.
+ *
+ * The public API works without a key at modest volume. Set COINGECKO_API_KEY
+ * (demo or pro) to raise rate limits. Configuration is read on first use so
+ * Goose can import the plugin during discovery without contacting CoinGecko.
+ */
+
+const PUBLIC_BASE = 'https://api.coingecko.com/api/v3';
+const PRO_BASE = 'https://pro-api.coingecko.com/api/v3';
+
+export class CryptoError extends Error {}
+
+/** Common ticker → CoinGecko id map for fast resolution without a search round-trip. */
+export const SYMBOL_TO_ID = {
+  btc: 'bitcoin',
+  xbt: 'bitcoin',
+  eth: 'ethereum',
+  sol: 'solana',
+  ada: 'cardano',
+  xrp: 'ripple',
+  doge: 'dogecoin',
+  dot: 'polkadot',
+  avax: 'avalanche-2',
+  link: 'chainlink',
+  matic: 'matic-network',
+  pol: 'polygon-ecosystem-token',
+  atom: 'cosmos',
+  near: 'near',
+  apt: 'aptos',
+  arb: 'arbitrum',
+  op: 'optimism',
+  sui: 'sui',
+  ton: 'the-open-network',
+  trx: 'tron',
+  bnb: 'binancecoin',
+  ltc: 'litecoin',
+  bch: 'bitcoin-cash',
+  uni: 'uniswap',
+  aave: 'aave',
+  mkr: 'maker',
+  pepe: 'pepe',
+  shib: 'shiba-inu',
+};
+
+export function connectionInfo(env = process.env) {
+  const apiKey = env.COINGECKO_API_KEY?.trim() || '';
+  const pro = env.COINGECKO_PRO === 'true' || env.COINGECKO_PRO === '1';
+  return {
+    configured: true,
+    apiKeyConfigured: Boolean(apiKey),
+    pro,
+    baseUrl: pro ? PRO_BASE : PUBLIC_BASE,
+  };
+}
+
+function timeoutMs(env) {
+  const raw = Number(env.COINGECKO_TIMEOUT_MS || 15000);
+  if (!Number.isInteger(raw) || raw < 100 || raw > 120000) {
+    throw new CryptoError('COINGECKO_TIMEOUT_MS must be an integer between 100 and 120000.');
+  }
+  return raw;
+}
+
+/**
+ * @param {{ env?: NodeJS.ProcessEnv, fetchFn?: typeof fetch }} [options]
+ */
+export function createClient({ env = process.env, fetchFn = globalThis.fetch } = {}) {
+  const info = connectionInfo(env);
+  const apiKey = env.COINGECKO_API_KEY?.trim() || '';
+  const timeout = timeoutMs(env);
+
+  return {
+    info,
+    async request(path, query = {}) {
+      if (!/^\/[a-z0-9/_-]*$/i.test(path)) throw new CryptoError('Invalid CoinGecko API path.');
+      const url = new URL(`${info.baseUrl}${path}`);
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.set(key, String(value));
+        }
+      }
+      const headers = { Accept: 'application/json' };
+      if (apiKey) {
+        headers[info.pro ? 'x-cg-pro-api-key' : 'x-cg-demo-api-key'] = apiKey;
+      }
+
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetchFn(url, {
+          method: 'GET',
+          redirect: 'error',
+          signal: controller.signal,
+          headers,
+        });
+        if (!response.ok) {
+          const hint = {
+            401: 'API key is invalid.',
+            403: 'API key is not allowed for this endpoint.',
+            429: 'Rate limited by CoinGecko — wait and retry, or set COINGECKO_API_KEY.',
+            404: 'Asset not found.',
+          }[response.status] || 'Request failed; check CoinGecko status and API version.';
+          throw new CryptoError(`CoinGecko HTTP ${response.status}: ${hint}`);
+        }
+        try {
+          return await response.json();
+        } catch {
+          throw new CryptoError('CoinGecko returned invalid JSON.');
+        }
+      } catch (error) {
+        if (error instanceof CryptoError) throw error;
+        if (controller.signal.aborted) throw new CryptoError('CoinGecko request timed out.');
+        throw new CryptoError('Cannot reach CoinGecko. Check DNS, TLS, and connectivity.');
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+  };
+}
+
+let _client = null;
+
+export function getClient(options) {
+  if (options) return createClient(options);
+  if (!_client) _client = createClient();
+  return _client;
+}
+
+/** Reset singleton — used by tests. */
+export function resetClient() {
+  _client = null;
+}
+
+/**
+ * Resolve a user-supplied symbol or CoinGecko id to a CoinGecko id.
+ * Prefers the local symbol map, then treats the input as an id if it looks like one.
+ */
+export function resolveId(input) {
+  if (typeof input !== 'string') return null;
+  const raw = input.trim();
+  if (!raw) return null;
+  const lower = raw.toLowerCase();
+  if (SYMBOL_TO_ID[lower]) return SYMBOL_TO_ID[lower];
+  // CoinGecko ids are lowercase kebab-case; allow them through.
+  if (/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(lower)) return lower;
+  return null;
+}
+
+export function resolveIds(inputs) {
+  const list = Array.isArray(inputs) ? inputs : String(inputs || '').split(/[\s,]+/);
+  const ids = [];
+  const unknown = [];
+  for (const item of list) {
+    if (!item) continue;
+    const id = resolveId(item);
+    if (id) ids.push(id);
+    else unknown.push(String(item));
+  }
+  return { ids: [...new Set(ids)], unknown };
+}

package/index.js

@@ -0,0 +1,331 @@
+/**
+ * Crypto plugin for Goose.
+ *
+ * Tools:
+ *   crypto_status          — provider / config check
+ *   crypto_get_price       — spot price for one or more assets
+ *   crypto_get_market      — market stats (24h change, volume, market cap)
+ *   crypto_list_watchlist  — show persisted watchlist
+ *   crypto_add_watchlist   — add an asset to the watchlist
+ *   crypto_remove_watchlist — remove an asset from the watchlist
+ *
+ * Tile:
+ *   watchlist — command-centre table of watchlist prices (via Goose plugin tiles)
+ *
+ * Provider: CoinGecko public API (optional COINGECKO_API_KEY for higher limits).
+ */
+
+import { CryptoError, getClient, resolveId, resolveIds, connectionInfo } from './client.js';
+import { addAsset, getWatchlist, removeAsset, setWatchlist } from './store.js';
+
+function fail(error) {
+  const message = error instanceof CryptoError ? error.message : 'Unexpected crypto plugin failure.';
+  return `Error: ${message}`;
+}
+
+function ok(data) {
+  return JSON.stringify(data);
+}
+
+function parseSymbols(symbols) {
+  if (Array.isArray(symbols)) return symbols;
+  if (typeof symbols === 'string') return symbols.split(/[\s,]+/).filter(Boolean);
+  return [];
+}
+
+async function fetchSimplePrices(ids, vsCurrency = 'usd') {
+  const client = getClient();
+  const data = await client.request('/simple/price', {
+    ids: ids.join(','),
+    vs_currencies: vsCurrency,
+    include_24hr_change: 'true',
+    include_last_updated_at: 'true',
+  });
+  return data;
+}
+
+async function fetchMarkets(ids, vsCurrency = 'usd') {
+  const client = getClient();
+  const data = await client.request('/coins/markets', {
+    vs_currency: vsCurrency,
+    ids: ids.join(','),
+    price_change_percentage: '24h',
+  });
+  if (!Array.isArray(data)) throw new CryptoError('Unexpected markets response from CoinGecko.');
+  return data;
+}
+
+function formatPrice(value, currency) {
+  if (value == null || Number.isNaN(Number(value))) return null;
+  const n = Number(value);
+  const digits = n >= 1000 ? 2 : n >= 1 ? 4 : 6;
+  return { amount: n, currency: currency.toUpperCase(), display: `${n.toLocaleString('en-US', {
+    style: 'currency',
+    currency: currency.toUpperCase(),
+    maximumFractionDigits: digits,
+  })}` };
+}
+
+function formatChange(value) {
+  if (value == null || Number.isNaN(Number(value))) return null;
+  const n = Number(value);
+  return { percent: n, display: `${n >= 0 ? '+' : ''}${n.toFixed(2)}%`, tone: n > 0 ? 'up' : n < 0 ? 'down' : 'neutral' };
+}
+
+const crypto_status = {
+  name: 'crypto_status',
+  description: 'Check crypto plugin configuration and CoinGecko connectivity without exposing API keys.',
+  riskLevel: 'safe',
+  parameters: { type: 'object', properties: {}, required: [] },
+  execute: async () => {
+    try {
+      const info = connectionInfo();
+      const client = getClient();
+      const ping = await client.request('/ping');
+      return ok({
+        ...info,
+        connected: Boolean(ping?.gecko_says),
+        provider: 'coingecko',
+        watchlistCount: getWatchlist().length,
+        nextStep: info.apiKeyConfigured
+          ? null
+          : 'Optional: set COINGECKO_API_KEY for higher CoinGecko rate limits.',
+      });
+    } catch (error) {
+      return fail(error);
+    }
+  },
+};
+
+const crypto_get_price = {
+  name: 'crypto_get_price',
+  description: 'Get the current spot price for one or more crypto assets. Accepts tickers (BTC, ETH) or CoinGecko ids (bitcoin, ethereum). Returns JSON with price, 24h change, and last update time.',
+  riskLevel: 'safe',
+  parameters: {
+    type: 'object',
+    properties: {
+      symbols: {
+        type: 'string',
+        description: 'Comma-separated tickers or CoinGecko ids, e.g. "BTC,ETH,solana".',
+      },
+      vsCurrency: {
+        type: 'string',
+        description: 'Quote currency. Defaults to usd.',
+      },
+    },
+    required: ['symbols'],
+  },
+  execute: async ({ symbols, vsCurrency = 'usd' } = {}) => {
+    try {
+      const { ids, unknown } = resolveIds(parseSymbols(symbols));
+      if (!ids.length) throw new CryptoError(`Could not resolve any assets from: ${symbols}`);
+      const currency = String(vsCurrency || 'usd').toLowerCase();
+      const data = await fetchSimplePrices(ids, currency);
+      const prices = ids.map(id => {
+        const row = data[id];
+        if (!row) return { id, error: 'No price returned' };
+        return {
+          id,
+          price: formatPrice(row[currency], currency),
+          change24h: formatChange(row[`${currency}_24h_change`]),
+          lastUpdatedAt: row.last_updated_at
+            ? new Date(row.last_updated_at * 1000).toISOString()
+            : null,
+        };
+      });
+      return ok({ vsCurrency: currency, prices, unknown });
+    } catch (error) {
+      return fail(error);
+    }
+  },
+};
+
+const crypto_get_market = {
+  name: 'crypto_get_market',
+  description: 'Get market stats for crypto assets: price, 24h change, 24h volume, market cap, and rank. Accepts tickers or CoinGecko ids.',
+  riskLevel: 'safe',
+  parameters: {
+    type: 'object',
+    properties: {
+      symbols: {
+        type: 'string',
+        description: 'Comma-separated tickers or CoinGecko ids.',
+      },
+      vsCurrency: {
+        type: 'string',
+        description: 'Quote currency. Defaults to usd.',
+      },
+    },
+    required: ['symbols'],
+  },
+  execute: async ({ symbols, vsCurrency = 'usd' } = {}) => {
+    try {
+      const { ids, unknown } = resolveIds(parseSymbols(symbols));
+      if (!ids.length) throw new CryptoError(`Could not resolve any assets from: ${symbols}`);
+      const currency = String(vsCurrency || 'usd').toLowerCase();
+      const markets = await fetchMarkets(ids, currency);
+      const byId = Object.fromEntries(markets.map(m => [m.id, m]));
+      const rows = ids.map(id => {
+        const m = byId[id];
+        if (!m) return { id, error: 'No market data returned' };
+        return {
+          id: m.id,
+          symbol: m.symbol?.toUpperCase(),
+          name: m.name,
+          rank: m.market_cap_rank,
+          price: formatPrice(m.current_price, currency),
+          change24h: formatChange(m.price_change_percentage_24h),
+          volume24h: m.total_volume,
+          marketCap: m.market_cap,
+          lastUpdatedAt: m.last_updated || null,
+        };
+      });
+      return ok({ vsCurrency: currency, markets: rows, unknown });
+    } catch (error) {
+      return fail(error);
+    }
+  },
+};
+
+const crypto_list_watchlist = {
+  name: 'crypto_list_watchlist',
+  description: 'List assets on the persisted crypto watchlist (used by the command-centre crypto tile and price digests).',
+  riskLevel: 'safe',
+  parameters: { type: 'object', properties: {}, required: [] },
+  execute: async () => ok({ assets: getWatchlist() }),
+};
+
+const crypto_add_watchlist = {
+  name: 'crypto_add_watchlist',
+  description: 'Add a crypto asset to the watchlist by ticker or CoinGecko id. Use when the user asks to track a coin.',
+  riskLevel: 'moderate',
+  parameters: {
+    type: 'object',
+    properties: {
+      symbol: {
+        type: 'string',
+        description: 'Ticker or CoinGecko id, e.g. "BTC" or "bitcoin".',
+      },
+    },
+    required: ['symbol'],
+  },
+  execute: async ({ symbol } = {}) => {
+    try {
+      const id = resolveId(symbol);
+      if (!id) throw new CryptoError(`Could not resolve asset: ${symbol}`);
+      // Enrich from markets when possible; fall back to id-only.
+      let meta = { id, symbol: String(symbol).toUpperCase(), name: id };
+      try {
+        const [market] = await fetchMarkets([id], 'usd');
+        if (market) {
+          meta = { id: market.id, symbol: market.symbol?.toUpperCase() || meta.symbol, name: market.name || meta.name };
+        }
+      } catch { /* keep meta fallback */ }
+      const assets = addAsset(meta);
+      return ok({ added: meta, assets });
+    } catch (error) {
+      return fail(error);
+    }
+  },
+};
+
+const crypto_remove_watchlist = {
+  name: 'crypto_remove_watchlist',
+  description: 'Remove a crypto asset from the watchlist by ticker or CoinGecko id.',
+  riskLevel: 'moderate',
+  parameters: {
+    type: 'object',
+    properties: {
+      symbol: {
+        type: 'string',
+        description: 'Ticker or CoinGecko id to remove.',
+      },
+    },
+    required: ['symbol'],
+  },
+  execute: async ({ symbol } = {}) => {
+    try {
+      const id = resolveId(symbol);
+      if (!id) throw new CryptoError(`Could not resolve asset: ${symbol}`);
+      return ok(removeAsset(id));
+    } catch (error) {
+      return fail(error);
+    }
+  },
+};
+
+export const tools = [
+  crypto_status,
+  crypto_get_price,
+  crypto_get_market,
+  crypto_list_watchlist,
+  crypto_add_watchlist,
+  crypto_remove_watchlist,
+];
+
+/**
+ * Command-centre tile — Goose discovers `tiles` and renders them in the web UI.
+ * `load()` must return a serialisable payload; keep it fast and side-effect free
+ * aside from read-only HTTP + local watchlist reads.
+ */
+export const tiles = [
+  {
+    id: 'watchlist',
+    title: 'Crypto',
+    description: 'Watchlist spot prices via CoinGecko',
+    refreshSeconds: 60,
+    async load() {
+      const assets = getWatchlist();
+      if (!assets.length) {
+        return {
+          kind: 'table',
+          columns: [
+            { key: 'asset', label: 'Asset' },
+            { key: 'price', label: 'Price' },
+            { key: 'change', label: '24h' },
+          ],
+          rows: [],
+          emptyMessage: 'Watchlist is empty. Ask Goose to add BTC or ETH.',
+          updatedAt: new Date().toISOString(),
+        };
+      }
+      try {
+        const ids = assets.map(a => a.id);
+        const data = await fetchSimplePrices(ids, 'usd');
+        const rows = assets.map(asset => {
+          const row = data[asset.id];
+          const price = formatPrice(row?.usd, 'usd');
+          const change = formatChange(row?.usd_24h_change);
+          return {
+            tone: change?.tone || 'neutral',
+            cells: {
+              asset: `${asset.symbol} · ${asset.name}`,
+              price: price?.display || '—',
+              change: change?.display || '—',
+            },
+          };
+        });
+        return {
+          kind: 'table',
+          columns: [
+            { key: 'asset', label: 'Asset' },
+            { key: 'price', label: 'Price', align: 'right' },
+            { key: 'change', label: '24h', align: 'right' },
+          ],
+          rows,
+          footer: 'Prices from CoinGecko · ask Goose to change the watchlist',
+          updatedAt: new Date().toISOString(),
+        };
+      } catch (error) {
+        return {
+          kind: 'error',
+          message: error instanceof CryptoError ? error.message : 'Failed to load crypto prices.',
+          updatedAt: new Date().toISOString(),
+        };
+      }
+    },
+  },
+];
+
+// Re-export for tests / advanced callers
+export { setWatchlist, getWatchlist };

package/mission.example.json

@@ -0,0 +1,12 @@
+{
+  "name": "crypto-morning-digest",
+  "cron": "0 8 * * *",
+  "timezone": "Europe/London",
+  "enabled": false,
+  "contextId": "mission-crypto-morning-digest",
+  "freshContext": true,
+  "maxIterations": 4,
+  "task": "Call crypto_list_watchlist, then crypto_get_market with those symbols. Summarise prices and 24h moves in a short briefing. Do not invent numbers — use only tool results. If a tool returns Error:, say so clearly.",
+  "notifySlack": false,
+  "speak": false
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@goose-plugins/crypto",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Crypto price tracking for Goose — watchlist, spot prices, and a command-centre tile",
+  "exports": {
+    ".": "./index.js",
+    "./store.js": "./store.js"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "store.js",
+    "README.md",
+    "mission.example.json"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "goose",
+    "goose-plugins",
+    "crypto",
+    "coingecko",
+    "prices"
+  ],
+  "license": "MIT",
+  "author": "Rory Standley",
+  "homepage": "https://github.com/rorystandley/goose-plugins/tree/main/crypto",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rorystandley/goose-plugins.git",
+    "directory": "crypto"
+  },
+  "bugs": {
+    "url": "https://github.com/rorystandley/goose-plugins/issues"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
+  }
+}

package/store.js

@@ -0,0 +1,96 @@
+/**
+ * Crypto watchlist store.
+ *
+ * Persists tracked CoinGecko ids to data/crypto-watchlist.json.
+ * Follows the architecture plugin pattern — module-level load, silent
+ * write failures, returns copies to prevent external mutation.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const DEFAULT_WATCHLIST = [
+  { id: 'bitcoin', symbol: 'BTC', name: 'Bitcoin' },
+  { id: 'ethereum', symbol: 'ETH', name: 'Ethereum' },
+  { id: 'solana', symbol: 'SOL', name: 'Solana' },
+];
+
+function storePath() {
+  return process.env.CRYPTO_WATCHLIST_PATH
+    || path.join(process.cwd(), 'data', 'crypto-watchlist.json');
+}
+
+function empty() {
+  return { assets: DEFAULT_WATCHLIST.map(a => ({ ...a })) };
+}
+
+function load() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(storePath(), 'utf8'));
+    if (!Array.isArray(parsed?.assets)) return empty();
+    return {
+      assets: parsed.assets
+        .filter(a => a && typeof a.id === 'string')
+        .map(a => ({
+          id: a.id,
+          symbol: typeof a.symbol === 'string' ? a.symbol : a.id.toUpperCase(),
+          name: typeof a.name === 'string' ? a.name : a.id,
+        })),
+    };
+  } catch {
+    return empty();
+  }
+}
+
+function save(data) {
+  try {
+    const file = storePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf8');
+  } catch { /* silent */ }
+}
+
+let store = load();
+
+export function getWatchlist() {
+  return store.assets.map(a => ({ ...a }));
+}
+
+export function setWatchlist(assets) {
+  store = {
+    assets: assets.map(a => ({
+      id: a.id,
+      symbol: a.symbol || a.id.toUpperCase(),
+      name: a.name || a.id,
+    })),
+  };
+  save(store);
+  return getWatchlist();
+}
+
+export function addAsset(asset) {
+  if (store.assets.some(a => a.id === asset.id)) {
+    store.assets = store.assets.map(a => (a.id === asset.id ? { ...a, ...asset } : a));
+  } else {
+    store.assets.push({
+      id: asset.id,
+      symbol: asset.symbol || asset.id.toUpperCase(),
+      name: asset.name || asset.id,
+    });
+  }
+  save(store);
+  return getWatchlist();
+}
+
+export function removeAsset(id) {
+  const before = store.assets.length;
+  store.assets = store.assets.filter(a => a.id !== id);
+  save(store);
+  return { removed: before !== store.assets.length, assets: getWatchlist() };
+}
+
+/** Test helper — reload from disk / reset in-memory state. */
+export function reloadStore() {
+  store = load();
+  return getWatchlist();
+}