mpkgit 0.1.0__tar.gz

mpkgit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mpkg contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mpkgit-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mpkgit
+Version: 0.1.0
+License: MIT
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: rich>=13
+Requires-Dist: InquirerPy>=0.3
+Requires-Dist: pycryptodome>=3.19
+Requires-Dist: pyfiglet>=0.8
+Requires-Dist: tqdm>=4.66
+Dynamic: license-file

mpkgit-0.1.0/mpkg/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

mpkgit-0.1.0/mpkg/assets/byfms_pow_solver.js

@@ -0,0 +1,148 @@
+
+
+const https = require('https');
+
+function api(url, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const body = opts.body || null;
+    const options = {
+      hostname: u.hostname,
+      port: 443,
+      path: u.pathname + u.search,
+      method: opts.method || 'GET',
+      headers: Object.assign({
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
+        'Accept': 'application/json, */*',
+        'Content-Type': 'application/json',
+      }, opts.headers || {}),
+    };
+    if (body) options.headers['Content-Length'] = Buffer.byteLength(body);
+    const req = https.request(options, res => {
+      let d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(d), raw: d }); }
+        catch { resolve({ status: res.statusCode, body: null, raw: d }); }
+      });
+    });
+    req.on('error', reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+const be = 512, lt = be - 1, dr = 2, lr = 2654435761, hr = 2246822519;
+
+function re(t, e) { t >>>= 0; return ((t << e) | (t >>> (32 - e))) >>> 0; }
+function ht(t, e) { return Math.imul(t, e) >>> 0; }
+function ye(t) {
+  t[0] = (t[0] + t[1]) >>> 0; t[3] = re(t[3] ^ t[0], 16);
+  t[2] = (t[2] + t[3]) >>> 0; t[1] = re(t[1] ^ t[2], 12);
+  t[0] = (t[0] + t[1]) >>> 0; t[3] = re(t[3] ^ t[0], 8);
+  t[2] = (t[2] + t[3]) >>> 0; t[1] = re(t[1] ^ t[2], 7);
+}
+function yr(t) {
+  const e = new Uint8Array(t.length);
+  for (let r = 0; r < t.length; r++) e[r] = t.charCodeAt(r) & 255;
+  return e;
+}
+function gr(t) {
+  const e = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762]);
+  for (let i = 0; i < t.length; i++) { e[0] = (e[0] + t[i]) >>> 0; e[0] = re(e[0], 7); ye(e); }
+  for (let i = 0; i < 8; i++) ye(e);
+  const r = new Uint32Array(be);
+  for (let i = 0; i < be; i++) { ye(e); r[i] = (e[0] ^ e[2]) >>> 0; }
+  for (let i = 0; i < dr; i++)
+    for (let s = 0; s < be; s++) {
+      const a = r[s] & lt;
+      let c = (r[s] + r[a]) >>> 0;
+      c = re(c, 13);
+      c = (c ^ ht(r[(s + 1) & lt], lr)) >>> 0;
+      r[s] = c; e[0] = (e[0] ^ c) >>> 0; ye(e);
+    }
+  const n = new Uint32Array(8), o = be / 8;
+  for (let i = 0; i < 8; i++) {
+    ye(e); let s = e[0]; const a = i * o;
+    for (let c = 0; c < o; c++) {
+      const d = r[a + c];
+      s = (s + d) >>> 0; s = re(s, 5); s = (s ^ ht(d, hr)) >>> 0;
+    }
+    n[i] = (s ^ e[2]) >>> 0;
+  }
+  return n;
+}
+function wr(t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const n = t[r];
+    if (n === 0) { e += 32; continue; }
+    return e + Math.clz32(n);
+  }
+  return e;
+}
+async function Er(t, e, r = 120000) {
+  if (e <= 0) return '0';
+  const o = t + ':';
+  const i = Date.now();
+  let s = 0;
+  const a = 4096;
+  for (;;) {
+    for (let c = 0; c < a; c++) {
+      const d = gr(yr(o + s));
+      if (wr(d) >= e) return String(s);
+      s++;
+    }
+    if (Date.now() - i > r) return null;
+    await new Promise(res => setImmediate(res));
+  }
+}
+
+async function main() {
+  const [base, vid, origin] = process.argv.slice(2);
+  if (!base || !vid || !origin) {
+    console.log(JSON.stringify({ error: 'usage: node byfms_pow_solver.js <base_url> <video_id> <embed_origin>' }));
+    process.exit(1);
+  }
+
+  const ch = await api(`${base}/api/videos/${vid}/embed/captcha`, { method: 'POST', body: '{}' });
+  if (!ch.body || !ch.body.pow_nonce) {
+    console.log(JSON.stringify({ error: 'captcha_failed', raw: (ch.raw || '').slice(0, 200) }));
+    return;
+  }
+  const { pow_nonce: nonce, pow_difficulty: difficulty, pow_token } = ch.body;
+
+  const solution = await Er(nonce, difficulty);
+  if (!solution) { console.log(JSON.stringify({ error: 'pow_timeout' })); return; }
+
+  const verif = await api(`${base}/api/videos/${vid}/embed/captcha/verify`, {
+    method: 'POST',
+    body: JSON.stringify({ pow_token, solution }),
+  });
+  const access_token = verif.body && verif.body.status === 'ok' ? verif.body.token : null;
+  if (!access_token) {
+    console.log(JSON.stringify({ error: 'verify_failed', raw: (verif.raw || '').slice(0, 200) }));
+    return;
+  }
+
+  const playRes = await api(`${base}/api/videos/${vid}/embed/playback`, {
+    method: 'POST',
+    headers: {
+      'X-Captcha-Token': access_token,
+      'X-Embed-Origin': origin,
+      'X-Embed-Referer': origin + '/',
+      'X-Embed-Parent': origin + '/',
+    },
+    body: JSON.stringify({ fingerprint: {} }),
+  });
+  if (playRes.status !== 200 || !playRes.body) {
+    console.log(JSON.stringify({ error: 'playback_failed', status: playRes.status, raw: (playRes.raw || '').slice(0, 300) }));
+    return;
+  }
+  console.log(JSON.stringify(playRes.body));
+}
+
+main().catch(e => {
+  console.log(JSON.stringify({ error: e.message }));
+  process.exit(1);
+});

