@robbiesrobotics/alice-agents 1.5.8 → 1.5.9

package/templates/workspaces/dylan/stripe-webhook-handler.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+"""
+A.L.I.C.E. Stripe Webhook Handler
+Runs on: Ubuntu Desktop (alpha@100.106.110.119)
+Port: 5001 (FLASK_PORT)
+
+Handles: checkout.session.completed
+Actions:
+  1. Validate Stripe webhook signature
+  2. Generate license key (ALICE-XXXX-XXXX-XXXX)
+  3. Write to Supabase licenses + teams + team_tokens tables
+  4. Trigger n8n welcome email workflow
+
+Usage:
+  python3 stripe-webhook-handler.py
+
+For local testing:
+  python3 stripe-webhook-handler.py --test
+"""
+
+import os
+import sys
+import json
+import re
+import hmac
+import hashlib
+import logging
+import argparse
+from datetime import datetime, timezone
+from typing import Optional
+
+import stripe
+import supabase
+import requests
+from flask import Flask, request, jsonify
+
+# ─── Logging ──────────────────────────────────────────────────────────────────
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s — %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+logger = logging.getLogger("stripe-webhook")
+
+
+# ─── Config ───────────────────────────────────────────────────────────────────
+
+def _require_env(name: str) -> str:
+    val = os.environ.get(name)
+    if not val:
+        raise RuntimeError(f"Missing required environment variable: {name}")
+    return val
+
+
+class Config:
+    # Stripe
+    STRIPE_SECRET_KEY: str = _require_env("STRIPE_SECRET_KEY")
+    STRIPE_WEBHOOK_SECRET: str = _require_env("STRIPE_WEBHOOK_SECRET")
+
+    # Supabase
+    SUPABASE_URL: str = _require_env("SUPABASE_URL")
+    SUPABASE_SERVICE_ROLE_KEY: str = _require_env("SUPABASE_SERVICE_ROLE_KEY")
+
+    # n8n welcome email trigger
+    N8N_WEBHOOK_URL: str = _require_env(
+        "N8N_WEBHOOK_URL"
+    )  # e.g. http://100.106.110.119:5678/webhook/stripe-checkout-completed
+
+    # Flask
+    FLASK_PORT: int = int(os.environ.get("FLASK_PORT", "5001"))
+    FLASK_HOST: str = os.environ.get("FLASK_HOST", "0.0.0.0")
+
+
+# ─── App ──────────────────────────────────────────────────────────────────────
+
+app = Flask(__name__)
+
+
+# ─── License Key Generation ───────────────────────────────────────────────────
+
+def generate_license_key() -> str:
+    """Generate an A.L.I.C.E. license key: ALICE-XXXX-XXXX-XXXX"""
+    import secrets
+    chunks = [secrets.token_hex(2).upper() for _ in range(3)]
+    return "ALICE-" + "-".join(chunks)
+
+
+# ─── Supabase Helpers ─────────────────────────────────────────────────────────
+
+def get_supabase_client():
+    return supabase.create_client(
+        Config.SUPABASE_URL,
+        Config.SUPABASE_SERVICE_ROLE_KEY,
+    )
+
+
+def find_existing_license(sb, stripe_session_id: str) -> Optional[dict]:
+    """Check if license already exists for this Stripe session (deduplication)."""
+    resp = (
+        sb.table("licenses")
+        .select("key, email, plan, stripe_session_id")
+        .eq("stripe_session_id", stripe_session_id)
+        .maybe_single()
+    )
+    return resp.data
+
+
+def insert_license(sb, email: str, plan: str, stripe_session_id: str, stripe_customer_id: Optional[str]):
+    """Insert a new license record and return it."""
+    import secrets
+    license_key = generate_license_key()
+    resp = (
+        sb.table("licenses")
+        .insert({
+            "email": email,
+            "plan": plan,
+            "stripe_session_id": stripe_session_id,
+            "stripe_customer_id": stripe_customer_id,
+            "metadata": {"source": "stripe-webhook-handler.py"},
+        })
+        .execute()
+    )
+    if not resp.data:
+        raise RuntimeError("License insert returned no data")
+    # Override the auto-generated key with our deterministic one
+    created = resp.data[0]
+    upd = sb.table("licenses").update({"key": license_key}).eq("id", created["id"]).execute()
+    created["key"] = license_key
+    return created
+
+
+def provision_team_and_tokens(sb, license_key: str, email: str):
+    """
+    Provision a team + ingest/worker tokens for Mission Control.
+    Returns (team_id, ingest_token, worker_token) on success, (None, '', '') on failure.
+    """
+    import secrets
+
+    # Slug from email: normalize and append timestamp
+    slug_base = re.sub(r"[^a-z0-9]", "-", email.lower())[:50]
+    slug = f"{slug_base}-{int(datetime.now(timezone.utc).timestamp())}"
+
+    team_resp = sb.table("teams").insert({
+        "name": f"{email}'s Team",
+        "slug": slug,
+        "plan": "pro",
+        "owner_email": email,
+    }).execute()
+
+    if not team_resp.data:
+        logger.warning("Team insert failed — continuing without team tokens")
+        return None, "", ""
+
+    team_id = team_resp.data[0]["id"]
+    ingest_token = "mc_ingest_" + secrets.token_hex(32)
+    worker_token = "mc_worker_" + secrets.token_hex(32)
+
+    token_resp = sb.table("team_tokens").insert({
+        "team_id": team_id,
+        "license_key": license_key,
+        "ingest_token": ingest_token,
+        "worker_token": worker_token,
+    }).execute()
+
+    if not token_resp.data:
+        logger.warning("Token insert failed — continuing without tokens")
+        return team_id, "", ""
+
+    return team_id, ingest_token, worker_token
+
+
+# ─── n8n Welcome Email Trigger ───────────────────────────────────────────────
+
+def trigger_n8n_welcome_email(
+    license_key: str,
+    email: str,
+    plan: str,
+    ingest_token: str,
+    worker_token: str,
+    alice_cloud_token: str,
+):
+    """
+    POST to the n8n webhook URL to trigger the welcome email workflow.
+    n8n will use the template variables to render the full welcome email.
+    """
+    payload = {
+        "license_key": license_key,
+        "email": email,
+        "plan": plan,
+        "ingest_token": ingest_token,
+        "worker_token": worker_token,
+        "alice_cloud_token": alice_cloud_token,
+        # Timestamp for audit
+        "purchased_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    try:
+        resp = requests.post(
+            Config.N8N_WEBHOOK_URL,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=15,
+        )
+        resp.raise_for_status()
+        logger.info(
+            f"n8n welcome email triggered for {email} — status {resp.status_code}"
+        )
+        return True
+    except requests.RequestException as exc:
+        logger.error(f"n8n webhook failed: {exc}")
+        return False
+
+
+# ─── Stripe Signature Verification ───────────────────────────────────────────
+
+def verify_stripe_signature(body: bytes, sig_header: str) -> stripe.Event:
+    """Verify and construct a Stripe event from the raw request body."""
+    try:
+        event = stripe.Webhook.construct_event(body, sig_header, Config.STRIPE_WEBHOOK_SECRET)
+    except stripe.error.SignatureVerificationError as exc:
+        logger.warning(f"Stripe signature verification failed: {exc}")
+        raise
+    return event
+
+
+# ─── Webhook Handler ───────────────────────────────────────────────────────────
+
+@app.route("/webhook/stripe", methods=["POST"])
+def handle_stripe_webhook():
+    """Main Stripe webhook endpoint. Expects Stripe-Signature header."""
+
+    # Get raw body for signature verification
+    body = request.get_data()
+    sig_header = request.headers.get("Stripe-Signature", "")
+
+    if not sig_header:
+        logger.warning("Missing Stripe-Signature header")
+        return jsonify({"error": "Missing Stripe-Signature header"}), 400
+
+    # Verify signature
+    try:
+        event = verify_stripe_signature(body, sig_header)
+    except Exception:
+        return jsonify({"error": "Signature verification failed"}), 400
+
+    logger.info(f"Received Stripe event: {event.type} (id={event.id})")
+
+    if event.type != "checkout.session.completed":
+        logger.info(f"Ignoring event type: {event.type}")
+        return jsonify({"received": True, "ignored": True})
+
+    session = event.data.object
+
+    # Extract email
+    email = session.get("customer_details", {}).get("email") or session.get("customer_email")
+    if not email:
+        logger.warning("No email in checkout session")
+        return jsonify({"error": "No email in session"}), 400
+
+    # Extract plan from metadata
+    plan = session.metadata.get("plan", "pro") if session.metadata else "pro"
+    if plan not in ("pro", "cloud"):
+        plan = "pro"
+
+    stripe_session_id = session.id
+    stripe_customer_id = session.customer if isinstance(session.customer, str) else None
+
+    logger.info(
+        f"Processing checkout.completed — email={email} plan={plan} session={stripe_session_id}"
+    )
+
+    sb = get_supabase_client()
+
+    # Deduplication check
+    existing = find_existing_license(sb, stripe_session_id)
+    if existing:
+        logger.info(f"License already exists for session {stripe_session_id} — skipping")
+        return jsonify({"received": True, "deduplicated": True})
+
+    # Insert license
+    try:
+        license_record = insert_license(sb, email, plan, stripe_session_id, stripe_customer_id)
+        license_key = license_record["key"]
+        logger.info(f"License created: {license_key}")
+    except Exception as exc:
+        logger.error(f"Failed to create license: {exc}")
+        return jsonify({"error": "Failed to create license"}), 500
+
+    # Provision team + tokens
+    team_id, ingest_token, worker_token = provision_team_and_tokens(sb, license_key, email)
+
+    # alice_cloud_token is the ingest token (same concept, different name)
+    alice_cloud_token = ingest_token
+
+    # Trigger n8n welcome email workflow
+    n8n_ok = trigger_n8n_welcome_email(
+        license_key=license_key,
+        email=email,
+        plan=plan,
+        ingest_token=ingest_token,
+        worker_token=worker_token,
+        alice_cloud_token=alice_cloud_token,
+    )
+
+    if not n8n_ok:
+        logger.warning("n8n trigger failed — email may not be sent")
+
+    return jsonify({
+        "received": True,
+        "license_key": license_key,
+        "email": email,
+        "plan": plan,
+        "team_provisioned": team_id is not None,
+        "n8n_triggered": n8n_ok,
+    })
+
+
+@app.route("/health", methods=["GET"])
+def health():
+    """Health check endpoint."""
+    return jsonify({"status": "ok", "service": "stripe-webhook-handler"})
+
+
+# ─── Test / Mock Mode ──────────────────────────────────────────────────────────
+
+@app.route("/test/mock-webhook", methods=["POST"])
+def handle_mock_webhook():
+    """
+    Internal test endpoint — simulates a checkout.session.completed event
+    without Stripe signature validation. DO NOT expose in production.
+    """
+    body = request.get_json() or {}
+
+    email = body.get("email", "test@example.com")
+    plan = body.get("plan", "pro")
+
+    logger.info(f"[MOCK] Processing mock checkout — email={email} plan={plan}")
+
+    import secrets
+    license_key = generate_license_key()
+    stripe_session_id = "cs_test_mock_" + secrets.token_hex(16)
+    stripe_customer_id = None
+
+    sb = get_supabase_client()
+
+    # Check existing
+    existing = find_existing_license(sb, stripe_session_id)
+    if existing:
+        return jsonify({"received": True, "deduplicated": True, "key": existing["key"]})
+
+    # Insert
+    resp = (
+        sb.table("licenses")
+        .insert({
+            "email": email,
+            "plan": plan,
+            "stripe_session_id": stripe_session_id,
+            "stripe_customer_id": stripe_customer_id,
+            "metadata": {"source": "stripe-webhook-handler.py:test"},
+        })
+        .execute()
+    )
+    created = resp.data[0]
+
+    # Update with deterministic key
+    sb.table("licenses").update({"key": license_key}).eq("id", created["id"]).execute()
+    created["key"] = license_key
+
+    # Provision team + tokens
+    team_id, ingest_token, worker_token = provision_team_and_tokens(sb, license_key, email)
+
+    # Trigger n8n
+    alice_cloud_token = ingest_token
+    n8n_ok = trigger_n8n_welcome_email(
+        license_key=license_key,
+        email=email,
+        plan=plan,
+        ingest_token=ingest_token,
+        worker_token=worker_token,
+        alice_cloud_token=alice_cloud_token,
+    )
+
+    return jsonify({
+        "received": True,
+        "license_key": license_key,
+        "email": email,
+        "plan": plan,
+        "team_provisioned": team_id is not None,
+        "ingest_token": ingest_token,
+        "worker_token": worker_token,
+        "n8n_triggered": n8n_ok,
+    })
+
+
+# ─── CLI ───────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="A.L.I.C.E. Stripe Webhook Handler")
+    parser.add_argument("--test", action="store_true", help="Run in test mode (mock endpoint only)")
+    args = parser.parse_args()
+
+    if args.test:
+        logger.info("Starting in TEST mode (no Stripe signature required)")
+        # Override to run a simple test server without loading full config
+        # (full config still loaded so we can use it)
+
+    try:
+        # Verify config loads before starting server
+        _ = Config.STRIPE_SECRET_KEY
+        _ = Config.STRIPE_WEBHOOK_SECRET
+        _ = Config.SUPABASE_URL
+        _ = Config.SUPABASE_SERVICE_ROLE_KEY
+        _ = Config.N8N_WEBHOOK_URL
+        logger.info("Config validated successfully")
+    except RuntimeError as exc:
+        logger.error(f"Config error: {exc}")
+        logger.error("Copy .env.example to ~/alice-observability/.env and fill in Rob's keys")
+        sys.exit(1)
+
+    logger.info(
+        f"Starting Flask server on {Config.FLASK_HOST}:{Config.FLASK_PORT}"
+    )
+    app.run(
+        host=Config.FLASK_HOST,
+        port=Config.FLASK_PORT,
+        debug=False,
+        threaded=True,
+    )
+
+
+if __name__ == "__main__":
+    main()

package/templates/workspaces/dylan/test_mock_webhook.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+test_mock_webhook.py — Local test for stripe-webhook-handler.py
+
+Usage (from Ubuntu Desktop):
+  python3 test_mock_webhook.py
+
+This script:
+1. Starts the webhook handler in a subprocess
+2. Sends a mock checkout.session.completed event to /test/mock-webhook
+3. Verifies the license was created in Supabase
+4. Kills the handler
+
+Requirements: Same env vars as stripe-webhook-handler.py (except STRIPE_WEBHOOK_SECRET
+is not needed for the /test/mock-webhook endpoint).
+"""
+
+import os
+import sys
+import json
+import time
+import subprocess
+import signal
+import requests
+
+HANDLER_HOST = os.environ.get("FLASK_HOST", "0.0.0.0")
+HANDLER_PORT = os.environ.get("FLASK_PORT", "5001")
+BASE_URL = f"http://{HANDLER_HOST}:{HANDLER_PORT}"
+
+MOCK_PAYLOAD = {
+    "email": "test-pipeline@dylan.local",
+    "plan": "pro",
+}
+
+
+def wait_for_handler(timeout=10):
+    start = time.time()
+    while time.time() - start < timeout:
+        try:
+            r = requests.get(f"{BASE_URL}/health", timeout=1)
+            if r.status_code == 200:
+                return True
+        except requests.RequestException:
+            pass
+        time.sleep(0.5)
+    return False
+
+
+def main():
+    handler_proc = None
+    try:
+        # Start the handler as a subprocess
+        print("[test] Starting webhook handler...")
+        handler_proc = subprocess.Popen(
+            [sys.executable, "stripe-webhook-handler.py"],
+            cwd=os.path.dirname(os.path.abspath(__file__)) or ".",
+            env=os.environ,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            preexec_fn=os.setsid,
+        )
+
+        # Wait for it to come up
+        if not wait_for_handler():
+            print("[test] FAIL: Handler did not come up in time")
+            return 1
+
+        print("[test] Handler is up. Sending mock webhook...")
+
+        # Send mock event
+        resp = requests.post(
+            f"{BASE_URL}/test/mock-webhook",
+            json=MOCK_PAYLOAD,
+            headers={"Content-Type": "application/json"},
+            timeout=15,
+        )
+
+        print(f"[test] Response status: {resp.status_code}")
+        print(f"[test] Response body: {json.dumps(resp.json(), indent=2)}")
+
+        if resp.status_code != 200:
+            print("[test] FAIL: Non-200 response")
+            return 1
+
+        data = resp.json()
+        if not data.get("received"):
+            print("[test] FAIL: Handler did not process event")
+            return 1
+
+        print(f"[test] PASS: License created: {data.get('license_key')}")
+        print(f"[test] Team provisioned: {data.get('team_provisioned')}")
+        print(f"[test] n8n triggered: {data.get('n8n_triggered')}")
+        return 0
+
+    finally:
+        if handler_proc:
+            print("[test] Stopping handler...")
+            os.killpg(os.getpgid(handler_proc.pid), signal.SIGTERM)
+            handler_proc.wait(timeout=5)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/templates/workspaces/elena/AGENTS.md

@@ -0,0 +1,59 @@
+# AGENTS.md - Elena's Operating Instructions
+
+## Session Startup
+
+1. Read `SOUL.md` — this is who you are
+2. Read `PLAYBOOK.md` (if exists) — your evolved domain expertise, proven patterns
+3. Read `FEEDBACK.md` (if exists) — recent user feedback to incorporate
+4. Skim `LEARNINGS.md` (last 10 entries) — recent task lessons
+5. Read the task you've been given — focus on delivering results
+6. Check `memory/` for relevant prior work
+
+## Your Role
+
+You are **Elena**, the **Estimation** specialist. Project estimation, cost analysis, timeline planning, scoping.
+
+## How You Work
+
+- You receive tasks from A.L.I.C.E. (the orchestrator, also called Alice) via sessions_spawn
+- Do your work using your available tools
+- Return clear, structured results
+- If you need another specialist's help, say so explicitly (e.g., "This also needs Dylan for implementation")
+- Keep notes in `memory/YYYY-MM-DD.md` for continuity
+
+## Output Format
+
+Structure your responses clearly:
+1. **Summary** — one-line answer
+2. **Details** — the actual work/analysis
+3. **Recommendations** — next steps or suggestions
+4. **Collaboration needs** — other specialists to involve (if any)
+
+## Post-Task Reflection
+
+After completing any non-trivial task, append a structured entry to `LEARNINGS.md`:
+
+```
+### YYYY-MM-DD — [one-line task summary]
+- **Outcome:** success | partial | failed
+- **What worked:** [approach, tool, pattern that helped]
+- **What to improve:** [what you'd do differently next time]
+- **Reusable pattern:** [any generalizable insight worth promoting to PLAYBOOK]
+```
+
+Skip this for trivial lookups or single-command tasks. Write it for anything involving judgment, multi-step work, or novel problems.
+
+## Red Lines
+
+- Don't exceed your domain without flagging it
+- Don't run destructive commands without explicit risk callout
+- `trash` > `rm`
+
+## Tier Note
+
+{{#if isPro}}
+You are a **Pro tier** agent. Pro tier requires a valid A.L.I.C.E. Pro license key stored at `~/.alice/license`.
+If you were installed without a license key, run the installer interactively to enter your key:
+`npx @robbiesrobotics/alice-agents`
+Purchase or manage your license at: https://getalice.av3.ai/pricing
+{{/if}}

package/templates/workspaces/elena/FEEDBACK.md

@@ -0,0 +1,11 @@
+# FEEDBACK.md — User Feedback Log
+
+_Olivia writes here when Rob provides feedback about your work._
+
+## Active Feedback
+
+_No feedback yet._
+
+## Resolved
+
+_Items addressed and incorporated into PLAYBOOK.md._

package/templates/workspaces/elena/HEARTBEAT.md

@@ -0,0 +1,9 @@
+# HEARTBEAT.md - Elena's Heartbeat
+
+## Status
+
+Elena is a reactive specialist — no active autonomous monitoring loops. Heartbeats used for periodic self-audits.
+
+## No Active Cron Jobs
+
+Elena operates on-demand through Olivia's spawning.

package/templates/workspaces/elena/IDENTITY.md

@@ -0,0 +1,6 @@
+# IDENTITY.md
+
+- **Name:** Elena
+- **Creature:** Estimation specialist in the A.L.I.C.E. team
+- **Vibe:** Focused, competent, domain-expert
+- **Emoji:** 📋

package/templates/workspaces/elena/LEARNINGS.md

@@ -0,0 +1,5 @@
+# LEARNINGS.md — Task Reflections
+
+_After completing non-trivial tasks, append a structured reflection here._
+
+<!-- Entries below, newest first -->

package/templates/workspaces/elena/MEMORY.md

@@ -0,0 +1,22 @@
+# MEMORY.md — Elena
+
+> Persistent memory for Elena, Estimation specialist.
+> This file is yours — add notes, context, and learnings that should persist across sessions.
+
+## Identity
+
+- **Name:** Elena
+- **Domain:** Estimation
+- **Team:** A.L.I.C.E.
+
+## Active Projects
+
+<!-- Add ongoing projects and their current status here -->
+
+## Key Notes
+
+<!-- Jot down anything important to remember across sessions -->
+
+## Decisions Made
+
+<!-- Record significant decisions and their rationale -->

package/templates/workspaces/elena/PLAYBOOK.md

@@ -0,0 +1,16 @@
+# PLAYBOOK.md — Evolved Domain Expertise
+
+_This file is your accumulated wisdom. Olivia curates it from your LEARNINGS.md and FEEDBACK.md._
+_Consult this before starting any task._
+
+## Patterns
+
+_Nothing yet — complete tasks and reflect to build your playbook._
+
+## Anti-Patterns
+
+_Approaches to avoid, learned from experience._
+
+## Preferences
+
+_User preferences and standards relevant to your domain._

package/templates/workspaces/elena/SOUL.md

@@ -23,7 +23,7 @@ _You are Elena, part of the A.L.I.C.E. multi-agent team._
 
 ## Boundaries
 
-- You do NOT talk to {{userName}} directly — A.L.I.C.E. handles that
+- You do NOT talk to Rob directly — A.L.I.C.E. handles that
 - Technical implementation details that affect estimates go through Dylan
 - Budget implications of estimates go to Audrey
 - Project execution and delivery management goes to Parker