polytool 0.2.4__tar.gz → 0.2.6__tar.gz

{polytool-0.2.4 → polytool-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polytool
-Version: 0.2.4
+Version: 0.2.6
 Summary: One-binary CLI bundling 26 everyday utilities — image/video/PDF conversion, background removal, OCR, QR codes, hashing, downloads, and more
 Project-URL: Homepage, https://github.com/k6w/polytool
 Project-URL: Repository, https://github.com/k6w/polytool

{polytool-0.2.4 → polytool-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polytool"
-version = "0.2.4"
+version = "0.2.6"
 description = "One-binary CLI bundling 26 everyday utilities — image/video/PDF conversion, background removal, OCR, QR codes, hashing, downloads, and more"
 readme = "README.md"
 requires-python = ">=3.13"

{polytool-0.2.4 → polytool-0.2.6}/src/polytool/__init__.py

@@ -1,4 +1,4 @@
 """polytool — one-binary CLI bundling 26 everyday utilities."""
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"
 __all__ = ["__version__"]

polytool-0.2.6/src/polytool/cli/__init__.py

@@ -0,0 +1,211 @@
+"""Root Typer app — subcommand groups are added by their own modules.
+
+Subcommand modules must keep top-level imports light (typer/rich/stdlib only).
+Heavy imports (Pillow, ffmpeg, rembg) happen inside command bodies via
+`polytool.core.lazy.require_extra`.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from typing import Annotated
+
+import typer
+
+from polytool import __version__
+from polytool.cli import (
+    clip,
+    color,
+    convert,
+    cron,
+    data,
+    dl,
+    enc,
+    file,
+    gen,
+    img,
+    net,
+    pdf,
+    qr,
+    shot,
+    text,
+    vid,
+)
+from polytool.core import runtime
+from polytool.core.console import console, err_console
+from polytool.core.errors import PolytoolError, render_panel
+
+app = typer.Typer(
+    name="polytool",
+    help="polytool — one-binary CLI bundling 26 everyday utilities (pt for short).",
+    no_args_is_help=True,
+    add_completion=False,
+    rich_markup_mode="rich",
+    # We handle PolytoolError ourselves via the `main()` wrapper below; disable
+    # Typer's pretty-traceback so it doesn't squash our hints.
+    pretty_exceptions_enable=False,
+)
+
+
+def run() -> None:
+    """Console-script entry point — runs the Typer app and renders PolytoolError nicely.
+
+    (Defined with a unique name to avoid clashing with the ``@app.callback()``
+    function below — both would otherwise be named ``main`` in this module.)
+    """
+    try:
+        app()
+    except PolytoolError as exc:
+        render_panel(exc.message, exc.hint)
+        sys.exit(1)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"polytool {__version__}")
+        raise typer.Exit
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    """polytool — one-binary CLI bundling 26 everyday utilities."""
+
+
+@app.command("setup")
+def cmd_setup(
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip prompts; install everything."),
+    ] = False,
+    skip_runtime: Annotated[
+        bool,
+        typer.Option("--skip-runtime", help="Don't fetch Deno (used by `pt dl get`)."),
+    ] = False,
+    skip_chromium: Annotated[
+        bool,
+        typer.Option(
+            "--skip-chromium", help="Don't fetch Playwright Chromium (used by `pt shot web`)."
+        ),
+    ] = False,
+) -> None:
+    """One-shot post-install: fetch every binary the [full] extra needs.
+
+    Most polytool features work the moment you `uv tool install 'polytool[full]'`.
+    A handful need extra one-time downloads that aren't pip packages:
+
+    - **Deno (~50 MB)** — solves YouTube's n-challenge for `pt dl get`.
+    - **Playwright Chromium (~150 MB)** — used by `pt shot web`.
+
+    `pt setup` fetches both. Run it once and you're done; you can also run
+    each install separately via `pt dl runtime install` and `pt shot install`.
+
+    Examples:
+
+        pt setup                # interactive; default-yes to each step
+        pt setup -y             # silent; install everything
+        pt setup --skip-chromium  # everything except Chromium
+    """
+    steps: list[tuple[str, str, callable]] = []  # type: ignore[type-arg]
+
+    if not skip_runtime:
+        steps.append(
+            (
+                "JS runtime (Deno)",
+                "for `pt dl get` to solve YouTube's n-challenge",
+                _install_runtime_step,
+            )
+        )
+    if not skip_chromium:
+        steps.append(
+            (
+                "Playwright Chromium",
+                "for `pt shot web`",
+                _install_chromium_step,
+            )
+        )
+
+    if not steps:
+        console.print("[dim]Nothing to do — both --skip-* flags set.[/dim]")
+        return
+
+    console.print("[bold]polytool setup[/bold]\n")
+    console.print("This will fetch one-time downloads needed by certain commands:\n")
+    for name, why, _ in steps:
+        console.print(f"  • [cyan]{name}[/cyan] — {why}")
+    console.print()
+
+    if not yes and not typer.confirm("Continue?", default=True):
+        console.print("[dim]Cancelled.[/dim]")
+        return
+
+    failures: list[str] = []
+    for name, _why, step in steps:
+        console.print(f"[bold]→ {name}[/bold]")
+        try:
+            step()
+        except Exception as exc:
+            failures.append(f"{name}: {exc}")
+            err_console.print(f"[red]failed:[/red] {exc}")
+        console.print()
+
+    if failures:
+        msg = "Some steps failed:\n  " + "\n  ".join(failures)
+        raise PolytoolError(msg)
+    console.print("[green]All set.[/green] You can now use every polytool command.")
+
+
+def _install_runtime_step() -> None:
+    sys_runtime = runtime.system_runtime_path()
+    if sys_runtime:
+        console.print(f"[green]system runtime already on PATH:[/green] {sys_runtime}")
+        return
+    if runtime.is_managed_deno_installed():
+        console.print(f"[green]already installed:[/green] {runtime.deno_binary_path()}")
+        return
+    binary = runtime.install_deno()
+    runtime.ensure_runtime_in_path()
+    console.print(f"[green]installed:[/green] {binary}")
+
+
+def _install_chromium_step() -> None:
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "playwright", "install", "chromium"],
+            check=True,
+        )
+    except FileNotFoundError as exc:
+        raise RuntimeError(
+            "Playwright Python package missing. Install with: uv tool install 'polytool[shot]'"
+        ) from exc
+    console.print("[green]Chromium installed.[/green]")
+
+
+app.add_typer(enc.app, name="enc")
+app.add_typer(gen.app, name="gen")
+app.add_typer(color.app, name="color")
+app.add_typer(convert.app, name="convert")
+app.add_typer(text.app, name="text")
+app.add_typer(data.app, name="data")
+app.add_typer(qr.app, name="qr")
+app.add_typer(clip.app, name="clip")
+app.add_typer(cron.app, name="cron")
+app.add_typer(net.app, name="net")
+app.add_typer(file.app, name="file")
+app.add_typer(img.app, name="img")
+app.add_typer(pdf.app, name="pdf")
+app.add_typer(vid.app, name="vid")
+app.add_typer(dl.app, name="dl")
+app.add_typer(shot.app, name="shot")
+
+
+__all__ = ["app"]

{polytool-0.2.4 → polytool-0.2.6}/src/polytool/cli/dl.py

@@ -2,12 +2,22 @@
 
 from __future__ import annotations
 
+import re
 from pathlib import Path
 from typing import Annotated
 
 import typer
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
 
-from polytool.core import config
+from polytool.core import config, runtime
 from polytool.core.browsers import (
     ALL_BROWSERS,
     FIREFOX_FORK_DIRS,
@@ -39,6 +49,193 @@ BOT_CHECK_HINTS = (
     "rate limit",
 )
 
+# Patterns that indicate YouTube's n-challenge / JS-runtime gap.
+N_CHALLENGE_PATTERNS = (
+    "n challenge",
+    "only images are available",
+    "requested format is not available",
+)
+
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+_NOISE_RE = re.compile(
+    r"^(?:Extracting URL|Downloading\s\S+|Extracting cookies|Extracted\s|"
+    r"\[\w+\]\s|Sleeping|Skipping|Deleting original file)"
+)
+
+
+def _strip(msg: object) -> str:
+    text = _ANSI_RE.sub("", str(msg)).strip()
+    for prefix in ("WARNING:", "ERROR:", "[generic]", "[youtube]"):
+        if text.startswith(prefix):
+            text = text[len(prefix) :].strip()
+    return text
+
+
+class _DlLogger:
+    """Capture yt-dlp warnings/errors so we can filter noise and surface hints."""
+
+    def __init__(self) -> None:
+        self.warnings: list[str] = []
+        self.errors: list[str] = []
+
+    def debug(self, msg: object) -> None:
+        pass
+
+    def info(self, msg: object) -> None:
+        pass
+
+    def warning(self, msg: object) -> None:
+        clean = _strip(msg)
+        if not clean:
+            return
+        self.warnings.append(clean)
+        if not _NOISE_RE.match(clean):
+            err_console.print(f"[yellow]warning:[/yellow] {clean}")
+
+    def error(self, msg: object) -> None:
+        clean = _strip(msg)
+        if clean:
+            self.errors.append(clean)
+
+
+def _make_progress() -> Progress:
+    """Rich progress bar tuned for downloads (title · bar · % · size · speed · ETA)."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold cyan]{task.description}"),
+        BarColumn(bar_width=None),
+        TextColumn("[progress.percentage]{task.percentage:>5.1f}%"),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+        console=err_console,
+        transient=False,
+    )
+
+
+def _make_progress_hook(progress: Progress, state: dict):
+    """Build a yt-dlp progress hook that drives the Rich progress bar."""
+
+    def hook(d: dict) -> None:
+        status = d.get("status")
+        if status == "downloading":
+            total = d.get("total_bytes") or d.get("total_bytes_estimate")
+            downloaded = d.get("downloaded_bytes", 0)
+            info = d.get("info_dict") or {}
+            title = info.get("title") or Path(d.get("filename", "download")).name
+            disp = title if len(title) <= 50 else title[:47] + "..."
+            tid = state.get("task_id")
+            if tid is None:
+                state["task_id"] = progress.add_task(disp, total=total)
+            else:
+                progress.update(tid, completed=downloaded, total=total, description=disp)
+        elif status == "finished":
+            tid = state.pop("task_id", None)
+            if tid is not None and progress.tasks[tid].total:
+                progress.update(tid, completed=progress.tasks[tid].total)
+
+    return hook
+
+
+def _n_challenge_hint(messages: list[str]) -> str | None:
+    text = " ".join(messages).lower()
+    if not any(p in text for p in N_CHALLENGE_PATTERNS):
+        return None
+    return (
+        "YouTube needs a JavaScript runtime to solve its n-challenge.\n\n"
+        "Polytool can manage one for you (no system install needed):\n"
+        "  [cyan]pt dl runtime install[/cyan]    "
+        "[dim]# downloads Deno (~50 MB) into ~/.polytool/runtime/[/dim]\n\n"
+        "Then re-run [cyan]pt dl get[/cyan]. The runtime is auto-detected on every call."
+    )
+
+
+def _hint_for_error(message: str, logger: _DlLogger) -> str | None:
+    """Pick the best hint for a failure: bot-check first, then n-challenge."""
+    pool = [message, *logger.warnings, *logger.errors]
+    return _bot_check_hint(message) or _n_challenge_hint(pool)
+
+
+# --------------------------------------------------------------------------- #
+# `pt dl runtime` — manage the bundled JS runtime
+# --------------------------------------------------------------------------- #
+runtime_app = typer.Typer(
+    name="runtime",
+    help="Manage the bundled JavaScript runtime (Deno) used to solve YouTube's n-challenge.",
+    no_args_is_help=True,
+)
+
+
+@runtime_app.command("install")
+def cmd_runtime_install(
+    force: Annotated[
+        bool, typer.Option("--force", help="Re-download even if already installed.")
+    ] = False,
+) -> None:
+    """Download Deno into ~/.polytool/runtime/ for yt-dlp to use.
+
+    Examples:
+
+        pt dl runtime install
+        pt dl runtime install --force
+    """
+    sys_path = runtime.system_runtime_path()
+    if sys_path and not force:
+        console.print(
+            f"[green]A system JS runtime is already on PATH:[/green] {sys_path}\n"
+            "[dim]No managed Deno needed. Pass --force to install anyway.[/dim]"
+        )
+        return
+    if runtime.is_managed_deno_installed() and not force:
+        console.print(
+            f"[green]Managed Deno already installed:[/green] {runtime.deno_binary_path()}\n"
+            "[dim]Pass --force to re-download.[/dim]"
+        )
+        return
+    try:
+        binary = runtime.install_deno()
+    except Exception as exc:
+        raise PolytoolError(f"Could not install Deno: {exc}") from exc
+    runtime.ensure_runtime_in_path()
+    console.print(f"[green]Installed Deno[/green] at [bold]{binary}[/bold]")
+
+
+@runtime_app.command("show")
+def cmd_runtime_show() -> None:
+    """Show the current JS-runtime status (system or managed).
+
+    Examples:
+
+        pt dl runtime show
+    """
+    sys_path = runtime.system_runtime_path()
+    if sys_path:
+        console.print(f"[cyan]system runtime:[/cyan] {sys_path}")
+    if runtime.is_managed_deno_installed():
+        console.print(f"[cyan]managed deno:[/cyan]  {runtime.deno_binary_path()}")
+    if not sys_path and not runtime.is_managed_deno_installed():
+        console.print("[dim]No JS runtime found.[/dim]")
+        console.print("Run [cyan]pt dl runtime install[/cyan] to fetch one.")
+
+
+@runtime_app.command("clear")
+def cmd_runtime_clear() -> None:
+    """Remove the managed Deno install at ~/.polytool/runtime/.
+
+    Examples:
+
+        pt dl runtime clear
+    """
+    if not runtime.RUNTIME_DIR.exists():
+        console.print("[dim]Nothing to clear — managed runtime dir doesn't exist.[/dim]")
+        return
+    runtime.remove_runtime()
+    console.print(f"[green]Removed[/green] {runtime.RUNTIME_DIR}")
+
+
+app.add_typer(runtime_app, name="runtime")
+
 
 def _parse_browser_spec(spec: str) -> tuple[str, str | None, str | None, str | None]:
     """Parse a polytool browser spec and return a yt-dlp-ready tuple.
@@ -316,12 +513,43 @@ def cmd_get(
     yt_dlp = require_extra("yt_dlp", extra="dl")
 
     output_dir.mkdir(parents=True, exist_ok=True)
+    # Make sure a JS runtime is reachable before we hit yt-dlp. If nothing is
+    # installed, fetch Deno automatically (one-time ~50 MB) — this is what the
+    # user expects from `polytool[full]`: it just works.
+    if runtime.ensure_runtime_in_path() is None:
+        err_console.print(
+            "[dim]No JS runtime found — polytool will fetch Deno once "
+            "(~50 MB into ~/.polytool/runtime/) so YouTube's n-challenge "
+            "can be solved.[/dim]"
+        )
+        try:
+            runtime.install_deno()
+            runtime.ensure_runtime_in_path()
+        except Exception as exc:
+            err_console.print(
+                f"[yellow]warning:[/yellow] auto-install failed: {exc}\n"
+                "[dim]Run [cyan]pt dl runtime install[/cyan] manually, "
+                "or install Deno/Node yourself.[/dim]"
+            )
+    logger = _DlLogger()
+    progress = _make_progress()
+    state: dict = {}
     opts: dict = {
         "outtmpl": str(output_dir / template),
         "noplaylist": False,
-        "quiet": False,
-        "no_warnings": False,
-        "progress": True,
+        "quiet": True,  # silence yt-dlp's stdout — we render our own UI
+        "no_warnings": True,  # warnings flow through our logger instead
+        "noprogress": True,  # we render a Rich progress bar
+        "logger": logger,
+        "progress_hooks": [_make_progress_hook(progress, state)],
+        # Try multiple YouTube clients — `tv` alone often fails the n-challenge
+        # while web/android/ios still return usable formats. yt-dlp aggregates
+        # formats across all clients before selecting.
+        "extractor_args": {
+            "youtube": {
+                "player_client": ["web", "web_safari", "mweb", "android", "ios", "tv"],
+            }
+        },
     }
     if audio_only:
         opts["format"] = "bestaudio/best"
@@ -330,6 +558,11 @@ def cmd_get(
         ]
     elif format_:
         opts["format"] = format_
+    else:
+        # `bv*+ba/b/18` — best video+audio, else best single, else fallback
+        # to YouTube's reliable 360p mp4 (format 18) which never needs the
+        # n-challenge solver and is available almost universally.
+        opts["format"] = "bv*+ba/b/18"
 
     _apply_cookie_opts(opts, cookies_from_browser, cookies_file)
     if username is not None:
@@ -340,16 +573,20 @@ def cmd_get(
         opts["videopassword"] = video_password
     if "cookiesfrombrowser" in opts and not (cookies_from_browser or cookies_file):
         err_console.print(
-            f"[dim]Using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
+            f"[dim]using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
         )
 
     try:
-        with yt_dlp.YoutubeDL(opts) as ydl:
+        with progress, yt_dlp.YoutubeDL(opts) as ydl:
             ydl.download([url])
     except yt_dlp.utils.DownloadError as exc:
-        raise PolytoolError(f"Download failed: {exc}", hint=_bot_check_hint(str(exc))) from exc
+        raise PolytoolError(
+            f"Download failed: {_strip(exc)}", hint=_hint_for_error(str(exc), logger)
+        ) from exc
     except Exception as exc:
-        raise PolytoolError(f"Download failed: {exc}", hint=_bot_check_hint(str(exc))) from exc
+        raise PolytoolError(
+            f"Download failed: {_strip(exc)}", hint=_hint_for_error(str(exc), logger)
+        ) from exc
     console.print("[green]Done.[/green]")
 
 
@@ -401,7 +638,18 @@ def cmd_info(
 
     yt_dlp = require_extra("yt_dlp", extra="dl")
 
-    opts: dict = {"quiet": True, "no_warnings": True}
+    runtime.ensure_runtime_in_path()
+    logger = _DlLogger()
+    opts: dict = {
+        "quiet": True,
+        "no_warnings": True,
+        "logger": logger,
+        "extractor_args": {
+            "youtube": {
+                "player_client": ["web", "web_safari", "mweb", "android", "ios", "tv"],
+            }
+        },
+    }
     _apply_cookie_opts(opts, cookies_from_browser, cookies_file)
     if username is not None:
         opts["username"] = username
@@ -411,7 +659,7 @@ def cmd_info(
         opts["videopassword"] = video_password
     if "cookiesfrombrowser" in opts and not (cookies_from_browser or cookies_file):
         err_console.print(
-            f"[dim]Using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
+            f"[dim]using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
         )
 
     # process=False skips yt-dlp's format-selection step. We only want metadata,
@@ -421,7 +669,9 @@ def cmd_info(
         with yt_dlp.YoutubeDL(opts) as ydl:
             info = ydl.extract_info(url, download=False, process=False)
     except Exception as exc:
-        raise PolytoolError(f"Could not fetch info: {exc}", hint=_bot_check_hint(str(exc))) from exc
+        raise PolytoolError(
+            f"Could not fetch info: {_strip(exc)}", hint=_hint_for_error(str(exc), logger)
+        ) from exc
 
     if info is None:
         raise PolytoolError("yt-dlp returned no metadata for this URL.")

polytool-0.2.6/src/polytool/core/runtime.py

@@ -0,0 +1,162 @@
+"""Managed JavaScript runtime — Deno, downloaded on demand.
+
+Some yt-dlp downloads (notably YouTube's "n-challenge") require an external
+JS runtime to solve a piece of obfuscated JavaScript. Rather than make users
+install Node/Deno system-wide, polytool can fetch a Deno binary into
+``~/.polytool/runtime/`` and prepend that directory to ``PATH`` for yt-dlp's
+subprocess lookups.
+
+* Single binary, ~50-80 MB depending on platform.
+* No admin rights needed — lives under the user's home dir.
+* Removed cleanly via ``pt dl runtime clear``.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import stat
+import sys
+import zipfile
+from pathlib import Path
+
+from polytool.core.console import err_console
+
+RUNTIME_DIR: Path = Path.home() / ".polytool" / "runtime"
+
+# We download from GitHub's "latest" redirect so the version follows upstream.
+_DENO_LATEST_BASE = "https://github.com/denoland/deno/releases/latest/download"
+
+# Names of system runtimes yt-dlp's EJS plugin will recognize on PATH.
+_RECOGNIZED_RUNTIMES: tuple[str, ...] = ("deno", "node", "bun")
+
+
+def _deno_archive_name() -> str:
+    """Return the Deno release archive name for this platform/arch."""
+    machine = platform.machine().lower()
+    if machine in {"x86_64", "amd64", "x64"}:
+        arch = "x86_64"
+    elif machine in {"arm64", "aarch64"}:
+        arch = "aarch64"
+    else:
+        raise RuntimeError(
+            f"Unsupported CPU arch for managed Deno install: {machine!r}. "
+            "Install Deno or Node manually."
+        )
+
+    if sys.platform == "win32":
+        return f"deno-{arch}-pc-windows-msvc.zip"
+    if sys.platform == "darwin":
+        return f"deno-{arch}-apple-darwin.zip"
+    if sys.platform.startswith("linux"):
+        return f"deno-{arch}-unknown-linux-gnu.zip"
+    raise RuntimeError(f"Unsupported platform for managed Deno install: {sys.platform!r}")
+
+
+def deno_binary_path() -> Path:
+    """Where the managed Deno binary lives on disk."""
+    name = "deno.exe" if sys.platform == "win32" else "deno"
+    return RUNTIME_DIR / name
+
+
+def system_runtime_path() -> str | None:
+    """Return the absolute path of any JS runtime already on the user's PATH."""
+    for tool in _RECOGNIZED_RUNTIMES:
+        found = shutil.which(tool)
+        if found:
+            return found
+    return None
+
+
+def is_managed_deno_installed() -> bool:
+    """True iff polytool's own Deno binary exists and is runnable."""
+    p = deno_binary_path()
+    if not p.exists():
+        return False
+    if sys.platform == "win32":
+        return True
+    return bool(p.stat().st_mode & stat.S_IXUSR)
+
+
+def install_deno() -> Path:
+    """Download Deno into ``RUNTIME_DIR`` and return the path to the binary.
+
+    Streams the zip with a Rich progress bar (this is a ~50-80 MB download).
+    Overwrites any existing binary.
+    """
+    import httpx
+    from rich.progress import (
+        BarColumn,
+        DownloadColumn,
+        Progress,
+        SpinnerColumn,
+        TextColumn,
+        TimeRemainingColumn,
+        TransferSpeedColumn,
+    )
+
+    RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
+    archive_name = _deno_archive_name()
+    url = f"{_DENO_LATEST_BASE}/{archive_name}"
+    archive_path = RUNTIME_DIR / archive_name
+
+    err_console.print(f"[dim]downloading {archive_name}[/dim]")
+    progress = Progress(
+        SpinnerColumn(),
+        TextColumn("[bold cyan]Deno"),
+        BarColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+        console=err_console,
+        transient=False,
+    )
+
+    with progress, httpx.stream("GET", url, follow_redirects=True, timeout=300) as resp:
+        resp.raise_for_status()
+        total = int(resp.headers.get("content-length") or 0) or None
+        task = progress.add_task("Deno", total=total)
+        with archive_path.open("wb") as f:
+            for chunk in resp.iter_bytes(chunk_size=64 * 1024):
+                f.write(chunk)
+                progress.update(task, advance=len(chunk))
+
+    err_console.print("[dim]extracting...[/dim]")
+    with zipfile.ZipFile(archive_path) as zf:
+        zf.extractall(RUNTIME_DIR)
+    archive_path.unlink()
+
+    binary = deno_binary_path()
+    if not binary.exists():
+        raise RuntimeError(f"Deno extracted but binary not found at {binary}")
+    if sys.platform != "win32":
+        binary.chmod(binary.stat().st_mode | 0o755)
+    return binary
+
+
+def ensure_runtime_in_path() -> str | None:
+    """Make sure a JS runtime is reachable to subprocesses.
+
+    Returns the absolute path of the runtime in use, or ``None`` if none is
+    available. If the managed Deno is installed but its directory isn't on
+    ``PATH`` yet, we prepend it (in-process only — no shell rc files touched).
+    """
+    sys_path = system_runtime_path()
+    if sys_path:
+        return sys_path
+    if is_managed_deno_installed():
+        binary = deno_binary_path()
+        parent = str(binary.parent)
+        current_path = os.environ.get("PATH", "")
+        segments = current_path.split(os.pathsep)
+        if parent not in segments:
+            os.environ["PATH"] = parent + os.pathsep + current_path
+        return str(binary)
+    return None
+
+
+def remove_runtime() -> None:
+    """Delete the managed runtime directory."""
+    if RUNTIME_DIR.exists():
+        shutil.rmtree(RUNTIME_DIR)

polytool-0.2.4/src/polytool/cli/__init__.py

@@ -1,98 +0,0 @@
-"""Root Typer app — subcommand groups are added by their own modules.
-
-Subcommand modules must keep top-level imports light (typer/rich/stdlib only).
-Heavy imports (Pillow, ffmpeg, rembg) happen inside command bodies via
-`polytool.core.lazy.require_extra`.
-"""
-
-from __future__ import annotations
-
-import sys
-
-import typer
-
-from polytool import __version__
-from polytool.cli import (
-    clip,
-    color,
-    convert,
-    cron,
-    data,
-    dl,
-    enc,
-    file,
-    gen,
-    img,
-    net,
-    pdf,
-    qr,
-    shot,
-    text,
-    vid,
-)
-from polytool.core.errors import PolytoolError, render_panel
-
-app = typer.Typer(
-    name="polytool",
-    help="polytool — one-binary CLI bundling 26 everyday utilities (pt for short).",
-    no_args_is_help=True,
-    add_completion=False,
-    rich_markup_mode="rich",
-    # We handle PolytoolError ourselves via the `main()` wrapper below; disable
-    # Typer's pretty-traceback so it doesn't squash our hints.
-    pretty_exceptions_enable=False,
-)
-
-
-def run() -> None:
-    """Console-script entry point — runs the Typer app and renders PolytoolError nicely.
-
-    (Defined with a unique name to avoid clashing with the ``@app.callback()``
-    function below — both would otherwise be named ``main`` in this module.)
-    """
-    try:
-        app()
-    except PolytoolError as exc:
-        render_panel(exc.message, exc.hint)
-        sys.exit(1)
-
-
-def _version_callback(value: bool) -> None:
-    if value:
-        typer.echo(f"polytool {__version__}")
-        raise typer.Exit
-
-
-@app.callback()
-def main(
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        callback=_version_callback,
-        is_eager=True,
-        help="Show version and exit.",
-    ),
-) -> None:
-    """polytool — one-binary CLI bundling 26 everyday utilities."""
-
-
-app.add_typer(enc.app, name="enc")
-app.add_typer(gen.app, name="gen")
-app.add_typer(color.app, name="color")
-app.add_typer(convert.app, name="convert")
-app.add_typer(text.app, name="text")
-app.add_typer(data.app, name="data")
-app.add_typer(qr.app, name="qr")
-app.add_typer(clip.app, name="clip")
-app.add_typer(cron.app, name="cron")
-app.add_typer(net.app, name="net")
-app.add_typer(file.app, name="file")
-app.add_typer(img.app, name="img")
-app.add_typer(pdf.app, name="pdf")
-app.add_typer(vid.app, name="vid")
-app.add_typer(dl.app, name="dl")
-app.add_typer(shot.app, name="shot")
-
-
-__all__ = ["app"]