ani-cli-npm 2.1.3 → 2.1.5

package/src/Anime.ts

@@ -0,0 +1,427 @@
+import {curl} from "./core_utils/curl";
+import {RegexParse} from "./core_utils/regex";
+import {generate_link} from "./url_genoration/generate_link";
+import {config_interface, player} from "./core_utils/interfaces";
+import {search_cache, new_cache} from "./file_managment/cache";
+import {number_input, selection} from "./IO/input";
+import {write_config} from "./file_managment/load_config";
+const W2GClient = require("w2g-client")
+const open = require("open")
+const PlayerController = require("media-player-controller")
+const dl = require("download-file-with-progressbar");
+const chalk = require("chalk")
+const m3u8ToMp4 = require("m3u8-to-mp4");
+const converter = new m3u8ToMp4();
+
+
+class Anime{
+    /*
+    Class for handling a show/film
+
+    Stores anime dpage links assigned with anime_id.
+
+    Initialised with Anime.init()
+
+     */
+
+    id: string = "";
+    episode_list: string[] = [];
+    most_recent:number = 0;
+    player:player = new class implements player {
+        play(episode_link: string): {} {
+            return {};
+        }
+        player: any;
+    };
+    current_pos:number = 0;
+    current_episode:number = 0;
+
+    async init(anime_id: string, cache_folder:string){ // init mate
+        /*
+        Initiate Anime object
+
+        Will first search cache folder for cache file (this will contain id and dpage links)
+
+        If no cache is found, it will use get_ep_bases(anime_id) to get links. (Webscrapes from animixplay.to), then creates cache
+
+        anime_id:
+         */
+        let cache_object = search_cache(cache_folder, anime_id)
+        this.id = anime_id
+        if (cache_object == 0){
+            await this.get_ep_bases(this.id)
+            new_cache(cache_folder,{
+                id: this.id,
+                episode_list: this.episode_list,
+                most_recent: this.most_recent
+            })
+        }else{
+            try{
+                this.episode_list = cache_object.episode_list
+                if (cache_object.most_recent != undefined){
+                    this.most_recent = cache_object.most_recent
+                }
+                if (cache_object.position != undefined){
+                    this.current_pos = cache_object.position
+                }
+            }catch{
+                await this.get_ep_bases(this.id)
+            }
+        }
+        new_cache(cache_folder,{
+            id: this.id,
+            episode_list: this.episode_list,
+            most_recent: this.most_recent
+        })
+        return 0;
+    }
+
+    async get_episode_link(episode:number, player:string = "VLC"){
+        let episode_dpage = this.episode_list[episode]
+        let id = episode_dpage.replace("//gogohd.pro/streaming.php?id=","")
+        id = id.slice(0, id.indexOf("="))
+        let link:string = await generate_link(1,id, player)
+        if (!link){
+            link = await generate_link(2,id, player)
+        }
+        if (!link){
+            console.log(chalk.red("Failed to generate links"))
+        }
+        if (player == "VLC" && link.includes("m3u8")){
+            console.log(chalk.red("Warning; VLC is not compatible with m3u8 playlist files without custom plugins."))
+        }
+        return link
+    }
+
+    async get_ep_bases(anime_id:string){
+        /*
+        Scrapes animixplay.to for dpage links.
+        returns array with all dpage links
+         */
+        let html = (await(curl("https://animixplay.to/v1/"+anime_id))).split("\n") //POTENTIAL BREAK POINT. animixplay.to may change domain address
+        let lines = ""
+        for (let x in html){
+            if(RegexParse(html[x], "*<div id=\"epslistplace\"*")){
+                lines = (html[x])
+            }
+        }
+        lines = lines.slice(55, lines.length).replace("}</div>", "")
+        lines = "{" + lines.slice(lines.indexOf(",")+1, lines.length) + "}"
+        let json = JSON.parse(lines)
+        for (const value of Object.entries(json) as unknown as string[]) {
+            if (typeof value[1] == "string"){
+                this.episode_list.push(value[1].replace("//gogohd.pro/streaming.php?id=",""))
+            }
+        }
+    }
+
+    async play_head(episode:number, config:config_interface, config_dir:string){
+        /*
+        # Starts play cascade.
+
+        ## Takes in:
+        ### Episode number, counting from 0
+        ### Config object
+        ### Config save directory
+
+         - If config.player is set to MPV or VLC, it will use the media-player-controller package.
+
+         - If set to Browser, it will use the "open" packer.
+
+         - If set to Link, it will simply print the media stream link to console, primarily for debuting peruses.
+         */
+        console.clear()
+        console.log(`Playing ${this.id} episode ${episode+1}`)// from ${new Date(this.current_pos * 1000).toISOString().slice(11, 19)}`)
+        if (this.current_pos != 0){
+            console.log(`Most recent position: ${new Date(this.current_pos * 1000).toISOString().slice(11, 19)}`)
+        }
+        switch (config.player){
+            case "MPV":
+                console.log(("Opening MPV.."))
+                this.player.player = await new PlayerController({
+                    app: 'mpv',
+                    args: ['--fullscreen', '--keep-open=yes'],// `--start=+${this.current_pos}`],
+                    media: await this.get_episode_link(episode, config.player),
+                    ipcPath: config.mpv_socket_path
+                });
+                this.player.play = (async (episode_link:string) => {
+                    this.player.player.load(episode_link)
+                })
+                this.player.player.on('playback', (data: any) =>{
+                    if (data.name == "time-pos" && data.value >= 0){
+                        this.current_pos = data.value;
+                    }
+                    //console.log(data)
+                })
+                this.player.player.on('app-exit', (code: any) => {
+                    config.most_recent.anime_id = this.id
+                    config.most_recent.episode_number = episode
+                    config.most_recent.episode_second = this.current_pos
+                    write_config(config_dir, config)
+                    this.most_recent = episode;
+                    new_cache(config_dir,{
+                        id: this.id,
+                        episode_list: this.episode_list,
+                        most_recent: this.most_recent,
+                        position: this.current_pos
+                    })
+                })
+                // @ts-ignore
+                await this.player.player.launch(err => {
+                    if (err) return console.error(err.message);
+                });
+
+                break
+            case "VLC":
+                console.log(("Opening VLC.."))
+                this.player.player = await new PlayerController({
+                    app: 'vlc',
+                    args: ['--fullscreen'],//, `--start-time ${this.current_pos}`],
+                    media: await this.get_episode_link(episode, config.player),
+                    //httpPort: (config.vlc_socket !== 0)? config.vlc_socket : null,
+                    //httpPass: (config.vlc_pass !== "")? config.vlc_socket : null,
+                });
+                // @ts-ignore
+                await this.player.player.launch(err => {
+                    if (err) return console.error(err.message);
+                });
+
+                this.player.play = (async (episode_link:string) => {
+                    this.player.player.quit()
+                    this.player.player = await new PlayerController({
+                        app: 'vlc',
+                        args: ['--fullscreen'],// "--start-time 0"],
+                        media: episode_link
+                        //httpPort: (config.vlc_socket !== 0)? config.vlc_socket : null,
+                        //httpPass: (config.vlc_pass !== "")? config.vlc_socket : null,
+                    });
+                    this.player.player.on('playback', (data: any) =>{
+                        if (data.name == "time-pos" && data.value >= 0){
+                            this.current_pos = data.value;
+                        }
+                        //console.log(data)
+                    })
+
+                    this.player.player.on('app-exit', (code: any) => {
+                        config.most_recent.anime_id = this.id
+                        config.most_recent.episode_number = episode
+                        config.most_recent.episode_second = this.current_pos
+                        write_config(config_dir, config)
+                        this.most_recent = episode;
+                        new_cache(config_dir,{
+                            id: this.id,
+                            episode_list: this.episode_list,
+                            most_recent: this.most_recent,
+                            position: this.current_pos
+                        })
+                    })
+                    // @ts-ignore
+                    await this.player.player.launch(err => {
+                        if (err) return console.error(err.message);
+                    });
+
+
+                })
+                break
+            case "BROWSER":
+                this.player.play = (async (episode_link:string) => {
+                    console.log(("Opening browser..."))
+                    await open(episode_link)
+                })
+                console.log(("Opening browser..."))
+                await open(await this.get_episode_link(episode, config.player))
+                break
+            case "W2G":
+                try{
+                    this.player.player = new W2GClient.W2GClient(config.w2g_api_key);
+                    await this.player.player.create(await this.get_episode_link(episode, config.player))
+                    console.log(chalk.green("Room link: " + await this.player.player.getLink()));
+                }catch{
+                    console.log(chalk.red("Failed to create w2g.tv room. \nthis can often be because your API token is invalid. You can change it in options."))
+                    process.exit()
+                }
+                this.player.play = (async (episode_link:string) => {
+                    console.log(("Updating W2G room..."))
+                    console.log(chalk.green("Room link: " + await this.player.player.getLink()));
+                    try{
+                        await this.player.player.update(episode_link)
+                    }catch{
+                        console.log(chalk.red("Error updating W2G room. Very sorry, w2g functionality is a bit broken at present. Worst case you should be able to just restart with a new room for each episode."))
+                    }
+                })
+                console.log("Opening W2G.tv...")
+                await open(await this.player.player.getLink())
+
+                break
+            case "LINK":
+                this.player.play = (async (episode_link:string) => {
+                    console.log(chalk.green(episode_link))
+                });
+                this.player.play(await this.get_episode_link(episode))
+                break
+        }
+        await this.play_controller(episode, config, config_dir, true)
+    }
+
+    async next(player:string){
+        this.current_episode += 1
+        this.current_pos = 0
+        this.player.play(await this.get_episode_link(this.current_episode, player))
+    }
+    async previous(player:string){
+        this.current_episode -= 1
+        this.current_pos = 0
+        this.player.play(await this.get_episode_link(this.current_episode, player))
+    }
+
+    private async play_controller(episode:number, config:config_interface, config_dir:string, first:boolean=false){
+        if (config.show_cover){
+
+        }
+        console.clear()
+        console.log(`Playing ${this.id} episode ${episode+1}`)// from ${new Date(this.current_pos * 1000).toISOString().slice(11, 19)}`)
+        // if (!first){
+        //     console.clear()
+        //     console.log(chalk.blue(`Playing ${this.id} episode ${episode+1}`))
+        //     if (this.player == 0){
+        //         await open(await this.get_episode_link(episode, "BROWSER"))
+        //     }else if(this.player == 1){
+        //         console.log(await this.get_episode_link(episode))
+        //     } else if (this.player.roomID != undefined){
+        //         console.log(chalk.green("Room link: "+ await this.player.getLink()));
+        //         this.player.update(await this.get_episode_link(episode))
+        //     } else if (this.player.opts.app == "mpv"){
+        //         await this.player.load(await this.get_episode_link(episode))
+        //     }else{
+        //         this.player.quit()
+        //         this.player = await new PlayerController({
+        //             app: 'vlc',
+        //             args: ['--fullscreen'],
+        //             media: await this.get_episode_link(episode, config.player)
+        //         });
+        //         // @ts-ignore
+        //         await this.player.launch(err => {
+        //             if (err) return console.error(err.message);
+        //         });
+        //     }
+        // }
+        this.current_episode = episode
+        config.most_recent.anime_id = this.id
+        config.most_recent.episode_number = episode
+        config.most_recent.episode_second = this.current_pos
+        write_config(config_dir, config)
+        this.most_recent = episode;
+        new_cache(config_dir,{
+            id: this.id,
+            episode_list: this.episode_list,
+            most_recent: this.most_recent,
+            position: this.current_pos
+        })
+
+
+        let selected:number; // Look, I'm sorry, but there is no way I can possibly document this in a sane way. It's a dumb patch.
+        do{
+            console.clear()
+            selected = await selection(
+                (episode <= 0)?                        [chalk.yellow("1/n) Next"), chalk.grey("2/p) Previous"), chalk.yellow("3/s) Select"), chalk.green("4/q) Quit")]:
+                    (episode >= this.episode_list.length-1)?    [chalk.grey("1/n) Next"), chalk.green("2/p) Previous"), chalk.yellow("3/s) Select"), chalk.green("4/q) Quit")] :
+                                                                [chalk.yellow("1/n) Next"), chalk.green("2/p) Previous"), chalk.yellow("3/s) Select"), chalk.green("4/q) Quit")],
+
+                ["n", "p", "s", "q"],
+                ((thing:string) => {return (thing)}),
+                ((thing:string) => {return (thing)}),
+                true
+            )
+            if (!(selected != ((episode <= 0)? 1 : (episode >= this.episode_list.length-1)? 0 : -1))){
+                console.log(chalk.red("Invalid choice."))
+            }
+        }while (!(selected != ((episode <= 0)? 1 : (episode >= this.episode_list.length-1)? 0 : -1)))
+
+        switch(selected){
+            case 0:
+                if (episode >= this.episode_list.length-1){
+                    await this.next(config.player)
+                    await this.play_controller(episode-1, config, config_dir)
+                }else{
+                    await this.next(config.player)
+                    await this.play_controller(episode+1, config, config_dir)
+                }
+                break
+            case 1:
+                if ((episode >= this.episode_list.length-1) || (episode <= 0)){
+                    break
+                }
+                await this.previous(config.player)
+                await this.play_controller(episode-1, config, config_dir)
+                break
+            case 2:
+                if (this.episode_list.length == 1){
+                    this.player.play(await this.get_episode_link(0, config.player))
+                    await this.play_controller(0, config, config_dir)
+                }else{
+                    console.log(`Select episode [1-${this.episode_list.length}]`)
+                    let episode = await number_input(this.episode_list.length, 1)-1
+                    this.player.play(await this.get_episode_link(episode, config.player))
+                    await this.play_controller(episode, config, config_dir)
+                }
+                break
+            case 3:
+                break
+        }
+    }
+
+    async download(episode:number, download_folder:string, final_ep:number){
+        /*
+        ## Downloads an episode (counting from 0) to download_folder, with progress bar.
+         */
+        while (episode <= final_ep){
+
+        }
+        try {
+            let ep_link: string = await this.get_episode_link(episode)
+            let file_name = `${this.id}-${episode + 1}.mp4`
+            if (ep_link.includes(".m3u8")){
+                console.log(chalk.green(`Downloading episode ${episode+1} of ${this.id.replace("-", "")} to ${download_folder+"/"+file_name}...`))
+                console.log("Progress bar unavailable for m3u8 files.")
+                await converter
+                    .setInputFile(ep_link)
+                    .setOutputFile((download_folder+"/"+file_name))
+                    .start();
+                console.log(chalk.green("Download finished."))
+            }else{
+                // @ts-ignore
+                let option = {
+                    filename: (ep_link.includes("m3u8") ? file_name.replace("mp4", "m3u8") : file_name),
+                    dir: download_folder,
+                    onDone: (final_ep > episode) ? ((info: any) => {
+                        // @ts-ignore
+                        console.log(chalk.green(`\n -- 1Download finished -- \nLocation: ${info.path}. Size: ${Math.round(info.size / 100000) * 10} Bytes\n`));
+                        this.download(episode + 1, download_folder, final_ep)
+                    }) : ((info: any) => {
+                        // @ts-ignore
+                        console.log(chalk.green(`\n -- 2Download finished -- \n${info.path}. Size: ${Math.round(info.size / 100000) * 10} Bytes\n`));
+                    }),
+                    // @ts-ignore
+                    onError: (err) => {
+                        console.log(chalk.red('error', err));
+                        this.download(episode, download_folder, final_ep)
+                    },
+                    // @ts-ignore
+                    onProgress: (curr, total) => {
+                        process.stdout.clearLine(0);
+                        process.stdout.cursorTo(0);
+                        process.stdout.write("\x1b[32m -- " + (curr / total * 100).toFixed(2) + "% " + "#".repeat(Math.ceil((curr / total) * ((process.stdout.columns - 20) / 1.5))) + "~".repeat(Math.ceil(((process.stdout.columns - 20) / 1.5) - (curr / total) * ((process.stdout.columns - 20) / 1.5))) + " -- \x1b[0m")
+                    }
+                }
+                //console.log((`${option.dir}/${option.filename}`))
+
+                return await dl(ep_link, option);
+            }
+        }catch{
+            await this.download(episode, download_folder, final_ep)
+        }
+    }
+
+}
+
+export {Anime}

