agencycore-cli 0.1.0__py3-none-any.whl

ac_cli/client.py

@@ -0,0 +1,81 @@
+"""Authenticated httpx client for the AgencyCore API."""
+
+import httpx
+import typer
+
+from ac_cli.config import load_config, save_config
+
+
+def _refresh_access_token(cfg: dict) -> str:
+    """Use stored refresh_token to obtain a new access_token from Supabase.
+
+    Persists the new tokens to config. Returns the new access_token.
+    Raises typer.Exit on failure.
+    """
+    from supabase import create_client
+
+    supabase_url = cfg.get("supabase_url")
+    supabase_anon_key = cfg.get("supabase_anon_key")
+    refresh_token = cfg.get("refresh_token")
+
+    if not supabase_url or not supabase_anon_key or not refresh_token:
+        typer.echo("Session expired. Run `ac login` to re-authenticate.")
+        raise typer.Exit(code=1)
+
+    try:
+        sb = create_client(supabase_url, supabase_anon_key)
+        response = sb.auth.refresh_session(refresh_token)
+    except Exception as exc:
+        typer.echo(f"Token refresh failed: {exc}\nRun `ac login` to re-authenticate.")
+        raise typer.Exit(code=1) from exc
+
+    session = response.session
+    if not session:
+        typer.echo("Token refresh returned no session. Run `ac login` to re-authenticate.")
+        raise typer.Exit(code=1)
+
+    cfg["access_token"] = session.access_token
+    cfg["refresh_token"] = session.refresh_token
+    save_config(cfg)
+    return session.access_token
+
+
+class _AuthClient(httpx.Client):
+    """httpx.Client that auto-refreshes expired Supabase tokens on 401."""
+
+    def __init__(self, cfg: dict, **kwargs: object) -> None:
+        self._cfg = cfg
+        super().__init__(**kwargs)
+
+    def send(self, request: httpx.Request, **kwargs: object) -> httpx.Response:
+        response = super().send(request, **kwargs)
+
+        if response.status_code == 401:
+            new_token = _refresh_access_token(self._cfg)
+            request.headers["Authorization"] = f"Bearer {new_token}"
+            self.headers["Authorization"] = f"Bearer {new_token}"
+            response = super().send(request, **kwargs)
+
+        return response
+
+
+def get_api_client() -> httpx.Client:
+    """Return an httpx.Client with base URL and auth header from stored config.
+
+    The client auto-refreshes the Supabase access token on 401 responses.
+    Raises typer.Exit if not logged in.
+    """
+    cfg = load_config()
+    access_token = cfg.get("access_token")
+    api_url = cfg.get("api_url")
+
+    if not access_token or not api_url:
+        typer.echo("Not logged in. Run `ac login` first.")
+        raise typer.Exit(code=1)
+
+    return _AuthClient(
+        cfg=cfg,
+        base_url=api_url,
+        headers={"Authorization": f"Bearer {access_token}"},
+        timeout=30.0,
+    )

ac_cli/commands/auth.py

