update

api/README.md

@@ -23,6 +23,7 @@ if the desired service isn't supported yet, feel free to create an appropriate i
 | instagram         | ✅            | ✅         | ✅         | ➖         | ➖              |
 | facebook          | ✅            | ❌         | ✅         | ➖         | ➖              |
 | loom              | ✅            | ❌         | ✅         | ✅         | ➖              |
+| newgrounds        | ✅            | ✅         | ✅         | ✅         | ✅              |
 | ok.ru             | ✅            | ❌         | ✅         | ✅         | ✅              |
 | pinterest         | ✅            | ✅         | ✅         | ➖         | ➖              |
 | reddit            | ✅            | ✅         | ✅         | ❌         | ❌              |
@@ -71,7 +72,7 @@ as long as you:
 
 ## open source acknowledgements
 ### ffmpeg
-cobalt relies on ffmpeg for muxing and encoding media files. ffmpeg is absolutely spectacular and we're privileged to have an ability to use it for free, just like anyone else. we believe it should be way more recognized.
+cobalt relies on ffmpeg for muxing and encoding media files. ffmpeg is absolutely spectacular and we're privileged to have the ability to use it for free, just like anyone else. we believe it should be way more recognized.
 
 you can [support ffmpeg here](https://ffmpeg.org/donations.html)!
 

api/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@imput/cobalt-api",
     "description": "save what you love",
-    "version": "10.9.1",
+    "version": "11.5",
     "author": "imput",
     "exports": "./src/cobalt.js",
     "type": "module",
@@ -34,11 +34,12 @@
         "ffmpeg-static": "^5.1.0",
         "hls-parser": "^0.10.7",
         "ipaddr.js": "2.2.0",
+        "mime": "^4.0.4",
         "nanoid": "^5.0.9",
         "set-cookie-parser": "2.6.0",
-        "undici": "^5.19.1",
+        "undici": "^6.21.3",
         "url-pattern": "1.0.3",
-        "youtubei.js": "^13.3.0",
+        "youtubei.js": "15.1.1",
         "zod": "^3.23.8"
     },
     "optionalDependencies": {

api/src/cobalt.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "url";
 import { env, isCluster } from "./config.js"
 import { Red } from "./misc/console-text.js";
 import { initCluster } from "./misc/cluster.js";
+import { setupEnvWatcher } from "./core/env.js";
 
 const app = express();
 
@@ -24,6 +25,10 @@ if (env.apiURL) {
        await initCluster();
     }
 
+    if (env.envFile) {
+        setupEnvWatcher();
+    }
+
     runAPI(express, app, __dirname, cluster.isPrimary);
 } else {
     console.log(

api/src/config.js

@@ -1,97 +1,41 @@
-import { Constants } from "youtubei.js";
 import { getVersion } from "@imput/version-info";
-import { services } from "./processing/service-config.js";
-import { supportsReusePort } from "./misc/cluster.js";
+import { loadEnvs, validateEnvs } from "./core/env.js";
 
 const version = await getVersion();
 
-const disabledServices = process.env.DISABLED_SERVICES?.split(',') || [];
-const enabledServices = new Set(Object.keys(services).filter(e => {
-    if (!disabledServices.includes(e)) {
-        return e;
-    }
-}));
-
-const env = {
-    apiURL: process.env.API_URL || '',
-    apiPort: process.env.API_PORT || 7860,
-    tunnelPort: process.env.API_PORT || 7860,
-    appKey: process.env.APPKEY,
-
-    listenAddress: process.env.API_LISTEN_ADDRESS,
-    freebindCIDR: process.platform === 'linux' && process.env.FREEBIND_CIDR,
-
-    corsWildcard: process.env.CORS_WILDCARD !== '0',
-    corsURL: process.env.CORS_URL,
-
-    cookiePath: process.env.COOKIE_PATH,
-
-    rateLimitWindow: (process.env.RATELIMIT_WINDOW && parseInt(process.env.RATELIMIT_WINDOW)) || 60,
-    rateLimitMax: (process.env.RATELIMIT_MAX && parseInt(process.env.RATELIMIT_MAX)) || 20,
-
-    sessionRateLimitWindow: (process.env.SESSION_RATELIMIT_WINDOW && parseInt(process.env.SESSION_RATELIMIT_WINDOW)) || 60,
-    sessionRateLimit: (process.env.SESSION_RATELIMIT && parseInt(process.env.SESSION_RATELIMIT)) || 10,
-
-    durationLimit: (process.env.DURATION_LIMIT && parseInt(process.env.DURATION_LIMIT)) || 10800,
-    streamLifespan: (process.env.TUNNEL_LIFESPAN && parseInt(process.env.TUNNEL_LIFESPAN)) || 90,
-
-    processingPriority: process.platform !== 'win32'
-        && process.env.PROCESSING_PRIORITY
-        && parseInt(process.env.PROCESSING_PRIORITY),
-
-    externalProxy: process.env.API_EXTERNAL_PROXY,
-
-    turnstileSitekey: process.env.TURNSTILE_SITEKEY,
-    turnstileSecret: process.env.TURNSTILE_SECRET,
-    jwtSecret: process.env.JWT_SECRET,
-    jwtLifetime: process.env.JWT_EXPIRY || 120,
+const canonicalEnv = Object.freeze(structuredClone(process.env));
+const env = loadEnvs();
 
-    sessionEnabled: process.env.TURNSTILE_SITEKEY
-        && process.env.TURNSTILE_SECRET
-        && process.env.JWT_SECRET,
-
-    apiKeyURL: process.env.API_KEY_URL && new URL(process.env.API_KEY_URL),
-    authRequired: process.env.API_AUTH_REQUIRED === '1',
-    redisURL: process.env.API_REDIS_URL,
-    instanceCount: (process.env.API_INSTANCE_COUNT && parseInt(process.env.API_INSTANCE_COUNT)) || 1,
-    keyReloadInterval: 900,
-
-    enabledServices,
-
-    customInnertubeClient: process.env.CUSTOM_INNERTUBE_CLIENT,
-    ytSessionServer: process.env.YOUTUBE_SESSION_SERVER,
-    ytSessionReloadInterval: 300,
-    ytSessionInnertubeClient: process.env.YOUTUBE_SESSION_INNERTUBE_CLIENT,
-}
-
-const genericUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36";
+const genericUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36";
 const cobaltUserAgent = `cobalt/${version} (+https://github.com/imputnet/cobalt)`;
 
 export const setTunnelPort = (port) => env.tunnelPort = port;
 export const isCluster = env.instanceCount > 1;
+export const updateEnv = (newEnv) => {
+    const changes = [];
 
-if (env.sessionEnabled && env.jwtSecret.length < 16) {
-    throw new Error("JWT_SECRET env is too short (must be at least 16 characters long)");
-}
+    // tunnelPort is special and needs to get carried over here
+    newEnv.tunnelPort = env.tunnelPort;
 
-if (env.instanceCount > 1 && !env.redisURL) {
-    throw new Error("API_REDIS_URL is required when API_INSTANCE_COUNT is >= 2");
-} else if (env.instanceCount > 1 && !await supportsReusePort()) {
-    console.error('API_INSTANCE_COUNT is not supported in your environment. to use this env, your node.js');
-    console.error('version must be >= 23.1.0, and you must be running a recent enough version of linux');
-    console.error('(or other OS that supports it). for more info, see `reusePort` option on');
-    console.error('https://nodejs.org/api/net.html#serverlistenoptions-callback');
-    throw new Error('SO_REUSEPORT is not supported');
-}
+    for (const key in env) {
+        if (key === 'subscribe') {
+            continue;
+        }
 
-if (env.customInnertubeClient && !Constants.SUPPORTED_CLIENTS.includes(env.customInnertubeClient)) {
-    console.error("CUSTOM_INNERTUBE_CLIENT is invalid. Provided client is not supported.");
-    console.error(`Supported clients are: ${Constants.SUPPORTED_CLIENTS.join(', ')}\n`);
-    throw new Error("Invalid CUSTOM_INNERTUBE_CLIENT");
+        if (String(env[key]) !== String(newEnv[key])) {
+            changes.push(key);
+        }
+        env[key] = newEnv[key];
+    }
+
+    return changes;
 }
 
+await validateEnvs(env);
+
 export {
     env,
+    canonicalEnv,
     genericUserAgent,
     cobaltUserAgent,
 }

api/src/core/api.js

@@ -1,23 +1,24 @@
 import cors from "cors";
 import http from "node:http";
 import rateLimit from "express-rate-limit";
-import { setGlobalDispatcher, ProxyAgent } from "undici";
+import { setGlobalDispatcher, EnvHttpProxyAgent } from "undici";
 import { getCommit, getBranch, getRemote, getVersion } from "@imput/version-info";
 
 import jwt from "../security/jwt.js";
 import stream from "../stream/stream.js";
 import match from "../processing/match.js";
 
-import { env, isCluster, setTunnelPort } from "../config.js";
+import { env } from "../config.js";
 import { extract } from "../processing/url.js";
-import { Green, Bright, Cyan } from "../misc/console-text.js";
+import { Bright, Cyan } from "../misc/console-text.js";
 import { hashHmac } from "../security/secrets.js";
 import { createStore } from "../store/redis-ratelimit.js";
 import { randomizeCiphers } from "../misc/randomize-ciphers.js";
 import { verifyTurnstileToken } from "../security/turnstile.js";
 import { friendlyServiceName } from "../processing/service-alias.js";
-import { verifyStream, getInternalStream } from "../stream/manage.js";
+import { verifyStream } from "../stream/manage.js";
 import { createResponse, normalizeRequest, getIP } from "../processing/request.js";
+import { setupTunnelHandler } from "./itunnel.js";
 
 import * as APIKeys from "../security/api-keys.js";
 import * as Cookies from "../processing/cookie/manager.js";
@@ -47,28 +48,31 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
     const startTime = new Date();
     const startTimestamp = startTime.getTime();
 
-    const serverInfo = JSON.stringify({
-        cobalt: {
-            version: version,
-            url: env.apiURL,
-            startTime: `${startTimestamp}`,
-            durationLimit: env.durationLimit,
-            turnstileSitekey: env.sessionEnabled ? env.turnstileSitekey : undefined,
-            services: [...env.enabledServices].map(e => {
-                return friendlyServiceName(e);
-            }),
-        },
-        git,
-    })
+    const getServerInfo = () => {
+        return JSON.stringify({
+            cobalt: {
+                version: version,
+                url: env.apiURL,
+                startTime: `${startTimestamp}`,
+                turnstileSitekey: env.sessionEnabled ? env.turnstileSitekey : undefined,
+                services: [...env.enabledServices].map(e => {
+                    return friendlyServiceName(e);
+                }),
+            },
+            git,
+        });
+    }
+
+    const serverInfo = getServerInfo();
 
     const handleRateExceeded = (_, res) => {
-        const { status, body } = createResponse("error", {
+        const { body } = createResponse("error", {
             code: "error.api.rate_exceeded",
             context: {
                 limit: env.rateLimitWindow
             }
         });
-        return res.status(status).json(body);
+        return res.status(429).json(body);
     };
 
     const keyGenerator = (req) => hashHmac(getIP(req), 'rate').toString('base64url');
@@ -94,14 +98,14 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
     });
 
     const apiTunnelLimiter = rateLimit({
-        windowMs: env.rateLimitWindow * 1000,
-        limit: (req) => req.rateLimitMax || env.rateLimitMax,
+        windowMs: env.tunnelRateLimitWindow * 1000,
+        limit: env.tunnelRateLimitMax,
         standardHeaders: 'draft-6',
         legacyHeaders: false,
-        keyGenerator: req => req.rateLimitKey || keyGenerator(req),
+        keyGenerator: req => keyGenerator(req),
         store: await createStore('tunnel'),
         handler: (_, res) => {
-            return res.sendStatus(429)
+            return res.sendStatus(429);
         }
     });
 
@@ -128,20 +132,6 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
         next();
     });
 
-    app.post('/', (req, res, next) => {
-        const appkey = req.query.appkey;
-
-        if (!appkey) {
-            return fail(res, "error.api.auth.appkey.missing");
-        }
-
-        if (appkey !== env.appKey) {
-            return fail(res, "error.api.auth.appkey.invalid");
-        }
-
-        next();
-    });
-
     app.post('/', (req, res, next) => {
         if (!env.apiKeyURL) {
             return next();
@@ -166,6 +156,7 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
             return fail(res, `error.api.auth.key.${error}`);
         }
 
+        req.authType = "key";
         return next();
     });
 
@@ -184,7 +175,7 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
                 return fail(res, "error.api.auth.jwt.invalid");
             }
 
-            const [type, token, ...rest] = authorization.split(" ");
+            const [ type, token, ...rest ] = authorization.split(" ");
             if (!token || type.toLowerCase() !== 'bearer' || rest.length) {
                 return fail(res, "error.api.auth.jwt.invalid");
             }
@@ -194,6 +185,7 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
             }
 
             req.rateLimitKey = hashHmac(token, 'rate');
+            req.authType = "session";
         } catch {
             return fail(res, "error.api.generic");
         }
@@ -253,11 +245,15 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
             return fail(res, "error.api.invalid_body");
         }
 
-        const parsed = extract(normalizedRequest.url);
+        const parsed = extract(
+            normalizedRequest.url,
+            APIKeys.getAllowedServices(req.rateLimitKey),
+        );
 
         if (!parsed) {
             return fail(res, "error.api.link.invalid");
         }
+
         if ("error" in parsed) {
             let context;
             if (parsed?.context) {
@@ -271,13 +267,23 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
                 host: parsed.host,
                 patternMatch: parsed.patternMatch,
                 params: normalizedRequest,
+                authType: req.authType ?? "none",
             });
 
             res.status(result.status).json(result.body);
         } catch {
             fail(res, "error.api.generic");
         }
