transmute-cli 0.2.3a0__py3-none-any.whl

transmute/commands.py

@@ -0,0 +1,321 @@
+"""Slash commands. Methods named cmd_<name> are dispatched from /<name>."""
+
+from __future__ import annotations
+
+import getpass
+import os
+import subprocess
+from pathlib import Path
+
+from .config import QUALITIES
+
+# The command reference shown in the scrollable /help panel above the live
+# prompt, rather than streamed through the transient message log.
+HELP_ROWS = [
+    ("/out [dir]", "show or set output dir; no arg opens a separate ~/ editor"),
+    ("/quality [128|192|256|320]", "show or set MP3 bitrate (kbps)"),
+    ("/enrich [codex|claude|api|on|off]", "choose or toggle metadata enrichment"),
+    ("/key [clear]", "securely set or clear one API key"),
+    ("/list", "show recent converted and failed tracks across sessions"),
+    ("/retry", "requeue all retryable failed downloads"),
+    ("/sync [spotify|music|retry]", "preview Spotify sync; a/A select tracks, Enter continues"),
+    ("/login [codex|claude]", "log in to a subscription provider"),
+    ("/logout [codex|claude]", "log out of a subscription provider"),
+    ("/clear", "clear history and messages"),
+    ("/help", "show commands while keeping URL input live; Esc closes help"),
+    ("/quit", "exit (or ctrl-d / double ctrl-c)"),
+    ("↑/↓", "select failed or low-confidence entries in History"),
+]
+
+
+class Commands:
+    def __init__(self, app) -> None:
+        self.app = app
+
+    def dispatch(self, text: str) -> None:
+        """Handle a /command line. /quit and friends exit the app."""
+        name, _, arg = text.lstrip("/").partition(" ")
+        if name in ("quit", "exit", "q"):
+            self.app.app.exit()
+            return
+        handler = getattr(self, f"cmd_{name}", None)
+        if handler:
+            handler(arg.strip())
+        else:
+            self.app.msg("class:err", f"unknown command: /{name}  (/help for commands)")
+
+    def cmd_help(self, _arg: str) -> None:
+        self.app.open_help()
+
+    def cmd_sync(self, arg: str) -> None:
+        if arg == "music":
+            self.app.msg("class:dim", "Import the output folder into macOS Music, then use Finder > iPhone > Music to sync. iPhone Music export is unsupported.")
+        elif arg == "retry":
+            self.app.retry_sync()
+        elif arg in ("", "spotify"):
+            self.app.start_sync_preview()
+        else:
+            self.app.msg("class:err", "sync must be spotify, music, or retry")
+
+    def _set_out_dir(self, text: str) -> None:
+        path = Path(text).expanduser()
+        if not path.is_absolute():
+            path = Path.home() / text  # bare names are home-relative
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            self.app.msg("class:err", f"can't use {path}: {e}")
+            return
+        self.app.set_out_dir(path)
+        self.app.msg("class:dim", f"output directory: {path}")
+
+    def cmd_out(self, arg: str) -> None:
+        """`/out <dir>` sets the directory in one shot (resolve, auto-create,
+        set). `/out` with no arg opens the interactive picker: the prompt is
+        rooted at ~/ (uneditable), completes real folder names as you type, and
+        offers to create a missing folder. URL input remains live; Enter applies
+        the folder and Esc cancels."""
+        if arg:
+            self._set_out_dir(arg)
+            return
+        settings = self.app.settings_snapshot()
+        self.app.msg("class:dim", f"output directory: {settings.out_dir}")
+        self.app.open_dir_picker()
+
+    def cmd_quality(self, arg: str) -> None:
+        if arg:
+            if arg not in QUALITIES:
+                self.app.msg(
+                    "class:err", f"quality must be one of {', '.join(QUALITIES)}"
+                )
+                return
+            self.app.set_quality(arg)
+        quality = self.app.settings_snapshot().quality
+        self.app.msg("class:dim", f"quality: {quality}k")
+
+    def cmd_enrich(self, arg: str) -> None:
+        if arg == "off":
+            self.app.enricher.set_enrichment_enabled(False)
+        elif arg == "on":
+            self.app.enricher.set_enrichment_enabled(True)
+        elif arg == "api":
+            if not self.app.enricher.use_api_key():
+                self.app.msg("class:err", self.app.enricher.last_error)
+                return
+        elif arg in ("codex", "claude"):
+            self.app.enricher.use_backend(arg)
+        elif arg:
+            self.app.msg(
+                "class:err",
+                "enrichment must be codex, claude, api, on, or off",
+            )
+            return
+        state = "on" if self.app.enricher.enabled else "off"
+        self.app.msg(
+            "class:dim",
+            f"metadata enrichment: {state} · {self.app.enricher.backend_label}",
+        )
+
+    def _apply_key(self, key: str) -> None:
+        try:
+            self.app.enricher.set_api_key(key)
+        except ValueError as e:
+            self.app.msg("class:err", str(e))
+            return
+        self.app.msg(
+            "class:ok",
+            f"{self.app.enricher.backend_label} key active — API enrichment prioritized",
+        )
+
+    def cmd_key(self, arg: str) -> None:
+        if arg == "clear":
+            self.app.enricher.clear_api_key()
+            source = (
+                " from environment"
+                if self.app.enricher.api_key_source == "environment"
+                else ""
+            )
+            self.app.msg(
+                "class:dim",
+                f"entered API key cleared · "
+                f"{self.app.enricher.backend_label}{source}",
+            )
+            return
+        if arg:
+            self.app.msg(
+                "class:err",
+                "for security, run /key with no argument and use the masked prompt",
+            )
+            return
+
+        from prompt_toolkit.application import run_in_terminal
+
+        app = self.app
+
+        async def task():
+            try:
+                key = await run_in_terminal(
+                    lambda: getpass.getpass(
+                        "API key (OpenAI sk-… or Anthropic sk-ant-…): "
+                    )
+                )
+            except (EOFError, KeyboardInterrupt):
+                key = ""
+            if key.strip():
+                self._apply_key(key)
+            else:
+                app.msg("class:dim", "API key entry cancelled")
+
+        app.app.create_background_task(task())
+
+    def cmd_login(self, arg: str) -> None:
+        from prompt_toolkit.application import run_in_terminal
+
+        app = self.app
+        provider = arg or "claude"
+        if provider not in ("codex", "claude"):
+            app.msg("class:err", "login provider must be codex or claude")
+            return
+        label = "Codex / ChatGPT" if provider == "codex" else "Claude"
+        command = (
+            ["codex", "login"]
+            if provider == "codex"
+            else ["claude", "auth", "login", "--claudeai"]
+        )
+
+        async def task():
+            def blocking() -> int:
+                print(f"Launching {label} login (browser will open)…\n")
+                try:
+                    return subprocess.run(
+                        command,
+                        timeout=300,
+                        check=False,
+                    ).returncode
+                except FileNotFoundError:
+                    return -1
+                except subprocess.TimeoutExpired:
+                    return -2
+
+            rc = await run_in_terminal(blocking)
+            if rc == 0:
+                if app.enricher.has_api_key:
+                    app.msg(
+                        "class:ok",
+                        f"logged in to {label} · "
+                        f"{app.enricher.backend_label} remains prioritized",
+                    )
+                else:
+                    app.enricher.use_backend(provider)
+                    app.msg(
+                        "class:ok",
+                        f"logged in to {app.enricher.backend_label} "
+                        "— enrichment enabled",
+                    )
+            elif rc == -1:
+                app.msg(
+                    "class:err",
+                    f"{provider} CLI not found — install it first",
+                )
+            elif rc == -2:
+                app.msg("class:err", f"{provider} login timed out")
+            else:
+                app.msg("class:err", "login failed or was cancelled")
+
+        app.app.create_background_task(task())
+
+    def cmd_logout(self, arg: str) -> None:
+        app = self.app
+        provider = arg or "claude"
+        if provider not in ("codex", "claude"):
+            app.msg("class:err", "logout provider must be codex or claude")
+            return
+        command = (
+            ["codex", "logout"] if provider == "codex" else ["claude", "auth", "logout"]
+        )
+        try:
+            proc = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False,
+            )
+        except FileNotFoundError:
+            app.msg("class:err", f"{provider} CLI not found — nothing to log out of")
+            return
+        except subprocess.TimeoutExpired:
+            app.msg("class:err", f"{provider} logout timed out")
+            return
+        if proc.returncode == 0:
+            if app.enricher.backend == provider:
+                app.enricher.enabled = False
+            label = "Codex / ChatGPT" if provider == "codex" else "Claude"
+            app.msg(
+                "class:dim",
+                f"logged out of {label}",
+            )
+        else:
+            app.msg(
+                "class:err",
+                (proc.stderr or proc.stdout).strip()[:120] or "logout failed",
+            )
+        if provider == "claude" and os.environ.get("ANTHROPIC_API_KEY"):
+            app.msg(
+                "class:warn",
+                "⚠ ANTHROPIC_API_KEY is still set in your shell — "
+                "enrichment can still bill the API via that key",
+            )
+
+    def cmd_list(self, _arg: str) -> None:
+        app = self.app
+        with app.lock:
+            completed, failed = list(app.completed), list(app.failed)
+        if not completed and not failed:
+            app.msg("class:dim", "nothing converted yet")
+            return
+        for job in completed:
+            app.msg("class:ok", f"✔ {job.title or job.url}")
+        for job in failed:
+            app.msg("class:err", f"✘ {job.url}")
+
+    def cmd_retry(self, _arg: str) -> None:
+        app = self.app
+        with app.activity_lock:
+            with app.lock:
+                failed = [job for job in app.failed if job.retryable]
+            if not failed:
+                app.msg("class:dim", "no failed downloads to retry")
+                return
+
+            # Persist the queued transition before removing the actionable
+            # failures from the current view.
+            app._submit_jobs(failed)
+            retry_ids = {job.history_id for job in failed}
+            with app.lock:
+                app.failed = [
+                    job for job in app.failed if job.history_id not in retry_ids
+                ]
+                app.history = [
+                    entry
+                    for entry in app.history
+                    if not (
+                        entry.kind == "err"
+                        and entry.job is not None
+                        and entry.job.history_id in retry_ids
+                    )
+                ]
+                app.sel = None
+
+    def cmd_clear(self, _arg: str) -> None:
+        app = self.app
+        with app.activity_lock:
+            with app.lock:
+                app.messages.clear()
+            app._persist("clear")
+            with app.lock:
+                app.history.clear()
+                app.completed.clear()
+                app.failed.clear()
+                app.sel = None
+        app.refresh()