@@ -0,0 +1,102 @@
+"""Authentication commands: login, logout, whoami."""
+
+import httpx
+import typer
+from rich import print as rprint
+from supabase import create_client
+
+from ac_cli.client import get_api_client
+from ac_cli.config import (
+    DEV_API_URL,
+    DEV_SUPABASE_ANON_KEY,
+    DEV_SUPABASE_URL,
+    STAGING_API_URL,
+    STAGING_SUPABASE_ANON_KEY,
+    STAGING_SUPABASE_URL,
+    clear_config,
+    save_config,
+)
+
+app = typer.Typer(help="Authentication commands")
+
+
+@app.command()
+def login(
+    email: str = typer.Option(None, help="Supabase account email"),
+    password: str = typer.Option(None, help="Account password"),
+    supabase_url: str = typer.Option(None, help="Supabase project URL"),
+    supabase_anon_key: str = typer.Option(None, help="Supabase anonymous/public key"),
+    api_url: str = typer.Option(None, help="AgencyCore API base URL"),
+    dev: bool = typer.Option(False, "--dev", help="Use local dev environment (localhost)"),
+) -> None:
+    """Sign in with email and password via Supabase.
+
+    By default, connects to the staging environment. Pass --dev to use local
+    dev services (localhost API + local Supabase).
+    """
+    if dev:
+        api_url = api_url or DEV_API_URL
+        supabase_url = supabase_url or DEV_SUPABASE_URL
+        supabase_anon_key = supabase_anon_key or DEV_SUPABASE_ANON_KEY
+        rprint("[dim]Using local dev environment[/dim]")
+    else:
+        api_url = api_url or STAGING_API_URL
+        supabase_url = supabase_url or STAGING_SUPABASE_URL
+        supabase_anon_key = supabase_anon_key or STAGING_SUPABASE_ANON_KEY
+
+    if not email:
+        email = typer.prompt("Email")
+    if not password:
+        password = typer.prompt("Password", hide_input=True)
+
+    try:
+        client = create_client(supabase_url, supabase_anon_key)
+        response = client.auth.sign_in_with_password(
+            {"email": email, "password": password}
+        )
+    except Exception as exc:
+        rprint(f"[red]Login failed:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    session = response.session
+    if not session:
+        rprint("[red]Login failed: no session returned.[/red]")
+        raise typer.Exit(code=1)
+
+    save_config(
+        {
+            "api_url": api_url,
+            "supabase_url": supabase_url,
+            "supabase_anon_key": supabase_anon_key,
+            "access_token": session.access_token,
+            "refresh_token": session.refresh_token,
+        }
+    )
+    rprint(f"[green]Logged in as {email}[/green]")
+
+
+@app.command()
+def logout() -> None:
+    """Clear stored credentials."""
+    clear_config()
+    rprint("[green]Logged out.[/green]")
+
+
+@app.command()
+def whoami() -> None:
+    """Show the currently authenticated user."""
+    with get_api_client() as client:
+        try:
+            resp = client.get("/whoami")
+            resp.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            try:
+                detail = exc.response.json().get("detail", exc.response.text)
+            except Exception:
+                detail = exc.response.text
+            rprint(f"[red]Error {exc.response.status_code}:[/red] {detail}")
+            raise typer.Exit(code=1)
+        except httpx.HTTPError as exc:
+            rprint(f"[red]Connection error:[/red] {exc}")
+            raise typer.Exit(code=1)
+    rprint(resp.json())

ac_cli/commands/crm/__init__.py

@@ -0,0 +1,172 @@
+"""CRM commands: search, companies, people, deals, activities, dashboard, lists."""
+
+import httpx
+import typer
+from rich import print as rprint
+
+from ac_cli.client import get_api_client
+from ac_cli.formatting import print_json, print_table
+
+app = typer.Typer(help="CRM commands")
+
+# -- Shared helpers -----------------------------------------------------------
+
+_CRM = "/api/v1/crm"
+
+
+@app.callback()
+def crm_callback(
+    ctx: typer.Context,
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    ctx.ensure_object(dict)
+    ctx.obj["json"] = json_output
+
+
+def _handle_error(exc: httpx.HTTPStatusError) -> None:
+    """Print API error detail and exit."""
+    try:
+        detail = exc.response.json().get("detail", exc.response.text)
+    except Exception:
+        detail = exc.response.text
+    rprint(f"[red]Error {exc.response.status_code}:[/red] {detail}")
+    raise typer.Exit(code=1)
+
+
+def _api_request(method: str, path: str, **kwargs: object) -> httpx.Response:
+    """Make an authenticated API request with standard error handling."""
+    with get_api_client() as client:
+        try:
+            resp = getattr(client, method)(path, **kwargs)
+            resp.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            _handle_error(exc)
+        except httpx.HTTPError as exc:
+            rprint(f"[red]Connection error:[/red] {exc}")
+            raise typer.Exit(code=1)
+    return resp
+
+
+def _build_body(**fields: object) -> dict:
+    """Build API request body from non-None fields."""
+    body: dict = {}
+    for key, value in fields.items():
+        if value is not None:
+            if key == "tags" and isinstance(value, str):
+                body[key] = [t.strip() for t in value.split(",")]
+            else:
+                body[key] = value
+    return body
+
+
+# =============================================================================
+# SEARCH
+# =============================================================================
+
+
+@app.command()
+def search(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="Search query"),
+) -> None:
+    """Search across companies, contacts, and deals."""
+    resp = _api_request("get", f"{_CRM}/search", params={"q": query})
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+        return
+
+    companies = data.get("companies", [])
+    contacts = data.get("contacts", [])
+    deals = data.get("deals", [])
+
+    if companies:
+        print_table(
+            companies,
+            [("name", "Name"), ("industry", "Industry"), ("id", "ID")],
+            title="Companies",
+        )
+    if contacts:
+        print_table(
+            contacts,
+            [("full_name", "Name"), ("email", "Email"), ("id", "ID")],
+            title="Contacts",
+        )
+    if deals:
+        print_table(
+            deals,
+            [("name", "Name"), ("stage", "Stage"), ("id", "ID")],
+            title="Deals",
+        )
+
+    if not companies and not contacts and not deals:
+        rprint("[dim]No results found.[/dim]")
+
+
+# =============================================================================
+# DASHBOARD
+# =============================================================================
+
+
+@app.command("dashboard")
+def dashboard(
+    ctx: typer.Context,
+    period: int = typer.Option(30, "--period", help="Period in days"),
+) -> None:
+    """Show CRM dashboard summary."""
+    resp = _api_request("get", f"{_CRM}/dashboard", params={"period_days": period})
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+        return
+
+    pipeline = data.get("pipeline", {})
+    active = data.get("active_pipeline", {})
+    leads = data.get("leads", {})
+    messages = data.get("messages_sent", {})
+
+    rprint(f"\n[bold]CRM Dashboard[/bold] (last {data.get('period_days', period)} days)\n")
+
+    rprint("[bold]Pipeline[/bold]")
+    rprint(f"  Total deals: {pipeline.get('total_deals', 0)}")
+    rprint(f"  Total value: ${pipeline.get('total_value', 0):,.2f}")
+    stages = pipeline.get("deals_by_stage", {})
+    for stage_name, stats in stages.items():
+        rprint(f"    {stage_name}: {stats.get('count', 0)} deals (${stats.get('value', 0):,.2f})")
+
+    rprint(f"\n[bold]Active Pipeline[/bold]")
+    rprint(f"  Active deals: {active.get('active_deals_count', 0)}")
+    rprint(f"  Total value: ${active.get('total_value', 0):,.2f}")
+    rprint(f"  Adjusted value: ${active.get('adjusted_value', 0):,.2f}")
+
+    rprint(f"\n[bold]Leads[/bold]")
+    rprint(f"  This period: {leads.get('current_period', 0)}")
+    rprint(f"  Previous: {leads.get('previous_period', 0)}")
+    rprint(f"  Change: {leads.get('change', 0):+d}")
+    rprint(f"  Total: {leads.get('total', 0)}")
+
+    rprint(f"\n[bold]Messages Sent[/bold]")
+    rprint(f"  This period: {messages.get('current_period', 0)}")
+    rprint(f"  Previous: {messages.get('previous_period', 0)}")
+    rprint(f"  Change: {messages.get('change', 0):+d}")
+
+
+# -- Register sub-command groups from submodules ------------------------------
+
+from ac_cli.commands.crm.companies import companies_app  # noqa: E402
+from ac_cli.commands.crm.people import people_app  # noqa: E402
+from ac_cli.commands.crm.deals import deals_app  # noqa: E402
+from ac_cli.commands.crm.activities import activities_app  # noqa: E402
+from ac_cli.commands.crm.lists import lists_app  # noqa: E402
+from ac_cli.commands.crm.communications import communications_app  # noqa: E402
+from ac_cli.commands.crm.imports import imports_app  # noqa: E402
+
+app.add_typer(companies_app, name="companies")
+app.add_typer(people_app, name="people")
+app.add_typer(deals_app, name="deals")
+app.add_typer(activities_app, name="activities")
+app.add_typer(lists_app, name="lists")
+app.add_typer(communications_app, name="comms")
+app.add_typer(imports_app, name="import")

ac_cli/commands/crm/activities.py

@@ -0,0 +1,193 @@
+"""CRM activities commands."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import typer
+from rich import print as rprint
+
+from ac_cli.commands.crm import _CRM, _api_request, _build_body
+from ac_cli.formatting import print_detail, print_json, print_table
+
+activities_app = typer.Typer(help="Activity operations")
+
+
+@activities_app.command("list")
+def activities_list(
+    ctx: typer.Context,
+    deal_id: str | None = typer.Option(None, "--deal-id", help="Filter by deal"),
+    company_id: str | None = typer.Option(None, "--company-id", help="Filter by company"),
+    contact_id: str | None = typer.Option(None, "--contact-id", help="Filter by contact"),
+    activity_type: str | None = typer.Option(None, "--type", help="Filter by type"),
+    status: str | None = typer.Option(None, help="Filter by status"),
+    sort_by: str | None = typer.Option(None, "--sort-by", help="Sort field: due_date or created_at"),
+    limit: int = typer.Option(100, help="Max results"),
+    offset: int = typer.Option(0, help="Offset"),
+) -> None:
+    """List activities."""
+    params: dict = {"limit": limit, "offset": offset}
+    if deal_id:
+        params["deal_id"] = deal_id
+    if company_id:
+        params["company_id"] = company_id
+    if contact_id:
+        params["contact_id"] = contact_id
+    if activity_type:
+        params["type"] = activity_type
+    if status:
+        params["status"] = status
+    if sort_by:
+        params["sort_by"] = sort_by
+
+    resp = _api_request("get", f"{_CRM}/activities", params=params)
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+        return
+
+    # API returns a flat list
+    items = data if isinstance(data, list) else data.get("data", [])
+    print_table(
+        items,
+        [
+            ("title", "Title"),
+            ("type", "Type"),
+            ("status", "Status"),
+            ("priority", "Priority"),
+            ("due_date", "Due Date"),
+            ("id", "ID"),
+        ],
+        title=f"Activities ({len(items)})",
+    )
+
+
+@activities_app.command("get")
+def activities_get(
+    ctx: typer.Context,
+    activity_id: str = typer.Argument(..., help="Activity ID"),
+) -> None:
+    """Get an activity by ID."""
+    resp = _api_request("get", f"{_CRM}/activities/{activity_id}")
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+        return
+
+    print_detail(data, [
+        ("id", "ID"),
+        ("title", "Title"),
+        ("type", "Type"),
+        ("status", "Status"),
+        ("priority", "Priority"),
+        ("due_date", "Due Date"),
+        ("completed_at", "Completed At"),
+        ("description", "Description"),
+        ("company_id", "Company ID"),
+        ("contact_id", "Contact ID"),
+        ("deal_id", "Deal ID"),
+        ("assigned_to", "Assigned To"),
+        ("created_at", "Created"),
+        ("updated_at", "Updated"),
+    ])
+
+
+@activities_app.command("create")
+def activities_create(
+    ctx: typer.Context,
+    activity_type: str = typer.Option(..., "--type", help="Activity type (call, meeting, email, task, note)"),
+    title: str = typer.Option(..., help="Activity title"),
+    due_date: str | None = typer.Option(None, "--due-date", help="Due date (ISO format)"),
+    priority: str | None = typer.Option(None, help="Priority (low, medium, high, urgent)"),
+    deal_id: str | None = typer.Option(None, "--deal-id", help="Deal ID"),
+    company_id: str | None = typer.Option(None, "--company-id", help="Company ID"),
+    contact_id: str | None = typer.Option(None, "--contact-id", help="Contact ID"),
+    description: str | None = typer.Option(None, help="Description"),
+) -> None:
+    """Create a new activity."""
+    body = _build_body(
+        type=activity_type, title=title, due_date=due_date,
+        priority=priority, deal_id=deal_id, company_id=company_id,
+        contact_id=contact_id, description=description,
+    )
+
+    me = _api_request("get", "/whoami")
+    body["organization_id"] = me.json()["organization_id"]
+
+    resp = _api_request("post", f"{_CRM}/activities", json=body)
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+    else:
+        rprint(f"[green]Created activity:[/green] {data['title']} ({data['id']})")
+
+
+@activities_app.command("update")
+def activities_update(
+    ctx: typer.Context,
+    activity_id: str = typer.Argument(..., help="Activity ID"),
+    title: str | None = typer.Option(None, help="Activity title"),
+    activity_type: str | None = typer.Option(None, "--type", help="Activity type (call, meeting, email, task, note)"),
+    status: str | None = typer.Option(None, help="Status (pending, in_progress, completed, cancelled)"),
+    priority: str | None = typer.Option(None, help="Priority (low, medium, high, urgent)"),
+    due_date: str | None = typer.Option(None, "--due-date", help="Due date (ISO format)"),
+    description: str | None = typer.Option(None, help="Description"),
+    deal_id: str | None = typer.Option(None, "--deal-id", help="Deal ID"),
+    company_id: str | None = typer.Option(None, "--company-id", help="Company ID"),
+    contact_id: str | None = typer.Option(None, "--contact-id", help="Contact ID"),
+) -> None:
+    """Update an existing activity."""
+    body = _build_body(
+        title=title, type=activity_type, status=status, priority=priority,
+        due_date=due_date, description=description, deal_id=deal_id,
+        company_id=company_id, contact_id=contact_id,
+    )
+
+    if not body:
+        rprint("[yellow]No fields to update.[/yellow]")
+        raise typer.Exit(code=1)
+
+    resp = _api_request("patch", f"{_CRM}/activities/{activity_id}", json=body)
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+    else:
+        rprint(f"[green]Updated activity:[/green] {data['title']} ({data['id']})")
+
+
+@activities_app.command("complete")
+def activities_complete(
+    ctx: typer.Context,
+    activity_id: str = typer.Argument(..., help="Activity ID"),
+) -> None:
+    """Mark an activity as completed."""
+    now = datetime.now(timezone.utc).isoformat()
+    resp = _api_request(
+        "patch",
+        f"{_CRM}/activities/{activity_id}",
+        json={"status": "completed", "completed_at": now},
+    )
+
+    data = resp.json()
+    if ctx.obj["json"]:
+        print_json(data)
+    else:
+        rprint(f"[green]Completed activity:[/green] {data['title']} ({data['id']})")
+
+
+@activities_app.command("delete")
+def activities_delete(
+    activity_id: str = typer.Argument(..., help="Activity ID"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Delete an activity."""
+    if not yes:
+        typer.confirm(f"Delete activity {activity_id}?", abort=True)
+
+    _api_request("delete", f"{_CRM}/activities/{activity_id}")
+
+    rprint(f"[green]Deleted activity {activity_id}[/green]")