server migration to TypeScript

server/src/utils/BetterLogger.ts

@@ -0,0 +1,46 @@
+const ansi = {
+    reset: '\u001b[0m',
+    red: '\u001b[31m',
+    cyan: '\u001b[36m',
+    green: '\u001b[32m',
+    yellow: '\u001b[93m',
+}
+
+class Logger {
+    /**
+     * Print a standard info message
+     * @param {string} proto the context/protocol/section outputting the message
+     * @param {string} args the acutal message
+     */
+    info(proto: string, args: string) {
+        process.stdout.write(
+            this.#__formatter(proto, args)
+        )
+    }
+    /**
+     * Print a warn message
+     * @param {string} proto the context/protocol/section outputting the message
+     * @param {string} args the acutal message
+     */
+    warn(proto: string, args: string) {
+        process.stdout.write(
+            `${ansi.yellow}${this.#__formatter(proto, args)}${ansi.reset}`
+        )
+    }
+    /**
+     * Print an error message
+     * @param {string} proto the context/protocol/section outputting the message
+     * @param {string} args the acutal message
+     */
+    err(proto: string, args: string) {
+        process.stdout.write(
+            `${ansi.red}${this.#__formatter(proto, args)}${ansi.reset}`
+        )
+    }
+
+    #__formatter(proto: any, args: any) {
+        return `[${proto}]\t${args}\n`
+    }
+}
+
+export default Logger;

server/src/utils/logger.ts

@@ -0,0 +1,18 @@
+/**
+ * Simplest logger function, takes two argument: first one put between
+ * square brackets (the protocol), the second one it's the effective message
+ * @param {string} proto protocol
+ * @param {string} args message
+ */
+export const logger = (proto: string, args: string) => {
+    console.log(`[${proto}]\t${args}`)
+}
+
+/**
+ * CLI splash
+ */
+export const splash = () => {
+    console.log("-------------------------------------------------")
+    console.log("yt-dlp-webUI - A web-ui for yt-dlp, simply enough")
+    console.log("-------------------------------------------------")
+}

server/src/utils/procUtils.ts

@@ -0,0 +1,41 @@
+import { spawn } from 'child_process';
+import fs = require('fs');
+import net = require('net');
+import { logger } from './logger';
+
+/**
+ * Browse /proc in order to find the specific pid
+ * @param {number} pid 
+ * @returns {*} process stats if any
+ */
+export function existsInProc(pid: number): any {
+    try {
+        return fs.statSync(`/proc/${pid}`)
+    } catch (e) {
+        logger('proc', `pid ${pid} not found in procfs`)
+    }
+}
+
+/*
+function retriveStdoutFromProcFd(pid) {
+    if (existsInProc(pid)) {
+        const unixSocket = fs.readlinkSync(`/proc/${pid}/fd/1`).replace('socket:[', '127.0.0.1:').replace(']', '')
+        if (unixSocket) {
+            console.log(unixSocket)
+            logger('proc', `found pending job on pid: ${pid} attached to UNIX socket: ${unixSocket}`)
+            return net.createConnection(unixSocket)
+        }
+    }
+}
+*/
+
+/**
+ * Kills a process with a sys-call
+ * @param {number} pid the killed process pid
+ */
+export async function killProcess(pid: number) {
+    const res = spawn('kill', [String(pid)])
+    res.on('exit', () => {
+        logger('proc', `Successfully killed yt-dlp process, pid: ${pid}`)
+    })
+}

server/src/utils/updater.js

@@ -0,0 +1,95 @@
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { Socket } = require('socket.io');
+
+// endpoint to github API
+const options = {
+    hostname: 'api.github.com',
+    path: '/repos/yt-dlp/yt-dlp/releases/latest',
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0'
+    },
+    method: 'GET',
+    port: 443,
+}
+
+/**
+ * Build the binary url based on the release tag
+ * @param {string} release yt-dlp GitHub release tag
+ * @returns {*} the fetch options with the correct tag and headers
+ */
+function buildDonwloadOptions(release) {
+    return {
+        hostname: 'github.com',
+        path: `/yt-dlp/yt-dlp/releases/download/${release}/yt-dlp`,
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0'
+        },
+        method: 'GET',
+        port: 443,
+    }
+}
+
+/**
+ * gets the yt-dlp latest binary URL from GitHub API
+ */
+async function update() {
+    // ensure that the binary has been removed
+    try {
+        fs.rmSync(path.join(__dirname, '..', 'core', 'yt-dlp'))
+    }
+    catch (e) {
+        console.log('file not found!')
+    }
+    // body buffer
+    let chunks = []
+    https.get(options, res => {
+        // push the http packets chunks into the buffer
+        res.on('data', chunk => {
+            chunks.push(chunk)
+        });
+        // the connection has ended so build the body from the buffer
+        // parse it as a JSON and get the tag_name
+        res.on('end', () => {
+            const buffer = Buffer.concat(chunks)
+            const release = JSON.parse(buffer.toString())['tag_name']
+            console.log('The latest release is:', release)
+            // invoke the binary downloader
+            downloadBinary(buildDonwloadOptions(release))
+        })
+    })
+}
+/**
+ * Utility that Pipes the latest binary to a file
+ * @param {string} url yt-dlp GitHub release url
+ */
+function downloadBinary(url) {
+    https.get(url, res => {
+        // if it is a redirect follow the url
+        if (res.statusCode === 301 || res.statusCode === 302) {
+            return downloadBinary(res.headers.location)
+        }
+        let bin = fs.createWriteStream(path.join(__dirname, '..', 'core', 'yt-dlp'))
+        res.pipe(bin)
+        // once the connection has ended make the file executable
+        res.on('end', () => {
+            fs.chmod(path.join(__dirname, '..', 'core', 'yt-dlp'), 0o775, err => {
+                err ? console.error('failed updating!') : console.log('done!')
+            })
+        })
+    })
+}
+/**
+ * Invoke the yt-dlp update procedure
+ * @param {Socket} socket the current connection socket
+ */
+function updateFromFrontend(socket) {
+    update().then(() => {
+        socket.emit('updated')
+    })
+}
+
+module.exports = {
+    ytdlpUpdater: updateFromFrontend
+}