cited-cli 0.3.2__py3-none-any.whl

cited_cli/commands/auth.py

@@ -0,0 +1,353 @@
+from __future__ import annotations
+
+import sys
+from typing import Annotated
+
+import typer
+
+from cited_cli.output.formatter import OutputContext, print_error, print_result, print_success
+from cited_cli.output.tables import render_kv
+from cited_cli.utils.errors import CitedAPIError, ExitCode, handle_api_error
+from cited_cli.utils.interactive import is_interactive
+from cited_core.api import endpoints
+from cited_core.api.client import CitedClient
+from cited_core.auth.store import TokenStore
+from cited_core.config.constants import DEFAULT_ENV, FRONTEND_URLS
+from cited_core.config.manager import ConfigManager
+
+auth_app = typer.Typer(name="auth", help="Authentication commands.")
+
+_VALID_PROVIDERS = ("google", "microsoft", "github")
+
+
+def _get_ctx(ctx: typer.Context) -> tuple[OutputContext, ConfigManager, str]:
+    obj = ctx.obj or {}
+    out = obj.get("output", OutputContext())
+    cfg = obj.get("config", ConfigManager())
+    env = cfg.get_environment(
+        profile=obj.get("profile", "default"),
+        override=obj.get("env_override"),
+    )
+    return out, cfg, env
+
+
+def _get_api_url(ctx: typer.Context, cfg: ConfigManager) -> str:
+    obj = ctx.obj or {}
+    return cfg.get_api_url(
+        profile=obj.get("profile", "default"),
+        env_override=obj.get("env_override"),
+    )
+
+
+def _password_login(out: OutputContext, api_url: str, env: str, email: str, password: str) -> None:
+    client = CitedClient(base_url=api_url)
+    try:
+        response = client.post(endpoints.CLI_LOGIN, json={"email": email, "password": password})
+        token = response["token"]
+
+        store = TokenStore()
+        store.save_token(env, token)
+        print_success(f"Logged in to {env} as {email}", out)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+def _browser_auth(
+    out: OutputContext, api_url: str, env: str, provider: str | None = None,
+    *, mode: str = "login",
+) -> None:
+    import webbrowser
+
+    from cited_cli.auth.oauth_server import OAuthCallbackServer
+
+    server = OAuthCallbackServer(timeout=120)
+    server.start()
+
+    client = CitedClient(base_url=api_url)
+    try:
+        payload: dict[str, str] = {"redirect_uri": server.redirect_uri, "mode": mode}
+        if provider:
+            payload["provider"] = provider
+
+        response = client.post(endpoints.CLI_OAUTH_START, json=payload)
+        auth_url = response["auth_url"]
+
+        action = "registration" if mode == "register" else "login"
+        label = f"{provider} {action}" if provider else action
+        out.console.print(f"Opening browser for {label}...")
+        if not webbrowser.open(auth_url):
+            out.console.print(
+                f"\nCould not open browser. Visit this URL manually:\n{auth_url}"
+            )
+        out.console.print("[dim]Waiting for authentication...[/dim]")
+
+        token = server.wait_for_token()
+        if not token:
+            # Paste fallback for environments where localhost callback fails
+            if is_interactive():
+                out.console.print(
+                    "\n[yellow]Browser callback timed out.[/yellow]\n"
+                    "If you completed login in the browser, copy the token shown\n"
+                    "on the success page and paste it below.\n"
+                )
+                pasted = typer.prompt("Paste token (or press Enter to cancel)", default="")
+                if pasted.strip():
+                    token = pasted.strip()
+                else:
+                    print_error("Authentication cancelled.", out)
+                    raise typer.Exit(ExitCode.AUTH_ERROR)
+            else:
+                print_error("Authentication timed out. Please try again.", out)
+                raise typer.Exit(ExitCode.AUTH_ERROR)
+
+        store = TokenStore()
+        store.save_token(env, token)
+        via = f" via {provider}" if provider else ""
+        success_msg = "Registered" if mode == "register" else "Logged in"
+        print_success(f"{success_msg} on {env}{via}", out)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        server.shutdown()
+        client.close()
+
+
+def _password_register(
+    out: OutputContext, api_url: str, env: str, name: str, email: str, password: str,
+) -> None:
+    from urllib.parse import parse_qs, urlparse
+
+    client = CitedClient(base_url=api_url)
+    try:
+        response = client.post(
+            endpoints.CLI_REGISTER,
+            json={"name": name, "email": email, "password": password},
+        )
+        msg = response["message"]
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+        return
+    finally:
+        client.close()
+
+    print_success(f"Account created for {email} on {env}", out)
+    out.console.print(f"[dim]{msg}[/dim]")
+
+    out.console.print("\n[bold]Paste your verification link from the email:[/bold]")
+    verify_url = typer.prompt("Verification URL").strip()
+
+    parsed = urlparse(verify_url)
+    params = parse_qs(parsed.query)
+    token = params.get("token", [None])[0]
+    if not token:
+        print_error(
+            "Could not find token in URL. Run `cited login` after verifying in browser.",
+            out,
+        )
+        raise typer.Exit(1)
+
+    client = CitedClient(base_url=api_url)
+    try:
+        verify_response = client.post(
+            endpoints.CLI_VERIFY_EMAIL,
+            json={"token": token},
+        )
+        jwt = verify_response["token"]
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+        return
+    finally:
+        client.close()
+
+    store = TokenStore()
+    store.save_token(env, jwt)
+    print_success(f"Email verified! Logged in as {email}", out)
+
+    frontend_url = FRONTEND_URLS.get(env, FRONTEND_URLS[DEFAULT_ENV])
+    out.console.print(f"[dim]→ Complete your account setup at {frontend_url}/onboarding[/dim]")
+
+
+def do_login(
+    ctx: typer.Context,
+    email: str | None = None,
+    password: str | None = None,
+    provider: str | None = None,
+) -> None:
+    """Shared login logic for both `cited login` and `cited auth login`."""
+    out, cfg, env = _get_ctx(ctx)
+    api_url = _get_api_url(ctx, cfg)
+
+    if provider and provider not in _VALID_PROVIDERS:
+        print_error(
+            f"Invalid provider '{provider}'. "
+            f"Must be one of: {', '.join(_VALID_PROVIDERS)}",
+            out,
+        )
+        raise typer.Exit(ExitCode.VALIDATION_ERROR)
+
+    if email:
+        if password is None:
+            if not is_interactive():
+                print_error(
+                    "Non-interactive mode requires --email and --password", out
+                )
+                raise typer.Exit(ExitCode.VALIDATION_ERROR)
+            password = typer.prompt("Password", hide_input=True)
+        _password_login(out, api_url, env, email, password)
+    else:
+        # Browser login — works in both TTY and non-TTY contexts.
+        # The browser opens independently and the localhost callback
+        # server receives the token without needing stdin.
+        _browser_auth(out, api_url, env, provider, mode="login")
+
+
+def do_logout(ctx: typer.Context) -> None:
+    """Shared logout logic for both `cited logout` and `cited auth logout`."""
+    out, cfg, env = _get_ctx(ctx)
+    store = TokenStore()
+
+    if not store.has_token(env):
+        print_error(f"Not logged in to {env}", out)
+        raise typer.Exit(ExitCode.ERROR)
+
+    store.delete_token(env)
+    print_success(f"Logged out of {env}", out)
+
+
+def do_register(
+    ctx: typer.Context,
+    email: str | None = None,
+    name: str | None = None,
+    password: str | None = None,
+    provider: str | None = None,
+) -> None:
+    """Shared register logic for both `cited register` and `cited auth register`."""
+    out, cfg, env = _get_ctx(ctx)
+    api_url = _get_api_url(ctx, cfg)
+
+    if provider and provider not in _VALID_PROVIDERS:
+        print_error(
+            f"Invalid provider '{provider}'. "
+            f"Must be one of: {', '.join(_VALID_PROVIDERS)}",
+            out,
+        )
+        raise typer.Exit(ExitCode.VALIDATION_ERROR)
+
+    if email:
+        if name is None:
+            if not is_interactive():
+                print_error("Non-interactive mode requires --name", out)
+                raise typer.Exit(ExitCode.VALIDATION_ERROR)
+            name = typer.prompt("Full name")
+        if password is None:
+            if not is_interactive():
+                print_error("Non-interactive mode requires --password", out)
+                raise typer.Exit(ExitCode.VALIDATION_ERROR)
+            password = typer.prompt("Password", hide_input=True)
+            confirm = typer.prompt("Confirm password", hide_input=True)
+            if password != confirm:
+                print_error("Passwords do not match.", out)
+                raise typer.Exit(ExitCode.VALIDATION_ERROR)
+        _password_register(out, api_url, env, name, email, password)
+    else:
+        _browser_auth(out, api_url, env, provider, mode="register")
+
+
+@auth_app.command()
+def login(
+    ctx: typer.Context,
+    email: Annotated[str | None, typer.Option(help="Email address")] = None,
+    password: Annotated[
+        str | None, typer.Option(help="Password", hide_input=True)
+    ] = None,
+    provider: Annotated[
+        str | None,
+        typer.Option(help="OAuth provider: google, microsoft, github"),
+    ] = None,
+) -> None:
+    """Log in to Cited. Opens browser by default, or use --email for password login."""
+    do_login(ctx, email, password, provider)
+
+
+@auth_app.command()
+def logout(ctx: typer.Context) -> None:
+    """Log out and clear stored credentials."""
+    do_logout(ctx)
+
+
+@auth_app.command()
+def register(
+    ctx: typer.Context,
+    email: Annotated[str | None, typer.Option(help="Email address")] = None,
+    name: Annotated[str | None, typer.Option(help="Full name")] = None,
+    password: Annotated[
+        str | None, typer.Option(help="Password", hide_input=True)
+    ] = None,
+    provider: Annotated[
+        str | None,
+        typer.Option(help="OAuth provider: google, microsoft, github"),
+    ] = None,
+) -> None:
+    """Register a new Cited account. Opens browser or use --email."""
+    do_register(ctx, email, name, password, provider)
+
+
+@auth_app.command()
+def status(ctx: typer.Context) -> None:
+    """Show current authentication status and user info."""
+    out, cfg, env = _get_ctx(ctx)
+    store = TokenStore()
+    token = store.get_token(env)
+
+    if not token:
+        print_error(f"Not logged in to {env}. Run: cited login", out)
+        raise typer.Exit(ExitCode.AUTH_ERROR)
+
+    api_url = _get_api_url(ctx, cfg)
+    client = CitedClient(base_url=api_url, token=token)
+    try:
+        user = client.get(endpoints.ME)
+        onboarding_completed = user.get("onboarding_completed", False)
+        data = {
+            "environment": env,
+            "email": user.get("email", ""),
+            "name": user.get("name", user.get("full_name", "")),
+            "plan": user.get("plan", user.get("subscription_tier", "")),
+            "onboarding_completed": onboarding_completed,
+        }
+        print_result(
+            data,
+            out,
+            human_formatter=lambda d, c: render_kv("Auth Status", d, c),
+        )
+        if not onboarding_completed and not out.json_mode:
+            frontend_url = FRONTEND_URLS.get(env, FRONTEND_URLS[DEFAULT_ENV])
+            out.console.print(
+                f"[yellow]→ Account setup incomplete. "
+                f"Visit {frontend_url}/onboarding to finish.[/yellow]"
+            )
+    except CitedAPIError as e:
+        if e.status_code in (401, 403):
+            store.delete_token(env)
+            print_error("Session expired. Run: cited login", out)
+            raise typer.Exit(ExitCode.AUTH_ERROR) from e
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@auth_app.command()
+def token(ctx: typer.Context) -> None:
+    """Print the raw JWT token (for piping to other tools)."""
+    out, cfg, env = _get_ctx(ctx)
+    store = TokenStore()
+    t = store.get_token(env)
+
+    if not t:
+        print_error(f"Not logged in to {env}", out)
+        raise typer.Exit(ExitCode.AUTH_ERROR)
+
+    # Always print raw token to stdout, even in JSON mode
+    sys.stdout.write(t + "\n")

