ani-cli-npm 1.4.2 → 2.0.0

package/.idea/{ani-cli-npm.iml → ani-cli-npm-ts.iml}

@@ -4,7 +4,7 @@
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/temp" />
       <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp.js" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />

package/.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/ani-cli-npm.iml" filepath="$PROJECT_DIR$/.idea/ani-cli-npm.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/ani-cli-npm-ts.iml" filepath="$PROJECT_DIR$/.idea/ani-cli-npm-ts.iml" />
     </modules>
   </component>
 </project>

package/bin/Anime.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Anime = void 0;
+const curl_1 = require("./curl");
+const regex_1 = require("./regex");
+const generate_link_1 = require("./generate_link");
+const cache_1 = require("./cache");
+const input_1 = require("./input");
+const load_config_1 = require("./load_config");
+const open = require("open");
+const PlayerController = require("media-player-controller");
+const dl = require("download-file-with-progressbar");
+const chalk = require("chalk");
+// const gogohd_url="https://gogohd.net/"
+const base_url = "https://animixplay.to";
+class Anime {
+    id = "";
+    episode_list = [];
+    player = 0;
+    async init(anime_id, cache_folder) {
+        let cache_object = (0, cache_1.search_cache)(cache_folder, anime_id);
+        this.id = anime_id;
+        if (cache_object == 0) {
+            await this.get_ap_bases(anime_id);
+        }
+        else {
+            try {
+                this.episode_list = cache_object.episode_list;
+            }
+            catch {
+                await this.get_ap_bases(anime_id);
+            }
+        }
+        return 0;
+    }
+    async get_episode_link(episode, player = "VLC") {
+        let episode_dpage = this.episode_list[episode];
+        let id = episode_dpage.replace("//gogohd.net/streaming.php?id=", "");
+        id = id.slice(0, id.indexOf("="));
+        let link = await (0, generate_link_1.generate_link)(1, id, player);
+        if (!link) {
+            link = await (0, generate_link_1.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_ap_bases(anime_id) {
+        let html = (await ((0, curl_1.curl)(base_url + "/v1/" + anime_id))).split("\n");
+        let lines = "";
+        for (let x in html) {
+            if ((0, regex_1.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)) {
+            this.episode_list.push(value[1]);
+        }
+    }
+    async play_head(episode, config, config_dir) {
+        console.clear();
+        console.log(`Playing ${this.id} episode ${episode + 1}`);
+        switch (config.player) {
+            case "MPV":
+                console.log(("Opening MPV.."));
+                this.player = await new PlayerController({
+                    app: 'mpv',
+                    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);
+                });
+                break;
+            case "VLC":
+                console.log(("Opening VLC.."));
+                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);
+                });
+                break;
+            case "BROWSER":
+                console.log(("Opening browser..."));
+                await open(await this.get_episode_link(episode, config.player));
+                break;
+            case "LINK":
+                this.player = 1;
+                console.log(await this.get_episode_link(episode, config.player));
+                break;
+        }
+        config.most_recent.anime_id = this.id;
+        config.most_recent.episode_number = episode;
+        (0, load_config_1.write_config)(config_dir, config);
+        if (episode <= 0) {
+            switch (await (0, input_1.selection)([
+                "Next",
+                "Quit"
+            ], ["n", "q"])) {
+                case 0:
+                    await this.play(episode + 1, config, config_dir);
+                    break;
+                case 1:
+                    break;
+            }
+        }
+        else if (episode >= this.episode_list.length - 1) {
+            switch (await (0, input_1.selection)([
+                "Previous",
+                "Quit"
+            ], ["p", "q"])) {
+                case 0:
+                    await this.play(episode - 1, config, config_dir);
+                    break;
+                case 1:
+                    break;
+            }
+        }
+        else {
+            switch (await (0, input_1.selection)([
+                "Next",
+                "Previous",
+                "Quit"
+            ], ["n", "p", "q"])) {
+                case 0:
+                    await this.play(episode + 1, config, config_dir);
+                    break;
+                case 1:
+                    await this.play(episode - 1, config, config_dir);
+                    break;
+                case 2:
+                    break;
+            }
+        }
+    }
+    async play(episode, config, config_dir) {
+        console.clear();
+        console.log(`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.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);
+            });
+        }
+        config.most_recent.anime_id = this.id;
+        config.most_recent.episode_number = episode;
+        (0, load_config_1.write_config)(config_dir, config);
+        if (episode <= 0) {
+            switch (await (0, input_1.selection)([
+                "Next",
+                "Quit"
+            ], ["n", "q"])) {
+                case 0:
+                    await this.play(episode + 1, config, config_dir);
+                    break;
+                case 1:
+                    break;
+            }
+        }
+        else if (episode >= this.episode_list.length - 1) {
+            switch (await (0, input_1.selection)([
+                "Previous",
+                "Quit"
+            ], ["p", "q"])) {
+                case 0:
+                    await this.play(episode - 1, config, config_dir);
+                    break;
+                case 1:
+                    break;
+            }
+        }
+        else {
+            switch (await (0, input_1.selection)([
+                "Next",
+                "Previous",
+                "Quit"
+            ], ["n", "p", "q"])) {
+                case 0:
+                    await this.play(episode + 1, config, config_dir);
+                    break;
+                case 1:
+                    await this.play(episode - 1, config, config_dir);
+                    break;
+                case 2:
+                    break;
+            }
+        }
+    }
+    async download(episode, download_folder) {
+        // @ts-ignore
+        let ep_link = await this.get_episode_link(episode);
+        let file_name = `${this.id}-${episode + 1}.mp4`;
+        if (ep_link.includes(".m3u8"))
+            console.log(chalk.red("Warning: Animixplay will download an m3u8 file. This will require some extra steps to play. It is advised to use a 3rd party website or tool to download these from the link."));
+        // @ts-ignore
+        let option = {
+            filename: ep_link.includes("m3u8") ? file_name.replace("mp4", "m3u8") : file_name,
+            dir: download_folder,
+            // @ts-ignore
+            onDone: (info) => {
+                // @ts-ignore
+                console.log(chalk.green(`\n -- Download finished -- \nLocation: ${info.path}. Size: ${Math.round(info.size / 100000) * 10} Bytes\n`) + ">");
+                return 0;
+            },
+            // @ts-ignore
+            onError: (err) => {
+                console.log(chalk.red('error', err));
+            },
+            // @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);
+    }
+    async bulk_download(start_episode, end_episode, download_folder) {
+        let downloaders = [];
+        for (let episode = start_episode; episode <= end_episode; episode++) {
+            downloaders.push(await this.download(episode, download_folder));
+        }
+        return await Promise.all(downloaders);
+    }
+}
+exports.Anime = Anime;

package/bin/cache.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search_cache = exports.new_cache = exports.clear_cache = void 0;
+const fs = __importStar(require("fs"));
+function clear_cache(location, show) {
+    try {
+        console.log("ye sorry that doesnt exist yet.");
+        if (show) {
+            console.log("Cleared cache");
+        }
+    }
+    catch {
+        if (show) {
+            console.log("Failed to clear cache.");
+        }
+    }
+}
+exports.clear_cache = clear_cache;
+function new_cache(location, anime, show) {
+    try {
+        fs.writeFileSync(location + "/" + anime.id + ".cache", JSON.stringify(anime));
+    }
+    catch {
+        if (show) {
+            console.log("Failed to write to cache");
+        }
+    }
+}
+exports.new_cache = new_cache;
+function get_cache(location, anime_id) {
+    return JSON.parse(fs.readFileSync(location + "/" + anime_id + ".cache").toString());
+}
+function search_cache(location, anime_id) {
+    try {
+        if (check_cache(location, anime_id)) {
+            return get_cache(location, anime_id);
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+exports.search_cache = search_cache;
+function check_cache(location, anime_id) {
+    return fs.readdirSync(location).includes(anime_id + ".cache");
+}

package/bin/change_config.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config_ = void 0;
+const chalk = require("chalk");
+const input_1 = require("./input");
+async function config_(temp) {
+    console.clear();
+    console.log(chalk.blue("ANI-CLI-NPM \n"));
+    console.log(chalk.yellow("Config:\n"));
+    let choice = await (0, input_1.selection)([
+        "Player; " + temp.player,
+        "Proxy; " + temp.proxy,
+        "User agent; " + temp.user_agent,
+        "Downloads folder; " + temp.download_folder,
+        "Save and exit",
+        "Exit without saving"
+    ], [], ((item) => { return chalk.cyan(item); }), ((item) => { return chalk.cyan(item); }));
+    switch (choice) {
+        case 0:
+            let player = await (0, input_1.selection)([
+                "VLC      - VLC media player",
+                "Browser  - Play in default browser",
+                "MPV      - MPV media player",
+                "Link     - Simply display the link in console"
+            ], [], ((item) => { return chalk.cyan(item); }), ((item) => { return chalk.cyan(item); }));
+            switch (player) {
+                case 0:
+                    temp.player = "VLC";
+                    break;
+                case 1:
+                    temp.player = "BROWSER";
+                    break;
+                case 2:
+                    temp.player = "MPV";
+                    break;
+                case 3:
+                    temp.player = "LINK";
+                    break;
+            }
+            // @ts-ignore
+            return temp, 0;
+        case 1:
+            console.log(chalk.cyan("New Proxy;"));
+            temp.proxy = (await ((0, input_1.input)())).replaceAll(" ", "");
+            // @ts-ignore
+            return temp, 0;
+        case 2:
+            console.log(chalk.cyan("New User Agent"));
+            temp.user_agent = await ((0, input_1.input)());
+            // @ts-ignore
+            return temp, 0;
+        case 3:
+            console.log(chalk.cyan("New Downloads Folder"));
+            temp.download_folder = await ((0, input_1.input)());
+            // @ts-ignore
+            return temp, 0;
+        case 4:
+            // @ts-ignore
+            return temp, 1;
+        case 5:
+            // @ts-ignore
+            return temp, 2;
+    }
+}
+exports.config_ = config_;

package/bin/curl.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curl = void 0;
+const fetch = require("node-fetch");
+async function curl(url, 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) {
+        console.warn(colors.Red, `Something went wrong connecting to ${url}.`);
+        await search();
+        process.exit()
+    })*/
+    if (redirect) {
+        return response.url;
+    }
+    else {
+        return await response.text();
+    }
+    /*}catch{
+        console.log(colors.Red, "Something went wrong in curl()")
+        await main()
+    }*/
+}
+exports.curl = curl;

package/bin/download.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.download = void 0;
+const search_anime_1 = require("./search_anime");
+const Anime_1 = require("./Anime");
+const input_1 = require("./input");
+const libs_1 = require("./libs");
+const chalk_1 = __importDefault(require("chalk"));
+async function download(cache_folder, config) {
+    try {
+        console.clear();
+        let download_id = await (0, search_anime_1.search)();
+        let download = new Anime_1.Anime();
+        await download.init(download_id, cache_folder);
+        console.log(`Select start episode [1-${download.episode_list.length}]`);
+        let start_ep_number = await (0, input_1.number_input)(download.episode_list.length);
+        console.log(`Select end episode [${start_ep_number}-${download.episode_list.length}]`);
+        let end_ep_number = await (0, input_1.number_input)(download.episode_list.length, start_ep_number) - 1;
+        let to_do = (0, libs_1.range)(start_ep_number, end_ep_number + 1);
+        do {
+            for (let x in to_do) {
+                try {
+                    await download.download(to_do[x] - 1, config.download_folder);
+                    to_do.splice(Number(x), 1);
+                }
+                catch {
+                    console.log(chalk_1.default.red("Failed to download episode " + to_do[x]));
+                }
+            }
+            if (to_do[0] !== undefined) { //TODO fix buggy downloads
+                console.log(chalk_1.default.red("Failed to download episodes: " + to_do) + "\nRetrying...");
+            }
+        } while (to_do[0] !== undefined);
+    }
+    catch {
+        return 1;
+    }
+    return 0;
+}
+exports.download = download;

package/bin/generate_link.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate_link = void 0;
+const gogohd_url = "https://gogohd.net/";
+const base_url = "https://animixplay.to";
+const curl_1 = require("./curl");
+const regex_1 = require("./regex");
+async function generate_link(provider, id, player) {
+    let html_ = "";
+    let provider_name = "";
+    switch (provider) {
+        case 1:
+            html_ = await (0, curl_1.curl)(`${gogohd_url}streaming.php?id=${id}`);
+            provider_name = 'Xstreamcdn';
+            console.log(`Fetching ${provider_name} links...`);
+            let html = html_.split("\n");
+            let fb_id = "";
+            for (let x in html) {
+                if ((0, regex_1.RegexParse)(html[x], "*<li class=\"linkserver\" data-status=\"1\" data-video=\"https://fembed9hd.com/v/*")) {
+                    fb_id = html[x].slice(html[x].indexOf("/v/") + 3, html[x].indexOf("\">X"));
+                    break;
+                }
+            }
+            if (!fb_id) {
+                console.log("Error, no fb_id found.");
+                return 0;
+            }
+            //let refr = "https://fembed-hd.com/v/"+fb_id
+            let post = await (0, curl_1.curl)("https://fembed-hd.com/api/source/" + fb_id, "POST");
+            post = post.slice(post.indexOf(",\"data\":[{\"file\":\"") + 18, post.length);
+            post = post.slice(0, post.indexOf("\"")).replaceAll("\\/", "/");
+            return post;
+        case 2:
+            provider_name = 'Animixplay';
+            let buffer = new Buffer(id);
+            let enc_id = buffer.toString("base64");
+            buffer = new Buffer(id + "LTXs3GrU8we9O" + enc_id);
+            let ani_id = buffer.toString("base64");
+            buffer = Buffer.from((await (0, curl_1.curl)(`${base_url}/api/live${ani_id}`, "GET", true)).split("#")[1], "base64");
+            if (player === "BROWSER") {
+                return `${base_url}/api/live${ani_id}`;
+            }
+            return buffer.toString("utf-8");
+    }
+}
+exports.generate_link = generate_link;