gflow-cli 0.2.0a1__py3-none-any.whl

flow_cli/auth.py

@@ -0,0 +1,87 @@
+"""Auth — capture/refresh Google session via Playwright persistent context.
+
+Sessions live under `Settings.home / profile_<name>/`. Default location is
+the OS-native user-data-dir (via `platformdirs`):
+
+  * Windows: `%LOCALAPPDATA%\\flow-cli\\profile_<name>`
+  * macOS:   `~/Library/Application Support/flow-cli/profile_<name>`
+  * Linux:   `~/.local/share/flow-cli/profile_<name>` (XDG)
+
+Override the root with `FLOW_CLI_HOME`. See `docs/AUTHENTICATION.md`.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from playwright.async_api import async_playwright
+
+from flow_cli.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+GEMINI_URL = "https://labs.google/fx/tools/flow?hl=en"
+
+
+def default_profile_root() -> Path:
+    """Root dir under which `profile_<name>/` subdirectories live.
+
+    Returns `Settings.home`. Reads env via `get_settings()` so changes to
+    `FLOW_CLI_HOME` after import are honoured (provided the cache is reset).
+    """
+    return get_settings().home
+
+
+def profile_dir(name: str = "default") -> Path:
+    return get_settings().profile_subdir(name)
+
+
+async def login(name: str = "default") -> Path:
+    """Open a HEADED Chromium window, let user sign into Google, persist session.
+
+    Returns the profile directory path. On subsequent runs the saved cookies
+    are reused; if Google's session expires, calling this again re-captures it.
+    """
+    pdir = profile_dir(name)
+    pdir.mkdir(parents=True, exist_ok=True)
+    logger.info("login: launching browser, profile=%s", pdir)
+    async with async_playwright() as pw:
+        ctx = await pw.chromium.launch_persistent_context(
+            user_data_dir=str(pdir),
+            headless=False,
+            viewport={"width": 1280, "height": 800},
+        )
+        try:
+            page = ctx.pages[0] if ctx.pages else await ctx.new_page()
+            await page.goto(GEMINI_URL, wait_until="domcontentloaded", timeout=60_000)
+            print(
+                "\n  Sign into your Google account in the open window.\n"
+                "  Once you reach the Flow editor, close the window to save the session.\n"
+            )
+            try:
+                await ctx.wait_for_event("close", timeout=600_000)  # pyright: ignore[reportUnknownMemberType]
+            except Exception:
+                pass
+        finally:
+            try:
+                await ctx.close()
+            except Exception:
+                pass
+    return pdir
+
+
+def status(name: str = "default") -> dict[str, object]:
+    """Lightweight check — does the profile dir exist and have cookies file?"""
+    pdir = profile_dir(name)
+    cookies_file: Path | None = None
+    for candidate in (pdir / "Default" / "Cookies", pdir / "Cookies"):
+        if candidate.exists():
+            cookies_file = candidate
+            break
+    return {
+        "profile": str(pdir),
+        "exists": pdir.exists(),
+        "cookies_present": cookies_file is not None,
+        "cookies_path": str(cookies_file) if cookies_file else None,
+    }

flow_cli/cli.py

@@ -0,0 +1,184 @@
+"""CLI entry point — Click app exposing the gflow commands."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from flow_cli import __version__, profile_store
+from flow_cli import auth as auth_mod
+from flow_cli.cli_video import video as _video_group
+
+console = Console()
+
+
+def _render_profiles_table(profiles: list[profile_store.ProfileMeta]) -> None:
+    """Pretty-print the profile inventory."""
+    if not profiles:
+        console.print("[yellow]No profiles found.[/yellow]")
+        return
+    root = auth_mod.default_profile_root()
+    console.print(f"\n[bold]Profiles in[/bold] {root}\n")
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Default", justify="center")
+    table.add_column("Name", style="bold")
+    table.add_column("Session")
+    table.add_column("Last used (UTC)")
+    table.add_column("Profile dir", overflow="fold")
+    for p in profiles:
+        marker = "[bold green]●[/bold green]" if p.is_default else ""
+        session = "[green]present[/green]" if p.cookies_present else "[red]missing[/red]"
+        last = p.last_used_at.strftime("%Y-%m-%d %H:%M:%S") if p.last_used_at else "-"
+        table.add_row(marker, p.name, session, last, str(p.profile_dir))
+    console.print(table)
+    console.print("\nUse [bold]gflow auth use <name>[/bold] to set the default profile.")
+    console.print(
+        "Use [bold]gflow auth login --profile <name>[/bold] to add or refresh a profile.\n"
+    )
+
+
+@click.group()
+@click.version_option(__version__, "-V", "--version")
+@click.option("--verbose", "-v", is_flag=True, help="Verbose logging.")
+@click.pass_context
+def main(ctx: click.Context, verbose: bool) -> None:
+    """gflow — drive Google Flow Veo I2V from the terminal."""
+    logging.basicConfig(
+        level=logging.DEBUG if verbose else logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    )
+    ctx.ensure_object(dict)
+
+
+# --- auth -------------------------------------------------------------------
+
+
+@main.group(invoke_without_command=True)
+@click.pass_context
+def auth(ctx: click.Context) -> None:
+    """Manage Google sessions for Flow.
+
+    Bare `gflow auth` shows the profile inventory. If no profiles exist yet,
+    it kicks off `gflow auth login` automatically.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+    profiles = profile_store.list_profiles()
+    if not profiles:
+        console.print("[yellow]No profiles found.[/yellow] Launching first-time login...\n")
+        ctx.invoke(auth_login)
+        return
+    _render_profiles_table(profiles)
+
+
+@auth.command("login")
+@click.option(
+    "--profile",
+    default=None,
+    help="Profile name. Defaults to the resolved default (env > config > auto).",
+)
+def auth_login(profile: str | None) -> None:
+    """One-time interactive sign-in. Opens a browser window."""
+    name = profile or _resolve_or_prompt(default_for_first_run="default")
+    pdir = asyncio.run(auth_mod.login(name))
+    console.print(f"[green]Session saved.[/green] Profile dir: {pdir}")
+    # If this was the very first profile, set it as default automatically so
+    # subsequent commands work without explicit --profile / FLOW_CLI_PROFILE.
+    profiles = profile_store.list_profiles()
+    if len(profiles) == 1:
+        profile_store.set_default_profile(profiles[0].name)
+        console.print(f"[dim]Set [bold]{profiles[0].name}[/bold] as default profile.[/dim]")
+
+
+@auth.command("status")
+@click.option("--profile", default=None)
+def auth_status(profile: str | None) -> None:
+    """Show whether a specific profile has a saved session."""
+    name = profile or _resolve_or_exit()
+    s = auth_mod.status(name)
+    if s["exists"] and s["cookies_present"]:
+        console.print(f"[green]Profile '{name}' is configured.[/green]")
+    else:
+        console.print(
+            f"[yellow]Profile '{name}' has no session.[/yellow] "
+            f"Run [bold]gflow auth login --profile {name}[/bold]."
+        )
+    for k, v in s.items():
+        console.print(f"  {k}: {v}")
+
+
+@auth.command("list")
+def auth_list() -> None:
+    """List every profile and indicate the current default."""
+    profiles = profile_store.list_profiles()
+    _render_profiles_table(profiles)
+
+
+@auth.command("use")
+@click.argument("name")
+def auth_use(name: str) -> None:
+    """Set NAME as the default profile."""
+    try:
+        cfg = profile_store.set_default_profile(name)
+    except FileNotFoundError as e:
+        console.print(f"[red]{e}[/red]")
+        sys.exit(2)
+    console.print(
+        f"[green]Default profile set to[/green] [bold]{name}[/bold]\n[dim]Persisted in {cfg}[/dim]"
+    )
+
+
+@auth.command("logout")
+@click.option("--profile", default=None)
+@click.option("--yes", "-y", is_flag=True, help="Skip the confirmation prompt.")
+def auth_logout(profile: str | None, yes: bool) -> None:
+    """Delete a profile's saved session (irreversible)."""
+    name = profile or _resolve_or_exit()
+    if not yes:
+        click.confirm(
+            f"Delete profile '{name}' and all cookies/state?",
+            abort=True,
+        )
+    try:
+        deleted = profile_store.delete_profile(name)
+    except FileNotFoundError as e:
+        console.print(f"[red]{e}[/red]")
+        sys.exit(2)
+    console.print(f"[yellow]Profile '{name}' removed.[/yellow]\n[dim]Deleted dir: {deleted}[/dim]")
+
+
+def _resolve_or_exit() -> str:
+    """Resolve the active profile or print a friendly error and exit."""
+    try:
+        return profile_store.resolve_profile(None)
+    except profile_store.NoProfilesError as e:
+        console.print(f"[yellow]{e}[/yellow]")
+        sys.exit(2)
+    except profile_store.NoDefaultProfileError as e:
+        console.print(f"[yellow]{e}[/yellow]")
+        sys.exit(2)
+
+
+def _resolve_or_prompt(default_for_first_run: str) -> str:
+    """Like _resolve_or_exit but for `auth login` — accept any name to create."""
+    try:
+        return profile_store.resolve_profile(None)
+    except profile_store.NoProfilesError:
+        return default_for_first_run
+    except profile_store.NoDefaultProfileError:
+        return click.prompt(
+            "Multiple profiles exist; pick a name to login or refresh",
+            default=default_for_first_run,
+        )
+
+
+main.add_command(_video_group)
+
+
+if __name__ == "__main__":
+    main()

