warp-server 0.1.0__tar.gz

warp_server-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+          enable-cache: false
+      - uses: astral-sh/ruff-action@v3
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+      - name: Install flatbuffers compiler
+        run: |
+          curl -Lo flatc.zip "https://github.com/google/flatbuffers/releases/download/v25.12.19/Linux.flatc.binary.clang%2B%2B-18.zip"
+          sudo unzip -o flatc.zip flatc -d /usr/local/bin
+          sudo chmod +x /usr/local/bin/flatc
+      - name: Generate FlatBuffer bindings
+        run: flatc --python -o src/warp_server/gen_flatbuffers warp/*.fbs
+      - run: uv sync
+      - run: uv run pytest -v

warp_server-0.1.0/.gitignore

@@ -0,0 +1,43 @@
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+._*
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# uv / virtualenvs
+.venv/
+venv/
+.python-version
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Xcode
+*.xcuserstate
+xcuserdata/
+*.xcworkspace/xcuserdata/
+DerivedData/
+
+warp-plugin-binja
+warp.db

warp_server-0.1.0/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "warp"]
+	path = warp
+	url = https://github.com/vector35/warp

warp_server-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-added-large-files
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.4
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

warp_server-0.1.0/DpNC5NEDJL42WlYjCyyNIGhdNHmLEtJ5h73TqVBYdM8

@@ -0,0 +1 @@
+key

warp_server-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: warp-server
+Version: 0.1.0
+Summary: WARP signature server API
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: click>=8.1
+Requires-Dist: fastapi>=0.115
+Requires-Dist: flatbuffers>=25.12.19
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: uvicorn[standard]>=0.30
+Description-Content-Type: text/markdown
+
+# warp-server
+
+FastAPI implementation of the WARP signature server API.
+
+## Development
+
+```bash
+git submodule update --init  # fetch warp/ schemas
+uv sync
+uv run warp-server        # start dev server on :8000
+uv run pytest              # run tests
+```
+
+### Regenerating FlatBuffer bindings
+
+The Python FlatBuffer bindings are generated from the `.fbs` schemas in `warp/`. To regenerate:
+
+```bash
+brew install flatbuffers   # if not already installed
+flatc --python -o src/warp_server/gen_flatbuffers warp/*.fbs
+```
+
+## Bootstrap: Create a User with an API Key
+
+The server uses Bearer token auth via API keys. Use the `warp-ctl` CLI to manage users and keys.
+
+### Quick bootstrap (admin + key in one step)
+
+```bash
+uv run warp-ctl bootstrap
+# Created admin user id=1 username=admin
+# API key: <key>
+```
+
+Options: `--email`, `--username` to customize the admin account.
+
+### Managing users
+
+```bash
+# create a regular user
+uv run warp-ctl user create --email alice@example.com --username alice
+
+# create an admin
+uv run warp-ctl user create --email ops@example.com --username ops --role Admin
+
+# list all users
+uv run warp-ctl user list
+
+# delete a user
+uv run warp-ctl user delete 2
+```
+
+### Managing API keys
+
+```bash
+# create a key for user id 1
+uv run warp-ctl key create --user-id 1 --name dev-key
+
+# list all keys (or filter by --user-id)
+uv run warp-ctl key list
+uv run warp-ctl key list --user-id 1
+
+# revoke a key
+uv run warp-ctl key revoke 3
+```
+
+### Managing sources
+
+```bash
+# create a source owned by user 1
+uv run warp-ctl source create --name my-signatures --user-id 1
+
+# list sources
+uv run warp-ctl source list
+```
+
+### Using the API key
+
+```bash
+# verify auth
+curl -H "Authorization: Bearer <key>" http://localhost:8000/api/v1/users/me
+
+# create a source via the API
+curl -X POST http://localhost:8000/api/v1/sources \
+  -H "Authorization: Bearer <key>" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "my-source", "user_ids": []}'
+```

warp_server-0.1.0/README.md

@@ -0,0 +1,88 @@
+# warp-server
+
+FastAPI implementation of the WARP signature server API.
+
+## Development
+
+```bash
+git submodule update --init  # fetch warp/ schemas
+uv sync
+uv run warp-server        # start dev server on :8000
+uv run pytest              # run tests
+```
+
+### Regenerating FlatBuffer bindings
+
+The Python FlatBuffer bindings are generated from the `.fbs` schemas in `warp/`. To regenerate:
+
+```bash
+brew install flatbuffers   # if not already installed
+flatc --python -o src/warp_server/gen_flatbuffers warp/*.fbs
+```
+
+## Bootstrap: Create a User with an API Key
+
+The server uses Bearer token auth via API keys. Use the `warp-ctl` CLI to manage users and keys.
+
+### Quick bootstrap (admin + key in one step)
+
+```bash
+uv run warp-ctl bootstrap
+# Created admin user id=1 username=admin
+# API key: <key>
+```
+
+Options: `--email`, `--username` to customize the admin account.
+
+### Managing users
+
+```bash
+# create a regular user
+uv run warp-ctl user create --email alice@example.com --username alice
+
+# create an admin
+uv run warp-ctl user create --email ops@example.com --username ops --role Admin
+
+# list all users
+uv run warp-ctl user list
+
+# delete a user
+uv run warp-ctl user delete 2
+```
+
+### Managing API keys
+
+```bash
+# create a key for user id 1
+uv run warp-ctl key create --user-id 1 --name dev-key
+
+# list all keys (or filter by --user-id)
+uv run warp-ctl key list
+uv run warp-ctl key list --user-id 1
+
+# revoke a key
+uv run warp-ctl key revoke 3
+```
+
+### Managing sources
+
+```bash
+# create a source owned by user 1
+uv run warp-ctl source create --name my-signatures --user-id 1
+
+# list sources
+uv run warp-ctl source list
+```
+
+### Using the API key
+
+```bash
+# verify auth
+curl -H "Authorization: Bearer <key>" http://localhost:8000/api/v1/users/me
+
+# create a source via the API
+curl -X POST http://localhost:8000/api/v1/sources \
+  -H "Authorization: Bearer <key>" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "my-source", "user_ids": []}'
+```

warp_server-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "warp-server"
+version = "0.1.0"
+description = "WARP signature server API"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.30",
+    "sqlalchemy[asyncio]>=2.0",
+    "aiosqlite>=0.20",
+    "pydantic>=2.0",
+    "pydantic-settings>=2.0",
+    "python-multipart>=0.0.9",
+    "click>=8.1",
+    "flatbuffers>=25.12.19",
+]
+
+[project.scripts]
+warp-server = "warp_server.main:run"
+warp-ctl = "warp_server.cli:app"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "httpx>=0.27",
+    "pre-commit>=4.5.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/warp_server"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.lint.per-file-ignores]
+"src/warp_server/warp_parser.py" = ["E402"]

warp_server-0.1.0/src/warp_server/auth.py

@@ -0,0 +1,66 @@
+from datetime import datetime, timezone
+
+from fastapi import Depends, HTTPException, Security, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from warp_server.database import get_db
+from warp_server.models import ApiKey, User
+
+security = HTTPBearer(auto_error=False)
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials | None = Security(security),
+    db: AsyncSession = Depends(get_db),
+) -> User:
+    if credentials is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Not authenticated"
+        )
+
+    token = credentials.credentials
+    result = await db.execute(select(ApiKey).where(ApiKey.key == token))
+    api_key = result.scalar_one_or_none()
+    if api_key is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key"
+        )
+
+    if api_key.expires_at and api_key.expires_at < datetime.now(timezone.utc):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="API key expired"
+        )
+
+    # Update last_used_at
+    api_key.last_used_at = datetime.now(timezone.utc)
+    await db.commit()
+
+    result = await db.execute(select(User).where(User.id == api_key.user_id))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found"
+        )
+    return user
+
+
+async def get_optional_user(
+    credentials: HTTPAuthorizationCredentials | None = Security(security),
+    db: AsyncSession = Depends(get_db),
+) -> User | None:
+    if credentials is None:
+        return None
+    try:
+        return await get_current_user(credentials, db)
+    except HTTPException:
+        return None
+
+
+def require_admin(user: User = Depends(get_current_user)) -> User:
+    if user.role != "Admin":
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Admin required"
+        )
+    return user

warp_server-0.1.0/src/warp_server/cli.py

@@ -0,0 +1,278 @@
+import asyncio
+import secrets
+from datetime import datetime, timezone
+
+import click
+from sqlalchemy import select
+
+from warp_server.database import async_session, engine
+from warp_server.models import ApiKey, Base, Source, SourceTag, SourceUser, User
+
+
+@click.group(name="warp-ctl", help="WARP server management CLI.")
+def app():
+    pass
+
+
+@app.group(help="Manage users.")
+def user():
+    pass
+
+
+@app.group(help="Manage API keys.")
+def key():
+    pass
+
+
+@app.group(help="Manage sources.")
+def source():
+    pass
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+async def _ensure_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+# ── Users ────────────────────────────────────────────────────────────
+
+
+@user.command("create")
+@click.option("--email", required=True, help="User email address.")
+@click.option(
+    "--username", default=None, help="Username (defaults to email local part)."
+)
+@click.option("--role", default="User", help="Role: User or Admin.")
+def user_create(email, username, role):
+    """Create a new user."""
+
+    async def _create():
+        await _ensure_tables()
+        async with async_session() as db:
+            name = username or email.split("@")[0]
+            u = User(email=email, username=name, role=role)
+            db.add(u)
+            await db.flush()
+            raw_key = secrets.token_urlsafe(32)
+            db.add(ApiKey(user_id=u.id, key=raw_key, name="default"))
+            await db.commit()
+            await db.refresh(u)
+            click.echo(f"Created user id={u.id} username={u.username} role={u.role}")
+            click.echo(f"API key: {raw_key}")
+            click.echo("Store this key securely — it cannot be retrieved later.")
+
+    _run(_create())
+
+
+@user.command("list")
+def user_list():
+    """List all users."""
+
+    async def _list():
+        await _ensure_tables()
+        async with async_session() as db:
+            result = await db.execute(select(User).order_by(User.id))
+            users = result.scalars().all()
+            if not users:
+                click.echo("No users found.")
+                return
+            click.echo(
+                f"{'ID':<6} {'Username':<20} {'Email':<30} {'Role':<10} {'Created'}"
+            )
+            click.echo("-" * 80)
+            for u in users:
+                click.echo(
+                    f"{u.id:<6} {u.username:<20} {u.email:<30} {u.role:<10} {u.created_at}"
+                )
+
+    _run(_list())
+
+
+@user.command("delete")
+@click.argument("user_id", type=int)
+def user_delete(user_id):
+    """Delete a user by ID."""
+
+    async def _delete():
+        await _ensure_tables()
+        async with async_session() as db:
+            result = await db.execute(select(User).where(User.id == user_id))
+            u = result.scalar_one_or_none()
+            if u is None:
+                click.echo(f"User {user_id} not found.", err=True)
+                raise SystemExit(1)
+            await db.delete(u)
+            await db.commit()
+            click.echo(f"Deleted user id={user_id} username={u.username}")
+
+    _run(_delete())
+
+
+# ── API Keys ─────────────────────────────────────────────────────────
+
+
+@key.command("create")
+@click.option(
+    "--user-id", required=True, type=int, help="User ID to create the key for."
+)
+@click.option("--name", default="default", help="Key name/label.")
+def key_create(user_id, name):
+    """Create an API key for a user."""
+
+    async def _create():
+        await _ensure_tables()
+        async with async_session() as db:
+            result = await db.execute(select(User).where(User.id == user_id))
+            u = result.scalar_one_or_none()
+            if u is None:
+                click.echo(f"User {user_id} not found.", err=True)
+                raise SystemExit(1)
+            raw_key = secrets.token_urlsafe(32)
+            api_key = ApiKey(
+                user_id=u.id,
+                key=raw_key,
+                name=name,
+                created_at=datetime.now(timezone.utc),
+            )
+            db.add(api_key)
+            await db.commit()
+            await db.refresh(api_key)
+            click.echo(f"Created API key for user={u.username}")
+            click.echo(f"Key: {raw_key}")
+            click.echo("Store this key securely — it cannot be retrieved later.")
+
+    _run(_create())
+
+
+@key.command("list")
+@click.option("--user-id", default=None, type=int, help="Filter keys by user ID.")
+def key_list(user_id):
+    """List API keys."""
+
+    async def _list():
+        await _ensure_tables()
+        async with async_session() as db:
+            query = select(ApiKey).order_by(ApiKey.id)
+            if user_id is not None:
+                query = query.where(ApiKey.user_id == user_id)
+            result = await db.execute(query)
+            keys = result.scalars().all()
+            if not keys:
+                click.echo("No API keys found.")
+                return
+            click.echo(
+                f"{'ID':<6} {'User ID':<8} {'Name':<16} {'Key (prefix)':<14} {'Created':<26} {'Last Used'}"
+            )
+            click.echo("-" * 90)
+            for k in keys:
+                click.echo(
+                    f"{k.id:<6} {k.user_id:<8} {k.name:<16} {k.key[:12] + '…':<14} {str(k.created_at):<26} {k.last_used_at or '—'}"
+                )
+
+    _run(_list())
+
+
+@key.command("revoke")
+@click.argument("key_id", type=int)
+def key_revoke(key_id):
+    """Revoke (delete) an API key."""
+
+    async def _revoke():
+        await _ensure_tables()
+        async with async_session() as db:
+            result = await db.execute(select(ApiKey).where(ApiKey.id == key_id))
+            api_key = result.scalar_one_or_none()
+            if api_key is None:
+                click.echo(f"API key {key_id} not found.", err=True)
+                raise SystemExit(1)
+            await db.delete(api_key)
+            await db.commit()
+            click.echo(f"Revoked API key id={key_id}")
+
+    _run(_revoke())
+
+
+# ── Sources ──────────────────────────────────────────────────────────
+
+
+@source.command("create")
+@click.option("--name", required=True, help="Source name.")
+@click.option("--user-id", default=None, type=int, help="User ID to add as owner.")
+def source_create(name, user_id):
+    """Create a new source."""
+
+    async def _create():
+        await _ensure_tables()
+        async with async_session() as db:
+            src = Source(name=name)
+            db.add(src)
+            await db.flush()
+            if user_id is not None:
+                db.add(SourceUser(source_id=src.id, user_id=user_id))
+            db.add(SourceTag(source_id=src.id, tag="trusted"))
+            await db.commit()
+            await db.refresh(src)
+            click.echo(f"Created source id={src.id} name={src.name}")
+
+    _run(_create())
+
+
+@source.command("list")
+def source_list():
+    """List all sources."""
+
+    async def _list():
+        await _ensure_tables()
+        async with async_session() as db:
+            result = await db.execute(select(Source).order_by(Source.name))
+            sources = result.scalars().all()
+            if not sources:
+                click.echo("No sources found.")
+                return
+            click.echo(f"{'ID':<6} {'Name':<30} {'Created'}")
+            click.echo("-" * 60)
+            for s in sources:
+                click.echo(f"{s.id:<6} {s.name:<30} {s.created_at}")
+
+    _run(_list())
+
+
+# ── Quick bootstrap ──────────────────────────────────────────────────
+
+
+@app.command("bootstrap")
+@click.option("--email", default="admin@localhost", help="Admin email.")
+@click.option("--username", default="admin", help="Admin username.")
+def bootstrap(email, username):
+    """Create an admin user with an API key in one step."""
+
+    async def _bootstrap():
+        await _ensure_tables()
+        async with async_session() as db:
+            result = await db.execute(select(User).where(User.username == username))
+            existing = result.scalar_one_or_none()
+            if existing is not None:
+                click.echo(
+                    f"User '{username}' already exists (id={existing.id}), skipping creation."
+                )
+                return
+            u = User(email=email, username=username, role="Admin")
+            db.add(u)
+            await db.flush()
+            raw_key = secrets.token_urlsafe(32)
+            db.add(ApiKey(user_id=u.id, key=raw_key, name="bootstrap"))
+            await db.commit()
+            await db.refresh(u)
+            click.echo(f"Created admin user id={u.id} username={u.username}")
+            click.echo(f"API key: {raw_key}")
+            click.echo("Store this key securely — it cannot be retrieved later.")
+
+    _run(_bootstrap())
+
+
+if __name__ == "__main__":
+    app()