HoneyandClaude Sonnet 4.6
86d3999628
- downloads.js: use durationMs (Spotify) before trackTimeMillis (iTunes) - server: read durationMs from top-level body, not only from tracks[0] - server: also grab durationMs + trackNum from iTunes in the Spotify path Without durationMs the duration filter never ran, allowing a 58s fan video to pass all text filters and be downloaded instead of the actual song. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
1435 lines
68 KiB
JavaScript
1435 lines
68 KiB
JavaScript
/**
|
||
* NovaSonic Backend Server
|
||
* Downloads music via yt-dlp / squid.wtf (Qobuz) and saves into your Navidrome library.
|
||
*
|
||
* Requirements:
|
||
* - Node.js 18+
|
||
* - yt-dlp installed (https://github.com/yt-dlp/yt-dlp)
|
||
* - ffmpeg installed
|
||
*/
|
||
|
||
const express = require('express');
|
||
const { execSync, spawn } = require('child_process');
|
||
const path = require('path');
|
||
const fs = require('fs');
|
||
const https = require('https');
|
||
const crypto = require('crypto');
|
||
|
||
const CONFIG = require('./lib/config');
|
||
const { jobs, updateJob, log } = require('./lib/jobs');
|
||
const { sanitize, lookupItunesTrackMeta, fetchItunesTracks, searchItunesAlbumTracks } = require('./lib/metadata');
|
||
const { downloadTrack, downloadAlbumTracks } = require('./lib/downloader');
|
||
const { buildRomajiIndex, clearRomajiCache, isTokenizerReady, fetchNdSongs, romajiForStorage } = require('./lib/romaji');
|
||
|
||
// ─── INIT ─────────────────────────────────────────────────────────────────────
|
||
const app = express();
|
||
app.use((req, res, next) => {
|
||
res.setHeader('Access-Control-Allow-Origin', '*');
|
||
res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PATCH,DELETE,OPTIONS');
|
||
res.setHeader('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-ABS-URL,X-ABS-Token');
|
||
res.setHeader('Access-Control-Allow-Private-Network', 'true');
|
||
if (req.method === 'OPTIONS') { res.sendStatus(204); return; }
|
||
next();
|
||
});
|
||
app.use(express.json({ limit: '10mb' }));
|
||
|
||
let ytdlpVersion = 'unknown';
|
||
try {
|
||
ytdlpVersion = execSync(`${CONFIG.ytdlpBin} --version`, { timeout: 5000 }).toString().trim();
|
||
console.log(`✅ yt-dlp ${ytdlpVersion} found`);
|
||
} catch {
|
||
console.warn('⚠️ yt-dlp not found!');
|
||
}
|
||
|
||
if (!fs.existsSync(CONFIG.musicPath)) {
|
||
console.warn(`⚠️ Music path "${CONFIG.musicPath}" does not exist — creating it`);
|
||
fs.mkdirSync(CONFIG.musicPath, { recursive: true });
|
||
}
|
||
|
||
// Search for a file by exact name anywhere under a directory (max depth 5)
|
||
function _findFileRecursive(dir, name, depth = 0) {
|
||
if (depth > 5) return null;
|
||
try {
|
||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||
if (entry.isDirectory()) {
|
||
const found = _findFileRecursive(path.join(dir, entry.name), name, depth + 1);
|
||
if (found) return found;
|
||
} else if (entry.name === name) {
|
||
return path.join(dir, entry.name);
|
||
}
|
||
}
|
||
} catch {}
|
||
return null;
|
||
}
|
||
|
||
// When Navidrome runs in a different container its paths start with a different root
|
||
// (e.g. /opt/navidrome/music) than the backend's mount (e.g. /music).
|
||
// Strip leading components from the absolute path and try joining with CONFIG.musicPath.
|
||
function _rebasePath(absolutePath, musicPath) {
|
||
const parts = absolutePath.split('/').filter(Boolean);
|
||
for (let i = 1; i < parts.length; i++) {
|
||
const candidate = path.join(musicPath, ...parts.slice(i));
|
||
if (fs.existsSync(candidate)) return candidate;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// When exact filename fails (e.g. file was renamed to include artist),
|
||
// look in the same dir for any audio file sharing the track-number prefix or title stem.
|
||
const AUDIO_EXT_RE = /\.(mp3|flac|opus|m4a|ogg|wav)$/i;
|
||
function _findFileInDir(dir, basename) {
|
||
try {
|
||
const m = basename.match(/^(\d+\s*-\s*)/);
|
||
const prefix = m ? m[1] : null;
|
||
const stem = basename.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '').toLowerCase();
|
||
for (const entry of fs.readdirSync(dir)) {
|
||
if (!AUDIO_EXT_RE.test(entry)) continue;
|
||
if (prefix && entry.startsWith(prefix)) return path.join(dir, entry);
|
||
if (entry.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '').toLowerCase() === stem) return path.join(dir, entry);
|
||
}
|
||
} catch {}
|
||
return null;
|
||
}
|
||
|
||
// Last-resort: deep recursive search by title stem (handles folder renames after metadata edit).
|
||
// Convention: MusicRoot/AlbumArtist/Album/{01 - }Artist - Title.ext
|
||
// The title stem is everything after the optional "NN - Artist - " prefix.
|
||
// We match any audio file whose stem ends with the same title words.
|
||
// Normalize a file stem for loose matching:
|
||
// 1. Strip compound track prefixes like "01-15 – " or "01 - " (handles en-dash, em-dash, hyphen)
|
||
// 2. Normalize all dash variants (en-dash, em-dash) to " - "
|
||
function _normStem(s) {
|
||
return s
|
||
.replace(/^\d[\d\-–—]*\s*[-–—]\s*/, '') // strip leading "01-15 – " or "01 - "
|
||
.replace(/\s*[–—]\s*/g, ' - '); // normalize remaining en/em-dash to " - "
|
||
}
|
||
|
||
function _findFileByStem(dir, titleStem, depth = 0) {
|
||
if (depth > 4) return null;
|
||
const normTitle = _normStem(titleStem);
|
||
try {
|
||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||
if (entry.isDirectory()) {
|
||
const found = _findFileByStem(path.join(dir, entry.name), titleStem, depth + 1);
|
||
if (found) return found;
|
||
} else if (AUDIO_EXT_RE.test(entry.name)) {
|
||
// Strip extension + leading track prefix, then normalize dashes
|
||
const bare = entry.name.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '');
|
||
const bareStem = _normStem(bare.toLowerCase());
|
||
// Match: exact, or "Artist - Title" ending with our title stem
|
||
if (bareStem === normTitle ||
|
||
bareStem.endsWith(' - ' + normTitle) ||
|
||
bareStem.endsWith(normTitle)) {
|
||
return path.join(dir, entry.name);
|
||
}
|
||
}
|
||
}
|
||
} catch {}
|
||
return null;
|
||
}
|
||
|
||
// Like _findFileByStem but also tries a romaji-converted stem.
|
||
// Handles the case where Navidrome has a Japanese path in its DB but the file
|
||
// on disk was stored with a romaji filename by the download pipeline.
|
||
function _findFileByStemOrRomaji(dir, stem) {
|
||
const direct = _findFileByStem(dir, stem);
|
||
if (direct) return direct;
|
||
try {
|
||
const rt = (romajiForStorage(stem) || '').toLowerCase().trim();
|
||
if (rt && rt !== stem) return _findFileByStem(dir, rt);
|
||
} catch {}
|
||
return null;
|
||
}
|
||
|
||
// ─── QUEUE ────────────────────────────────────────────────────────────────────
|
||
let activeDownloads = 0;
|
||
const downloadQueue = [];
|
||
|
||
function processQueue() {
|
||
if (activeDownloads >= CONFIG.maxParallel || downloadQueue.length === 0) return;
|
||
const task = downloadQueue.shift();
|
||
activeDownloads++;
|
||
task().finally(() => { activeDownloads--; processQueue(); });
|
||
}
|
||
|
||
function enqueue(task) {
|
||
downloadQueue.push(task);
|
||
processQueue();
|
||
}
|
||
|
||
// ─── SPOTIFY ──────────────────────────────────────────────────────────────────
|
||
function parseSpotifyUrl(url) {
|
||
const m = url.match(/open\.spotify\.com\/(?:[a-z]{2,8}-[a-z]{2,8}\/)?(?:intl-[a-z-]+\/)?(track|album|playlist)\/([A-Za-z0-9]+)/);
|
||
if (!m) throw new Error('Ungültige Spotify-URL — erwartet: open.spotify.com/track|album|playlist/...');
|
||
return { type: m[1], id: m[2] };
|
||
}
|
||
|
||
|
||
// ─── ROUTES ──────────────────────────────────────────────────────────────────
|
||
|
||
// GET /api/romaji-index?ndUrl=...&user=...&pass=...
|
||
app.get('/api/romaji-index', async (req, res) => {
|
||
const { ndUrl, user, pass } = req.query;
|
||
if (!ndUrl || !user || !pass) return res.status(400).json({ error: 'missing params' });
|
||
if (!isTokenizerReady()) return res.status(503).json({ error: 'tokenizer not ready — try again in a few seconds' });
|
||
try {
|
||
const { fromCache, index } = await buildRomajiIndex(ndUrl, user, pass);
|
||
if (!fromCache) console.log(`✅ Romaji index built: ${index.length} JP songs`);
|
||
res.json(index);
|
||
} catch (e) {
|
||
console.error('Romaji index error:', e);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// DELETE /api/romaji-index — force rebuild on next request
|
||
app.delete('/api/romaji-index', (req, res) => {
|
||
clearRomajiCache();
|
||
res.json({ ok: true });
|
||
});
|
||
|
||
// ─── ROMAJI OVERRIDES (server-side, shared across all clients) ───────────────
|
||
const _overridesFile = path.join(CONFIG.dataPath, 'romaji-overrides.json');
|
||
|
||
function _loadOverrides() {
|
||
try { return JSON.parse(fs.readFileSync(_overridesFile, 'utf8')); } catch { return {}; }
|
||
}
|
||
function _saveOverrides(map) {
|
||
try {
|
||
fs.mkdirSync(CONFIG.dataPath, { recursive: true });
|
||
fs.writeFileSync(_overridesFile, JSON.stringify(map, null, 2), 'utf8');
|
||
} catch (e) { console.error('Failed to save romaji overrides:', e.message); }
|
||
}
|
||
|
||
// GET /api/romaji-overrides — returns the full kanji→romaji map
|
||
app.get('/api/romaji-overrides', (_req, res) => res.json(_loadOverrides()));
|
||
|
||
// POST /api/romaji-overrides — upsert { kanji, romaji }
|
||
app.post('/api/romaji-overrides', (req, res) => {
|
||
const { kanji, romaji } = req.body;
|
||
if (!kanji?.trim()) return res.status(400).json({ error: 'kanji required' });
|
||
const map = _loadOverrides();
|
||
if (romaji?.trim()) map[kanji.trim()] = romaji.trim();
|
||
else delete map[kanji.trim()];
|
||
_saveOverrides(map);
|
||
clearRomajiCache(); // rebuild romaji index so display picks up the change
|
||
res.json({ ok: true });
|
||
});
|
||
|
||
// DELETE /api/romaji-overrides/:kanji — remove one entry
|
||
app.delete('/api/romaji-overrides/:kanji', (req, res) => {
|
||
const kanji = decodeURIComponent(req.params.kanji);
|
||
const map = _loadOverrides();
|
||
delete map[kanji];
|
||
_saveOverrides(map);
|
||
clearRomajiCache();
|
||
res.json({ ok: true });
|
||
});
|
||
|
||
// POST /api/romaji-convert — convert an array of strings to romaji
|
||
app.post('/api/romaji-convert', (req, res) => {
|
||
const { texts } = req.body;
|
||
if (!Array.isArray(texts)) return res.status(400).json({ error: 'texts must be array' });
|
||
if (!isTokenizerReady()) return res.status(503).json({ error: 'tokenizer not ready' });
|
||
res.json({ results: texts.map(t => romajiForStorage(t) || t) });
|
||
});
|
||
|
||
// GET /api/genre-playcounts?ndUrl=...&user=...&pass=...
|
||
// Returns { [genre]: totalPlayCount } sorted by plays desc, cached for 20 min.
|
||
const _genrePlayCache = new Map();
|
||
const GENRE_PLAY_TTL = 20 * 60 * 1000;
|
||
app.get('/api/genre-playcounts', async (req, res) => {
|
||
const { ndUrl, user, pass } = req.query;
|
||
if (!ndUrl || !user || !pass) return res.status(400).json({ error: 'missing params' });
|
||
const key = `${ndUrl}|${user}`;
|
||
const cached = _genrePlayCache.get(key);
|
||
if (cached && Date.now() - cached.ts < GENRE_PLAY_TTL) return res.json(cached.data);
|
||
try {
|
||
const songs = await fetchNdSongs(ndUrl, user, pass);
|
||
const totals = {};
|
||
for (const s of songs) {
|
||
const g = s.genre;
|
||
if (!g || !(s.playCount > 0)) continue;
|
||
totals[g] = (totals[g] || 0) + s.playCount;
|
||
}
|
||
_genrePlayCache.set(key, { ts: Date.now(), data: totals });
|
||
res.json(totals);
|
||
} catch (e) {
|
||
console.error('genre-playcounts error:', e);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/spotify/track-artwork', async (req, res) => {
|
||
const tracks = req.body.tracks || [];
|
||
if (!tracks.length) return res.json({ results: [] });
|
||
const CONC = 8;
|
||
const results = [];
|
||
for (let i = 0; i < tracks.length; i += CONC) {
|
||
const batch = tracks.slice(i, i + CONC);
|
||
const batchRes = await Promise.all(batch.map(async t => {
|
||
const searchArtist = (t.artistName || '').split(/\s*[,/•]\s*/)[0].trim();
|
||
const meta = await lookupItunesTrackMeta(searchArtist, t.trackName || '');
|
||
return { idx: t.idx, artworkUrl: meta.artworkUrl || t.existingArt || '' };
|
||
}));
|
||
results.push(...batchRes);
|
||
}
|
||
res.json({ results });
|
||
});
|
||
|
||
// ─── ITUNES METADATA LOOKUP (must be before the proxy route) ─────────────────
|
||
app.get('/api/itunes/lookup', async (req, res, next) => {
|
||
const { artist, title } = req.query;
|
||
// ID-based lookups (?id=...) are not for track meta — let them fall through to the proxy.
|
||
if (!artist || !title) return next();
|
||
try {
|
||
const meta = await lookupItunesTrackMeta(artist, title);
|
||
if (!meta.album && !meta.genre && !meta.year) return res.json({ found: false });
|
||
res.json({
|
||
found: true,
|
||
album: meta.album || undefined,
|
||
year: meta.year || undefined,
|
||
trackNum: meta.trackNum || undefined,
|
||
totalTracks: meta.totalTracks || undefined,
|
||
genre: meta.genre || undefined,
|
||
coverUrl: meta.artworkUrl || undefined,
|
||
artist: meta.itunesArtistName || undefined,
|
||
});
|
||
} catch (e) {
|
||
console.error('[itunes/lookup]', e.message);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// ─── ITUNES PROXY ─────────────────────────────────────────────────────────────
|
||
// Browsers can't call itunes.apple.com directly (no CORS headers). Proxy it here.
|
||
// Note: /api/itunes/lookup is handled above — proxy only covers /search and id-based /lookup.
|
||
app.get('/api/itunes/:endpoint', (req, res) => {
|
||
const allowed = new Set(['search', 'lookup']);
|
||
if (!allowed.has(req.params.endpoint)) return res.status(404).json({ error: 'not found' });
|
||
const qs = new URLSearchParams(req.query).toString();
|
||
const target = `https://itunes.apple.com/${req.params.endpoint}${qs ? '?' + qs : ''}`;
|
||
https.get(target, { headers: { 'User-Agent': 'NovaSonic/1.0' } }, upstream => {
|
||
res.setHeader('Content-Type', 'application/json');
|
||
upstream.pipe(res);
|
||
}).on('error', e => res.status(502).json({ error: e.message }));
|
||
});
|
||
|
||
app.get('/api/events/:artist', (req, res) => {
|
||
const key = CONFIG.ticketmasterKey;
|
||
if (!key) { console.warn('[events] TICKETMASTER_API_KEY not set'); return res.json([]); }
|
||
const artist = req.params.artist;
|
||
const now = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z'); // 2024-06-08T12:00:00Z
|
||
const url = `https://app.ticketmaster.com/discovery/v2/events.json` +
|
||
`?keyword=${encodeURIComponent(artist)}&classificationName=music` +
|
||
`&startDateTime=${now}&size=20&sort=date,asc` +
|
||
`&apikey=${key}`;
|
||
https.get(url, { headers: { 'Accept': 'application/json' } }, upstream => {
|
||
let body = '';
|
||
upstream.on('data', d => body += d);
|
||
upstream.on('end', () => {
|
||
try {
|
||
const data = JSON.parse(body);
|
||
if (upstream.statusCode !== 200 || data.fault || data.errors) {
|
||
console.error('[events] Ticketmaster error:', upstream.statusCode, JSON.stringify(data).slice(0, 200));
|
||
return res.json([]);
|
||
}
|
||
const raw = data?._embedded?.events || [];
|
||
const events = raw.map(e => {
|
||
const venue = e._embedded?.venues?.[0] || {};
|
||
const start = e.dates?.start || {};
|
||
const dt = start.dateTime || (start.localDate
|
||
? `${start.localDate}T${start.localTime || '00:00:00'}`
|
||
: null);
|
||
const soldOut = e.dates?.status?.code === 'offsale' ||
|
||
e.dates?.status?.code === 'cancelled';
|
||
return {
|
||
datetime: dt,
|
||
venue: {
|
||
name: venue.name || '',
|
||
city: venue.city?.name || '',
|
||
country: venue.country?.name || '',
|
||
},
|
||
offers: e.url ? [{ url: e.url, status: soldOut ? 'unavailable' : 'available' }] : [],
|
||
};
|
||
}).filter(e => e.datetime);
|
||
console.log(`[events] ${artist}: ${events.length} events`);
|
||
res.json(events);
|
||
} catch(err) { console.error('[events] parse error:', err); res.json([]); }
|
||
});
|
||
}).on('error', e => { console.error('[events] request error:', e.message); res.json([]); });
|
||
});
|
||
|
||
// Debug-only: returns raw Ticketmaster response so you can see exactly what the API sends back.
|
||
// Visit /api/events-debug/Maduk in your browser to test.
|
||
app.get('/api/events-debug/:artist', (req, res) => {
|
||
const key = CONFIG.ticketmasterKey;
|
||
if (!key) return res.json({ error: 'TICKETMASTER_API_KEY not set in .env' });
|
||
const artist = req.params.artist;
|
||
const now = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
|
||
const url = `https://app.ticketmaster.com/discovery/v2/events.json` +
|
||
`?keyword=${encodeURIComponent(artist)}&classificationName=music` +
|
||
`&startDateTime=${now}&size=5&sort=date,asc&apikey=${key}`;
|
||
https.get(url, { headers: { 'Accept': 'application/json' } }, upstream => {
|
||
let body = '';
|
||
upstream.on('data', d => body += d);
|
||
upstream.on('end', () => {
|
||
try { res.json({ status: upstream.statusCode, url: url.replace(key, 'KEY_HIDDEN'), body: JSON.parse(body) }); }
|
||
catch { res.json({ status: upstream.statusCode, raw: body.slice(0, 500) }); }
|
||
});
|
||
}).on('error', e => res.json({ error: e.message }));
|
||
});
|
||
|
||
app.get('/api/health', (req, res) => {
|
||
res.json({
|
||
status: 'ok', ytdlpVersion,
|
||
musicPath: CONFIG.musicPath,
|
||
audioFormat: CONFIG.audioFmt,
|
||
downloadBackend: CONFIG.downloadBackend,
|
||
activeJobs: activeDownloads,
|
||
queueLength: downloadQueue.length,
|
||
spotify: { configured: true },
|
||
});
|
||
});
|
||
|
||
async function _resolveSpotifyViaSpotdl(url) {
|
||
const { execFile } = require('child_process');
|
||
const scriptPath = path.join(__dirname, 'spotify_resolve.py');
|
||
// Strip ?si= and other tracking params — spotdl doesn't handle them
|
||
const cleanUrl = url.split('?')[0];
|
||
return new Promise((resolve, reject) => {
|
||
execFile('python3', [scriptPath, cleanUrl], { timeout: 90000, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
|
||
if (stderr?.trim()) stderr.trim().split('\n').forEach(l => console.log('[py]', l));
|
||
// Always try to parse stdout first — script outputs JSON even on error
|
||
const out = stdout?.trim();
|
||
if (out) {
|
||
try {
|
||
const data = JSON.parse(out);
|
||
if (data.error === 'RATE_LIMITED') return reject(new Error(`RATE_LIMITED:${data.retryAfter || 30}`));
|
||
if (data.error) return reject(new Error(`spotdl: ${data.error}`));
|
||
return resolve(data);
|
||
} catch { /* not JSON, fall through */ }
|
||
}
|
||
if (err) return reject(new Error(`spotdl exited ${err.code}: ${stderr?.trim() || out || err.message}`));
|
||
reject(new Error(`spotdl: keine Ausgabe`));
|
||
});
|
||
});
|
||
}
|
||
|
||
// Tracks when the Spotify rate limit window expires so retries never reach Spotify.
|
||
let _spRateLimitUntil = 0;
|
||
|
||
app.post('/api/spotify/resolve', async (req, res) => {
|
||
const { url } = req.body;
|
||
if (!url) return res.status(400).json({ error: 'url required' });
|
||
|
||
// Block retries until the cooldown the Spotify told us has actually elapsed.
|
||
const now = Date.now();
|
||
if (_spRateLimitUntil > now) {
|
||
const secs = Math.ceil((_spRateLimitUntil - now) / 1000);
|
||
console.log(`[spotify/resolve] cooldown active — ${secs}s remaining`);
|
||
return res.status(429).json({ error: 'RATE_LIMITED', retryAfter: secs });
|
||
}
|
||
|
||
try {
|
||
const { type, id } = parseSpotifyUrl(url);
|
||
console.log(`[spotify/resolve] ${type} ${id}`);
|
||
|
||
const timeout = new Promise((_, reject) =>
|
||
setTimeout(() => reject(new Error('Zeitüberschreitung — Spotify API antwortet nicht (>120s)')), 120000)
|
||
);
|
||
const data = await Promise.race([_resolveSpotifyViaSpotdl(url), timeout]);
|
||
res.json(data);
|
||
} catch(e) {
|
||
console.error('[spotify/resolve]', e.message);
|
||
if (e.message.includes('403') && e.message.includes('/playlists/')) {
|
||
return res.status(403).json({ error: 'EDITORIAL_PLAYLIST' });
|
||
}
|
||
if (e.message.startsWith('RATE_LIMITED:')) {
|
||
const secs = parseInt(e.message.split(':')[1], 10) || 30;
|
||
_spRateLimitUntil = Date.now() + secs * 1000;
|
||
return res.status(429).json({ error: 'RATE_LIMITED', retryAfter: secs });
|
||
}
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// Normalize user-supplied artist strings — accepts •, ·, ;, or , as separators
|
||
// and rejoins with the canonical sep ("; " for track artist, ", " for album artist).
|
||
function _normalizeArtists(str, sep) {
|
||
if (!str) return str;
|
||
// If an explicit separator is present use it; otherwise fall back to splitting on spaces
|
||
// so the user can type "Artist1 Artist2" without a semicolon.
|
||
return str.split(/\s*[•·;,]\s*/).map(s => s.trim()).filter(Boolean).join(sep);
|
||
}
|
||
|
||
// Strip " - Topic" suffix YouTube Music appends to artist channel names
|
||
function _cleanYtArtist(name) {
|
||
return (name || '').replace(/\s*-\s*Topic$/i, '').trim();
|
||
}
|
||
|
||
app.post('/api/youtube/resolve', async (req, res) => {
|
||
const { url } = req.body;
|
||
if (!url) return res.status(400).json({ error: 'url required' });
|
||
|
||
try {
|
||
const { execFile } = require('child_process');
|
||
const stdout = await new Promise((resolve, reject) => {
|
||
execFile(CONFIG.ytdlpBin, [
|
||
'--dump-json', '--flat-playlist', '--no-warnings',
|
||
'--playlist-items', '1-50',
|
||
url,
|
||
], { timeout: 45000, maxBuffer: 20 * 1024 * 1024 }, (err, out, stderr) => {
|
||
if (err && !out?.trim()) return reject(new Error(stderr?.trim() || err.message));
|
||
resolve(out || '');
|
||
});
|
||
});
|
||
|
||
const entries = stdout.trim().split('\n')
|
||
.map(l => { try { return JSON.parse(l.trim()); } catch { return null; } })
|
||
.filter(Boolean);
|
||
|
||
if (!entries.length) return res.status(404).json({ error: 'Keine Ergebnisse von yt-dlp' });
|
||
|
||
const isPlaylist = entries.length > 1 || entries[0]?._type === 'playlist';
|
||
|
||
if (isPlaylist) {
|
||
const plTitle = entries[0]?.playlist_title || entries[0]?.playlist || 'YouTube Playlist';
|
||
const plArtist = _cleanYtArtist(entries[0]?.uploader || entries[0]?.channel || '');
|
||
const tracks = entries.map(e => ({
|
||
trackName: e.title || '',
|
||
artistName: _cleanYtArtist(e.uploader || e.channel || plArtist),
|
||
artworkUrl: e.thumbnail || '',
|
||
durationMs: e.duration ? Math.round(e.duration * 1000) : undefined,
|
||
sourceUrl: e.webpage_url || e.url || (e.id ? `https://www.youtube.com/watch?v=${e.id}` : ''),
|
||
}));
|
||
return res.json({ type: 'playlist', name: plTitle, artist: plArtist,
|
||
artworkUrl: entries[0]?.thumbnail || '', tracks });
|
||
}
|
||
|
||
// Single video — enrich with iTunes
|
||
const e = entries[0];
|
||
const rawArtist = _cleanYtArtist(e.uploader || e.channel || e.creator || '');
|
||
const title = e.title || '';
|
||
const sourceUrl = e.webpage_url || url;
|
||
let itunes = {};
|
||
try { itunes = await lookupItunesTrackMeta(rawArtist.split(',')[0].trim(), title); } catch {}
|
||
|
||
const artist = itunes.artist || rawArtist;
|
||
const artworkUrl = itunes.artworkUrl || e.thumbnail || '';
|
||
return res.json({
|
||
type: 'track', name: title, artist, artworkUrl,
|
||
tracks: [{
|
||
trackName: title,
|
||
artistName: artist,
|
||
artworkUrl: artworkUrl,
|
||
collectionName: itunes.album || '',
|
||
releaseDate: itunes.year ? String(itunes.year) : '',
|
||
trackNumber: itunes.trackNum || undefined,
|
||
durationMs: itunes.durationMs || (e.duration ? Math.round(e.duration * 1000) : undefined),
|
||
genre: itunes.genre || '',
|
||
sourceUrl,
|
||
}],
|
||
});
|
||
} catch (e) {
|
||
console.error('[youtube/resolve]', e.message);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/download', async (req, res) => {
|
||
const { type, artist, title, album, artworkUrl, collectionId, jobId: clientJobId, explicit,
|
||
trackNum: bodyTrackNum, totalTracks: bodyTotalTracks, discNum: bodyDiscNum, discTotal: bodyDiscTotal,
|
||
sourceUrl } = req.body;
|
||
if (!artist || !title) return res.status(400).json({ error: 'artist and title required' });
|
||
|
||
const jobId = clientJobId || ('job_' + Date.now());
|
||
jobs.set(jobId, {
|
||
id: jobId, type, artist, title, album,
|
||
status: 'queued', progress: 0, message: 'In Warteschlange…',
|
||
log: [], createdAt: Date.now(), updatedAt: Date.now(),
|
||
});
|
||
res.json({ jobId, status: 'queued' });
|
||
|
||
enqueue(async () => {
|
||
updateJob(jobId, { status: 'running', progress: 5, message: 'Gestartet…' });
|
||
try {
|
||
if (type === 'track') {
|
||
const sp = req.body.tracks?.[0] || {};
|
||
const spAlbum = sp.collectionName || sp.album || album || '';
|
||
const spArt = sp.artworkUrl100 || sp.artworkUrl || artworkUrl || '';
|
||
const spYear = sp.releaseDate ? new Date(sp.releaseDate).getFullYear() : (sp.year || undefined);
|
||
let meta = {
|
||
album: spAlbum, year: spYear,
|
||
trackNum: sp.trackNumber || bodyTrackNum || undefined,
|
||
totalTracks: sp.trackCount || bodyTotalTracks || undefined,
|
||
discNum: sp.discNumber || bodyDiscNum || undefined,
|
||
discTotal: sp.discCount || bodyDiscTotal || undefined,
|
||
genre: sp.primaryGenreName || sp.genre || undefined,
|
||
artworkUrl: spArt, explicit: sp.trackExplicitness === 'explicit' || !!explicit,
|
||
durationMs: sp.durationMs || req.body.durationMs || undefined,
|
||
};
|
||
const searchArtist = artist.split(',')[0].trim();
|
||
if (!meta.album) {
|
||
log(jobId, '📋 Suche Album-Metadaten von iTunes…');
|
||
const extra = await lookupItunesTrackMeta(searchArtist, title);
|
||
if (extra.album) log(jobId, `📋 Album: "${extra.album}" (${extra.year || '?'})`);
|
||
meta = { ...meta, ...extra, artworkUrl: spArt || extra.artworkUrl || '', genre: meta.genre || extra.genre || undefined };
|
||
} else {
|
||
log(jobId, `📋 Album aus Spotify: "${meta.album}"`);
|
||
// Spotify enrichment has no genre, totalTracks, or disc info — fetch from iTunes
|
||
if (!meta.genre || !meta.totalTracks) {
|
||
const genreMeta = await lookupItunesTrackMeta(searchArtist, title).catch(() => ({}));
|
||
if (!meta.genre && genreMeta.genre) { meta.genre = genreMeta.genre; log(jobId, `📋 Genre: "${genreMeta.genre}"`); }
|
||
if (!meta.totalTracks && genreMeta.totalTracks) { meta.totalTracks = genreMeta.totalTracks; }
|
||
if (!meta.discNum && genreMeta.discNum) { meta.discNum = genreMeta.discNum; }
|
||
if (!meta.discTotal && genreMeta.discTotal) { meta.discTotal = genreMeta.discTotal; }
|
||
if (!meta.durationMs && genreMeta.durationMs) { meta.durationMs = genreMeta.durationMs; }
|
||
if (!meta.trackNum && genreMeta.trackNum) { meta.trackNum = genreMeta.trackNum; }
|
||
}
|
||
}
|
||
const finalArtist = meta.itunesArtistName || artist;
|
||
const result = await downloadTrack({ jobId, artist: finalArtist, rawArtist: artist, title, ...meta, sourceUrl: sourceUrl || sp.sourceUrl || undefined });
|
||
if (result?.skipped) {
|
||
updateJob(jobId, { status: 'done', progress: 100, message: 'Bereits vorhanden – übersprungen', skipped: true });
|
||
} else {
|
||
updateJob(jobId, { status: 'done', progress: 100, message: 'Fertig!' });
|
||
}
|
||
|
||
} else if (type === 'album') {
|
||
let tracks = [];
|
||
if (collectionId) {
|
||
log(jobId, '📋 Lade Track-Liste von iTunes…');
|
||
tracks = await fetchItunesTracks(collectionId);
|
||
}
|
||
if (!tracks.length) {
|
||
log(jobId, '🔍 Suche Album auf iTunes…');
|
||
tracks = await searchItunesAlbumTracks(artist, album || title);
|
||
}
|
||
if (!tracks.length) {
|
||
throw new Error(`Keine einzelnen Tracks für "${album || title}" gefunden. Bitte über iTunes Global-Suche herunterladen.`);
|
||
}
|
||
const { done: dlDone, skipped: dlSkipped } = await downloadAlbumTracks({ jobId, artist, albumTitle: album || title, tracks, artworkUrl });
|
||
const allSkipped = dlSkipped === tracks.length;
|
||
const someSkipped = dlSkipped > 0 && !allSkipped;
|
||
const msg = allSkipped
|
||
? `Album bereits vorhanden – alle ${dlSkipped} Tracks übersprungen`
|
||
: someSkipped
|
||
? `Album fertig! (${dlDone} geladen, ${dlSkipped} bereits vorhanden)`
|
||
: `Album "${album || title}" fertig!`;
|
||
updateJob(jobId, { status: 'done', progress: 100, message: msg, skipped: allSkipped });
|
||
|
||
} else if (type === 'artist') {
|
||
log(jobId, `🎤 Künstler-Download: ${artist}`);
|
||
const artistData = await new Promise((resolve, reject) => {
|
||
https.get(`https://itunes.apple.com/search?term=${encodeURIComponent(artist)}&media=music&entity=album&limit=10&country=de`, res => {
|
||
let d = ''; res.on('data', c => d += c);
|
||
res.on('end', () => { try { resolve(JSON.parse(d).results || []); } catch { reject(new Error('parse')); } });
|
||
}).on('error', reject);
|
||
});
|
||
const artistAlbums = artistData.filter(a => a.artistName?.toLowerCase() === artist.toLowerCase()).slice(0, 10);
|
||
log(jobId, `📀 ${artistAlbums.length} Alben gefunden`);
|
||
let done = 0;
|
||
for (const alb of artistAlbums) {
|
||
const tracks = await fetchItunesTracks(alb.collectionId).catch(() => []);
|
||
if (tracks.length) {
|
||
await downloadAlbumTracks({ jobId, artist, albumTitle: alb.collectionName, tracks, artworkUrl: alb.artworkUrl100 });
|
||
}
|
||
done++;
|
||
updateJob(jobId, { progress: Math.round((done / artistAlbums.length) * 95) });
|
||
}
|
||
updateJob(jobId, { status: 'done', progress: 100, message: `Künstler "${artist}" fertig!` });
|
||
|
||
} else if (type === 'playlist') {
|
||
const plTracks = req.body.tracks || [];
|
||
if (!plTracks.length) throw new Error('Keine Tracks übergeben');
|
||
log(jobId, `🎵 Playlist "${title}" — ${plTracks.length} Tracks`);
|
||
let done = 0, skipped = 0;
|
||
const CONC = CONFIG.maxParallel || 2;
|
||
for (let i = 0; i < plTracks.length; i += CONC) {
|
||
const batch = plTracks.slice(i, i + CONC);
|
||
const batchResults = await Promise.allSettled(batch.map(async track => {
|
||
const trackTitle = track.trackName || '';
|
||
const trackArtist = track.artistName || artist || '';
|
||
// If the frontend already enriched this track with iTunes data (collectionName +
|
||
// trackNumber + durationMs all present), skip the re-lookup to avoid a different
|
||
// iTunes result overriding the already-correct enriched metadata.
|
||
const alreadyEnriched = !!(track.collectionName && track.trackNumber && track.durationMs);
|
||
const searchArtist = trackArtist.split(',')[0].trim();
|
||
let itunes = {};
|
||
if (alreadyEnriched) {
|
||
log(jobId, `📋 Frontend-Metadaten: "${trackArtist} – ${trackTitle}" (${track.collectionName})`);
|
||
// Spotify enrichment copies album/trackNum/duration but not genre/totalTracks/disc — fetch those
|
||
const genreMeta = await lookupItunesTrackMeta(searchArtist, trackTitle).catch(() => ({}));
|
||
itunes = {
|
||
genre: genreMeta.genre,
|
||
totalTracks: genreMeta.totalTracks,
|
||
discNum: genreMeta.discNum,
|
||
discTotal: genreMeta.discTotal,
|
||
};
|
||
} else {
|
||
log(jobId, `📋 iTunes: "${trackArtist} – ${trackTitle}"`);
|
||
itunes = await lookupItunesTrackMeta(searchArtist, trackTitle);
|
||
}
|
||
// Prefer iTunes-resolved name (from server lookup or frontend enrichment) for sort tags / folders.
|
||
// trackArtist stays as rawArtist for main tags and YTM search.
|
||
const resolvedArtist = itunes.itunesArtistName || track.itunesArtistName || trackArtist;
|
||
return downloadTrack({
|
||
jobId,
|
||
artist: resolvedArtist, // iTunes English name → used for sort tags + folder names
|
||
rawArtist: trackArtist, // original Spotify/Japanese name → used for main tag + YTM search
|
||
albumArtist: resolvedArtist,
|
||
title: trackTitle,
|
||
album: itunes.album || track.collectionName || track.album || '',
|
||
year: itunes.year || (track.releaseDate ? new Date(track.releaseDate).getFullYear() : undefined) || track.year,
|
||
trackNum: itunes.trackNum || track.trackNumber || undefined,
|
||
totalTracks: itunes.totalTracks || undefined,
|
||
genre: itunes.genre || track.primaryGenreName || track.genre || undefined,
|
||
artworkUrl: itunes.artworkUrl || track.artworkUrl100 || track.artworkUrl || artworkUrl || '',
|
||
explicit: track.trackExplicitness === 'explicit',
|
||
durationMs: itunes.durationMs || track.durationMs || undefined,
|
||
sourceUrl: track.sourceUrl || undefined,
|
||
});
|
||
}));
|
||
for (let j = 0; j < batchResults.length; j++) {
|
||
const r = batchResults[j];
|
||
if (r.status === 'rejected') {
|
||
log(jobId, `⚠️ Fehler bei "${batch[j].trackName || '?'}": ${r.reason?.message || r.reason}`);
|
||
} else if (r.value?.skipped) {
|
||
skipped++;
|
||
} else {
|
||
done++;
|
||
}
|
||
updateJob(jobId, { progress: Math.round(((done + skipped) / plTracks.length) * 90) });
|
||
}
|
||
}
|
||
const allSkipped = skipped === plTracks.length;
|
||
updateJob(jobId, {
|
||
status: 'done', progress: 100, skipped: allSkipped,
|
||
message: allSkipped
|
||
? `Alle ${skipped} Tracks bereits vorhanden`
|
||
: `Fertig! ${done} geladen${skipped ? `, ${skipped} übersprungen` : ''}`,
|
||
});
|
||
}
|
||
} catch (err) {
|
||
console.error(`[${jobId}] Error:`, err.message);
|
||
updateJob(jobId, { status: 'error', message: err.message });
|
||
}
|
||
});
|
||
});
|
||
|
||
// POST /api/fix-artist-sort — batch-update sort tags + rename artist folder for all songs by a kanji artist
|
||
app.post('/api/fix-artist-sort', async (req, res) => {
|
||
const { ndUrl, user, pass, artistKanji, artistSort, jobId: clientJobId } = req.body;
|
||
if (!ndUrl || !user || !pass || !artistKanji || !artistSort)
|
||
return res.status(400).json({ error: 'ndUrl, user, pass, artistKanji, artistSort required' });
|
||
|
||
const jobId = clientJobId || ('job_' + Date.now());
|
||
jobs.set(jobId, {
|
||
id: jobId, type: 'fix-sort',
|
||
artist: artistKanji, title: `Romaji-Fix: ${artistSort}`, album: '',
|
||
status: 'queued', progress: 0, message: 'Suche Songs…',
|
||
log: [], createdAt: Date.now(), updatedAt: Date.now(),
|
||
});
|
||
res.json({ jobId, status: 'queued' });
|
||
|
||
(async () => {
|
||
const mkTok = () => {
|
||
const s = Math.random().toString(36).slice(2, 10);
|
||
return { s, t: crypto.createHash('md5').update(pass + s).digest('hex') };
|
||
};
|
||
|
||
// Search Navidrome for all songs by this artist
|
||
let songs = [];
|
||
try {
|
||
const { s, t } = mkTok();
|
||
const r = await fetch(
|
||
`${ndUrl}/rest/search3?query=${encodeURIComponent(artistKanji)}&artistCount=0&albumCount=0&songCount=500&u=${encodeURIComponent(user)}&t=${t}&s=${s}&v=1.16.1&c=novasonic&f=json`,
|
||
{ signal: AbortSignal.timeout(15000) }
|
||
);
|
||
const d = await r.json();
|
||
const all = d?.['subsonic-response']?.searchResult3?.song || [];
|
||
songs = all.filter(sng => sng.artist === artistKanji || sng.albumArtist === artistKanji);
|
||
} catch (e) {
|
||
updateJob(jobId, { status: 'error', message: `Navidrome-Suche fehlgeschlagen: ${e.message}` });
|
||
return;
|
||
}
|
||
|
||
if (!songs.length) {
|
||
updateJob(jobId, { status: 'done', progress: 100, message: 'Keine Songs gefunden' });
|
||
return;
|
||
}
|
||
|
||
log(jobId, `🔍 ${songs.length} Songs gefunden für "${artistKanji}"`);
|
||
updateJob(jobId, { status: 'running', progress: 10, message: `${songs.length} Songs gefunden…` });
|
||
|
||
let done = 0, errors = 0;
|
||
const errorDetails = [];
|
||
const safeArtistDir = sanitize(artistSort.split(/[,;&]/)[0].trim());
|
||
|
||
for (const ndSong of songs) {
|
||
try {
|
||
// Resolve file path
|
||
let filePath = ndSong.path;
|
||
if (!filePath) { errors++; continue; }
|
||
if (!path.isAbsolute(filePath)) filePath = path.join(CONFIG.musicPath, filePath);
|
||
if (!fs.existsSync(filePath)) {
|
||
const fileName = path.basename(filePath);
|
||
const titleStem = fileName.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '').toLowerCase();
|
||
const found = _rebasePath(filePath, CONFIG.musicPath)
|
||
|| _findFileRecursive(CONFIG.musicPath, fileName)
|
||
|| _findFileByStemOrRomaji(CONFIG.musicPath, titleStem);
|
||
if (found) filePath = found;
|
||
else {
|
||
const detail = `Nicht gefunden: ${path.basename(ndSong.path || '')}`;
|
||
log(jobId, `⚠ ${detail}`);
|
||
errorDetails.push(detail);
|
||
errors++; continue;
|
||
}
|
||
}
|
||
|
||
const fileExt = path.extname(filePath);
|
||
const tmpFile = filePath.slice(0, -fileExt.length) + '.sorttmp' + fileExt;
|
||
|
||
// -map_metadata 0 preserves all existing tags; individual -metadata flags override only sort ones
|
||
await new Promise((resolve, reject) => {
|
||
const ff = spawn('ffmpeg', [
|
||
'-i', filePath,
|
||
'-map', '0:a', '-map', '0:v?',
|
||
'-c', 'copy', '-map_metadata', '0',
|
||
'-metadata', `ARTISTSORT=${artistSort}`,
|
||
'-metadata', `ALBUMARTISTSORT=${artistSort}`,
|
||
tmpFile, '-y', '-loglevel', 'error',
|
||
]);
|
||
let ffErr = '';
|
||
ff.stderr.on('data', d => ffErr += d.toString());
|
||
ff.on('error', reject);
|
||
ff.on('close', code => code === 0 ? resolve() : reject(new Error(`ffmpeg exit ${code}: ${ffErr.slice(-200)}`)));
|
||
});
|
||
fs.renameSync(tmpFile, filePath);
|
||
|
||
// Rename the file itself: keep track prefix + title, replace artist segment.
|
||
// Convention: {NN - }Artist - Title.ext (separator may be " - " or " – ")
|
||
const oldBasename = path.basename(filePath);
|
||
const oldStem = oldBasename.slice(0, -fileExt.length);
|
||
// Extract leading track prefix (e.g. "01 - " or "01-15 – ")
|
||
const trackPrefixMatch = oldStem.match(/^(\d[\d\-]*\s*[-–—]\s*)/);
|
||
const trackPrefix = trackPrefixMatch ? trackPrefixMatch[1] : '';
|
||
// Everything after the track prefix: "OldArtist - Title" or just "Title"
|
||
const afterPrefix = oldStem.slice(trackPrefix.length);
|
||
// Split on first " - " or " – ": if 2+ segments, first is old artist, rest is title
|
||
const segments = afterPrefix.split(/\s+[-–—]\s+/);
|
||
const titlePart = segments.length >= 2 ? segments.slice(1).join(' - ') : afterPrefix;
|
||
const safeArtistFile = sanitize(artistSort.split(/[,;&]/)[0].trim());
|
||
const safeTitlePart = sanitize(titlePart);
|
||
const newBasename = `${trackPrefix}${safeArtistFile} - ${safeTitlePart}${fileExt}`;
|
||
|
||
if (newBasename !== oldBasename) {
|
||
const renamedPath = path.join(path.dirname(filePath), newBasename);
|
||
if (!fs.existsSync(renamedPath)) {
|
||
fs.renameSync(filePath, renamedPath);
|
||
filePath = renamedPath;
|
||
}
|
||
}
|
||
|
||
// Move to correct artist/album folder: {musicPath}/{safeArtistDir}/{albumName}/
|
||
const oldAlbumDir = path.dirname(filePath);
|
||
const oldArtistDir = path.dirname(oldAlbumDir);
|
||
const albumName = path.basename(oldAlbumDir);
|
||
const newAlbumDir = path.join(CONFIG.musicPath, safeArtistDir, albumName);
|
||
|
||
if (newAlbumDir !== oldAlbumDir) {
|
||
fs.mkdirSync(newAlbumDir, { recursive: true });
|
||
const destFile = path.join(newAlbumDir, path.basename(filePath));
|
||
if (!fs.existsSync(destFile)) fs.renameSync(filePath, destFile);
|
||
// Clean up empty old dirs
|
||
try {
|
||
if (fs.readdirSync(oldAlbumDir).filter(f => !f.startsWith('.')).length === 0) {
|
||
fs.rmdirSync(oldAlbumDir);
|
||
if (fs.readdirSync(oldArtistDir).filter(f => !f.startsWith('.')).length === 0)
|
||
fs.rmdirSync(oldArtistDir);
|
||
}
|
||
} catch {}
|
||
}
|
||
|
||
done++;
|
||
updateJob(jobId, { progress: 10 + Math.round((done / songs.length) * 80), message: `${done}/${songs.length} Songs aktualisiert…` });
|
||
log(jobId, `✅ ${ndSong.title}`);
|
||
} catch (e) {
|
||
const detail = `${ndSong.title}: ${e.message}`;
|
||
log(jobId, `❌ ${detail}`);
|
||
errorDetails.push(detail);
|
||
errors++;
|
||
}
|
||
}
|
||
|
||
// Trigger Navidrome rescan
|
||
try {
|
||
const { s, t } = mkTok();
|
||
await fetch(`${ndUrl}/rest/startScan?u=${encodeURIComponent(user)}&t=${t}&s=${s}&v=1.16.1&c=novasonic&f=json`, { signal: AbortSignal.timeout(5000) });
|
||
} catch {}
|
||
|
||
const firstErr = errorDetails[0] ? ` (${errorDetails[0]})` : '';
|
||
const msg = errors > 0
|
||
? `${done} aktualisiert, ${errors} Fehler${firstErr}`
|
||
: `${done} Songs aktualisiert`;
|
||
updateJob(jobId, { status: 'done', progress: 100, message: msg });
|
||
})().catch(e => updateJob(jobId, { status: 'error', message: e.message }));
|
||
});
|
||
|
||
app.get('/api/status/:jobId', (req, res) => {
|
||
const job = jobs.get(req.params.jobId);
|
||
if (!job) return res.status(404).json({ error: 'Job not found' });
|
||
res.json(job);
|
||
});
|
||
|
||
app.get('/api/jobs', (req, res) => {
|
||
res.json(Array.from(jobs.values()).sort((a, b) => b.createdAt - a.createdAt).slice(0, 50));
|
||
});
|
||
|
||
// ─── SOUNDCLOUD RESOLVE ──────────────────────────────────────────────────────
|
||
app.post('/api/soundcloud/resolve', async (req, res) => {
|
||
const { url } = req.body;
|
||
if (!url || !url.includes('soundcloud.com')) return res.status(400).json({ error: 'SoundCloud URL required' });
|
||
try {
|
||
const { execFile } = require('child_process');
|
||
const data = await new Promise((resolve, reject) => {
|
||
execFile(
|
||
CONFIG.ytdlpBin,
|
||
['--flat-playlist', '--dump-single-json', '--no-warnings', url],
|
||
{ timeout: 30000, maxBuffer: 5 * 1024 * 1024 },
|
||
(err, stdout, stderr) => {
|
||
if (err) return reject(new Error(`yt-dlp: ${stderr?.trim() || err.message}`));
|
||
try { resolve(JSON.parse(stdout.trim())); }
|
||
catch { reject(new Error('yt-dlp: ungültige Ausgabe')); }
|
||
}
|
||
);
|
||
});
|
||
|
||
const isPlaylist = data._type === 'playlist' || Array.isArray(data.entries);
|
||
if (isPlaylist) {
|
||
const entries = data.entries || [];
|
||
const tracks = entries.map(e => ({
|
||
trackName: e.title || '',
|
||
artistName: e.uploader || e.artist || data.uploader || '',
|
||
artworkUrl: e.thumbnail || '',
|
||
duration: e.duration || 0,
|
||
genre: e.genre || '',
|
||
album: (e.album && !e.album.startsWith('[')) ? e.album : (e.title || ''),
|
||
sourceUrl: e.url || e.webpage_url || '',
|
||
}));
|
||
res.json({
|
||
type: 'playlist',
|
||
name: data.title || data.uploader || 'SoundCloud Playlist',
|
||
artist: data.uploader || '',
|
||
artworkUrl: data.thumbnail || tracks[0]?.artworkUrl || '',
|
||
tracks,
|
||
});
|
||
} else {
|
||
// Filter yt-dlp placeholder values — treat them as empty
|
||
const scAlbum = (data.album && !data.album.startsWith('[')) ? data.album : '';
|
||
const track = {
|
||
trackName: data.title || '',
|
||
artistName: data.uploader || data.artist || '',
|
||
artworkUrl: data.thumbnail || '',
|
||
duration: data.duration || 0,
|
||
genre: data.genre || '',
|
||
// Use track title as album for singles with no real album
|
||
album: scAlbum || data.title || '',
|
||
year: data.upload_date ? parseInt(data.upload_date.slice(0, 4), 10) : undefined,
|
||
sourceUrl: url,
|
||
};
|
||
res.json({
|
||
type: 'track',
|
||
name: track.trackName,
|
||
artist: track.artistName,
|
||
artworkUrl: track.artworkUrl,
|
||
tracks: [track],
|
||
});
|
||
}
|
||
} catch (e) {
|
||
console.error('[soundcloud/resolve]', e.message);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
|
||
// ─── MUSICBRAINZ LOOKUP ──────────────────────────────────────────────────────
|
||
app.get('/api/musicbrainz/lookup', async (req, res) => {
|
||
const { artist, title } = req.query;
|
||
if (!artist || !title) return res.status(400).json({ error: 'artist and title required' });
|
||
try {
|
||
// Use only the first artist — MB won't match "VXLLAIN, iGRES, ENXK" against "VXLLAIN feat. iGRES & ENXK"
|
||
const firstArtist = artist.split(/[,;&•]/)[0].trim().replace(/"/g, '');
|
||
const query = `recording:"${title.replace(/"/g, '')}" AND artistname:"${firstArtist}"`;
|
||
const url = `https://musicbrainz.org/ws/2/recording/?query=${encodeURIComponent(query)}&fmt=json&limit=5`;
|
||
const r = await fetch(url, { headers: { 'User-Agent': 'NovaSonic/1.0 (me_honeyy@proton.me)' }, signal: AbortSignal.timeout(10000) });
|
||
if (!r.ok) return res.status(502).json({ error: `MusicBrainz ${r.status}` });
|
||
const data = await r.json();
|
||
const recordings = data.recordings || [];
|
||
if (!recordings.length) return res.json({ found: false });
|
||
|
||
const rec = recordings[0];
|
||
const release = (rec.releases || [])[0];
|
||
const mbArtist = (rec['artist-credit'] || []).map(c => c.name || c.artist?.name).filter(Boolean).join('; ');
|
||
const genre = (rec.genres || rec.tags || []).sort((a, b) => (b.count||0) - (a.count||0))[0]?.name || '';
|
||
const year = release?.date ? release.date.slice(0, 4) : '';
|
||
const trackNum = release?.media?.[0]?.['track-offset'] != null
|
||
? (release.media[0]['track-offset'] + 1) : undefined;
|
||
const totalTracks = release?.media?.[0]?.['track-count'] || undefined;
|
||
const coverUrl = release?.id ? `https://coverartarchive.org/release/${release.id}/front` : null;
|
||
res.json({
|
||
found: true,
|
||
title: rec.title || title,
|
||
artist: mbArtist || artist,
|
||
album: release?.title || '',
|
||
year: year ? parseInt(year, 10) : undefined,
|
||
trackNum: trackNum,
|
||
totalTracks: totalTracks,
|
||
genre: genre,
|
||
coverUrl: coverUrl,
|
||
mbid: rec.id,
|
||
});
|
||
} catch (e) {
|
||
console.error('[musicbrainz/lookup]', e.message);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// ─── SORT TAGS READ ──────────────────────────────────────────────────────────
|
||
app.get('/api/song-sorttags', async (req, res) => {
|
||
const { ndUrl, user, pass, songId } = req.query;
|
||
if (!ndUrl || !user || !pass || !songId) return res.status(400).json({ error: 'ndUrl, user, pass, songId required' });
|
||
let filePath;
|
||
try {
|
||
const salt = Math.random().toString(36).slice(2, 10);
|
||
const token = crypto.createHash('md5').update(pass + salt).digest('hex');
|
||
const ndRes = await fetch(`${ndUrl}/rest/getSong?id=${songId}&u=${encodeURIComponent(user)}&t=${token}&s=${salt}&v=1.16.1&c=novasonic&f=json`, { signal: AbortSignal.timeout(8000) });
|
||
const nd = await ndRes.json();
|
||
filePath = nd?.['subsonic-response']?.song?.path;
|
||
if (!filePath) return res.status(404).json({ error: 'Song not found' });
|
||
} catch (e) { return res.status(502).json({ error: e.message }); }
|
||
if (!path.isAbsolute(filePath)) filePath = path.join(CONFIG.musicPath, filePath);
|
||
if (!fs.existsSync(filePath)) {
|
||
const fileName = path.basename(filePath);
|
||
const rebased = _rebasePath(filePath, CONFIG.musicPath);
|
||
const rebasedDir = rebased ? path.dirname(rebased) : null;
|
||
const titleStem = fileName.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '').toLowerCase();
|
||
const found = rebased
|
||
|| _findFileRecursive(CONFIG.musicPath, fileName)
|
||
|| _findFileInDir(rebasedDir || path.dirname(filePath), fileName)
|
||
|| _findFileByStemOrRomaji(CONFIG.musicPath, titleStem);
|
||
if (found) filePath = found; else return res.status(404).json({ error: 'File not found' });
|
||
}
|
||
try {
|
||
const out = await new Promise((resolve, reject) => {
|
||
const proc = spawn('ffprobe', ['-v', 'quiet', '-print_format', 'json', '-show_entries', 'format_tags', filePath]);
|
||
let buf = '';
|
||
proc.stdout.on('data', d => buf += d);
|
||
proc.on('error', reject);
|
||
proc.on('close', () => { try { resolve(JSON.parse(buf)); } catch { resolve({}); } });
|
||
});
|
||
const tags = out?.format?.tags || {};
|
||
const findTag = (...keys) => { for (const k of keys) { const v = tags[k] || tags[k.toLowerCase()] || tags[k.toUpperCase()]; if (v) return v; } return ''; };
|
||
res.json({
|
||
titleSort: findTag('TITLESORT', 'titlesort'),
|
||
artistSort: findTag('ARTISTSORT', 'artistsort'),
|
||
albumArtistSort: findTag('ALBUMARTISTSORT', 'albumartistsort', 'TSO2'),
|
||
albumSort: findTag('ALBUMSORT', 'albumsort'),
|
||
});
|
||
} catch (e) { res.status(500).json({ error: e.message }); }
|
||
});
|
||
|
||
// ─── PLAYLIST MIGRATION HELPERS ──────────────────────────────────────────────
|
||
// Used to preserve playlist membership when a file is renamed/moved during edit.
|
||
|
||
async function _ndApi(ndUrl, user, pass, method, extra = '') {
|
||
const s = Math.random().toString(36).slice(2, 10);
|
||
const t = crypto.createHash('md5').update(pass + s).digest('hex');
|
||
const r = await fetch(
|
||
`${ndUrl}/rest/${method}?u=${encodeURIComponent(user)}&t=${t}&s=${s}&v=1.16.1&c=novasonic&f=json${extra}`,
|
||
{ signal: AbortSignal.timeout(8000) }
|
||
);
|
||
return r.json();
|
||
}
|
||
|
||
async function _playlistsContaining(ndUrl, user, pass, songId) {
|
||
try {
|
||
const d = await _ndApi(ndUrl, user, pass, 'getPlaylists');
|
||
const pls = [].concat(d?.['subsonic-response']?.playlists?.playlist || []);
|
||
const affected = [];
|
||
for (const pl of pls) {
|
||
const det = await _ndApi(ndUrl, user, pass, 'getPlaylist', `&id=${pl.id}`);
|
||
const entries = [].concat(det?.['subsonic-response']?.playlist?.entry || []);
|
||
if (entries.some(e => e.id === songId)) affected.push(pl.id);
|
||
}
|
||
return affected;
|
||
} catch { return []; }
|
||
}
|
||
|
||
// Poll Navidrome until the renamed song appears (up to ~5s)
|
||
async function _findSongAfterRename(ndUrl, user, pass, title, artist, oldId) {
|
||
for (let i = 0; i < 5; i++) {
|
||
if (i > 0) await new Promise(r => setTimeout(r, 1200));
|
||
try {
|
||
const q = encodeURIComponent(`${artist} ${title}`.trim().slice(0, 100));
|
||
const d = await _ndApi(ndUrl, user, pass, 'search3', `&query=${q}&songCount=20&artistCount=0&albumCount=0`);
|
||
const songs = [].concat(d?.['subsonic-response']?.searchResult3?.song || []);
|
||
const match = songs.find(s =>
|
||
s.id !== oldId &&
|
||
(s.title || '').toLowerCase() === (title || '').toLowerCase()
|
||
);
|
||
if (match) return match;
|
||
} catch {}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
async function _migratePlaylists(ndUrl, user, pass, plIds, oldId, newId) {
|
||
for (const plId of plIds) {
|
||
try {
|
||
const det = await _ndApi(ndUrl, user, pass, 'getPlaylist', `&id=${plId}`);
|
||
const entries = [].concat(det?.['subsonic-response']?.playlist?.entry || []);
|
||
const idx = entries.findIndex(e => e.id === oldId);
|
||
let extra = `&songIdToAdd=${newId}`;
|
||
if (idx >= 0) extra += `&songIndexToRemove=${idx}`;
|
||
await _ndApi(ndUrl, user, pass, 'updatePlaylist', `&playlistId=${plId}${extra}`);
|
||
} catch {}
|
||
}
|
||
}
|
||
|
||
// ─── METADATA EDIT ───────────────────────────────────────────────────────────
|
||
app.post('/api/edit-metadata', async (req, res) => {
|
||
const { ndUrl, user, pass, songId, title, artist, albumArtist, album, year, trackNum, totalTracks,
|
||
discNum, discTotal, genre, artworkBase64, artworkMime, artworkUrl: newArtworkUrl,
|
||
titleSort, artistSort, albumArtistSort, albumSort } = req.body;
|
||
if (!ndUrl || !user || !pass || !songId) return res.status(400).json({ error: 'ndUrl, user, pass, songId required' });
|
||
|
||
// Normalize artist separators — accept •, ·, ;, , and rejoin canonically
|
||
const normalArtist = _normalizeArtists(artist, ';');
|
||
const normalAlbumArtist = _normalizeArtists(albumArtist, ', ');
|
||
|
||
// Convert Japanese names to romaji for storage
|
||
const romajiArtist = normalArtist ? romajiForStorage(normalArtist) || normalArtist : normalArtist;
|
||
const romajiAlbumArtist = normalAlbumArtist ? romajiForStorage(normalAlbumArtist) || normalAlbumArtist : normalAlbumArtist;
|
||
const romajiTitle = title ? romajiForStorage(title) || title : title;
|
||
const romajiAlbum = album ? romajiForStorage(album) || album : album;
|
||
|
||
// Resolve file path from Navidrome
|
||
let filePath;
|
||
let ndSong;
|
||
try {
|
||
const salt = Math.random().toString(36).slice(2, 10);
|
||
const token = crypto.createHash('md5').update(pass + salt).digest('hex');
|
||
const ndApi = `${ndUrl}/rest/getSong?id=${songId}&u=${encodeURIComponent(user)}&t=${token}&s=${salt}&v=1.16.1&c=novasonic&f=json`;
|
||
const ndRes = await fetch(ndApi, { signal: AbortSignal.timeout(8000) });
|
||
const ndData = await ndRes.json();
|
||
ndSong = ndData?.['subsonic-response']?.song;
|
||
filePath = ndSong?.path;
|
||
if (!filePath) return res.status(404).json({ error: 'Song not found in Navidrome' });
|
||
} catch (e) {
|
||
return res.status(502).json({ error: `Navidrome lookup failed: ${e.message}` });
|
||
}
|
||
|
||
// Collect playlists containing this song BEFORE the edit so we can restore membership
|
||
// if the file gets renamed/moved (which changes the Navidrome song ID).
|
||
const affectedPlaylists = await _playlistsContaining(ndUrl, user, pass, songId).catch(() => []);
|
||
|
||
// If not absolute, try relative to music root
|
||
if (!path.isAbsolute(filePath)) filePath = path.join(CONFIG.musicPath, filePath);
|
||
|
||
// Fallback: Navidrome may return a path from a different container mount.
|
||
// 1. Rebase: strip leading path components and rejoin under CONFIG.musicPath.
|
||
// 2. Exact recursive search under CONFIG.musicPath.
|
||
// 3. Fuzzy dir search: same dir, matching track-number prefix or title stem.
|
||
if (!fs.existsSync(filePath)) {
|
||
const rebased = _rebasePath(filePath, CONFIG.musicPath);
|
||
const fileName = path.basename(filePath);
|
||
const rebasedDir = rebased ? path.dirname(rebased) : null;
|
||
// Also check the original dir — the file may have been renamed (e.g. artist added to filename)
|
||
// but Navidrome's index is stale and still points to the old name.
|
||
const originalDir = path.dirname(filePath);
|
||
const titleStem = fileName.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '').toLowerCase();
|
||
const found = rebased
|
||
|| _findFileRecursive(CONFIG.musicPath, fileName)
|
||
|| _findFileInDir(rebasedDir || originalDir, fileName)
|
||
|| _findFileByStemOrRomaji(CONFIG.musicPath, titleStem);
|
||
if (found) { filePath = found; }
|
||
else return res.status(404).json({ error: `File not found: ${filePath} (music root: ${CONFIG.musicPath})` });
|
||
}
|
||
|
||
// Resolve artwork: base64 > URL
|
||
let artFile = null;
|
||
try {
|
||
if (artworkBase64) {
|
||
artFile = filePath + '.arttmp';
|
||
const mime = artworkMime || 'image/jpeg';
|
||
const ext = mime.includes('png') ? 'png' : 'jpg';
|
||
artFile = filePath + `.arttmp.${ext}`;
|
||
fs.writeFileSync(artFile, Buffer.from(artworkBase64, 'base64'));
|
||
} else if (newArtworkUrl) {
|
||
artFile = filePath + '.arttmp.jpg';
|
||
// Download artwork URL (may redirect — use fetch which follows redirects)
|
||
const artRes = await fetch(newArtworkUrl, { signal: AbortSignal.timeout(15000) });
|
||
if (artRes.ok) {
|
||
const buf = Buffer.from(await artRes.arrayBuffer());
|
||
fs.writeFileSync(artFile, buf);
|
||
} else {
|
||
artFile = null;
|
||
}
|
||
}
|
||
} catch { artFile = null; }
|
||
|
||
const fileExt = path.extname(filePath);
|
||
const tmpFile = filePath.slice(0, -fileExt.length) + '.edittmp' + fileExt;
|
||
|
||
try {
|
||
await new Promise((resolve, reject) => {
|
||
const ffArgs = ['-i', filePath];
|
||
if (artFile) ffArgs.push('-i', artFile);
|
||
ffArgs.push('-map', '0:a');
|
||
// Always carry cover art: new file if provided, otherwise preserve existing embedded art
|
||
if (artFile) {
|
||
ffArgs.push('-map', '1:v');
|
||
} else {
|
||
ffArgs.push('-map', '0:v?'); // '?' = optional, no error if file has no cover
|
||
}
|
||
ffArgs.push('-c', 'copy', '-map_metadata', '-1', '-id3v2_version', '3');
|
||
// Main tags: store original user input (may be Japanese — Apple Music / other apps see authentic text)
|
||
if (title) ffArgs.push('-metadata', `title=${title}`);
|
||
if (normalArtist) ffArgs.push('-metadata', `artist=${normalArtist}`);
|
||
const resolvedAlbumArtist = normalAlbumArtist || (normalArtist ? normalArtist.split(';')[0].trim() : null);
|
||
if (resolvedAlbumArtist) ffArgs.push('-metadata', `album_artist=${resolvedAlbumArtist}`);
|
||
if (album) ffArgs.push('-metadata', `album=${album}`);
|
||
// Sort tags: manual override from frontend > auto-computed romaji
|
||
const effectiveTitleSort = titleSort !== undefined ? titleSort : (romajiTitle !== title ? romajiTitle : null);
|
||
const effectiveArtistSort = artistSort !== undefined ? artistSort : (romajiArtist !== normalArtist ? romajiArtist : null);
|
||
const resolvedRomajiAA = romajiAlbumArtist || (romajiArtist ? romajiArtist.split(';')[0].trim() : null);
|
||
const effectiveAlbumArtistSort = albumArtistSort !== undefined ? albumArtistSort : (resolvedRomajiAA !== resolvedAlbumArtist ? resolvedRomajiAA : null);
|
||
const effectiveAlbumSort = albumSort !== undefined ? albumSort : (romajiAlbum !== album ? romajiAlbum : null);
|
||
if (effectiveTitleSort) ffArgs.push('-metadata', `TITLESORT=${effectiveTitleSort}`);
|
||
if (effectiveArtistSort) ffArgs.push('-metadata', `ARTISTSORT=${effectiveArtistSort}`);
|
||
if (effectiveAlbumArtistSort) ffArgs.push('-metadata', `ALBUMARTISTSORT=${effectiveAlbumArtistSort}`);
|
||
if (effectiveAlbumSort) ffArgs.push('-metadata', `ALBUMSORT=${effectiveAlbumSort}`);
|
||
if (year) ffArgs.push('-metadata', `date=${year}`);
|
||
if (trackNum) ffArgs.push('-metadata', `track=${totalTracks ? `${trackNum}/${totalTracks}` : String(trackNum)}`);
|
||
if (totalTracks) ffArgs.push('-metadata', `totaltracks=${String(totalTracks)}`);
|
||
if (discNum) ffArgs.push('-metadata', `disc=${discTotal ? `${discNum}/${discTotal}` : String(discNum)}`);
|
||
if (genre) ffArgs.push('-metadata', `genre=${genre}`);
|
||
ffArgs.push('-metadata:s:v', 'title=Album cover', '-metadata:s:v', 'comment=Cover (front)');
|
||
ffArgs.push(tmpFile, '-y', '-loglevel', 'error');
|
||
|
||
const ff = spawn('ffmpeg', ffArgs);
|
||
let ffErr = '';
|
||
ff.stderr.on('data', d => ffErr += d.toString());
|
||
ff.on('error', reject);
|
||
ff.on('close', code => {
|
||
if (code === 0 && fs.existsSync(tmpFile)) resolve();
|
||
else reject(new Error(`ffmpeg exit ${code}: ${ffErr.slice(-300)}`));
|
||
});
|
||
});
|
||
|
||
fs.renameSync(tmpFile, filePath);
|
||
if (artFile) try { fs.unlinkSync(artFile); } catch {}
|
||
|
||
// ── Post-save: rename file and/or move to correct artist/album folder ──
|
||
let currentFile = filePath;
|
||
|
||
// 1. Rename file if title changed — convention: {01 - }?{Artist} - {Title}.ext
|
||
if (title) {
|
||
const safeTitle = sanitize(romajiTitle || title);
|
||
const fileArtist = (romajiArtist || ndSong?.artist || '').replace(/;/g, ',');
|
||
const safeArtistPart = fileArtist ? sanitize(fileArtist) + ' - ' : '';
|
||
const prefix = trackNum ? String(trackNum).padStart(2, '0') + ' - ' : '';
|
||
const newName = `${prefix}${safeArtistPart}${safeTitle}${fileExt}`;
|
||
const newPath = path.join(path.dirname(currentFile), newName);
|
||
if (newPath !== currentFile && !fs.existsSync(newPath)) {
|
||
try { fs.renameSync(currentFile, newPath); currentFile = newPath; }
|
||
catch (e) { console.error('[edit-metadata] file rename:', e.message); }
|
||
}
|
||
}
|
||
|
||
// 2. Move to new artist/album folder when albumArtist or album changed
|
||
const oldAlbumDir = path.dirname(currentFile);
|
||
const oldArtistDir = path.dirname(oldAlbumDir);
|
||
const newAlbumName = romajiAlbum ? sanitize(romajiAlbum) : path.basename(oldAlbumDir);
|
||
const newArtistName = (albumArtistSort || romajiAlbumArtist) ? sanitize((albumArtistSort || romajiAlbumArtist).split(/[,;&]/)[0].trim()) : path.basename(oldArtistDir);
|
||
const newDir = path.join(CONFIG.musicPath, newArtistName, newAlbumName);
|
||
|
||
if (newDir !== oldAlbumDir) {
|
||
try {
|
||
fs.mkdirSync(newDir, { recursive: true });
|
||
const destFile = path.join(newDir, path.basename(currentFile));
|
||
if (!fs.existsSync(destFile)) {
|
||
fs.renameSync(currentFile, destFile);
|
||
currentFile = destFile;
|
||
}
|
||
// Remove old album dir if now empty, then old artist dir if also empty
|
||
const oldAlbumLeft = fs.readdirSync(oldAlbumDir).filter(f => !f.startsWith('.'));
|
||
if (oldAlbumLeft.length === 0) {
|
||
try { fs.rmdirSync(oldAlbumDir); } catch {}
|
||
try {
|
||
const oldArtistLeft = fs.readdirSync(oldArtistDir).filter(f => !f.startsWith('.'));
|
||
if (oldArtistLeft.length === 0) fs.rmdirSync(oldArtistDir);
|
||
} catch {}
|
||
}
|
||
} catch (e) { console.error('[edit-metadata] move:', e.message); }
|
||
} else if (romajiAlbum && path.basename(oldAlbumDir) !== sanitize(romajiAlbum)) {
|
||
// Only album name changed (no artist move) — rename album folder in place
|
||
const renamedDir = path.join(oldArtistDir, sanitize(romajiAlbum));
|
||
if (!fs.existsSync(renamedDir)) {
|
||
try { fs.renameSync(oldAlbumDir, renamedDir); }
|
||
catch (e) { console.error('[edit-metadata] folder rename:', e.message); }
|
||
}
|
||
}
|
||
|
||
// Trigger Navidrome rescan
|
||
try {
|
||
const salt2 = Math.random().toString(36).slice(2, 10);
|
||
const tok2 = crypto.createHash('md5').update(pass + salt2).digest('hex');
|
||
await fetch(`${ndUrl}/rest/startScan?u=${encodeURIComponent(user)}&t=${tok2}&s=${salt2}&v=1.16.1&c=novasonic&f=json`, { signal: AbortSignal.timeout(5000) });
|
||
} catch {}
|
||
|
||
// Restore playlist membership after rename/move — the rescan gives the renamed song a new ID
|
||
if (affectedPlaylists.length > 0) {
|
||
const effectiveTitle = title || ndSong?.title || '';
|
||
const effectiveArtist = (artist || ndSong?.artist || '').split(';')[0].trim();
|
||
const newSong = await _findSongAfterRename(ndUrl, user, pass, effectiveTitle, effectiveArtist, songId);
|
||
if (newSong && newSong.id !== songId) {
|
||
await _migratePlaylists(ndUrl, user, pass, affectedPlaylists, songId, newSong.id);
|
||
}
|
||
}
|
||
|
||
res.json({ ok: true });
|
||
} catch (e) {
|
||
try { if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile); } catch {}
|
||
if (artFile) try { fs.unlinkSync(artFile); } catch {}
|
||
console.error('[edit-metadata]', e.message);
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// ─── SONG DELETE ─────────────────────────────────────────────────────────────
|
||
// Deletes a song file from disk, then prunes empty album/artist folders.
|
||
// Folder pruning is strictly depth-limited: only the direct album parent and its
|
||
// artist parent are ever touched — no recursive delete, no removing the music root.
|
||
app.post('/api/delete-song', async (req, res) => {
|
||
const { ndUrl, user, pass, songId } = req.body;
|
||
if (!ndUrl || !user || !pass || !songId)
|
||
return res.status(400).json({ error: 'ndUrl, user, pass, songId required' });
|
||
|
||
// Resolve the file path from Navidrome
|
||
let filePath;
|
||
try {
|
||
const salt = Math.random().toString(36).slice(2, 10);
|
||
const token = crypto.createHash('md5').update(pass + salt).digest('hex');
|
||
const ndRes = await fetch(
|
||
`${ndUrl}/rest/getSong?id=${songId}&u=${encodeURIComponent(user)}&t=${token}&s=${salt}&v=1.16.1&c=novasonic&f=json`,
|
||
{ signal: AbortSignal.timeout(8000) }
|
||
);
|
||
const ndData = await ndRes.json();
|
||
filePath = ndData?.['subsonic-response']?.song?.path;
|
||
if (!filePath) return res.status(404).json({ error: 'Song not found in Navidrome' });
|
||
} catch (e) {
|
||
return res.status(502).json({ error: `Navidrome lookup failed: ${e.message}` });
|
||
}
|
||
|
||
if (!path.isAbsolute(filePath)) filePath = path.join(CONFIG.musicPath, filePath);
|
||
if (!fs.existsSync(filePath)) {
|
||
const fileName = path.basename(filePath);
|
||
const titleStem = fileName.replace(AUDIO_EXT_RE, '').replace(/^\d+\s*-\s*/, '').toLowerCase();
|
||
const found = _rebasePath(filePath, CONFIG.musicPath)
|
||
|| _findFileRecursive(CONFIG.musicPath, fileName)
|
||
|| _findFileInDir(path.dirname(filePath), fileName)
|
||
|| _findFileByStemOrRomaji(CONFIG.musicPath, titleStem);
|
||
if (found) filePath = found;
|
||
else return res.status(404).json({ error: 'File not found on disk' });
|
||
}
|
||
|
||
// Safety: file must be inside the music root and must be an audio file
|
||
const realFile = path.resolve(filePath);
|
||
const realRoot = path.resolve(CONFIG.musicPath);
|
||
const rootSlash = realRoot.endsWith(path.sep) ? realRoot : realRoot + path.sep;
|
||
if (!realFile.startsWith(rootSlash))
|
||
return res.status(403).json({ error: 'Path outside music root — refusing to delete' });
|
||
if (!AUDIO_EXT_RE.test(path.extname(realFile)))
|
||
return res.status(400).json({ error: 'Target is not a recognised audio file' });
|
||
|
||
const albumDir = path.dirname(realFile);
|
||
const artistDir = path.dirname(albumDir);
|
||
|
||
// Delete the file
|
||
try { fs.unlinkSync(realFile); }
|
||
catch (e) { return res.status(500).json({ error: `Could not delete file: ${e.message}` }); }
|
||
|
||
// Prune empty album folder — only if it is a direct child of the music root hierarchy
|
||
// (not the root itself) and only when truly empty (no hidden files either)
|
||
if (albumDir !== realRoot && albumDir.startsWith(rootSlash)) {
|
||
try {
|
||
const albumLeft = fs.readdirSync(albumDir).filter(f => !f.startsWith('.'));
|
||
if (albumLeft.length === 0) {
|
||
fs.rmdirSync(albumDir); // throws if not empty — extra safety net
|
||
// Prune empty artist folder only if it too is directly inside the music root
|
||
if (artistDir !== realRoot && artistDir.startsWith(rootSlash)) {
|
||
try {
|
||
const artistLeft = fs.readdirSync(artistDir).filter(f => !f.startsWith('.'));
|
||
if (artistLeft.length === 0) fs.rmdirSync(artistDir);
|
||
} catch {}
|
||
}
|
||
}
|
||
} catch {}
|
||
}
|
||
|
||
// Trigger Navidrome rescan so the deleted song disappears from the UI
|
||
try {
|
||
const s2 = Math.random().toString(36).slice(2, 10);
|
||
const t2 = crypto.createHash('md5').update(pass + s2).digest('hex');
|
||
await fetch(
|
||
`${ndUrl}/rest/startScan?u=${encodeURIComponent(user)}&t=${t2}&s=${s2}&v=1.16.1&c=novasonic&f=json`,
|
||
{ signal: AbortSignal.timeout(5000) }
|
||
);
|
||
} catch {}
|
||
|
||
res.json({ ok: true });
|
||
});
|
||
|
||
// ─── ABS PROXY ───────────────────────────────────────────────────────────────
|
||
// Forwards API calls to Audiobookshelf to avoid CORS restrictions in the browser.
|
||
// The browser sends X-ABS-URL and X-ABS-Token headers; audio streaming uses
|
||
// direct <audio src> URLs and is unaffected by CORS.
|
||
app.all('/api/abs-proxy/*path', async (req, res) => {
|
||
const absBase = req.headers['x-abs-url'];
|
||
const absToken = req.headers['x-abs-token'];
|
||
if (!absBase || !absToken) { res.status(400).json({ error: 'Missing X-ABS-URL or X-ABS-Token' }); return; }
|
||
|
||
// Strip the proxy prefix to get the ABS path (e.g. /api/me, /api/libraries/…)
|
||
const absPath = req.path.replace(/^\/api\/abs-proxy/, '');
|
||
const qs = Object.keys(req.query).length ? '?' + new URLSearchParams(req.query).toString() : '';
|
||
const url = `${absBase}${absPath}${qs}`;
|
||
|
||
const fwdHeaders = { 'Authorization': `Bearer ${absToken}`, 'Content-Type': 'application/json' };
|
||
const opts = { method: req.method, headers: fwdHeaders };
|
||
if (req.method !== 'GET' && req.method !== 'HEAD' && req.body && Object.keys(req.body).length) {
|
||
opts.body = JSON.stringify(req.body);
|
||
}
|
||
|
||
try {
|
||
const upstream = await fetch(url, opts);
|
||
const text = await upstream.text();
|
||
res.status(upstream.status)
|
||
.setHeader('Content-Type', upstream.headers.get('Content-Type') || 'application/json')
|
||
.send(text);
|
||
} catch (e) {
|
||
res.status(502).json({ error: `ABS proxy error: ${e.message}` });
|
||
}
|
||
});
|
||
|
||
// ─── START ────────────────────────────────────────────────────────────────────
|
||
app.listen(CONFIG.port, () => {
|
||
console.log(`\n🎵 NovaSonic Backend running on port ${CONFIG.port}`);
|
||
console.log(` Music folder : ${CONFIG.musicPath}`);
|
||
console.log(` Audio format : ${CONFIG.audioFmt} (quality ${CONFIG.audioQuality})`);
|
||
console.log(` yt-dlp : ${ytdlpVersion}`);
|
||
console.log('');
|
||
});
|