flow_cli/cli_video.py

@@ -0,0 +1,322 @@
+"""`gflow video` command group — t2v subcommand (text-to-video).
+
+Helper functions `_resolve_profile` and `_make_provider_dir` are thin wrappers
+over the same profile/auth machinery used by the rest of cli.py, kept as
+named module-level functions so the test suite can patch them cleanly.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from flow_cli import auth as auth_mod
+from flow_cli import profile_store
+from flow_cli.api.client import FlowApiClient
+from flow_cli.api.video import Aspect, GenerateVideoRequest
+from flow_cli.config import get_settings
+from flow_cli.manifest import ManifestEntry, parse_manifest
+from flow_cli.paths import video_output_path
+
+console = Console()
+
+# Terminal statuses that end the polling loop.
+_TERMINAL = frozenset(
+    [
+        "MEDIA_GENERATION_STATUS_COMPLETED",
+        "MEDIA_GENERATION_STATUS_FAILED",
+    ]
+)
+
+
+def _resolve_profile(profile: str | None) -> str:
+    """Return the active profile name or exit with a friendly message."""
+    if profile:
+        return profile
+    try:
+        return profile_store.resolve_profile(None)
+    except profile_store.NoProfilesError as exc:
+        console.print(f"[yellow]{exc}[/yellow]")
+        sys.exit(2)
+    except profile_store.NoDefaultProfileError as exc:
+        console.print(f"[yellow]{exc}[/yellow]")
+        sys.exit(2)
+
+
+def _make_provider_dir(profile_name: str) -> Path:
+    """Return the Playwright profile dir for *profile_name*, or exit if absent."""
+    pdir = auth_mod.profile_dir(profile_name)
+    if not pdir.exists():
+        console.print(
+            f"[red]No session for profile '{profile_name}'.[/red] "
+            "Run [bold]gflow auth login[/bold] first."
+        )
+        sys.exit(2)
+    return pdir
+
+
+# ---------------------------------------------------------------------------
+# Click group
+# ---------------------------------------------------------------------------
+
+
+@click.group()
+def video() -> None:
+    """Generate and manage videos via Google Flow Veo."""
+
+
+# ---------------------------------------------------------------------------
+# t2v subcommand
+# ---------------------------------------------------------------------------
+
+
+@video.command("t2v")
+@click.argument("prompt")
+@click.option(
+    "-o",
+    "--output",
+    "output",
+    default=None,
+    type=click.Path(path_type=Path),
+    help="Where to save the mp4. Defaults to <output_dir>/videos/<date>/<media>.mp4.",
+)
+@click.option(
+    "--aspect",
+    default="9:16",
+    show_default=True,
+    type=click.Choice(["9:16", "16:9", "1:1"]),
+    help="Video aspect ratio.",
+)
+@click.option("--seed", default=None, type=int, help="RNG seed for reproducibility.")
+@click.option("--profile", default=None, help="Profile name (overrides default).")
+@click.option(
+    "--poll-interval",
+    default=5.0,
+    show_default=True,
+    type=float,
+    help="Seconds between status polls.",
+)
+def t2v(
+    prompt: str,
+    output: Path | None,
+    aspect: str,
+    seed: int | None,
+    profile: str | None,
+    poll_interval: float,
+) -> None:
+    """Generate a video from PROMPT (text-to-video)."""
+    profile_name = _resolve_profile(profile)
+    provider_dir = _make_provider_dir(profile_name)
+    settings = get_settings()
+    asyncio.run(
+        _run_t2v(
+            profile_dir=provider_dir,
+            headless=settings.headless,
+            prompt=prompt,
+            output=output,
+            aspect=Aspect.from_cli(aspect),
+            seed=seed,
+            poll_interval=poll_interval,
+            output_root=settings.output_dir,
+        )
+    )
+
+
+async def _run_t2v(
+    *,
+    profile_dir: Path,
+    headless: bool,
+    prompt: str,
+    output: Path | None,
+    aspect: Aspect,
+    seed: int | None,
+    poll_interval: float,
+    output_root: Path,
+) -> None:
+    async with FlowApiClient(profile_dir=profile_dir, headless=headless) as client:
+        console.print("  Creating project...")
+        project = await client.create_project()
+        console.print(f"  Project: {project.project_id}")
+        req = GenerateVideoRequest(prompt=prompt, aspect=aspect)
+        console.print("  Submitting generation...")
+        op = await client.generate_video(project_id=project.project_id, req=req, seed=seed)
+        console.print(f"  Operation: {op.operation_name}")
+        await _poll_and_download(
+            client=client,
+            project_id=project.project_id,
+            media_name=op.media_name,
+            output=output or video_output_path(output_root, job_id=op.media_name),
+            poll_interval=poll_interval,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Shared polling helper
+# ---------------------------------------------------------------------------
+
+
+async def _poll_and_download(
+    *,
+    client: FlowApiClient,
+    project_id: str,
+    media_name: str,
+    output: Path,
+    poll_interval: float,
+) -> None:
+    """Poll until terminal status, then download the result to *output*."""
+    while True:
+        statuses = await client.get_video_status(project_id, [media_name])
+        if not statuses:
+            console.print("[red]No status returned from API.[/red]")
+            sys.exit(1)
+        st = statuses[0]
+        console.print(f"  Status: {st.status}")
+        if st.status in _TERMINAL:
+            break
+        await asyncio.sleep(poll_interval)
+
+    if not st.succeeded:
+        console.print(f"[red]Generation failed (status={st.status}).[/red]")
+        sys.exit(1)
+
+    saved = await client.download(media_name, output)
+    console.print(f"[green]Saved[/green] {saved}")
+
+
+# ---------------------------------------------------------------------------
+# i2v subcommand
+# ---------------------------------------------------------------------------
+
+
+@video.command("i2v")
+@click.argument("image", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.argument("prompt")
+@click.option("-o", "--output", type=click.Path(path_type=Path), default=None)
+@click.option("--aspect", type=click.Choice(["9:16", "16:9", "1:1"]), default="9:16")
+@click.option("--seed", type=int, default=None)
+@click.option("--profile", default=None)
+@click.option("--poll-interval", type=float, default=5.0)
+def i2v(
+    image: Path,
+    prompt: str,
+    output: Path | None,
+    aspect: str,
+    seed: int | None,
+    profile: str | None,
+    poll_interval: float,
+) -> None:
+    """Generate a video from a START IMAGE + text prompt."""
+    profile_name = _resolve_profile(profile)
+    pdir = _make_provider_dir(profile_name)
+    settings = get_settings()
+    asyncio.run(
+        _run_i2v(
+            profile_dir=pdir,
+            headless=settings.headless,
+            image=image,
+            prompt=prompt,
+            output=output,
+            aspect=Aspect.from_cli(aspect),
+            seed=seed,
+            poll_interval=poll_interval,
+            output_root=settings.output_dir,
+        )
+    )
+
+
+async def _run_i2v(
+    *,
+    profile_dir: Path,
+    headless: bool,
+    image: Path,
+    prompt: str,
+    output: Path | None,
+    aspect: Aspect,
+    seed: int | None,
+    poll_interval: float,
+    output_root: Path,
+) -> None:
+    async with FlowApiClient(profile_dir=profile_dir, headless=headless) as client:
+        console.print("  Creating project...")
+        project = await client.create_project()
+        console.print(f"  Uploading {image.name}...")
+        asset = await client.upload_image(project.project_id, image)
+        console.print(f"  Asset: [dim]{asset.name}[/dim]")
+        req = GenerateVideoRequest(prompt=prompt, aspect=aspect, start_asset_uuid=asset.name)
+        console.print("  Submitting generation...")
+        op = await client.generate_video(project_id=project.project_id, req=req, seed=seed)
+        await _poll_and_download(
+            client=client,
+            project_id=project.project_id,
+            media_name=op.media_name,
+            output=output or video_output_path(output_root, job_id=op.media_name),
+            poll_interval=poll_interval,
+        )
+
+
+# ---------------------------------------------------------------------------
+# batch subcommand
+# ---------------------------------------------------------------------------
+
+
+@video.command("batch")
+@click.argument("manifest", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--out-dir", type=click.Path(path_type=Path), default=None)
+@click.option("--profile", default=None)
+@click.option("--poll-interval", type=float, default=5.0, show_default=True)
+def batch(
+    manifest: Path,
+    out_dir: Path | None,
+    profile: str | None,
+    poll_interval: float,
+) -> None:
+    """Run a TSV manifest of video generations."""
+    profile_name = _resolve_profile(profile)
+    pdir = _make_provider_dir(profile_name)
+    settings = get_settings()
+    entries = parse_manifest(manifest)
+    out_root = out_dir or settings.output_dir
+    asyncio.run(
+        _run_batch(
+            profile_dir=pdir,
+            headless=settings.headless,
+            entries=entries,
+            out_root=out_root,
+            poll_interval=poll_interval,
+        )
+    )
+
+
+async def _run_batch(
+    *,
+    profile_dir: Path,
+    headless: bool,
+    entries: list[ManifestEntry],
+    out_root: Path,
+    poll_interval: float,
+) -> None:
+    async with FlowApiClient(profile_dir=profile_dir, headless=headless) as client:
+        console.print(f"  Creating project for {len(entries)} clips...")
+        project = await client.create_project()
+        for i, e in enumerate(entries, start=1):
+            console.print(f"  [{i}/{len(entries)}] [bold]{e.prompt[:60]}[/bold]")
+            start_uuid = None
+            if e.start_image:
+                asset = await client.upload_image(project.project_id, e.start_image)
+                start_uuid = asset.name
+            req = GenerateVideoRequest(
+                prompt=e.prompt, aspect=e.aspect, start_asset_uuid=start_uuid
+            )
+            op = await client.generate_video(project_id=project.project_id, req=req)
+            output = e.output_path or video_output_path(out_root, job_id=op.media_name)
+            await _poll_and_download(
+                client=client,
+                project_id=project.project_id,
+                media_name=op.media_name,
+                output=output,
+                poll_interval=poll_interval,
+            )