mpkgit-0.1.0/mpkg/banner.py

@@ -0,0 +1,14 @@
+import pyfiglet
+
+
+def b1() -> None:
+    try:
+        banner = pyfiglet.figlet_format("Mpkg", font="slant")
+    except Exception:
+        banner = "Mpkg\n"
+    print(banner)
+    print("  type Mpkg -h for help\n")
+
+
+def b2() -> None:
+    print("\n[done] Grab complete. 🎬")

mpkgit-0.1.0/mpkg/catalog.py

@@ -0,0 +1,121 @@
+import json
+import os
+import re
+
+from .hosts import h1, HostError
+
+CATALOG_PATH = os.path.expanduser("~/.mpkg_catalog.json")
+
+SEED = [
+    {"title": "Eddington (2025)", "host": "filemoon",
+     "url": "https://filemoon.to/e/ro2jnqsg89j0/2025_Eddington.mp4"},
+    {"title": "InkaSex - Patty Cherry New Year 2026", "host": "streamtape",
+     "url": "https://streamtape.com/v/p2bJ3gYOvZiXBG/x.mp4"},
+]
+
+HOST_LABEL = {
+    "filemoon": "Filemoon", "streamtape": "StreamTape", "voe": "VOE",
+    "vidmoly": "VidMoly", "mixdrop": "MixDrop", "vidcloud": "VidCloud",
+}
+
+
+def k1() -> list:
+    if not os.path.exists(CATALOG_PATH):
+        return []
+    try:
+        with open(CATALOG_PATH) as f:
+            data = json.load(f)
+        return [e for e in data if isinstance(e, dict) and e.get("url")]
+    except Exception:
+        return []
+
+
+def k2(entries: list) -> None:
+    with open(CATALOG_PATH, "w") as f:
+        json.dump(entries, f, indent=2)
+
+
+def k3() -> list:
+    seen, out = set(), []
+    for e in SEED + k1():
+        if e["url"] in seen:
+            continue
+        seen.add(e["url"])
+        out.append(e)
+    return out
+
+
+def k4(url: str, title: str = None, host: str = None) -> dict:
+    if host is None:
+        host = h1(url)
+    if title is None:
+        title = k7(url) or url
+    entries = k1()
+    for e in entries:
+        if e["url"] == url:
+            if title:
+                e["title"] = title
+            k2(entries)
+            return e
+    entry = {"title": title, "host": host, "url": url}
+    entries.append(entry)
+    k2(entries)
+    return entry
+
+
+def k5(text: str) -> int:
+    count = 0
+    for url in re.findall(r"https?://\S+", text):
+        url = url.rstrip(".,;)")
+        try:
+            k4(url)
+            count += 1
+        except HostError:
+            pass
+    return count
+
+
+def k6(url: str) -> bool:
+    entries = k1()
+    before = len(entries)
+    entries = [e for e in entries if e["url"] != url]
+    k2(entries)
+    return len(entries) != before
+
+
+def k7(url: str) -> str:
+    path = url.split("/", 3)[-1]
+    name = path.rsplit("/", 1)[-1]
+    name = re.sub(r"\.(mp4|mkv|webm|html?)$", "", name, flags=re.I)
+    name = re.sub(r"[\-_]+", " ", name).strip().title()
+    return name or None
+
+
+def k8(query: str, index: list = None, limit: int = 20) -> list:
+    if index is None:
+        index = k3()
+    q = query.lower().strip()
+    q_words = set(q.split())
+
+    def score(e):
+        t = e["title"].lower()
+        if t.startswith(q):
+            return 3
+        if all(w in t for w in q_words):
+            return 2
+        if any(w in t for w in q_words):
+            return 1
+        return 0
+
+    results = [(score(e), e) for e in index if score(e) > 0]
+    results.sort(key=lambda x: (-x[0], x[1]["title"]))
+    return [e for _, e in results[:limit]]
+
+
+def k9(index: list = None) -> dict:
+    if index is None:
+        index = k3()
+    out = {}
+    for e in index:
+        out.setdefault(HOST_LABEL.get(e["host"], e["host"]), []).append(e)
+    return out

