flowmusic-cli 0.1.0__py3-none-any.whl

flowmusic_cli/api/generate.py

@@ -0,0 +1,387 @@
+"""Generation orchestration: send → stream → wait for audio → fetch clip metadata.
+
+The web app talks to an LLM "co-producer" (chat mode). It decides which tools to
+call (``audio__create_song`` etc.); each successful tool-return carries a
+``clip_id`` + ``operation_id`` which we poll until the audio has rendered.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+from flowmusic_cli.api.client import UPLOAD_AUDIO_INSTRUCTIONS, FlowMusicClient
+from flowmusic_cli.config import DEFAULT_MODEL
+from flowmusic_cli.errors import ApiError, Blocked, GenerationFailed, NoAccess, UsageError
+
+ProgressFn = Callable[[str, dict], None]
+
+# Tools whose result is a new audio clip.
+AUDIO_TOOLS = {
+    "audio__create_song",
+    "lyria__generate_song",
+    "audio__modify_song",
+    "audio__render_edit",
+    "audio__apply_effect",
+    "audio__convert_format",
+    "audio__split_stems",
+}
+
+
+@dataclass
+class JobOutcome:
+    job_id: str
+    conversation_id: str | None = None
+    title: str | None = None
+    text: str = ""
+    tool_calls: list[dict] = field(default_factory=list)
+    tool_returns: list[dict] = field(default_factory=list)
+    suggestions: list[str] = field(default_factory=list)
+    completed: bool = False
+
+    @property
+    def clip_refs(self) -> list[dict]:
+        """``[{clip_id, operation_id, title, tool}]`` for every audio result."""
+        refs: list[dict] = []
+        for tr in self.tool_returns:
+            content = tr.get("content")
+            if not isinstance(content, dict):
+                continue
+            # Edit/remix tools (audio__render_edit, ...) return a list of outputs.
+            for o in content.get("clip_outputs") or []:
+                if isinstance(o, dict) and o.get("clip_id"):
+                    refs.append({
+                        "clip_id": o["clip_id"],
+                        "operation_id": content.get("operation_id"),
+                        "title": o.get("title"),
+                        "tool": tr.get("tool_name"),
+                        "estimated_time": content.get("estimated_time"),
+                    })
+            for cid_key, op_key in (("clip_id", "operation_id"), ("clip_id_b", "operation_id_b")):
+                if content.get(cid_key):
+                    refs.append({
+                        "clip_id": content[cid_key],
+                        "operation_id": content.get(op_key),
+                        "title": content.get("title"),
+                        "tool": tr.get("tool_name"),
+                        "estimated_time": content.get("estimated_time"),
+                    })
+        return refs
+
+    @property
+    def failures(self) -> list[dict]:
+        out = []
+        for tr in self.tool_returns:
+            c = tr.get("content")
+            if isinstance(c, dict) and c.get("status") not in (None, "success", "complete", "completed"):
+                out.append({"tool": tr.get("tool_name"), **c})
+            elif isinstance(c, str) and tr.get("tool_name") in AUDIO_TOOLS and "error" in c.lower():
+                out.append({"tool": tr.get("tool_name"), "status": "error", "message": c})
+        return out
+
+
+def run_job(client: FlowMusicClient, job_id: str, on_progress: ProgressFn | None = None) -> JobOutcome:
+    out = JobOutcome(job_id=job_id)
+    emit = on_progress or (lambda kind, data: None)
+    for ev in client.stream_job(job_id):
+        d = ev.data if isinstance(ev.data, dict) else {}
+        if ev.event == "conversation_id":
+            out.conversation_id = d.get("id")
+            emit("conversation", d)
+        elif ev.event == "part":
+            part = d.get("part") or {}
+            kind = part.get("part_kind")
+            status = d.get("status")
+            if kind == "tool-call" and status == "final":
+                out.tool_calls.append(part)
+                emit("tool_call", part)
+            elif kind == "tool-return":
+                out.tool_returns.append(part)
+                emit("tool_return", part)
+            elif kind == "text":
+                if status == "delta":
+                    emit("text_delta", {"delta": d.get("delta", "")})
+                elif status == "final":
+                    out.text = (out.text + "\n\n" + part.get("content", "")).strip()
+                    emit("text", part)
+        elif ev.event == "message" and isinstance(d.get("parts"), list):
+            # Direct tool-call jobs stream whole messages instead of incremental parts.
+            for part in d["parts"]:
+                kind = part.get("part_kind")
+                if kind == "tool-call":
+                    out.tool_calls.append(part)
+                    emit("tool_call", part)
+                elif kind == "tool-return":
+                    out.tool_returns.append(part)
+                    emit("tool_return", part)
+                elif kind == "text":
+                    out.text = (out.text + "\n\n" + part.get("content", "")).strip()
+                    emit("text", part)
+        elif ev.event == "complete":
+            out.completed = True
+            emit("complete", d)
+        elif ev.event == "generated-title":
+            out.title = d.get("title")
+        elif ev.event == "suggestion":
+            for p in d.get("parts", []):
+                if p.get("tool_name") == "synthetic__suggest_actions" and isinstance(p.get("args"), dict):
+                    out.suggestions = [v for v in p["args"].values() if isinstance(v, str)]
+        elif ev.event == "error":
+            msg = d.get("message") or d.get("detail") or str(ev.data)
+            raise GenerationFailed(f"Producer error: {msg}")
+    return out
+
+
+def wait_for_clips(
+    client: FlowMusicClient,
+    refs: list[dict],
+    *,
+    timeout: float = 600,
+    interval: float = 3,
+    on_progress: ProgressFn | None = None,
+) -> list[dict]:
+    """Poll render status until every clip is done; return full clip objects."""
+    emit = on_progress or (lambda kind, data: None)
+    pending = {r["clip_id"]: r for r in refs}
+    errors: list[str] = []
+    deadline = time.monotonic() + timeout
+    while pending and time.monotonic() < deadline:
+        for cid, ref in list(pending.items()):
+            op = ref.get("operation_id")
+            if op and ref.get("tool") in (None, "audio__create_song", "lyria__generate_song"):
+                try:
+                    st = client.song_status(op)
+                except ApiError:
+                    st = None
+                if st:
+                    status = (st.get("status") or "").lower()
+                    if status in ("complete", "completed", "success"):
+                        pending.pop(cid)
+                        emit("clip_ready", ref)
+                    elif status in ("error", "failed", "failure", "cancelled"):
+                        pending.pop(cid)
+                        errors.append(f"{ref.get('title') or cid}: {st.get('error_type')} {st.get('error_message')}")
+                    else:
+                        emit("clip_progress", {**ref, "progress": st.get("progress")})
+                    continue
+            # Fallback for other tools: the clip is ready once it has audio.
+            clip = client.get_clips([cid]).get(cid) or {}
+            if clip.get("wav_url") or clip.get("audio_url"):
+                pending.pop(cid)
+                emit("clip_ready", ref)
+        if pending:
+            time.sleep(interval)
+    if pending:
+        errors.append(f"timed out waiting for {', '.join(pending)}")
+    ids = [r["clip_id"] for r in refs]
+    clips_by_id = client.get_clips(ids)
+    clips = [clips_by_id[i] for i in ids if i in clips_by_id]
+    if errors and not clips:
+        _raise_failure("; ".join(errors))
+    for c in clips:
+        c.setdefault("_errors", [])
+    if errors:
+        clips[0]["_errors"] = errors
+    return clips
+
+
+def _raise_failure(message: str):
+    low = message.lower()
+    if any(w in low for w in ("moderat", "policy", "blocked", "safety", "copyright", "flag")):
+        raise Blocked(message)
+    raise GenerationFailed(message)
+
+
+def build_prompt(prompt: str, *, lyrics: str | None = None, instrumental: bool = False) -> str:
+    text = prompt.strip()
+    if instrumental:
+        text += "\n\nMake it instrumental (no vocals)."
+    if lyrics:
+        text += "\n\nUse exactly these lyrics, unchanged:\n\n" + lyrics.strip()
+    return text
+
+
+def upload_parts(clip: dict, *, name: str | None = None) -> list[dict]:
+    """The synthetic tool-call/return pair the web app sends for an attached upload."""
+    call_id = str(uuid.uuid4())
+    args: dict[str, Any] = {
+        "id": clip["id"],
+        "url": clip.get("audio_url") or clip.get("url") or clip.get("wav_url"),
+        "name": name or clip.get("title") or "upload",
+        "instructions": UPLOAD_AUDIO_INSTRUCTIONS,
+    }
+    dur = (clip.get("duration") or {}).get("value") if isinstance(clip.get("duration"), dict) else clip.get("duration")
+    if dur:
+        try:
+            args["duration_s"] = float(dur)
+        except (TypeError, ValueError):
+            pass
+    return [
+        {"tool_name": "synthetic__upload_audio", "args": args, "tool_call_id": call_id, "part_kind": "tool-call"},
+        {
+            "tool_name": "synthetic__upload_audio",
+            "content": None,
+            "tool_call_id": call_id,
+            "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            "part_kind": "tool-return",
+        },
+    ]
+
+
+@dataclass
+class GenerationResult:
+    conversation_id: str | None
+    job_ids: list[str]
+    clips: list[dict]
+    message: str = ""
+    title: str | None = None
+    suggestions: list[str] = field(default_factory=list)
+
+
+def chat(
+    client: FlowMusicClient,
+    prompt: str,
+    *,
+    conversation_id: str | None = None,
+    model: str = DEFAULT_MODEL,
+    lyrics: str | None = None,
+    instrumental: bool = False,
+    attachments: list[dict] | None = None,
+    wait: bool = True,
+    timeout: float = 600,
+    on_progress: ProgressFn | None = None,
+) -> GenerationResult:
+    """Send a message to the co-producer (new or existing conversation)."""
+    parts: list[dict] = []
+    for clip in attachments or []:
+        parts.extend(upload_parts(clip))
+    parts.append({"content": build_prompt(prompt, lyrics=lyrics, instrumental=instrumental),
+                  "part_kind": "user-prompt"})
+    job_id = client.send_message(parts, conversation_id=conversation_id, model=model)
+    (on_progress or (lambda k, d: None))("job", {"job_id": job_id})
+    if not wait:
+        return GenerationResult(conversation_id=conversation_id, job_ids=[job_id], clips=[])
+    outcome = run_job(client, job_id, on_progress)
+    refs = outcome.clip_refs
+    if not refs and outcome.failures:
+        _raise_failure("; ".join(str(f.get("message") or f.get("error_message") or f) for f in outcome.failures))
+    clips = wait_for_clips(client, refs, timeout=timeout, on_progress=on_progress) if refs else []
+    return GenerationResult(
+        conversation_id=outcome.conversation_id or conversation_id,
+        job_ids=[job_id],
+        clips=clips,
+        message=outcome.text,
+        title=outcome.title,
+        suggestions=outcome.suggestions,
+    )
+
+
+def direct_create(
+    client: FlowMusicClient,
+    sound_prompt: str,
+    *,
+    count: int = 1,
+    title: str | None = None,
+    lyrics: str | None = None,
+    instrumental: bool = False,
+    conversation_id: str | None = None,
+    model: str = DEFAULT_MODEL,
+    timeout: float = 600,
+    on_progress: ProgressFn | None = None,
+) -> GenerationResult:
+    """EXPERIMENTAL: call ``audio__create_song`` directly, bypassing the LLM producer.
+
+    The prompt is used verbatim as ``sound_prompt``. Lyrics are first registered
+    with ``lyrics__register`` (the same call the web lyrics editor makes).
+    """
+    if count < 1:
+        raise UsageError("--count must be >= 1")
+    lyrics_id = None
+    if instrumental and not lyrics:
+        lyrics = "[Instrumental]"
+    if lyrics:
+        job = client.send_tool_call("lyrics__register", {"lyrics": lyrics}, conversation_id=conversation_id,
+                                    model=model)
+        outcome = run_job(client, job, on_progress)
+        conversation_id = outcome.conversation_id or conversation_id
+        for tr in outcome.tool_returns:
+            c = tr.get("content")
+            if isinstance(c, dict) and c.get("lyrics_id"):
+                lyrics_id = c["lyrics_id"]
+        if not lyrics_id:
+            raise GenerationFailed("lyrics__register returned no lyrics_id")
+    job_ids, refs = [], []
+    for _ in range(count):
+        args: dict[str, Any] = {"sound_prompt": sound_prompt}  # the tool rejects a `title` arg
+        if lyrics_id:
+            args["lyrics_id"] = lyrics_id
+        job = client.send_tool_call("audio__create_song", args, conversation_id=conversation_id, model=model)
+        job_ids.append(job)
+        outcome = run_job(client, job, on_progress)
+        conversation_id = outcome.conversation_id or conversation_id
+        if not outcome.clip_refs and outcome.failures:
+            _raise_failure("; ".join(str(f) for f in outcome.failures))
+        refs.extend(outcome.clip_refs)
+    clips = wait_for_clips(client, refs, timeout=timeout, on_progress=on_progress) if refs else []
+    if title:
+        for i, clip in enumerate(clips):
+            t = title if len(clips) == 1 else f"{title} ({i + 1})"
+            try:
+                client.update_clip(clip["id"], title=t)
+                clip["title"] = t
+            except ApiError:
+                pass
+    return GenerationResult(conversation_id=conversation_id, job_ids=job_ids, clips=clips)
+
+
+def upload_audio(
+    client: FlowMusicClient,
+    path,
+    *,
+    remove_vocals: bool = False,
+    timeout: float = 300,
+    on_progress: ProgressFn | None = None,
+) -> dict:
+    """Upload an audio file the way the web app does; returns ``{clip_id, url, ...}``."""
+    emit = on_progress or (lambda k, d: None)
+    up = client.upload_audio(path)
+    clip_id, op_id = up.get("clip_id"), up.get("operation_id")
+    if not clip_id or not op_id:
+        raise ApiError(f"Unexpected upload response: {up}")
+    emit("upload_checking", {"clip_id": clip_id})
+    deadline = time.monotonic() + timeout
+    st: dict = {}
+    while time.monotonic() < deadline:
+        st = client.upload_check_status(clip_id, op_id) or {}
+        if st.get("status") != "pending":
+            break
+        time.sleep(2)
+    if st.get("status") != "complete":
+        raise GenerationFailed(f"Upload check did not complete: {st or 'timeout'}")
+    decision = st.get("decision") or "allowed"
+    reason = st.get("reason")
+    if decision == "allowed":
+        res = client.confirm_upload(clip_id, op_id)
+    elif decision == "requires_vocal_removal" or (st.get("has_vocals") and remove_vocals):
+        # Observed decisions: "allowed", "requires_vocal_removal", "blocked" (e.g. vocals
+        # in a region where vocal uploads are restricted: there removal is refused too).
+        if not remove_vocals:
+            raise Blocked(f"This track can only be used without vocals ({reason or 'vocals detected'}).",
+                          hint="Re-run with --remove-vocals.")
+        emit("removing_vocals", {"clip_id": clip_id})
+        try:
+            res = client.remove_vocals(clip_id, op_id)
+        except (NoAccess, ApiError) as e:
+            raise Blocked(f"Vocal removal was refused: {e.detail}",
+                          hint="Vocal uploads/removal aren't available for your account or region; "
+                               "upload an instrumental instead.") from e
+    else:
+        hint = "Upload an instrumental (no vocals) instead." if st.get("has_vocals") else None
+        if st.get("has_cid_match"):
+            hint = "The track matched existing copyrighted content."
+        raise Blocked(f"Upload rejected: {reason or decision}", hint=hint)
+    return {"clip_id": res.get("clip_id") or clip_id, "url": res.get("url"), "check": st}

flowmusic_cli/api/sse.py

@@ -0,0 +1,49 @@
+"""Minimal Server-Sent-Events parser for ``/messages/{job_id}/stream``."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class SSEEvent:
+    event: str
+    data: Any
+    id: str | None = None
+
+
+def parse_sse(lines: Iterable[str]) -> Iterator[SSEEvent]:
+    event, data_lines, ev_id = "message", [], None
+    for raw in lines:
+        line = raw.rstrip("\r\n")
+        if line == "":
+            if data_lines:
+                text = "\n".join(data_lines)
+                try:
+                    data = json.loads(text)
+                except ValueError:
+                    data = text
+                yield SSEEvent(event=event, data=data, id=ev_id)
+            event, data_lines = "message", []
+            continue
+        if line.startswith(":"):
+            continue  # keep-alive comment (": ping - ...")
+        field, _, value = line.partition(":")
+        if value.startswith(" "):
+            value = value[1:]
+        if field == "event":
+            event = value
+        elif field == "data":
+            data_lines.append(value)
+        elif field == "id":
+            ev_id = value
+    if data_lines:
+        text = "\n".join(data_lines)
+        try:
+            data = json.loads(text)
+        except ValueError:
+            data = text
+        yield SSEEvent(event=event, data=data, id=ev_id)

