cmo-dog 2.0.0__tar.gz

cmo_dog-2.0.0/.env.example

@@ -0,0 +1,20 @@
+BACKBOARD_API_KEY=
+BACKBOARD_ASSISTANT_CONTENT=
+BACKBOARD_ASSISTANT_COMPETITOR=
+BACKBOARD_ASSISTANT_BRAND=
+BACKBOARD_ASSISTANT_AUDIT=
+BACKBOARD_ASSISTANT_STORAGE=
+
+STRIPE_SECRET_KEY=
+STRIPE_WEBHOOK_SECRET=
+STRIPE_PRICE_ID=
+
+# Both point to port 8000 — Next.js handles /api/* proxying to FastAPI internally.
+# For App Runner, set both to your App Runner URL (https://xxx.us-east-1.awsapprunner.com).
+DOMAIN_CLIENT=http://localhost:8000
+DOMAIN_SERVER=http://localhost:8000
+
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+
+ADMIN_EMAILS=you@example.com,other@example.com

cmo_dog-2.0.0/.gitignore

@@ -0,0 +1,20 @@
+.env
+.venv
+uv.lock
+__pycache__/
+*.pyc
+*.pyo
+terraform/terraform.tfvars
+terraform/terraform.tfstate
+terraform/terraform.tfstate.backup
+.DS_Store
+.cursor
+.cursorignore
+ terraform/.terraform.lock.hcl
+terraform/.terraform/
+terraform/bootstrap/.terraform.lock.hcl
+terraform/bootstrap/.terraform/
+terraform/bootstrap/terraform.tfstate
+terraform/bootstrap/terraform.tfstate.backup
+model_list.csv
+terraform/.terraform.lock.hcl

cmo_dog-2.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: cmo-dog
+Version: 2.0.0
+Summary: AI CMO Terminal — Backboard agents for traffic and users
+Requires-Python: >=3.11
+Requires-Dist: apscheduler>=3.10
+Requires-Dist: backboard-sdk>=1.5.0
+Requires-Dist: bcrypt>=4.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: sse-starlette>=2.0
+Requires-Dist: stripe>=11.0
+Requires-Dist: uvicorn[standard]>=0.32.0

cmo_dog-2.0.0/README.md