package/src/IO/help.ts

@@ -0,0 +1,64 @@
+import {selection} from "./input";
+
+const chalk = require("chalk")
+
+
+const helps = [
+    (async () => { // Playing anime
+        console.log(chalk.cyan("Playing anime: \n" +
+            "  Search: \n" +
+            "    Search for a show/movie. This will search on gogoanime.dk.\n" +
+            "  Episode selection: \n" +
+            "    Once an anime is selected, select an episode. If there is only 1 episode " +
+            "(in the case of a movie), the episode will be played automatically.\n" +
+            "    The episode selected will be played in the video player selected in options. Info on video players can be found in options help."))
+        await help()
+        return
+    }),
+    (async () => { // Downloading anime
+        console.log(chalk.cyan("Downloading anime: \n" +
+            "  Search: \n" +
+            "    Search for a show/movie. This will search on gogoanime.dk.\n" +
+            "  Episode selection: \n" +
+            "    Once an anime is selected, select a start episode and an end episode. If there is only 1 episode " +
+            "(in the case of a movie), the episode will be downloaded automatically. Download folder can be changed in options. Default to run location.\n" +
+            "    The selected episodes will be downloaded. It is common for episode links to fail to be fetched, when this happens the episode will be passed, then reattempted in another pass.\n" +
+            "    Episodes sourced from Animixplay links will download m3u8 file, which you will have difficulty playing, if you are able to at all."))
+        await help()
+        return
+    }),
+    (async () => {
+        console.log(chalk.cyan("Options: \n" +
+            "  Player: \n" +
+            "    Player used to play anime.\n" +
+            "  Proxy: \n" +
+            "    https proxy address and port in form ip:port. This is not currently implemented.\n" +
+            "  User agent:\n" +
+            "    node-fetch user agent.\n" +
+            "  Downloads folder:\n" +
+            "    Folder to place downloaded episodes.\n" +
+            "  MPV socket connection file:\n" +
+            "    File for mpv socket, used to control mpv instance with outside tools.\n" +
+            "  VLC socket:\n" +
+            "    VLC http control socket\n" +
+            "  VLC pass:\n" +
+            "    VLC http control password\n" +
+            "  W2G api token:\n" +
+            "    Your user access token for w2g.tv. Can be found at https://w2g.tv/en/account/edit_user under Tools/API\n"
+        ))
+        await help()
+        return
+    }),
+    (async () => {
+        return
+    })
+
+]
+
+
+async function help(){
+    console.log(chalk.cyan("Help page select: \n"))
+    return helps[await selection(["Playing", "Downloading", "Options", "Quit"], ["p", "d", "o", "q"])]()
+}
+
+export {help}

