sipi-bot 0.1.0__py3-none-any.whl

sipi_bot-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: sipi-bot
+Version: 0.1.0
+Summary: The spend firewall for autonomous AI agents — approve, block, or flag every transaction before a dollar moves.
+Author-email: Sipi <sales@sipiteno.com>
+License: MIT
+Project-URL: Homepage, https://sipi.bot
+Project-URL: Repository, https://github.com/kindrat86/sipi-bot
+Project-URL: Live Dashboard, https://sipi.bot/dashboard
+Project-URL: Eval Report, https://sipi.bot/eval
+Keywords: ai-agents,agent-economy,mcp,spend-control,guardrails,agent-safety,x402,autonomous-agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Dynamic: license-file
+
+# sipi.bot — the spend firewall for autonomous AI agents
+
+> You gave an autonomous agent your credit card and no spending limit.
+> **sipi.bot** is the firewall that approves, blocks, or flags every
+> transaction against *your* rules — before a single dollar moves.
+
+One capability, three surfaces:
+
+- **MCP tool** — Claude Code / Cursor / Hermes call `evaluate_spend` natively.
+- **HTTP API** — any agent `POST /v1/transactions/evaluate`.
+- **CLI** — verify without an agent.
+
+## 10-second test
+
+```bash
+pip install sipi-bot
+sipi-bot eval --amount 6200 --merchant unknown-gpu.ru --category compute
+# -> {"decision": "BLOCKED", "reason": "Transaction $6,200.00 exceeds per-transaction limit $500.00."}
+
+sipi-bot serve --port 8080   # landing + dashboard + API
+```
+
+Or from source:
+
+```bash
+python3.11 -m spendfirewall.cli eval --amount 6200 --merchant unknown-gpu.ru --category compute
+```
+
+Then open http://localhost:8080 (landing), http://localhost:8080/dashboard (control room), http://localhost:8080/pricing (Team $99 / Business $499).
+
+**Hosted:** [sipi.bot](https://sipi.bot) · [dashboard](https://sipi.bot/dashboard) · [get an API key →](https://sipi.bot/pricing)
+
+## The core call an agent makes before spending
+
+```bash
+curl -X POST https://sipi.bot/v1/transactions/evaluate \
+  -H "Authorization: Bearer sk_live_..." \
+  -d '{"amount": 6200, "merchant": "unknown-gpu.ru", "category": "compute"}'
+```
+
+Returns one of: `APPROVED` (go), `BLOCKED` (do not spend), `FLAGGED` (human must approve).
+
+## Rule types
+
+`per_transaction`, `daily_total`, `velocity` (runaway protection), `merchant_block`,
+`merchant_allow` (allowlist), `category_limit`, `time_window`, `approval_threshold`.
+
+First `BLOCKED` wins. `FLAGGED` is non-blocking (queued for human approval).
+
+## Eval gym (the guarantee + the sales asset)
+
+```bash
+python3.11 -m spendfirewall.eval.run_eval   # 53 scenarios -> eval_report.json + .md
+```
+
+53/53 passing. Served live at `/eval`. This is what backs the guarantee:
+*if the firewall green-lights a spend that breaks your rule, that month is free.*
+
+## MCP config
+
+```json
+{ "mcpServers": { "sipi-bot": { "command": "python", "args": ["-m", "spendfirewall.mcp_server"] } } }
+```
+
+## Framework integrations
+
+Drop-in "spend guardrails" recipes — each verified live against https://sipi.bot:
+
+- [LangChain & CrewAI](integrations/SPEND_GUARDRAILS_RECIPE.md) — `@tool` / `BaseTool` wrappers + zero-dep `sipi_guard.py` client
+- [OpenAI Agents SDK](integrations/openai-agents-sdk.md) — `@function_tool` guard
+- [Vercel AI SDK](integrations/vercel-ai-sdk.md) — `tool({execute})` guard + `sipiGuard.ts` client
+
+The core call is always the same: `evaluate(amount, merchant, category)` → `APPROVED` / `BLOCKED` / `FLAGGED`.
+
+## Deploy (Fly.io)
+
+```bash
+flyctl launch --no-deploy --copy-config --name sipi-bot-firewall
+flyctl volumes create sf_data --size 1 --region iad --yes
+flyctl deploy
+flyctl certs add sipi.bot
+```
+
+Stdlib-only (http.server, sqlite3). No framework, trivial deploy. `pip install mcp` only for the MCP surface.

sipi_bot-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+sipi_bot-0.1.0.dist-info/licenses/LICENSE,sha256=kYWGb6dxxrW86NgCVy2OJYAy5u8ZI9Q0LzDTavSc3A8,1072
+spendfirewall/__init__.py,sha256=FWwfHj4s5Uvnzzb4FKxL7HcP8fU9vZ0RwVU4xzu5MyA,214
+spendfirewall/api.py,sha256=UXTtn_teyXESg6MnMHQPIjT1Denl1Xz1_YFxmNTedWA,18499
+spendfirewall/billing.py,sha256=URPrJRjbYzMvfldj7xBc2V04QViwiGFW6hqYMh-6XFI,8085
+spendfirewall/cli.py,sha256=mWnlHwzxAx_ZG4GeseSHo6kAXQs643mlGzd2UwHiAfY,1932
+spendfirewall/core.py,sha256=B_VfhnWqThnNqiBTQuWDyg7SPZBxiC8Eo4A1q7vM-QY,2170
+spendfirewall/engine.py,sha256=8k965eIdaImVAGtd3tyhj8ZrbSHSyL8O6tqtohqq568,9297
+spendfirewall/mcp_server.py,sha256=ajq1Q6FTcueKmHcx__NchqJFoZZeHnBiRNhRtbUAvhQ,2478
+spendfirewall/store.py,sha256=HxmaU6NEtCDm9J8SMz7qcvM5g5SiVNseCmPlsfh0j4s,11568
+spendfirewall/templates.py,sha256=eFSD4UARH1bX_kxIG_vuLQZyWt_vdpw8fGxxmUetKrs,55597
+spendfirewall/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spendfirewall/eval/eval_scenarios.py,sha256=6aKBqZGo9dD9td7ibGgxAg7LIDNncBWvQZ8QNafZMyc,14703
+spendfirewall/eval/run_eval.py,sha256=Y9E7cUlfx_MeIl27H8v4JXP9sMR12EQ6CJ_m1bu75GE,6417
+sipi_bot-0.1.0.dist-info/METADATA,sha256=bOV9qoSliB3WnlRi9arH-uRmhW09JXu31oZd2WraR88,4090
+sipi_bot-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+sipi_bot-0.1.0.dist-info/entry_points.txt,sha256=YWf94vM_saXJAyFgluo5QN4YpekjZcJozs0T-v61KYc,52
+sipi_bot-0.1.0.dist-info/top_level.txt,sha256=iQ9IUssgjSISyTEG6ojQnVHq7N2DWPomWf2B2Q6vzx8,14
+sipi_bot-0.1.0.dist-info/RECORD,,

sipi_bot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sipi_bot-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sipi-bot = spendfirewall.cli:main

sipi_bot-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sipi (sipi.bot)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sipi_bot-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+spendfirewall

spendfirewall/__init__.py

@@ -0,0 +1,8 @@
+"""Sipi.bot — the spend firewall for autonomous AI agents.
+
+We make sure no agent ever spends a dollar you didn't authorize.
+"""
+
+__version__ = "0.1.0"
+__product__ = "Sipi Spend Firewall"
+__domain__ = "sipi.bot"

spendfirewall/api.py

@@ -0,0 +1,409 @@
+"""api.py — HTTP API + dashboard server + SSE + agent-card + eval report.
+
+Stdlib only (http.server). Serves:
+  GET  /                          landing page
+  GET  /dashboard                 control room
+  GET  /health                    {"ok": true}
+  GET  /.well-known/agent-card.json   agent discoverability
+  GET  /eval                      last eval report (JSON) — the sales asset
+  POST /v1/transactions/evaluate  THE core call (auth optional in free mode)
+  GET  /v1/activity               SSE live stream
+  GET  /api/stats                 dashboard aggregates
+  GET  /api/transactions          recent txns
+  GET  /api/approvals             pending approvals
+  POST /api/approvals/<id>        resolve {decision}
+  GET  /api/rules                 list rules
+  POST /api/rules                 add rule
+  DELETE /api/rules/<id>          delete rule
+  GET  /api/agents                list agents
+  POST /api/agents                register agent -> api key
+  POST /subscribe                 email capture
+"""
+from __future__ import annotations
+
+import json
+import os
+import queue
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlparse
+
+from . import __version__, core, store, templates
+from . import billing
+
+_SUBSCRIBERS: list[queue.Queue] = []
+_SUB_LOCK = threading.Lock()
+_EVAL_REPORT_PATH = os.environ.get("EVAL_REPORT", os.path.join(os.getcwd(), "eval_report.json"))
+_SUBSCRIBERS_FILE = os.environ.get("SUBS_FILE", os.path.join(os.getcwd(), "subscribers.txt"))
+
+
+def _broadcast(event: dict) -> None:
+    data = json.dumps(event)
+    with _SUB_LOCK:
+        dead = []
+        for q in _SUBSCRIBERS:
+            try:
+                q.put_nowait(data)
+            except Exception:
+                dead.append(q)
+        for q in dead:
+            _SUBSCRIBERS.remove(q)
+
+
+def agent_card() -> dict:
+    return {
+        "name": "sipi.bot Spend Firewall",
+        "description": "Approves, blocks, or flags every transaction an autonomous AI agent "
+                       "proposes, against configurable spend rules. The firewall for the agent economy.",
+        "version": __version__,
+        "url": "https://sipi.bot",
+        "provider": {"organization": "sipi.bot", "url": "https://sipi.bot"},
+        "capabilities": {"streaming": True},
+        "skills": [{
+            "id": "evaluate_transaction",
+            "name": "Evaluate a spend",
+            "description": "Given amount, merchant, category, returns APPROVED, BLOCKED, or FLAGGED.",
+            "tags": ["spend-control", "policy", "guardrail", "agent-safety"],
+            "examples": ["Can my agent spend $6200 at unknown-gpu.ru?"],
+        }],
+        "endpoints": {
+            "evaluate": "https://sipi.bot/v1/transactions/evaluate",
+            "activity": "https://sipi.bot/v1/activity",
+            "eval_report": "https://sipi.bot/eval",
+        },
+    }
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.0"
+
+    def log_message(self, *a):  # quieter logs
+        pass
+
+    def _send(self, code: int, body: bytes, ctype="application/json", noindex=False):
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        if noindex:
+            # Machine endpoints (JSON) should not appear in search indexes.
+            self.send_header("X-Robots-Tag", "noindex")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Connection", "close")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Headers", "Authorization,Content-Type")
+        self.send_header("Access-Control-Allow-Methods", "GET,POST,DELETE,OPTIONS,HEAD")
+        # Security headers (Technical SEO + hardening)
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("X-Frame-Options", "SAMEORIGIN")
+        self.send_header("Referrer-Policy", "strict-origin-when-cross-origin")
+        self.send_header("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
+        self.close_connection = True
+        self.end_headers()
+        if getattr(self, "_head_only", False):
+            return
+        self.wfile.write(body)
+        self.wfile.flush()
+
+    def do_HEAD(self):
+        """Mirror do_GET but suppress the body (fixes 501-on-HEAD; crawlers/audits use HEAD)."""
+        self._head_only = True
+        try:
+            self.do_GET()
+        finally:
+            self._head_only = False
+
+    def _json(self, code, obj, noindex=False):
+        self._send(code, json.dumps(obj).encode(), "application/json", noindex=noindex)
+
+    def _html(self, html: str):
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Cache-Control", "public, max-age=3600, s-maxage=86400, stale-while-revalidate=604800")
+        self.send_header("Strict-Transport-Security", "max-age=63072000; includeSubDomains; preload")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("X-Frame-Options", "DENY")
+        self.send_header("Referrer-Policy", "strict-origin-when-cross-origin")
+        self.send_header("Content-Security-Policy", "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://js.stripe.com https://eu.i.posthog.com https://eu-assets.i.posthog.com https://eu.posthog.com https://checkout.stripe.com; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https://eu.i.posthog.com https://eu-assets.i.posthog.com https://sipi.bot; frame-ancestors 'none'; object-src 'none'; base-uri 'self'; frame-src https://js.stripe.com https://checkout.stripe.com")
+        self.send_header("Permissions-Policy", "camera=(), microphone=(), geolocation=(), payment=(), usb=(), browsing-topics=(), interest-cohort=()")
+        self.end_headers()
+        self.wfile.write(html.encode())
+
+    def _body(self) -> dict:
+        try:
+            n = int(self.headers.get("Content-Length", 0))
+            if n <= 0:
+                return {}
+            return json.loads(self.rfile.read(n) or b"{}")
+        except Exception:
+            return {}
+
+    def do_OPTIONS(self):
+        self._send(204, b"")
+
+    def do_GET(self):
+        path = urlparse(self.path).path
+
+        # SEO: redirect www to apex
+        if 'host' in (h.lower() for h in self.headers.keys()):
+            host = self.headers.get('Host', '') or self.headers.get('host', '')
+            if host.startswith('www.'):
+                target = 'https://' + host[4:] + self.path
+                self.send_response(301)
+                self.send_header('Location', target)
+                self.end_headers()
+                return
+
+
+        # ── pSEO static pages ──────────────────────────
+        try_pseo = self._serve_pseo(path)
+        if try_pseo:
+            return
+        if path == "/" or path == "/index.html":
+            return self._html(templates.landing_page_html())
+        if path == "/dashboard":
+            return self._html(templates.dashboard_html())
+        if path == "/health":
+            return self._json(200, {"ok": True, "service": "sipi.bot", "version": __version__},
+                              noindex=True)
+        if path == "/BingSiteAuth.xml":
+            xml = ('<?xml version="1.0"?>\n<users>\n\t<user>'
+                   'FA4E122745948F0CAD16959F59DDCB85</user>\n</users>')
+            return self._send(200, xml.encode(), "application/xml")
+        if path == "/.well-known/agent-card.json":
+            return self._json(200, agent_card())
+        if path == "/eval":
+            if os.path.exists(_EVAL_REPORT_PATH):
+                with open(_EVAL_REPORT_PATH) as f:
+                    return self._json(200, json.load(f), noindex=True)
+            return self._json(200, {"status": "not_run_yet",
+                                    "hint": "run: python -m spendfirewall.eval.run_eval"},
+                              noindex=True)
+        if path == "/api/stats":
+            return self._json(200, core.status())
+        if path == "/api/transactions":
+            return self._json(200, store.recent_transactions(50))
+        if path == "/api/approvals":
+            return self._json(200, store.list_approvals("pending"))
+        if path == "/api/rules":
+            return self._json(200, store.list_rules())
+        if path == "/api/agents":
+            return self._json(200, store.list_agents())
+        if path == "/pricing":
+            return self._html(templates.pricing_html())
+        if path == "/about":
+            return self._html(templates.doc_page_html(
+                "About", "/about",
+                "sipi.bot is the spend firewall for autonomous AI agents — evaluate every transaction against your rules and get approve, block, or flag in under 5ms.",
+                templates.ABOUT_BODY))
+        if path == "/privacy":
+            return self._html(templates.doc_page_html(
+                "Privacy Policy", "/privacy",
+                "How sipi.bot handles transaction metadata, account data, and analytics. We are a decision layer — we never store card numbers.",
+                templates.PRIVACY_BODY))
+        if path == "/terms":
+            return self._html(templates.doc_page_html(
+                "Terms of Service", "/terms",
+                "Terms for using sipi.bot, the spend firewall for autonomous AI agents, including the rule-integrity guarantee.",
+                templates.TERMS_BODY))
+        if path == "/billing/status":
+            return self._json(200, billing.status())
+        if path.startswith("/checkout/"):
+            plan = path.rsplit("/", 1)[-1]
+            try:
+                url = billing.create_checkout_session(plan)
+            except Exception as e:
+                return self._json(400, {"error": str(e)})
+            self.send_response(302)
+            self.send_header("Location", url)
+            self.send_header("Content-Length", "0")
+            self.send_header("X-Robots-Tag", "noindex, nofollow")
+            self.end_headers()
+            return
+        if path.startswith("/keys/"):
+            sess = path.rsplit("/", 1)[-1]
+            rec = billing.key_for_session(sess)
+            return self._html(templates.key_success_html(rec))
+        if path == "/v1/activity":
+            return self._sse()
+        # Static files from public/ (sitemap.xml, robots.txt, llms.txt, pSEO
+        # pages written by the growth engine). Served last, before 404.
+        if self._serve_static(path):
+            return
+        return self._json(404, {"error": "not_found"})
+
+    def _serve_static(self, path: str) -> bool:
+        """Serve a file from the public/ dir if it exists. Path-traversal safe."""
+        import mimetypes
+        root = os.environ.get("PUBLIC_DIR", os.path.join(os.getcwd(), "public"))
+        rel = path.lstrip("/") or "index.html"
+        if rel.endswith("/"):
+            rel += "index.html"
+        target = os.path.normpath(os.path.join(root, rel))
+        # containment check: must stay under root
+        if not target.startswith(os.path.abspath(root) + os.sep) and target != os.path.abspath(root):
+            return False
+        if not os.path.isfile(target):
+            # try /foo -> /foo/index.html (pSEO cluster pages)
+            alt = os.path.normpath(os.path.join(root, rel, "index.html"))
+            if os.path.isfile(alt):
+                target = alt
+            else:
+                return False
+        ctype = mimetypes.guess_type(target)[0] or "application/octet-stream"
+        try:
+            with open(target, "rb") as f:
+                data = f.read()
+        except OSError:
+            return False
+        self._send(200, data, ctype)
+        return True
+
+    def _sse(self):
+        self.send_response(200)
+        self.send_header("Content-Security-Policy", "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://js.stripe.com https://eu.i.posthog.com https://eu-assets.i.posthog.com https://eu.posthog.com https://checkout.stripe.com; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https://eu.i.posthog.com https://eu-assets.i.posthog.com https://sipi.bot; frame-ancestors 'none'; object-src 'none'; base-uri 'self'; frame-src https://js.stripe.com https://checkout.stripe.com")
+        self.send_header("Permissions-Policy", "camera=(), microphone=(), geolocation=(), payment=(), usb=(), browsing-topics=(), interest-cohort=()")
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Connection", "keep-alive")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        q: queue.Queue = queue.Queue()
+        with _SUB_LOCK:
+            _SUBSCRIBERS.append(q)
+        try:
+            self.wfile.write(b": connected\n\n")
+            self.wfile.flush()
+            while True:
+                try:
+                    data = q.get(timeout=15)
+                    self.wfile.write(f"data: {data}\n\n".encode())
+                except queue.Empty:
+                    self.wfile.write(b"data: ping\n\n")
+                self.wfile.flush()
+        except Exception:
+            pass
+        finally:
+            with _SUB_LOCK:
+                if q in _SUBSCRIBERS:
+                    _SUBSCRIBERS.remove(q)
+
+    def do_DELETE(self):
+        path = urlparse(self.path).path
+        if path.startswith("/api/rules/"):
+            rid = path.rsplit("/", 1)[-1]
+            return self._json(200, {"deleted": store.delete_rule(rid)})
+        return self._json(404, {"error": "not_found"})
+
+    
+    def _serve_pseo(self, path):
+        """Serve pSEO static HTML pages from vs/ for/ learn/ integrations/ subdirs."""
+        import os
+        for prefix in ("/vs/", "/for/", "/learn/", "/integrations/", "/glossary/", "/use-cases/", "/faq/"):
+            if path.startswith(prefix):
+                filepath = os.path.join(os.path.dirname(__file__), "..", path.lstrip("/"), "index.html")
+                filepath = os.path.normpath(filepath)
+                if os.path.isfile(filepath):
+                    try:
+                        with open(filepath, encoding="utf-8") as fh:
+                            return self._html(fh.read())
+                    except Exception:
+                        pass
+                return None
+        return None
+
+    def do_POST(self):
+        path = urlparse(self.path).path
+
+        # Stripe webhook must read the RAW body once (before _body parses it)
+        # for signature verification.
+        if path == "/webhooks/stripe":
+            try:
+                n = int(self.headers.get("Content-Length", 0))
+                raw = self.rfile.read(n) if n > 0 else b"{}"
+            except Exception:
+                raw = b"{}"
+            sig = self.headers.get("Stripe-Signature", "")
+            try:
+                result = billing.handle_webhook(raw, sig)
+            except Exception as e:
+                return self._json(400, {"error": str(e)})
+            return self._json(200, result)
+
+        body = self._body()
+
+        if path == "/v1/transactions/evaluate":
+            # Auth optional in free/self-host mode. If a key is provided, tie to agent.
+            agent_id = None
+            auth = self.headers.get("Authorization", "")
+            if auth.startswith("Bearer "):
+                agent = store.get_agent_by_key(auth[7:].strip())
+                if agent:
+                    agent_id = agent["id"]
+            try:
+                result = core.evaluate_transaction(
+                    amount=body.get("amount", 0),
+                    merchant=body.get("merchant", ""),
+                    category=body.get("category", ""),
+                    description=body.get("description", ""),
+                    currency=body.get("currency", "USD"),
+                    timestamp=body.get("timestamp"),
+                    agent_id=agent_id,
+                )
+            except Exception as e:
+                return self._json(400, {"error": str(e)})
+            _broadcast({"type": "transaction", **result})
+            return self._json(200, result)
+
+        if path == "/api/rules":
+            r = store.add_rule(
+                rule_type=body.get("rule_type", "per_transaction"),
+                params=body.get("params", {}),
+                action=body.get("action", "BLOCKED"),
+                priority=int(body.get("priority", 100)),
+                label=body.get("label", ""),
+            )
+            return self._json(200, r)
+
+        if path == "/api/agents":
+            return self._json(200, store.create_agent(body.get("name", "agent")))
+
+        if path.startswith("/api/approvals/"):
+            aid = path.rsplit("/", 1)[-1]
+            ok = store.resolve_approval(aid, body.get("decision", "deny"))
+            _broadcast({"type": "approval_resolved", "id": aid})
+            return self._json(200, {"resolved": ok})
+
+        if path == "/admin/reset":
+            # Admin-gated: clears transaction + approval history (keeps rules/agents).
+            # Used to reset the public demo after testing. Set ADMIN_TOKEN on the server.
+            token = os.environ.get("ADMIN_TOKEN", "")
+            auth = self.headers.get("Authorization", "")
+            given = auth[7:].strip() if auth.startswith("Bearer ") else ""
+            if not token or given != token:
+                return self._json(403, {"error": "forbidden"})
+            n = store.reset_demo_data()
+            return self._json(200, {"reset": True, "cleared": n})
+
+        if path == "/subscribe":
+            email = (body.get("email") or "").strip()
+            if email and "@" in email:
+                try:
+                    with open(_SUBSCRIBERS_FILE, "a") as f:
+                        f.write(email + "\n")
+                except Exception:
+                    pass
+                return self._json(200, {"ok": True, "message": "You're on the list. We'll email your pilot access."})
+            return self._json(400, {"ok": False, "message": "Enter a valid email."})
+
+        return self._json(404, {"error": "not_found"})
+
+
+def serve(host="0.0.0.0", port=None):
+    port = port or int(os.environ.get("PORT", 8080))
+    store.init_db()
+    srv = ThreadingHTTPServer((host, port), Handler)
+    print(f"sipi.bot spend firewall on http://{host}:{port}")
+    srv.serve_forever()
+
+
+if __name__ == "__main__":
+    serve()