@hasindu---7/ff-link-extract 1.0.1 → 2.0.1

package/README.md

@@ -1,58 +1,252 @@
 # ff-link-extract
 
-CLI to extract direct `https://fuckingfast.co/dl/...` links from fuckingfast page URLs.
+Extracts direct download links from fuckingfast page links and generates clean output files.
 
-## Install
+## Commands Overview
+
+This package ships with three CLI commands:
+
+- `ff-link-extract`: Main extractor. Reads input links (plain links, HTML, or supported paste URLs) and generates direct download outputs.
+- `ff-link-extract-autorun`: Opens links from a text file in your browser at timed intervals using config settings.
+- `ff-link-extract-init`: Creates starter files (`urls.txt` and `autorun.config.json`) in your current folder.
+
+Quick examples:
+
+```bash
+# 1) Create starter files in current folder
+ff-link-extract-init
+
+# 2) Extract direct links
+ff-link-extract -i urls.txt -o all-direct-links
+
+# 3) Open extracted links at intervals
+ff-link-extract-autorun -c autorun.config.json
+```
+
+This tool reads your source list, finds page URLs, fetches each page, and extracts the real link in this format:
+
+https://fuckingfast.co/dl/...
+
+## Who This Is For
+
+- Anyone who has a list of fuckingfast page links.
+- Users who want one-click output links.
+- Users who want both machine-readable and human-readable results.
+
+## Fastest Way To Use (Recommended)
+
+Run without installing anything:
+
+```bash
+npx -y @hasindu---7/ff-link-extract -i urls.txt -o all-direct-links
+```
+
+Why recommended:
+
+- Always uses the latest version.
+- No global install issues.
+- Works great across Windows, macOS, and Linux.
+
+## Global Install (Optional)
 
 ```bash
 npm install -g @hasindu---7/ff-link-extract
 ```
 
-## Usage
+Then run:
 
 ```bash
 ff-link-extract -i urls.txt -o all-direct-links
 ```
 
-## Input formats supported
+Create starter files in your current folder:
+
+```bash
+ff-link-extract-init
+```
+
+This creates:
+
+- urls.txt
+- autorun.config.json
+
+So users do not need to look inside node_modules for templates.
+
+## Input File Formats
+
+The input file can be in any of these formats:
 
 - One URL per line.
-- Raw HTML (for example copied `<a href="...">` blocks).
-- Mixed text that contains fuckingfast URLs.
+- Raw HTML blocks (including anchor tags).
+- Mixed text that contains fuckingfast links.
+- A PrivateBin paste URL (for example from paste.fitgirl-repacks.site with a key in the URL hash).
+
+Example file names:
+
+- urls.txt
+- links.txt
+- pasted-html.txt
+
+## Output Files
+
+With this command:
+
+```bash
+ff-link-extract -i urls.txt -o all-direct-links
+```
+
+You get:
+
+- links/YYYY-MM-DD_HH-mm-ss/all-direct-links.txt: Direct links only, one per line.
+- links/YYYY-MM-DD_HH-mm-ss/all-direct-links.html: Clickable links page for browser use.
+- links/YYYY-MM-DD_HH-mm-ss/all-direct-links.json: Full success and error report.
 
-## Output files
+Each run creates a new timestamped folder under links so previous runs stay saved and easy to compare.
 
-With `-o all-direct-links`, it creates:
+## Autorun Mode (Open Links At Intervals)
 
-- `all-direct-links.txt` - direct links only (one per line)
-- `all-direct-links.html` - clickable links page
-- `all-direct-links.json` - detailed report with success/failure per source URL
+This package also includes a second command:
 
-## Options
+- ff-link-extract-autorun
 
-- `-i, --input <file>`: input file path (default: `urls.txt`)
-- `-o, --output-prefix <name>`: output file prefix (default: `direct-links`)
-- `-h, --help`: show help
-- `-v, --version`: show version
+It opens links from a text file in your default browser one by one using timed intervals.
 
