foxreach-cli 0.1.0__py3-none-any.whl

foxreach_cli/commands/leads.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import asdict
+from typing import Optional
+
+import click
+
+from foxreach import FoxReachError, LeadCreate, LeadUpdate
+
+from ..client_factory import get_client
+from ..output import print_detail, print_error, print_json, print_meta, print_success, print_table
+
+
+@click.group()
+def leads() -> None:
+    """Manage leads."""
+
+
+@leads.command("list")
+@click.option("--search", default=None, help="Search by email, name, or company")
+@click.option("--status", default=None, type=click.Choice(["active", "bounced", "unsubscribed", "replied"]))
+@click.option("--page", default=1, type=int, help="Page number")
+@click.option("--limit", default=50, type=int, help="Results per page")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def leads_list(search: Optional[str], status: Optional[str], page: int, limit: int, as_json: bool) -> None:
+    """List leads."""
+    client = get_client()
+    try:
+        result = client.leads.list(page=page, page_size=limit, search=search, status=status)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json({"data": [asdict(l) for l in result.data], "meta": asdict(result.meta)})
+        return
+
+    if not result.data:
+        click.echo("No leads found.")
+        return
+
+    print_table(
+        result.data,
+        ["ID", "Email", "First Name", "Last Name", "Company", "Status"],
+        {"ID": "id", "Email": "email", "First Name": "first_name", "Last Name": "last_name", "Company": "company", "Status": "status"},
+    )
+    print_meta(result.meta)
+
+
+@leads.command("get")
+@click.argument("lead_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def leads_get(lead_id: str, as_json: bool) -> None:
+    """Get a lead by ID."""
+    client = get_client()
+    try:
+        lead = client.leads.get(lead_id)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(lead)
+        return
+
+    print_detail(lead, [
+        "id", "email", "first_name", "last_name", "company", "title",
+        "phone", "linkedin_url", "website", "status", "source",
+        "tags", "notes", "created_at", "updated_at",
+    ])
+
+
+@leads.command("create")
+@click.option("--email", required=True, help="Lead email address")
+@click.option("--first-name", default=None, help="First name")
+@click.option("--last-name", default=None, help="Last name")
+@click.option("--company", default=None, help="Company name")
+@click.option("--title", default=None, help="Job title")
+@click.option("--phone", default=None, help="Phone number")
+@click.option("--linkedin", default=None, help="LinkedIn URL")
+@click.option("--website", default=None, help="Website URL")
+@click.option("--notes", default=None, help="Notes")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def leads_create(
+    email: str,
+    first_name: Optional[str],
+    last_name: Optional[str],
+    company: Optional[str],
+    title: Optional[str],
+    phone: Optional[str],
+    linkedin: Optional[str],
+    website: Optional[str],
+    notes: Optional[str],
+    as_json: bool,
+) -> None:
+    """Create a new lead."""
+    client = get_client()
+    try:
+        lead = client.leads.create(LeadCreate(
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            company=company,
+            title=title,
+            phone=phone,
+            linkedin_url=linkedin,
+            website=website,
+            notes=notes,
+        ))
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(lead)
+    else:
+        print_success(f"Lead created: {lead.id}")
+
+
+@leads.command("update")
+@click.argument("lead_id")
+@click.option("--first-name", default=None, help="First name")
+@click.option("--last-name", default=None, help="Last name")
+@click.option("--company", default=None, help="Company name")
+@click.option("--title", default=None, help="Job title")
+@click.option("--phone", default=None, help="Phone number")
+@click.option("--linkedin", default=None, help="LinkedIn URL")
+@click.option("--website", default=None, help="Website URL")
+@click.option("--notes", default=None, help="Notes")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def leads_update(
+    lead_id: str,
+    first_name: Optional[str],
+    last_name: Optional[str],
+    company: Optional[str],
+    title: Optional[str],
+    phone: Optional[str],
+    linkedin: Optional[str],
+    website: Optional[str],
+    notes: Optional[str],
+    as_json: bool,
+) -> None:
+    """Update a lead."""
+    client = get_client()
+    try:
+        lead = client.leads.update(lead_id, LeadUpdate(
+            first_name=first_name,
+            last_name=last_name,
+            company=company,
+            title=title,
+            phone=phone,
+            linkedin_url=linkedin,
+            website=website,
+            notes=notes,
+        ))
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(lead)
+    else:
+        print_success(f"Lead updated: {lead.id}")
+
+
+@leads.command("delete")
+@click.argument("lead_id")
+@click.confirmation_option(prompt="Are you sure you want to delete this lead?")
+def leads_delete(lead_id: str) -> None:
+    """Delete a lead."""
+    client = get_client()
+    try:
+        client.leads.delete(lead_id)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+    print_success(f"Lead deleted: {lead_id}")

foxreach_cli/commands/sequences.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import asdict
+from typing import Optional
+
+import click
+
+from foxreach import FoxReachError, SequenceCreate, SequenceUpdate
+
+from ..client_factory import get_client
+from ..output import print_detail, print_error, print_json, print_success, print_table
+
+
+@click.group()
+def sequences() -> None:
+    """Manage campaign sequences (email steps)."""
+
+
+@sequences.command("list")
+@click.option("--campaign", required=True, help="Campaign ID")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def sequences_list(campaign: str, as_json: bool) -> None:
+    """List sequences for a campaign."""
+    client = get_client()
+    try:
+        items = client.campaigns.sequences.list(campaign)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json([asdict(s) for s in items])
+        return
+
+    if not items:
+        click.echo("No sequences found.")
+        return
+
+    print_table(
+        items,
+        ["ID", "Step", "Subject", "Delay Days", "Type"],
+        {"ID": "id", "Step": "step_number", "Subject": "subject", "Delay Days": "delay_days", "Type": "template_type"},
+    )
+
+
+@sequences.command("create")
+@click.option("--campaign", required=True, help="Campaign ID")
+@click.option("--body", required=True, help="Email body (supports {{variables}})")
+@click.option("--subject", default=None, help="Email subject")
+@click.option("--delay-days", default=1, type=int, help="Days to wait before sending")
+@click.option("--step", default=None, type=int, help="Step number")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def sequences_create(
+    campaign: str,
+    body: str,
+    subject: Optional[str],
+    delay_days: int,
+    step: Optional[int],
+    as_json: bool,
+) -> None:
+    """Add a sequence step to a campaign."""
+    client = get_client()
+    try:
+        seq = client.campaigns.sequences.create(campaign, SequenceCreate(
+            body=body,
+            subject=subject,
+            delay_days=delay_days,
+            step_number=step,
+        ))
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(seq)
+    else:
+        print_success(f"Sequence created: {seq.id} (step {seq.step_number})")
+
+
+@sequences.command("update")
+@click.option("--campaign", required=True, help="Campaign ID")
+@click.option("--sequence", "sequence_id", required=True, help="Sequence ID")
+@click.option("--body", default=None, help="Email body")
+@click.option("--subject", default=None, help="Email subject")
+@click.option("--delay-days", default=None, type=int, help="Days to wait before sending")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def sequences_update(
+    campaign: str,
+    sequence_id: str,
+    body: Optional[str],
+    subject: Optional[str],
+    delay_days: Optional[int],
+    as_json: bool,
+) -> None:
+    """Update a sequence step."""
+    client = get_client()
+    try:
+        seq = client.campaigns.sequences.update(campaign, sequence_id, SequenceUpdate(
+            body=body,
+            subject=subject,
+            delay_days=delay_days,
+        ))
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(seq)
+    else:
+        print_success(f"Sequence updated: {seq.id}")
+
+
+@sequences.command("delete")
+@click.option("--campaign", required=True, help="Campaign ID")
+@click.option("--sequence", "sequence_id", required=True, help="Sequence ID")
+@click.confirmation_option(prompt="Are you sure you want to delete this sequence?")
+def sequences_delete(campaign: str, sequence_id: str) -> None:
+    """Delete a sequence step."""
+    client = get_client()
+    try:
+        client.campaigns.sequences.delete(campaign, sequence_id)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+    print_success(f"Sequence deleted: {sequence_id}")

foxreach_cli/commands/templates.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import asdict
+from typing import Optional
+
+import click
+
+from foxreach import FoxReachError, TemplateCreate, TemplateUpdate
+
+from ..client_factory import get_client
+from ..output import print_detail, print_error, print_json, print_meta, print_success, print_table
+
+
+@click.group()
+def templates() -> None:
+    """Manage email templates."""
+
+
+@templates.command("list")
+@click.option("--page", default=1, type=int)
+@click.option("--limit", default=50, type=int)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def templates_list(page: int, limit: int, as_json: bool) -> None:
+    """List templates."""
+    client = get_client()
+    try:
+        result = client.templates.list(page=page, page_size=limit)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json({"data": [asdict(t) for t in result.data], "meta": asdict(result.meta)})
+        return
+
+    if not result.data:
+        click.echo("No templates found.")
+        return
+
+    print_table(
+        result.data,
+        ["ID", "Name", "Subject", "Type", "Created At"],
+        {"ID": "id", "Name": "name", "Subject": "subject", "Type": "template_type", "Created At": "created_at"},
+    )
+    print_meta(result.meta)
+
+
+@templates.command("get")
+@click.argument("template_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def templates_get(template_id: str, as_json: bool) -> None:
+    """Get a template by ID."""
+    client = get_client()
+    try:
+        template = client.templates.get(template_id)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(template)
+        return
+
+    print_detail(template, [
+        "id", "name", "subject", "body", "template_type",
+        "send_as_html", "created_at", "updated_at",
+    ])
+
+
+@templates.command("create")
+@click.option("--name", required=True, help="Template name")
+@click.option("--body", required=True, help="Email body (supports {{variables}})")
+@click.option("--subject", default=None, help="Email subject")
+@click.option("--html", is_flag=True, help="Send as HTML")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def templates_create(name: str, body: str, subject: Optional[str], html: bool, as_json: bool) -> None:
+    """Create a new template."""
+    client = get_client()
+    try:
+        template = client.templates.create(TemplateCreate(
+            name=name,
+            body=body,
+            subject=subject,
+            send_as_html=html,
+        ))
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(template)
+    else:
+        print_success(f"Template created: {template.id}")
+
+
+@templates.command("update")
+@click.argument("template_id")
+@click.option("--name", default=None, help="Template name")
+@click.option("--body", default=None, help="Email body")
+@click.option("--subject", default=None, help="Email subject")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def templates_update(template_id: str, name: Optional[str], body: Optional[str], subject: Optional[str], as_json: bool) -> None:
+    """Update a template."""
+    client = get_client()
+    try:
+        template = client.templates.update(template_id, TemplateUpdate(
+            name=name,
+            body=body,
+            subject=subject,
+        ))
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    if as_json:
+        print_json(template)
+    else:
+        print_success(f"Template updated: {template.id}")
+
+
+@templates.command("delete")
+@click.argument("template_id")
+@click.confirmation_option(prompt="Are you sure you want to delete this template?")
+def templates_delete(template_id: str) -> None:
+    """Delete a template."""
+    client = get_client()
+    try:
+        client.templates.delete(template_id)
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+    print_success(f"Template deleted: {template_id}")

foxreach_cli/config.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+_CONFIG_DIR = Path.home() / ".foxreach"
+_CONFIG_FILE = _CONFIG_DIR / "config.json"
+
+
+def _load() -> Dict[str, Any]:
+    if _CONFIG_FILE.exists():
+        return json.loads(_CONFIG_FILE.read_text())
+    return {}
+
+
+def _save(data: Dict[str, Any]) -> None:
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _CONFIG_FILE.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def get_api_key() -> Optional[str]:
+    env = os.environ.get("FOXREACH_API_KEY")
+    if env:
+        return env
+    return _load().get("api_key")
+
+
+def get_base_url() -> Optional[str]:
+    env = os.environ.get("FOXREACH_BASE_URL")
+    if env:
+        return env
+    return _load().get("base_url")
+
+
+def set_api_key(key: str) -> None:
+    data = _load()
+    data["api_key"] = key
+    _save(data)
+
+
+def set_base_url(url: str) -> None:
+    data = _load()
+    data["base_url"] = url
+    _save(data)
+
+
+def get_all() -> Dict[str, Any]:
+    data = _load()
+    if os.environ.get("FOXREACH_API_KEY"):
+        data["api_key"] = os.environ["FOXREACH_API_KEY"]
+        data["_api_key_source"] = "env"
+    if os.environ.get("FOXREACH_BASE_URL"):
+        data["base_url"] = os.environ["FOXREACH_BASE_URL"]
+        data["_base_url_source"] = "env"
+    return data
+
+
+def mask_key(key: str) -> str:
+    if len(key) <= 8:
+        return key[:4] + "****"
+    return key[:4] + "*" * (len(key) - 8) + key[-4:]

foxreach_cli/main.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import sys
+
+import click
+
+from foxreach import FoxReachError
+
+from . import config as cfg
+from .output import console, print_error, print_success
+
+
+@click.group()
+@click.version_option(package_name="foxreach-cli")
+def cli() -> None:
+    """FoxReach CLI — manage your cold email outreach from the terminal."""
+
+
+# ── Config ────────────────────────────────────────────────────────────────
+
+@cli.group()
+def config() -> None:
+    """Manage CLI configuration."""
+
+
+@config.command("set-key")
+@click.option("--key", prompt="API Key", hide_input=True, help="Your FoxReach API key (otr_...)")
+def config_set_key(key: str) -> None:
+    """Save your API key."""
+    if not key.startswith("otr_"):
+        print_error('API key must start with "otr_"')
+        sys.exit(1)
+    cfg.set_api_key(key)
+    print_success("API key saved.")
+
+
+@config.command("set-url")
+@click.argument("url")
+def config_set_url(url: str) -> None:
+    """Override the API base URL."""
+    cfg.set_base_url(url)
+    print_success(f"Base URL set to {url}")
+
+
+@config.command("show")
+def config_show() -> None:
+    """Show current configuration."""
+    data = cfg.get_all()
+    key = data.get("api_key")
+    if key:
+        source = data.get("_api_key_source", "config file")
+        console.print(f"API Key:  {cfg.mask_key(key)}  [dim]({source})[/dim]")
+    else:
+        console.print("API Key:  [dim]not set[/dim]")
+
+    url = data.get("base_url")
+    if url:
+        source = data.get("_base_url_source", "config file")
+        console.print(f"Base URL: {url}  [dim]({source})[/dim]")
+    else:
+        console.print("Base URL: [dim]default[/dim]")
+
+
+# ── Register command groups ───────────────────────────────────────────────
+
+from .commands.leads import leads
+from .commands.campaigns import campaigns
+from .commands.sequences import sequences
+from .commands.templates import templates
+from .commands.accounts import accounts
+from .commands.inbox import inbox
+from .commands.analytics import analytics
+
+cli.add_command(leads)
+cli.add_command(campaigns)
+cli.add_command(sequences)
+cli.add_command(templates)
+cli.add_command(accounts)
+cli.add_command(inbox)
+cli.add_command(analytics)
+
+
+def main() -> None:
+    try:
+        cli()
+    except FoxReachError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

foxreach_cli/output.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import asdict
+from typing import Any, Dict, List, Optional, Sequence
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def print_json(data: Any) -> None:
+    if hasattr(data, "__dataclass_fields__"):
+        data = asdict(data)
+    click.echo(json.dumps(data, indent=2, default=str))
+
+
+def print_table(rows: Sequence[Any], columns: List[str], field_map: Optional[Dict[str, str]] = None) -> None:
+    """Print a rich table. field_map maps column headers to dataclass field names."""
+    table = Table(show_header=True, header_style="bold cyan")
+    for col in columns:
+        table.add_column(col)
+
+    for row in rows:
+        values = []
+        for col in columns:
+            field = (field_map or {}).get(col, col.lower().replace(" ", "_"))
+            val = getattr(row, field, "") if hasattr(row, field) else ""
+            values.append(str(val) if val is not None else "")
+        table.add_row(*values)
+
+    console.print(table)
+
+
+def print_detail(obj: Any, fields: List[str]) -> None:
+    """Print a single object as key-value pairs."""
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+
+    for field in fields:
+        val = getattr(obj, field, None)
+        label = field.replace("_", " ").title()
+        table.add_row(label, str(val) if val is not None else "-")
+
+    console.print(table)
+
+
+def print_success(message: str) -> None:
+    console.print(f"[green]{message}[/green]")
+
+
+def print_error(message: str) -> None:
+    err_console.print(f"[red]Error:[/red] {message}")
+
+
+def print_meta(meta: Any) -> None:
+    if meta and hasattr(meta, "total"):
+        console.print(
+            f"\n[dim]Page {meta.page}/{meta.total_pages} "
+            f"({meta.total} total)[/dim]"
+        )