transmute/config.py

@@ -0,0 +1,21 @@
+"""Settings and shared constants."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+STATE_DIR = Path.home() / ".transmute"
+HISTORY_FILE = STATE_DIR / "history"
+ACTIVITY_FILE = STATE_DIR / "activity.sqlite3"
+SETTINGS_FILE = STATE_DIR / "settings.json"
+SETTINGS_VERSION = 1
+QUALITIES = ("128", "192", "256", "320")
+MAX_WORKERS = 4
+SIGNIN_RECHECK_SECONDS = 15
+
+
+@dataclass(frozen=True)
+class Settings:
+    out_dir: Path = field(default_factory=lambda: Path.home() / "Downloads")
+    quality: str = "320"

transmute/downloader.py

@@ -0,0 +1,190 @@
+"""Local yt-dlp download pipeline."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+from urllib.parse import urlparse
+from uuid import uuid4
+
+from .config import Settings
+
+URL_RE = re.compile(r"https?://(?:(?!https?://)\S)+")
+JobStatus = Literal["queued", "downloading", "converting", "done", "error"]
+ProgressCallback = Callable[["Job", float | None], None]
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+# (substring of the lowercased yt-dlp message, short human message, retryable)
+# Non-retryable means retrying the same URL cannot succeed without the user
+# changing something first.
+_ERROR_PATTERNS: list[tuple[str, str, bool]] = [
+    ("unsupported url", "", False),  # message built from the domain, see below
+    ("is not a valid url", "not a valid link", False),
+    ("private video", "video is private", False),
+    ("video unavailable", "video unavailable", False),
+    ("has been removed", "video was removed", False),
+    ("no longer available", "video is no longer available", False),
+    ("sign in to confirm", "requires login — needs browser cookies", False),
+    ("login required", "requires login — needs browser cookies", False),
+    ("not available in your country", "not available in your region", False),
+    ("ffprobe and ffmpeg not found", "ffmpeg missing — brew install ffmpeg", False),
+    ("timed out", "network error — timed out", True),
+    ("temporary failure in name resolution", "network error — DNS failed", True),
+    ("getaddrinfo failed", "network error — DNS failed", True),
+    ("connection", "network error — connection failed", True),
+    ("http error 403", "download refused (HTTP 403) — update transmute if it persists", True),
+    ("http error 5", "server error — try again later", True),
+    ("unable to download", "network error — download failed", True),
+]
+
+# Hosts we can actually download from. Subdomains (www., m., music., on., …)
+# are matched too, so e.g. music.youtube.com and on.soundcloud.com are allowed.
+#
+# TO ADD A NEW MEDIA SOURCE: append its bare registrable domain here (e.g.
+# "bandcamp.com", "vimeo.com"). That is the single choke point — is_supported_url
+# and the input gate in App._accept both read from this tuple, so no other code
+# needs to change to widen what the app accepts. Only add a host once yt-dlp can
+# actually extract audio from it, otherwise links pass the gate and fail later at
+# download time.
+SUPPORTED_HOSTS = ("youtube.com", "youtu.be", "soundcloud.com")
+
+
+def is_supported_url(url: str) -> bool:
+    """True only for links to a supported media source (see SUPPORTED_HOSTS).
+
+    We gate input up front rather than letting anything ``http(s)://`` through
+    for two reasons: the download pipeline is built around yt-dlp audio
+    extraction, which only works for known media hosts, and rejecting an
+    unsupported paste immediately gives the user a clear message instead of a
+    cryptic failure minutes later. Matching is anchored to each host's registrable
+    domain (``host == h`` or ``host.endswith("." + h)``) so subdomains like
+    ``music.youtube.com`` are accepted while look-alikes like
+    ``youtube.com.evil.com`` are not.
+
+    To support a new format/source, add its host to SUPPORTED_HOSTS above; this
+    function and the App._accept input gate pick it up automatically.
+    """
+    host = (urlparse(url).hostname or "").lower()
+    return any(host == h or host.endswith("." + h) for h in SUPPORTED_HOSTS)
+
+
+@dataclass
+class Job:
+    url: str
+    status: JobStatus = "queued"
+    title: str | None = None
+    uploader: str | None = None
+    duration: int | None = None
+    description: str | None = None
+    tags: list[str] | None = None
+    path: Path | None = None
+    error: str | None = None  # short human-readable summary
+    error_detail: str | None = None  # full untruncated message from yt-dlp
+    retryable: bool = True
+    history_id: str = field(default_factory=lambda: uuid4().hex, compare=False)
+
+
+class _SilentLogger:
+    """Swallow yt-dlp's log output; even with quiet=True it prints errors to
+    stderr, which corrupts the full-screen TUI. Failures reach us as raised
+    exceptions instead."""
+
+    def debug(self, msg: str) -> None:
+        pass
+
+    def warning(self, msg: str) -> None:
+        pass
+
+    def error(self, msg: str) -> None:
+        pass
+
+
+def classify_error(e: Exception, url: str) -> tuple[str, str, bool]:
+    """Turn a raw yt-dlp exception into (summary, detail, retryable).
+
+    yt-dlp embeds ANSI color codes in its exception messages when it detects
+    a tty, so strip those before anything else.
+    """
+    detail = ANSI_RE.sub("", str(e)).strip()
+    low = detail.lower()
+    for needle, summary, retryable in _ERROR_PATTERNS:
+        if needle in low:
+            if needle == "unsupported url":
+                domain = urlparse(url).netloc or url
+                summary = f"{domain} isn't a supported site"
+            return summary, detail, retryable
+    first = detail.split("\n")[0].removeprefix("ERROR: ").strip()[:120]
+    return first or "unknown error", detail, True
+
+
+def extract_urls(text: str) -> list[str]:
+    """Pull URLs out of free text, including ones pasted back-to-back."""
+    return URL_RE.findall(text)
+
+
+def download_job(
+    job: Job,
+    settings: Settings,
+    on_progress: ProgressCallback | None = None,
+) -> Job:
+    """Download one URL to MP3 and normalize third-party failures onto `job`."""
+    import yt_dlp
+
+    def hook(d: dict) -> None:
+        info = d.get("info_dict") or {}
+        if info.get("title"):
+            job.title = info["title"]
+        status = d.get("status")
+        if status == "downloading":
+            job.status = "downloading"
+            total = d.get("total_bytes") or d.get("total_bytes_estimate")
+            if on_progress and total:
+                on_progress(job, d.get("downloaded_bytes", 0) / total)
+        elif status == "finished":
+            job.status = "converting"
+            if on_progress:
+                on_progress(job, None)
+
+    opts = {
+        "format": "bestaudio/best",
+        "outtmpl": str(settings.out_dir / "%(uploader)s - %(title)s.%(ext)s"),
+        "noplaylist": True,
+        "color": "never",  # keep ANSI codes out of exception messages
+        "logger": _SilentLogger(),
+        "quiet": True,
+        "no_warnings": True,
+        "noprogress": True,
+        "writethumbnail": True,
+        "progress_hooks": [hook],
+        "postprocessors": [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": settings.quality,
+            },
+            {"key": "FFmpegMetadata"},
+            {"key": "EmbedThumbnail"},
+        ],
+    }
+
+    try:
+        settings.out_dir.mkdir(parents=True, exist_ok=True)
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            info = ydl.extract_info(job.url, download=True)
+        job.title = info.get("title") or job.title
+        job.uploader = info.get("uploader")
+        job.duration = info.get("duration")
+        job.description = info.get("description")
+        job.tags = info.get("tags")
+        downloads = info.get("requested_downloads") or []
+        if downloads and downloads[0].get("filepath"):
+            job.path = Path(downloads[0]["filepath"])
+        job.status = "done"
+    except Exception as e:  # noqa: BLE001
+        job.status = "error"
+        job.error, job.error_detail, job.retryable = classify_error(e, job.url)
+
+    return job