-## Local development
+If the input file is not found in the current folder, autorun automatically tries the latest folder inside links.
+
+Default config file shipped with package:
+
+- autorun.config.json
+
+Default config values:
+
+- inputFile: all-direct-links.txt
+- intervalMs: 20000
+- startDelayMs: 3000
+- maxLinks: 999999
+- dryRun: false
+
+Example:
+
+```bash
+ff-link-extract-autorun -c autorun.config.json
+```
+
+If you do not have config yet:
+
+```bash
+ff-link-extract-init
+ff-link-extract-autorun -c autorun.config.json
+```
 
-Run directly without installing globally:
+Quick test mode without opening browser:
 
 ```bash
-node ff_extract_links.js -i urls.txt -o all-direct-links
+ff-link-extract-autorun -c autorun.config.json --dry-run
 ```
 
-Or test as package command locally:
+Override config from command line:
+
+```bash
+ff-link-extract-autorun -i all-direct-links.txt --interval-ms 15000 --start-delay-ms 5000 --max-links 20
+```
+
+## Command Options
+
+- -i, --input <file>: Input file path. Default is urls.txt.
+- -o, --output-prefix <name>: Output prefix. Default is direct-links.
+- -h, --help: Show help.
+- -v, --version: Show installed version.
+
+Autorun command options:
+
+- -c, --config <file>: Config file path. Default is autorun.config.json.
+- -i, --input <file>: Links file path override.
+- --interval-ms <number>: Delay between opening each link.
+- --start-delay-ms <number>: Delay before first link opens.
+- --max-links <number>: Open only first N links.
+- --dry-run: Print schedule only. No browser opens.
+
+Init command options:
+
+- -f, --force: Overwrite existing starter files.
+- -h, --help: Show help.
+
+## Copy-Paste Examples
+
+Use a custom file and custom output name:
+
+```bash
+ff-link-extract -i my-links.txt -o game-links
+```
+
+Use a paste source URL directly:
+
+```bash
+echo "https://paste.fitgirl-repacks.site/?add4fc7178e6fa8f#831kvVZtdGSNdTncYhZ8e2vnks7wuCyYYXHYFeZaWhT3" > paste_source.txt
+ff-link-extract -i paste_source.txt -o game-links
+```
+
+Check installed version:
+
+```bash
+ff-link-extract --version
+```
+
+Show help:
+
+```bash
+ff-link-extract --help
+```
+
+## Updating
+
+If using npx:
+
+- No manual update needed. You get the newest version by default.
+
+If globally installed:
+
+```bash
+npm i -g @hasindu---7/ff-link-extract@latest
+```
+
+## Troubleshooting
+
+Problem: command not found after global install on macOS or Linux.
+
+Use npx instead:
+
+```bash
+npx -y @hasindu---7/ff-link-extract -i urls.txt -o all-direct-links
+```
+
+Problem: extraction fails for some links.
+
+- Check all-direct-links.json for per-link error details.
+- Retry the command after a few minutes.
+- Confirm input actually contains valid fuckingfast page URLs.
+
+Problem: no links found in input.
+
+- Make sure the file includes URLs starting with https://fuckingfast.co/
+- Remove unrelated text if needed and retry.
+
+## Local Development
+
+Run script directly:
+
+```bash
+node bin/ff_extract_links.js -i urls.txt -o all-direct-links
+```
+
+Test package command locally:
 
 ```bash
 npm link
 ff-link-extract -i urls.txt -o all-direct-links
 ```
 
-## Publish to npm
-
-1. `npm login`
-2. `npm publish --access public`
+## Package
 
-If the package name is already taken, change `name` in `package.json` first.
+- Package: @hasindu---7/ff-link-extract
+- Current bundled files are organized under bin and templates for easier maintenance.

package/{ff_extract_links.js → bin/ff_extract_links.js}

@@ -2,12 +2,19 @@
 
 const fs = require('fs');
 const path = require('path');