package/src/IO/input.ts

@@ -0,0 +1,92 @@
+import chalk from "chalk";
+const _prompt = require("simple-input");
+
+
+async function selection(options:string[], extra_options:string[] = [], color1 = ((thing:string) => {return chalk.yellow(thing)}), color2 = ((thing:string) => {return chalk.green(thing)}), overwrite:boolean=false){
+    /*
+    selection(options, extra_options, color1, color2)
+
+    Gives use prompt to choose from a list of options. Either by inputting a number ranging from 1, to the length of the list. Or by inputting a letter (non-caps-sensitive) relating to the option.
+
+
+     - options: array of options; e.g. ["play", "download", "continue", "quit"] REQUIRED
+
+
+     - extra_options: array of characters as alternatives to numbers (both will be displayed). e.g. ["p", "d", "c", "q"].
+
+       default: []
+
+     - color1 and color2: functions that will dictate what 2 colors the options with alternate between (option1 will be color1, option2;color2, option3;color1, etc).
+     recommended for this function to return a chalk.____() parsed string.
+
+       default: ((thing:string) => {return chalk.yellow(thing)}) and ((thing:string) => {return chalk.green(thing)})
+
+     - Overwrite: boolean. Please dont use this. I should not be using it. It prints out the raw string instead of adding numbers to them to allow for bogus.
+    */
+
+
+    let color:boolean = true;
+    for (let x in options){
+        if (!overwrite){
+            if (color){
+                console.log(
+                    color1((parseInt(x)+1).toString()+
+                        ((extra_options[x] == undefined)? "" : "/"+extra_options[x])+
+                        ") "+options[x].replaceAll("-", " "))
+                )
+            }else{
+                console.log(
+                    color2((parseInt(x)+1).toString()+
+                        ((extra_options[x] == undefined)? "" : "/"+extra_options[x])+
+                        ") "+options[x].replaceAll("-", " "))
+                )
+            }
+        }else{
+            console.log(options[x])
+        }
+        color = !color
+    }
+    let input:string = ""
+    do{
+        // @ts-ignore
+        input = (await _prompt(">")).toLowerCase()
+        for (let x in extra_options){
+            if (extra_options[x].toLowerCase() == input){
+                input = (parseInt(x)+1).toString()
+            }
+        }
+        if (!(1 <= parseInt(input) && parseInt(input) <= options.length)){
+            console.log(chalk.red("Invalid choice."))
+        }
+    }while(!(1 <= parseInt(input) && parseInt(input) <= options.length))
+    return parseInt(input)-1
+}
+
+async function input(){
+    return await _prompt(">")
+}
+
+async function number_input(max:number, min:number=1, extra_options:string[] =[], extra_option_values:number[]=[]){
+    let selector:string;
+    let selection:number;
+    do{
+        selector = await _prompt(">")
+        if (extra_options.includes(selector.toLowerCase())){
+            selection = extra_option_values[extra_options.indexOf(selector)]
+        }else{
+            selection = parseInt(selector)
+        }
+        if (selector == ""){
+            selection = min
+        }
+        if (!(min <= selection && selection <= max)){
+            console.log(chalk.red("Invalid choice."))
+        }
+    }while (!(min <= selection && selection <= max))
+
+    return selection
+}
+
+
+
+export {selection, input, number_input}