flowmusic_cli/auth/browser_login.py

@@ -0,0 +1,118 @@
+"""One-time interactive login in a real browser window.
+
+The user signs in with Google on flowmusic.app as usual; we only watch the
+cookie jar until the Supabase session cookie appears, then close the window.
+After that, the CLI never needs a browser again (tokens refresh over HTTP).
+
+The launch flags mirror gflow-cli's measured "stealth set": without them Google
+may flag the automated window and reject the sign-in.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from typing import Any
+
+from flowmusic_cli.auth.session import COOKIE_BASE, Session, decode_cookie_value, join_cookie_chunks
+from flowmusic_cli.errors import LoginFailed
+
+_CHANNELS = ("chrome", "msedge", None)  # None = Playwright's bundled Chromium
+
+
+def _launch_kwargs(profile_dir: Path, channel: str | None) -> dict[str, Any]:
+    return {
+        "user_data_dir": str(profile_dir),
+        "channel": channel,
+        "headless": False,
+        "no_viewport": True,
+        "chromium_sandbox": True,
+        "ignore_default_args": ["--enable-automation"],
+        "args": [
+            "--disable-blink-features=AutomationControlled",
+            "--password-store=basic",
+            "--window-size=1200,900",
+        ],
+    }
+
+
+def browser_login(
+    site_url: str,
+    browser_profile_dir: Path,
+    *,
+    timeout: float = 300,
+    channel: str | None = "auto",
+    on_status=lambda msg: None,
+    validate=None,
+) -> Session:
+    """Return a session once one is found and ``validate(session)`` accepts it.
+
+    ``validate`` should exchange the refresh token (returning the fresh session)
+    or raise. A profile reused from an earlier login may still hold a cookie
+    whose refresh token the CLI has since rotated; such a stale session is
+    discarded and the user is asked to sign in again.
+    """
+    try:
+        from playwright.sync_api import Error as PlaywrightError
+        from playwright.sync_api import sync_playwright
+    except ImportError as e:  # pragma: no cover
+        raise LoginFailed("Playwright is not installed.", hint="pip install playwright") from e
+
+    browser_profile_dir.mkdir(parents=True, exist_ok=True)
+    channels = _CHANNELS if channel == "auto" else (channel,)
+
+    with sync_playwright() as p:
+        ctx = None
+        last_err: Exception | None = None
+        for ch in channels:
+            try:
+                ctx = p.chromium.launch_persistent_context(**_launch_kwargs(browser_profile_dir, ch))
+                on_status(f"Opened {ch or 'bundled Chromium'}.")
+                break
+            except PlaywrightError as e:
+                last_err = e
+        if ctx is None:
+            raise LoginFailed(
+                f"Could not start a browser ({last_err}).",
+                hint="Install Google Chrome, or run `playwright install chromium`.",
+            )
+        try:
+            page = ctx.pages[0] if ctx.pages else ctx.new_page()
+            page.goto(site_url, wait_until="domcontentloaded")
+            on_status("Sign in with Google in the browser window (this window closes by itself).")
+            deadline = time.monotonic() + timeout
+            while time.monotonic() < deadline:
+                # All domains: the auth callback may set the cookie on the apex or www host.
+                jar = {c["name"]: c["value"] for c in ctx.cookies()
+                       if c["name"].startswith(COOKIE_BASE) and "flowmusic" in c.get("domain", "")}
+                joined = join_cookie_chunks(jar)
+                session = None
+                if joined:
+                    try:
+                        data = decode_cookie_value(joined)
+                        if data.get("access_token") and data.get("refresh_token"):
+                            session = Session.from_dict(data)
+                    except ValueError:
+                        pass  # chunks still being written
+                if session is not None:
+                    if validate is None:
+                        return session
+                    try:
+                        return validate(session)
+                    except Exception as e:  # stale/revoked: start over
+                        on_status(f"Stored browser session is no longer valid ({e}); please sign in again.")
+                        try:
+                            ctx.clear_cookies(domain=re.compile(r"flowmusic\.app$"))
+                        except TypeError:  # older Playwright
+                            ctx.clear_cookies()
+                        page.goto(site_url, wait_until="domcontentloaded")
+                if not ctx.pages:
+                    raise LoginFailed("The browser window was closed before sign-in completed.")
+                time.sleep(1.0)
+            raise LoginFailed(f"No sign-in detected within {int(timeout)}s.")
+        finally:
+            try:
+                ctx.close()
+            except Exception:
+                pass