+const { decryptPrivateBin } = require('privatebin-decrypt');
 
 function parseArgs(argv) {
-  const args = { input: 'urls.txt', outputPrefix: 'direct-links', help: false, version: false };
+  const args = {
+    input: 'urls.txt',
+    outputPrefix: 'direct-links',
+    help: false,
+    version: false,
+  };
 
   for (let i = 2; i < argv.length; i += 1) {
     const arg = argv[i];
+
     if (arg === '-h' || arg === '--help') {
       args.help = true;
       continue;
@@ -33,7 +40,7 @@ function parseArgs(argv) {
 
 function readPackageVersion() {
   try {
-    const packagePath = path.resolve(__dirname, 'package.json');
+    const packagePath = path.resolve(__dirname, '..', 'package.json');
     if (!fs.existsSync(packagePath)) {
       return 'dev';
     }
@@ -56,6 +63,8 @@ function printHelp() {
   console.log('  -o, --output-prefix <name>  Output prefix for .txt/.html/.json files. Default: direct-links');
   console.log('  -h, --help                  Show this help');
   console.log('  -v, --version               Show version');
+  console.log('');
+  console.log('Also supports paste page URLs (e.g. paste.fitgirl-repacks.site) and expands links automatically.');
 }
 
 function sanitizeLine(line) {
@@ -69,12 +78,32 @@ function normalizeExtractedUrl(raw) {
     .trim();
 }
 
-function extractSourceUrls(inputText) {
+function dedupePreserveOrder(values) {
+  return [...new Set(values)];
+}
+
+function extractFuckingfastUrls(inputText) {
   const allMatches = inputText.match(/https?:\/\/fuckingfast\.co\/[^\s"'<>]+/gi) || [];
   const cleaned = allMatches.map(normalizeExtractedUrl).filter(Boolean);
+  return dedupePreserveOrder(cleaned);
+}
 
-  // Preserve order while removing duplicates.
-  return [...new Set(cleaned)];
+function extractHttpUrls(inputText) {
+  const allMatches = inputText.match(/https?:\/\/[^\s"'<>]+/gi) || [];
+  const cleaned = allMatches.map(normalizeExtractedUrl).filter(Boolean);
+  return dedupePreserveOrder(cleaned);
+}
+
+function isAggregatorPageUrl(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    return (
+      u.hostname === 'paste.fitgirl-repacks.site'
+      || u.hostname.endsWith('.paste.fitgirl-repacks.site')
+    );
+  } catch {
+    return false;
+  }
 }
 
 function escapeHtml(str) {
@@ -99,14 +128,12 @@ function extractFilenameFromUrl(rawUrl) {
 }
 
 function extractDirectDownload(html) {
-  // Primary pattern used on the sample pages.
   const openPattern = /window\.open\(\s*["'](https:\/\/fuckingfast\.co\/dl\/[A-Za-z0-9_\-]+)["']\s*\)/i;
   const m1 = html.match(openPattern);
   if (m1) {
     return m1[1];
   }
 
-  // Fallback in case the download URL appears elsewhere in the source.
   const fallback = html.match(/https:\/\/fuckingfast\.co\/dl\/[A-Za-z0-9_\-]+/i);
   if (fallback) {
     return fallback[0];
@@ -115,6 +142,19 @@ function extractDirectDownload(html) {
   return null;
 }
 
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+function buildRunDirectory(cwd) {
+  const now = new Date();
+  const stamp = `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}_${pad2(now.getHours())}-${pad2(now.getMinutes())}-${pad2(now.getSeconds())}`;
+  const linksRoot = path.resolve(cwd, 'links');
+  const runDir = path.resolve(linksRoot, stamp);
+  fs.mkdirSync(runDir, { recursive: true });
+  return runDir;
+}
+
 async function fetchHtml(url) {
   const res = await fetch(url, {
     headers: {
@@ -131,6 +171,84 @@ async function fetchHtml(url) {
   return await res.text();
 }
 
+async function fetchPrivateBinPayload(pageUrl) {
+  const u = new URL(pageUrl);
+  const apiUrl = `${u.origin}${u.pathname}${u.search}`;
+  const res = await fetch(apiUrl, {
+    headers: {
+      'X-Requested-With': 'JSONHttpRequest',
+      accept: 'application/json, text/javascript, */*; q=0.01',
+    },
+    redirect: 'follow',
+  });
+
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}`);
+  }
+
+  return await res.json();
+}
+
+async function extractLinksFromPrivateBinPage(pageUrl) {
+  const u = new URL(pageUrl);
+  const key = (u.hash || '').replace(/^#/, '');
+
+  if (!key) {
+    return [];
+  }
+
+  const payload = await fetchPrivateBinPayload(pageUrl);
+  if (!payload || typeof payload.ct !== 'string' || !Array.isArray(payload.adata)) {
+    return [];
+  }
+
+  const decrypted = await decryptPrivateBin({
+    key,
+    data: payload.adata,
+    cipherMessage: payload.ct,
+  });
+
+  return extractFuckingfastUrls(decrypted || '');
+}
+
+async function resolveSourceUrls(inputText) {
+  const directUrls = extractFuckingfastUrls(inputText);
+  const allHttpUrls = extractHttpUrls(inputText);
+  const aggregatorUrls = allHttpUrls.filter(isAggregatorPageUrl);
+
+  if (aggregatorUrls.length === 0) {
+    return directUrls;
+  }
+
+  const collected = [...directUrls];
+  const seen = new Set(directUrls);
+
+  console.log(`Found ${aggregatorUrls.length} paste source URL(s); expanding links...`);
+
+  for (const pageUrl of aggregatorUrls) {
+    try {
+      const html = await fetchHtml(pageUrl);
+      let found = extractFuckingfastUrls(html);
+
+      // PrivateBin pages often require client-side decryption; fallback to JSON API decrypt.
+      if (found.length === 0) {
+        found = await extractLinksFromPrivateBinPage(pageUrl);
+      }
+
+      for (const url of found) {
+        if (!seen.has(url)) {
+          seen.add(url);
+          collected.push(url);
+        }
+      }
+    } catch (err) {
+      console.warn(`Could not read paste source: ${pageUrl} (${err.message || String(err)})`);
+    }
+  }
+
+  return collected;
+}
+
 async function main() {
   const { input, outputPrefix, help, version } = parseArgs(process.argv);
 
@@ -149,21 +267,20 @@ async function main() {
 
   if (!fs.existsSync(inputPath)) {
     console.error(`Input file not found: ${inputPath}`);
-    console.error('Create a text file with one fuckingfast page URL per line.');
+    console.error('Create a text file with one fuckingfast page URL per line, raw HTML, or a paste source URL.');
     process.exit(1);
   }
 
   const rawInput = fs.readFileSync(inputPath, 'utf8');
-  let urls = extractSourceUrls(rawInput);
+  let urls = await resolveSourceUrls(rawInput);
 
-  // Fallback for old format: one URL per line (with optional comments).
   if (urls.length === 0) {
     const rawLines = rawInput.split(/\r?\n/);
     urls = rawLines.map(sanitizeLine).filter((line) => line && !line.startsWith('#'));
   }
 
   if (urls.length === 0) {
-    console.error('No URLs found in input file.');
+    console.error('No source URLs found in input file.');
     process.exit(1);
   }
 
@@ -205,9 +322,10 @@ async function main() {
     }
   }
 
-  const txtOut = path.resolve(cwd, `${outputPrefix}.txt`);
-  const htmlOut = path.resolve(cwd, `${outputPrefix}.html`);
-  const jsonOut = path.resolve(cwd, `${outputPrefix}.json`);
+  const runDir = buildRunDirectory(cwd);
+  const txtOut = path.resolve(runDir, `${outputPrefix}.txt`);
+  const htmlOut = path.resolve(runDir, `${outputPrefix}.html`);
+  const jsonOut = path.resolve(runDir, `${outputPrefix}.json`);
 
   fs.writeFileSync(txtOut, txtLines.join('\n') + (txtLines.length ? '\n' : ''), 'utf8');
 
@@ -290,6 +408,7 @@ async function main() {
 
   console.log('');
   console.log(`Done. Success: ${okCount}, Failed: ${failCount}`);
+  console.log(`Run folder: ${runDir}`);
   console.log(`Text links: ${txtOut}`);
   console.log(`Clickable HTML: ${htmlOut}`);
   console.log(`Full report: ${jsonOut}`);

package/bin/ff_extract_links_autorun.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+function readJsonFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${filePath}: ${err.message || String(err)}`);
+  }
+}
+
+function parseArgs(argv) {
+  const args = {
+    config: 'autorun.config.json',
+    input: null,
+    intervalMs: null,
+    startDelayMs: null,
+    maxLinks: null,
+    dryRun: false,
+    help: false,
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === '-h' || arg === '--help') {
+      args.help = true;
+      continue;
+    }
+    if (arg === '--dry-run') {
+      args.dryRun = true;
+      continue;
+    }
+    if ((arg === '-c' || arg === '--config') && argv[i + 1]) {
+      args.config = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if ((arg === '-i' || arg === '--input') && argv[i + 1]) {
+      args.input = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === '--interval-ms' && argv[i + 1]) {
+      args.intervalMs = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg === '--start-delay-ms' && argv[i + 1]) {
+      args.startDelayMs = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg === '--max-links' && argv[i + 1]) {
+      args.maxLinks = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+  }
+
+  return args;
+}
+
+function printHelp() {
+  console.log('ff-link-extract-autorun');
+  console.log('Open links from a text file at configurable intervals.');
+  console.log('');
+  console.log('Usage:');
+  console.log('  ff-link-extract-autorun -c autorun.config.json');
+  console.log('  ff-link-extract-autorun -i all-direct-links.txt --interval-ms 20000');
+  console.log('');
+  console.log('Options:');
+  console.log('  -c, --config <file>      Config file path (default: autorun.config.json)');
+  console.log('  -i, --input <file>       Links file path override');
+  console.log('  --interval-ms <number>   Interval between openings');
+  console.log('  --start-delay-ms <num>   Delay before first open');
+  console.log('  --max-links <number>     Open only first N links');
+  console.log('  --dry-run                Print schedule, do not open browser');
+  console.log('  -h, --help               Show this help');
+}
+
+function normalizeUrl(raw) {
+  return String(raw || '').trim();
+}
+
+function loadLinks(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Links file not found: ${filePath}`);
+  }
+
+  const lines = fs.readFileSync(filePath, 'utf8').split(/\r?\n/);
+  const links = lines
+    .map(normalizeUrl)
+    .filter((line) => line && !line.startsWith('#') && /^https?:\/\//i.test(line));
+
+  return [...new Set(links)];
+}
+
+function findLatestTimestampDir(baseDir) {
+  if (!fs.existsSync(baseDir)) {
+    return null;
+  }
+
+  const dirs = fs.readdirSync(baseDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .sort();
+
+  if (dirs.length === 0) {
+    return null;
+  }
+
+  return path.resolve(baseDir, dirs[dirs.length - 1]);
+}
+
+function resolveLinksFilePath(cwd, inputFile) {
+  const explicitPath = path.resolve(cwd, inputFile);
+  if (fs.existsSync(explicitPath)) {
+    return explicitPath;
+  }
+
+  const latestRunDir = findLatestTimestampDir(path.resolve(cwd, 'links'));
+  if (!latestRunDir) {
+    return explicitPath;
+  }
+
+  const latestPath = path.resolve(latestRunDir, path.basename(inputFile));
+  if (fs.existsSync(latestPath)) {
+    return latestPath;
+  }
+
+  return explicitPath;
+}
+
+function openInBrowser(url) {
+  if (process.platform === 'win32') {
+    // start requires a window title argument before URL.
+    spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+
+  if (process.platform === 'darwin') {
+    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+
+  spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+function asNonNegativeNumber(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) {
+    return fallback;
+  }
+  return n;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const cwd = process.cwd();
+  const configPath = path.resolve(cwd, args.config);
+  const config = readJsonFile(configPath) || {};
+
+  const inputFile = args.input || config.inputFile || 'all-direct-links.txt';
+  const linksPath = resolveLinksFilePath(cwd, inputFile);
+
+  const intervalMs = asNonNegativeNumber(
+    args.intervalMs != null ? args.intervalMs : config.intervalMs,
+    20000
+  );
+  const startDelayMs = asNonNegativeNumber(
+    args.startDelayMs != null ? args.startDelayMs : config.startDelayMs,
+    3000
+  );
+  const maxLinks = asNonNegativeNumber(
+    args.maxLinks != null ? args.maxLinks : config.maxLinks,
+    Number.MAX_SAFE_INTEGER
+  );
+  const dryRun = Boolean(args.dryRun || config.dryRun);
+
+  const links = loadLinks(linksPath).slice(0, maxLinks);
+  if (links.length === 0) {
+    console.error('No valid URLs found in links file.');
+    process.exit(1);
+  }
+
+  console.log(`Loaded ${links.length} link(s) from ${linksPath}`);
+  console.log(`Start delay: ${startDelayMs}ms | Interval: ${intervalMs}ms | Dry run: ${dryRun}`);
+
+  await new Promise((resolve) => setTimeout(resolve, startDelayMs));
+
+  for (let i = 0; i < links.length; i += 1) {
+    const url = links[i];
+    const index = i + 1;
+
+    if (dryRun) {
+      console.log(`[${index}/${links.length}] Would open: ${url}`);
+    } else {
+      console.log(`[${index}/${links.length}] Opening: ${url}`);
+      openInBrowser(url);
+    }
+
+    if (i < links.length - 1) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+
+  console.log('Autorun finished.');
+}
+
+main().catch((err) => {
+  console.error(err.message || String(err));
+  process.exit(1);
+});

package/bin/ff_extract_links_init.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv) {
+  return {
+    force: argv.includes('--force') || argv.includes('-f'),
+    help: argv.includes('--help') || argv.includes('-h'),
+  };
+}
+
+function printHelp() {
+  console.log('ff-link-extract-init');
+  console.log('Copy starter files into the current folder.');
+  console.log('');
+  console.log('Usage:');
+  console.log('  ff-link-extract-init');
+  console.log('  ff-link-extract-init --force');
+  console.log('');
+  console.log('Options:');
+  console.log('  -f, --force  Overwrite existing files');
+  console.log('  -h, --help   Show this help');
+}
+
+function copyTemplate(templatePath, outPath, force) {
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Template not found: ${templatePath}`);
+  }
+
+  if (fs.existsSync(outPath) && !force) {
+    return { status: 'skip', path: outPath };
+  }
+
+  fs.copyFileSync(templatePath, outPath);
+  return { status: fs.existsSync(outPath) ? 'write' : 'skip', path: outPath };
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const packageRoot = path.resolve(__dirname, '..');
+  const templatesDir = path.resolve(packageRoot, 'templates');
+  const cwd = process.cwd();
+
+  const targets = [
+    { from: path.resolve(templatesDir, 'urls.txt'), to: path.resolve(cwd, 'urls.txt') },
+    { from: path.resolve(templatesDir, 'autorun.config.json'), to: path.resolve(cwd, 'autorun.config.json') },
+  ];
+
+  let wrote = 0;
+  let skipped = 0;
+
+  for (const item of targets) {
+    const existedBefore = fs.existsSync(item.to);
+    copyTemplate(item.from, item.to, args.force);
+
+    if (existedBefore && !args.force) {
+      skipped += 1;
+      console.log(`Skipped existing: ${item.to}`);
+    } else {
+      wrote += 1;
+      console.log(`Created: ${item.to}`);
+    }
+  }
+
+  console.log('');
+  console.log(`Done. Created: ${wrote}, Skipped: ${skipped}`);
+  console.log('Next: add your source links to urls.txt, then run ff-link-extract.');
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(err.message || String(err));
+  process.exit(1);
+}

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "@hasindu---7/ff-link-extract",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "Extract direct fuckingfast download links from page URLs",
   "bin": {
-    "ff-link-extract": "ff_extract_links.js"
+    "ff-link-extract": "bin/ff_extract_links.js",
+    "ff-link-extract-autorun": "bin/ff_extract_links_autorun.js",
+    "ff-link-extract-init": "bin/ff_extract_links_init.js"
   },
   "type": "commonjs",
   "files": [
-    "ff_extract_links.js",
+    "bin/ff_extract_links.js",
+    "bin/ff_extract_links_autorun.js",
+    "bin/ff_extract_links_init.js",
+    "templates/autorun.config.json",
+    "templates/urls.txt",
     "README.md",
-    "urls.txt"
+    "package.json"
   ],
   "keywords": [
     "fuckingfast",
@@ -20,5 +26,8 @@
   "license": "MIT",
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "privatebin-decrypt": "^1.0.3"
   }
 }

package/templates/autorun.config.json

@@ -0,0 +1,7 @@
+{
+  "inputFile": "all-direct-links.txt",
+  "intervalMs": 20000,
+  "startDelayMs": 3000,
+  "maxLinks": 999999,
+  "dryRun": false
+}