package/src/core_utils/curl.ts

@@ -0,0 +1,32 @@
+const fetch = require("node-fetch")
+const chalk = require("chalk")
+async function curl(url: string, method="GET", redirect = false){
+    try{
+    let response = await fetch(url, {
+        //"agent": proxyAgent,
+        "headers": {
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/100.0',
+            "X-Requested-With": "XMLHttpRequest"
+        },
+        "referrerPolicy": "origin",
+        "body": null,
+        "method": method,
+        "redirect": 'follow',
+        // "follow": 10,
+    }).catch(async function(err:string) {
+        console.warn(chalk.red(`Something went wrong connecting to ${url}. ${err}`));
+        process.exit()
+    })
+    if (redirect){
+        return response.url
+    }else{
+        return await response.text()
+    }
+    }catch{
+        console.log(chalk.red("Something went wrong in curl()"))
+        process.exit()
+    }
+
+}
+
+export {curl}

package/src/core_utils/interfaces.ts

@@ -0,0 +1,25 @@
+interface config_interface{
+    player: string,
+    proxy: string,
+    user_agent: string,
+    most_recent: {
+        episode_number: number,
+        episode_second: number,
+        anime_id: string,
+    }
+    download_folder:string,
+    debug_mode: boolean,
+    mpv_socket_path: string,
+    vlc_socket:number,
+    vlc_pass:string,
+    w2g_api_key:string,
+    show_cover: boolean
+}
+
+interface player{
+    player: any,
+    play: ((episode_link:string) => {}),
+}
+
+
+export {config_interface, player}

package/src/core_utils/libs.ts

@@ -0,0 +1,13 @@
+// Random functions
+
+function range(start:number, end:number) {
+    let ans = [];
+    for (let i = start; i <= end; i++) {
+        ans.push(i);
+    }
+    return ans;
+}
+
+
+
+export {range}

package/src/core_utils/regex.ts

@@ -0,0 +1,5 @@
+function RegexParse(str: string, rule: string) {
+    let escapeRegex = (str: string) => str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
+    return new RegExp("^" + rule.split("*").map(escapeRegex).join(".*") + "$").test(str);
+}
+export { RegexParse }

package/src/cover_manager.ts

@@ -0,0 +1,9 @@
+// let base:string = "https://gogocdn.net/cover/yuri-on-ice-dub.png"
+
+
+
+
+
+
+// export {display_cover}
+