cited_cli/commands/business.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cited_cli.output.formatter import OutputContext, print_error, print_result, print_success
+from cited_cli.output.tables import render_bar, render_kv, render_table
+from cited_cli.utils.errors import CitedAPIError, ExitCode, handle_api_error
+from cited_cli.utils.interactive import can_prompt, prompt_choice, prompt_if_missing
+from cited_core.api import endpoints
+from cited_core.api.client import CitedClient
+from cited_core.auth.store import TokenStore
+from cited_core.config.constants import VALID_INDUSTRIES
+from cited_core.config.manager import ConfigManager
+
+business_app = typer.Typer(name="business", help="Manage businesses.")
+
+
+def _get_client(ctx: typer.Context) -> tuple[OutputContext, CitedClient, str]:
+    obj = ctx.obj or {}
+    out: OutputContext = obj.get("output", OutputContext())
+    cfg: ConfigManager = obj.get("config", ConfigManager())
+    profile = obj.get("profile", "default")
+    env = cfg.get_environment(profile, obj.get("env_override"))
+    api_url = cfg.get_api_url(profile, obj.get("env_override"))
+
+    store = TokenStore()
+    token = store.get_token(env)
+    if not token:
+        print_error(f"Not logged in to {env}. Run: cited login", out)
+        raise typer.Exit(ExitCode.AUTH_ERROR)
+
+    return out, CitedClient(base_url=api_url, token=token), env
+
+
+@business_app.command("list")
+def business_list(ctx: typer.Context) -> None:
+    """List all businesses."""
+    out, client, _ = _get_client(ctx)
+    try:
+        data = client.get(endpoints.BUSINESSES)
+        businesses = (
+            data if isinstance(data, list)
+            else data.get("businesses", data.get("items", [data]))
+        )
+
+        def _human(d: object, console: Console) -> None:
+            items = d if isinstance(d, list) else []
+            rows = []
+            for b in items:
+                rows.append([
+                    b.get("id", "")[:8],
+                    b.get("name", ""),
+                    b.get("website", ""),
+                    b.get("industry", ""),
+                ])
+            render_table("Businesses", ["ID", "Name", "Website", "Industry"], rows, console)
+
+        print_result(businesses, out, human_formatter=_human)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@business_app.command("get")
+def business_get(
+    ctx: typer.Context,
+    business_id: Annotated[str, typer.Argument(help="Business ID")],
+) -> None:
+    """Get business details."""
+    out, client, _ = _get_client(ctx)
+    try:
+        path = endpoints.BUSINESS.format(business_id=business_id)
+        data = client.get(path)
+        print_result(
+            data,
+            out,
+            human_formatter=lambda d, c: render_kv(
+                d.get("name", "Business"),
+                {k: v for k, v in d.items() if v is not None and k != "id"},
+                c,
+            ),
+        )
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@business_app.command("create")
+def business_create(
+    ctx: typer.Context,
+    name: Annotated[str | None, typer.Option(help="Business name")] = None,
+    website: Annotated[str | None, typer.Option(help="Business website URL")] = None,
+    description: Annotated[
+        str | None, typer.Option(help="Business description (min 50 chars)")
+    ] = None,
+    industry: Annotated[str | None, typer.Option(help="Industry")] = None,
+) -> None:
+    """Create a new business."""
+    out, client, _ = _get_client(ctx)
+    name = prompt_if_missing(name, "--name", "Business name", out)
+    website = prompt_if_missing(website, "--website", "Website URL", out)
+    description = prompt_if_missing(description, "--description", "Description (min 50 chars)", out)
+    if industry is None and can_prompt(out):
+        industry = prompt_choice(industry, "--industry", "Select industry:", VALID_INDUSTRIES, out)
+    try:
+        payload: dict[str, str] = {"name": name, "website": website, "description": description}
+        if industry:
+            payload["industry"] = industry
+        data = client.post(endpoints.BUSINESSES, json=payload)
+        print_result(data, out, human_formatter=lambda d, c: render_kv("Created Business", d, c))
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@business_app.command("update")
+def business_update(
+    ctx: typer.Context,
+    business_id: Annotated[str, typer.Argument(help="Business ID")],
+    name: Annotated[str | None, typer.Option(help="New name")] = None,
+    website: Annotated[str | None, typer.Option(help="New website")] = None,
+    industry: Annotated[str | None, typer.Option(help="New industry")] = None,
+) -> None:
+    """Update a business."""
+    out, client, _ = _get_client(ctx)
+    try:
+        payload: dict[str, str] = {}
+        if name is not None:
+            payload["name"] = name
+        if website is not None:
+            payload["website"] = website
+        if industry is not None:
+            payload["industry"] = industry
+        if not payload:
+            print_error("No fields to update. Use --name, --website, or --industry.", out)
+            raise typer.Exit(ExitCode.VALIDATION_ERROR)
+        path = endpoints.BUSINESS.format(business_id=business_id)
+        data = client.patch(path, json=payload)
+        print_success(f"Updated business {business_id[:8]}", out)
+        print_result(data, out)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@business_app.command("delete")
+def business_delete(
+    ctx: typer.Context,
+    business_id: Annotated[str, typer.Argument(help="Business ID")],
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation")] = False,
+) -> None:
+    """Delete a business."""
+    out, client, _ = _get_client(ctx)
+    if not yes and not out.json_mode:
+        typer.confirm(f"Delete business {business_id}?", abort=True)
+    try:
+        path = endpoints.BUSINESS.format(business_id=business_id)
+        client.delete(path)
+        print_success(f"Deleted business {business_id[:8]}", out)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@business_app.command("health")
+def business_health(
+    ctx: typer.Context,
+    business_id: Annotated[str, typer.Argument(help="Business ID")],
+) -> None:
+    """Show health scores for a business."""
+    out, client, _ = _get_client(ctx)
+    try:
+        path = endpoints.HEALTH_SCORES.format(business_id=business_id)
+        data = client.get(path)
+
+        def _human(d: object, console: Console) -> None:
+            console.print()
+            console.print("[bold]Health Scores[/bold]")
+            console.print("─" * 50)
+            dd = d if isinstance(d, dict) else {}
+            scores = dd.get("scores", dd)
+            if isinstance(scores, dict):
+                for label, value in scores.items():
+                    if isinstance(value, (int, float)):
+                        render_bar(label.replace("_", " ").title(), value, console=console)
+            console.print()
+
+        print_result(data, out, human_formatter=_human)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@business_app.command("crawl")
+def business_crawl(
+    ctx: typer.Context,
+    business_id: Annotated[str, typer.Argument(help="Business ID")],
+) -> None:
+    """Trigger a website crawl for a business."""
+    out, client, _ = _get_client(ctx)
+    try:
+        path = endpoints.CRAWL_START.format(business_id=business_id)
+        data = client.post(path, timeout=60.0)
+        print_result(data, out, human_formatter=lambda d, c: render_kv("Crawl Started", d, c))
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()