@@ -0,0 +1,220 @@
+<p align="center">
+  <img src="assets/onni.png" alt="Onni — CMO.dog" width="200" style="border-radius:50%;" />
+</p>
+
+<h1 align="center">CMO.dog</h1>
+
+<p align="center">
+  <strong>Drop in a URL. Onni fetches your Chief Marketing Officer.</strong>
+  <br />
+  A good Finnish dog who audits your site, maps your competitors, and finds your brand voice — in seconds.
+</p>
+
+<p align="center">
+  <a href="https://backboard.io"><img src="https://img.shields.io/badge/Powered%20by-Backboard.io-6366f1?style=flat-square" alt="Powered by Backboard" /></a>
+  <img src="https://img.shields.io/badge/Python-3.11%2B-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python 3.11+" />
+  <img src="https://img.shields.io/badge/Next.js-15-black?style=flat-square&logo=next.js" alt="Next.js 15" />
+  <img src="https://img.shields.io/badge/FastAPI-0.115-009688?style=flat-square&logo=fastapi&logoColor=white" alt="FastAPI" />
+  <img src="https://img.shields.io/badge/license-MIT-brightgreen?style=flat-square" alt="MIT License" />
+</p>
+
+---
+
+## Who is Onni?
+
+Onni is a Finnish dog. In Finnish, *onni* means **luck** — and that's what he brings your marketing.
+
+Hiring a CMO costs $200k/year. Good ones take months to ramp up.
+
+**Onni does it in 60 seconds.**
+
+Type in any URL. Four AI agents fire up in parallel — they read your site, search the web, and hand back:
+
+- A **site audit** with real scores (performance, SEO, accessibility, best practices)
+- A **competitor landscape** with categories and pricing
+- A **brand voice profile** so your copy sounds like *you*
+- A ranked list of **SEO fixes** with step-by-step instructions
+- An **AI chat** interface so you can keep drilling into next steps
+
+No prompt engineering. No setup. Just a URL.
+
+---
+
+## Demo
+
+> Type a URL → watch Onni run → read your marketing brief
+
+```
+> Checking what content and documents you have...
+> Content and documents summarized.
+> Now let me check out your competition...
+> Searching: yoursite.com competitors alternative
+> Evaluating competitor positioning strategy...
+> Competitor analysis complete.
+> Now let me figure out your brand voice...
+> Brand voice guide ready
+> Running website audit...
+> Scanning page structure and metadata...
+> Page speed and core web vitals measured
+> Found 7 SEO optimization opportunities (score: 64/100)
+```
+
+---
+
+## Features
+
+| | |
+|---|---|
+| **Website Audit** | Performance, SEO, Accessibility, and Best Practices scores with specific failing checks and how-to-fix guides |
+| **Competitor Intel** | Direct vs. secondary competitors with pricing — sourced live from the web |
+| **Brand Voice** | 2–3 sentence brand profile your team can actually use |
+| **SEO Fix Queue** | Ranked issues (Critical → High → Medium) with numbered remediation steps |
+| **AI CMO Chat** | Ask follow-up questions about your audit — Onni remembers context |
+| **Live Terminal** | Real-time SSE stream so you see agents working, not a spinner |
+
+---
+
+## Stack
+
+| Layer | Tech |
+|---|---|
+| AI Agents | [Backboard.io](https://backboard.io) — threads, assistants, web search |
+| API | FastAPI + Uvicorn, Server-Sent Events |
+| Frontend | Next.js 15, Tailwind CSS, shadcn/ui |
+| Runtime | Python 3.11+ via `uv`, Node 18+ |
+| Schemas | Pydantic v2 |
+
+---
+
+## Quick Start
+
+### 1. Clone & install
+
+```bash
+git clone https://github.com/your-org/cmo.dog.git
+cd cmo.dog
+
+# Python deps
+uv sync
+
+# Frontend deps
+cd web && npm install && cd ..
+```
+
+### 2. Configure `.env`
+
+```bash
+cp .env.example .env
+```
+
+```env
+BACKBOARD_API_KEY=your_key_here
+
+# Assistant IDs — created once, reused forever (never delete these)
+BACKBOARD_ASSISTANT_CONTENT=asst_...
+BACKBOARD_ASSISTANT_COMPETITOR=asst_...
+BACKBOARD_ASSISTANT_BRAND=asst_...
+BACKBOARD_ASSISTANT_AUDIT=asst_...
+```
+
+> Get a free Backboard API key at [backboard.io](https://backboard.io). Create your four assistants once and paste the IDs here.
+
+### 3. Run
+
+```bash
+./start.sh
+```
+
+API → `http://localhost:8000`  
+App → `http://localhost:3000`
+
+---
+
+## How It Works
+
+```
+User enters URL
+      │
+      ▼
+ FastAPI /runs  ──────────────────────────────────────────────┐
+      │                                                        │
+      │  SSE stream → browser terminal                        │
+      ▼                                                        │
+┌─────────────────────────────────────────────────────────┐   │
+│                  Orchestrator Pipeline                  │   │
+│                                                         │   │
+│  1. Content Agent    → summarize site + docs            │   │
+│  2. Competitor Agent → find rivals, pricing             │   │
+│  3. Brand Agent      → extract voice & tone             │   │
+│  4. Audit Agent      → scores + SEO checks + fixes      │   │
+└─────────────────────────────────────────────────────────┘   │
+      │                                                        │
+      └──────────────── RunStatus (Pydantic) ─────────────────┘
+                             │
+                     GET /runs/{id}
+                             │
+                      Next.js dashboard
+                  (audit · competitors · chat)
+```
+
+Each agent is a [Backboard](https://backboard.io) assistant with live web search enabled — no stale training data, no hallucinated competitors.
+
+---
+
+## Project Structure
+
+```
+cmo.dog/
+├── app/
+│   ├── main.py          # FastAPI routes + SSE
+│   ├── orchestrator.py  # Agent pipeline
+│   └── schemas.py       # Pydantic models
+├── web/
+│   ├── src/app/         # Next.js pages
+│   └── src/components/  # UI components
+├── assets/
+│   └── onni.png         # The dog himself
+├── scripts/             # Smoke tests
+├── pyproject.toml       # uv/hatch config
+└── start.sh             # Clean start script
+```
+
+---
+
+## API
+
+```http
+POST /runs          body: { website_url }   → { run_id }
+GET  /runs/{id}     → RunStatus JSON
+GET  /runs/{id}/stream  → SSE terminal lines
+POST /runs/{id}/chat    body: { message }   → { reply }
+```
+
+---
+
+## Contributing
+
+Pull requests welcome. Keep it surgical — one concern per PR.
+
+- Backend logic lives in `app/` only. No logic in the frontend.
+- Pydantic models for all data shapes.
+- `uv` for Python deps, `npm` for frontend.
+- Never delete Backboard assistants — they carry persistent data.
+
+---
+
+## Built with
+
+- [Backboard.io](https://backboard.io) — AI agent infrastructure
+- [FastAPI](https://fastapi.tiangolo.com)
+- [Next.js](https://nextjs.org)
+- [Tailwind CSS](https://tailwindcss.com)
+- [shadcn/ui](https://ui.shadcn.com)
+
+---
+
+<p align="center">
+  Made with 🐾 and too many competitor analyses.
+  <br />
+  <a href="https://cmo.dog">cmo.dog</a> · <a href="https://backboard.io">backboard.io</a>
+</p>

cmo_dog-2.0.0/app/__init__.py

@@ -0,0 +1 @@
+# AI CMO Terminal API

cmo_dog-2.0.0/app/config.py

@@ -0,0 +1,29 @@
+"""App configuration via pydantic-settings."""
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    backboard_api_key: str = ""
+    backboard_assistant_storage: str = ""
+
+    stripe_secret_key: str = ""
+    stripe_webhook_secret: str = ""
+    stripe_price_id: str = ""
+
+    google_client_id: str = ""
+    google_client_secret: str = ""
+
+    domain_client: str = ""
+    domain_server: str = ""
+    free_prompts_limit: int = 5
+    admin_emails: str = ""  # comma-separated list of admin email addresses
+
+    @property
+    def admin_email_set(self) -> set[str]:
+        return {e.strip().lower() for e in self.admin_emails.split(",") if e.strip()}
+
+
+settings = Settings()

cmo_dog-2.0.0/app/main.py

@@ -0,0 +1,257 @@
+"""FastAPI app: runs API and SSE stream. All logic in API."""
+
+import asyncio
+import csv
+import json
+import os
+import uuid
+from contextlib import asynccontextmanager
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+from fastapi import FastAPI, Header, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from sse_starlette.sse import EventSourceResponse
+
+from app import orchestrator
+from app.config import settings
+from app.routes.auth import router as auth_router
+from app.routes.billing import router as billing_router
+from app.routes.admin import router as admin_router
+from app.routes.monitors import router as monitors_router
+from app.services.monitor_scheduler import start_scheduler, stop_scheduler
+from app.services.user_service import find_user_by_token, increment_prompts
+from app.services.run_history_service import list_runs, get_run_detail
+from pydantic import BaseModel as PydanticBaseModel
+
+from app.schemas import AnalyticsMetric, ChatMessage, FeedItem, RunCreate, RunResponse, RunStatus
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    start_scheduler()
+    yield
+    stop_scheduler()
+
+
+app = FastAPI(title="AI CMO Terminal API", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:8000",
+        "http://127.0.0.1:8000",
+        "http://localhost:9000",
+        "http://127.0.0.1:9000",
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "https://cmo.dog",
+        "https://www.cmo.dog",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(auth_router)
+app.include_router(billing_router)
+app.include_router(admin_router)
+app.include_router(monitors_router)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+@app.post("/api/runs", response_model=RunResponse)
+async def create_run(body: RunCreate, x_user_token: str = Header(None)):
+    if not x_user_token:
+        raise HTTPException(status_code=401, detail="Sign up to use Onni")
+
+    user = await find_user_by_token(x_user_token)
+    if not user:
+        raise HTTPException(status_code=401, detail="Invalid token — sign up again")
+
+    plan = user.get("plan", "free")
+    prompts_used = int(user.get("prompts_used", 0))
+
+    if plan == "free" and prompts_used >= settings.free_prompts_limit:
+        raise HTTPException(
+            status_code=402,
+            detail={
+                "error": "limit_reached",
+                "prompts_used": prompts_used,
+                "prompts_limit": settings.free_prompts_limit,
+            },
+        )
+
+    # Deduct token before the run starts — no matter what happens next
+    try:
+        await increment_prompts(user["user_id"])
+    except Exception as e:
+        print(f"[billing] WARN: increment_prompts failed for {user['user_id']}: {e}")
+
+    run_id = uuid.uuid4().hex[:12]
+    orchestrator._runs[run_id] = RunStatus(
+        run_id=run_id,
+        status="pending",
+        website_url=body.website_url,
+        llm_provider=body.llm_provider,
+        model_name=body.model_name,
+        credits=2000,
+        analytics_overview=[
+            AnalyticsMetric(key="performance", label="Performance", score=44, tone="red"),
+            AnalyticsMetric(key="accessibility", label="Accessibility", score=78, tone="yellow"),
+            AnalyticsMetric(key="best_practices", label="Best Practices", score=73, tone="yellow"),
+            AnalyticsMetric(key="seo", label="SEO", score=92, tone="green"),
+        ],
+        feed_items=[],
+        chat_status="loading",
+    )
+    orchestrator._terminal_lines[run_id] = []
+    orchestrator._terminal_events[run_id] = asyncio.Event()
+
+    asyncio.create_task(
+        orchestrator.run_orchestrator(
+            run_id, body.website_url, plan=plan, user_id=user["user_id"],
+            llm_provider=body.llm_provider, model_name=body.model_name,
+        )
+    )
+
+    return RunResponse(run_id=run_id)
+
+
+@app.get("/api/runs/{run_id}", response_model=RunStatus)
+async def get_run(run_id: str, x_user_token: str = Header(None)):
+    run = orchestrator.get_run(run_id)
+    if run:
+        return run
+    # Fall back to persisted history if not in memory (e.g. after restart)
+    if x_user_token:
+        user = await find_user_by_token(x_user_token)
+        if user:
+            detail = await get_run_detail(run_id, user["user_id"])
+            if detail:
+                return RunStatus(**{k: v for k, v in detail.items() if k in RunStatus.model_fields})
+    raise HTTPException(status_code=404, detail="Run not found")
+
+
+@app.get("/api/history")
+async def get_history(x_user_token: str = Header(None)):
+    if not x_user_token:
+        raise HTTPException(status_code=401, detail="Authentication required")
+    user = await find_user_by_token(x_user_token)
+    if not user:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    summaries = await list_runs(user["user_id"])
+    return {"runs": summaries}
+
+
+async def stream_generator(run_id: str):
+    run = orchestrator.get_run(run_id)
+    if not run:
+        yield {"data": '{"line": "> Run not found."}'}
+        return
+
+    evt = orchestrator.get_terminal_event(run_id)
+    pos = 0
+
+    try:
+        while True:
+            # Replay buffered lines (catches up any client that connected late)
+            lines = orchestrator.get_terminal_lines(run_id)
+            while pos < len(lines):
+                yield {"data": json.dumps({"line": lines[pos]})}
+                pos += 1
+
+            # Done if run has finished
+            r = orchestrator.get_run(run_id)
+            if r and r.status in ("completed", "failed"):
+                break
+
+            # Wait for next line (or timeout to re-check status)
+            evt.clear()
+            try:
+                await asyncio.wait_for(asyncio.shield(evt.wait()), timeout=30.0)
+            except asyncio.TimeoutError:
+                pass
+    except asyncio.CancelledError:
+        pass
+
+
+@app.get("/api/runs/{run_id}/stream")
+async def stream_run(run_id: str):
+    if not orchestrator.get_run(run_id):
+        raise HTTPException(status_code=404, detail="Run not found")
+    return EventSourceResponse(stream_generator(run_id))
+
+
+class ChatRequest(PydanticBaseModel):
+    message: str
+
+
+@app.post("/api/runs/{run_id}/chat")
+async def chat(run_id: str, body: ChatRequest):
+    run = orchestrator.get_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    run.chat_messages.append(ChatMessage(role="user", content=body.message))
+    reply = await orchestrator.chat_reply(run_id, body.message)
+    run.chat_messages.append(ChatMessage(role="assistant", content=reply))
+    return {"messages": run.chat_messages}
+
+
+_EXCLUDED_PROVIDERS: set[str] = set()
+
+@lru_cache(maxsize=1)
+def _load_model_list() -> dict[str, Any]:
+    """Parse model_list.csv once and return provider-grouped data."""
+    csv_path = Path(__file__).parent.parent / "model_list.csv"
+    providers: dict[str, list[dict]] = {}
+
+    if not csv_path.exists():
+        return {"providers": [], "models": {}}
+
+    with open(csv_path, newline="") as f:
+        for row in csv.DictReader(f):
+            if row.get("model_type") != "llm":
+                continue
+            if row.get("supports_tools") != "True":
+                continue
+            provider = row.get("provider", "")
+            if provider in _EXCLUDED_PROVIDERS:
+                continue
+            try:
+                input_cost = float(row.get("input_cost_per_1m_tokens") or 0)
+                output_cost = float(row.get("output_cost_per_1m_tokens") or 0)
+                context = int(row.get("context_limit") or 0)
+            except (ValueError, TypeError):
+                continue
+            providers.setdefault(provider, []).append({
+                "id": row["name"],
+                "context": context,
+                "input_cost": input_cost,
+                "output_cost": output_cost,
+            })
+
+    return {
+        "providers": sorted(providers.keys()),
+        "models": providers,
+    }
+
+
+@app.get("/api/models")
+async def get_models():
+    return _load_model_list()
+
+
+def run():
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=9000, reload=True)