@hasindu---7/ff-link-extract 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+# ff-link-extract
+
+CLI to extract direct `https://fuckingfast.co/dl/...` links from fuckingfast page URLs.
+
+## Install
+
+```bash
+npm install -g @hasindu---7/ff-link-extract
+```
+
+## Usage
+
+```bash
+ff-link-extract -i urls.txt -o all-direct-links
+```
+
+## Input formats supported
+
+- One URL per line.
+- Raw HTML (for example copied `<a href="...">` blocks).
+- Mixed text that contains fuckingfast URLs.
+
+## Output files
+
+With `-o all-direct-links`, it creates:
+
+- `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
+
+## Options
+
+- `-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
+
+## Local development
+
+Run directly without installing globally:
+
+```bash
+node ff_extract_links.js -i urls.txt -o all-direct-links
+```
+
+Or test as 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`
+
+If the package name is already taken, change `name` in `package.json` first.

package/ff_extract_links.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv) {
+  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;
+    }
+    if (arg === '-v' || arg === '--version') {
+      args.version = true;
+      continue;
+    }
+    if ((arg === '-i' || arg === '--input') && argv[i + 1]) {
+      args.input = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if ((arg === '-o' || arg === '--output-prefix') && argv[i + 1]) {
+      args.outputPrefix = argv[i + 1];
+      i += 1;
+      continue;
+    }
+  }
+
+  return args;
+}
+
+function readPackageVersion() {
+  try {
+    const packagePath = path.resolve(__dirname, 'package.json');
+    if (!fs.existsSync(packagePath)) {
+      return 'dev';
+    }
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    return pkg.version || 'dev';
+  } catch {
+    return 'dev';
+  }
+}
+
+function printHelp() {
+  console.log('ff-link-extract');
+  console.log('Extract direct https://fuckingfast.co/dl/... links from fuckingfast page URLs.');
+  console.log('');
+  console.log('Usage:');
+  console.log('  ff-link-extract -i urls.txt -o all-direct-links');
+  console.log('');
+  console.log('Options:');
+  console.log('  -i, --input <file>          Input file (plain URLs or raw HTML/text). Default: urls.txt');
+  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');
+}
+
+function sanitizeLine(line) {
+  return line.replace(/^\uFEFF/, '').trim();
+}
+
+function normalizeExtractedUrl(raw) {
+  return raw
+    .replace(/&amp;/gi, '&')
+    .replace(/["'<>]+$/g, '')
+    .trim();
+}
+
+function extractSourceUrls(inputText) {
+  const allMatches = inputText.match(/https?:\/\/fuckingfast\.co\/[^\s"'<>]+/gi) || [];
+  const cleaned = allMatches.map(normalizeExtractedUrl).filter(Boolean);
+
+  // Preserve order while removing duplicates.
+  return [...new Set(cleaned)];
+}
+
+function escapeHtml(str) {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function extractFilenameFromUrl(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    if (u.hash && u.hash.length > 1) {
+      return decodeURIComponent(u.hash.slice(1));
+    }
+    return u.pathname.split('/').filter(Boolean).pop() || rawUrl;
+  } catch {
+    return 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];
+  }
+
+  return null;
+}
+
+async function fetchHtml(url) {
+  const res = await fetch(url, {
+    headers: {
+      'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
+      accept: 'text/html,application/xhtml+xml',
+    },
+    redirect: 'follow',
+  });
+
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}`);
+  }
+
+  return await res.text();
+}
+
+async function main() {
+  const { input, outputPrefix, help, version } = parseArgs(process.argv);
+
+  if (help) {
+    printHelp();
+    return;
+  }
+
+  if (version) {
+    console.log(readPackageVersion());
+    return;
+  }
+
+  const cwd = process.cwd();
+  const inputPath = path.resolve(cwd, input);
+
+  if (!fs.existsSync(inputPath)) {
+    console.error(`Input file not found: ${inputPath}`);
+    console.error('Create a text file with one fuckingfast page URL per line.');
+    process.exit(1);
+  }
+
+  const rawInput = fs.readFileSync(inputPath, 'utf8');
+  let urls = extractSourceUrls(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.');
+    process.exit(1);
+  }
+
+  console.log(`Found ${urls.length} source URL(s) in ${path.basename(inputPath)}.`);
+  console.log(`Processing ${urls.length} URL(s)...`);
+
+  const results = [];
+
+  for (let i = 0; i < urls.length; i += 1) {
+    const sourceUrl = urls[i];
+    const name = extractFilenameFromUrl(sourceUrl);
+    process.stdout.write(`[${i + 1}/${urls.length}] ${name} ... `);
+
+    try {
+      const html = await fetchHtml(sourceUrl);
+      const direct = extractDirectDownload(html);
+
+      if (!direct) {
+        results.push({ sourceUrl, name, direct: null, error: 'Download URL not found in HTML' });
+        console.log('NOT FOUND');
+        continue;
+      }
+
+      results.push({ sourceUrl, name, direct, error: null });
+      console.log('OK');
+    } catch (err) {
+      results.push({ sourceUrl, name, direct: null, error: err.message || String(err) });
+      console.log(`ERROR (${err.message || String(err)})`);
+    }
+  }
+
+  const txtLines = [];
+  const htmlRows = [];
+
+  for (const row of results) {
+    if (row.direct) {
+      txtLines.push(row.direct);
+      htmlRows.push(`<li><a href="${escapeHtml(row.direct)}" target="_blank" rel="noopener noreferrer">${escapeHtml(row.name)}</a></li>`);
+    }
+  }
+
+  const txtOut = path.resolve(cwd, `${outputPrefix}.txt`);
+  const htmlOut = path.resolve(cwd, `${outputPrefix}.html`);
+  const jsonOut = path.resolve(cwd, `${outputPrefix}.json`);
+
+  fs.writeFileSync(txtOut, txtLines.join('\n') + (txtLines.length ? '\n' : ''), 'utf8');
+
+  const htmlDoc = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>FuckingFast Direct Links</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --bg: #f5f7fb;
+      --card: #ffffff;
+      --text: #111827;
+      --muted: #6b7280;
+      --accent: #0f766e;
+    }
+    body {
+      margin: 0;
+      font: 16px/1.5 Segoe UI, Arial, sans-serif;
+      color: var(--text);
+      background: radial-gradient(circle at top right, #dbeafe, transparent 40%), var(--bg);
+    }
+    .wrap {
+      max-width: 900px;
+      margin: 2rem auto;
+      padding: 1rem;
+    }
+    .card {
+      background: var(--card);
+      border-radius: 14px;
+      box-shadow: 0 10px 24px rgba(15, 23, 42, 0.08);
+      padding: 1.25rem;
+    }
+    h1 {
+      margin: 0 0 0.5rem;
+      font-size: 1.25rem;
+    }
+    p {
+      color: var(--muted);
+      margin-top: 0;
+    }
+    ul {
+      margin: 0;
+      padding-left: 1.2rem;
+    }
+    li {
+      margin: 0.45rem 0;
+      word-break: break-all;
+    }
+    a {
+      color: var(--accent);
+      text-decoration: none;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+  </style>
+</head>
+<body>
+  <main class="wrap">
+    <section class="card">
+      <h1>Extracted Direct Links (${txtLines.length}/${results.length})</h1>
+      <p>Open links in a new tab. Failed extractions are listed in the JSON report.</p>
+      <ul>
+        ${htmlRows.join('\n        ')}
+      </ul>
+    </section>
+  </main>
+</body>
+</html>
+`;
+
+  fs.writeFileSync(htmlOut, htmlDoc, 'utf8');
+  fs.writeFileSync(jsonOut, JSON.stringify(results, null, 2) + '\n', 'utf8');
+
+  const okCount = results.filter((r) => r.direct).length;
+  const failCount = results.length - okCount;
+
+  console.log('');
+  console.log(`Done. Success: ${okCount}, Failed: ${failCount}`);
+  console.log(`Text links: ${txtOut}`);
+  console.log(`Clickable HTML: ${htmlOut}`);
+  console.log(`Full report: ${jsonOut}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@hasindu---7/ff-link-extract",
+  "version": "1.0.0",
+  "description": "Extract direct fuckingfast download links from page URLs",
+  "bin": {
+    "ff-link-extract": "ff_extract_links.js"
+  },
+  "type": "commonjs",
+  "files": [
+    "ff_extract_links.js",
+    "README.md"
+  ],
+  "keywords": [
+    "fuckingfast",
+    "link-extractor",
+    "cli",
+    "download"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}