wsnipz 1.0.0

package/dist/banner.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printBanner = printBanner;
+const figlet_1 = __importDefault(require("figlet"));
+const chalk_1 = __importDefault(require("chalk"));
+const ui_1 = require("./ui");
+const VERSION = '1.0.0';
+function printBanner() {
+    const art = figlet_1.default.textSync('WSniper', {
+        font: 'Standard',
+        horizontalLayout: 'fitted',
+        verticalLayout: 'default',
+    });
+    const colored = (0, ui_1.gradient)(['#5865F2', '#9B59B6', '#EB459E'], art);
+    console.log(colored);
+    const tag = ' Discord Username Availability Checker ';
+    const line = chalk_1.default.gray('─'.repeat(tag.length));
+    console.log(chalk_1.default.gray(tag));
+    console.log(line);
+    console.log(chalk_1.default.gray(`  v${VERSION}  •  proxies rotatifs  •  mode interactif`));
+    console.log();
+}

package/dist/checker.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUsernames = checkUsernames;
+const discord_1 = require("./discord");
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function checkUsernames(usernames, opts) {
+    const results = [];
+    let cursor = 0;
+    let done = 0;
+    const total = usernames.length;
+    async function worker() {
+        while (true) {
+            const i = cursor++;
+            if (i >= total)
+                break;
+            const username = usernames[i];
+            let res = await (0, discord_1.checkUsername)(username, opts.token, opts.pool);
+            if (res.status === 'ratelimited') {
+                const waitMs = Math.max((res.retryAfter ?? 1) * 1000, 500);
+                await sleep(waitMs);
+                res = await (0, discord_1.checkUsername)(username, opts.token, opts.pool);
+            }
+            const result = {
+                username,
+                status: res.status,
+                message: res.message,
+            };
+            results.push(result);
+            done++;
+            opts.onProgress?.(done, total, result);
+            if (opts.delayMs > 0)
+                await sleep(opts.delayMs);
+        }
+    }
+    const workers = Array.from({ length: Math.max(opts.concurrency, 1) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}

package/dist/config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_PATH = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.wsniper');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+exports.CONFIG_PATH = CONFIG_FILE;
+function loadConfig() {
+    try {
+        if (fs_1.default.existsSync(CONFIG_FILE)) {
+            const raw = fs_1.default.readFileSync(CONFIG_FILE, 'utf-8');
+            const parsed = JSON.parse(raw);
+            return {
+                token: parsed.token ?? null,
+                proxy: parsed.proxy ?? null,
+            };
+        }
+    }
+    catch {
+        // ignore malformed config
+    }
+    return { token: null, proxy: null };
+}
+function saveConfig(config) {
+    try {
+        if (!fs_1.default.existsSync(CONFIG_DIR)) {
+            fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    catch {
+        // ignore write errors
+    }
+}

package/dist/discord.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUsername = checkUsername;
+exports.validateToken = validateToken;
+const axios_1 = __importDefault(require("axios"));
+const POMELO_ENDPOINT = 'https://discord.com/api/v9/users/@me/pomelo-attempt';
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+    'x-discord-locale': 'en-US',
+};
+async function checkUsername(username, token, pool) {
+    const config = {
+        method: 'POST',
+        url: POMELO_ENDPOINT,
+        headers: { ...DEFAULT_HEADERS, Authorization: token },
+        data: { username },
+        validateStatus: () => true,
+        timeout: 15000,
+        proxy: false,
+    };
+    const proxyUrl = pool?.next() ?? undefined;
+    if (proxyUrl) {
+        const agent = pool.createAgent(proxyUrl);
+        config.httpAgent = agent;
+        config.httpsAgent = agent;
+    }
+    try {
+        const res = await axios_1.default.request(config);
+        if (res.status === 204 || res.status === 200) {
+            if (res.data?.taken === true) {
+                return { status: 'taken', message: 'Pseudo déjà pris' };
+            }
+            return { status: 'available' };
+        }
+        if (res.status === 429) {
+            const retryAfter = Number(res.data?.retry_after ?? 1);
+            return { status: 'ratelimited', retryAfter: isNaN(retryAfter) ? 1 : retryAfter };
+        }
+        if (res.status === 400) {
+            if (res.data?.taken === true) {
+                return { status: 'taken', message: 'Pseudo déjà pris' };
+            }
+            const usernameErrors = res.data?.errors?.username?._errors || [];
+            const codes = usernameErrors.map((e) => e.code).filter(Boolean);
+            if (codes.includes('USERNAME_TOO_MANY_RESULTS')) {
+                return { status: 'taken', message: 'Pseudo déjà pris' };
+            }
+            if (codes.length > 0) {
+                return { status: 'invalid', message: codes.join(', ') };
+            }
+            return { status: 'invalid', message: 'Format invalide' };
+        }
+        if (res.status === 401 || res.status === 403) {
+            return { status: 'error', message: `Token invalide (${res.status})` };
+        }
+        return { status: 'error', message: `HTTP ${res.status}` };
+    }
+    catch (err) {
+        return { status: 'error', message: err?.code || err?.message || 'Erreur réseau' };
+    }
+}
+async function validateToken(token, pool) {
+    // A lightweight check: a known-taken username should return 400 (taken) rather than 401.
+    const res = await checkUsername('discord', token, pool);
+    return res.status !== 'error' || !res.message?.includes('Token invalide');
+}

package/dist/generators.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECIAL = exports.DIGITS = exports.LETTERS = void 0;
+exports.charsetFor = charsetFor;
+exports.patternLabel = patternLabel;
+exports.generateUsernames = generateUsernames;
+exports.maxUniqueFor = maxUniqueFor;
+exports.LETTERS = 'abcdefghijklmnopqrstuvwxyz';
+exports.DIGITS = '0123456789';
+exports.SPECIAL = '._';
+const PATTERN_SETS = {
+    'letters': exports.LETTERS,
+    'digits': exports.DIGITS,
+    'letters+digits': exports.LETTERS + exports.DIGITS,
+    'letters+special': exports.LETTERS + exports.SPECIAL,
+    'letters+digits+special': exports.LETTERS + exports.DIGITS + exports.SPECIAL,
+    'digits+special': exports.DIGITS + exports.SPECIAL,
+};
+const PATTERN_LABELS = {
+    'letters': 'Lettres (a-z)',
+    'digits': 'Chiffres (0-9)',
+    'letters+digits': 'Lettres + Chiffres',
+    'letters+special': 'Lettres + Caractères spéciaux (._)',
+    'letters+digits+special': 'Lettres + Chiffres + Caractères spéciaux',
+    'digits+special': 'Chiffres + Caractères spéciaux',
+};
+function charsetFor(pattern) {
+    return PATTERN_SETS[pattern];
+}
+function patternLabel(pattern) {
+    return PATTERN_LABELS[pattern] || pattern;
+}
+function randomString(length, charset) {
+    let out = '';
+    for (let i = 0; i < length; i++) {
+        out += charset[Math.floor(Math.random() * charset.length)];
+    }
+    return out;
+}
+function generateUsernames(pattern, length, count) {
+    const charset = charsetFor(pattern);
+    const seen = new Set();
+    const out = [];
+    const maxAttempts = count * 1000;
+    let attempts = 0;
+    while (out.length < count && attempts < maxAttempts) {
+        attempts++;
+        const name = randomString(length, charset);
+        if (!seen.has(name)) {
+            seen.add(name);
+            out.push(name);
+        }
+    }
+    return out;
+}
+function maxUniqueFor(pattern, length) {
+    const charset = charsetFor(pattern);
+    return Math.pow(charset.length, length);
+}

package/dist/index.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const banner_1 = require("./banner");
+const prompts_1 = require("./prompts");
+const config_1 = require("./config");
+const program = new commander_1.Command();
+function guardInteractive() {
+    if (!process.stdin.isTTY) {
+        console.error(chalk_1.default.yellow('\nwsniper est un outil interactif : lance-le dans un terminal réel.\n' +
+            'Exemple : ') +
+            chalk_1.default.cyan('wsniper') +
+            chalk_1.default.gray('  ou  ') +
+            chalk_1.default.cyan('wsniper config'));
+        return false;
+    }
+    return true;
+}
+program
+    .name('wsniper')
+    .description('Vérificateur de disponibilité de pseudos Discord avec proxies rotatifs')
+    .version('1.0.0');
+program
+    .command('config')
+    .description('Configurer le token Discord et les proxies')
+    .action(async () => {
+    if (!guardInteractive())
+        return;
+    (0, banner_1.printBanner)();
+    const config = (0, config_1.loadConfig)();
+    await (0, prompts_1.configureSettings)(config, (c) => (0, config_1.saveConfig)(c));
+});
+program
+    .command('path')
+    .description('Afficher le chemin du fichier de configuration')
+    .action(() => {
+    console.log(config_1.CONFIG_PATH);
+});
+program
+    .action(async () => {
+    if (!guardInteractive())
+        return;
+    (0, banner_1.printBanner)();
+    const config = (0, config_1.loadConfig)();
+    await (0, prompts_1.mainMenu)(config, (c) => (0, config_1.saveConfig)(c));
+});
+program.parseAsync(process.argv).catch((err) => {
+    if (err?.name === 'ExitPromptError') {
+        console.log(chalk_1.default.gray('\nInterrompu.'));
+        return;
+    }
+    console.error(chalk_1.default.red('\nUne erreur est survenue :'), err?.message || err);
+    process.exit(1);
+});

package/dist/prompts.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROXY_FORMAT_LINES = exports.PATTERN_CHOICES = void 0;
+exports.mainMenu = mainMenu;
+exports.runChecker = runChecker;
+exports.configureSettings = configureSettings;
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const proxies_1 = require("./proxies");
+const generators_1 = require("./generators");
+const checker_1 = require("./checker");
+const ui_1 = require("./ui");
+exports.PATTERN_CHOICES = [
+    { name: 'Lettres uniquement (a-z)', value: 'letters' },
+    { name: 'Chiffres uniquement (0-9)', value: 'digits' },
+    { name: 'Lettres + Chiffres', value: 'letters+digits' },
+    { name: 'Lettres + Caractères spéciaux (._)', value: 'letters+special' },
+    { name: 'Lettres + Chiffres + Caractères spéciaux', value: 'letters+digits+special' },
+    { name: 'Chiffres + Caractères spéciaux', value: 'digits+special' },
+];
+exports.PROXY_FORMAT_LINES = [
+    chalk_1.default.gray('Un proxy par ligne. # pour commenter.'),
+    '',
+    chalk_1.default.white('  http://ip:port'),
+    chalk_1.default.white('  http://utilisateur:mdp@ip:port'),
+    chalk_1.default.white('  https://ip:port'),
+    chalk_1.default.white('  socks4://ip:port'),
+    chalk_1.default.white('  socks5://ip:port'),
+    chalk_1.default.white('  socks5://utilisateur:mdp@ip:port'),
+    chalk_1.default.gray('  ip:port                    -> http par défaut'),
+    chalk_1.default.gray('  ip:port:utilisateur:mdp    -> http par défaut'),
+];
+async function mainMenu(config, save) {
+    while (true) {
+        const { choice } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'choice',
+            message: 'Que veux-tu faire ?',
+            choices: [
+                { name: 'Lancer le checker', value: 'check' },
+                {
+                    name: `Configuration  ${config.token ? chalk_1.default.green('(token ok)') : chalk_1.default.red('(aucun token)')}`,
+                    value: 'config',
+                },
+                { name: 'Quitter', value: 'quit' },
+            ],
+        });
+        if (choice === 'check') {
+            await runChecker(config, save);
+        }
+        else if (choice === 'config') {
+            await configureSettings(config, save);
+        }
+        else {
+            console.log(chalk_1.default.gray('\nÀ bientôt !'));
+            break;
+        }
+    }
+}
+async function ensureProxyPool(config) {
+    const choices = [];
+    if (config.proxy && config.proxy.file && fs_1.default.existsSync(config.proxy.file)) {
+        const n = config.proxy.loaded?.length ?? 0;
+        choices.push({
+            name: `Utiliser les proxies enregistrés (${n} • ${config.proxy.rotating ? 'rotatifs' : 'statiques'})`,
+            value: 'saved',
+        });
+    }
+    choices.push({ name: 'Charger un nouveau fichier de proxies', value: 'new' });
+    choices.push({ name: 'Connexion directe (sans proxy)', value: 'direct' });
+    const { mode } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'mode',
+        message: 'Configuration des proxies :',
+        choices,
+    });
+    if (mode === 'direct') {
+        console.log(chalk_1.default.yellow('  Connexion directe sélectionnée (non recommandé pour un scan massif).'));
+        return null;
+    }
+    if (mode === 'saved') {
+        return proxies_1.ProxyPool.loadFromFile(config.proxy.file, config.proxy.rotating);
+    }
+    console.log((0, ui_1.box)('Format des proxies', exports.PROXY_FORMAT_LINES));
+    console.log();
+    const { file } = await inquirer_1.default.prompt({
+        type: 'input',
+        name: 'file',
+        message: 'Chemin du fichier .txt de proxies :',
+        default: 'proxies.txt',
+        validate: (v) => v && fs_1.default.existsSync(v) ? true : 'Fichier introuvable',
+    });
+    const { rotating } = await inquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'rotating',
+        message: "Vos proxies sont-ils rotatifs (le fournisseur change l'IP automatiquement) ?",
+        default: true,
+    });
+    const pool = proxies_1.ProxyPool.loadFromFile(file, rotating);
+    if (pool.size === 0) {
+        console.log(chalk_1.default.red('  Aucun proxy valide trouvé dans le fichier.'));
+    }
+    config.proxy = { file, rotating, loaded: pool.list };
+    console.log(chalk_1.default.green(`  ${pool.size} proxy(s) chargé(s).`));
+    return pool;
+}
+async function ensureToken(config, save) {
+    if (config.token) {
+        const { reuse } = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'reuse',
+            message: 'Utiliser le token enregistré ?',
+            default: true,
+        });
+        if (reuse)
+            return config.token;
+    }
+    const { token } = await inquirer_1.default.prompt({
+        type: 'password',
+        name: 'token',
+        mask: '*',
+        message: 'Token Discord :',
+        validate: (v) => (v && v.length > 10 ? true : 'Token invalide'),
+    });
+    config.token = token;
+    save(config);
+    return token;
+}
+async function runChecker(config, save) {
+    const { pattern } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'pattern',
+        message: 'Type de pseudo à générer :',
+        choices: exports.PATTERN_CHOICES,
+    });
+    const maxLen = 32;
+    const { length } = await inquirer_1.default.prompt({
+        type: 'number',
+        name: 'length',
+        message: `Longueur des pseudos (2-${maxLen}) :`,
+        default: 4,
+        validate: (v) => v >= 2 && v <= maxLen ? true : `Entre 2 et ${maxLen}`,
+    });
+    const maxUnique = (0, generators_1.maxUniqueFor)(pattern, length);
+    const { count } = await inquirer_1.default.prompt({
+        type: 'number',
+        name: 'count',
+        message: 'Combien de pseudos vérifier ?',
+        default: 50,
+        validate: (v) => v >= 1 && v <= 100000 ? true : 'Entre 1 et 100000',
+    });
+    const effectiveCount = Math.min(count, maxUnique);
+    if (effectiveCount < count) {
+        console.log(chalk_1.default.yellow(`  Seulement ${maxUnique} combinaisons possibles pour "${(0, generators_1.patternLabel)(pattern)}" de longueur ${length}.`));
+    }
+    const token = await ensureToken(config, save);
+    const pool = await ensureProxyPool(config);
+    save(config);
+    const { concurrency } = await inquirer_1.default.prompt({
+        type: 'number',
+        name: 'concurrency',
+        message: 'Concurrence (requêtes simultanées) :',
+        default: pool && pool.size > 0 ? Math.min(pool.size, 10) : 1,
+        validate: (v) => (v >= 1 && v <= 100 ? true : 'Entre 1 et 100'),
+    });
+    const { delay } = await inquirer_1.default.prompt({
+        type: 'number',
+        name: 'delay',
+        message: 'Délai entre requêtes (ms) :',
+        default: 0,
+        validate: (v) => v >= 0 ? true : '>= 0',
+    });
+    const usernames = (0, generators_1.generateUsernames)(pattern, length, effectiveCount);
+    console.log(chalk_1.default.cyan(`\nGénération de ${usernames.length} pseudos (${(0, generators_1.patternLabel)(pattern)}, longueur ${length})...`));
+    const stats = { available: 0, taken: 0, invalid: 0, errors: 0, total: usernames.length };
+    const spinner = (0, ora_1.default)({ text: 'Vérification en cours...', spinner: 'dots' }).start();
+    const onProgress = (done, total, r) => {
+        if (r.status === 'available')
+            stats.available++;
+        else if (r.status === 'taken')
+            stats.taken++;
+        else if (r.status === 'invalid')
+            stats.invalid++;
+        else
+            stats.errors++;
+        spinner.text =
+            `[${done}/${total}] ` +
+                `${chalk_1.default.green('✓' + stats.available)} ` +
+                `${chalk_1.default.red('✗' + stats.taken)} ` +
+                `${chalk_1.default.yellow('!' + stats.invalid)} ` +
+                `${chalk_1.default.gray('?' + stats.errors)}`;
+        if (r.status === 'available') {
+            spinner.stop();
+            console.log(chalk_1.default.green.bold('  ✓ DISPONIBLE : ') + chalk_1.default.white.bold(r.username));
+            spinner.start();
+        }
+    };
+    const results = await (0, checker_1.checkUsernames)(usernames, {
+        token,
+        pool,
+        concurrency,
+        delayMs: delay,
+        onProgress,
+    });
+    spinner.succeed(chalk_1.default.green('Vérification terminée !'));
+    console.log();
+    console.log((0, ui_1.box)('Résumé', (0, ui_1.summaryLines)(stats)));
+    console.log();
+    const available = results.filter((r) => r.status === 'available');
+    if (available.length > 0) {
+        console.log((0, ui_1.availableTable)(results));
+        const stamp = Date.now();
+        const availFile = `available_${stamp}.txt`;
+        fs_1.default.writeFileSync(availFile, available.map((r) => r.username).join('\n'), 'utf-8');
+        console.log(chalk_1.default.green(`\n  Pseudos disponibles sauvegardés : ${chalk_1.default.bold(availFile)}`));
+    }
+    else {
+        console.log(chalk_1.default.gray('  Aucun pseudo disponible trouvé.'));
+    }
+    const stamp = Date.now();
+    const resFile = `results_${stamp}.txt`;
+    fs_1.default.writeFileSync(resFile, results.map((r) => `${r.username}\t${r.status}${r.message ? '\t' + r.message : ''}`).join('\n'), 'utf-8');
+    console.log(chalk_1.default.gray(`  Résultats complets : ${resFile}\n`));
+}
+async function configureSettings(config, save) {
+    console.log((0, ui_1.box)('Configuration actuelle', [
+        `Token    : ${config.token ? chalk_1.default.green('défini') + chalk_1.default.gray(' (' + config.token.slice(0, 6) + '...)') : chalk_1.default.red('non défini')}`,
+        `Proxies  : ${config.proxy ? `${config.proxy.loaded?.length ?? 0} • ${config.proxy.rotating ? 'rotatifs' : 'statiques'}` : chalk_1.default.red('non configurés')}`,
+        `Fichier  : ${config.proxy?.file ?? '-'}`,
+    ]));
+    console.log();
+    const { setToken } = await inquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'setToken',
+        message: 'Définir un nouveau token Discord ?',
+        default: !config.token,
+    });
+    if (setToken) {
+        const { token } = await inquirer_1.default.prompt({
+            type: 'password',
+            name: 'token',
+            mask: '*',
+            message: 'Token Discord :',
+            validate: (v) => (v && v.length > 10 ? true : 'Token invalide'),
+        });
+        config.token = token;
+        save(config);
+        console.log(chalk_1.default.green('  Token enregistré.'));
+    }
+    const pool = await ensureProxyPool(config);
+    if (pool) {
+        config.proxy = { ...config.proxy, loaded: pool.list };
+    }
+    save(config);
+    console.log(chalk_1.default.green('\nConfiguration enregistrée.'));
+}

