gerdur 0.0.0-probe → 1.0.0

package/dist/src/lib/arl-setup.js

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverFromLoginFailure = exports.runSetup = exports.ensureArl = exports.chooseAndConfigureArl = exports.promptForEmailLogin = exports.tryEmailLogin = exports.resolveCredentials = exports.promptForArl = exports.printArlInstructions = exports.isInteractive = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const signale_1 = __importDefault(require("./signale"));
+const email_login_1 = require("./email-login");
+/**
+ * True when we are attached to an interactive terminal and not running in a
+ * scripted / headless context. Only then is it safe to block on a prompt.
+ */
+const isInteractive = (headless) => !headless && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+exports.isInteractive = isInteractive;
+/**
+ * Print short, copy-pasteable instructions on where to obtain a Deezer arl cookie.
+ */
+const printArlInstructions = () => {
+    console.log(signale_1.default.info('An ' + chalk_1.default.yellow('arl') + ' cookie is required to log in to Deezer.'));
+    console.log(signale_1.default.note('How to get it:'));
+    console.log(signale_1.default.note('1. Open ' + chalk_1.default.cyan('https://www.deezer.com') + ' in your browser and log in.'));
+    console.log(signale_1.default.note('2. Open DevTools (F12) → ' + chalk_1.default.cyan('Application') + ' → Cookies → deezer.com.'));
+    console.log(signale_1.default.note('3. Copy the value of the ' + chalk_1.default.yellow('arl') + ' cookie (a long hex string).'));
+    console.log(signale_1.default.note('You can also set it any time with: ' + chalk_1.default.cyan('gerdur --set-arl <arl>')));
+    console.log(signale_1.default.note('Or without a config file: ' + chalk_1.default.cyan('GERDUR_ARL=<arl> gerdur ...')));
+};
+exports.printArlInstructions = printArlInstructions;
+/**
+ * Interactively ask the user to paste an arl cookie and persist it to config.
+ *
+ * Returns the entered arl, or `null` if the user aborted / gave nothing.
+ * The caller is responsible for only invoking this in an interactive context.
+ */
+const promptForArl = async (conf) => {
+    const { arl } = await (0, prompts_1.default)([
+        {
+            type: 'password',
+            name: 'arl',
+            message: 'Paste your arl cookie:',
+            validate: (value) => {
+                const v = (value || '').trim();
+                if (!v) {
+                    return 'arl cannot be empty';
+                }
+                if (!/^[a-f0-9]{16,}$/i.test(v)) {
+                    return 'That does not look like an arl (expected a long hex string)';
+                }
+                return true;
+            },
+        },
+    ], {
+        onCancel: () => {
+            console.log(signale_1.default.note('Aborted.'));
+            process.exit();
+        },
+    });
+    const value = (arl || '').trim();
+    if (!value) {
+        return null;
+    }
+    const configPath = conf.set('cookies.arl', value);
+    console.log(signale_1.default.success('arl saved.'));
+    console.log(signale_1.default.note(configPath));
+    return value;
+};
+exports.promptForArl = promptForArl;
+/**
+ * Resolve email/password credentials from (in order): explicit config, then the
+ * `GERDUR_EMAIL` / `GERDUR_PASSWORD` environment variables. Used for non-interactive
+ * login attempts. Returns `null` if either half is missing.
+ */
+const resolveCredentials = (conf) => {
+    const email = (conf.get('cookies.email') || process.env.GERDUR_EMAIL || '').trim();
+    const password = (conf.get('cookies.password') || process.env.GERDUR_PASSWORD || '').trim();
+    if (email && password) {
+        return { email, password };
+    }
+    return null;
+};
+exports.resolveCredentials = resolveCredentials;
+/**
+ * Attempt an email/password login and, on success, persist the fetched arl.
+ * The password itself is never written to disk by this function.
+ *
+ * Returns the arl on success, or `null` on any failure (the caller should fall
+ * back to pasting an arl).
+ */
+const tryEmailLogin = async (conf, email, password, { persistCredentials = false } = {}) => {
+    console.log(signale_1.default.pending('Logging in as ' + email + '...'));
+    const result = await (0, email_login_1.loginWithEmail)(email, password);
+    if (!result.ok) {
+        console.log(signale_1.default.warn(result.message));
+        return null;
+    }
+    if (persistCredentials) {
+        conf.set('cookies.email', email);
+        conf.set('cookies.password', password);
+        console.log(signale_1.default.warn('Email and password saved in plaintext in your config file. Anyone with the file can read them.'));
+    }
+    const configPath = conf.set('cookies.arl', result.arl);
+    console.log(signale_1.default.success('Logged in and saved arl.'));
+    console.log(signale_1.default.note(configPath));
+    return result.arl;
+};
+exports.tryEmailLogin = tryEmailLogin;
+/**
+ * Interactively prompt for email + password (password masked), attempt login,
+ * and persist the arl on success. Offers to save the credentials to config
+ * (with a plaintext warning) if the login worked.
+ *
+ * Returns the arl on success, or `null` on failure/cancel so the caller can
+ * fall back to pasting an arl.
+ */
+const promptForEmailLogin = async (conf) => {
+    const { email, password } = await (0, prompts_1.default)([
+        {
+            type: 'text',
+            name: 'email',
+            message: 'Deezer email:',
+            validate: (v) => (v && v.includes('@') ? true : 'Enter a valid email'),
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Deezer password:',
+            validate: (v) => (v ? true : 'Password cannot be empty'),
+        },
+    ], {
+        onCancel: () => {
+            console.log(signale_1.default.note('Aborted.'));
+            process.exit();
+        },
+    });
+    if (!email || !password) {
+        return null;
+    }
+    const arl = await (0, exports.tryEmailLogin)(conf, email, password);
+    if (!arl) {
+        return null;
+    }
+    const { save } = await (0, prompts_1.default)([
+        {
+            type: 'confirm',
+            name: 'save',
+            message: 'Save email & password to config for future logins? (stored in plaintext)',
+            initial: false,
+        },
+    ]);
+    if (save) {
+        conf.set('cookies.email', email);
+        conf.set('cookies.password', password);
+        console.log(signale_1.default.warn('Saved in plaintext. Delete them from your config to remove.'));
+    }
+    return arl;
+};
+exports.promptForEmailLogin = promptForEmailLogin;
+/**
+ * Interactive picker for how to configure an arl.
+ *
+ * Offers email/password login (which fetches the arl automatically via Deezer's
+ * mobile OAuth flow) and pasting an arl. Email login falls back to arl paste if
+ * it fails. The `_experimentalLogin` parameter is retained for backward
+ * compatibility and no longer gates the email option.
+ *
+ * Returns the arl on success or `null` if nothing was configured.
+ */
+const chooseAndConfigureArl = async (conf, _experimentalLogin = false) => {
+    const { method } = await (0, prompts_1.default)([
+        {
+            type: 'select',
+            name: 'method',
+            message: 'How would you like to log in?',
+            choices: [
+                { title: 'Email & password (fetches your arl automatically)', value: 'email' },
+                { title: 'Paste an arl cookie', value: 'arl' },
+            ],
+            initial: 0,
+        },
+    ]);
+    if (method === 'email') {
+        const arl = await (0, exports.promptForEmailLogin)(conf);
+        if (arl) {
+            return arl;
+        }
+        console.log(signale_1.default.note('Falling back to entering an arl manually.'));
+    }
+    (0, exports.printArlInstructions)();
+    console.log('');
+    return (0, exports.promptForArl)(conf);
+};
+exports.chooseAndConfigureArl = chooseAndConfigureArl;
+/**
+ * Ensure a usable arl is configured before attempting to log in.
+ *
+ * When no user-supplied arl exists (empty or still the bundled default) and we
+ * are in an interactive terminal, print instructions and prompt for one.
+ * In non-interactive / headless contexts this is a no-op so existing scripted
+ * behavior is preserved.
+ *
+ * Returns the arl to use for the session.
+ */
+const ensureArl = async (conf, headless, experimentalLogin = false) => {
+    if (conf.hasUserArl()) {
+        return conf.getArl();
+    }
+    // Non-interactive: no prompting. If email/password are configured (env/config)
+    // but no arl is set yet, attempt a login so scripted/headless runs can work
+    // from credentials alone. Otherwise keep the existing (default arl) behavior.
+    if (!(0, exports.isInteractive)(headless)) {
+        const creds = (0, exports.resolveCredentials)(conf);
+        if (creds) {
+            const arl = await (0, exports.tryEmailLogin)(conf, creds.email, creds.password);
+            if (arl) {
+                return arl;
+            }
+        }
+        return conf.getArl();
+    }
+    console.log(signale_1.default.warn('No arl cookie configured yet (using the shared default).'));
+    const arl = await (0, exports.chooseAndConfigureArl)(conf, experimentalLogin);
+    return arl ?? conf.getArl();
+};
+exports.ensureArl = ensureArl;
+/**
+ * On-demand guided setup, triggered by `gerdur setup` / `--setup`.
+ *
+ * Always prints instructions and prompts for an arl (even when one is already
+ * configured), so users can (re)configure without hunting for the flag.
+ * Requires an interactive terminal.
+ */
+const runSetup = async (conf, headless, experimentalLogin = false) => {
+    if (!(0, exports.isInteractive)(headless)) {
+        console.error(signale_1.default.error('Setup requires an interactive terminal.'));
+        console.error(signale_1.default.note('Use ' + chalk_1.default.cyan('gerdur --set-arl <arl>') + ' or the GERDUR_ARL env var instead.'));
+        process.exit(1);
+    }
+    console.log(signale_1.default.info('gerdur guided setup'));
+    if (conf.hasUserArl()) {
+        console.log(signale_1.default.note('An arl is already configured; continuing will replace it.'));
+    }
+    await (0, exports.chooseAndConfigureArl)(conf, experimentalLogin);
+    console.log(signale_1.default.success('Setup complete. Run ' + chalk_1.default.cyan('gerdur') + ' to start downloading.'));
+    process.exit();
+};
+exports.runSetup = runSetup;
+/**
+ * Handle a failed login by offering to enter a fresh arl and retrying.
+ *
+ * Returns the new arl if the user provided one, otherwise `null` (and the
+ * original error should be surfaced by the caller).
+ */
+const recoverFromLoginFailure = async (conf, headless, err, experimentalLogin = false) => {
+    if (!(0, exports.isInteractive)(headless)) {
+        return null;
+    }
+    console.log(signale_1.default.error('Could not log in: ' + err.message));
+    console.log(signale_1.default.note('Your arl cookie is likely missing, expired, or invalid.'));
+    console.log('');
+    const { retry } = await (0, prompts_1.default)([
+        {
+            type: 'confirm',
+            name: 'retry',
+            message: 'Set up a new login now?',
+            initial: true,
+        },
+    ]);
+    if (!retry) {
+        return null;
+    }
+    return (0, exports.chooseAndConfigureArl)(conf, experimentalLogin);
+};
+exports.recoverFromLoginFailure = recoverFromLoginFailure;

