mr-magic-mcp-server 0.1.5

package/src/providers/melon.js

@@ -0,0 +1,201 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+
+import { normalizeLyricRecord, recomputeSyncFlags } from '../provider-result-schema.js';
+import { MELON_COOKIE, warnMissingEnv } from '../utils/config.js';
+import { createLogger } from '../utils/logger.js';
+
+const SEARCH_URL = 'https://www.melon.com/search/song/index.htm';
+const LYRIC_URL = 'https://www.melon.com/song/lyricInfo.json';
+const HTTP_TIMEOUT_MS = Number(process.env.MR_MAGIC_HTTP_TIMEOUT_MS || 10000);
+const USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36';
+let cachedMelonCookie = null;
+const logger = createLogger('provider:melon');
+
+async function ensureMelonCookie() {
+  const manualCookie = typeof MELON_COOKIE === 'function' ? MELON_COOKIE() : MELON_COOKIE;
+  if (manualCookie) {
+    cachedMelonCookie = manualCookie;
+    return manualCookie;
+  }
+  if (cachedMelonCookie) return cachedMelonCookie;
+  const response = await axios.get('https://www.melon.com', {
+    timeout: HTTP_TIMEOUT_MS,
+    headers: {
+      'User-Agent': USER_AGENT,
+      Accept: 'text/html'
+    }
+  });
+  const setCookies = response.headers['set-cookie'] || [];
+  const cookie = setCookies.map((entry) => entry.split(';')[0]).join('; ');
+  cachedMelonCookie = cookie;
+  return cookie;
+}
+
+async function buildSearchHeaders() {
+  const headers = {
+    'User-Agent': USER_AGENT,
+    Accept:
+      'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+    'Accept-Language': 'en-US,en;q=0.9',
+    'sec-ch-ua': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"macOS"',
+    Referer: 'https://www.melon.com/search/song/index.htm',
+    'Sec-Fetch-Dest': 'document',
+    'Sec-Fetch-Mode': 'navigate',
+    'Sec-Fetch-Site': 'same-origin',
+    'Sec-Fetch-User': '?1',
+    'Upgrade-Insecure-Requests': '1'
+  };
+  if (!cachedMelonCookie) {
+    warnMissingEnv(['MELON_COOKIE']);
+  }
+  const cookie = await ensureMelonCookie();
+  if (cookie) headers.Cookie = cookie;
+  return headers;
+}
+
+async function fetchSearchPage(track) {
+  const headers = await buildSearchHeaders();
+  const response = await axios.get(SEARCH_URL, {
+    timeout: HTTP_TIMEOUT_MS,
+    headers,
+    params: {
+      q: `${(track.artist || '').trim()} ${(track.title || '').trim()}`.trim(),
+      section: '',
+      mwkLogType: 'T',
+      searchGnbYn: 'Y',
+      kkoSpl: 'N',
+      kkoDpType: '',
+      searchType: 1,
+      searchGubun: 1
+    }
+  });
+  return response.data;
+}
+
+async function buildLyricHeaders(songId) {
+  const headers = {
+    'User-Agent': USER_AGENT,
+    Accept: 'application/json, text/javascript, */*; q=0.01',
+    Referer: `https://www.melon.com/song/detail.htm?songId=${songId}`
+  };
+  const cookie = await ensureMelonCookie();
+  if (cookie) headers.Cookie = cookie;
+  return headers;
+}
+
+function extractSongId(value) {
+  if (!value) return null;
+  const goSongMatch = value.match(/goSongDetail\([^0-9]*?(\d+)\)/);
+  if (goSongMatch) return goSongMatch[1];
+  const searchLogMatch = value.match(/searchLog\('[^']+','[^']+','[^']+','[^']+','(\d+)'\)/);
+  if (searchLogMatch) return searchLogMatch[1];
+  const playMatch = value.match(/playSong\([^0-9]*?(\d+)\)/);
+  if (playMatch) return playMatch[1];
+  return null;
+}
+
+function parseSearchPage(html) {
+  const $ = cheerio.load(html);
+  const seenIds = new Set();
+  return $('#frm_defaultList > div > table > tbody > tr')
+    .map((_, row) => {
+      const $row = $(row);
+      const cells = $row.find('td');
+      const titleAnchor = cells.eq(2).find('a.fc_gray').first();
+      const artistAnchor = cells.eq(3).find('#artistName > a').first();
+      const albumAnchor = cells.eq(4).find('a').first();
+      const titleHref = titleAnchor.attr('href') || titleAnchor.attr('onclick') || '';
+      const artistHref = artistAnchor.attr('href') || artistAnchor.attr('onclick') || '';
+      let songId = extractSongId(titleHref) || extractSongId(artistHref);
+      if (!songId) songId = extractSongId($row.html() || '');
+      if (!songId || seenIds.has(songId)) {
+        return null;
+      }
+      const title = titleAnchor.text().trim().replace(/\s+/g, ' ');
+      const artist = artistAnchor.text().trim().replace(/\s+/g, ' ');
+      const album = albumAnchor.text().trim().replace(/\s+/g, ' ');
+      seenIds.add(songId);
+      if (!title && !artist) return null;
+      return { songId, title, artist, album };
+    })
+    .get()
+    .filter(Boolean);
+}
+
+async function fetchLyricInfo(songId) {
+  const searchParams = new URLSearchParams({ songId });
+  const headers = await buildLyricHeaders(songId);
+  try {
+    const response = await axios.get(`${LYRIC_URL}?${searchParams.toString()}`, {
+      timeout: HTTP_TIMEOUT_MS,
+      headers
+    });
+    return response.data;
+  } catch (error) {
+    logger.error('Melon lyricInfo fetch failed', { error, songId });
+    throw error;
+  }
+}
+
+function toLyricStrings(lyricInfo) {
+  if (!lyricInfo) return { plain: null, synced: null };
+  if (typeof lyricInfo.lyric === 'string' && lyricInfo.lyric.trim()) {
+    const plain = lyricInfo.lyric
+      .replace(/<BR\s*\/?>/gi, '\n')
+      .replace(/&#39;/g, "'")
+      .replace(/&amp;/g, '&')
+      .replace(/&quot;/g, '"')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .trim();
+    return { plain: plain || null, synced: null };
+  }
+  if (!lyricInfo.lyricList) return { plain: null, synced: null };
+  const list = lyricInfo.lyricList;
+  const plain = list
+    .map((item) => item.lyric || '')
+    .filter(Boolean)
+    .join('\n');
+  return { plain: plain || null, synced: null };
+}
+
+export async function searchMelon(track) {
+  const pageHtml = await fetchSearchPage(track);
+  return parseSearchPage(pageHtml).map((record) =>
+    normalizeLyricRecord({
+      provider: 'melon',
+      id: record.songId,
+      trackName: record.title,
+      artistName: record.artist,
+      albumName: record.album,
+      duration: null,
+      plainLyrics: null,
+      syncedLyrics: null,
+      sourceUrl: `https://www.melon.com/song/detail.htm?songId=${record.songId}`,
+      confidence: 0.5,
+      synced: false,
+      status: 'ok',
+      raw: record
+    })
+  );
+}
+
+export async function fetchFromMelon(track) {
+  const candidates = await searchMelon(track);
+  const primary = candidates[0];
+  if (!primary) return null;
+  try {
+    const lyricInfo = await fetchLyricInfo(primary.providerId);
+    const { plain, synced } = toLyricStrings(lyricInfo);
+    primary.plainLyrics = plain;
+    primary.syncedLyrics = synced;
+    recomputeSyncFlags(primary);
+  } catch (error) {
+    logger.error('Melon lyricInfo request failed', { error, songId: primary.providerId });
+  }
+  return primary;
+}

package/src/providers/musixmatch.js

@@ -0,0 +1,165 @@
+import axios from 'axios';
+
+import { normalizeLyricRecord } from '../provider-result-schema.js';
+import { assertEnv } from '../utils/config.js';
+import { createLogger } from '../utils/logger.js';
+import {
+  getMusixmatchToken,
+  invalidateMusixmatchToken
+} from '../utils/tokens/musixmatch-token-manager.js';
+
+const BASE_URL = 'https://apic-desktop.musixmatch.com/ws/1.1/macro.subtitles.get';
+const HTTP_TIMEOUT_MS = Number(process.env.MR_MAGIC_HTTP_TIMEOUT_MS || 10000);
+const MOZILLA_USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36';
+const DEFAULT_HEADERS = {
+  authority: 'apic-desktop.musixmatch.com',
+  'User-Agent': MOZILLA_USER_AGENT
+};
+
+const logger = createLogger('provider:musixmatch');
+
+function buildParams(track, token) {
+  const durationSeconds = track.duration ? Math.round(track.duration / 1000) : '';
+  return new URLSearchParams({
+    format: 'json',
+    namespace: 'lyrics_richsynched',
+    subtitle_format: 'mxm',
+    app_id: 'web-desktop-app-v1.0',
+    q_album: track.album || '',
+    q_artist: track.artist || '',
+    q_artists: track.artist || '',
+    q_track: track.title || '',
+    track_spotify_id: track.uri || '',
+    q_duration: durationSeconds,
+    f_subtitle_length: durationSeconds ? Math.floor(durationSeconds) : '',
+    usertoken: token || ''
+  });
+}
+
+function normalizeBody(body) {
+  const matcher = body['matcher.track.get']?.message?.body;
+  if (!matcher) {
+    return null;
+  }
+
+  const meta = matcher.track || {};
+  const lyricsBody = body['track.lyrics.get']?.message?.body?.lyrics?.lyrics_body || '';
+  const subtitlesRoot = body['track.subtitles.get']?.message?.body;
+  const subtitleEntry =
+    subtitlesRoot?.subtitle_list?.find((entry) => {
+      if (!entry) return false;
+      if (entry.subtitle_body) return true;
+      if (entry.subtitle?.subtitle_body) return true;
+      return Boolean(entry.subtitle_id || entry.subtitle?.subtitle_id);
+    }) ?? null;
+  let syncedLines = [];
+  const resolveBody = () => {
+    if (!subtitleEntry) return null;
+    if (subtitleEntry.subtitle_body) return subtitleEntry.subtitle_body;
+    if (subtitleEntry.subtitle?.subtitle_body) return subtitleEntry.subtitle.subtitle_body;
+    const subtitleId = subtitleEntry.subtitle_id || subtitleEntry.subtitle?.subtitle_id;
+    if (!subtitleId) return null;
+    const rawSubtitle = subtitlesRoot?.subtitle?.find((entry) => entry.subtitle_id === subtitleId);
+    return rawSubtitle?.subtitle_body ?? null;
+  };
+
+  const subtitleBody = resolveBody();
+  if (subtitleBody) {
+    try {
+      syncedLines = JSON.parse(subtitleBody);
+    } catch (error) {
+      logger.warn('Failed to parse Musixmatch subtitle_body', { error });
+      syncedLines = [];
+    }
+  }
+
+  const syncedLyrics = syncedLines
+    .map((item) => {
+      const time = item?.time || {};
+      return `[${time.minutes.toString().padStart(2, '0')}:${time.seconds.toString().padStart(2, '0')}.${(
+        time.hundredths || 0
+      )
+        .toString()
+        .padStart(2, '0')}] ${item.text}`.trim();
+    })
+    .join('\n');
+
+  const plainLyrics = lyricsBody.split('\n').filter(Boolean).join('\n');
+  const sourceUrl = meta.share_url || '';
+
+  return normalizeLyricRecord({
+    provider: 'musixmatch',
+    id: meta.track_id,
+    trackName: meta.track_name,
+    artistName: meta.artist_name,
+    albumName: meta.album_name,
+    duration: meta.track_length || null,
+    plainLyrics: plainLyrics || null,
+    syncedLyrics: syncedLyrics || null,
+    sourceUrl,
+    confidence: 1,
+    synced: Boolean(syncedLyrics),
+    status: 'ok',
+    raw: body
+  });
+}
+
+async function macroRequest(track) {
+  await ensureMusixmatchToken();
+  let token = await getMusixmatchToken();
+  const attempt = async (tok) => {
+    const params = buildParams(track, tok);
+    const response = await axios.get(`${BASE_URL}?${params.toString()}`, {
+      timeout: HTTP_TIMEOUT_MS,
+      headers: DEFAULT_HEADERS
+    });
+    return response.data?.message?.body?.macro_calls || response.data?.message?.body || {};
+  };
+
+  try {
+    return await attempt(token);
+  } catch (error) {
+    if (error.response?.status === 401 || error.response?.status === 403) {
+      logger.warn('Musixmatch token rejected, invalidating', { status: error.response.status });
+      invalidateMusixmatchToken();
+      token = await getMusixmatchToken();
+      if (token) {
+        try {
+          return await attempt(token);
+        } catch (retryError) {
+          logger.error('Musixmatch retry failed', { error: retryError });
+        }
+      }
+    }
+    throw error;
+  }
+}
+
+async function ensureMusixmatchToken() {
+  const token = await getMusixmatchToken();
+  if (!token) {
+    assertEnv(['MUSIXMATCH_TOKEN']);
+  }
+}
+
+export async function fetchFromMusixmatch(track) {
+  try {
+    const body = await macroRequest(track);
+    const record = normalizeBody(body);
+    return record;
+  } catch (error) {
+    logger.error('Musixmatch request failed', { error });
+    return null;
+  }
+}
+
+export async function searchMusixmatch(track) {
+  const record = await fetchFromMusixmatch(track);
+  return record ? [record] : [];
+}
+
+export async function checkMusixmatchTokenReady() {
+  const token = await getMusixmatchToken();
+  return Boolean(token);
+}

package/src/services/airtable-writer.js

@@ -0,0 +1,246 @@
+import '../utils/config.js';
+
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('airtable-writer');
+
+const AIRTABLE_API_BASE = 'https://api.airtable.com/v0';
+
+/**
+ * Returns the configured Airtable personal access token, or throws if missing.
+ */
+function getAirtableToken() {
+  const token = process.env.AIRTABLE_PERSONAL_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error(
+      'AIRTABLE_PERSONAL_ACCESS_TOKEN is not set. ' +
+        'Add it to your .env file. See .env.example for details.'
+    );
+  }
+  return token;
+}
+
+/**
+ * Build the Airtable REST API URL for a table.
+ * @param {string} baseId
+ * @param {string} tableId
+ * @returns {string}
+ */
+function tableUrl(baseId, tableId) {
+  return `${AIRTABLE_API_BASE}/${encodeURIComponent(baseId)}/${encodeURIComponent(tableId)}`;
+}
+
+/**
+ * Make a request to the Airtable REST API.
+ * @param {string} method
+ * @param {string} url
+ * @param {object} [body]
+ * @returns {Promise<object>}
+ */
+async function airtableRequest(method, url, body) {
+  const token = getAirtableToken();
+  const init = {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    }
+  };
+  if (body != null) {
+    init.body = JSON.stringify(body);
+  }
+
+  const timeoutMs = Number(process.env.MR_MAGIC_HTTP_TIMEOUT_MS || 10000);
+  let controller;
+  let timeoutId;
+  if (typeof AbortController !== 'undefined') {
+    controller = new AbortController();
+    init.signal = controller.signal;
+    timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  }
+
+  let res;
+  try {
+    res = await fetch(url, init);
+  } finally {
+    if (timeoutId != null) clearTimeout(timeoutId);
+  }
+
+  const text = await res.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = { _rawBody: text };
+  }
+
+  if (!res.ok) {
+    const message =
+      json?.error?.message ||
+      json?.message ||
+      json?.error ||
+      text ||
+      `Airtable API error ${res.status}`;
+    const err = new Error(`Airtable ${res.status}: ${message}`);
+    err.status = res.status;
+    err.airtableError = json;
+    throw err;
+  }
+
+  return json;
+}
+
+/**
+ * Create a new record in an Airtable table.
+ *
+ * @param {object} opts
+ * @param {string} opts.baseId
+ * @param {string} opts.tableId
+ * @param {Record<string, unknown>} opts.fields  - { fieldIdOrName: value, ... }
+ * @returns {Promise<{ id: string, createdTime: string, fields: Record<string, unknown> }>}
+ */
+export async function createAirtableRecord({ baseId, tableId, fields }) {
+  logger.debug('Creating Airtable record', { baseId, tableId, fieldKeys: Object.keys(fields) });
+  const url = tableUrl(baseId, tableId);
+  const result = await airtableRequest('POST', url, { records: [{ fields }] });
+  const record = result?.records?.[0];
+  if (!record) {
+    throw new Error('Airtable create returned no record');
+  }
+  logger.info('Airtable record created', { baseId, tableId, recordId: record.id });
+  return record;
+}
+
+/**
+ * Update an existing record in an Airtable table (PATCH — only named fields are changed).
+ *
+ * @param {object} opts
+ * @param {string} opts.baseId
+ * @param {string} opts.tableId
+ * @param {string} opts.recordId
+ * @param {Record<string, unknown>} opts.fields  - { fieldIdOrName: value, ... }
+ * @returns {Promise<{ id: string, createdTime: string, fields: Record<string, unknown> }>}
+ */
+export async function updateAirtableRecord({ baseId, tableId, recordId, fields }) {
+  logger.debug('Updating Airtable record', {
+    baseId,
+    tableId,
+    recordId,
+    fieldKeys: Object.keys(fields)
+  });
+  const url = `${tableUrl(baseId, tableId)}`;
+  const result = await airtableRequest('PATCH', url, {
+    records: [{ id: recordId, fields }]
+  });
+  const record = result?.records?.[0];
+  if (!record) {
+    throw new Error('Airtable update returned no record');
+  }
+  logger.info('Airtable record updated', { baseId, tableId, recordId: record.id });
+  return record;
+}
+
+/**
+ * Push catalog fields to Airtable.
+ *
+ * Resolves field values from the provided `fieldValues` map plus an optional
+ * `lyricsText` string that arrives server-side (never through the LLM).
+ *
+ * If `recordId` is supplied → PATCH update.
+ * If `recordId` is omitted → POST create.
+ * If `splitLyricsUpdate` is true → create the record without lyrics first,
+ * then PATCH lyrics in a second call (safe for very large lyric payloads).
+ *
+ * @param {object} opts
+ * @param {string} opts.baseId
+ * @param {string} opts.tableId
+ * @param {string} [opts.recordId]
+ * @param {Record<string, string>} opts.fieldValues   - { fieldId: scalarValue }
+ * @param {string} [opts.lyricsFieldId]               - field ID where lyrics should go
+ * @param {string} [opts.lyricsText]                  - raw lyrics text (fetched server-side)
+ * @param {boolean} [opts.splitLyricsUpdate]          - force two-step create+update
+ * @returns {Promise<{ record: object, lyricsRecord?: object, steps: string[] }>}
+ */
+export async function pushCatalogToAirtable({
+  baseId,
+  tableId,
+  recordId,
+  fieldValues = {},
+  lyricsFieldId,
+  lyricsText,
+  splitLyricsUpdate = false
+}) {
+  const steps = [];
+  const hasLyrics = lyricsFieldId && lyricsText;
+
+  // ------------------------------------------------------------------
+  // Build the non-lyrics fields object
+  // ------------------------------------------------------------------
+  const baseFields = { ...fieldValues };
+
+  // ------------------------------------------------------------------
+  // Decide flow
+  // ------------------------------------------------------------------
+  const isUpdate = Boolean(recordId);
+  const forceSplit = splitLyricsUpdate || false;
+
+  let record;
+
+  if (isUpdate) {
+    // --- UPDATE existing record ---
+    if (hasLyrics && !forceSplit) {
+      // Include lyrics in the single PATCH
+      const fields = { ...baseFields, [lyricsFieldId]: lyricsText };
+      record = await updateAirtableRecord({ baseId, tableId, recordId, fields });
+      steps.push(`updated record ${record.id} with all fields including lyrics`);
+      return { record, steps };
+    }
+
+    if (hasLyrics && forceSplit) {
+      // Two-step: update base fields first, then lyrics
+      record = await updateAirtableRecord({ baseId, tableId, recordId, fields: baseFields });
+      steps.push(`updated record ${record.id} base fields`);
+      const lyricsRecord = await updateAirtableRecord({
+        baseId,
+        tableId,
+        recordId: record.id,
+        fields: { [lyricsFieldId]: lyricsText }
+      });
+      steps.push(`updated record ${lyricsRecord.id} lyrics field`);
+      return { record, lyricsRecord, steps };
+    }
+
+    // No lyrics — plain update
+    record = await updateAirtableRecord({ baseId, tableId, recordId, fields: baseFields });
+    steps.push(`updated record ${record.id} base fields`);
+    return { record, steps };
+  }
+
+  // --- CREATE new record ---
+  if (hasLyrics && !forceSplit) {
+    // Single create with all fields
+    const fields = { ...baseFields, [lyricsFieldId]: lyricsText };
+    record = await createAirtableRecord({ baseId, tableId, fields });
+    steps.push(`created record ${record.id} with all fields including lyrics`);
+    return { record, steps };
+  }
+
+  if (hasLyrics && forceSplit) {
+    // Two-step: create without lyrics, then PATCH lyrics
+    record = await createAirtableRecord({ baseId, tableId, fields: baseFields });
+    steps.push(`created record ${record.id} without lyrics`);
+    const lyricsRecord = await updateAirtableRecord({
+      baseId,
+      tableId,
+      recordId: record.id,
+      fields: { [lyricsFieldId]: lyricsText }
+    });
+    steps.push(`updated record ${lyricsRecord.id} lyrics field`);
+    return { record, lyricsRecord, steps };
+  }
+
+  // No lyrics — plain create
+  record = await createAirtableRecord({ baseId, tableId, fields: baseFields });
+  steps.push(`created record ${record.id} base fields only`);
+  return { record, steps };
+}