mpkgit-0.1.0/mpkg/cli.py

@@ -0,0 +1,231 @@
+import argparse
+import os
+import random
+import re
+import shutil
+import sys
+import time
+
+from rich.console import Console
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+
+from mpkg import __version__
+from mpkg.banner import b1, b2
+from mpkg.config import c1, c2, c3, CONFIG_PATH
+from mpkg.catalog import k3, k4, k5, k8, k9, HOST_LABEL
+from mpkg.hosts import h2, HostError
+from mpkg.grab import g10, DEFAULT_THREADS, g2
+
+console = Console()
+
+
+def l1(s: str) -> str:
+    s = re.sub(r'\.(mp4|mkv|webm|avi|m4v)$', '', s, flags=re.I)
+    return re.sub(r'[^\w\-. ]', '_', s).strip() or "video"
+
+
+def l2() -> None:
+    missing = []
+    if not shutil.which("ffmpeg"):
+        missing.append("ffmpeg   -> apt install ffmpeg / pkg install ffmpeg")
+    if not shutil.which("node"):
+        missing.append("node     -> needed for Filemoon PoW; apt install nodejs")
+    if missing:
+        console.print("[bold red]Missing required tools:[/bold red]")
+        for m in missing:
+            console.print(f"  [red]{m}[/red]")
+        sys.exit(1)
+
+
+def l3(catalog: list) -> None:
+    grouped = k9(catalog)
+    for host_label in sorted(grouped):
+        console.print(f"[bold cyan]{host_label}[/bold cyan]")
+        for e in grouped[host_label]:
+            console.print(f"   {e['title']}  [dim]{e['url'][:70]}[/dim]")
+        console.print()
+
+
+def l4(url: str, title: str, dl_dir: str, threads: int, quality: str,
+       limit_minutes: int, retries: int = 1) -> bool:
+    out_path = os.path.join(dl_dir, l1(title) + ".mp4")
+    if os.path.exists(g2(out_path)):
+        console.print(f"  [dim]Already done, skipping: {title}[/dim]")
+        return True
+
+    console.print(f"  [dim]Resolving {title} ({url[:70]}…)[/dim]")
+    for attempt in range(retries + 1):
+        try:
+            item = h2(url)
+        except HostError as e:
+            console.print(f"  [yellow]resolve error: {e}[/yellow]")
+            break
+        except Exception as e:
+            console.print(f"  [yellow]resolve error: {e}[/yellow]")
+            break
+        console.print(f"  Media: {item['url'][:100]}")
+        ok = g10(item, out_path, threads=threads, quality=quality, limit_minutes=limit_minutes)
+        if ok:
+            return True
+        if attempt < retries:
+            console.print(f"  [dim]Retrying ({attempt + 1}/{retries})…[/dim]")
+            time.sleep(2)
+    return False
+
+
+def main() -> None:
+    b1()
+    l2()
+    cfg = c1()
+
+    parser = argparse.ArgumentParser(
+        prog="Mpkg",
+        description="Mpkg",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument("-s", "--search", type=str, help="search")
+    parser.add_argument("-q", "--quality", type=str, default=None, help="quality")
+    parser.add_argument("-t", "--threads", type=int, default=None, help="threads")
+    parser.add_argument("-d", "--download-dir", type=str, default=None, help="dir")
+    parser.add_argument("--limit-minutes", type=int, default=0, help="preview")
+    parser.add_argument("--config", action="store_true", help="config")
+    parser.add_argument("--set-quality", type=str, metavar="Q", help="set quality")
+    parser.add_argument("--set-threads", type=int, metavar="N", help="set threads")
+    parser.add_argument("--set-download-dir", type=str, metavar="PATH", help="set dir")
+    parser.add_argument("--reset-config", action="store_true", help="reset config")
+    parser.add_argument("--version", action="store_true", help="version")
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_add = sub.add_parser("add", help="add url [title]")
+    p_add.add_argument("url")
+    p_add.add_argument("title", nargs="*")
+
+    p_import = sub.add_parser("import", help="import file")
+    p_import.add_argument("path")
+
+    p_list = sub.add_parser("list", help="list")
+
+    p_diag = sub.add_parser("diag", help="diag url")
+    p_diag.add_argument("url")
+
+    p_grab = sub.add_parser("grab", help="grab url")
+    p_grab.add_argument("url")
+    p_grab.add_argument("-q", "--quality", type=str, default=None, help="quality")
+    p_grab.add_argument("-t", "--threads", type=int, default=None, help="threads")
+    p_grab.add_argument("-d", "--download-dir", type=str, default=None, help="dir")
+    p_grab.add_argument("--limit-minutes", type=int, default=None, help="preview")
+
+    args = parser.parse_args()
+
+    if args.version:
+        print(f"Mpkg {__version__}")
+        sys.exit(0)
+
+    if args.config:
+        console.print(f"[bold cyan]Config[/bold cyan] ({CONFIG_PATH})")
+        for k, v in cfg.items():
+            console.print(f"  {k}: [green]{v}[/green]")
+        sys.exit(0)
+
+    if args.reset_config:
+        c3()
+        console.print("✓ Config reset to defaults.")
+        sys.exit(0)
+
+    changed = False
+    if args.set_quality:
+        cfg["quality"], changed = args.set_quality, True
+    if args.set_threads:
+        cfg["threads"], changed = args.set_threads, True
+    if args.set_download_dir:
+        cfg["download_dir"], changed = os.path.normpath(args.set_download_dir), True
+    if changed:
+        c2(cfg)
+        console.print(f"✓ Config saved to {CONFIG_PATH}")
+        sys.exit(0)
+
+    quality = args.quality or cfg["quality"]
+    threads = args.threads or cfg.get("threads", DEFAULT_THREADS)
+    dl_dir = os.path.normpath(args.download_dir or cfg["download_dir"])
+    os.makedirs(dl_dir, exist_ok=True)
+
+    if args.cmd == "add":
+        try:
+            entry = k4(args.url, title=" ".join(args.title) or None)
+            console.print(f"✓ Added: {entry['title']} ({HOST_LABEL.get(entry['host'], entry['host'])})")
+        except HostError as e:
+            console.print(f"[red]{e}[/red]")
+        sys.exit(0)
+
+    if args.cmd == "import":
+        if not os.path.exists(args.path):
+            console.print(f"[red]File not found: {args.path}[/red]")
+            sys.exit(1)
+        n = k5(open(args.path).read())
+        console.print(f"✓ Imported {n} URL(s)")
+        sys.exit(0)
+
+    if args.cmd == "diag":
+        console.print(f"Resolving {args.url}")
+        try:
+            item = h2(args.url)
+            console.print(f"[green]{item['kind']}[/green]  {item['url']}")
+        except HostError as e:
+            console.print(f"[red]{e}[/red]")
+            sys.exit(1)
+        sys.exit(0)
+
+    if args.cmd == "grab":
+        title = args.url.rsplit("/", 1)[-1][:60] or "video"
+        g_quality = getattr(args, "quality", None) or quality
+        g_threads = getattr(args, "threads", None) or threads
+        g_limit = getattr(args, "limit_minutes", None) or args.limit_minutes
+        g_dir = os.path.normpath(getattr(args, "download_dir", None) or dl_dir)
+        ok = l4(args.url, title, g_dir, g_threads, g_quality, g_limit)
+        sys.exit(0 if ok else 1)
+
+    if args.cmd == "list":
+        catalog = k3()
+        console.print(f"[bold]Catalog[/bold] — {len(catalog)} titles\n")
+        l3(catalog)
+        sys.exit(0)
+
+    catalog = k3()
+    if not catalog:
+        console.print("[yellow]Empty catalog — add URLs first:\n  Mpkg add <embed-url> \"Title\"[/yellow]")
+        sys.exit(0)
+
+    if args.search:
+        results = k8(args.search, catalog)
+        if not results:
+            console.print(f"[bold yellow]No matches for '{args.search}'[/bold yellow]")
+            sys.exit(0)
+    else:
+        results = catalog
+
+    choices = [
+        Choice(value=e, name=f"[{HOST_LABEL.get(e['host'], e['host'])}] {e['title']}")
+        for e in results
+    ]
+    selected = inquirer.fuzzy(
+        message="Pick a title:",
+        choices=choices,
+        instruction="(type to filter, Enter to select)",
+    ).execute()
+    if not selected:
+        sys.exit(0)
+
+    console.print(f"\n[bold cyan]Title: {selected['title']}[/bold cyan]")
+    console.print(f"  Lang/quality: {quality} | Threads: {threads} | Saving to: {dl_dir}")
+
+    ok = l4(selected["url"], selected["title"], dl_dir, threads, quality, args.limit_minutes)
+    if ok:
+        b2()
+    else:
+        console.print("[red]Grab failed — check the host / URL, or run Mpkg diag <url>[/red]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mpkgit-0.1.0/mpkg/config.py

@@ -0,0 +1,36 @@
+import json
+import os
+
+CONFIG_PATH = os.path.expanduser("~/.mpkg_config.json")
+
+DEFAULT_CONFIG = {
+    "quality": "best",
+    "threads": 12,
+    "download_dir": os.path.join(os.path.expanduser("~"), "Movies"),
+}
+
+
+def c1() -> dict:
+    if not os.path.exists(CONFIG_PATH):
+        return DEFAULT_CONFIG.copy()
+    try:
+        with open(CONFIG_PATH) as f:
+            user = json.load(f)
+        cfg = DEFAULT_CONFIG.copy()
+        cfg.update({k: v for k, v in user.items() if k in DEFAULT_CONFIG})
+        return cfg
+    except Exception:
+        return DEFAULT_CONFIG.copy()
+
+
+def c2(cfg: dict) -> None:
+    try:
+        with open(CONFIG_PATH, "w") as f:
+            json.dump(cfg, f, indent=2)
+    except Exception:
+        pass
+
+
+def c3() -> None:
+    if os.path.exists(CONFIG_PATH):
+        os.remove(CONFIG_PATH)