package/dist/proxies.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyPool = void 0;
+exports.normalizeProxyUrl = normalizeProxyUrl;
+const fs_1 = __importDefault(require("fs"));
+const { ProxyAgent } = require('proxy-agent');
+function normalizeProxyUrl(raw) {
+    let s = raw.trim();
+    if (!s)
+        return s;
+    const hasScheme = /^[a-z0-9]+:\/\//i.test(s);
+    if (hasScheme) {
+        const idx = s.indexOf('://');
+        const scheme = s.slice(0, idx);
+        const rest = s.slice(idx + 3);
+        const parts = rest.split(':');
+        // ip:port:user:pass without an @ sign -> rewrite to scheme://user:pass@ip:port
+        if (parts.length >= 4 && !rest.includes('@')) {
+            const ip = parts[0];
+            const port = parts[1];
+            const cred = parts.slice(2);
+            const pass = cred.pop();
+            const user = cred.join(':');
+            return `${scheme}://${encodeURIComponent(user)}:${encodeURIComponent(pass)}@${ip}:${port}`;
+        }
+        return s;
+    }
+    // No scheme present
+    if (s.includes('@')) {
+        return 'http://' + s;
+    }
+    const parts = s.split(':');
+    if (parts.length === 2) {
+        return 'http://' + s;
+    }
+    if (parts.length === 4) {
+        const [ip, port, user, pass] = parts;
+        return `http://${encodeURIComponent(user)}:${encodeURIComponent(pass)}@${ip}:${port}`;
+    }
+    if (parts.length === 3) {
+        const [ip, port, user] = parts;
+        return `http://${encodeURIComponent(user)}:@${ip}:${port}`;
+    }
+    return 'http://' + s;
+}
+class ProxyPool {
+    constructor(proxies = [], rotating = false) {
+        this.proxies = [];
+        this.index = 0;
+        this.rotating = false;
+        this.proxies = proxies;
+        this.rotating = rotating;
+    }
+    get size() {
+        return this.proxies.length;
+    }
+    get list() {
+        return [...this.proxies];
+    }
+    static loadFromFile(path, rotating) {
+        const content = fs_1.default.readFileSync(path, 'utf-8');
+        const proxies = content
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith('#'))
+            .map(normalizeProxyUrl)
+            .filter((l) => l.length > 0);
+        return new ProxyPool(proxies, rotating);
+    }
+    next() {
+        if (this.proxies.length === 0)
+            return null;
+        const proxy = this.proxies[this.index % this.proxies.length];
+        this.index++;
+        return proxy;
+    }
+    createAgent(proxyUrl) {
+        return new ProxyAgent(proxyUrl);
+    }
+}
+exports.ProxyPool = ProxyPool;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.gradient = gradient;
+exports.box = box;
+exports.statusLabel = statusLabel;
+exports.availableTable = availableTable;
+exports.summaryLines = summaryLines;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return [
+        parseInt(h.slice(0, 2), 16),
+        parseInt(h.slice(2, 4), 16),
+        parseInt(h.slice(4, 6), 16),
+    ];
+}
+function lerp(a, b, t) {
+    return Math.round(a + (b - a) * t);
+}
+function gradient(colors, text) {
+    if (colors.length === 0)
+        return text;
+    if (colors.length === 1) {
+        const [r, g, b] = hexToRgb(colors[0]);
+        return chalk_1.default.rgb(r, g, b)(text);
+    }
+    const chars = Array.from(text);
+    const n = chars.length;
+    const segs = colors.length - 1;
+    return chars
+        .map((ch, i) => {
+        const t = n === 1 ? 0 : i / (n - 1);
+        const seg = Math.min(Math.floor(t * segs), segs - 1);
+        const localT = t * segs - seg;
+        const c1 = hexToRgb(colors[seg]);
+        const c2 = hexToRgb(colors[seg + 1]);
+        return chalk_1.default.rgb(lerp(c1[0], c2[0], localT), lerp(c1[1], c2[1], localT), lerp(c1[2], c2[2], localT))(ch);
+    })
+        .join('');
+}
+function box(title, lines) {
+    const all = [chalk_1.default.bold.cyan(title), ...lines];
+    const innerWidth = Math.max(...all.map((l) => stripAnsi(l).length)) + 2;
+    const top = '┌' + '─'.repeat(innerWidth) + '┐';
+    const bot = '└' + '─'.repeat(innerWidth) + '┘';
+    const mid = all.map((l) => {
+        const len = stripAnsi(l).length;
+        const pad = ' '.repeat(Math.max(innerWidth - len, 0));
+        return '│ ' + l + pad + '│';
+    });
+    return [top, ...mid, bot].join('\n');
+}
+const STATUS_STYLE = {
+    available: (s) => chalk_1.default.green.bold(s),
+    taken: (s) => chalk_1.default.red(s),
+    invalid: (s) => chalk_1.default.yellow(s),
+    ratelimited: (s) => chalk_1.default.magenta(s),
+    error: (s) => chalk_1.default.gray(s),
+};
+function statusLabel(status) {
+    const fn = STATUS_STYLE[status] || ((s) => s);
+    return fn(status.toUpperCase());
+}
+function availableTable(results) {
+    const available = results.filter((r) => r.status === 'available');
+    if (available.length === 0)
+        return chalk_1.default.gray('Aucun pseudo disponible trouvé.');
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.cyan.bold('#'),
+            chalk_1.default.cyan.bold('Pseudo'),
+            chalk_1.default.cyan.bold('Statut'),
+        ],
+        colWidths: [6, 26, 16],
+        style: { head: [], border: ['gray'] },
+    });
+    available.forEach((r, i) => {
+        table.push([String(i + 1), chalk_1.default.white.bold(r.username), statusLabel(r.status)]);
+    });
+    return table.toString();
+}
+function summaryLines(stats) {
+    return [
+        `  ${chalk_1.default.green.bold('Disponibles')} : ${stats.available}`,
+        `  ${chalk_1.default.red('Pris')}         : ${stats.taken}`,
+        `  ${chalk_1.default.yellow('Invalides')}    : ${stats.invalid}`,
+        `  ${chalk_1.default.gray('Erreurs')}       : ${stats.errors}`,
+        `  ${chalk_1.default.cyan('Total')}         : ${stats.total}`,
+    ];
+}

package/package.json

@@ -0,0 +1 @@
+{"name": "wsnipz", "version": "1.0.0", "description": "A modern Discord username availability checker CLI with rotating proxy support.", "main": "dist/index.js", "bin": {"wsniper": "dist/index.js"}, "files": ["dist"], "scripts": {"build": "tsc", "dev": "ts-node src/index.ts", "start": "node dist/index.js", "prepublishOnly": "npm run build"}, "keywords": ["discord", "username", "checker", "sniper", "cli", "proxy", "availability", "wsnipz"], "author": "", "license": "MIT", "engines": {"node": ">=16"}, "dependencies": {"axios": "^1.7.7", "chalk": "^4.1.2", "cli-table3": "^0.6.5", "commander": "^11.1.0", "figlet": "^1.8.0", "inquirer": "^8.2.6", "ora": "^5.4.1", "proxy-agent": "^5.0.0"}, "devDependencies": {"@types/figlet": "^1.7.0", "@types/inquirer": "^8.2.10", "@types/node": "^20.16.0", "ts-node": "^10.9.2", "typescript": "^5.6.0"}}