oto-cli 1.0.0__py3-none-any.whl

oto/__init__.py

@@ -0,0 +1,3 @@
+"""Oto - CLI tools for automation."""
+
+__version__ = "1.0.0"

oto/cli.py

@@ -0,0 +1,74 @@
+"""Oto CLI - composable toolkit for AI agents."""
+
+import importlib
+import sys
+from pathlib import Path
+
+import typer
+
+app = typer.Typer(
+    name="oto",
+    help="CLI toolkit for AI agents. JSON on stdout, composable with pipes.",
+    no_args_is_help=True,
+)
+
+# Auto-discover commands from oto/commands/*.py
+_commands_dir = Path(__file__).parent / "commands"
+for _cmd_file in sorted(_commands_dir.glob("*.py")):
+    if _cmd_file.name.startswith("_"):
+        continue
+    _module_name = _cmd_file.stem
+    try:
+        _module = importlib.import_module(f"oto.commands.{_module_name}")
+    except ImportError:
+        continue
+    if hasattr(_module, "app"):
+        app.add_typer(_module.app, name=_module_name)
+
+
+@app.command("config")
+def show_config():
+    """Show current configuration and detected secrets."""
+    from oto.config import _find_project_secrets, _get_user_secrets, get_secret
+
+    project_secrets = _find_project_secrets()
+    user_secrets = _get_user_secrets()
+
+    print("Secrets files:")
+    print(f"  Project: {project_secrets or '.otomata/secrets.env (not found)'}")
+    print(f"  User:    {user_secrets}{' (exists)' if user_secrets.exists() else ' (not found)'}")
+    print()
+    print("Secrets status:")
+    secrets = [
+        "GOOGLE_SERVICE_ACCOUNT",
+        "GOOGLE_OAUTH_CLIENT",
+        "NOTION_API_KEY",
+        "LINKEDIN_COOKIE",
+        "SIRENE_API_KEY",
+        "SERPER_API_KEY",
+        "KASPR_API_KEY",
+        "HUNTER_API_KEY",
+        "LEMLIST_API_KEY",
+        "PENNYLANE_API_KEY",
+        "GROQ_API_KEY",
+        "ANTHROPIC_ADMIN_API_KEY",
+        "FOLK_API_KEY",
+        "TULS_API_TOKEN",
+    ]
+    for name in secrets:
+        status = "+" if get_secret(name) else "-"
+        print(f"  {status} {name}")
+
+
+def main():
+    try:
+        app()
+    except ValueError as e:
+        if "not found. Set it via:" in str(e):
+            print(f"Error: {e}", file=sys.stderr)
+            raise SystemExit(1)
+        raise
+
+
+if __name__ == "__main__":
+    main()

oto/commands/anthropic.py

