mr-magic-mcp-server 0.1.5

package/src/utils/tokens/genius-token-manager.js

@@ -0,0 +1,119 @@
+import axios from 'axios';
+
+import { getEnvValue } from '../config.js';
+import { createLogger } from '../logger.js';
+
+const GENIUS_TOKEN_ENDPOINT = 'https://api.genius.com/oauth/token';
+const logger = createLogger('genius-token-manager');
+
+let cachedToken = null;
+let cachedExpiry = 0;
+let lastAuthMode = 'unknown';
+
+function getFallbackToken() {
+  return getEnvValue('GENIUS_ACCESS_TOKEN');
+}
+
+function tokenExpired() {
+  if (!cachedToken) return true;
+  const now = Date.now();
+  return now >= cachedExpiry - 60_000; // refresh one minute early
+}
+
+async function fetchClientCredentialsToken() {
+  const clientId = getEnvValue('GENIUS_CLIENT_ID');
+  const clientSecret = getEnvValue('GENIUS_CLIENT_SECRET');
+  if (!clientId || !clientSecret) {
+    return null;
+  }
+  const params = new URLSearchParams({
+    client_id: clientId,
+    client_secret: clientSecret,
+    grant_type: 'client_credentials'
+  });
+  try {
+    const response = await axios.post(GENIUS_TOKEN_ENDPOINT, params.toString(), {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
+      }
+    });
+    const { access_token: accessToken, expires_in: expiresIn } = response.data ?? {};
+    if (!accessToken) {
+      throw new Error('Genius token response missing access_token');
+    }
+    const ttl = Number(expiresIn) || 3600;
+    cachedToken = accessToken;
+    cachedExpiry = Date.now() + ttl * 1000;
+    lastAuthMode = 'client_credentials';
+    logger.info('Genius token refreshed', { ttlSeconds: ttl });
+    return cachedToken;
+  } catch (error) {
+    logger.error('Failed to refresh Genius token', {
+      error: error.response?.data || error.message
+    });
+    return null;
+  }
+}
+
+export async function getGeniusToken({ forceRefresh = false } = {}) {
+  if (!forceRefresh && !tokenExpired()) {
+    return cachedToken;
+  }
+  const token = await fetchClientCredentialsToken();
+  if (token) {
+    return token;
+  }
+  const fallback = getFallbackToken();
+  if (fallback && fallback !== cachedToken) {
+    logger.warn('Using fallback Genius access token from environment');
+    cachedToken = fallback;
+    cachedExpiry = Date.now() + 86_400_000; // 1 day placeholder
+    lastAuthMode = 'env_access_token';
+    return cachedToken;
+  }
+  return cachedToken;
+}
+
+export function invalidateGeniusToken() {
+  cachedToken = null;
+  cachedExpiry = 0;
+  lastAuthMode = 'unknown';
+}
+
+export function hasValidGeniusAuth() {
+  const hasClient = Boolean(getEnvValue('GENIUS_CLIENT_ID') && getEnvValue('GENIUS_CLIENT_SECRET'));
+  if (hasClient) return true;
+  return Boolean(getFallbackToken());
+}
+
+export function describeGeniusAuthMode() {
+  if (lastAuthMode !== 'unknown') {
+    return lastAuthMode;
+  }
+  if (cachedToken && cachedExpiry > Date.now()) {
+    return 'cached_runtime_token';
+  }
+  const hasClient = Boolean(getEnvValue('GENIUS_CLIENT_ID') && getEnvValue('GENIUS_CLIENT_SECRET'));
+  if (hasClient) {
+    return 'client_credentials';
+  }
+  if (getFallbackToken()) {
+    return 'env_access_token';
+  }
+  return 'none';
+}
+
+export function getGeniusDiagnostics() {
+  const clientId = getEnvValue('GENIUS_CLIENT_ID');
+  const clientSecret = getEnvValue('GENIUS_CLIENT_SECRET');
+  const fallback = getFallbackToken();
+  const ttlMs = Math.max(cachedExpiry - Date.now(), 0);
+
+  return {
+    clientCredentialsPresent: Boolean(clientId && clientSecret),
+    fallbackTokenPresent: Boolean(fallback),
+    runtimeTokenCached: Boolean(cachedToken),
+    runtimeTokenExpiresInMs: cachedToken ? ttlMs : 0,
+    lastAuthMode: describeGeniusAuthMode()
+  };
+}