package/dist/src/lib/auto-updater.d.ts

@@ -0,0 +1,2 @@
+declare const updateBinary: (pkg: any) => Promise<void>;
+export default updateBinary;

package/dist/src/lib/auto-updater.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const got_1 = __importDefault(require("got"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const chalk_1 = __importDefault(require("chalk"));
+const log_update_1 = __importDefault(require("log-update"));
+const signale_1 = __importDefault(require("./signale"));
+const util_1 = require("./util");
+const updateCheck = async (pkg) => {
+    const beta = pkg.version.includes('beta');
+    const releases = await (0, got_1.default)('https://api.github.com/repos/soulwax/gerdur/releases').json();
+    const data = releases.filter((r) => r.prerelease === beta)[0];
+    if (data.tag_name > pkg.version) {
+        return data;
+    }
+    log_update_1.default.clear();
+    console.info(signale_1.default.info(`gerdur is up-to-date (${data.tag_name})`));
+};
+const updateBinary = async (pkg) => {
+    (0, log_update_1.default)(signale_1.default.info('Checking for new updates...'));
+    const data = await updateCheck(pkg);
+    log_update_1.default.clear();
+    if (data) {
+        let platform = '';
+        switch (process.platform) {
+            case 'linux':
+            case 'cygwin':
+                platform = 'linux';
+                break;
+            case 'darwin':
+                platform = 'macos';
+                break;
+            case 'win32':
+                platform = 'win';
+                break;
+            default:
+                throw new Error('Unknown platform: ' + process.platform);
+        }
+        const bin = `gerdur-${data.tag_name}${platform === 'win' ? '.exe' : ''}`;
+        if ((0, fs_1.existsSync)(bin)) {
+            throw new Error(`${bin} already exists`);
+        }
+        const asset = data.assets.find((a) => a.name.includes(platform));
+        if (asset) {
+            console.log(signale_1.default.info('Changelog:'));
+            console.log(data.body + '\n');
+            console.log(`  Downloading ${asset.browser_download_url}`);
+            const bar = (0, util_1.progressBar)(asset.size, 40);
+            const humanSizeTotal = (asset.size / 1024 / 1024).toFixed(2);
+            const { body } = await (0, got_1.default)(asset.browser_download_url, { responseType: 'buffer' }).on('downloadProgress', ({ transferred }) => {
+                (0, log_update_1.default)(`  ${bar(transferred)} | ${humanSizeTotal}MiB`);
+            });
+            log_update_1.default.done();
+            (0, log_update_1.default)(signale_1.default.info('Extracting archive...'));
+            const zip = new adm_zip_1.default(body).getEntries()[0].getData();
+            log_update_1.default.clear();
+            console.log(signale_1.default.info('Writing to ' + bin));
+            (0, fs_1.writeFileSync)(bin, zip, { mode: '755' });
+            console.log(signale_1.default.info(`Updated. Run ${chalk_1.default.yellow(bin)} to use the new version.`));
+        }
+        else {
+            throw new Error(`Unable to find asset for ${platform}`);
+        }
+    }
+};
+exports.default = updateBinary;

package/dist/src/lib/config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Default per-user (global) config location, so `gerdur` works from any directory
+ * without needing a `gerdur.config.json` in the current folder.
+ * Honors `XDG_CONFIG_HOME` on Linux/macOS, otherwise falls back to `~/.config`.
+ */
+export declare const globalConfigPath: () => string;
+/**
+ * Resolve which config file to use when the user did not pass `--config-file`.
+ * Preference order:
+ *   1. `gerdur.config.json` in the current directory (project-local, legacy behavior)
+ *   2. the global config file (if it already exists)
+ *   3. the global config path (created on first write)
+ */
+export declare const resolveConfigFile: (configFile: string) => string;
+type keysType = 'concurrency' | 'saveLayout' | 'saveLayout.track' | 'saveLayout.album' | 'saveLayout.artist' | 'saveLayout.playlist' | 'playlist.resolveFullPath' | 'trackNumber' | 'fallbackTrack' | 'fallbackQuality' | 'overwrite' | 'coverSize' | 'coverSize.128' | 'coverSize.320' | 'coverSize.flac' | 'cookies.arl' | 'cookies.email' | 'cookies.password';
+declare class Config {
+    userConfigLocation: string | null;
+    private configFile;
+    private store;
+    constructor(configFile?: string);
+    private getConfig;
+    /**
+     * Get an item.
+     * @param key - The key of the item to get.
+     * @param defaultValue - The default value if the item does not exist.
+     */
+    get(key: keysType, defaultValue?: string | boolean | number): string | number | boolean | undefined;
+    /**
+     * Set an item or multiple items at once.
+     * @param {key|object} - You can use [dot-notation](https://github.com/sindresorhus/dot-prop) in a key to access nested properties. Or a hashmap of items to set at once.
+     * @param value - Must be JSON serializable. Trying to set the type `undefined`, `function`, or `symbol` will result in a `TypeError`.
+     */
+    set(key: keysType, value: string | boolean | number, persist?: boolean): string;
+    /**
+     * Delete an item.
+     * @param key - The key of the item to delete.
+     */
+    delete(key: keysType): void;
+    /**
+     * The arl to use for the session. The `GERDUR_ARL` environment variable takes
+     * precedence over the stored config so it can be supplied without writing a
+     * config file (useful for CI, containers, and quick one-offs).
+     */
+    getArl(): string;
+    /**
+     * Whether a usable arl cookie has been provided by the user, via the
+     * `GERDUR_ARL` environment variable or config. Returns `false` when the arl is
+     * empty or still the bundled default (which is shared, rate-limited, and
+     * expires) so callers can prompt for one.
+     */
+    hasUserArl(): boolean;
+}
+export default Config;

package/dist/src/lib/config.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigFile = exports.globalConfigPath = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const dot_prop_1 = __importDefault(require("dot-prop"));
+const signale_1 = __importDefault(require("./signale"));
+/**
+ * Default per-user (global) config location, so `gerdur` works from any directory
+ * without needing a `gerdur.config.json` in the current folder.
+ * Honors `XDG_CONFIG_HOME` on Linux/macOS, otherwise falls back to `~/.config`.
+ */
+const globalConfigPath = () => {
+    const base = process.env.XDG_CONFIG_HOME || (0, path_1.join)((0, os_1.homedir)(), '.config');
+    return (0, path_1.join)(base, 'gerdur', 'gerdur.config.json');
+};
+exports.globalConfigPath = globalConfigPath;
+/**
+ * Resolve which config file to use when the user did not pass `--config-file`.
+ * Preference order:
+ *   1. `gerdur.config.json` in the current directory (project-local, legacy behavior)
+ *   2. the global config file (if it already exists)
+ *   3. the global config path (created on first write)
+ */
+const resolveConfigFile = (configFile) => {
+    const isDefaultName = configFile === 'gerdur.config.json';
+    if (!isDefaultName) {
+        return configFile;
+    }
+    if ((0, fs_1.existsSync)(configFile)) {
+        return configFile;
+    }
+    const global = (0, exports.globalConfigPath)();
+    if ((0, fs_1.existsSync)(global)) {
+        return global;
+    }
+    return configFile;
+};
+exports.resolveConfigFile = resolveConfigFile;
+const old_arl = 'c911a4ac9f44a52bf23720cc88588557d999b975094068d258e617bf3e9110a2626c2ff7f5d3cb471b435512e0f5a4de4d7d7e3becad4bf80b0a0e230d9001a814124f87833fe772fb6b1327d2be740f65bc5bcfc1de9171926b5ea9aae69db7';
+const defaultConfig = {
+    concurrency: 4,
+    saveLayout: {
+        track: 'Music/{ALB_TITLE}/{SNG_TITLE}',
+        album: 'Music/{ALB_TITLE}/{SNG_TITLE}',
+        artist: 'Music/{ALB_TITLE}/{SNG_TITLE}',
+        playlist: 'Playlist/{TITLE}/{SNG_TITLE}',
+    },
+    playlist: {
+        resolveFullPath: false,
+    },
+    trackNumber: true,
+    fallbackTrack: true,
+    fallbackQuality: true,
+    overwrite: false,
+    coverSize: {
+        '128': 500,
+        '320': 500,
+        flac: 1000,
+    },
+    cookies: {
+        arl: 'c973964816688562722418b5200c1515dffaad15a42643ebf87cc72824a54612ec51c2ad42d566743f9e424c774e98ccae7737770acff59251328e6cd598c7bcac38ca269adf78bfb88ec5bbad6cd800db3c0b88b2af645bb22b99e71de26416',
+    },
+};
+class Config {
+    userConfigLocation;
+    configFile;
+    store;
+    constructor(configFile = 'gerdur.config.json') {
+        this.userConfigLocation = null;
+        this.configFile = (0, exports.resolveConfigFile)(configFile);
+        this.store = this.getConfig(this.configFile);
+        // migrate data
+        if (this.store.cookies.arl === old_arl) {
+            this.set('cookies.arl', defaultConfig.cookies.arl);
+        }
+    }
+    getConfig(configFile) {
+        if (!(0, fs_1.existsSync)(configFile)) {
+            return defaultConfig;
+        }
+        try {
+            const userConfig = JSON.parse((0, fs_1.readFileSync)(configFile, 'utf-8'));
+            if (userConfig.saveLayout) {
+                userConfig.saveLayout = { ...defaultConfig.saveLayout, ...userConfig.saveLayout };
+            }
+            if (userConfig.playlist) {
+                userConfig.playlist = { ...defaultConfig.playlist, ...userConfig.playlist };
+            }
+            if (userConfig.coverSize) {
+                userConfig.coverSize = { ...defaultConfig.coverSize, ...userConfig.coverSize };
+            }
+            if (userConfig.cookies) {
+                userConfig.cookies = { ...defaultConfig.cookies, ...userConfig.cookies };
+            }
+            this.userConfigLocation = configFile;
+            return { ...defaultConfig, ...userConfig };
+        }
+        catch (err) {
+            console.error(signale_1.default.error(`Unable to parse config: ${configFile}`));
+            console.error(signale_1.default.note(err.message));
+            console.warn(signale_1.default.warn('Falling back to default config'));
+            return defaultConfig;
+        }
+    }
+    /**
+     * Get an item.
+     * @param key - The key of the item to get.
+     * @param defaultValue - The default value if the item does not exist.
+     */
+    get(key, defaultValue) {
+        return dot_prop_1.default.get(this.store, key, defaultValue);
+    }
+    /**
+     * Set an item or multiple items at once.
+     * @param {key|object} - You can use [dot-notation](https://github.com/sindresorhus/dot-prop) in a key to access nested properties. Or a hashmap of items to set at once.
+     * @param value - Must be JSON serializable. Trying to set the type `undefined`, `function`, or `symbol` will result in a `TypeError`.
+     */
+    set(key, value, persist = true) {
+        dot_prop_1.default.set(this.store, key, value);
+        if (persist) {
+            const dir = (0, path_1.dirname)(this.configFile);
+            if (dir && !(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(this.configFile, JSON.stringify(this.store, null, 2));
+        }
+        return this.configFile;
+    }
+    /**
+     * Delete an item.
+     * @param key - The key of the item to delete.
+     */
+    delete(key) {
+        dot_prop_1.default.delete(this.store, key);
+    }
+    /**
+     * The arl to use for the session. The `GERDUR_ARL` environment variable takes
+     * precedence over the stored config so it can be supplied without writing a
+     * config file (useful for CI, containers, and quick one-offs).
+     */
+    getArl() {
+        const env = (process.env.GERDUR_ARL || '').trim();
+        if (env) {
+            return env;
+        }
+        return dot_prop_1.default.get(this.store, 'cookies.arl', '');
+    }
+    /**
+     * Whether a usable arl cookie has been provided by the user, via the
+     * `GERDUR_ARL` environment variable or config. Returns `false` when the arl is
+     * empty or still the bundled default (which is shared, rate-limited, and
+     * expires) so callers can prompt for one.
+     */
+    hasUserArl() {
+        const arl = this.getArl();
+        return Boolean(arl) && arl !== defaultConfig.cookies.arl && arl !== old_arl;
+    }
+}
+exports.default = Config;

package/dist/src/lib/decrypt-pool.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const decryptDownloadFile: (tmpfile: string, trackId: string) => Promise<Buffer>;