@@ -0,0 +1,64 @@
+"""Anthropic Admin API commands (usage & cost tracking)."""
+
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Anthropic Admin API (usage & cost tracking)")
+
+
+@app.command("usage")
+def usage(
+    days: int = typer.Option(7, "--days", "-d", help="Number of days to look back"),
+    bucket: str = typer.Option("1d", "--bucket", "-b", help="Bucket width: 1m, 1h, 1d"),
+    group_by: Optional[str] = typer.Option("model", "--group-by", "-g", help="Group by: model, api_key_id, workspace_id, service_tier"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Filter to specific model"),
+):
+    """Get token usage report."""
+    import json
+    from oto.tools.anthropic import AnthropicAdminClient
+
+    client = AnthropicAdminClient()
+    groups = [g.strip() for g in group_by.split(",")] if group_by else None
+    models = [model] if model else None
+    data = client.get_usage(bucket_width=bucket, group_by=groups, models=models,
+                            limit=days if bucket == "1d" else None)
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+@app.command("cost")
+def cost(
+    days: int = typer.Option(30, "--days", "-d", help="Number of days to look back"),
+    group_by: Optional[str] = typer.Option(None, "--group-by", "-g", help="Group by: workspace_id, description"),
+):
+    """Get cost report (daily, USD)."""
+    import json
+    from oto.tools.anthropic import AnthropicAdminClient
+
+    client = AnthropicAdminClient()
+    groups = [g.strip() for g in group_by.split(",")] if group_by else None
+    data = client.get_costs(group_by=groups)
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+@app.command("summary")
+def summary(
+    days: int = typer.Option(7, "--days", "-d", help="Number of days to look back"),
+):
+    """Daily usage summary with estimated costs by model."""
+    import json
+    from oto.tools.anthropic import AnthropicAdminClient
+
+    client = AnthropicAdminClient()
+    result = client.get_daily_summary(days=days)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@app.command("today")
+def today():
+    """Today's usage and estimated cost."""
+    import json
+    from oto.tools.anthropic import AnthropicAdminClient
+
+    client = AnthropicAdminClient()
+    result = client.get_today_cost()
+    print(json.dumps(result, indent=2, ensure_ascii=False))

oto/commands/audio.py

@@ -0,0 +1,91 @@
+"""Audio recorder commands — push transcripts to tuls.me."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+app = typer.Typer(help="Audio recorder — transcripts & summaries on tuls.me")
+
+
+def _out(data):
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def _client():
+    from oto.tools.audio import AudioClient
+    return AudioClient()
+
+
+@app.command("push")
+def push(
+    folder: Optional[str] = typer.Argument(None, help="Recording folder path (default: latest in ~/Recordings)"),
+    with_audio: bool = typer.Option(False, "--with-audio", help="Include audio.mp3 in upload"),
+):
+    """Push a local recording to tuls.me."""
+    path = _resolve_folder(folder)
+    try:
+        result = _client().push(path, with_audio=with_audio)
+        _out(result)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        if "409" in str(e):
+            print(f"Already pushed: {path.name}")
+            raise typer.Exit(0)
+        raise
+
+
+@app.command("list")
+def list_recordings():
+    """List all recordings."""
+    _out(_client().list())
+
+
+@app.command("get")
+def get(recording_id: str = typer.Argument(..., help="Recording ID")):
+    """Get a recording with transcript and summary."""
+    _out(_client().get(recording_id))
+
+
+@app.command("delete")
+def delete(recording_id: str = typer.Argument(..., help="Recording ID")):
+    """Delete a recording."""
+    _client().delete(recording_id)
+    print(f"Deleted {recording_id}")
+
+
+@app.command("summarize")
+def summarize(
+    recording_id: str = typer.Argument(..., help="Recording ID"),
+    prompt: Optional[str] = typer.Option(None, "--prompt", "-p", help="Custom summary prompt"),
+):
+    """Trigger AI summary on a transcribed recording."""
+    _out(_client().summarize(recording_id, prompt=prompt))
+
+
+def _resolve_folder(folder: Optional[str]) -> Path:
+    """Resolve recording folder path (default: latest in ~/Recordings)."""
+    if folder:
+        path = Path(folder).expanduser()
+        if not path.is_absolute():
+            recordings_dir = Path.home() / "Recordings"
+            path = recordings_dir / folder
+        if not path.is_dir():
+            print(f"Error: Not a directory: {path}")
+            raise typer.Exit(1)
+        return path
+
+    recordings_dir = Path.home() / "Recordings"
+    if not recordings_dir.is_dir():
+        print(f"Error: {recordings_dir} not found")
+        raise typer.Exit(1)
+
+    folders = sorted(recordings_dir.iterdir(), key=lambda p: p.stat().st_mtime, reverse=True)
+    folders = [f for f in folders if f.is_dir()]
+    if not folders:
+        print("Error: No recordings found")
+        raise typer.Exit(1)
+    return folders[0]

oto/commands/browser.py

@@ -0,0 +1,257 @@
+"""Browser automation commands (LinkedIn, Crunchbase, Pappers, Indeed, G2)."""
+
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Browser automation tools (LinkedIn, Crunchbase, Indeed, etc.)")
+
+# LinkedIn subcommands
+linkedin_app = typer.Typer(help="LinkedIn scraping (profile, company, employees, search)")
+app.add_typer(linkedin_app, name="linkedin")
+
+
+def _linkedin_client(**kwargs):
+    """Create LinkedInClient with common options."""
+    from oto.tools.browser import LinkedInClient
+    return LinkedInClient(**kwargs)
+
+
+@linkedin_app.command("profile")
+def linkedin_profile(
+    url: str = typer.Argument(..., help="LinkedIn profile URL"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    identity: str = typer.Option("default", help="Identity for rate limiting"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Scrape LinkedIn profile page."""
+    import asyncio
+    import json
+
+    async def run():
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, identity=identity, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.scrape_profile(url)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@linkedin_app.command("company")
+def linkedin_company(
+    url: str = typer.Argument(..., help="LinkedIn company URL"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    identity: str = typer.Option("default", help="Identity for rate limiting"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Scrape LinkedIn company page."""
+    import asyncio
+    import json
+
+    async def run():
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, identity=identity, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.scrape_company(url)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@linkedin_app.command("search")
+def linkedin_search(
+    query: str = typer.Argument(..., help="Search query"),
+    limit: int = typer.Option(5, help="Max results"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Search LinkedIn companies."""
+    import asyncio
+    import json
+
+    async def run():
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.search_companies(query, limit=limit)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@linkedin_app.command("people")
+def linkedin_people(
+    slug: str = typer.Argument(..., help="LinkedIn company slug"),
+    limit: int = typer.Option(20, help="Max results"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """List people from a LinkedIn company page."""
+    import asyncio
+    import json
+
+    async def run():
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.get_company_people(slug, limit=limit)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@linkedin_app.command("employees")
+def linkedin_employees(
+    company: str = typer.Argument(..., help="LinkedIn company slug"),
+    keywords: Optional[str] = typer.Option(None, help="Title keywords (comma-separated)"),
+    limit: int = typer.Option(10, help="Max results"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Search company employees on LinkedIn."""
+    import asyncio
+    import json
+
+    async def run():
+        kw_list = keywords.split(",") if keywords else None
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.search_employees(company, keywords=kw_list, limit=limit)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@linkedin_app.command("search-people")
+def linkedin_search_people(
+    keywords: str = typer.Argument(..., help="Search keywords (e.g., 'credit manager')"),
+    geo: Optional[str] = typer.Option("105015875", help="Geo URN ID (default: France)"),
+    limit: int = typer.Option(50, help="Max results"),
+    pages: int = typer.Option(5, help="Max pages to scrape"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Search people on LinkedIn by keywords and location."""
+    import asyncio
+    import json
+
+    async def run():
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.search_people(keywords, geo=geo, limit=limit, pages=pages)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@linkedin_app.command("posts")
+def linkedin_posts(
+    url: str = typer.Argument(..., help="LinkedIn profile URL"),
+    limit: int = typer.Option(10, "--limit", "-n", help="Max posts"),
+    cookie: Optional[str] = typer.Option(None, envvar="LINKEDIN_COOKIE", help="li_at cookie"),
+    cdp_url: Optional[str] = typer.Option(None, "--cdp-url", help="Connect to existing Chrome via CDP"),
+    profile: Optional[str] = typer.Option(None, help="Chrome profile directory path"),
+    channel: Optional[str] = typer.Option(None, envvar="BROWSER_CHANNEL", help="Chrome channel"),
+    no_rate_limit: bool = typer.Option(False, "--no-rate-limit", help="Disable rate limiting"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Scrape posts from a LinkedIn profile."""
+    import asyncio
+    import json
+
+    async def run():
+        async with _linkedin_client(cookie=cookie, cdp_url=cdp_url, profile=profile, channel=channel, headless=headless, rate_limit=not no_rate_limit) as client:
+            return await client.scrape_profile_posts(url, max_posts=limit)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@app.command("crunchbase-company")
+def crunchbase_company(
+    slug: str = typer.Argument(..., help="Company slug or URL"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Get company from Crunchbase."""
+    import asyncio
+    import json
+    from oto.tools.browser import CrunchbaseClient
+
+    async def run():
+        async with CrunchbaseClient(headless=headless) as client:
+            return await client.get_company(slug)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@app.command("pappers-siren")
+def pappers_siren(
+    siren: str = typer.Argument(..., help="SIREN number"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Get French company data from Pappers."""
+    import asyncio
+    import json
+    from oto.tools.browser import PappersClient
+
+    async def run():
+        async with PappersClient(headless=headless) as client:
+            return await client.get_company_by_siren(siren)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@app.command("indeed-search")
+def indeed_search(
+    query: str = typer.Argument(..., help="Job search query"),
+    location: str = typer.Option("", help="Location"),
+    country: str = typer.Option("fr", help="Country code (fr, us, uk, de)"),
+    limit: int = typer.Option(25, help="Max results"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Search jobs on Indeed."""
+    import asyncio
+    import json
+    from oto.tools.browser import IndeedClient
+
+    async def run():
+        async with IndeedClient(country=country, headless=headless) as client:
+            return await client.search_jobs(query, location=location, max_results=limit)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@app.command("g2-reviews")
+def g2_reviews(
+    url: str = typer.Argument(..., help="G2 product reviews URL"),
+    limit: int = typer.Option(50, help="Max reviews"),
+    headless: bool = typer.Option(True, help="Run headless"),
+):
+    """Scrape product reviews from G2."""
+    import asyncio
+    import json
+    from oto.tools.browser import G2Client
+
+    async def run():
+        async with G2Client(headless=headless) as client:
+            return await client.get_product_reviews(url, max_reviews=limit)
+
+    result = asyncio.run(run())
+    print(json.dumps(result, indent=2, ensure_ascii=False))

oto/commands/company.py

@@ -0,0 +1,23 @@
+"""Company lookup command (SIREN multi-source)."""
+
+import typer
+
+app = typer.Typer(help="Company lookup")
+
+
+@app.command("info")
+def info(
+    siren: str = typer.Argument(..., help="SIREN number (9 digits)"),
+):
+    """Get French company info by SIREN (directors, finances, address). No API key needed."""
+    import json
+    from oto.tools.sirene import EntreprisesClient
+
+    client = EntreprisesClient()
+    result = client.get_by_siren(siren)
+
+    if not result:
+        print(f"Company not found: {siren}")
+        raise typer.Exit(1)
+
+    print(json.dumps(result, indent=2, ensure_ascii=False))

oto/commands/enrichment.py

@@ -0,0 +1,152 @@
+"""Contact enrichment commands (Kaspr, Hunter, Lemlist)."""
+
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Contact enrichment tools")
+
+# Kaspr subcommands
+kaspr_app = typer.Typer(help="Kaspr contact enrichment")
+app.add_typer(kaspr_app, name="kaspr")
+
+# Hunter subcommands
+hunter_app = typer.Typer(help="Hunter.io email tools")
+app.add_typer(hunter_app, name="hunter")
+
+# Lemlist subcommands
+lemlist_app = typer.Typer(help="Lemlist campaign & lead management")
+app.add_typer(lemlist_app, name="lemlist")
+
+
+@kaspr_app.command("enrich")
+def kaspr_enrich(
+    linkedin_slug: str = typer.Argument(..., help="LinkedIn profile slug"),
+    name: Optional[str] = typer.Option(None, "--name", help="Person full name"),
+):
+    """Enrich a LinkedIn profile with Kaspr (email, phone)."""
+    import json
+    from oto.tools.kaspr import KasprClient
+
+    client = KasprClient()
+    result = client.enrich_linkedin(linkedin_slug, name=name)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@hunter_app.command("domain")
+def hunter_domain(
+    domain: str = typer.Argument(..., help="Domain to search"),
+    limit: int = typer.Option(10, "--limit", "-n", help="Max results"),
+):
+    """Search emails for a domain via Hunter."""
+    import json
+    from oto.tools.hunter import HunterClient
+
+    client = HunterClient()
+    result = client.domain_search(domain, limit=limit)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@hunter_app.command("find")
+def hunter_find(
+    domain: str = typer.Argument(..., help="Domain"),
+    name: str = typer.Option(..., "--name", help="Full name"),
+):
+    """Find email for a person at a domain via Hunter."""
+    import json
+    from oto.tools.hunter import HunterClient
+
+    client = HunterClient()
+    result = client.email_finder(domain, full_name=name)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@hunter_app.command("verify")
+def hunter_verify(
+    email: str = typer.Argument(..., help="Email to verify"),
+):
+    """Verify an email address via Hunter."""
+    import json
+    from oto.tools.hunter import HunterClient
+
+    client = HunterClient()
+    result = client.email_verifier(email)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@lemlist_app.command("campaigns")
+def lemlist_campaigns():
+    """List all Lemlist campaigns."""
+    import json
+    from oto.tools.lemlist import LemlistClient
+
+    client = LemlistClient()
+    campaigns = client.list_campaigns()
+    result = [{"id": c.id, "name": c.name, "status": c.status, "senders": c.senders} for c in campaigns]
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@lemlist_app.command("leads")
+def lemlist_leads(
+    campaign_id: str = typer.Argument(..., help="Campaign ID"),
+):
+    """List leads in a campaign."""
+    import json
+    from oto.tools.lemlist import LemlistClient
+
+    client = LemlistClient()
+    leads = client.get_all_leads(campaign_id)
+    print(json.dumps(leads, indent=2, ensure_ascii=False))
+
+
+@lemlist_app.command("add-lead")
+def lemlist_add_lead(
+    campaign_id: str = typer.Argument(..., help="Campaign ID"),
+    email: str = typer.Option(..., "--email", "-e", help="Lead email"),
+    first_name: str = typer.Option(None, "--first-name", help="First name"),
+    last_name: str = typer.Option(None, "--last-name", help="Last name"),
+    company: str = typer.Option(None, "--company", help="Company name"),
+    phone: str = typer.Option(None, "--phone", help="Phone number"),
+    linkedin: str = typer.Option(None, "--linkedin", help="LinkedIn URL"),
+):
+    """Add a lead to a Lemlist campaign."""
+    import json
+    from oto.tools.lemlist import LemlistClient
+    from oto.tools.lemlist.client import Lead
+
+    client = LemlistClient()
+    lead = Lead(
+        email=email,
+        firstName=first_name,
+        lastName=last_name,
+        companyName=company,
+        phone=phone,
+        linkedinUrl=linkedin,
+    )
+    result = client.add_lead(campaign_id, lead)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@lemlist_app.command("delete-lead")
+def lemlist_delete_lead(
+    campaign_id: str = typer.Argument(..., help="Campaign ID"),
+    email: str = typer.Argument(..., help="Lead email to remove"),
+):
+    """Remove a lead from a Lemlist campaign."""
+    import json
+    from oto.tools.lemlist import LemlistClient
+
+    client = LemlistClient()
+    result = client.delete_lead(campaign_id, email)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+@lemlist_app.command("export")
+def lemlist_export(
+    campaign_id: str = typer.Argument(..., help="Campaign ID"),
+):
+    """Export leads from a campaign as CSV."""
+    from oto.tools.lemlist import LemlistClient
+
+    client = LemlistClient()
+    csv_data = client.export_leads(campaign_id)
+    print(csv_data)