package/src/utils/tokens/musixmatch-token-manager.js

@@ -0,0 +1,130 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { getEnvValue, getProjectRoot } from '../config.js';
+import { createLogger } from '../logger.js';
+
+const logger = createLogger('musixmatch-token-manager');
+const TOKEN_CACHE_PATH =
+  process.env.MUSIXMATCH_TOKEN_CACHE ||
+  path.join(getProjectRoot(), '.cache', 'musixmatch-token.json');
+
+let cachedToken = null;
+let lastLoadedFrom = 'unknown';
+let cachedDesktopCookie = null;
+
+function getCacheDir() {
+  return path.dirname(TOKEN_CACHE_PATH);
+}
+
+async function ensureCacheDir() {
+  const dir = getCacheDir();
+  await fs.mkdir(dir, { recursive: true }).catch(() => {});
+}
+
+async function readCachedToken() {
+  try {
+    await ensureCacheDir();
+    const raw = await fs.readFile(TOKEN_CACHE_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed?.token) {
+      cachedToken = parsed.token;
+      cachedDesktopCookie = parsed.desktopCookie || null;
+      lastLoadedFrom = 'cache';
+      return cachedToken;
+    }
+  } catch (error) {
+    // ignore missing cache
+  }
+  return null;
+}
+
+async function writeCachedToken(token, desktopCookie) {
+  if (!token) return;
+  try {
+    await ensureCacheDir();
+    const payload = { token };
+    if (desktopCookie) {
+      payload.desktopCookie = desktopCookie;
+    }
+    await fs.writeFile(TOKEN_CACHE_PATH, JSON.stringify(payload, null, 2), 'utf8');
+  } catch (error) {
+    logger.warn('Failed to persist Musixmatch token cache', { error });
+  }
+}
+
+export async function getMusixmatchToken() {
+  if (cachedToken) {
+    return cachedToken;
+  }
+  const envToken = getEnvValue('MUSIXMATCH_TOKEN');
+  if (envToken) {
+    cachedToken = envToken;
+    lastLoadedFrom = 'env';
+    cachedDesktopCookie = null;
+    return cachedToken;
+  }
+  return readCachedToken();
+}
+
+export async function setMusixmatchToken(token, { desktopCookie } = {}) {
+  if (!token) return;
+  cachedToken = token;
+  lastLoadedFrom = 'runtime';
+  cachedDesktopCookie = desktopCookie || null;
+  await writeCachedToken(token, desktopCookie);
+  logger.info('Musixmatch token updated', {
+    source: 'runtime',
+    desktopCookiePresent: Boolean(desktopCookie)
+  });
+}
+
+export function invalidateMusixmatchToken() {
+  cachedToken = null;
+}
+
+export function describeMusixmatchTokenSource() {
+  return lastLoadedFrom;
+}
+
+export async function getMusixmatchTokenDiagnostics() {
+  const envToken = getEnvValue('MUSIXMATCH_TOKEN');
+  const diagnostics = {
+    cachePath: TOKEN_CACHE_PATH,
+    cacheDir: getCacheDir(),
+    cacheAttempted: false,
+    cacheFound: false,
+    cacheBytes: 0,
+    cacheTokenPresent: false,
+    cacheError: null,
+    envPresent: Boolean(envToken),
+    runtimeTokenCached: Boolean(cachedToken),
+    lastLoadedFrom,
+    resolvedSource: 'none'
+  };
+
+  try {
+    await ensureCacheDir();
+    diagnostics.cacheAttempted = true;
+    const raw = await fs.readFile(TOKEN_CACHE_PATH);
+    diagnostics.cacheFound = true;
+    diagnostics.cacheBytes = raw.length;
+    const parsed = JSON.parse(raw.toString('utf8'));
+    diagnostics.cacheTokenPresent = Boolean(parsed?.token);
+  } catch (error) {
+    diagnostics.cacheError = error?.code === 'ENOENT' ? null : error?.message;
+  }
+
+  if (cachedToken) {
+    diagnostics.resolvedSource = lastLoadedFrom;
+  } else if (envToken) {
+    diagnostics.resolvedSource = 'env';
+  } else if (diagnostics.cacheTokenPresent) {
+    diagnostics.resolvedSource = 'cache';
+  } else {
+    diagnostics.resolvedSource = 'none';
+  }
+
+  diagnostics.tokenPresent = diagnostics.resolvedSource !== 'none';
+  return diagnostics;
+}