442 lines
16 KiB
JavaScript
442 lines
16 KiB
JavaScript
/* ============================================================================
|
|
* server.js — YT Player PWA backend
|
|
*
|
|
* Runtime: Bun (https://bun.sh)
|
|
* Framework: Hono v4
|
|
* DB: libsql (concurrent SQLite fork, embedded file mode)
|
|
*
|
|
* Endpoints:
|
|
* GET /api/search?q=<query> yt-dlp search → slim card array
|
|
* GET /api/channel?c=<channel> yt-dlp channel uploads → slim card array
|
|
* GET /api/streams?v=<videoId> yt-dlp stream info → {meta, audioUrl, qualities}
|
|
* GET /api/download/:videoId proxy best progressive stream → binary
|
|
* GET /api/version { version }
|
|
* POST /api/user/sync upsert user playlists + last-seen version
|
|
* GET /api/user/data?fp=<fp> retrieve stored playlists + history
|
|
* GET /* serve frontend/public static files
|
|
*
|
|
* JSON shapes mirror the Tauri (Rust) bridge exactly so the existing app.js
|
|
* UI code works without modification in WEB mode.
|
|
* ========================================================================== */
|
|
|
|
import { Hono } from 'hono';
|
|
import { serveStatic } from 'hono/bun';
|
|
import { logger } from 'hono/logger';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { createServer } from 'node:http';
|
|
import { readFileSync, readdirSync, statSync } from 'node:fs';
|
|
import { createHash } from 'node:crypto';
|
|
import { initDb, upsertUser, recordVideoAccess, getUserData } from './db.js';
|
|
|
|
const PORT = parseInt(process.env.PORT || '3000', 10);
|
|
const APP_VERSION = process.env.APP_VERSION || '1.0.0';
|
|
const YTDLP = process.env.YTDLP_PATH || 'yt-dlp';
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// BUILD_TAG — must be DETERMINISTIC across restarts of identical code.
|
|
//
|
|
// Previously this was `Date.now().toString(36)`, which changes every time the
|
|
// process starts even if nothing was deployed (crash-loop, healthcheck
|
|
// restart, container reschedule). The frontend's checkBuildTag() polls
|
|
// /api/version and re-shows the "Update available" modal the instant the tag
|
|
// drifts — so a restarting-but-unchanged server kept re-announcing an update
|
|
// that never actually happened, and clicking "Refresh UI" (which itself
|
|
// reloads the page and re-polls) never made the prompt go away for good.
|
|
//
|
|
// Fix: hash the actual served frontend files. Identical code → identical
|
|
// hash → identical tag, no matter how many times the process restarts. A
|
|
// real deploy (changed files) still produces a new tag as intended.
|
|
// process.env.BUILD_TAG still wins if a CI pipeline already injects a git
|
|
// SHA — that's an even better source of truth than a content hash.
|
|
// ----------------------------------------------------------------------------
|
|
function computeBuildTag() {
|
|
try {
|
|
// Hash EVERY served frontend file (recursively, in sorted order), not a
|
|
// hand-picked subset — a change to any shell file (e.g. sw-update.js or
|
|
// opfs.js) must produce a new tag, or clients keep their old SW cache
|
|
// and never receive the change.
|
|
const hash = createHash('sha256');
|
|
const walk = (dir) => {
|
|
for (const name of readdirSync(dir).sort()) {
|
|
const path = `${dir}/${name}`;
|
|
if (statSync(path).isDirectory()) walk(path);
|
|
else { hash.update(path); hash.update(readFileSync(path)); }
|
|
}
|
|
};
|
|
walk('./public');
|
|
return hash.digest('hex').slice(0, 12);
|
|
} catch {
|
|
// Frontend files not readable (e.g. unit tests run outside ./public) —
|
|
// fall back to a fixed tag rather than Date.now(), so it still never
|
|
// drifts spuriously between restarts.
|
|
return 'dev-build';
|
|
}
|
|
}
|
|
|
|
const BUILD_TAG = process.env.BUILD_TAG || computeBuildTag();
|
|
|
|
const SEARCH_LIMIT = 25;
|
|
const CHANNEL_LIMIT = 60;
|
|
|
|
// ============================================================================
|
|
// yt-dlp helpers
|
|
// ============================================================================
|
|
|
|
// Run yt-dlp synchronously and return stdout as a string.
|
|
// Throws on non-zero exit.
|
|
function runYtdlp(args) {
|
|
const result = spawnSync(YTDLP, args, {
|
|
encoding: 'utf8',
|
|
maxBuffer: 32 * 1024 * 1024, // 32 MB — large channel dumps can be big
|
|
});
|
|
if (result.error) throw new Error('yt-dlp not found: ' + result.error.message);
|
|
if (result.status !== 0) {
|
|
const err = (result.stderr || '').trim();
|
|
throw new Error(err || 'yt-dlp exited with code ' + result.status);
|
|
}
|
|
return result.stdout || '';
|
|
}
|
|
|
|
// Helpers to pick the right field from a yt-dlp JSON record
|
|
function pick(obj, ...keys) {
|
|
for (const k of keys) {
|
|
const v = obj[k];
|
|
if (v && typeof v === 'string' && v.trim()) return v.trim();
|
|
}
|
|
return '';
|
|
}
|
|
|
|
function pickChannel(obj) { return pick(obj, 'channel', 'uploader'); }
|
|
function pickChannelUrl(obj) { return pick(obj, 'channel_url', 'uploader_url'); }
|
|
function pickChannelId(obj) { return pick(obj, 'channel_id', 'uploader_id'); }
|
|
|
|
// Normalise a flat-playlist yt-dlp record into the slim UI card shape
|
|
function slimEntry(j) {
|
|
const id = pick(j, 'id');
|
|
if (!id) return null;
|
|
return {
|
|
id,
|
|
title: pick(j, 'title') || '(untitled)',
|
|
channel: pickChannel(j),
|
|
channelId: pickChannelId(j),
|
|
channelUrl: pickChannelUrl(j),
|
|
duration: typeof j.duration === 'number' ? j.duration : 0,
|
|
thumbnail: `https://i.ytimg.com/vi/${id}/mqdefault.jpg`,
|
|
};
|
|
}
|
|
|
|
// Parse multi-line JSON output from yt-dlp --dump-json --flat-playlist
|
|
function parseCards(output) {
|
|
const results = [];
|
|
for (const line of output.split('\n')) {
|
|
const t = line.trim();
|
|
if (!t) continue;
|
|
try {
|
|
const j = JSON.parse(t);
|
|
const card = slimEntry(j);
|
|
if (card) results.push(card);
|
|
} catch { /* skip malformed lines */ }
|
|
}
|
|
return results;
|
|
}
|
|
|
|
// Resolve a channel identifier to a /videos URL yt-dlp can fetch
|
|
function channelToUrl(c) {
|
|
let base = c.trim();
|
|
if (!base.startsWith('http')) {
|
|
base = base.startsWith('@') ? `https://www.youtube.com/${base}`
|
|
: base.startsWith('UC') ? `https://www.youtube.com/channel/${base}`
|
|
: `https://www.youtube.com/@${base}`;
|
|
}
|
|
base = base.replace(/\/$/, '');
|
|
return base.endsWith('/videos') ? base : base + '/videos';
|
|
}
|
|
|
|
// ============================================================================
|
|
// App setup
|
|
// ============================================================================
|
|
|
|
const app = new Hono();
|
|
app.use('*', logger());
|
|
|
|
// ============================================================================
|
|
// API routes
|
|
// ============================================================================
|
|
|
|
// GET /api/version
|
|
// Returns version string + a build tag that changes on every server restart/deploy.
|
|
// Clients poll this to detect when a new build is live and prompt a reload.
|
|
app.get('/api/version', (c) =>
|
|
c.json(
|
|
{ version: APP_VERSION, buildTag: BUILD_TAG },
|
|
200,
|
|
{ 'Cache-Control': 'no-store, no-cache, must-revalidate' }
|
|
)
|
|
);
|
|
|
|
// GET /api/search?q=<query>
|
|
app.get('/api/search', async (c) => {
|
|
const q = (c.req.query('q') || '').trim();
|
|
if (!q) return c.json({ ok: false, error: 'empty query' }, 400);
|
|
|
|
try {
|
|
const out = runYtdlp([
|
|
`ytsearch${SEARCH_LIMIT}:${q}`,
|
|
'--dump-json', '--flat-playlist',
|
|
'--no-warnings', '--ignore-errors',
|
|
]);
|
|
return c.json({ ok: true, results: parseCards(out) });
|
|
} catch (err) {
|
|
return c.json({ ok: false, error: err.message }, 500);
|
|
}
|
|
});
|
|
|
|
// GET /api/channel?c=<channel>
|
|
app.get('/api/channel', async (c) => {
|
|
const chan = (c.req.query('c') || '').trim();
|
|
if (!chan) return c.json({ ok: false, error: 'missing channel' }, 400);
|
|
|
|
try {
|
|
const url = channelToUrl(chan);
|
|
const out = runYtdlp([
|
|
url,
|
|
'--dump-json', '--flat-playlist',
|
|
'--no-warnings', '--ignore-errors',
|
|
'--playlist-end', String(CHANNEL_LIMIT),
|
|
]);
|
|
const results = parseCards(out);
|
|
// Extract channel name + URL from the first record
|
|
const first = results[0];
|
|
let channelName = '', channelUrl = '';
|
|
for (const line of out.split('\n')) {
|
|
const t = line.trim();
|
|
if (!t) continue;
|
|
try {
|
|
const j = JSON.parse(t);
|
|
channelName = channelName || pickChannel(j);
|
|
channelUrl = channelUrl || pickChannelUrl(j);
|
|
if (channelName && channelUrl) break;
|
|
} catch { /* skip */ }
|
|
}
|
|
return c.json({ ok: true, channel: channelName || (first?.channel || ''), channelUrl, results });
|
|
} catch (err) {
|
|
return c.json({ ok: false, error: err.message }, 500);
|
|
}
|
|
});
|
|
|
|
// GET /api/streams?v=<videoId>
|
|
app.get('/api/streams', async (c) => {
|
|
const videoId = (c.req.query('v') || '').replace(/[/\\:?<>|*"]/g, '').trim();
|
|
if (!videoId) return c.json({ ok: false, error: 'missing videoId' }, 400);
|
|
|
|
try {
|
|
const url = `https://www.youtube.com/watch?v=${videoId}`;
|
|
const out = runYtdlp(['-J', '--no-warnings', url]);
|
|
const info = JSON.parse(out);
|
|
const formats = Array.isArray(info.formats) ? info.formats : [];
|
|
|
|
// Best audio-only stream (prefer mp4a/m4a by bitrate)
|
|
let bestAudioUrl = null;
|
|
let bestAudioScore = -1;
|
|
for (const f of formats) {
|
|
if (!f.url) continue;
|
|
const hasVideo = f.vcodec && f.vcodec !== 'none';
|
|
const hasAudio = f.acodec && f.acodec !== 'none';
|
|
if (hasVideo || !hasAudio) continue;
|
|
let score = f.abr || 0;
|
|
if (f.acodec && f.acodec.includes('mp4a')) score += 1000;
|
|
if (score > bestAudioScore) { bestAudioScore = score; bestAudioUrl = f.url; }
|
|
}
|
|
|
|
// Quality list — progressive (single-file, hasAudio) first, then adaptive
|
|
const qualities = [];
|
|
const seen = new Set();
|
|
for (const wantProg of [true, false]) {
|
|
for (const f of formats) {
|
|
if (!f.url) continue;
|
|
const hasVideo = f.vcodec && f.vcodec !== 'none';
|
|
const hasAudio = f.acodec && f.acodec !== 'none';
|
|
if (!hasVideo) continue;
|
|
if ((hasAudio) !== wantProg) continue;
|
|
const h = f.height || 0;
|
|
if (h <= 0 || seen.has(h)) continue;
|
|
seen.add(h);
|
|
qualities.push({ label: h + 'p', height: h, hasAudio: !!hasAudio, url: f.url, ext: f.ext || '' });
|
|
}
|
|
}
|
|
qualities.sort((a, b) => b.height - a.height);
|
|
|
|
return c.json({
|
|
ok: true,
|
|
data: {
|
|
meta: {
|
|
id: videoId,
|
|
title: pick(info, 'title') || '(untitled)',
|
|
channel: pickChannel(info),
|
|
channelId: pickChannelId(info),
|
|
channelUrl: pickChannelUrl(info),
|
|
duration: typeof info.duration === 'number' ? info.duration : 0,
|
|
thumbnail: `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`,
|
|
},
|
|
audioUrl: bestAudioUrl,
|
|
qualities,
|
|
},
|
|
});
|
|
} catch (err) {
|
|
return c.json({ ok: false, error: err.message }, 500);
|
|
}
|
|
});
|
|
|
|
// GET /api/download/:videoId
|
|
// Resolves the best progressive (audio+video single-file) stream URL via
|
|
// yt-dlp and proxies the binary to the browser so OPFS can store it.
|
|
// The browser never contacts YouTube CDN directly (CORS would block it).
|
|
app.get('/api/download/:videoId', async (c) => {
|
|
const videoId = (c.req.param('videoId') || '').replace(/[/\\:?<>|*"]/g, '').trim();
|
|
if (!videoId) return c.json({ ok: false, error: 'missing videoId' }, 400);
|
|
|
|
try {
|
|
const url = `https://www.youtube.com/watch?v=${videoId}`;
|
|
// --get-url with bestvideo+bestaudio/best format is not what we want
|
|
// here — we need a SINGLE FILE so no ffmpeg muxing is required in the
|
|
// browser. Use -f "bestvideo[ext=mp4][acodec!=none]/best[ext=mp4]/best"
|
|
const out = runYtdlp([
|
|
url,
|
|
'--no-warnings',
|
|
'-f', 'bestvideo[ext=mp4][acodec!=none]/bestvideo[acodec!=none]/best[ext=mp4]/best',
|
|
'--get-url',
|
|
]);
|
|
const streamUrl = out.trim();
|
|
if (!streamUrl) throw new Error('No stream URL returned');
|
|
|
|
// Fetch from YouTube and pipe to the client
|
|
const upstream = await fetch(streamUrl, {
|
|
headers: {
|
|
// Mimic a browser to avoid 403s from YouTube CDN
|
|
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
|
|
'Referer': 'https://www.youtube.com/',
|
|
},
|
|
});
|
|
if (!upstream.ok) throw new Error(`Upstream error ${upstream.status}`);
|
|
|
|
const contentType = upstream.headers.get('content-type') || 'video/mp4';
|
|
const contentLength = upstream.headers.get('content-length');
|
|
|
|
const headers = new Headers({
|
|
'Content-Type': contentType,
|
|
'Content-Disposition': `attachment; filename="${videoId}.mp4"`,
|
|
'Cache-Control': 'no-store',
|
|
'Access-Control-Allow-Origin': '*',
|
|
});
|
|
if (contentLength) headers.set('Content-Length', contentLength);
|
|
|
|
// Log the access if a fingerprint was supplied (fire-and-forget)
|
|
const fp = c.req.query('fp');
|
|
if (fp) {
|
|
recordVideoAccess(fp, { id: videoId }).catch(() => {});
|
|
}
|
|
|
|
return new Response(upstream.body, { status: 200, headers });
|
|
} catch (err) {
|
|
return c.json({ ok: false, error: err.message }, 500);
|
|
}
|
|
});
|
|
|
|
// POST /api/user/sync
|
|
// Body: { fingerprint, playlists?, recentVideo?, appVersion? }
|
|
app.post('/api/user/sync', async (c) => {
|
|
let body;
|
|
try { body = await c.req.json(); } catch { return c.json({ ok: false, error: 'invalid JSON' }, 400); }
|
|
|
|
const fp = (body.fingerprint || '').trim();
|
|
if (!fp) return c.json({ ok: false, error: 'missing fingerprint' }, 400);
|
|
|
|
try {
|
|
await upsertUser({ fingerprint: fp, appVersion: body.appVersion, playlists: body.playlists });
|
|
if (body.recentVideo && body.recentVideo.id) {
|
|
await recordVideoAccess(fp, body.recentVideo);
|
|
}
|
|
return c.json({ ok: true });
|
|
} catch (err) {
|
|
return c.json({ ok: false, error: err.message }, 500);
|
|
}
|
|
});
|
|
|
|
// GET /api/user/data?fp=<fingerprint>
|
|
app.get('/api/user/data', async (c) => {
|
|
const fp = (c.req.query('fp') || '').trim();
|
|
if (!fp) return c.json({ ok: false, error: 'missing fingerprint' }, 400);
|
|
try {
|
|
const userData = await getUserData(fp);
|
|
return c.json({ ok: true, ...userData, version: APP_VERSION });
|
|
} catch (err) {
|
|
return c.json({ ok: false, error: err.message }, 500);
|
|
}
|
|
});
|
|
|
|
// ============================================================================
|
|
// GET /sw.js — serve the service worker with BUILD_TAG injected
|
|
//
|
|
// The raw sw.js file contains the placeholder `__BUILD_TAG__` which is
|
|
// replaced here with the actual BUILD_TAG string so the SW's cache name
|
|
// tracks the deployment automatically — no manual version bump needed.
|
|
// Served with no-store cache headers so browsers always re-fetch it and
|
|
// pick up the substituted value rather than a browser-cached stale copy.
|
|
// ============================================================================
|
|
let _swSource = null;
|
|
app.get('/sw.js', (c) => {
|
|
if (!_swSource) {
|
|
try {
|
|
_swSource = readFileSync('./public/sw.js', 'utf8');
|
|
} catch {
|
|
return c.text('Service worker not found', 404);
|
|
}
|
|
}
|
|
// Inject the build tag: replace the whole fallback expression with the
|
|
// real value. Matched by REGEX, not an exact string — an exact match broke
|
|
// the moment the fallback literal in sw.js was bumped ('v1.0.3' → 'v1.0.4'),
|
|
// after which the replacement silently did nothing, the SW version froze,
|
|
// and clients never saw another update no matter how many times we deployed.
|
|
const src = _swSource.replace(
|
|
/typeof __BUILD_TAG__ !== 'undefined' \? __BUILD_TAG__ : '[^']*'/,
|
|
JSON.stringify(BUILD_TAG)
|
|
);
|
|
if (src === _swSource) {
|
|
console.error('[sw] BUILD_TAG injection failed — placeholder not found in sw.js');
|
|
}
|
|
return c.text(src, 200, {
|
|
'Content-Type': 'application/javascript; charset=utf-8',
|
|
'Cache-Control': 'no-store, no-cache, must-revalidate',
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Static files — serve the frontend/public directory
|
|
// Must come AFTER all /api routes so API takes priority
|
|
// ============================================================================
|
|
app.use('/*', serveStatic({ root: './public' }));
|
|
// SPA fallback — return index.html for any unmatched path
|
|
app.get('/*', serveStatic({ path: './public/index.html' }));
|
|
|
|
// ============================================================================
|
|
// Boot
|
|
// ============================================================================
|
|
async function main() {
|
|
await initDb();
|
|
console.log(`[ytplayer] DB ready`);
|
|
console.log(`[ytplayer] Starting on port ${PORT}`);
|
|
|
|
// Bun.serve is the native Bun HTTP server
|
|
Bun.serve({
|
|
port: PORT,
|
|
fetch: app.fetch,
|
|
});
|
|
|
|
console.log(`[ytplayer] Listening → http://localhost:${PORT}`);
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error('[ytplayer] fatal:', err);
|
|
process.exit(1);
|
|
});
|