-    })
+    });
+
+    app.use('/tunnel', cors({
+        methods: ['GET'],
+        exposedHeaders: [
+            'Estimated-Content-Length',
+            'Content-Disposition'
+        ],
+        ...corsConfig,
+    }));
 
     app.get('/tunnel', apiTunnelLimiter, async (req, res) => {
         const id = String(req.query.id);
@@ -308,43 +314,11 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
         }
 
         return stream(res, streamInfo);
-    })
-
-    const itunnelHandler = (req, res) => {
-        if (!req.ip.endsWith('127.0.0.1')) {
-            return res.sendStatus(403);
-        }
-
-        if (String(req.query.id).length !== 21) {
-            return res.sendStatus(400);
-        }
-
-        const streamInfo = getInternalStream(req.query.id);
-        if (!streamInfo) {
-            return res.sendStatus(404);
-        }
-
-        streamInfo.headers = new Map([
-            ...(streamInfo.headers || []),
-            ...Object.entries(req.headers)
-        ]);
-
-        return stream(res, { type: 'internal', data: streamInfo });
-    };
-
-    app.get('/itunnel', itunnelHandler);
+    });
 
     app.get('/', (_, res) => {
         res.type('json');
-        res.status(200).send(JSON.stringify({
-            status: 'success',
-            message: 'Hello, world!'
-        }));
-    })
-
-    app.get('/api-status', (_, res) => {
-        res.type('json');
-        res.status(200).send(serverInfo);
+        res.status(200).send(env.envFile ? getServerInfo() : serverInfo);
     })
 
     app.get('/favicon.ico', (req, res) => {
@@ -363,13 +337,17 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
     randomizeCiphers();
     setInterval(randomizeCiphers, 1000 * 60 * 30); // shuffle ciphers every 30 minutes
 
-    if (env.externalProxy) {
-        if (env.freebindCIDR) {
-            throw new Error('Freebind is not available when external proxy is enabled')
+    env.subscribe(['externalProxy', 'httpProxyValues'], () => {
+        // TODO: remove env.externalProxy in a future version
+        const options = {};
+        if (env.externalProxy) {
+            options.httpProxy = env.externalProxy;
         }
 
-        setGlobalDispatcher(new ProxyAgent(env.externalProxy))
-    }
+        setGlobalDispatcher(
+            new EnvHttpProxyAgent(options)
+        );
+    });
 
     http.createServer(app).listen({
         port: env.apiPort,
@@ -406,17 +384,5 @@ export const runAPI = async (express, app, __dirname, isPrimary = true) => {
         }
     });
 
-    if (isCluster) {
-        const istreamer = express();
-        istreamer.get('/itunnel', itunnelHandler);
-        const server = istreamer.listen({
-            port: 0,
-            host: '127.0.0.1',
-            exclusive: true
-        }, () => {
-            const { port } = server.address();
-            console.log(`${Green('[✓]')} cobalt sub-instance running on 127.0.0.1:${port}`);
-            setTunnelPort(port);
-        });
-    }
+    setupTunnelHandler();
 }

api/src/core/env.js

@@ -0,0 +1,289 @@
+import { Constants } from "youtubei.js";
+import { services } from "../processing/service-config.js";
+import { updateEnv, canonicalEnv, env as currentEnv } from "../config.js";
+
+import { FileWatcher } from "../misc/file-watcher.js";
+import { isURL } from "../misc/utils.js";
+import * as cluster from "../misc/cluster.js";
+import { Green, Yellow } from "../misc/console-text.js";
+
+const forceLocalProcessingOptions = ["never", "session", "always"];
+const youtubeHlsOptions = ["never", "key", "always"];
+
+const httpProxyVariables = ["NO_PROXY", "HTTP_PROXY", "HTTPS_PROXY"].flatMap(
+    k => [ k, k.toLowerCase() ]
+);
+
+const changeCallbacks = {};
+
+const onEnvChanged = (changes) => {
+    for (const key of changes) {
+        if (changeCallbacks[key]) {
+            changeCallbacks[key].map(fn => {
+                try { fn() } catch {}
+            });
+        }
+    }
+}
+
+const subscribe = (keys, fn) => {
+    keys = [keys].flat();
+
+    for (const key of keys) {
+        if (key in currentEnv && key !== 'subscribe') {
+            changeCallbacks[key] ??= [];
+            changeCallbacks[key].push(fn);
+            fn();
+        } else throw `invalid env key ${key}`;
+    }
+}
+
+export const loadEnvs = (env = process.env) => {
+    const allServices = new Set(Object.keys(services));
+    const disabledServices = env.DISABLED_SERVICES?.split(',') || [];
+    const enabledServices = new Set(Object.keys(services).filter(e => {
+        if (!disabledServices.includes(e)) {
+            return e;
+        }
+    }));
+
+    // we need to copy the proxy envs (HTTP_PROXY, HTTPS_PROXY)
+    // back into process.env, so that EnvHttpProxyAgent can pick
+    // them up later
+    for (const key of httpProxyVariables) {
+        const value = env[key] ?? canonicalEnv[key];
+        if (value !== undefined) {
+            process.env[key] = env[key];
+        } else {
+            delete process.env[key];
+        }
+    }
+
+    return {
+        apiURL: env.API_URL || '',
+        apiPort: env.API_PORT || 9000,
+        tunnelPort: env.API_PORT || 9000,
+
+        listenAddress: env.API_LISTEN_ADDRESS,
+        freebindCIDR: process.platform === 'linux' && env.FREEBIND_CIDR,
+
+        corsWildcard: env.CORS_WILDCARD !== '0',
+        corsURL: env.CORS_URL,
+
+        cookiePath: env.COOKIE_PATH,
+
+        rateLimitWindow: (env.RATELIMIT_WINDOW && parseInt(env.RATELIMIT_WINDOW)) || 60,
+        rateLimitMax: (env.RATELIMIT_MAX && parseInt(env.RATELIMIT_MAX)) || 20,
+
+        tunnelRateLimitWindow: (env.TUNNEL_RATELIMIT_WINDOW && parseInt(env.TUNNEL_RATELIMIT_WINDOW)) || 60,
+        tunnelRateLimitMax: (env.TUNNEL_RATELIMIT_MAX && parseInt(env.TUNNEL_RATELIMIT_MAX)) || 40,
+
+        sessionRateLimitWindow: (env.SESSION_RATELIMIT_WINDOW && parseInt(env.SESSION_RATELIMIT_WINDOW)) || 60,
+        sessionRateLimit:
+            // backwards compatibility with SESSION_RATELIMIT
+            // till next major due to an error in docs
+            (env.SESSION_RATELIMIT_MAX && parseInt(env.SESSION_RATELIMIT_MAX))
+            || (env.SESSION_RATELIMIT && parseInt(env.SESSION_RATELIMIT))
+            || 10,
+
+        durationLimit: (env.DURATION_LIMIT && parseInt(env.DURATION_LIMIT)) || 10800,
+        streamLifespan: (env.TUNNEL_LIFESPAN && parseInt(env.TUNNEL_LIFESPAN)) || 90,
+
+        processingPriority: process.platform !== 'win32'
+            && env.PROCESSING_PRIORITY
+            && parseInt(env.PROCESSING_PRIORITY),
+
+        externalProxy: env.API_EXTERNAL_PROXY,
+
+        // used only for comparing against old values when envs are being updated
+        httpProxyValues: httpProxyVariables.map(k => String(env[k])).join(''),
+
+        turnstileSitekey: env.TURNSTILE_SITEKEY,
+        turnstileSecret: env.TURNSTILE_SECRET,
+        jwtSecret: env.JWT_SECRET,
+        jwtLifetime: env.JWT_EXPIRY || 120,
+
+        sessionEnabled: env.TURNSTILE_SITEKEY
+                            && env.TURNSTILE_SECRET
+                            && env.JWT_SECRET,
+
+        apiKeyURL: env.API_KEY_URL && new URL(env.API_KEY_URL),
+        authRequired: env.API_AUTH_REQUIRED === '1',
+        redisURL: env.API_REDIS_URL,
+        instanceCount: (env.API_INSTANCE_COUNT && parseInt(env.API_INSTANCE_COUNT)) || 1,
+        keyReloadInterval: 900,
+
+        allServices,
+        enabledServices,
+
+        customInnertubeClient: env.CUSTOM_INNERTUBE_CLIENT,
+        ytSessionServer: env.YOUTUBE_SESSION_SERVER,
+        ytSessionReloadInterval: 300,
+        ytSessionInnertubeClient: env.YOUTUBE_SESSION_INNERTUBE_CLIENT,
+        ytAllowBetterAudio: env.YOUTUBE_ALLOW_BETTER_AUDIO !== "0",
+
+        // "never" | "session" | "always"
+        forceLocalProcessing: env.FORCE_LOCAL_PROCESSING ?? "never",
+
+        // "never" | "key" | "always"
+        enableDeprecatedYoutubeHls: env.ENABLE_DEPRECATED_YOUTUBE_HLS ?? "never",
+
+        envFile: env.API_ENV_FILE,
+        envRemoteReloadInterval: 300,
+
+        subscribe,
+    };
+}
+
+let loggedProxyWarning = false;
+
+export const validateEnvs = async (env) => {
+    if (env.sessionEnabled && env.jwtSecret.length < 16) {
+        throw new Error("JWT_SECRET env is too short (must be at least 16 characters long)");
+    }
+
+    if (env.instanceCount > 1 && !env.redisURL) {
+        throw new Error("API_REDIS_URL is required when API_INSTANCE_COUNT is >= 2");
+    } else if (env.instanceCount > 1 && !await cluster.supportsReusePort()) {
+        console.error('API_INSTANCE_COUNT is not supported in your environment. to use this env, your node.js');
+        console.error('version must be >= 23.1.0, and you must be running a recent enough version of linux');
+        console.error('(or other OS that supports it). for more info, see `reusePort` option on');
+        console.error('https://nodejs.org/api/net.html#serverlistenoptions-callback');
+        throw new Error('SO_REUSEPORT is not supported');
+    }
+
+    if (env.customInnertubeClient && !Constants.SUPPORTED_CLIENTS.includes(env.customInnertubeClient)) {
+        console.error("CUSTOM_INNERTUBE_CLIENT is invalid. Provided client is not supported.");
+        console.error(`Supported clients are: ${Constants.SUPPORTED_CLIENTS.join(', ')}\n`);
+        throw new Error("Invalid CUSTOM_INNERTUBE_CLIENT");
+    }
+
+    if (env.forceLocalProcessing && !forceLocalProcessingOptions.includes(env.forceLocalProcessing)) {
+        console.error("FORCE_LOCAL_PROCESSING is invalid.");
+        console.error(`Supported options are are: ${forceLocalProcessingOptions.join(', ')}\n`);
+        throw new Error("Invalid FORCE_LOCAL_PROCESSING");
+    }
+
+    if (env.enableDeprecatedYoutubeHls && !youtubeHlsOptions.includes(env.enableDeprecatedYoutubeHls)) {
+        console.error("ENABLE_DEPRECATED_YOUTUBE_HLS is invalid.");
+        console.error(`Supported options are are: ${youtubeHlsOptions.join(', ')}\n`);
+        throw new Error("Invalid ENABLE_DEPRECATED_YOUTUBE_HLS");
+    }
+
+    if (env.externalProxy && env.freebindCIDR) {
+        throw new Error('freebind is not available when external proxy is enabled')
+    }
+
+    if (env.externalProxy && !loggedProxyWarning) {
+        console.error('API_EXTERNAL_PROXY is deprecated and will be removed in a future release.');
+        console.error('Use HTTP_PROXY or HTTPS_PROXY instead.');
+        console.error('You can read more about the new proxy variables in docs/api-env-variables.md\n');
+
+        // prevent the warning from being printed on every env validation
+        loggedProxyWarning = true;
+    }
+
+    return env;
+}
+
+const reloadEnvs = async (contents) => {
+    const newEnvs = {};
+    const resolvedContents = await contents;
+
+    for (let line of resolvedContents.split('\n')) {
+        line = line.trim();
+        if (line === '') {
+            continue;
+        }
+
+        let [ key, value ] = line.split(/=(.+)?/);
+        if (key) {
+            if (value.match(/^['"]/) && value.match(/['"]$/)) {
+                value = JSON.parse(value);
+            }
+
+            newEnvs[key] = value || '';
+        }
+    }
+
+    const candidate = {
+        ...canonicalEnv,
+        ...newEnvs,
+    };
+
+    const parsed = await validateEnvs(
+        loadEnvs(candidate)
+    );
+
+    cluster.broadcast({ env_update: resolvedContents });
+    return updateEnv(parsed);
+}
+
+const wrapReload = (contents) => {
+    reloadEnvs(contents)
+    .then(changes => {
+        if (changes.length === 0) {
+            return;
+        }
+
+        onEnvChanged(changes);
+
+        console.log(`${Green('[✓]')} envs reloaded successfully!`);
+        for (const key of changes) {
+            const value = currentEnv[key];
+            const isSecret = key.toLowerCase().includes('apikey')
+                          || key.toLowerCase().includes('secret')
+                          || key === 'httpProxyValues';
+
+            if (!value) {
+                console.log(`    removed: ${key}`);
+            } else {
+                console.log(`    changed: ${key} -> ${isSecret ? '***' : value}`);
+            }
+        }
+    })
+    .catch((e) => {
+        console.error(`${Yellow('[!]')} Failed reloading environment variables at ${new Date().toISOString()}.`);
+        console.error('Error:', e);
+    });
+}
+
+let watcher;
+const setupWatcherFromFile = (path) => {
+    const load = () => wrapReload(watcher.read());
+
+    if (isURL(path)) {
+        watcher = FileWatcher.fromFileProtocol(path);
+    } else {
+        watcher = new FileWatcher({ path });
+    }
+
+    watcher.on('file-updated', load);
+    load();
+}
+
+const setupWatcherFromFetch = (url) => {
+    const load = () => wrapReload(fetch(url).then(r => r.text()));
+    setInterval(load, currentEnv.envRemoteReloadInterval);
+    load();
+}
+
+export const setupEnvWatcher = () => {
+    if (cluster.isPrimary) {
+        const envFile = currentEnv.envFile;
+        const isFile = !isURL(envFile)
+                       || new URL(envFile).protocol === 'file:';
+
+        if (isFile) {
+            setupWatcherFromFile(envFile);
+        } else {
+            setupWatcherFromFetch(envFile);
+        }
+    } else if (cluster.isWorker) {
+        process.on('message', (message) => {
+            if ('env_update' in message) {
+                reloadEnvs(message.env_update);
+            }
+        });
+    }
+}

api/src/core/itunnel.js

@@ -0,0 +1,61 @@
+import stream from "../stream/stream.js";
+import { getInternalTunnel } from "../stream/manage.js";
+import { setTunnelPort } from "../config.js";
+import { Green } from "../misc/console-text.js";
+import express from "express";
+
+const validateTunnel = (req, res) => {
+    if (!req.ip.endsWith('127.0.0.1')) {
+        res.sendStatus(403);
+        return;
+    }
+
+    if (String(req.query.id).length !== 21) {
+        res.sendStatus(400);
+        return;
+    }
+
+    const streamInfo = getInternalTunnel(req.query.id);
+    if (!streamInfo) {
+        res.sendStatus(404);
+        return;
+    }
+
+    return streamInfo;
+}
+
+const streamTunnel = (req, res) => {
+    const streamInfo = validateTunnel(req, res);
+    if (!streamInfo) {
+        return;
+    }
+
+    streamInfo.headers = new Map([
+        ...(streamInfo.headers || []),
+        ...Object.entries(req.headers)
+    ]);
+
+    return stream(res, { type: 'internal', data: streamInfo });
+}
+
+export const setupTunnelHandler = () => {
+    const tunnelHandler = express();
+
+    tunnelHandler.get('/itunnel', streamTunnel);
+
+    // fallback
+    tunnelHandler.use((_, res) => res.sendStatus(400));
+    // error handler
+    tunnelHandler.use((_, __, res, ____) => res.socket.end());
+
+
+    const server = tunnelHandler.listen({
+        port: 0,
+        host: '127.0.0.1',
+        exclusive: true
+    }, () => {
+        const { port } = server.address();
+        console.log(`${Green('[✓]')} internal tunnel handler running on 127.0.0.1:${port}`);
+        setTunnelPort(port);
+    });
+}

api/src/misc/cluster.js

@@ -13,7 +13,8 @@ export const supportsReusePort = async () => {
             server.on('error', (err) => (server.close(), reject(err)));
         });
 
-        return true;
+        const [major, minor] = process.versions.node.split('.').map(Number);
+        return major > 23 || (major === 23 && minor >= 1);
     } catch {
         return false;
     }

api/src/misc/file-watcher.js

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'node:events';
+import * as fs from 'node:fs/promises';
+
+export class FileWatcher extends EventEmitter {
+    #path;
+    #hasWatcher = false;
+    #lastChange = new Date().getTime();
+
+    constructor({ path, ...rest }) {
+        super(rest);
+        this.#path = path;
+    }
+
+    async #setupWatcher() {
+        if (this.#hasWatcher)
+            return;
+
+        this.#hasWatcher = true;
+        const watcher = fs.watch(this.#path);
+        for await (const _ of watcher) {
+            if (new Date() - this.#lastChange > 50) {
+                this.emit('file-updated');
+                this.#lastChange = new Date().getTime();
+            }
+        }
+    }
+
+    read() {
+        this.#setupWatcher();
+        return fs.readFile(this.#path, 'utf8');
+    }
+
+    static fromFileProtocol(url_) {
+        const url = new URL(url_);
+        if (url.protocol !== 'file:') {
+            return;
+        }
+
+        const pathname = url.pathname === '/' ? '' : url.pathname;
+        const file_path = decodeURIComponent(url.host + pathname);
+        return new this({ path: file_path });
+    }
+}

api/src/misc/language-codes.js

@@ -0,0 +1,54 @@
+// converted from this file https://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt
+const iso639_1to2 = {
+    'aa': 'aar', 'ab': 'abk', 'af': 'afr', 'ak': 'aka', 'sq': 'sqi',
+    'am': 'amh', 'ar': 'ara', 'an': 'arg', 'hy': 'hye', 'as': 'asm',
+    'av': 'ava', 'ae': 'ave', 'ay': 'aym', 'az': 'aze', 'ba': 'bak',
+    'bm': 'bam', 'eu': 'eus', 'be': 'bel', 'bn': 'ben', 'bi': 'bis',
+    'bs': 'bos', 'br': 'bre', 'bg': 'bul', 'my': 'mya', 'ca': 'cat',
+    'ch': 'cha', 'ce': 'che', 'zh': 'zho', 'cu': 'chu', 'cv': 'chv',
+    'kw': 'cor', 'co': 'cos', 'cr': 'cre', 'cs': 'ces', 'da': 'dan',
+    'dv': 'div', 'nl': 'nld', 'dz': 'dzo', 'en': 'eng', 'eo': 'epo',
+    'et': 'est', 'ee': 'ewe', 'fo': 'fao', 'fj': 'fij', 'fi': 'fin',
+    'fr': 'fra', 'fy': 'fry', 'ff': 'ful', 'ka': 'kat', 'de': 'deu',
+    'gd': 'gla', 'ga': 'gle', 'gl': 'glg', 'gv': 'glv', 'el': 'ell',
+    'gn': 'grn', 'gu': 'guj', 'ht': 'hat', 'ha': 'hau', 'he': 'heb',
+    'hz': 'her', 'hi': 'hin', 'ho': 'hmo', 'hr': 'hrv', 'hu': 'hun',
+    'ig': 'ibo', 'is': 'isl', 'io': 'ido', 'ii': 'iii', 'iu': 'iku',
+    'ie': 'ile', 'ia': 'ina', 'id': 'ind', 'ik': 'ipk', 'it': 'ita',
+    'jv': 'jav', 'ja': 'jpn', 'kl': 'kal', 'kn': 'kan', 'ks': 'kas',
+    'kr': 'kau', 'kk': 'kaz', 'km': 'khm', 'ki': 'kik', 'rw': 'kin',
+    'ky': 'kir', 'kv': 'kom', 'kg': 'kon', 'ko': 'kor', 'kj': 'kua',
+    'ku': 'kur', 'lo': 'lao', 'la': 'lat', 'lv': 'lav', 'li': 'lim',
+    'ln': 'lin', 'lt': 'lit', 'lb': 'ltz', 'lu': 'lub', 'lg': 'lug',
+    'mk': 'mkd', 'mh': 'mah', 'ml': 'mal', 'mi': 'mri', 'mr': 'mar',
+    'ms': 'msa', 'mg': 'mlg', 'mt': 'mlt', 'mn': 'mon', 'na': 'nau',
+    'nv': 'nav', 'nr': 'nbl', 'nd': 'nde', 'ng': 'ndo', 'ne': 'nep',
+    'nn': 'nno', 'nb': 'nob', 'no': 'nor', 'ny': 'nya', 'oc': 'oci',
+    'oj': 'oji', 'or': 'ori', 'om': 'orm', 'os': 'oss', 'pa': 'pan',
+    'fa': 'fas', 'pi': 'pli', 'pl': 'pol', 'pt': 'por', 'ps': 'pus',
+    'qu': 'que', 'rm': 'roh', 'ro': 'ron', 'rn': 'run', 'ru': 'rus',
+    'sg': 'sag', 'sa': 'san', 'si': 'sin', 'sk': 'slk', 'sl': 'slv',
+    'se': 'sme', 'sm': 'smo', 'sn': 'sna', 'sd': 'snd', 'so': 'som',
+    'st': 'sot', 'es': 'spa', 'sc': 'srd', 'sr': 'srp', 'ss': 'ssw',
+    'su': 'sun', 'sw': 'swa', 'sv': 'swe', 'ty': 'tah', 'ta': 'tam',
+    'tt': 'tat', 'te': 'tel', 'tg': 'tgk', 'tl': 'tgl', 'th': 'tha',
+    'bo': 'bod', 'ti': 'tir', 'to': 'ton', 'tn': 'tsn', 'ts': 'tso',
+    'tk': 'tuk', 'tr': 'tur', 'tw': 'twi', 'ug': 'uig', 'uk': 'ukr',
+    'ur': 'urd', 'uz': 'uzb', 've': 'ven', 'vi': 'vie', 'vo': 'vol',
+    'cy': 'cym', 'wa': 'wln', 'wo': 'wol', 'xh': 'xho', 'yi': 'yid',
+    'yo': 'yor', 'za': 'zha', 'zu': 'zul',
+}
+
+const iso639_2to1 = Object.fromEntries(
+    Object.entries(iso639_1to2).map(([k, v]) => [v, k])
+);
+
+const maps = {
+    2: iso639_1to2,
+    3: iso639_2to1,
+}
+
+export const convertLanguageCode = (code) => {
+    code = code?.split("-")[0]?.split("_")[0] || "";
+    return maps[code.length]?.[code.toLowerCase()] || null;
+}

api/src/misc/utils.js

@@ -1,4 +1,4 @@
-import { request } from 'undici';
+import { request } from "undici";
 const redirectStatuses = new Set([301, 302, 303, 307, 308]);
 
 export async function getRedirectingURL(url, dispatcher, headers) {
@@ -8,18 +8,34 @@ export async function getRedirectingURL(url, dispatcher, headers) {
         headers,
         redirect: 'manual'
     };
+    const getParams = {
+        ...params,
+        method: 'GET',
+    };
 
-    let location = await request(url, params).then(r => {
+    const callback = (r) => {
         if (redirectStatuses.has(r.statusCode) && r.headers['location']) {
             return r.headers['location'];
         }
-    }).catch(() => null);
+    }
 
-    location ??= await fetch(url, params).then(r => {
-        if (redirectStatuses.has(r.status) && r.headers.has('location')) {
-            return r.headers.get('location');
-        }
-    }).catch(() => null);
+    /*
+        try request() with HEAD & GET,
+        then do the same with fetch
+        (fetch is required for shortened reddit links)
+    */
+
+    let location = await request(url, params)
+        .then(callback).catch(() => null);
+
+    location ??= await request(url, getParams)
+        .then(callback).catch(() => null);
+
+    location ??= await fetch(url, params)
+        .then(callback).catch(() => null);
+
+    location ??= await fetch(url, getParams)
+        .then(callback).catch(() => null);
 
     return location;
 }
@@ -52,3 +68,12 @@ export function splitFilenameExtension(filename) {
 export function zip(a, b) {
     return a.map((value, i) => [ value, b[i] ]);
 }
+
+export function isURL(input) {
+    try {
+        new URL(input);
+        return true;
+    } catch {
+        return false;
+    }
+}

api/src/processing/cookie/manager.js

@@ -13,6 +13,7 @@ const VALID_SERVICES = new Set([
     'reddit',
     'twitter',
     'youtube',
+    'vimeo_bearer',
 ]);
 
 const invalidCookies = {};

api/src/processing/create-filename.js

@@ -1,10 +1,25 @@
-const illegalCharacters = ['}', '{', '%', '>', '<', '^', ';', ':', '`', '$', '"', "@", '=', '?', '|', '*'];
+// characters that are disallowed on windows:
+// https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+const characterMap = {
+    '<':  '＜',
+    '>':  '＞',
+    ':':  '：',
+    '"':  '＂',
+    '/':  '／',
+    '\\': '＼',
+    '|': '｜',
+    '?': '？',
+    '*': '＊'
+};
 
-const sanitizeString = (string) => {
-    for (const i in illegalCharacters) {
-        string = string.replaceAll("/", "_").replaceAll("\\", "_")
-                       .replaceAll(illegalCharacters[i], '')
+export const sanitizeString = (string) => {
+    // remove any potential control characters the string might contain
+    string = string.replace(/[\u0000-\u001F\u007F-\u009F]/g, "");
+
+    for (const [ char, replacement ] of Object.entries(characterMap)) {
+        string = string.replaceAll(char, replacement);
     }
+
     return string;
 }
 

api/src/processing/match-action.js

@@ -4,8 +4,24 @@ import { createResponse } from "./request.js";
 import { audioIgnore } from "./service-config.js";
 import { createStream } from "../stream/manage.js";
 import { splitFilenameExtension } from "../misc/utils.js";
+import { convertLanguageCode } from "../misc/language-codes.js";
 
-export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disableMetadata, filenameStyle, twitterGif, requestIP, audioBitrate, alwaysProxy }) {
+const extraProcessingTypes = new Set(["merge", "remux", "mute", "audio", "gif"]);
+
+export default function({
+    r,
+    host,
+    audioFormat,
+    isAudioOnly,
+    isAudioMuted,
+    disableMetadata,
+    filenameStyle,
+    convertGif,
+    requestIP,
+    audioBitrate,
+    alwaysProxy,
+    localProcessing,
+}) {
     let action,
         responseType = "tunnel",
         defaultParams = {
@@ -16,13 +32,16 @@ export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disab
                     createFilename(r.filenameAttributes, filenameStyle, isAudioOnly, isAudioMuted) : r.filename,
             fileMetadata: !disableMetadata ? r.fileMetadata : false,
             requestIP,
-            originalRequest: r.originalRequest
+            originalRequest: r.originalRequest,
+            subtitles: r.subtitles,
+            cover: !disableMetadata ? r.cover : false,
+            cropCover: !disableMetadata ? r.cropCover : false,
         },
         params = {};
 
     if (r.isPhoto) action = "photo";
     else if (r.picker) action = "picker"
-    else if (r.isGif && twitterGif) action = "gif";
+    else if (r.isGif && convertGif) action = "gif";
     else if (isAudioOnly) action = "audio";
     else if (isAudioMuted) action = "muteVideo";
     else if (r.isHLS) action = "hls";
@@ -128,7 +147,9 @@ export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disab
 
                 case "vimeo":
                     if (Array.isArray(r.urls)) {
-                        params = { type: "merge" }
+                        params = { type: "merge" };
+                    } else if (r.subtitles) {
+                        params = { type: "remux" };
                     } else {
                         responseType = "redirect";
                     }
@@ -142,10 +163,24 @@ export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disab
                     }
                     break;
 
-                case "ok":
+                case "loom":
+                    if (r.subtitles) {
+                        params = { type: "remux" };
+                    } else {
+                        responseType = "redirect";
+                    }
+                    break;
+
                 case "vk":
                 case "tiktok":
+                    params = {
+                        type: r.subtitles ? "remux" : "proxy"
+                    };
+                    break;
+
+                case "ok":
                 case "xiaohongshu":
+                case "newgrounds":
                     params = { type: "proxy" };
                     break;
 
@@ -155,7 +190,6 @@ export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disab
                 case "pinterest":
                 case "streamable":
                 case "snapchat":
-                case "loom":
                 case "twitch":
                     responseType = "redirect";
                     break;
@@ -163,7 +197,7 @@ export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disab
             break;
 
         case "audio":
-            if (audioIgnore.includes(host) || (host === "reddit" && r.typeId === "redirect")) {
+            if (audioIgnore.has(host) || (host === "reddit" && r.typeId === "redirect")) {
                 return createResponse("error", {
                     code: "error.api.service.audio_not_supported"
                 })
@@ -211,10 +245,39 @@ export default function({ r, host, audioFormat, isAudioOnly, isAudioMuted, disab
         defaultParams.filename += `.${audioFormat}`;
     }
 
+    // alwaysProxy is set to true in match.js if localProcessing is forced
     if (alwaysProxy && responseType === "redirect") {
         responseType = "tunnel";
         params.type = "proxy";
     }
 
-    return createResponse(responseType, {...defaultParams, ...params})
+    // TODO: add support for HLS
+    // (very painful)
+    if (!params.isHLS && responseType !== "picker") {
+        const isPreferredWithExtra =
+            localProcessing === "preferred" && extraProcessingTypes.has(params.type);
+
+        if (localProcessing === "forced" || isPreferredWithExtra) {
+            responseType = "local-processing";
+        }
+    }
+
+    // extractors usually return ISO 639-1 language codes,
+    // but video players expect ISO 639-2, so we convert them here
+    const sublanguage = defaultParams.fileMetadata?.sublanguage;
+    if (sublanguage && sublanguage.length !== 3) {
+        const code = convertLanguageCode(sublanguage);
+        if (code) {
+            defaultParams.fileMetadata.sublanguage = code;
+        } else {
+            // if a language code couldn't be converted,
+            // then we don't want it at all
+            delete defaultParams.fileMetadata.sublanguage;
+        }
+    }
+
+    return createResponse(
+        responseType,
+        { ...defaultParams, ...params }
+    );
 }

api/src/processing/match.js

@@ -29,10 +29,11 @@ import loom from "./services/loom.js";
 import facebook from "./services/facebook.js";
 import bluesky from "./services/bluesky.js";
 import xiaohongshu from "./services/xiaohongshu.js";
+import newgrounds from "./services/newgrounds.js";
 
 let freebind;
 
-export default async function({ host, patternMatch, params }) {
+export default async function({ host, patternMatch, params, authType }) {
     const { url } = params;
     assert(url instanceof URL);
     let dispatcher, requestIP;
@@ -65,14 +66,26 @@ export default async function({ host, patternMatch, params }) {
             });
         }
 
+        // youtubeHLS will be fully removed in the future
+        let youtubeHLS = params.youtubeHLS;
+        const hlsEnv = env.enableDeprecatedYoutubeHls;
+
+        if (hlsEnv === "never" || (hlsEnv === "key" && authType !== "key")) {
+            youtubeHLS = false;
+        }
+
+        const subtitleLang =
+            params.subtitleLang !== "none" ? params.subtitleLang : undefined;
+
         switch (host) {
             case "twitter":
                 r = await twitter({
                     id: patternMatch.id,
                     index: patternMatch.index - 1,
-                    toGif: !!params.twitterGif,
+                    toGif: !!params.convertGif,
                     alwaysProxy: params.alwaysProxy,
-                    dispatcher
+                    dispatcher,
+                    subtitleLang
                 });
                 break;
 
@@ -81,7 +94,8 @@ export default async function({ host, patternMatch, params }) {
                     ownerId: patternMatch.ownerId,
                     videoId: patternMatch.videoId,
                     accessKey: patternMatch.accessKey,
-                    quality: params.videoQuality
+                    quality: params.videoQuality,
+                    subtitleLang,
                 });
                 break;
 
@@ -101,18 +115,24 @@ export default async function({ host, patternMatch, params }) {
                     dispatcher,
                     id: patternMatch.id.slice(0, 11),
                     quality: params.videoQuality,
-                    format: params.youtubeVideoCodec,
+                    codec: params.youtubeVideoCodec,
+                    container: params.youtubeVideoContainer,
                     isAudioOnly,
                     isAudioMuted,
                     dubLang: params.youtubeDubLang,
-                    youtubeHLS: params.youtubeHLS,
+                    youtubeHLS,
+                    subtitleLang,
                 }
 
                 if (url.hostname === "music.youtube.com" || isAudioOnly) {
                     fetchInfo.quality = "1080";
-                    fetchInfo.format = "vp9";
+                    fetchInfo.codec = "vp9";
                     fetchInfo.isAudioOnly = true;
                     fetchInfo.isAudioMuted = false;
+
+                    if (env.ytAllowBetterAudio && params.youtubeBetterAudio) {
+                        fetchInfo.quality = "max";
+                    }
                 }
 
                 r = await youtube(fetchInfo);
@@ -131,8 +151,9 @@ export default async function({ host, patternMatch, params }) {
                     shortLink: patternMatch.shortLink,
                     fullAudio: params.tiktokFullAudio,
                     isAudioOnly,
-                    h265: params.tiktokH265,
+                    h265: params.allowH265,
                     alwaysProxy: params.alwaysProxy,
+                    subtitleLang,
                 });
                 break;
 
@@ -150,6 +171,7 @@ export default async function({ host, patternMatch, params }) {
                     password: patternMatch.password,
                     quality: params.videoQuality,
                     isAudioOnly,
+                    subtitleLang,
                 });
                 break;
 
@@ -157,12 +179,8 @@ export default async function({ host, patternMatch, params }) {
                 isAudioOnly = true;
                 isAudioMuted = false;
                 r = await soundcloud({
-                    url,
-                    author: patternMatch.author,
-                    song: patternMatch.song,
+                    ...patternMatch,
                     format: params.audioFormat,
-                    shortLink: patternMatch.shortLink || false,
-                    accessKey: patternMatch.accessKey || false
                 });
                 break;
 
@@ -205,6 +223,7 @@ export default async function({ host, patternMatch, params }) {
                     key: patternMatch.key,
                     quality: params.videoQuality,
                     isAudioOnly,
+                    subtitleLang,
                 });
                 break;
 
@@ -221,7 +240,8 @@ export default async function({ host, patternMatch, params }) {
 
             case "loom":
                 r = await loom({
-                    id: patternMatch.id
+                    id: patternMatch.id,
+                    subtitleLang,
                 });
                 break;
 
@@ -243,12 +263,19 @@ export default async function({ host, patternMatch, params }) {
             case "xiaohongshu":
                 r = await xiaohongshu({
                     ...patternMatch,
-                    h265: params.tiktokH265,
+                    h265: params.allowH265,
                     isAudioOnly,
                     dispatcher,
                 });
                 break;
 
+            case "newgrounds":
+                r = await newgrounds({
+                    ...patternMatch,
+                    quality: params.videoQuality,
+                });
+                break;
+
             default:
                 return createResponse("error", {
                     code: "error.api.service.unsupported"
@@ -271,7 +298,7 @@ export default async function({ host, patternMatch, params }) {
             switch(r.error) {
                 case "content.too_long":
                     context = {
-                        limit: env.durationLimit / 60,
+                        limit: parseFloat((env.durationLimit / 60).toFixed(2)),
                     }
                     break;
 
@@ -292,6 +319,15 @@ export default async function({ host, patternMatch, params }) {
             })
         }
 
+        let localProcessing = params.localProcessing;
+        const lpEnv = env.forceLocalProcessing;
+        const shouldForceLocal = lpEnv === "always" || (lpEnv === "session" && authType === "session");
+        const localDisabled = (!localProcessing || localProcessing === "disabled");
+
+        if (shouldForceLocal && localDisabled) {
+            localProcessing = "preferred";
+        }
+
         return matchAction({
             r,
             host,
@@ -300,10 +336,11 @@ export default async function({ host, patternMatch, params }) {
             isAudioMuted,
             disableMetadata: params.disableMetadata,
             filenameStyle: params.filenameStyle,
-            twitterGif: params.twitterGif,
+            convertGif: params.convertGif,
             requestIP,
             audioBitrate: params.audioBitrate,
-            alwaysProxy: params.alwaysProxy,
+            alwaysProxy: params.alwaysProxy || localProcessing === "forced",
+            localProcessing,
         })
     } catch {
         return createResponse("error", {

api/src/processing/request.js

@@ -1,7 +1,8 @@
+import mime from "mime";
 import ipaddr from "ipaddr.js";
 
-import { createStream } from "../stream/manage.js";
 import { apiSchema } from "./schema.js";
+import { createProxyTunnels, createStream } from "../stream/manage.js";
 
 export function createResponse(responseType, responseData) {
     const internalError = (code) => {
@@ -10,7 +11,7 @@ export function createResponse(responseType, responseData) {
             body: {
                 status: "error",
                 error: {
-                    code: code || "error.api.fetch.critical",
+                    code: code || "error.api.fetch.critical.core",
                 },
                 critical: true
             }
@@ -49,6 +50,44 @@ export function createResponse(responseType, responseData) {
                 }
                 break;
 
+            case "local-processing":
+                response = {
+                    type: responseData?.type,
+                    service: responseData?.service,
+                    tunnel: createProxyTunnels(responseData),
+
+                    output: {
+                        type: mime.getType(responseData?.filename) || undefined,
+                        filename: responseData?.filename,
+                        metadata: responseData?.fileMetadata || undefined,
+                        subtitles: !!responseData?.subtitles || undefined,
+                    },
+
+                    audio: {
+                        copy: responseData?.audioCopy,
+                        format: responseData?.audioFormat,
+                        bitrate: responseData?.audioBitrate,
+                        cover: !!responseData?.cover || undefined,
+                        cropCover: !!responseData?.cropCover || undefined,
+                    },
+
+                    isHLS: responseData?.isHLS,
+                }
+
+                if (!response.audio.format) {
+                    if (response.type === "audio") {
+                        // audio response without a format is invalid
+                        return internalError();
+                    }
+                    delete response.audio;
+                }
+
+                if (!response.output.type || !response.output.filename) {
+                    // response without a type or filename is invalid
+                    return internalError();
+                }
+                break;
+
             case "picker":
                 response = {
                     picker: responseData?.picker,
@@ -72,11 +111,16 @@ export function createResponse(responseType, responseData) {
             }
         }
     } catch {
-        return internalError()
+        return internalError();
     }
 }
 
 export function normalizeRequest(request) {
+    // TODO: remove after backwards compatibility period
+    if ("localProcessing" in request && typeof request.localProcessing === "boolean") {
+        request.localProcessing = request.localProcessing ? "preferred" : "disabled";
+    }
+
     return apiSchema.safeParseAsync(request).catch(() => (
         { success: false }
     ));

api/src/processing/schema.js

@@ -20,32 +20,45 @@ export const apiSchema = z.object({
 
     filenameStyle: z.enum(
         ["classic", "pretty", "basic", "nerdy"]
-    ).default("classic"),
+    ).default("basic"),
 
     youtubeVideoCodec: z.enum(
         ["h264", "av1", "vp9"]
     ).default("h264"),
 
+    youtubeVideoContainer: z.enum(
+        ["auto", "mp4", "webm", "mkv"]
+    ).default("auto"),
+
     videoQuality: z.enum(
         ["max", "4320", "2160", "1440", "1080", "720", "480", "360", "240", "144"]
     ).default("1080"),
 
+    localProcessing: z.enum(
+        ["disabled", "preferred", "forced"]
+    ).default("disabled"),
+
     youtubeDubLang: z.string()
                      .min(2)
                      .max(8)
                      .regex(/^[0-9a-zA-Z\-]+$/)
                      .optional(),
 
-    // TODO: remove this variable as it's no longer used
-    // and is kept for schema compatibility reasons
-    youtubeDubBrowserLang: z.boolean().default(false),
+    subtitleLang: z.string()
+                     .min(2)
+                     .max(8)
+                     .regex(/^[0-9a-zA-Z\-]+$/)
+                     .optional(),
 
-    alwaysProxy: z.boolean().default(false),
     disableMetadata: z.boolean().default(false),
+
+    allowH265: z.boolean().default(false),
+    convertGif: z.boolean().default(true),
     tiktokFullAudio: z.boolean().default(false),
-    tiktokH265: z.boolean().default(false),
-    twitterGif: z.boolean().default(true),
+
+    alwaysProxy: z.boolean().default(false),
 
     youtubeHLS: z.boolean().default(false),
+    youtubeBetterAudio: z.boolean().default(false),
 })
 .strict();

api/src/processing/service-alias.js

@@ -1,5 +1,6 @@
 const friendlyNames = {
     bsky: "bluesky",
+    twitch: "twitch clips"
 }
 
 export const friendlyServiceName = (service) => {

api/src/processing/service-config.js

@@ -1,12 +1,13 @@
 import UrlPattern from "url-pattern";
 
-export const audioIgnore = ["vk", "ok", "loom"];
-export const hlsExceptions = ["dailymotion", "vimeo", "rutube", "bsky", "youtube"];
+export const audioIgnore = new Set(["vk", "ok", "loom"]);
+export const hlsExceptions = new Set(["dailymotion", "vimeo", "rutube", "bsky", "youtube"]);
 
 export const services = {
     bilibili: {
         patterns: [
             "video/:comId",
+            "video/:comId?p=:partId",
             "_shortLink/:comShortLink",
             "_tv/:lang/video/:tvId",
             "_tv/video/:tvId"
@@ -74,6 +75,12 @@ export const services = {
             "url_shortener/:shortLink"
         ],
     },
+    newgrounds: {
+        patterns: [
+            "portal/view/:id",
+            "audio/listen/:audioId",
+        ]
+    },
     reddit: {
         patterns: [
             "comments/:id",
@@ -116,6 +123,7 @@ export const services = {
             "add/:username",
             "u/:username",
             "t/:shortLink",
+            "o/:spotlightId",
         ],
         subdomains: ["t", "story"],
     },
@@ -158,6 +166,7 @@ export const services = {
     twitch: {
         patterns: [":channel/clip/:clip"],
         tld: "tv",
+        subdomains: ["clips", "www", "m"],
     },
     twitter: {
         patterns: [
@@ -176,7 +185,8 @@ export const services = {
             ":id",
             "video/:id",
             ":id/:password",
-            "/channels/:user/:id"
+            "/channels/:user/:id",
+            "groups/:groupId/videos/:id"
         ],
         subdomains: ["player"],
     },
@@ -184,12 +194,13 @@ export const services = {
         patterns: [
             "video:ownerId_:videoId",
             "clip:ownerId_:videoId",
-            "clips:duplicate?z=clip:ownerId_:videoId",
-            "videos:duplicate?z=video:ownerId_:videoId",
             "video:ownerId_:videoId_:accessKey",
             "clip:ownerId_:videoId_:accessKey",
-            "clips:duplicate?z=clip:ownerId_:videoId_:accessKey",
-            "videos:duplicate?z=video:ownerId_:videoId_:accessKey"
+
+            // links with a duplicate author id and/or zipper query param
+            "clips:duplicateId",
+            "videos:duplicateId",
+            "search/video"
         ],
         subdomains: ["m"],
         altDomains: ["vkvideo.ru", "vk.ru"],
@@ -198,7 +209,7 @@ export const services = {
         patterns: [
             "explore/:id?xsec_token=:token",
             "discovery/item/:id?xsec_token=:token",
-            "a/:shareId"
+            ":shareType/:shareId",
         ],
         altDomains: ["xhslink.com"],
     },
@@ -206,7 +217,8 @@ export const services = {
         patterns: [
             "watch?v=:id",
             "embed/:id",
-            "watch/:id"
+            "watch/:id",
+            "v/:id"
         ],
         subdomains: ["music", "m"],
     }

api/src/processing/service-patterns.js

@@ -1,53 +1,72 @@
 export const testers = {
     "bilibili": pattern =>
-        pattern.comId?.length <= 12 || pattern.comShortLink?.length <= 16
-        || pattern.tvId?.length <= 24,
+        (pattern.comId?.length <= 12 && pattern.partId?.length <= 3) ||
+        (pattern.comId?.length <= 12 && !pattern.partId) ||
+        pattern.comShortLink?.length <= 16 ||
+        pattern.tvId?.length <= 24,
+
+    "bsky": pattern =>
+        pattern.user?.length <= 128 && pattern.post?.length <= 128,
 
     "dailymotion": pattern => pattern.id?.length <= 32,
 
+    "facebook": pattern =>
+        pattern.shortLink?.length <= 11 ||
+        pattern.username?.length <= 30 ||
+        pattern.caption?.length <= 255 ||
+        pattern.id?.length <= 20 && !pattern.shareType ||
+        pattern.id?.length <= 20 && pattern.shareType?.length === 1,
+
     "instagram": pattern =>
-        pattern.postId?.length <= 48
-        || pattern.shareId?.length <= 16
-        || (pattern.username?.length <= 30 && pattern.storyId?.length <= 24),
+        pattern.postId?.length <= 48 ||
+        pattern.shareId?.length <= 16 ||
+        (pattern.username?.length <= 30 && pattern.storyId?.length <= 24),
 
     "loom": pattern =>
         pattern.id?.length <= 32,
 
+    "newgrounds": pattern =>
+        pattern.id?.length <= 12 ||
+        pattern.audioId?.length <= 12,
+
     "ok": pattern =>
         pattern.id?.length <= 16,
 
     "pinterest": pattern =>
-        pattern.id?.length <= 128 || pattern.shortLink?.length <= 32,
+        pattern.id?.length <= 128 ||
+        pattern.shortLink?.length <= 32,
 
     "reddit": pattern =>
-        pattern.id?.length <= 16 && !pattern.sub && !pattern.user
-        || (pattern.sub?.length <= 22 && pattern.id?.length <= 16)
-        || (pattern.user?.length <= 22 && pattern.id?.length <= 16)
-        || (pattern.sub?.length <= 22 && pattern.shareId?.length <= 16)
-        || (pattern.shortId?.length <= 16),
+        pattern.id?.length <= 16 && !pattern.sub && !pattern.user ||
+        (pattern.sub?.length <= 22 && pattern.id?.length <= 16) ||
+        (pattern.user?.length <= 22 && pattern.id?.length <= 16) ||
+        (pattern.sub?.length <= 22 && pattern.shareId?.length <= 16) ||
+        (pattern.shortId?.length <= 16),
 
     "rutube": pattern =>
         (pattern.id?.length === 32 && pattern.key?.length <= 32) ||
-        pattern.id?.length === 32 || pattern.yappyId?.length === 32,
-
-    "soundcloud": pattern =>
-        (pattern.author?.length <= 255 && pattern.song?.length <= 255)
-        || pattern.shortLink?.length <= 32,
+        pattern.id?.length === 32 ||
+        pattern.yappyId?.length === 32,
 
     "snapchat": pattern =>
-        (pattern.username?.length <= 32 && (!pattern.storyId || pattern.storyId?.length <= 255))
-        || pattern.spotlightId?.length <= 255
-        || pattern.shortLink?.length <= 16,
+        (pattern.username?.length <= 32 && (!pattern.storyId || pattern.storyId?.length <= 255)) ||
+        pattern.spotlightId?.length <= 255 ||
+        pattern.shortLink?.length <= 16,
+
+    "soundcloud": pattern =>
+        (pattern.author?.length <= 255 && pattern.song?.length <= 255) ||
+        pattern.shortLink?.length <= 32,
 
     "streamable": pattern =>
         pattern.id?.length <= 6,
 
     "tiktok": pattern =>
-        pattern.postId?.length <= 21 || pattern.shortLink?.length <= 13,
+        pattern.postId?.length <= 21 ||
+        pattern.shortLink?.length <= 21,
 
     "tumblr": pattern =>
-        pattern.id?.length < 21
-        || (pattern.id?.length < 21 && pattern.user?.length <= 32),
+        pattern.id?.length < 21 ||
+        (pattern.id?.length < 21 && pattern.user?.length <= 32),
 
     "twitch": pattern =>
         pattern.channel && pattern.clip?.length <= 100,
@@ -56,27 +75,16 @@ export const testers = {
         pattern.id?.length < 20,
 
     "vimeo": pattern =>
-        pattern.id?.length <= 11
-        && (!pattern.password || pattern.password.length < 16),
+        pattern.id?.length <= 11 && (!pattern.password || pattern.password.length < 16),
 
     "vk": pattern =>
         (pattern.ownerId?.length <= 10 && pattern.videoId?.length <= 10) ||
         (pattern.ownerId?.length <= 10 && pattern.videoId?.length <= 10 && pattern.videoId?.accessKey <= 18),
 
+    "xiaohongshu": pattern =>
+        pattern.id?.length <= 24 && pattern.token?.length <= 64 ||
+        pattern.shareId?.length <= 24 && pattern.shareType?.length === 1,
+
     "youtube": pattern =>
         pattern.id?.length <= 11,
-
-    "facebook": pattern =>
-        pattern.shortLink?.length <= 11
-        || pattern.username?.length <= 30
-        || pattern.caption?.length <= 255
-        || pattern.id?.length <= 20 && !pattern.shareType
-        || pattern.id?.length <= 20 && pattern.shareType?.length === 1,
-
-    "bsky": pattern =>
-        pattern.user?.length <= 128 && pattern.post?.length <= 128,
-
-    "xiaohongshu": pattern =>
-        pattern.id?.length <= 24 && pattern.token?.length <= 64
-        || pattern.shareId?.length <= 12,
 }

api/src/processing/services/bilibili.js

@@ -17,8 +17,14 @@ function extractBestQuality(dashData) {
     return [ bestVideo, bestAudio ];
 }
 
-async function com_download(id) {
-    let html = await fetch(`https://bilibili.com/video/${id}`, {
+async function com_download(id, partId) {
+    const url = new URL(`https://bilibili.com/video/${id}`);
+
+    if (partId) {
+        url.searchParams.set('p', partId);
+    }
+
+    const html = await fetch(url, {
         headers: {
             "user-agent": genericUserAgent
         }
@@ -34,7 +40,10 @@ async function com_download(id) {
         return { error: "fetch.empty" };
     }
 
-    let streamData = JSON.parse(html.split('<script>window.__playinfo__=')[1].split('</script>')[0]);
+    const streamData = JSON.parse(
+        html.split('<script>window.__playinfo__=')[1].split('</script>')[0]
+    );
+
     if (streamData.data.timelength > env.durationLimit * 1000) {
         return { error: "content.too_long" };
     }
@@ -44,10 +53,15 @@ async function com_download(id) {
         return { error: "fetch.empty" };
     }
 
+    let filenameBase = `bilibili_${id}`;
+    if (partId) {
+        filenameBase += `_${partId}`;
+    }
+
     return {
         urls: [video.baseUrl, audio.baseUrl],
-        audioFilename: `bilibili_${id}_audio`,
-        filename: `bilibili_${id}_${video.width}x${video.height}.mp4`
+        audioFilename: `${filenameBase}_audio`,
+        filename: `${filenameBase}_${video.width}x${video.height}.mp4`,
     };
 }
 
@@ -86,14 +100,14 @@ async function tv_download(id) {
     };
 }
 
-export default async function({ comId, tvId, comShortLink }) {
+export default async function({ comId, tvId, comShortLink, partId }) {
     if (comShortLink) {
         const patternMatch = await resolveRedirectingURL(`https://b23.tv/${comShortLink}`);
         comId = patternMatch?.comId;
     }
 
     if (comId) {
-        return com_download(comId);
+        return com_download(comId, partId);
     } else if (tvId) {
         return tv_download(tvId);
     }

api/src/processing/services/loom.js

@@ -1,18 +1,18 @@
 import { genericUserAgent } from "../../config.js";
 
-export default async function({ id }) {
+const craftHeaders = id => ({
+    "user-agent": genericUserAgent,
+    "content-type": "application/json",
+    origin: "https://www.loom.com",
+    referer: `https://www.loom.com/share/${id}`,
+    cookie: `loom_referral_video=${id};`,
+    "x-loom-request-source": "loom_web_be851af",
+});
+
+async function fromTranscodedURL(id) {
     const gql = await fetch(`https://www.loom.com/api/campaigns/sessions/${id}/transcoded-url`, {
         method: "POST",
-        headers: {
-            "user-agent": genericUserAgent,
-            origin: "https://www.loom.com",
-            referer: `https://www.loom.com/share/${id}`,
-            cookie: `loom_referral_video=${id};`,
-
-            "apollographql-client-name": "web",
-            "apollographql-client-version": "14c0b42",
-            "x-loom-request-source": "loom_web_14c0b42",
-        },
+        headers: craftHeaders(id),
         body: JSON.stringify({
             force_original: false,
             password: null,
@@ -20,20 +20,89 @@ export default async function({ id }) {
             deviceID: null
         })
     })
-    .then(r => r.status === 200 ? r.json() : false)
+    .then(r => r.status === 200 && r.json())
+    .catch(() => {});
+
+    if (gql?.url?.includes('.mp4?')) {
+        return gql.url;
+    }
+}
+
+async function fromRawURL(id) {
+    const gql = await fetch(`https://www.loom.com/api/campaigns/sessions/${id}/raw-url`, {
+        method: "POST",
+        headers: craftHeaders(id),
+        body: JSON.stringify({
+            anonID: crypto.randomUUID(),
+            client_name: "web",
+            client_version: "be851af",
+            deviceID: null,
+            force_original: false,
+            password: null,
+            supported_mime_types: ["video/mp4"],
+        })
+    })
+    .then(r => r.status === 200 && r.json())
+    .catch(() => {});
+
+    if (gql?.url?.includes('.mp4?')) {
+        return gql.url;
+    }
+}
+
+async function getTranscript(id) {
+    const gql = await fetch(`https://www.loom.com/graphql`, {
+        method: "POST",
+        headers: craftHeaders(id),
+        body: JSON.stringify({
+            operationName: "FetchVideoTranscriptForFetchTranscript",
+            variables: {
+                videoId: id,
+                password: null,
+            },
+            query: `
+                query FetchVideoTranscriptForFetchTranscript($videoId: ID!, $password: String) {
+                    fetchVideoTranscript(videoId: $videoId, password: $password) {
+                        ... on VideoTranscriptDetails {
+                        captions_source_url
+                        language
+                        __typename
+                        }
+                        ... on GenericError {
+                        message
+                        __typename
+                        }
+                        __typename
+                    }
+                }`,
+        })
+    })
+    .then(r => r.status === 200 && r.json())
     .catch(() => {});
 
-    if (!gql) return { error: "fetch.empty" };
+    if (gql?.data?.fetchVideoTranscript?.captions_source_url?.includes('.vtt?')) {
+        return gql.data.fetchVideoTranscript.captions_source_url;
+    }
+}
+
+export default async function({ id, subtitleLang }) {
+    let url = await fromTranscodedURL(id);
+    url ??= await fromRawURL(id);
 
-    const videoUrl = gql?.url;
+    if (!url) {
+        return { error: "fetch.empty" }
+    }
 
-    if (videoUrl?.includes('.mp4?')) {
-        return {
-            urls: videoUrl,
-            filename: `loom_${id}.mp4`,
-            audioFilename: `loom_${id}_audio`
-        }
+    let subtitles;
+    if (subtitleLang) {
+        const transcript = await getTranscript(id);
+        if (transcript) subtitles = transcript;
     }
 
-    return { error: "fetch.empty" }
+    return {
+        urls: url,
+        subtitles,
+        filename: `loom_${id}.mp4`,
+        audioFilename: `loom_${id}_audio`
+    }
 }

api/src/processing/services/newgrounds.js

@@ -0,0 +1,103 @@
+import { genericUserAgent } from "../../config.js";
+
+const getVideo = async ({ id, quality }) => {
+    const json = await fetch(`https://www.newgrounds.com/portal/video/${id}`, {
+        headers: {
+            "User-Agent": genericUserAgent,
+            "X-Requested-With": "XMLHttpRequest", // required to get the JSON response
+        }
+    })
+    .then(r => r.json())
+    .catch(() => {});
+
+    if (!json) return { error: "fetch.empty" };
+
+    const videoSources = json.sources;
+    const videoQualities = Object.keys(videoSources);
+
+    if (videoQualities.length === 0) {
+        return { error: "fetch.empty" };
+    }
+
+    const bestVideo = videoSources[videoQualities[0]]?.[0],
+          userQuality = quality === "2160" ? "4k" : `${quality}p`,
+          preferredVideo = videoSources[userQuality]?.[0],
+          video = preferredVideo || bestVideo,
+          videoQuality = preferredVideo ? userQuality : videoQualities[0];
+
+    if (!bestVideo || !video.type.includes("mp4")) {
+        return { error: "fetch.empty" };
+    }
+
+    const fileMetadata = {
+        title: decodeURIComponent(json.title),
+        artist: decodeURIComponent(json.author),
+    }
+
+    return {
+        urls: video.src,
+        filenameAttributes: {
+            service: "newgrounds",
+            id,
+            title: fileMetadata.title,
+            author: fileMetadata.artist,
+            extension: "mp4",
+            qualityLabel: videoQuality,
+            resolution: videoQuality,
+        },
+        fileMetadata,
+    }
+}
+
+const getMusic = async ({ id }) => {
+    const html = await fetch(`https://www.newgrounds.com/audio/listen/${id}`, {
+        headers: {
+            "User-Agent": genericUserAgent,
+        }
+    })
+    .then(r => r.text())
+    .catch(() => {});
+
+    if (!html) return { error: "fetch.fail" };
+
+    const params = JSON.parse(
+        `{${html.split(',"params":{')[1]?.split(',"images":')[0]}}`
+    );
+    if (!params) return { error: "fetch.empty" };
+
+    if (!params.name || !params.artist || !params.filename || !params.icon) {
+        return { error: "fetch.empty" };
+    }
+
+    const fileMetadata = {
+        title: decodeURIComponent(params.name),
+        artist: decodeURIComponent(params.artist),
+    }
+
+    return {
+        urls: params.filename,
+        filenameAttributes: {
+            service: "newgrounds",
+            id,
+            title: fileMetadata.title,
+            author: fileMetadata.artist,
+        },
+        fileMetadata,
+        cover:
+            params.icon.includes(".png?") || params.icon.includes(".jpg?")
+                ? params.icon
+                : undefined,
+        isAudioOnly: true,
+        bestAudio: "mp3",
+    }
+}
+
+export default function({ id, audioId, quality }) {
+    if (id) {
+        return getVideo({ id, quality });
+    } else if (audioId) {
+        return getMusic({ id: audioId });
+    }
+
+    return { error: "fetch.empty" };
+}

api/src/processing/services/pinterest.js

@@ -3,6 +3,7 @@ import { resolveRedirectingURL } from "../url.js";
 
 const videoRegex = /"url":"(https:\/\/v1\.pinimg\.com\/videos\/.*?)"/g;
 const imageRegex = /src="(https:\/\/i\.pinimg\.com\/.*\.(jpg|gif))"/g;
+const notFoundRegex = /"__typename"\s*:\s*"PinNotFound"/;
 
 export default async function(o) {
     let id = o.id;
@@ -19,6 +20,10 @@ export default async function(o) {
         headers: { "user-agent": genericUserAgent }
     }).then(r => r.text()).catch(() => {});
 
+    const invalidPin = html.match(notFoundRegex);
+
+    if (invalidPin) return { error: "fetch.empty" };
+
     if (!html) return { error: "fetch.fail" };
 
     const videoLink = [...html.matchAll(videoRegex)]

api/src/processing/services/rutube.js

@@ -65,8 +65,21 @@ export default async function(obj) {
         artist: play.author.name.trim(),
     }
 
+    let subtitles;
+    if (obj.subtitleLang && play.captions?.length) {
+        const subtitle = play.captions.find(
+            s => ["webvtt", "srt"].includes(s.format) && s.code.startsWith(obj.subtitleLang)
+        );
+
+        if (subtitle) {
+            subtitles = subtitle.file;
+            fileMetadata.sublanguage = obj.subtitleLang;
+        }
+    }
+
     return {
         urls: matchingQuality.uri,
+        subtitles,
         isHLS: true,
         filenameAttributes: {
             service: "rutube",

api/src/processing/services/snapchat.js

@@ -102,10 +102,10 @@ export default async function (obj) {
         params = await resolveRedirectingURL(`https://t.snapchat.com/${obj.shortLink}`);
     }
 
-    if (params.spotlightId) {
+    if (params?.spotlightId) {
         const result = await getSpotlight(params.spotlightId);
         if (result) return result;
-    } else if (params.username) {
+    } else if (params?.username) {
         const result = await getStory(params.username, params.storyId, obj.alwaysProxy);
         if (result) return result;
     }

api/src/processing/services/soundcloud.js

@@ -1,4 +1,5 @@
 import { env } from "../../config.js";
+import { resolveRedirectingURL } from "../url.js";
 
 const cachedID = {
     version: '',
@@ -7,22 +8,25 @@ const cachedID = {
 
 async function findClientID() {
     try {
-        let sc = await fetch('https://soundcloud.com/').then(r => r.text()).catch(() => {});
-        let scVersion = String(sc.match(/<script>window\.__sc_version="[0-9]{10}"<\/script>/)[0].match(/[0-9]{10}/));
+        const sc = await fetch('https://soundcloud.com/').then(r => r.text()).catch(() => {});
+        const scVersion = String(sc.match(/<script>window\.__sc_version="[0-9]{10}"<\/script>/)[0].match(/[0-9]{10}/));
 
-        if (cachedID.version === scVersion) return cachedID.id;
+        if (cachedID.version === scVersion) {
+            return cachedID.id;
+        }
+
+        const scripts = sc.matchAll(/<script.+src="(.+)">/g);
 
-        let scripts = sc.matchAll(/<script.+src="(.+)">/g);
         let clientid;
         for (let script of scripts) {
-            let url = script[1];
+            const url = script[1];
 
             if (!url?.startsWith('https://a-v2.sndcdn.com/')) {
                 return;
             }
 
-            let scrf = await fetch(url).then(r => r.text()).catch(() => {});
-            let id = scrf.match(/\("client_id=[A-Za-z0-9]{32}"\)/);
+            const scrf = await fetch(url).then(r => r.text()).catch(() => {});
+            const id = scrf.match(/\("client_id=[A-Za-z0-9]{32}"\)/);
 
             if (id && typeof id[0] === 'string') {
                 clientid = id[0].match(/[A-Za-z0-9]{32}/)[0];
@@ -36,47 +40,79 @@ async function findClientID() {
     } catch {}
 }
 
+const findBestForPreset = (transcodings, preset) => {
+    let inferior;
+    for (const entry of transcodings) {
+        const protocol = entry?.format?.protocol;
+
+        if (entry.snipped || protocol?.includes('encrypted')) {
+            continue;
+        }
+
+        if (entry?.preset?.startsWith(`${preset}_`)) {
+            if (protocol === 'progressive') {
+                return entry;
+            }
+
+            inferior = entry;
+        }
+    }
+
+    return inferior;
+}
+
 export default async function(obj) {
-    let clientId = await findClientID();
+    const clientId = await findClientID();
     if (!clientId) return { error: "fetch.fail" };
 
     let link;
-    if (obj.url.hostname === 'on.soundcloud.com' && obj.shortLink) {
-        link = await fetch(`https://on.soundcloud.com/${obj.shortLink}/`, { redirect: "manual" }).then(r => {
-            if (r.status === 302 && r.headers.get("location").startsWith("https://soundcloud.com/")) {
-                return r.headers.get("location").split('?', 1)[0]
-            }
-        }).catch(() => {});
+
+    if (obj.shortLink) {
+        obj = {
+            ...obj,
+            ...await resolveRedirectingURL(
+                `https://on.soundcloud.com/${obj.shortLink}`
+            )
+        }
     }
 
-    if (!link && obj.author && obj.song) {
-        link = `https://soundcloud.com/${obj.author}/${obj.song}${obj.accessKey ? `/s-${obj.accessKey}` : ''}`
+    if (obj.author && obj.song) {
+        link = `https://soundcloud.com/${obj.author}/${obj.song}`;
+        if (obj.accessKey) {
+            link += `/s-${obj.accessKey}`;
+        }
     }
 
     if (!link && obj.shortLink) return { error: "fetch.short_link" };
     if (!link) return { error: "link.unsupported" };
 
-    let json = await fetch(`https://api-v2.soundcloud.com/resolve?url=${link}&client_id=${clientId}`)
-                     .then(r => r.status === 200 ? r.json() : false)
-                     .catch(() => {});
+    const resolveURL = new URL("https://api-v2.soundcloud.com/resolve");
+    resolveURL.searchParams.set("url", link);
+    resolveURL.searchParams.set("client_id", clientId);
 
+    const json = await fetch(resolveURL).then(r => r.json()).catch(() => {});
     if (!json) return { error: "fetch.fail" };
 
-    if (json?.policy === "BLOCK") {
+    if (json.duration > env.durationLimit * 1000) {
+        return { error: "content.too_long" };
+    }
+
+    if (json.policy === "BLOCK") {
         return { error: "content.region" };
     }
 
-    if (json?.policy === "SNIP") {
+    if (json.policy === "SNIP") {
         return { error: "content.paid" };
     }
 
-    if (!json?.media?.transcodings || !json?.media?.transcodings.length === 0) {
+    if (!json.media?.transcodings || !json.media?.transcodings.length === 0) {
         return { error: "fetch.empty" };
     }
 
     let bestAudio = "opus",
-        selectedStream = json.media.transcodings.find(v => v.preset === "opus_0_0"),
-        mp3Media = json.media.transcodings.find(v => v.preset === "mp3_0_0");
+        selectedStream = findBestForPreset(json.media.transcodings, "opus");
+
+    const mp3Media = findBestForPreset(json.media.transcodings, "mp3");
 
     // use mp3 if present if user prefers it or if opus isn't available
     if (mp3Media && (obj.format === "mp3" || !selectedStream)) {
@@ -88,35 +124,50 @@ export default async function(obj) {
         return { error: "fetch.empty" };
     }
 
-    let fileUrlBase = selectedStream.url;
-    let fileUrl = `${fileUrlBase}${fileUrlBase.includes("?") ? "&" : "?"}client_id=${clientId}&track_authorization=${json.track_authorization}`;
+    const fileUrl = new URL(selectedStream.url);
+    fileUrl.searchParams.set("client_id", clientId);
+    fileUrl.searchParams.set("track_authorization", json.track_authorization);
 
-    if (!fileUrl.startsWith("https://api-v2.soundcloud.com/media/soundcloud:tracks:"))
-        return { error: "fetch.empty" };
+    const file = await fetch(fileUrl)
+                     .then(async r => new URL((await r.json()).url))
+                     .catch(() => {});
 
-    if (json.duration > env.durationLimit * 1000) {
-        return { error: "content.too_long" };
+    if (!file) return { error: "fetch.empty" };
+
+    const artist = json.user?.username?.trim();
+    const fileMetadata = {
+        title: json.title?.trim(),
+        album: json.publisher_metadata?.album_title?.trim(),
+        artist,
+        album_artist: artist,
+        composer: json.publisher_metadata?.writer_composer?.trim(),
+        genre: json.genre?.trim(),
+        date: json.display_date?.trim().slice(0, 10),
+        copyright: json.license?.trim(),
     }
 
-    let file = await fetch(fileUrl)
-                     .then(async r => (await r.json()).url)
-                     .catch(() => {});
-    if (!file) return { error: "fetch.empty" };
+    let cover;
+    if (json.artwork_url) {
+        const coverUrl = json.artwork_url.replace(/-large/, "-t1080x1080");
+        const testCover = await fetch(coverUrl)
+            .then(r => r.status === 200)
+            .catch(() => {});
 
-    let fileMetadata = {
-        title: json.title.trim(),
-        artist: json.user.username.trim(),
+        if (testCover) {
+            cover = coverUrl;
+        }
     }
 
     return {
-        urls: file,
+        urls: file.toString(),
+        cover,
         filenameAttributes: {
             service: "soundcloud",
             id: json.id,
-            title: fileMetadata.title,
-            author: fileMetadata.artist
+            ...fileMetadata
         },
         bestAudio,
-        fileMetadata
+        fileMetadata,
+        isHLS: file.pathname.endsWith('.m3u8'),
     }
 }

api/src/processing/services/tiktok.js

@@ -4,6 +4,7 @@ import { extract, normalizeURL } from "../url.js";
 import { genericUserAgent } from "../../config.js";
 import { updateCookie } from "../cookie/manager.js";
 import { createStream } from "../../stream/manage.js";
+import { convertLanguageCode } from "../../misc/language-codes.js";
 
 const shortDomain = "https://vt.tiktok.com/";
 
@@ -23,8 +24,10 @@ export default async function(obj) {
 
         if (html.startsWith('<a href="https://')) {
             const extractedURL = html.split('<a href="')[1].split('?')[0];
-            const { patternMatch } = extract(normalizeURL(extractedURL));
-            postId = patternMatch?.postId;
+            const { host, patternMatch } = extract(normalizeURL(extractedURL));
+            if (host === "tiktok") {
+                postId = patternMatch?.postId;
+            }
         }
     }
     if (!postId) return { error: "fetch.short_link" };
@@ -97,8 +100,23 @@ export default async function(obj) {
     }
 
     if (video) {
+        let subtitles, fileMetadata;
+        if (obj.subtitleLang && detail?.video?.subtitleInfos?.length) {
+            const langCode = convertLanguageCode(obj.subtitleLang);
+            const subtitle = detail?.video?.subtitleInfos.find(
+                s => s.LanguageCodeName.startsWith(langCode) && s.Format === "webvtt"
+            )
+            if (subtitle) {
+                subtitles = subtitle.Url;
+                fileMetadata = {
+                    sublanguage: langCode,
+                }
+            }
+        }
         return {
             urls: video,
+            subtitles,
+            fileMetadata,
             filename: videoFilename,
             headers: { cookie }
         }
@@ -150,4 +168,6 @@ export default async function(obj) {
             headers: { cookie }
         }
     }
+
+    return { error: "fetch.empty" };
 }

api/src/processing/services/twitter.js

@@ -1,13 +1,14 @@
+import HLS from "hls-parser";
 import { genericUserAgent } from "../../config.js";
 import { createStream } from "../../stream/manage.js";
 import { getCookie, updateCookie } from "../cookie/manager.js";
 
-const graphqlURL = 'https://api.x.com/graphql/I9GDzyCGZL2wSoYFFrrTVw/TweetResultByRestId';
+const graphqlURL = 'https://api.x.com/graphql/4Siu98E55GquhG52zHdY5w/TweetDetail';
 const tokenURL = 'https://api.x.com/1.1/guest/activate.json';
 
-const tweetFeatures = JSON.stringify({"creator_subscriptions_tweet_preview_api_enabled":true,"communities_web_enable_tweet_community_results_fetch":true,"c9s_tweet_anatomy_moderator_badge_enabled":true,"articles_preview_enabled":true,"tweetypie_unmention_optimization_enabled":true,"responsive_web_edit_tweet_api_enabled":true,"graphql_is_translatable_rweb_tweet_is_translatable_enabled":true,"view_counts_everywhere_api_enabled":true,"longform_notetweets_consumption_enabled":true,"responsive_web_twitter_article_tweet_consumption_enabled":true,"tweet_awards_web_tipping_enabled":false,"creator_subscriptions_quote_tweet_preview_enabled":false,"freedom_of_speech_not_reach_fetch_enabled":true,"standardized_nudges_misinfo":true,"tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled":true,"rweb_video_timestamps_enabled":true,"longform_notetweets_rich_text_read_enabled":true,"longform_notetweets_inline_media_enabled":true,"rweb_tipjar_consumption_enabled":true,"responsive_web_graphql_exclude_directive_enabled":true,"verified_phone_label_enabled":false,"responsive_web_graphql_skip_user_profile_image_extensions_enabled":false,"responsive_web_graphql_timeline_navigation_enabled":true,"responsive_web_enhance_cards_enabled":false});
+const tweetFeatures = JSON.stringify({"rweb_video_screen_enabled":false,"payments_enabled":false,"rweb_xchat_enabled":false,"profile_label_improvements_pcf_label_in_post_enabled":true,"rweb_tipjar_consumption_enabled":true,"verified_phone_label_enabled":false,"creator_subscriptions_tweet_preview_api_enabled":true,"responsive_web_graphql_timeline_navigation_enabled":true,"responsive_web_graphql_skip_user_profile_image_extensions_enabled":false,"premium_content_api_read_enabled":false,"communities_web_enable_tweet_community_results_fetch":true,"c9s_tweet_anatomy_moderator_badge_enabled":true,"responsive_web_grok_analyze_button_fetch_trends_enabled":false,"responsive_web_grok_analyze_post_followups_enabled":true,"responsive_web_jetfuel_frame":true,"responsive_web_grok_share_attachment_enabled":true,"articles_preview_enabled":true,"responsive_web_edit_tweet_api_enabled":true,"graphql_is_translatable_rweb_tweet_is_translatable_enabled":true,"view_counts_everywhere_api_enabled":true,"longform_notetweets_consumption_enabled":true,"responsive_web_twitter_article_tweet_consumption_enabled":true,"tweet_awards_web_tipping_enabled":false,"responsive_web_grok_show_grok_translated_post":false,"responsive_web_grok_analysis_button_from_backend":true,"creator_subscriptions_quote_tweet_preview_enabled":false,"freedom_of_speech_not_reach_fetch_enabled":true,"standardized_nudges_misinfo":true,"tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled":true,"longform_notetweets_rich_text_read_enabled":true,"longform_notetweets_inline_media_enabled":true,"responsive_web_grok_image_annotation_enabled":true,"responsive_web_grok_imagine_annotation_enabled":true,"responsive_web_grok_community_note_auto_translation_is_enabled":false,"responsive_web_enhance_cards_enabled":false});
 
-const tweetFieldToggles = JSON.stringify({"withArticleRichContentState":true,"withArticlePlainText":false,"withGrokAnalyze":false});
+const tweetFieldToggles = JSON.stringify({"withArticleRichContentState":true,"withArticlePlainText":false,"withGrokAnalyze":false,"withDisallowedReplyControls":false});
 
 const commonHeaders = {
     "user-agent": genericUserAgent,
@@ -99,10 +100,14 @@ const requestTweet = async(dispatcher, tweetId, token, cookie) => {
 
     graphqlTweetURL.searchParams.set('variables',
         JSON.stringify({
-            tweetId,
-            withCommunity: false,
-            includePromotedContent: false,
-            withVoice: false
+            focalTweetId: tweetId,
+            with_rux_injections: false,
+            rankingMode: "Relevance",
+            includePromotedContent: true,
+            withCommunity: true,
+            withQuickPromoteEligibilityTweetFields: true,
+            withBirdwatchNotes: true,
+            withVoice: true
         })
     );
     graphqlTweetURL.searchParams.set('features', tweetFeatures);
@@ -128,24 +133,48 @@ const requestTweet = async(dispatcher, tweetId, token, cookie) => {
     return result
 }
 
-const extractGraphqlMedia = async (tweet, dispatcher, id, guestToken, cookie) => {
-    let tweetTypename = tweet?.data?.tweetResult?.result?.__typename;
+const parseCard = (cardOuter) => {
+    const card = JSON.parse(
+      (cardOuter?.legacy?.binding_values[0].value
+       || cardOuter?.binding_values?.unified_card)?.string_value,
+    );
+
+    if (!["video_website", "image_website"].includes(card?.type)
+        || !card?.media_entities
+        || card?.component_objects?.media_1?.type !== "media") {
+      return;
+    }
+
+    const mediaId = card.component_objects?.media_1?.data?.id;
+    return [card.media_entities[mediaId]];
+};
+
+const extractGraphqlMedia = async (thread, dispatcher, id, guestToken, cookie) => {
+    const addInsn = thread?.data?.threaded_conversation_with_injections_v2?.instructions?.find(
+        insn => insn.type === 'TimelineAddEntries'
+    );
+
+    const tweetResult = addInsn?.entries?.find(
+        entry => entry.entryId === `tweet-${id}`
+    )?.content?.itemContent?.tweet_results?.result;
+
+    let tweetTypename = tweetResult?.__typename;
 
     if (!tweetTypename) {
         return { error: "fetch.empty" }
     }
 
-    if (tweetTypename === "TweetUnavailable") {
-        const reason = tweet?.data?.tweetResult?.result?.reason;
-        switch(reason) {
-            case "Protected":
-                return { error: "content.post.private" };
-            case "NsfwLoggedOut":
-                if (cookie) {
-                    tweet = await requestTweet(dispatcher, id, guestToken, cookie);
-                    tweet = await tweet.json();
-                    tweetTypename = tweet?.data?.tweetResult?.result?.__typename;
-                } else return { error: "content.post.age" };
+    if (tweetTypename === "TweetUnavailable" || tweetTypename === "TweetTombstone") {
+        const reason = tweetResult?.result?.reason;
+        if (reason === 'Protected') {
+            return { error: "content.post.private" };
+        } else if (reason === "NsfwLoggedOut" || tweetResult?.tombstone?.text?.text?.startsWith('Age-restricted')) {
+            if (!cookie) {
+                return { error: "content.post.age" };
+            }
+
+            const tweet = await requestTweet(dispatcher, id, guestToken, cookie).then(t => t.json());
+            return extractGraphqlMedia(tweet, dispatcher, id, guestToken);
         }
     }
 
@@ -153,8 +182,7 @@ const extractGraphqlMedia = async (tweet, dispatcher, id, guestToken, cookie) =>
         return { error: "content.post.unavailable" }
     }
 
-    let tweetResult = tweet.data.tweetResult.result,
-        baseTweet = tweetResult.legacy,
+    let baseTweet = tweetResult.legacy,
         repostedTweet = baseTweet?.retweeted_status_result?.result.legacy.extended_entities;
 
     if (tweetTypename === "TweetWithVisibilityResults") {
@@ -162,69 +190,52 @@ const extractGraphqlMedia = async (tweet, dispatcher, id, guestToken, cookie) =>
         repostedTweet = baseTweet?.retweeted_status_result?.result.tweet.legacy.extended_entities;
     }
 
-    return (repostedTweet?.media || baseTweet?.extended_entities?.media);
-}
-
-const testResponse = (result) => {
-    const contentLength = result.headers.get("content-length");
-
-    if (!contentLength || contentLength === '0') {
-        return false;
-    }
-
-    if (!result.headers.get("content-type").startsWith("application/json")) {
-        return false;
+    if (tweetResult.card?.legacy?.binding_values?.length) {
+        return parseCard(tweetResult.card);
     }
 
-    return true;
+    return (repostedTweet?.media || baseTweet?.extended_entities?.media);
 }
 
-export default async function({ id, index, toGif, dispatcher, alwaysProxy }) {
+export default async function({ id, index, toGif, dispatcher, alwaysProxy, subtitleLang }) {
     const cookie = await getCookie('twitter');
 
-    let syndication = false;
-
     let guestToken = await getGuestToken(dispatcher);
     if (!guestToken) return { error: "fetch.fail" };
 
-    // for now we assume that graphql api will come back after some time,
-    // so we try it first
-
     let tweet = await requestTweet(dispatcher, id, guestToken);
 
-    // get new token & retry if old one expired
-    if ([403, 429].includes(tweet.status)) {
-        guestToken = await getGuestToken(dispatcher, true);
-        if (cookie) {
-            tweet = await requestTweet(dispatcher, id, guestToken, cookie);
-        } else {
-            tweet = await requestTweet(dispatcher, id, guestToken);
+    if ([403, 404, 429].includes(tweet.status)) {
+        // get new token & retry if old one expired
+        if ([403, 429].includes(tweet.status)) {
+            guestToken = await getGuestToken(dispatcher, true);
         }
+        tweet = await requestTweet(dispatcher, id, guestToken, cookie);
     }
 
-    const testGraphql = testResponse(tweet);
+    let media;
+    try {
+        tweet = await tweet.json();
+        media = await extractGraphqlMedia(tweet, dispatcher, id, guestToken, cookie);
+    } catch {}
 
     // if graphql requests fail, then resort to tweet embed api
-    if (!testGraphql) {
-        syndication = true;
-        tweet = await requestSyndication(dispatcher, id);
+    if (!media || 'error' in media) {
+        try {
+            tweet = await requestSyndication(dispatcher, id);
+            tweet = await tweet.json();
 
-        const testSyndication = testResponse(tweet);
+            if (tweet?.card) {
+                media = parseCard(tweet.card);
+            }
+        } catch {}
 
-        // if even syndication request failed, then cry out loud
-        if (!testSyndication) {
-            return { error: "fetch.fail" };
-        }
+        media = tweet?.mediaDetails ?? media;
     }
 
-    tweet = await tweet.json();
-
-    let media =
-        syndication
-            ? tweet.mediaDetails
-            : await extractGraphqlMedia(tweet, dispatcher, id, guestToken, cookie);
-
-    if (!media) return { error: "fetch.empty" };
+    if (!media || 'error' in media) {
+        return { error: media?.error || "fetch.empty" };
+    }
 
     // check if there's a video at given index (/video/<index>)
     if (index >= 0 && index < media?.length) {
@@ -239,6 +250,30 @@ export default async function({ id, index, toGif, dispatcher, alwaysProxy }) {
         url, filename,
     });
 
+    const extractSubtitles = async (hlsUrl) => {
+        const mainHls = await fetch(hlsUrl).then(r => r.text()).catch(() => {});
+        if (!mainHls) return;
+
+        const subtitle = HLS.parse(mainHls)?.variants[0]?.subtitles?.find(
+            s => s.language.startsWith(subtitleLang)
+        );
+        if (!subtitle) return;
+
+        const subtitleUrl = new URL(subtitle.uri, hlsUrl).toString();
+        const subtitleHls = await fetch(subtitleUrl).then(r => r.text());
+        if (!subtitleHls) return;
+
+        const finalSubtitlePath = HLS.parse(subtitleHls)?.segments?.[0].uri;
+        if (!finalSubtitlePath) return;
+
+        const finalSubtitleUrl = new URL(finalSubtitlePath, hlsUrl).toString();
+
+        return {
+            url: finalSubtitleUrl,
+            language: subtitle.language,
+        };
+    }
+
     switch (media?.length) {
         case undefined:
         case 0:
@@ -246,21 +281,37 @@ export default async function({ id, index, toGif, dispatcher, alwaysProxy }) {
                 error: "fetch.empty"
             }
         case 1:
-            if (media[0].type === "photo") {
+            const mediaItem = media[0];
+            if (mediaItem.type === "photo") {
                 return {
                     type: "proxy",
                     isPhoto: true,
-                    filename: `twitter_${id}.${getFileExt(media[0].media_url_https)}`,
-                    urls: `${media[0].media_url_https}?name=4096x4096`
+                    filename: `twitter_${id}.${getFileExt(mediaItem.media_url_https)}`,
+                    urls: `${mediaItem.media_url_https}?name=4096x4096`
+                }
+            }
+
+            let subtitles;
+            let fileMetadata;
+            if (mediaItem.type === "video" && subtitleLang) {
+                const hlsVariant = mediaItem.video_info?.variants?.find(
+                    v => v.content_type === "application/x-mpegURL"
+                );
+                if (hlsVariant) {
+                    const { url, language } = await extractSubtitles(hlsVariant.url) || {};
+                    subtitles = url;
+                    if (language) fileMetadata = { sublanguage: language };
                 }
             }
 
             return {
-                type: needsFixing(media[0]) ? "remux" : "proxy",
-                urls: bestQuality(media[0].video_info.variants),
+                type: subtitles || needsFixing(mediaItem) ? "remux" : "proxy",
+                urls: bestQuality(mediaItem.video_info.variants),
                 filename: `twitter_${id}.mp4`,
                 audioFilename: `twitter_${id}_audio`,
-                isGif: media[0].type === "animated_gif"
+                isGif: mediaItem.type === "animated_gif",
+                subtitles,
+                fileMetadata,
             }
         default:
             const proxyThumb = (url, i) =>

api/src/processing/services/vimeo.js

@@ -1,6 +1,7 @@
 import HLS from "hls-parser";
 import { env } from "../../config.js";
 import { merge } from '../../misc/utils.js';
+import { getCookie } from "../cookie/manager.js";
 
 const resolutionMatch = {
     "3840": 2160,
@@ -15,7 +16,44 @@ const resolutionMatch = {
     "426": 240
 }
 
-const requestApiInfo = (videoId, password) => {
+const genericHeaders = {
+    Accept: 'application/vnd.vimeo.*+json; version=3.4.10',
+    'User-Agent': 'com.vimeo.android.videoapp (Google, Pixel 7a, google, Android 16/36 Version 11.8.1) Kotlin VimeoNetworking/3.12.0',
+    Authorization: 'Basic NzRmYTg5YjgxMWExY2JiNzUwZDg1MjhkMTYzZjQ4YWYyOGEyZGJlMTp4OGx2NFd3QnNvY1lkamI2UVZsdjdDYlNwSDUrdm50YzdNNThvWDcwN1JrenJGZC9tR1lReUNlRjRSVklZeWhYZVpRS0tBcU9YYzRoTGY2Z1dlVkJFYkdJc0dMRHpoZWFZbU0reDRqZ1dkZ1diZmdIdGUrNUM5RVBySlM0VG1qcw==',
+    'Accept-Language': 'en',
+}
+
+let bearer = '';
+
+const getBearer = async (refresh = false) => {
+    const cookie = getCookie('vimeo_bearer')?.values?.()?.access_token;
+    if ((bearer || cookie) && !refresh) return bearer || cookie;
+
+    const oauthResponse = await fetch(
+        'https://api.vimeo.com/oauth/authorize/client',
+        {
+            method: 'POST',
+            body: new URLSearchParams({
+                scope: 'private public create edit delete interact upload purchased stats',
+                grant_type: 'client_credentials',
+            }).toString(),
+            headers: {
+                ...genericHeaders,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            }
+        }
+    )
+    .then(a => a.json())
+    .catch(() => {});
+
+    if (!oauthResponse || !oauthResponse.access_token) {
+        return;
+    }
+
+    return bearer = oauthResponse.access_token;
+}
+
+const requestApiInfo = (bearerToken, videoId, password) => {
     if (password) {
         videoId += `:${password}`
     }
@@ -24,10 +62,8 @@ const requestApiInfo = (videoId, password) => {
         `https://api.vimeo.com/videos/${videoId}`,
         {
             headers: {
-                Accept: 'application/vnd.vimeo.*+json; version=3.4.2',
-                'User-Agent': 'Vimeo/10.19.0 (com.vimeo; build:101900.57.0; iOS 17.5.1) Alamofire/5.9.0 VimeoNetworking/5.0.0',
-                Authorization: 'Basic MTMxNzViY2Y0NDE0YTQ5YzhjZTc0YmU0NjVjNDQxYzNkYWVjOWRlOTpHKzRvMmgzVUh4UkxjdU5FRW80cDNDbDhDWGR5dVJLNUJZZ055dHBHTTB4V1VzaG41bEx1a2hiN0NWYWNUcldSSW53dzRUdFRYZlJEZmFoTTArOTBUZkJHS3R4V2llYU04Qnl1bERSWWxUdXRidjNqR2J4SHFpVmtFSUcyRktuQw==',
-                'Accept-Language': 'en'
+                ...genericHeaders,
+                Authorization: `Bearer ${bearerToken}`,
             }
         }
     )
@@ -40,7 +76,7 @@ const compareQuality = (rendition, requestedQuality) => {
     return Math.abs(quality - requestedQuality);
 }
 
-const getDirectLink = (data, quality) => {
+const getDirectLink = async (data, quality, subtitleLang) => {
     if (!data.files) return;
 
     const match = data.files
@@ -56,8 +92,23 @@ const getDirectLink = (data, quality) => {
 
     if (!match) return;
 
+    let subtitles;
+    if (subtitleLang && data.config_url) {
+        const config = await fetch(data.config_url)
+                    .then(r => r.json())
+                    .catch(() => {});
+
+        if (config && config.request?.text_tracks?.length) {
+            subtitles = config.request.text_tracks.find(
+                t => t.lang.startsWith(subtitleLang)
+            );
+            subtitles = new URL(subtitles.url, "https://player.vimeo.com/").toString();
+        }
+    }
+
     return {
         urls: match.link,
+        subtitles,
         filenameAttributes: {
             resolution: `${match.width}x${match.height}`,
             qualityLabel: match.rendition,
@@ -136,14 +187,33 @@ export default async function(obj) {
     if (quality < 240) quality = 240;
     if (!quality || obj.isAudioOnly) quality = 9000;
 
-    const info = await requestApiInfo(obj.id, obj.password);
+    const bearerToken = await getBearer();
+    if (!bearerToken) {
+        return { error: "fetch.fail" };
+    }
+
+    let info = await requestApiInfo(bearerToken, obj.id, obj.password);
     let response;
 
+    // auth error, try to refresh the token
+    if (info?.error_code === 8003) {
+        const newBearer = await getBearer(true);
+        if (!newBearer) {
+            return { error: "fetch.fail" };
+        }
+        info = await requestApiInfo(newBearer, obj.id, obj.password);
+    }
+
+    // if there's still no info, then return a generic error
+    if (!info || info.error_code) {
+        return { error: "fetch.empty" };
+    }
+
     if (obj.isAudioOnly) {
         response = await getHLS(info.config_url, { ...obj, quality });
     }
 
-    if (!response) response = getDirectLink(info, quality);
+    if (!response) response = await getDirectLink(info, quality, obj.subtitleLang);
     if (!response) response = { error: "fetch.empty" };
 
     if (response.error) {
@@ -155,6 +225,10 @@ export default async function(obj) {
         artist: info.user.name,
     };
 
+    if (response.subtitles) {
+        fileMetadata.sublanguage = obj.subtitleLang;
+    }
+
     return merge(
         {
             fileMetadata,

api/src/processing/services/vk.js

@@ -76,7 +76,7 @@ const getVideo = async (ownerId, videoId, accessKey) => {
     return video;
 }
 
-export default async function ({ ownerId, videoId, accessKey, quality }) {
+export default async function ({ ownerId, videoId, accessKey, quality, subtitleLang }) {
     const token = await getToken();
     if (!token) return { error: "fetch.fail" };
 
@@ -125,8 +125,20 @@ export default async function ({ ownerId, videoId, accessKey, quality }) {
         title: video.title.trim(),
     }
 
+    let subtitles;
+    if (subtitleLang && video.subtitles?.length) {
+        const subtitle = video.subtitles.find(
+            s => s.title.endsWith(".vtt") && s.lang.startsWith(subtitleLang)
+        );
+        if (subtitle) {
+            subtitles = subtitle.url;
+            fileMetadata.sublanguage = subtitleLang;
+        }
+    }
+
     return {
         urls: url,
+        subtitles,
         fileMetadata,
         filenameAttributes: {
             service: "vk",

api/src/processing/services/xiaohongshu.js

@@ -6,13 +6,13 @@ const https = (url) => {
     return url.replace(/^http:/i, 'https:');
 }
 
-export default async function ({ id, token, shareId, h265, isAudioOnly, dispatcher }) {
+export default async function ({ id, token, shareType, shareId, h265, isAudioOnly, dispatcher }) {
     let noteId = id;
     let xsecToken = token;
 
     if (!noteId) {
         const patternMatch = await resolveRedirectingURL(
-            `https://xhslink.com/a/${shareId}`,
+            `https://xhslink.com/${shareType}/${shareId}`,
             dispatcher
         );
 

api/src/processing/services/youtube.js

@@ -72,19 +72,98 @@ const cloneInnertube = async (customFetch, useSession) => {
 
     const session = new Session(
         innertube.session.context,
-        innertube.session.key,
+        innertube.session.api_key,
         innertube.session.api_version,
         innertube.session.account_index,
+        innertube.session.config_data,
         innertube.session.player,
         cookie,
         customFetch ?? innertube.session.http.fetch,
-        innertube.session.cache
+        innertube.session.cache,
+        sessionTokens?.potoken
     );
 
     const yt = new Innertube(session);
     return yt;
 }
 
+const getHlsVariants = async (hlsManifest, dispatcher) => {
+    if (!hlsManifest) {
+        return { error: "youtube.no_hls_streams" };
+    }
+
+    const fetchedHlsManifest =
+        await fetch(hlsManifest, { dispatcher })
+            .then(r => r.status === 200 ? r.text() : undefined)
+            .catch(() => {});
+
+    if (!fetchedHlsManifest) {
+        return { error: "youtube.no_hls_streams" };
+    }
+
+    const variants = HLS.parse(fetchedHlsManifest).variants.sort(
+        (a, b) => Number(b.bandwidth) - Number(a.bandwidth)
+    );
+
+    if (!variants || variants.length === 0) {
+        return { error: "youtube.no_hls_streams" };
+    }
+
+    return variants;
+}
+
+const getSubtitles = async (info, dispatcher, subtitleLang) => {
+    const preferredCap = info.captions.caption_tracks.find(caption =>
+        caption.kind !== 'asr' && caption.language_code.startsWith(subtitleLang)
+    );
+
+    const captionsUrl = preferredCap?.base_url;
+    if (!captionsUrl) return;
+
+    if (!captionsUrl.includes("exp=xpe")) {
+        let url = new URL(captionsUrl);
+        url.searchParams.set('fmt', 'vtt');
+
+        return {
+            url: url.toString(),
+            language: preferredCap.language_code,
+        }
+    }
+
+    // if we have exp=xpe in the url, then captions are
+    // locked down and can't be accessed without a yummy potoken,
+    // so instead we just use subtitles from HLS
+
+    const hlsVariants = await getHlsVariants(
+        info.streaming_data.hls_manifest_url,
+        dispatcher
+    );
+    if (hlsVariants?.error) return;
+
+    // all variants usually have the same set of subtitles
+    const hlsSubtitles = hlsVariants[0]?.subtitles;
+    if (!hlsSubtitles?.length) return;
+
+    const preferredHls = hlsSubtitles.find(
+        subtitle => subtitle.language.startsWith(subtitleLang)
+    );
+
+    if (!preferredHls) return;
+
+    const fetchedHlsSubs =
+        await fetch(preferredHls.uri, { dispatcher })
+            .then(r => r.status === 200 ? r.text() : undefined)
+            .catch(() => {});
+
+    const parsedSubs = HLS.parse(fetchedHlsSubs);
+    if (!parsedSubs) return;
+
+    return {
+        url: parsedSubs.segments[0]?.uri,
+        language: preferredHls.language,
+    }
+}
+
 export default async function (o) {
     const quality = o.quality === "max" ? 9000 : Number(o.quality);
 
@@ -92,7 +171,7 @@ export default async function (o) {
     let innertubeClient = o.innertubeClient || env.customInnertubeClient || "IOS";
 
     // HLS playlists from the iOS client don't contain the av1 video format.
-    if (useHLS && o.format === "av1") {
+    if (useHLS && o.codec === "av1") {
         useHLS = false;
     }
 
@@ -102,18 +181,24 @@ export default async function (o) {
 
     // iOS client doesn't have adaptive formats of resolution >1080p,
     // so we use the WEB_EMBEDDED client instead for those cases
-    const useSession =
+    let useSession =
         env.ytSessionServer && (
             (
                 !useHLS
                 && innertubeClient === "IOS"
                 && (
-                    (quality > 1080 && o.format !== "h264")
-                    || (quality > 1080 && o.format !== "vp9")
+                    (quality > 1080 && o.codec !== "h264")
+                    || (quality > 1080 && o.codec !== "vp9")
                 )
             )
         );
 
+    // we can get subtitles reliably only from the iOS client
+    if (o.subtitleLang) {
+        innertubeClient = "IOS";
+        useSession = false;
+    }
+
     if (useSession) {
         innertubeClient = env.ytSessionInnertubeClient || "WEB_EMBEDDED";
     }
@@ -139,7 +224,7 @@ export default async function (o) {
 
     let info;
     try {
-        info = await yt.getBasicInfo(o.id, innertubeClient);
+        info = await yt.getBasicInfo(o.id, { client: innertubeClient });
     } catch (e) {
         if (e?.info) {
             let errorInfo;
@@ -220,37 +305,16 @@ export default async function (o) {
         return videoQualities.find(qual => qual >= shortestSide);
     }
 
-    let video, audio, dubbedLanguage,
-        codec = o.format || "h264", itag = o.itag;
+    let video, audio, subtitles, dubbedLanguage,
+        codec = o.codec || "h264", itag = o.itag;
 
     if (useHLS) {
-        const hlsManifest = info.streaming_data.hls_manifest_url;
-
-        if (!hlsManifest) {
-            return { error: "youtube.no_hls_streams" };
-        }
-
-        const fetchedHlsManifest = await fetch(hlsManifest, {
-            dispatcher: o.dispatcher,
-        }).then(r => {
-            if (r.status === 200) {
-                return r.text();
-            } else {
-                throw new Error("couldn't fetch the HLS playlist");
-            }
-        }).catch(() => { });
-
-        if (!fetchedHlsManifest) {
-            return { error: "youtube.no_hls_streams" };
-        }
-
-        const variants = HLS.parse(fetchedHlsManifest).variants.sort(
-            (a, b) => Number(b.bandwidth) - Number(a.bandwidth)
+        const variants = await getHlsVariants(
+            info.streaming_data.hls_manifest_url,
+            o.dispatcher
         );
 
-        if (!variants || variants.length === 0) {
-            return { error: "youtube.no_hls_streams" };
-        }
+        if (variants?.error) return variants;
 
         const matchHlsCodec = codecs => (
             codecs.includes(hlsCodecList[codec].videoCodec)
@@ -278,7 +342,7 @@ export default async function (o) {
         // some videos (mainly those with AI dubs) don't have any tracks marked as default
         // why? god knows, but we assume that a default track is marked as such in the title
         if (!audio) {
-            audio = selected.audio.find(i => i.name.endsWith("- original"));
+            audio = selected.audio.find(i => i.name.endsWith("original"));
         }
 
         if (o.dubLang) {
@@ -367,9 +431,9 @@ export default async function (o) {
 
         audio = sorted_formats[codec].bestAudio;
 
-        if (audio?.audio_track && !audio?.audio_track?.audio_is_default) {
+        if (audio?.audio_track && !audio?.is_original) {
             audio = sorted_formats[codec].audio.find(i =>
-                i?.audio_track?.audio_is_default
+                i?.is_original
             );
         }
 
@@ -378,7 +442,7 @@ export default async function (o) {
                 i.language?.startsWith(o.dubLang) && i.audio_track
             );
 
-            if (dubbedAudio && !dubbedAudio?.audio_track?.audio_is_default) {
+            if (dubbedAudio && !dubbedAudio?.is_original) {
                 audio = dubbedAudio;
                 dubbedLanguage = dubbedAudio.language;
             }
@@ -401,6 +465,13 @@ export default async function (o) {
 
             if (!video) video = sorted_formats[codec].bestVideo;
         }
+
+        if (o.subtitleLang && !o.isAudioOnly && info.captions?.caption_tracks?.length) {
+            const videoSubtitles = await getSubtitles(info, o.dispatcher, o.subtitleLang);
+            if (videoSubtitles) {
+                subtitles = videoSubtitles;
+            }
+        }
     }
 
     if (video?.drm_families || audio?.drm_families) {
@@ -424,6 +495,10 @@ export default async function (o) {
         }
     }
 
+    if (subtitles) {
+        fileMetadata.sublanguage = subtitles.language;
+    }
+
     const filenameAttributes = {
         service: "youtube",
         id: o.id,
@@ -457,6 +532,15 @@ export default async function (o) {
             urls = audio.decipher(innertube.session.player);
         }
 
+        let cover = `https://i.ytimg.com/vi/${o.id}/maxresdefault.jpg`;
+        const testMaxCover = await fetch(cover, { dispatcher: o.dispatcher })
+            .then(r => r.status === 200)
+            .catch(() => {});
+
+        if (!testMaxCover) {
+            cover = basicInfo.thumbnail?.[0]?.url;
+        }
+
         return {
             type: "audio",
             isAudioOnly: true,
@@ -465,7 +549,10 @@ export default async function (o) {
             fileMetadata,
             bestAudio,
             isHLS: useHLS,
-            originalRequest
+            originalRequest,
+
+            cover,
+            cropCover: basicInfo.author.endsWith("- Topic"),
         }
     }
 
@@ -475,7 +562,7 @@ export default async function (o) {
         if (useHLS) {
             resolution = normalizeQuality(video.resolution);
             filenameAttributes.resolution = `${video.resolution.width}x${video.resolution.height}`;
-            filenameAttributes.extension = hlsCodecList[codec].container;
+            filenameAttributes.extension = o.container === "auto" ? hlsCodecList[codec].container : o.container;
 
             video = video.uri;
             audio = audio.uri;
@@ -486,7 +573,7 @@ export default async function (o) {
             });
 
             filenameAttributes.resolution = `${video.width}x${video.height}`;
-            filenameAttributes.extension = codecList[codec].container;
+            filenameAttributes.extension = o.container === "auto" ? codecList[codec].container : o.container;
 
             if (!clientsWithNoCipher.includes(innertubeClient) && innertube) {
                 video = video.decipher(innertube.session.player);
@@ -506,6 +593,7 @@ export default async function (o) {
                 video,
                 audio,
             ],
+            subtitles: subtitles?.url,
             filenameAttributes,
             fileMetadata,
             isHLS: useHLS,

api/src/processing/url.js

@@ -17,7 +17,7 @@ function aliasURL(url) {
             if (url.pathname.startsWith('/live/') || url.pathname.startsWith('/shorts/')) {
                 url.pathname = '/watch';
                 // parts := ['', 'live' || 'shorts', id, ...rest]
-                url.search = `?v=${encodeURIComponent(parts[2])}`
+                url.search = `?v=${encodeURIComponent(parts[2])}`;
             }
             break;
 
@@ -61,23 +61,23 @@ function aliasURL(url) {
 
         case "b23":
             if (url.hostname === 'b23.tv' && parts.length === 2) {
-                url = new URL(`https://bilibili.com/_shortLink/${parts[1]}`)
+                url = new URL(`https://bilibili.com/_shortLink/${parts[1]}`);
             }
             break;
 
         case "dai":
             if (url.hostname === 'dai.ly' && parts.length === 2) {
-                url = new URL(`https://dailymotion.com/video/${parts[1]}`)
+                url = new URL(`https://dailymotion.com/video/${parts[1]}`);
             }
             break;
 
         case "facebook":
         case "fb":
             if (url.searchParams.get('v')) {
-                url = new URL(`https://web.facebook.com/user/videos/${url.searchParams.get('v')}`)
+                url = new URL(`https://web.facebook.com/user/videos/${url.searchParams.get('v')}`);
             }
             if (url.hostname === 'fb.watch') {
-                url = new URL(`https://web.facebook.com/_shortLink/${parts[1]}`)
+                url = new URL(`https://web.facebook.com/_shortLink/${parts[1]}`);
             }
             break;
 
@@ -92,11 +92,14 @@ function aliasURL(url) {
             if (services.vk.altDomains.includes(url.hostname)) {
                 url.hostname = 'vk.com';
             }
+            if (url.searchParams.get('z')) {
+                url = new URL(`https://vk.com/${url.searchParams.get('z')}`);
+            }
             break;
 
         case "xhslink":
             if (url.hostname === 'xhslink.com' && parts.length === 3) {
-                url = new URL(`https://www.xiaohongshu.com/a/${parts[2]}`);
+                url = new URL(`https://www.xiaohongshu.com/${parts[1]}/${parts[2]}`);
             }
             break;
 
@@ -106,7 +109,7 @@ function aliasURL(url) {
                 url.pathname = `/share/${idPart.slice(-32)}`;
             }
             break;
-            
+
         case "redd":
             /* reddit short video links can be treated by changing https://v.redd.it/<id>
             to https://reddit.com/video/<id>.*/
@@ -144,6 +147,7 @@ function cleanURL(url) {
                 limitQuery('v');
             }
             break;
+        case "bilibili":
         case "rutube":
             if (url.searchParams.get('p')) {
                 limitQuery('p');
@@ -196,7 +200,7 @@ export function normalizeURL(url) {
     );
 }
 
-export function extract(url) {
+export function extract(url, enabledServices = env.enabledServices) {
     if (!(url instanceof URL)) {
         url = new URL(url);
     }
@@ -207,7 +211,7 @@ export function extract(url) {
         return { error: "link.invalid" };
     }
 
-    if (!env.enabledServices.has(host)) {
+    if (!enabledServices.has(host)) {
         // show a different message when youtube is disabled on official instances
         // as it only happens when shit hits the fan
         if (new URL(env.apiURL).hostname.endsWith(".imput.net") && host === "youtube") {

api/src/security/api-keys.js

@@ -1,8 +1,8 @@
 import { env } from "../config.js";
-import { readFile } from "node:fs/promises";
 import { Green, Yellow } from "../misc/console-text.js";
 import ip from "ipaddr.js";
 import * as cluster from "../misc/cluster.js";
+import { FileWatcher } from "../misc/file-watcher.js";
 
 // this function is a modified variation of code
 // from https://stackoverflow.com/a/32402438/14855621
@@ -13,9 +13,9 @@ const generateWildcardRegex = rule => {
 
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
-let keys = {};
+let keys = {}, reader = null;
 
-const ALLOWED_KEYS = new Set(['name', 'ips', 'userAgents', 'limit']);
+const ALLOWED_KEYS = new Set(['name', 'ips', 'userAgents', 'limit', 'allowedServices']);
 
 /* Expected format pseudotype:
 ** type KeyFileContents = Record<
@@ -24,7 +24,8 @@ const ALLOWED_KEYS = new Set(['name', 'ips', 'userAgents', 'limit']);
 **        name?: string,
 **        limit?: number | "unlimited",
 **        ips?: CIDRString[],
-**        userAgents?: string[]
+**        userAgents?: string[],
+**        allowedServices?: "all" | string[],
 **    }
 ** >;
 */
@@ -77,6 +78,19 @@ const validateKeys = (input) => {
                 throw "`userAgents` in details contains an invalid user agent: " + invalid_ua;
             }
         }
+
+        if (details.allowedServices) {
+            if (Array.isArray(details.allowedServices)) {
+                const invalid_services = details.allowedServices.some(
+                    service => !env.allServices.has(service)
+                );
+                if (invalid_services) {
+                    throw "`allowedServices` in details contains an invalid service";
+                }
+            } else if (details.allowedServices !== "all") {
+                throw "details object contains value for `allowedServices` which is not an array or `all`";
+            }
+        }
     });
 }
 
@@ -112,40 +126,53 @@ const formatKeys = (keyData) => {
         if (data.userAgents) {
             formatted[key].userAgents = data.userAgents.map(generateWildcardRegex);
         }
+
+        if (data.allowedServices) {
+            if (Array.isArray(data.allowedServices)) {
+                formatted[key].allowedServices = new Set(data.allowedServices);
+            } else {
+                formatted[key].allowedServices = data.allowedServices;
+            }
+        }
     }
 
     return formatted;
 }
 
 const updateKeys = (newKeys) => {
-    keys = formatKeys(newKeys);
-}
+    validateKeys(newKeys);
 
-const loadKeys = async (source) => {
-    let updated;
-    if (source.protocol === 'file:') {
-        const pathname = source.pathname === '/' ? '' : source.pathname;
-        updated = JSON.parse(
-            await readFile(
-                decodeURIComponent(source.host + pathname),
-                'utf8'
-            )
-        );
-    } else {
-        updated = await fetch(source).then(a => a.json());
-    }
+    cluster.broadcast({ api_keys: newKeys });
 
-    validateKeys(updated);
+    keys = formatKeys(newKeys);
+}
 
-    cluster.broadcast({ api_keys: updated });
+const loadRemoteKeys = async (source) => {
+    updateKeys(
+        await fetch(source).then(a => a.json())
+    );
+}
 
-    updateKeys(updated);
+const loadLocalKeys = async () => {
+    updateKeys(
+        JSON.parse(await reader.read())
+    );
 }
 
 const wrapLoad = (url, initial = false) => {
-    loadKeys(url)
-    .then(() => {
+    let load = loadRemoteKeys.bind(null, url);
+
+    if (url.protocol === 'file:') {
         if (initial) {
+            reader = FileWatcher.fromFileProtocol(url);
+            reader.on('file-updated', () => wrapLoad(url));
+        }
+
+        load = loadLocalKeys;
+    }
+
+    load().then(() => {
+        if (initial || reader) {
             console.log(`${Green('[✓]')} api keys loaded successfully!`)
         }
     })
@@ -214,7 +241,7 @@ export const validateAuthorization = (req) => {
 export const setup = (url) => {
     if (cluster.isPrimary) {
         wrapLoad(url, true);
-        if (env.keyReloadInterval > 0) {
+        if (env.keyReloadInterval > 0 && url.protocol !== 'file:') {
             setInterval(() => wrapLoad(url), env.keyReloadInterval * 1000);
         }
     } else if (cluster.isWorker) {
@@ -225,3 +252,15 @@ export const setup = (url) => {
         });
     }
 }
+
+export const getAllowedServices = (key) => {
+    if (typeof key !== "string") return;
+
+    const allowedServices = keys[key.toLowerCase()]?.allowedServices;
+    if (!allowedServices) return;
+
+    if (allowedServices === "all") {
+        return env.allServices;
+    }
+    return allowedServices;
+}

api/src/stream/ffmpeg.js

@@ -0,0 +1,215 @@
+import ffmpeg from "ffmpeg-static";
+import { spawn } from "child_process";
+import { create as contentDisposition } from "content-disposition-header";
+
+import { env } from "../config.js";
+import { destroyInternalStream } from "./manage.js";
+import { hlsExceptions } from "../processing/service-config.js";
+import { closeResponse, pipe, estimateTunnelLength, estimateAudioMultiplier } from "./shared.js";
+
+const metadataTags = new Set([
+    "album",
+    "composer",
+    "genre",
+    "copyright",
+    "title",
+    "artist",
+    "album_artist",
+    "track",
+    "date",
+    "sublanguage"
+]);
+
+const convertMetadataToFFmpeg = (metadata) => {
+    const args = [];
+
+    for (const [ name, value ] of Object.entries(metadata)) {
+        if (metadataTags.has(name)) {
+            if (name === "sublanguage") {
+                args.push('-metadata:s:s:0', `language=${value}`);
+                continue;
+            }
+            args.push('-metadata', `${name}=${value.replace(/[\u0000-\u0009]/g, '')}`); // skipcq: JS-0004
+        } else {
+            throw `${name} metadata tag is not supported.`;
+        }
+    }
+
+    return args;
+}
+
+const killProcess = (p) => {
+    p?.kill('SIGTERM'); // ask the process to terminate itself gracefully
+
+    setTimeout(() => {
+        if (p?.exitCode === null)
+            p?.kill('SIGKILL'); // brutally murder the process if it didn't quit
+    }, 5000);
+}
+
+const getCommand = (args) => {
+    if (typeof env.processingPriority === 'number' && !isNaN(env.processingPriority)) {
+        return ['nice', ['-n', env.processingPriority.toString(), ffmpeg, ...args]]
+    }
+    return [ffmpeg, args]
+}
+
+const render = async (res, streamInfo, ffargs, estimateMultiplier) => {
+    let process;
+    const urls = Array.isArray(streamInfo.urls) ? streamInfo.urls : [streamInfo.urls];
+    const shutdown = () => (
+        killProcess(process),
+        closeResponse(res),
+        urls.map(destroyInternalStream)
+    );
+
+    try {
+        const args = [
+            '-loglevel', '-8',
+            ...ffargs,
+        ];
+
+        process = spawn(...getCommand(args), {
+            windowsHide: true,
+            stdio: [
+                'inherit', 'inherit', 'inherit',
+                'pipe'
+            ],
+        });
+
+        const [,,, muxOutput] = process.stdio;
+
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('Content-Disposition', contentDisposition(streamInfo.filename));
+
+        res.setHeader(
+            'Estimated-Content-Length',
+            await estimateTunnelLength(streamInfo, estimateMultiplier)
+        );
+
+        pipe(muxOutput, res, shutdown);
+
+        process.on('close', shutdown);
+        res.on('finish', shutdown);
+    } catch {
+        shutdown();
+    }
+}
+
+const remux = async (streamInfo, res) => {
+    const format = streamInfo.filename.split('.').pop();
+    const urls = Array.isArray(streamInfo.urls) ? streamInfo.urls : [streamInfo.urls];
+    const args = urls.flatMap(url => ['-i', url]);
+
+    // if the stream type is merge, we expect two URLs
+    if (streamInfo.type === 'merge' && urls.length !== 2) {
+        return closeResponse(res);
+    }
+
+    if (streamInfo.subtitles) {
+        args.push(
+            '-i', streamInfo.subtitles,
+            '-map', `${urls.length}:s`,
+            '-c:s', format === 'mp4' ? 'mov_text' : 'webvtt',
+        );
+    }
+
+    if (urls.length === 2) {
+        args.push(
+            '-map', '0:v',
+            '-map', '1:a',
+        );
+    } else {
+        args.push(
+            '-map', '0:v:0',
+            '-map', '0:a:0'
+        );
+    }
+
+    args.push(
+        '-c:v', 'copy',
+        ...(streamInfo.type === 'mute' ? ['-an'] : ['-c:a', 'copy'])
+    );
+
+    if (format === 'mp4') {
+        args.push('-movflags', 'faststart+frag_keyframe+empty_moov');
+    }
+
+    if (streamInfo.type !== 'mute' && streamInfo.isHLS && hlsExceptions.has(streamInfo.service)) {
+        if (streamInfo.service === 'youtube' && format === 'webm') {
+            args.push('-c:a', 'libopus');
+        } else {
+            args.push('-c:a', 'aac', '-bsf:a', 'aac_adtstoasc');
+        }
+    }
+
+    if (streamInfo.metadata) {
+        args.push(...convertMetadataToFFmpeg(streamInfo.metadata));
+    }
+
+    args.push('-f', format === 'mkv' ? 'matroska' : format, 'pipe:3');
+
+    await render(res, streamInfo, args);
+}
+
+const convertAudio = async (streamInfo, res) => {
+    const args = [
+        '-i', streamInfo.urls,
+        '-vn',
+        ...(streamInfo.audioCopy ? ['-c:a', 'copy'] : ['-b:a', `${streamInfo.audioBitrate}k`]),
+    ];
+
+    if (streamInfo.audioFormat === 'mp3' && streamInfo.audioBitrate === '8') {
+        args.push('-ar', '12000');
+    }
+
+    if (streamInfo.audioFormat === 'opus') {
+        args.push('-vbr', 'off');
+    }
+
+    if (streamInfo.audioFormat === 'mp4a') {
+        args.push('-movflags', 'frag_keyframe+empty_moov');
+    }
+
+    if (streamInfo.metadata) {
+        args.push(...convertMetadataToFFmpeg(streamInfo.metadata));
+    }
+
+    args.push(
+        '-f',
+        streamInfo.audioFormat === 'm4a' ? 'ipod' : streamInfo.audioFormat,
+        'pipe:3',
+    );
+
+    await render(
+        res,
+        streamInfo,
+        args,
+        estimateAudioMultiplier(streamInfo) * 1.1,
+    );
+}
+
+const convertGif = async (streamInfo, res) => {
+    const args = [
+        '-i', streamInfo.urls,
+
+        '-vf',
+        'scale=-1:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse',
+        '-loop', '0',
+
+        '-f', 'gif', 'pipe:3',
+    ];
+
+    await render(
+        res,
+        streamInfo,
+        args,
+        60,
+    );
+}
+
+export default {
+    remux,
+    convertAudio,
+    convertGif,
+}

api/src/stream/internal-hls.js

@@ -1,5 +1,6 @@
 import HLS from "hls-parser";
 import { createInternalStream } from "./manage.js";
+import { request } from "undici";
 
 function getURL(url) {
     try {
@@ -55,8 +56,11 @@ function transformMediaPlaylist(streamInfo, hlsPlaylist) {
 
 const HLS_MIME_TYPES = ["application/vnd.apple.mpegurl", "audio/mpegurl", "application/x-mpegURL"];
 
-export function isHlsResponse (req) {
-    return HLS_MIME_TYPES.includes(req.headers['content-type']);
+export function isHlsResponse(req, streamInfo) {
+    return HLS_MIME_TYPES.includes(req.headers['content-type'])
+        // bluesky's cdn responds with wrong content-type for the hls playlist,
+        // so we enforce it here until they fix it
+        || (streamInfo.service === 'bsky' && streamInfo.url.endsWith('.m3u8'));
 }
 
 export async function handleHlsPlaylist(streamInfo, req, res) {
@@ -71,3 +75,67 @@ export async function handleHlsPlaylist(streamInfo, req, res) {
 
     res.send(hlsPlaylist);
 }
+
+async function getSegmentSize(url, config) {
+    const segmentResponse = await request(url, {
+        ...config,
+        throwOnError: true
+    });
+
+    if (segmentResponse.headers['content-length']) {
+        segmentResponse.body.dump();
+        return +segmentResponse.headers['content-length'];
+    }
+
+    // if the response does not have a content-length
+    // header, we have to compute it ourselves
+    let size = 0;
+
+    for await (const data of segmentResponse.body) {
+        size += data.length;
+    }
+
+    return size;
+}
+
+export async function probeInternalHLSTunnel(streamInfo) {
+    const { url, headers, dispatcher, signal } = streamInfo;
+
+    // remove all falsy headers
+    Object.keys(headers).forEach(key => {
+        if (!headers[key]) delete headers[key];
+    });
+
+    const config = { headers, dispatcher, signal, maxRedirections: 16 };
+
+    const manifestResponse = await fetch(url, config);
+
+    const manifest = HLS.parse(await manifestResponse.text());
+    if (manifest.segments.length === 0)
+        return -1;
+
+    const segmentSamples = await Promise.all(
+        Array(5).fill().map(async () => {
+            const manifestIdx = Math.floor(Math.random() * manifest.segments.length);
+            const randomSegment = manifest.segments[manifestIdx];
+            if (!randomSegment.uri)
+                throw "segment is missing URI";
+
+            let segmentUrl;
+
+            if (getURL(randomSegment.uri)) {
+                segmentUrl = new URL(randomSegment.uri);
+            } else {
+                segmentUrl = new URL(randomSegment.uri, streamInfo.url);
+            }
+
+            const segmentSize = await getSegmentSize(segmentUrl, config) / randomSegment.duration;
+            return segmentSize;
+        })
+    );
+
+    const averageBitrate = segmentSamples.reduce((a, b) => a + b) / segmentSamples.length;
+    const totalDuration = manifest.segments.reduce((acc, segment) => acc + segment.duration, 0);
+
+    return averageBitrate * totalDuration;
+}

api/src/stream/internal.js

@@ -1,11 +1,13 @@
 import { request } from "undici";
 import { Readable } from "node:stream";
 import { closeRequest, getHeaders, pipe } from "./shared.js";
-import { handleHlsPlaylist, isHlsResponse } from "./internal-hls.js";
+import { handleHlsPlaylist, isHlsResponse, probeInternalHLSTunnel } from "./internal-hls.js";
 
 const CHUNK_SIZE = BigInt(8e6); // 8 MB
 const min = (a, b) => a < b ? a : b;
 
+const serviceNeedsChunks = new Set(["youtube", "vk"]);
+
 async function* readChunks(streamInfo, size) {
     let read = 0n, chunksSinceTransplant = 0;
     while (read < size) {
@@ -15,7 +17,7 @@ async function* readChunks(streamInfo, size) {
 
         const chunk = await request(streamInfo.url, {
             headers: {
-                ...getHeaders('youtube'),
+                ...getHeaders(streamInfo.service),
                 Range: `bytes=${read}-${read + CHUNK_SIZE}`
             },
             dispatcher: streamInfo.dispatcher,
@@ -48,7 +50,7 @@ async function* readChunks(streamInfo, size) {
     }
 }
 
-async function handleYoutubeStream(streamInfo, res) {
+async function handleChunkedStream(streamInfo, res) {
     const { signal } = streamInfo.controller;
     const cleanup = () => (res.end(), closeRequest(streamInfo.controller));
 
@@ -56,7 +58,7 @@ async function handleYoutubeStream(streamInfo, res) {
         let req, attempts = 3;
         while (attempts--) {
             req = await fetch(streamInfo.url, {
-                headers: getHeaders('youtube'),
+                headers: getHeaders(streamInfo.service),
                 method: 'HEAD',
                 dispatcher: streamInfo.dispatcher,
                 signal
@@ -118,10 +120,7 @@ async function handleGenericStream(streamInfo, res) {
         res.status(fileResponse.statusCode);
         fileResponse.body.on('error', () => {});
 
-        // bluesky's cdn responds with wrong content-type for the hls playlist,
-        // so we enforce it here until they fix it
-        const isHls = isHlsResponse(fileResponse)
-                      || (streamInfo.service === "bsky" && streamInfo.url.endsWith('.m3u8'));
+        const isHls = isHlsResponse(fileResponse, streamInfo);
 
         for (const [ name, value ] of Object.entries(fileResponse.headers)) {
             if (!isHls || name.toLowerCase() !== 'content-length') {
@@ -149,9 +148,46 @@ export function internalStream(streamInfo, res) {
         streamInfo.headers.delete('icy-metadata');
     }
 
-    if (streamInfo.service === 'youtube' && !streamInfo.isHLS) {
-        return handleYoutubeStream(streamInfo, res);
+    if (serviceNeedsChunks.has(streamInfo.service) && !streamInfo.isHLS) {
+        return handleChunkedStream(streamInfo, res);
     }
 
     return handleGenericStream(streamInfo, res);
 }
+
+export async function probeInternalTunnel(streamInfo) {
+    try {
+        const signal = AbortSignal.timeout(3000);
+        const headers = {
+            ...Object.fromEntries(streamInfo.headers || []),
+            ...getHeaders(streamInfo.service),
+            host: undefined,
+            range: undefined
+        };
+
+        if (streamInfo.isHLS) {
+            return probeInternalHLSTunnel({
+                ...streamInfo,
+                signal,
+                headers
+            });
+        }
+
+        const response = await request(streamInfo.url, {
+            method: 'HEAD',
+            headers,
+            dispatcher: streamInfo.dispatcher,
+            signal,
+            maxRedirections: 16
+        });
+
+        if (response.statusCode !== 200)
+            throw "status is not 200 OK";
+
+        const size = +response.headers['content-length'];
+        if (isNaN(size))
+            throw "content-length is not a number";
+
+        return size;
+    } catch {}
+}

api/src/stream/manage.js

@@ -41,7 +41,10 @@ export function createStream(obj) {
             audioFormat: obj.audioFormat,
 
             isHLS: obj.isHLS || false,
-            originalRequest: obj.originalRequest
+            originalRequest: obj.originalRequest,
+
+            // url to a subtitle file
+            subtitles: obj.subtitles,
         };
 
     // FIXME: this is now a Promise, but it is not awaited
@@ -70,11 +73,70 @@ export function createStream(obj) {
     return streamLink.toString();
 }
 
-export function getInternalStream(id) {
+export function createProxyTunnels(info) {
+    const proxyTunnels = [];
+
+    let urls = info.url;
+
+    if (typeof urls === "string") {
+        urls = [urls];
+    }
+
+    const tunnelTemplate = {
+        type: "proxy",
+        headers: info?.headers,
+        requestIP: info?.requestIP,
+    }
+
+    for (const url of urls) {
+        proxyTunnels.push(
+            createStream({
+                ...tunnelTemplate,
+                url,
+                service: info?.service,
+                originalRequest: info?.originalRequest,
+            })
+        );
+    }
+
+    if (info.subtitles) {
+        proxyTunnels.push(
+            createStream({
+                ...tunnelTemplate,
+                url: info.subtitles,
+                service: `${info?.service}-subtitles`,
+            })
+        );
+    }
+
+    if (info.cover) {
+        proxyTunnels.push(
+            createStream({
+                ...tunnelTemplate,
+                url: info.cover,
+                service: `${info?.service}-cover`,
+            })
+        );
+    }
+
+    return proxyTunnels;
+}
+
+export function getInternalTunnel(id) {
     return internalStreamCache.get(id);
 }
 
-export function createInternalStream(url, obj = {}) {
+export function getInternalTunnelFromURL(url) {
+    url = new URL(url);
+    if (url.hostname !== '127.0.0.1') {
+        return;
+    }
+
+    const id = url.searchParams.get('id');
+    return getInternalTunnel(id);
+}
+
+export function createInternalStream(url, obj = {}, isSubtitles) {
     assert(typeof url === 'string');
 
     let dispatcher = obj.dispatcher;
@@ -95,9 +157,12 @@ export function createInternalStream(url, obj = {}) {
         headers = new Map(Object.entries(obj.headers));
     }
 
+    // subtitles don't need special treatment unlike big media files
+    const service = isSubtitles ? `${obj.service}-subtitles` : obj.service;
+
     internalStreamCache.set(streamID, {
         url,
-        service: obj.service,
+        service,
         headers,
         controller,
         dispatcher,
@@ -131,7 +196,7 @@ export function destroyInternalStream(url) {
     const id = getInternalTunnelId(url);
 
     if (internalStreamCache.has(id)) {
-        closeRequest(getInternalStream(id)?.controller);
+        closeRequest(getInternalTunnel(id)?.controller);
         internalStreamCache.delete(id);
     }
 }
@@ -143,7 +208,7 @@ const transplantInternalTunnels = function(tunnelUrls, transplantUrls) {
 
     for (const [ tun, url ] of zip(tunnelUrls, transplantUrls)) {
         const id = getInternalTunnelId(tun);
-        const itunnel = getInternalStream(id);
+        const itunnel = getInternalTunnel(id);
 
         if (!itunnel) continue;
         itunnel.url = url;
@@ -208,6 +273,14 @@ function wrapStream(streamInfo) {
         }
     } else throw 'invalid urls';
 
+    if (streamInfo.subtitles) {
+        streamInfo.subtitles = createInternalStream(
+            streamInfo.subtitles,
+            streamInfo,
+            /*isSubtitles=*/true
+        );
+    }
+
     return streamInfo;
 }
 

api/src/stream/proxy.js

@@ -0,0 +1,43 @@
+import { Agent, request } from "undici";
+import { create as contentDisposition } from "content-disposition-header";
+
+import { destroyInternalStream } from "./manage.js";
+import { getHeaders, closeRequest, closeResponse, pipe } from "./shared.js";
+
+const defaultAgent = new Agent();
+
+export default async function (streamInfo, res) {
+    const abortController = new AbortController();
+    const shutdown = () => (
+        closeRequest(abortController),
+        closeResponse(res),
+        destroyInternalStream(streamInfo.urls)
+    );
+
+    try {
+        res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+        res.setHeader('Content-disposition', contentDisposition(streamInfo.filename));
+
+        const { body: stream, headers, statusCode } = await request(streamInfo.urls, {
+            headers: {
+                ...getHeaders(streamInfo.service),
+                Range: streamInfo.range
+            },
+            signal: abortController.signal,
+            maxRedirections: 16,
+            dispatcher: defaultAgent,
+        });
+
+        res.status(statusCode);
+
+        for (const headerName of ['accept-ranges', 'content-type', 'content-length']) {
+            if (headers[headerName]) {
+                res.setHeader(headerName, headers[headerName]);
+            }
+        }
+
+        pipe(stream, res, shutdown);
+    } catch {
+        shutdown();
+    }
+}

api/src/stream/shared.js

@@ -1,5 +1,7 @@
 import { genericUserAgent } from "../config.js";
 import { vkClientAgent } from "../processing/services/vk.js";
+import { getInternalTunnelFromURL } from "./manage.js";
+import { probeInternalTunnel } from "./internal.js";
 
 const defaultHeaders = {
     'user-agent': genericUserAgent
@@ -17,6 +19,9 @@ const serviceHeaders = {
     },
     vk: {
         'user-agent': vkClientAgent
+    },
+    tiktok: {
+        referer: 'https://www.tiktok.com/',
     }
 }
 
@@ -47,3 +52,40 @@ export function pipe(from, to, done) {
 
     from.pipe(to);
 }
+
+export async function estimateTunnelLength(streamInfo, multiplier = 1.1) {
+    let urls = streamInfo.urls;
+    if (!Array.isArray(urls)) {
+        urls = [ urls ];
+    }
+
+    const internalTunnels = urls.map(getInternalTunnelFromURL);
+    if (internalTunnels.some(t => !t))
+        return -1;
+
+    const sizes = await Promise.all(internalTunnels.map(probeInternalTunnel));
+    const estimatedSize = sizes.reduce(
+        // if one of the sizes is missing, let's just make a very
+        // bold guess that it's the same size as the existing one
+        (acc, cur) => cur <= 0 ? acc * 2 : acc + cur,
+        0
+    );
+
+    if (isNaN(estimatedSize) || estimatedSize <= 0) {
+        return -1;
+    }
+
+    return Math.floor(estimatedSize * multiplier);
+}
+
+export function estimateAudioMultiplier(streamInfo) {
+    if (streamInfo.audioFormat === 'wav') {
+        return 1411 / 128;
+    }
+
+    if (streamInfo.audioCopy) {
+        return 1;
+    }
+
+    return streamInfo.audioBitrate / 128;
+}

api/src/stream/stream.js

@@ -1,4 +1,5 @@
-import stream from "./types.js";
+import proxy from "./proxy.js";
+import ffmpeg from "./ffmpeg.js";
 
 import { closeResponse } from "./shared.js";
 import { internalStream } from "./internal.js";
@@ -7,23 +8,21 @@ export default async function(res, streamInfo) {
     try {
         switch (streamInfo.type) {
             case "proxy":
-                return await stream.proxy(streamInfo, res);
+                return await proxy(streamInfo, res);
 
             case "internal":
-                return internalStream(streamInfo.data, res);
+                return await internalStream(streamInfo.data, res);
 
             case "merge":
-                return stream.merge(streamInfo, res);
-
             case "remux":
             case "mute":
-                return stream.remux(streamInfo, res);
+                return await ffmpeg.remux(streamInfo, res);
 
             case "audio":
-                return stream.convertAudio(streamInfo, res);
+                return await ffmpeg.convertAudio(streamInfo, res);
 
             case "gif":
-                return stream.convertGif(streamInfo, res);
+                return await ffmpeg.convertGif(streamInfo, res);
         }
 
         closeResponse(res);

api/src/stream/types.js

@@ -1,340 +0,0 @@
-import { Agent, request } from "undici";
-import ffmpeg from "ffmpeg-static";
-import { spawn } from "child_process";
-import { create as contentDisposition } from "content-disposition-header";
-
-import { env } from "../config.js";
-import { destroyInternalStream } from "./manage.js";
-import { hlsExceptions } from "../processing/service-config.js";
-import { getHeaders, closeRequest, closeResponse, pipe } from "./shared.js";
-
-const ffmpegArgs = {
-    webm: ["-c:v", "copy", "-c:a", "copy"],
-    mp4: ["-c:v", "copy", "-c:a", "copy", "-movflags", "faststart+frag_keyframe+empty_moov"],
-    m4a: ["-movflags", "frag_keyframe+empty_moov"],
-    gif: ["-vf", "scale=-1:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse", "-loop", "0"]
-}
-
-const metadataTags = [
-    "album",
-    "copyright",
-    "title",
-    "artist",
-    "track",
-    "date",
-];
-
-const convertMetadataToFFmpeg = (metadata) => {
-    let args = [];
-
-    for (const [ name, value ] of Object.entries(metadata)) {
-        if (metadataTags.includes(name)) {
-            args.push('-metadata', `${name}=${value.replace(/[\u0000-\u0009]/g, "")}`);
-        } else {
-            throw `${name} metadata tag is not supported.`;
-        }
-    }
-
-    return args;
-}
-
-const toRawHeaders = (headers) => {
-    return Object.entries(headers)
-                 .map(([key, value]) => `${key}: ${value}\r\n`)
-                 .join('');
-}
-
-const killProcess = (p) => {
-    p?.kill('SIGTERM'); // ask the process to terminate itself gracefully
-
-    setTimeout(() => {
-        if (p?.exitCode === null)
-            p?.kill('SIGKILL'); // brutally murder the process if it didn't quit
-    }, 5000);
-}
-
-const getCommand = (args) => {
-    if (typeof env.processingPriority === 'number' && !isNaN(env.processingPriority)) {
-        return ['nice', ['-n', env.processingPriority.toString(), ffmpeg, ...args]]
-    }
-    return [ffmpeg, args]
-}
-
-const defaultAgent = new Agent();
-
-const proxy = async (streamInfo, res) => {
-    const abortController = new AbortController();
-    const shutdown = () => (
-        closeRequest(abortController),
-        closeResponse(res),
-        destroyInternalStream(streamInfo.urls)
-    );
-
-    try {
-        res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
-        res.setHeader('Content-disposition', contentDisposition(streamInfo.filename));
-
-        const { body: stream, headers, statusCode } = await request(streamInfo.urls, {
-            headers: {
-                ...getHeaders(streamInfo.service),
-                Range: streamInfo.range
-            },
-            signal: abortController.signal,
-            maxRedirections: 16,
-            dispatcher: defaultAgent,
-        });
-
-        res.status(statusCode);
-
-        for (const headerName of ['accept-ranges', 'content-type', 'content-length']) {
-            if (headers[headerName]) {
-                res.setHeader(headerName, headers[headerName]);
-            }
-        }
-
-        pipe(stream, res, shutdown);
-    } catch {
-        shutdown();
-    }
-}
-
-const merge = (streamInfo, res) => {
-    let process;
-    const shutdown = () => (
-        killProcess(process),
-        closeResponse(res),
-        streamInfo.urls.map(destroyInternalStream)
-    );
-
-    const headers = getHeaders(streamInfo.service);
-    const rawHeaders = toRawHeaders(headers);
-
-    try {
-        if (streamInfo.urls.length !== 2) return shutdown();
-
-        const format = streamInfo.filename.split('.')[streamInfo.filename.split('.').length - 1];
-
-        let args = [
-            '-loglevel', '-8',
-            '-headers', rawHeaders,
-            '-i', streamInfo.urls[0],
-            '-headers', rawHeaders,
-            '-i', streamInfo.urls[1],
-            '-map', '0:v',
-            '-map', '1:a',
-        ]
-
-        args = args.concat(ffmpegArgs[format]);
-
-        if (hlsExceptions.includes(streamInfo.service) && streamInfo.isHLS) {
-            if (streamInfo.service === "youtube" && format === "webm") {
-                args.push('-c:a', 'libopus');
-            } else {
-                args.push('-c:a', 'aac', '-bsf:a', 'aac_adtstoasc');
-            }
-        }
-
-        if (streamInfo.metadata) {
-            args = args.concat(convertMetadataToFFmpeg(streamInfo.metadata))
-        }
-
-        args.push('-f', format, 'pipe:3');
-
-        process = spawn(...getCommand(args), {
-            windowsHide: true,
-            stdio: [
-                'inherit', 'inherit', 'inherit',
-                'pipe'
-            ],
-        });
-
-        const [,,, muxOutput] = process.stdio;
-
-        res.setHeader('Connection', 'keep-alive');
-        res.setHeader('Content-Disposition', contentDisposition(streamInfo.filename));
-
-        pipe(muxOutput, res, shutdown);
-
-        process.on('close', shutdown);
-        res.on('finish', shutdown);
-    } catch {
-        shutdown();
-    }
-}
-
-const remux = (streamInfo, res) => {
-    let process;
-    const shutdown = () => (
-        killProcess(process),
-        closeResponse(res),
-        destroyInternalStream(streamInfo.urls)
-    );
-
-    try {
-        let args = [
-            '-loglevel', '-8',
-            '-headers', toRawHeaders(getHeaders(streamInfo.service)),
-        ]
-
-        if (streamInfo.service === "twitter") {
-            args.push('-seekable', '0')
-        }
-
-        args.push(
-            '-i', streamInfo.urls,
-            '-c:v', 'copy',
-        )
-
-        if (streamInfo.type === "mute") {
-            args.push('-an');
-        }
-
-        if (hlsExceptions.includes(streamInfo.service)) {
-            if (streamInfo.type !== "mute") {
-                args.push('-c:a', 'aac')
-            }
-            args.push('-bsf:a', 'aac_adtstoasc');
-        }
-
-        let format = streamInfo.filename.split('.')[streamInfo.filename.split('.').length - 1];
-        if (format === "mp4") {
-            args.push('-movflags', 'faststart+frag_keyframe+empty_moov')
-        }
-
-        args.push('-f', format, 'pipe:3');
-
-        process = spawn(...getCommand(args), {
-            windowsHide: true,
-            stdio: [
-                'inherit', 'inherit', 'inherit',
-                'pipe'
-            ],
-        });
-
-        const [,,, muxOutput] = process.stdio;
-
-        res.setHeader('Connection', 'keep-alive');
-        res.setHeader('Content-Disposition', contentDisposition(streamInfo.filename));
-
-        pipe(muxOutput, res, shutdown);
-
-        process.on('close', shutdown);
-        res.on('finish', shutdown);
-    } catch {
-        shutdown();
-    }
-}
-
-const convertAudio = (streamInfo, res) => {
-    let process;
-    const shutdown = () => (
-        killProcess(process),
-        closeResponse(res),
-        destroyInternalStream(streamInfo.urls)
-    );
-
-    try {
-        let args = [
-            '-loglevel', '-8',
-            '-headers', toRawHeaders(getHeaders(streamInfo.service)),
-        ]
-
-        if (streamInfo.service === "twitter") {
-            args.push('-seekable', '0');
-        }
-
-        args.push(
-            '-i', streamInfo.urls,
-            '-vn'
-        )
-
-        if (streamInfo.audioCopy) {
-            args.push("-c:a", "copy")
-        } else {
-            args.push("-b:a", `${streamInfo.audioBitrate}k`)
-        }
-
-        if (streamInfo.audioFormat === "mp3" && streamInfo.audioBitrate === "8") {
-            args.push("-ar", "12000");
-        }
-
-        if (streamInfo.audioFormat === "opus") {
-            args.push("-vbr", "off")
-        }
-
-        if (ffmpegArgs[streamInfo.audioFormat]) {
-            args = args.concat(ffmpegArgs[streamInfo.audioFormat])
-        }
-
-        if (streamInfo.metadata) {
-            args = args.concat(convertMetadataToFFmpeg(streamInfo.metadata))
-        }
-
-        args.push('-f', streamInfo.audioFormat === "m4a" ? "ipod" : streamInfo.audioFormat, 'pipe:3');
-
-        process = spawn(...getCommand(args), {
-            windowsHide: true,
-            stdio: [
-                'inherit', 'inherit', 'inherit',
-                'pipe'
-            ],
-        });
-
-        const [,,, muxOutput] = process.stdio;
-
-        res.setHeader('Connection', 'keep-alive');
-        res.setHeader('Content-Disposition', contentDisposition(streamInfo.filename));
-
-        pipe(muxOutput, res, shutdown);
-        res.on('finish', shutdown);
-    } catch {
-        shutdown();
-    }
-}
-
-const convertGif = (streamInfo, res) => {
-    let process;
-    const shutdown = () => (killProcess(process), closeResponse(res));
-
-    try {
-        let args = [
-            '-loglevel', '-8'
-        ]
-
-        if (streamInfo.service === "twitter") {
-            args.push('-seekable', '0')
-        }
-
-        args.push('-i', streamInfo.urls);
-        args = args.concat(ffmpegArgs.gif);
-        args.push('-f', "gif", 'pipe:3');
-
-        process = spawn(...getCommand(args), {
-            windowsHide: true,
-            stdio: [
-                'inherit', 'inherit', 'inherit',
-                'pipe'
-            ],
-        });
-
-        const [,,, muxOutput] = process.stdio;
-
-        res.setHeader('Connection', 'keep-alive');
-        res.setHeader('Content-Disposition', contentDisposition(streamInfo.filename));
-
-        pipe(muxOutput, res, shutdown);
-
-        process.on('close', shutdown);
-        res.on('finish', shutdown);
-    } catch {
-        shutdown();
-    }
-}
-
-export default {
-    proxy,
-    merge,
-    remux,
-    convertAudio,
-    convertGif,
-}

api/src/util/test.js

@@ -4,7 +4,7 @@ import { env } from "../config.js";
 import { runTest } from "../misc/run-test.js";
 import { loadJSON } from "../misc/load-from-fs.js";
 import { Red, Bright } from "../misc/console-text.js";
-import { setGlobalDispatcher, ProxyAgent } from "undici";
+import { setGlobalDispatcher, EnvHttpProxyAgent, ProxyAgent } from "undici";
 import { randomizeCiphers } from "../misc/randomize-ciphers.js";
 
 import { services } from "../processing/service-config.js";
@@ -69,9 +69,10 @@ const printHeader = (service, padLen) => {
     console.log(service + '='.repeat(50));
 }
 
-if (env.externalProxy) {
-    setGlobalDispatcher(new ProxyAgent(env.externalProxy));
-}
+// TODO: remove env.externalProxy in a future version
+setGlobalDispatcher(
+    new EnvHttpProxyAgent({ httpProxy: env.externalProxy || undefined })
+);
 
 env.streamLifespan = 10000;
 env.apiURL = 'http://x/';

api/src/util/tests/bilibili.json

@@ -56,5 +56,14 @@
             "code": 200,
             "status": "tunnel"
         }
+    },
+    {
+        "name": "bilibili.com link with part id",
+        "url": "https://www.bilibili.com/video/BV1uo4y1K72s?spm_id_from=333.788.videopod.episodes&p=6",
+        "params": {},
+        "expected": {
+            "code": 200,
+            "status": "tunnel"
+        }
     }
 ]

api/src/util/tests/facebook.json

@@ -1,7 +1,7 @@
 [
     {
         "name": "direct video with username and id",
-        "url": "https://web.facebook.com/100048111287134/videos/1157798148685638/",
+        "url": "https://web.facebook.com/100071784061914/videos/588631943886661/",
         "params": {},
         "expected": {
             "code": 200,

api/src/util/tests/loom.json

@@ -29,5 +29,32 @@
             "code": 400,
             "status": "error"
         }
+    },
+    {
+        "name": "video with no transcodedUrl",
+        "url": "https://www.loom.com/share/aa3d8b08bee74d05af5b42989e9f33e9",
+        "params": {},
+        "expected": {
+            "code": 200,
+            "status": "redirect"
+        }
+    },
+    {
+        "name": "video with title in url",
+        "url": "https://www.loom.com/share/Meet-AI-workflows-aa3d8b08bee74d05af5b42989e9f33e9",
+        "params": {},
+        "expected": {
+            "code": 200,
+            "status": "redirect"
+        }
+    },
+    {
+        "name": "video with title in url (2)",
+        "url": "https://www.loom.com/share/Unlocking-Incredible-Organizational-Velocity-with-Async-Video-4a2a8baf124c4390954dcbb46a58cfd7",
+        "params": {},
+        "expected": {
+            "code": 200,
+            "status": "redirect"
+        }
     }
-]
+]

api/src/util/tests/newgrounds.json

@@ -0,0 +1,42 @@
+[
+    {
+        "name": "regular video",
+        "url": "https://www.newgrounds.com/portal/view/938050",
+        "params": {},
+        "expected": {
+            "code": 200,
+            "status": "tunnel"
+        }
+    },
+    {
+        "name": "regular video (audio only)",
+        "url": "https://www.newgrounds.com/portal/view/938050",
+        "params": {
+            "downloadMode": "audio"
+        },
+        "expected": {
+            "code": 200,
+            "status": "tunnel"
+        }
+    },
+    {
+        "name": "regular video (muted)",
+        "url": "https://www.newgrounds.com/portal/view/938050",
+        "params": {
+            "downloadMode": "mute"
+        },
+        "expected": {
+            "code": 200,
+            "status": "tunnel"
+        }
+    },
+    {
+        "name": "regular music",
+        "url": "https://www.newgrounds.com/audio/listen/500476",
+        "params": {},
+        "expected": {
+            "code": 200,
+            "status": "tunnel"
+        }
+    }
+]