mr-magic-mcp-server 0.2.6 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mr-magic-mcp-server",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "description": "Lyrics MCP server connecting LRCLIB, Genius, Musixmatch, and Melon",
   "type": "module",
   "main": "src/index.js",
@@ -21,6 +21,7 @@
     ".env.example"
   ],
   "scripts": {
+    "cleanup": "eslint . --fix && prettier --write .",
     "cli": "node src/bin/cli.js",
     "server:http": "node src/bin/http-server.js",
     "server:mcp": "node src/bin/mcp-server.js",
@@ -30,7 +31,8 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "test": "node src/tests/run-tests.js",
-    "fetch:musixmatch-token": "node src/scripts/fetch_MUSIXMATCH_ALT_FALLBACK_TOKEN.mjs",
+    "fetch:musixmatch-token": "node src/scripts/fetch_musixmatch_token.mjs",
+    "push:musixmatch-token": "node src/scripts/push_musixmatch_token.mjs",
     "fetch:genius-token": "node src/scripts/fetch_genius_token.mjs",
     "repro:mcp:arg-boundary": "node src/scripts/mcp-arg-boundary-repro.mjs",
     "repro:mcp:arg-boundary:sdk": "node src/scripts/mcp-arg-boundary-sdk-repro.mjs"

package/src/providers/genius.js

@@ -25,7 +25,7 @@ async function ensureGeniusAuth() {
     await getGeniusToken();
     return;
   }
-  assertEnv(['GENIUS_ACCESS_TOKEN']);
+  assertEnv(['GENIUS_DIRECT_TOKEN']);
 }
 
 function normalizeHit(hit, query) {

package/src/providers/musixmatch.js

@@ -138,12 +138,11 @@ async function macroRequest(track) {
 async function ensureMusixmatchToken() {
   const token = await getMusixmatchToken();
   if (!token) {
-    // Neither a fallback token (MUSIXMATCH_FALLBACK_TOKEN / MUSIXMATCH_ALT_USER_TOKEN env vars) nor a
+    // Neither a direct token (MUSIXMATCH_DIRECT_TOKEN env var) nor a KV token nor a
     // cache token (on-disk .cache/musixmatch-token.json) could be found.
     throw new Error(
       'Musixmatch token not found. ' +
-        'Set MUSIXMATCH_FALLBACK_TOKEN (fallback token — recommended for production/ephemeral hosts) ' +
-        'or MUSIXMATCH_ALT_USER_TOKEN as an environment variable, ' +
+        'Set MUSIXMATCH_DIRECT_TOKEN as an environment variable (recommended for production/ephemeral hosts), ' +
         'or run `npm run fetch:musixmatch-token` to populate the on-disk cache token.'
     );
   }

package/src/scripts/fetch_genius_token.mjs

@@ -3,7 +3,8 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 import axios from 'axios';
-import '../src/utils/config.js';
+import '../utils/config.js';
+import { describeKvBackend, isKvConfigured, kvSet } from '../utils/kv-store.js';
 
 const TOKEN_ENDPOINT = 'https://api.genius.com/oauth/token';
 
@@ -17,10 +18,10 @@ function printDeploymentBlock(accessToken) {
   console.log('LOCAL DEVELOPMENT (cache token)');
   console.log('  Token written to the cache file above.');
   console.log('  The server reads it on startup when a writable filesystem is available.\n');
-  console.log('RENDER / EPHEMERAL DEPLOYMENTS (fallback token)');
+  console.log('RENDER / EPHEMERAL DEPLOYMENTS (direct token)');
   console.log('  If you cannot use client_credentials, set the token as an env var');
-  console.log('  in your platform dashboard. It acts as a static fallback token:\n');
-  console.log(`  GENIUS_ACCESS_TOKEN=${accessToken}\n`);
+  console.log('  in your platform dashboard. It acts as a static direct token:\n');
+  console.log(`  GENIUS_DIRECT_TOKEN=${accessToken}\n`);
   console.log("  Note: static tokens don't auto-refresh. Redeploy with a new token");
   console.log('  if/when it expires. The client_credentials path avoids this entirely.');
   console.log('─'.repeat(68) + '\n');
@@ -66,6 +67,22 @@ async function main() {
     console.log(`\nCache token written to: ${cachePath}`);
     console.log('(The server reads this file on startup when a writable filesystem is available.)');
 
+    // Write to KV store if configured (ephemeral hosts, npx installs).
+    if (isKvConfigured()) {
+      const kvKey = process.env.GENIUS_TOKEN_KV_KEY || 'mr-magic:genius-token';
+      const kvTtl = parseInt(process.env.GENIUS_TOKEN_KV_TTL_SECONDS || '3600', 10);
+      const kvPayload = JSON.stringify({
+        access_token: accessToken,
+        expires_at: Date.now() + (expiresIn || 3600) * 1000
+      });
+      try {
+        await kvSet(kvKey, kvPayload, kvTtl);
+        console.log(`Token written to KV store (${describeKvBackend()}) under key: ${kvKey}`);
+      } catch (err) {
+        console.warn(`Failed to write token to KV store: ${err.message}`);
+      }
+    }
+
     printDeploymentBlock(accessToken);
   } catch (error) {
     console.error('Failed to refresh Genius token:', error.response?.data || error.message);

package/src/scripts/fetch_musixmatch_token.mjs

@@ -2,8 +2,9 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
-import { chromium } from 'playwright';
-import '../src/utils/config.js';
+import { chromium, firefox, webkit } from 'playwright';
+import '../utils/config.js';
+import { describeKvBackend, isKvConfigured, kvSet } from '../utils/kv-store.js';
 
 const AUTH_URL = 'https://auth.musixmatch.com/';
 
@@ -17,8 +18,21 @@ async function saveToken(token, desktopCookie) {
     payload.desktopCookie = desktopCookie;
   }
   await writeFile(cachePath, JSON.stringify(payload, null, 2), 'utf8');
-  console.log(`\nCache token written to: ${cachePath}`);
-  console.log('(The server reads this file on startup when a writable filesystem is available.)');
+  console.log(`\nToken written to cache: ${cachePath}`);
+  console.log('(Local and persistent servers read this file on startup.)');
+}
+
+async function saveToKv(token, desktopCookie) {
+  if (!isKvConfigured()) return;
+  const kvKey = process.env.MUSIXMATCH_TOKEN_KV_KEY || 'mr-magic:musixmatch-token';
+  const kvTtl = parseInt(process.env.MUSIXMATCH_TOKEN_KV_TTL_SECONDS || '2592000', 10);
+  const payload = JSON.stringify({ token, ...(desktopCookie ? { desktopCookie } : {}) });
+  try {
+    await kvSet(kvKey, payload, kvTtl);
+    console.log(`Token written to KV store (${describeKvBackend()}) under key: ${kvKey}`);
+  } catch (error) {
+    console.error(`Failed to write token to KV store: ${error.message}`);
+  }
 }
 
 function printDeploymentBlock(tokenValue) {
@@ -26,32 +40,158 @@ function printDeploymentBlock(tokenValue) {
     typeof tokenValue === 'string'
       ? tokenValue
       : (tokenValue?.message?.body?.usertoken ?? JSON.stringify(tokenValue));
+  const kvBackend = isKvConfigured() ? describeKvBackend() : null;
+
   console.log('\n' + '─'.repeat(68));
   console.log('Token captured successfully!\n');
-  console.log('LOCAL DEVELOPMENT (cache token)');
-  console.log('  The token has been written to the cache file above.');
-  console.log('  The server loads it at startup — no further action needed.\n');
-  console.log('RENDER / EPHEMERAL DEPLOYMENTS (fallback token)');
-  console.log('  The filesystem is wiped on restart, so set the token as an');
-  console.log('  environment variable in your platform dashboard instead:\n');
-  console.log(`  MUSIXMATCH_FALLBACK_TOKEN=${tokenString}\n`);
-  console.log('  The server reads MUSIXMATCH_FALLBACK_TOKEN on startup (1st priority)');
-  console.log('  and never touches the cache file on ephemeral hosts.');
+
+  console.log('LOCAL & PERSISTENT SERVERS (cache token)');
+  console.log('  Token written to .cache/musixmatch-token.json (or MUSIXMATCH_TOKEN_CACHE).');
+  console.log('  Any server with a writable, persistent filesystem (local dev, VPS,');
+  console.log('  dedicated host) reads it automatically on startup.');
+  console.log('  Re-run this script only when your token expires.\n');
+
+  if (kvBackend) {
+    console.log(`EPHEMERAL / NPX INSTALLS — KV STORE (${kvBackend})`);
+    console.log(`  Token written to KV key "mr-magic:musixmatch-token".`);
+    console.log('  The server reads it on startup automatically — no extra config needed.');
+    console.log('  Re-run this script when your token expires to refresh the KV entry.\n');
+  } else {
+    console.log('EPHEMERAL / NPX INSTALLS — KV STORE (not configured)');
+    console.log('  Set UPSTASH_REDIS_REST_URL + UPSTASH_REDIS_REST_TOKEN (Upstash Redis)');
+    console.log('  or CF_API_TOKEN + CF_ACCOUNT_ID + CF_KV_NAMESPACE_ID (Cloudflare KV)');
+    console.log('  and re-run this script to have the token stored in KV automatically.\n');
+  }
+
+  console.log('EPHEMERAL / SERVERLESS — MANUAL ENV VAR OVERRIDE');
+  console.log('  Copy the token below and set it in your platform dashboard.');
+  console.log(
+    '  The server reads MUSIXMATCH_DIRECT_TOKEN on startup (highest priority env var):\n'
+  );
+  console.log(`  MUSIXMATCH_DIRECT_TOKEN=${tokenString}\n`);
+
   console.log('─'.repeat(68) + '\n');
 }
 
+function isHeadlessEnabled() {
+  const value = (process.env.HEADLESS || '').trim().toLowerCase();
+  return value === '1' || value === 'true' || value === 'yes';
+}
+
 async function main() {
-  console.log('Launching Playwright to acquire Musixmatch token...');
-  const browser = await chromium.launch({ headless: process.env.HEADLESS !== 'false' });
-  const context = await browser.newContext({ viewport: { width: 1280, height: 900 } });
+  const headless = isHeadlessEnabled();
+
+  // Persistent browser session — stores cookies/logins between script runs so you don't
+  // have to sign in again until your session actually expires.
+  // Override with PLAYWRIGHT_SESSION_DIR env var if you need a different location.
+  const sessionDir =
+    process.env.PLAYWRIGHT_SESSION_DIR || path.resolve('.cache', 'playwright-session');
+  await mkdir(sessionDir, { recursive: true });
+
+  console.log(`Launching Playwright (headless=${headless}) to acquire Musixmatch token...`);
+  console.log(`Browser session directory: ${sessionDir}\n`);
+
+  // Try real installed browsers in priority order so Google OAuth doesn't block the
+  // automated bundled Chromium.  Override with BROWSER=<name> to skip straight to one.
+  //   Chromium channels : chrome, brave, msedge, comet
+  //   Other engines     : firefox, safari (webkit)
+  //   Last resort       : bundled Chromium (may be blocked by Google OAuth)
+  //
+  // launchPersistentContext() is used instead of launch() + newContext() so the browser
+  // session (cookies, logins) is saved to sessionDir and reused on subsequent runs.
+  const CHROMIUM_UA =
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+  const chromiumArgs = ['--disable-blink-features=AutomationControlled'];
+  const baseOpts = { headless, slowMo: headless ? 0 : 150, viewport: { width: 1280, height: 900 } };
+  const chromiumOpts = { ...baseOpts, args: chromiumArgs, userAgent: CHROMIUM_UA };
+
+  // Each launcher returns a BrowserContext (launchPersistentContext skips browser.newContext()).
+  const candidates = [
+    [
+      'chrome',
+      () => chromium.launchPersistentContext(sessionDir, { ...chromiumOpts, channel: 'chrome' })
+    ],
+    [
+      'brave (channel)',
+      () => chromium.launchPersistentContext(sessionDir, { ...chromiumOpts, channel: 'brave' })
+    ],
+    [
+      'brave (path)',
+      () =>
+        chromium.launchPersistentContext(sessionDir, {
+          ...chromiumOpts,
+          executablePath: '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'
+        })
+    ],
+    [
+      'msedge',
+      () => chromium.launchPersistentContext(sessionDir, { ...chromiumOpts, channel: 'msedge' })
+    ],
+    [
+      'comet',
+      () =>
+        chromium.launchPersistentContext(sessionDir, {
+          ...chromiumOpts,
+          executablePath: '/Applications/Comet.app/Contents/MacOS/Comet'
+        })
+    ],
+    ['firefox', () => firefox.launchPersistentContext(sessionDir, { ...baseOpts })],
+    ['safari (webkit)', () => webkit.launchPersistentContext(sessionDir, { ...baseOpts })],
+    ['bundled chromium', () => chromium.launchPersistentContext(sessionDir, { ...chromiumOpts })]
+  ];
+
+  // If BROWSER is set, move that candidate to the front.
+  const browserEnv = (process.env.BROWSER || '').trim().toLowerCase();
+  const orderedCandidates = browserEnv
+    ? [
+        ...candidates.filter(([label]) => label.startsWith(browserEnv)),
+        ...candidates.filter(([label]) => !label.startsWith(browserEnv))
+      ]
+    : candidates;
+
+  let context;
+  let chosenLabel;
+  for (const [label, launcher] of orderedCandidates) {
+    try {
+      context = await launcher();
+      chosenLabel = label;
+      break;
+    } catch (err) {
+      console.warn(`  ${label} not available (${err.message?.split('\n')[0]}), trying next...`);
+    }
+  }
+
+  if (!context) {
+    console.error('No usable browser found. Install Chrome, Brave, Edge, Firefox, or Safari.');
+    process.exit(1);
+  }
+  console.log(`Using browser: ${chosenLabel}`);
+
+  // Remove the webdriver flag that Google uses to detect automated browsers.
+  await context.addInitScript(() => {
+    Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+  });
+
   const page = await context.newPage();
 
-  console.log('Navigate to Musixmatch login and sign in.');
-  await page.goto(AUTH_URL, { waitUntil: 'domcontentloaded' });
-  console.log('Waiting to be redirected to https://www.musixmatch.com/discover ...');
-  await page.waitForURL('**/discover', { timeout: 0 });
+  page.on('console', (msg) => {
+    if (msg.type() === 'error') {
+      const text = msg.text();
+      // Suppress benign COOP warning emitted by the auth page itself.
+      if (text.includes('Cross-Origin-Opener-Policy')) return;
+      console.error(`[browser console error] ${text}`);
+    }
+  });
+  page.on('pageerror', (err) => console.error(`[browser page error] ${err.message}`));
+
+  console.log(`Navigating to ${AUTH_URL} — sign in in the browser window that appears.`);
+  // 'commit' fires as soon as the server response starts (before content loads), which avoids
+  // ERR_ABORTED on browsers like Comet that intercept or redirect during initial navigation.
+  await page.goto(AUTH_URL, { waitUntil: 'commit' });
+  console.log('Waiting to be redirected to https://account.musixmatch.com/ ...');
+  await page.waitForURL('https://account.musixmatch.com/**', { timeout: 0 });
 
-  const cookies = await context.cookies('https://www.musixmatch.com');
+  const cookies = await context.cookies('https://account.musixmatch.com');
   const userCookie = cookies.find((cookie) => cookie.name === 'musixmatchUserToken');
   const desktopCookie = cookies.find((cookie) => cookie.name === 'web-desktop-app-v1.0');
   if (!userCookie) {
@@ -70,14 +210,20 @@ async function main() {
   console.log('\nMusixmatch token payload:');
   console.log(JSON.stringify(parsed, null, 2));
 
-  await saveToken(parsed, desktopCookie ? decodeURIComponent(desktopCookie.value) : null);
+  const decodedDesktopCookie = desktopCookie ? decodeURIComponent(desktopCookie.value) : null;
+
+  // Write to all configured storage backends in parallel.
+  await Promise.allSettled([
+    saveToken(parsed, decodedDesktopCookie),
+    saveToKv(parsed, decodedDesktopCookie)
+  ]);
 
   // Extract the raw token string for the deployment hint.
   // The parsed payload is the full musixmatchUserToken JSON object; the server
   // stores and reads the entire parsed object as the `token` field.
   printDeploymentBlock(parsed);
 
-  await browser.close();
+  await context.close();
 }
 
 main().catch((error) => {

package/src/scripts/push_musixmatch_token.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * push_musixmatch_token.mjs
+ *
+ * Seed the Musixmatch token to all configured storage backends (Upstash Redis,
+ * Cloudflare KV, and/or on-disk cache) WITHOUT opening a browser.
+ *
+ * Use this when you already have a token value — e.g. captured once locally via
+ * `npm run fetch:musixmatch-token` — and need to push it to a headless server,
+ * ephemeral deployment (Render), or CI/CD pipeline where a browser is unavailable.
+ *
+ * Usage (env var — recommended for Render / build/start commands):
+ *   MUSIXMATCH_DIRECT_TOKEN='{"message":...}' npm run push:musixmatch-token
+ *
+ * Usage (CLI flag):
+ *   npm run push:musixmatch-token -- --token '{"message":...}'
+ *
+ * The token value must be the full musixmatchUserToken JSON payload (the same
+ * object that `fetch:musixmatch-token` captures and prints after sign-in).
+ * A raw string token is also accepted.
+ *
+ * Exit codes:
+ *   0 — token pushed successfully (or no token provided, no-op)
+ *   1 — token was provided but a push failure occurred (KV write error, etc.)
+ *
+ * Render example (build command or start command):
+ *   MUSIXMATCH_DIRECT_TOKEN='...' npm run push:musixmatch-token && npm run server:mcp:http
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+
+import '../utils/config.js';
+import { describeKvBackend, isKvConfigured, kvSet } from '../utils/kv-store.js';
+
+// ─── Argument parsing ─────────────────────────────────────────────────────────
+
+const { values } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    token: { type: 'string', short: 't' },
+    help: { type: 'boolean', short: 'h' }
+  },
+  strict: false
+});
+
+if (values.help) {
+  console.log(`
+push_musixmatch_token — seed Musixmatch token to all configured backends
+
+Usage:
+  MUSIXMATCH_DIRECT_TOKEN='<json_or_string>' npm run push:musixmatch-token
+  npm run push:musixmatch-token -- --token '<json_or_string>'
+
+The token value is the full musixmatchUserToken JSON payload captured by
+fetch:musixmatch-token, or a raw string token.
+
+Backends written (if configured):
+  • Upstash Redis  — UPSTASH_REDIS_REST_URL + UPSTASH_REDIS_REST_TOKEN
+  • Cloudflare KV  — CF_API_TOKEN + CF_ACCOUNT_ID + CF_KV_NAMESPACE_ID
+  • On-disk cache  — .cache/musixmatch-token.json (or MUSIXMATCH_TOKEN_CACHE)
+
+If MUSIXMATCH_DIRECT_TOKEN is not set and --token is not supplied, the
+script exits 0 with no output (safe to chain in build/start commands).
+`);
+  process.exit(0);
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const rawToken = values.token || process.env.MUSIXMATCH_DIRECT_TOKEN;
+
+  // If no token is provided, exit silently so this can be safely chained in
+  // build/start commands when the token hasn't been set yet.
+  if (!rawToken) {
+    return;
+  }
+
+  // Parse as JSON if possible; otherwise treat as a raw string token.
+  let parsedToken;
+  try {
+    parsedToken = JSON.parse(rawToken);
+  } catch {
+    parsedToken = rawToken;
+  }
+
+  console.log('Pushing Musixmatch token to configured backends...');
+  let anyFailed = false;
+
+  // ─── On-disk cache ───────────────────────────────────────────────────────
+  const cachePath =
+    process.env.MUSIXMATCH_TOKEN_CACHE || path.resolve('.cache', 'musixmatch-token.json');
+  try {
+    await mkdir(path.dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, JSON.stringify({ token: parsedToken }, null, 2), 'utf8');
+    console.log(`  ✓ Disk cache: ${cachePath}`);
+  } catch (err) {
+    console.warn(`  ✗ Disk cache write failed (${err.message}) — continuing.`);
+    // Not fatal; remote hosts may not have a writable FS.
+  }
+
+  // ─── KV store ─────────────────────────────────────────────────────────────
+  if (isKvConfigured()) {
+    const kvKey = process.env.MUSIXMATCH_TOKEN_KV_KEY || 'mr-magic:musixmatch-token';
+    const kvTtl = parseInt(process.env.MUSIXMATCH_TOKEN_KV_TTL_SECONDS || '2592000', 10);
+    const payload = JSON.stringify({ token: parsedToken });
+    try {
+      await kvSet(kvKey, payload, kvTtl);
+      console.log(`  ✓ KV store (${describeKvBackend()}): key="${kvKey}", ttl=${kvTtl}s`);
+    } catch (err) {
+      console.error(`  ✗ KV store write failed: ${err.message}`);
+      anyFailed = true;
+    }
+  } else {
+    console.log(
+      '  — KV store: not configured (set UPSTASH_REDIS_REST_URL/TOKEN or CF_* vars to enable)'
+    );
+  }
+
+  if (anyFailed) {
+    console.error('\n✗ One or more backends failed — see errors above.');
+    process.exit(1);
+  }
+
+  console.log('\n✓ Token pushed. The server will read it from the available backend on startup.');
+}
+
+main().catch((err) => {
+  console.error('Unexpected error:', err.message);
+  process.exit(1);
+});

package/src/transport/mcp-tools.js

@@ -435,11 +435,10 @@ export async function handleMcpTool(name, args = {}) {
 
   if (name === 'runtime_status') {
     const CREDENTIAL_KEYS = [
-      'GENIUS_ACCESS_TOKEN',
+      'GENIUS_DIRECT_TOKEN',
       'GENIUS_CLIENT_ID',
       'GENIUS_CLIENT_SECRET',
-      'MUSIXMATCH_ALT_USER_TOKEN',
-      'MUSIXMATCH_FALLBACK_TOKEN',
+      'MUSIXMATCH_DIRECT_TOKEN',
       'MELON_COOKIE'
     ];
     return {

package/src/transport/token-startup-log.js

@@ -37,7 +37,7 @@ async function logGeniusStatus(context) {
     context,
     provider: 'genius',
     clientCredentialsPresent: diagnostics.clientCredentialsPresent,
-    fallbackTokenPresent: diagnostics.fallbackTokenPresent,
+    directTokenPresent: diagnostics.directTokenPresent,
     cacheTokenPresent: diagnostics.cacheTokenPresent,
     cacheTokenExpired: diagnostics.cacheTokenExpired
   });
@@ -73,7 +73,7 @@ async function logGeniusStatus(context) {
     logger.warn('Genius credentials missing', {
       context,
       provider: 'genius',
-      details: 'set GENIUS_CLIENT_ID/SECRET or GENIUS_ACCESS_TOKEN'
+      details: 'set GENIUS_CLIENT_ID/SECRET or GENIUS_DIRECT_TOKEN'
     });
   }
 }
@@ -86,8 +86,7 @@ async function logMusixmatchStatus(context) {
     context,
     provider: 'musixmatch',
     cachePath: diagnostics.cachePath,
-    userEnvPresent: diagnostics.userEnvPresent,
-    envPresent: diagnostics.envPresent,
+    directEnvPresent: diagnostics.directEnvPresent,
     runtimeTokenCached: diagnostics.runtimeTokenCached,
     lastLoadedFrom: diagnostics.lastLoadedFrom
   });
@@ -117,7 +116,7 @@ async function logMusixmatchStatus(context) {
       context,
       provider: 'musixmatch',
       details:
-        'run npm run fetch:musixmatch-token to capture the cache token, or set MUSIXMATCH_FALLBACK_TOKEN as a fallback token for ephemeral deployments'
+        'run npm run fetch:musixmatch-token to capture the cache token, or set MUSIXMATCH_DIRECT_TOKEN as a direct token for ephemeral deployments'
     });
   }
 }

package/src/utils/config.js

@@ -23,7 +23,7 @@ export function getEnvValue(name) {
   return process.env[name] ?? null;
 }
 
-const DEFAULT_REQUIRED = ['GENIUS_ACCESS_TOKEN'];
+const DEFAULT_REQUIRED = ['GENIUS_DIRECT_TOKEN'];
 const warnedMissingEnvCache = new Set();
 
 function getMissingEnvVars(requiredVars = DEFAULT_REQUIRED) {