cited_cli/commands/config_cmd.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cited_cli.output.formatter import OutputContext, print_error, print_result, print_success
+from cited_cli.output.tables import render_kv, render_table
+from cited_cli.utils.errors import ExitCode
+from cited_cli.utils.interactive import prompt_choice, prompt_if_missing
+from cited_core.config.constants import ENVIRONMENTS
+from cited_core.config.manager import VALID_KEYS, VALID_OUTPUT_VALUES, ConfigManager
+
+config_app = typer.Typer(name="config", help="Manage CLI configuration.")
+
+
+def _get_ctx(ctx: typer.Context) -> tuple[OutputContext, ConfigManager, str]:
+    obj = ctx.obj or {}
+    out = obj.get("output", OutputContext())
+    cfg = obj.get("config", ConfigManager())
+    profile = obj.get("profile", "default")
+    return out, cfg, profile
+
+
+@config_app.command("set")
+def config_set(
+    ctx: typer.Context,
+    key: Annotated[str | None, typer.Argument(help="Config key to set")] = None,
+    value: Annotated[str | None, typer.Argument(help="Value to set")] = None,
+) -> None:
+    """Set a configuration value."""
+    out, cfg, profile = _get_ctx(ctx)
+    key = prompt_choice(key, "KEY", "Select config key:", sorted(VALID_KEYS), out)
+
+    if key not in VALID_KEYS:
+        print_error(f"Unknown config key: {key}. Valid keys: {', '.join(sorted(VALID_KEYS))}", out)
+        raise typer.Exit(ExitCode.VALIDATION_ERROR)
+
+    if key == "environment":
+        value = prompt_choice(value, "VALUE", "Select environment:", list(ENVIRONMENTS.keys()), out)
+    elif key == "output":
+        value = prompt_choice(
+            value, "VALUE", "Select output format:",
+            sorted(VALID_OUTPUT_VALUES), out,
+        )
+    else:
+        value = prompt_if_missing(value, "VALUE", f"Value for {key}", out)
+
+    if key == "environment" and value not in ENVIRONMENTS:
+        print_error(
+            f"Unknown environment: {value}. Valid: {', '.join(ENVIRONMENTS.keys())}", out
+        )
+        raise typer.Exit(ExitCode.VALIDATION_ERROR)
+
+    if key == "output" and value not in VALID_OUTPUT_VALUES:
+        print_error(
+            f"Unknown output format: {value}. Valid: {', '.join(sorted(VALID_OUTPUT_VALUES))}", out
+        )
+        raise typer.Exit(ExitCode.VALIDATION_ERROR)
+
+    cfg.set(key, value, profile)
+    suffix = f" (profile: {profile})" if profile != "default" else ""
+    print_success(f"Set {key} = {value}{suffix}", out)
+
+
+@config_app.command("get")
+def config_get(
+    ctx: typer.Context,
+    key: Annotated[str, typer.Argument(help="Config key to read")],
+) -> None:
+    """Get a configuration value."""
+    out, cfg, profile = _get_ctx(ctx)
+    value = cfg.get(key, profile)
+    if value is None:
+        print_error(f"Key '{key}' is not set", out)
+        raise typer.Exit(ExitCode.NOT_FOUND)
+    print_result({key: value}, out, human_formatter=lambda d, c: c.print(value))
+
+
+@config_app.command("show")
+def config_show(ctx: typer.Context) -> None:
+    """Show all configuration values."""
+    out, cfg, profile = _get_ctx(ctx)
+    data = cfg.get_all(profile)
+    if not data:
+        print_error("No configuration set", out)
+        raise typer.Exit(ExitCode.NOT_FOUND)
+    print_result(
+        data,
+        out,
+        human_formatter=lambda d, c: render_kv(f"Config ({profile})", d, c),
+    )
+
+
+@config_app.command("environments")
+def config_environments(ctx: typer.Context) -> None:
+    """List available environments and their API URLs."""
+    out, cfg, profile = _get_ctx(ctx)
+    current_env = cfg.get_environment(profile, (ctx.obj or {}).get("env_override"))
+    rows = []
+    env_data = {}
+    for name, url in ENVIRONMENTS.items():
+        active = "→" if name == current_env else ""
+        rows.append([active, name, url])
+        env_data[name] = {"url": url, "active": name == current_env}
+
+    def _human(data: dict[str, object], console: Console) -> None:
+        render_table("Environments", ["", "Name", "API URL"], rows, console)
+
+    print_result(env_data, out, human_formatter=_human)