abstractgateway 0.1.0__py3-none-any.whl

abstractgateway/__init__.py

@@ -0,0 +1,11 @@
+"""AbstractGateway.
+
+AbstractGateway is a deployable Run Gateway host for AbstractRuntime:
+- durable command inbox (start/resume/pause/cancel/emit_event)
+- ledger replay + SSE streaming (replay-first)
+- security middleware for network-safe deployments
+"""
+
+__version__ = "0.1.0"
+
+

abstractgateway/app.py

@@ -0,0 +1,55 @@
+"""AbstractGateway FastAPI application."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .routes import gateway_router
+from .security import GatewaySecurityMiddleware, load_gateway_auth_policy_from_env
+
+
+@asynccontextmanager
+async def _lifespan(_app: FastAPI):
+    # Start the background worker that polls the durable command inbox and ticks runs.
+    from .service import start_gateway_runner, stop_gateway_runner
+
+    start_gateway_runner()
+    try:
+        yield
+    finally:
+        stop_gateway_runner()
+
+
+app = FastAPI(
+    title="AbstractGateway",
+    description="Durable Run Gateway for AbstractRuntime (commands + ledger replay/stream).",
+    version="0.1.0",
+    lifespan=_lifespan,
+)
+
+# Gateway security (backlog 309).
+app.add_middleware(GatewaySecurityMiddleware, policy=load_gateway_auth_policy_from_env())
+
+# CORS for browser clients. In production, prefer configuring exact origins and terminating TLS at a reverse proxy.
+#
+# IMPORTANT: add after GatewaySecurityMiddleware so CORS headers are present even on early security rejections
+# (otherwise browsers surface a generic "NetworkError").
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(gateway_router, prefix="/api")
+
+
+@app.get("/api/health")
+async def health_check():
+    return {"status": "healthy", "service": "abstractgateway"}
+
+

abstractgateway/cli.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import argparse
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="abstractgateway", description="AbstractGateway (Run Gateway host)")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    serve = sub.add_parser("serve", help="Run the AbstractGateway HTTP/SSE server")
+    serve.add_argument("--host", default="127.0.0.1", help="Bind host (default: 127.0.0.1)")
+    serve.add_argument("--port", type=int, default=8080, help="Bind port (default: 8080)")
+    serve.add_argument("--reload", action="store_true", help="Enable auto-reload (dev only)")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "serve":
+        import uvicorn
+
+        uvicorn.run(
+            "abstractgateway.app:app",
+            host=str(args.host),
+            port=int(args.port),
+            reload=bool(args.reload),
+        )
+        return
+
+    raise SystemExit(2)
+
+

abstractgateway/config.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+
+def _as_bool(raw: Any, default: bool) -> bool:
+    if raw is None:
+        return default
+    if isinstance(raw, bool):
+        return raw
+    s = str(raw).strip().lower()
+    if not s:
+        return default
+    if s in {"1", "true", "yes", "on"}:
+        return True
+    if s in {"0", "false", "no", "off"}:
+        return False
+    return default
+
+
+def _as_int(raw: Optional[str], default: int) -> int:
+    if raw is None or not str(raw).strip():
+        return default
+    try:
+        return int(str(raw).strip())
+    except Exception:
+        return default
+
+
+def _as_float(raw: Optional[str], default: float) -> float:
+    if raw is None or not str(raw).strip():
+        return default
+    try:
+        return float(str(raw).strip())
+    except Exception:
+        return default
+
+
+def _env(name: str, fallback: Optional[str] = None) -> Optional[str]:
+    v = os.getenv(name)
+    if v is not None and str(v).strip():
+        return v
+    if fallback:
+        v2 = os.getenv(fallback)
+        if v2 is not None and str(v2).strip():
+            return v2
+    return None
+
+
+@dataclass(frozen=True)
+class GatewayHostConfig:
+    """Process-level configuration for the AbstractGateway host."""
+
+    data_dir: Path
+    flows_dir: Path
+
+    runner_enabled: bool = True
+    poll_interval_s: float = 0.25
+    command_batch_limit: int = 200
+    tick_max_steps: int = 100
+    tick_workers: int = 2
+    run_scan_limit: int = 200
+
+    @staticmethod
+    def from_env() -> "GatewayHostConfig":
+        # NOTE: We intentionally use ABSTRACTGATEWAY_* as the canonical namespace.
+        # For a transition period, we accept legacy ABSTRACTFLOW_* names as fallbacks.
+        data_dir_raw = _env("ABSTRACTGATEWAY_DATA_DIR", "ABSTRACTFLOW_RUNTIME_DIR") or "./runtime"
+        flows_dir_raw = _env("ABSTRACTGATEWAY_FLOWS_DIR", "ABSTRACTFLOW_FLOWS_DIR") or "./flows"
+
+        enabled_raw = _env("ABSTRACTGATEWAY_RUNNER", "ABSTRACTFLOW_GATEWAY_RUNNER") or "1"
+        runner_enabled = _as_bool(enabled_raw, True)
+
+        poll_s = _as_float(_env("ABSTRACTGATEWAY_POLL_S", "ABSTRACTFLOW_GATEWAY_POLL_S"), 0.25)
+        tick_workers = _as_int(_env("ABSTRACTGATEWAY_TICK_WORKERS", "ABSTRACTFLOW_GATEWAY_TICK_WORKERS"), 2)
+        tick_steps = _as_int(_env("ABSTRACTGATEWAY_TICK_MAX_STEPS", "ABSTRACTFLOW_GATEWAY_TICK_MAX_STEPS"), 100)
+        batch = _as_int(_env("ABSTRACTGATEWAY_COMMAND_BATCH_LIMIT", "ABSTRACTFLOW_GATEWAY_COMMAND_BATCH_LIMIT"), 200)
+        scan = _as_int(_env("ABSTRACTGATEWAY_RUN_SCAN_LIMIT", "ABSTRACTFLOW_GATEWAY_RUN_SCAN_LIMIT"), 200)
+
+        return GatewayHostConfig(
+            data_dir=Path(data_dir_raw).expanduser().resolve(),
+            flows_dir=Path(flows_dir_raw).expanduser().resolve(),
+            runner_enabled=bool(runner_enabled),
+            poll_interval_s=float(poll_s),
+            command_batch_limit=max(1, int(batch)),
+            tick_max_steps=max(1, int(tick_steps)),
+            tick_workers=max(1, int(tick_workers)),
+            run_scan_limit=max(1, int(scan)),
+        )
+
+

abstractgateway/hosts/__init__.py

@@ -0,0 +1,6 @@
+from .visualflow_host import VisualFlowGatewayHost
+from .bundle_host import WorkflowBundleGatewayHost
+
+__all__ = ["VisualFlowGatewayHost", "WorkflowBundleGatewayHost"]
+
+