keywright-server 0.0.1__py3-none-any.whl

keywright_server/web/network_map_ui.py

@@ -0,0 +1,37 @@
+"""Admin-only network map; controller reads share discovery's audit and locking."""
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import JSONResponse
+
+from .. import discovery, inventory, network_map
+from ..db import session
+from . import auth
+from .admin import render
+from .security import require_same_origin
+
+router = APIRouter(dependencies=[Depends(require_same_origin), Depends(auth.require_admin)])
+
+
+@router.get('/ui/inventory/map')
+async def network_map_page(request: Request, source: str = ''):
+    async with session() as db:
+        graph = await network_map.snapshot(db, source)
+    return render(request, 'inventory_map.html', graph=graph)
+
+
+@router.get('/ui/inventory/map/data')
+async def network_map_data(source: str = ''):
+    async with session() as db:
+        return await network_map.snapshot(db, source)
+
+
+@router.post('/ui/inventory/map/refresh')
+async def network_map_refresh(request: Request):
+    form = await request.form()
+    try:
+        source = inventory.value(form, 'resource_id', required=True)
+        run = await discovery.refresh(source, 'omada', min_interval=network_map.REFRESH_SECONDS)
+    except (discovery.DiscoveryError, inventory.InventoryError) as exc:
+        return JSONResponse({'error': str(exc)}, status_code=409)
+    async with session() as db:
+        graph = await network_map.snapshot(db, source)
+    return JSONResponse(graph, status_code=200 if run.status == 'succeeded' else 502)

keywright_server/web/oidc.py

@@ -0,0 +1,231 @@
+"""OIDC authorization code + PKCE login, with one-use flows and revocable local sessions."""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import logging
+import secrets
+from datetime import timedelta
+from urllib.parse import urlencode, urlsplit
+
+import httpx2 as httpx
+from authlib.integrations.base_client.errors import OAuthError
+from authlib.integrations.starlette_client import OAuth
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from joserfc.errors import JoseError
+from sqlalchemy import delete
+
+from .. import audit
+from ..config import settings
+from ..db import session
+from ..models import AdminLoginFlow, AdminSession, now
+from . import auth
+from .security import _origin, safe_redirect
+
+router = APIRouter()
+log = logging.getLogger("keywright.oidc")
+FLOW_COOKIE = "kw_oidc_flow"
+FLOW_PATH = "/ui/oidc"
+FLOW_TTL = 300
+
+
+class CallbackLogFilter(logging.Filter):
+    """Uvicorn includes the query string in access logs; authorization codes stay out."""
+
+    def filter(self, record):
+        if isinstance(record.args, tuple) and len(record.args) == 5:
+            address, method, target, version, status = record.args
+            if isinstance(target, str) and target.split("?", 1)[0] in (
+                "/ui/oidc/callback", "/ui/mcp-oauth/callback",
+            ):
+                record.args = (address, method, target.split("?", 1)[0], version, status)
+        return True
+
+
+def digest(value: str) -> str:
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def config_key() -> str:
+    return digest(json.dumps([settings.oidc_issuer, settings.oidc_client_id,
+                              settings.oidc_client_secret, settings.oidc_admin_group,
+                              settings.public_url, settings.oidc_session_ttl_s]))
+
+
+def https_url(value: str) -> bool:
+    try:
+        url = urlsplit(value)
+        return bool(url.scheme == "https" and url.hostname and url.port != 0
+                    and not url.username and not url.password and not url.fragment
+                    and not url.query and not any(c.isspace() for c in value))
+    except ValueError:
+        return False
+
+
+def configure(app) -> None:
+    access_log = logging.getLogger("uvicorn.access")
+    if not any(isinstance(item, CallbackLogFilter) for item in access_log.filters):
+        access_log.addFilter(CallbackLogFilter())
+    if settings.auth_mode not in ("password", "both", "oidc"):
+        raise ValueError("KW_AUTH_MODE must be password, both, or oidc")
+    if not auth.oidc_enabled():
+        app.state.oidc = None
+        return
+    if (not https_url(settings.oidc_issuer) or not https_url(settings.public_url)
+            or urlsplit(settings.public_url).path not in ("", "/")):
+        raise ValueError("OIDC requires an HTTPS KW_OIDC_ISSUER and an HTTPS origin in KW_PUBLIC_URL")
+    if not all((settings.oidc_client_id, settings.oidc_client_secret, settings.oidc_admin_group)):
+        raise ValueError("OIDC requires KW_OIDC_CLIENT_ID, KW_OIDC_CLIENT_SECRET, and KW_OIDC_ADMIN_GROUP")
+    if not 300 <= settings.oidc_session_ttl_s <= 86400:
+        raise ValueError("KW_OIDC_SESSION_TTL must be between 300 and 86400 seconds")
+    # Authlib handles discovery, PKCE, code exchange, JWKS rotation and ID token validation.
+    # Flow persistence is ours: no session middleware containing OAuth material in cookies.
+    app.state.oidc = OAuth().register(
+        "authentik", client_id=settings.oidc_client_id, client_secret=settings.oidc_client_secret,
+        server_metadata_url=settings.oidc_issuer.rstrip("/") + "/.well-known/openid-configuration",
+        client_kwargs={"scope": "openid profile email", "code_challenge_method": "S256",
+                       "token_endpoint_auth_method": "client_secret_basic", "timeout": 10.0},
+    )
+
+
+def callback_url() -> str:
+    # Fixed operator-configured origin, never derived from Host or forwarding headers.
+    return settings.public_url.rstrip("/") + "/ui/oidc/callback"
+
+
+async def provider(request: Request):
+    if not auth.oidc_enabled():
+        raise HTTPException(404)
+    client = request.app.state.oidc
+    metadata = await client.load_server_metadata()
+    if metadata.get("issuer") != settings.oidc_issuer:
+        raise ValueError("OIDC discovery issuer mismatch")
+    for name in ("authorization_endpoint", "token_endpoint", "jwks_uri"):
+        if not https_url(metadata.get(name, "")):
+            raise ValueError("OIDC discovery requires HTTPS endpoints")
+    # Only asymmetric ID token signatures, even if discovery advertises other algorithms.
+    supported = metadata.get("id_token_signing_alg_values_supported", ["RS256"])
+    algorithms = [alg for alg in supported if alg in ("RS256", "RS384", "RS512", "ES256", "ES384", "ES512")]
+    if not algorithms:
+        raise ValueError("OIDC provider has no supported signing algorithm")
+    metadata["id_token_signing_alg_values_supported"] = algorithms
+    return client
+
+
+def failure(message: str, status: int = 400):
+    # Deliberately do not reflect provider error strings, tokens, or exception messages.
+    response = HTMLResponse(
+        '<!doctype html><title>Keywright sign in</title><h1>Sign in unsuccessful</h1>'
+        f'<p>{message}</p><p><a href="/ui/login?local=1">Return to sign in</a></p>', status_code=status,
+    )
+    response.delete_cookie(FLOW_COOKIE, path=FLOW_PATH, secure=True, httponly=True, samesite="lax")
+    return response
+
+
+@router.get("/ui/oidc/login")
+async def login(request: Request, next: str = "/ui"):
+    if not auth.oidc_enabled():
+        raise HTTPException(404)
+    if _origin(str(request.url)) != _origin(settings.public_url):
+        # Aliases and direct LAN URLs must start on the callback's origin so its cookie arrives.
+        return RedirectResponse(settings.public_url.rstrip("/") + "/ui/oidc/login?" +
+                                urlencode({"next": safe_redirect(next)}), status_code=303)
+    auth.limit_login(request)
+    state, browser, nonce, verifier = (secrets.token_urlsafe(32) for _ in range(4))
+    try:
+        client = await provider(request)
+        result = await client.create_authorization_url(
+            callback_url(), state=state, nonce=nonce, code_verifier=verifier,
+        )
+    except (httpx.HTTPError, OAuthError, ValueError, KeyError, TypeError) as exc:
+        log.warning("OIDC login unavailable (%s)", type(exc).__name__)
+        return failure("Authentik is unavailable. Try again shortly.", 503)
+    async with session() as db:
+        await db.execute(delete(AdminLoginFlow).where(AdminLoginFlow.expires_at <= now()))
+        await db.execute(delete(AdminSession).where(AdminSession.expires_at <= now()))
+        db.add(AdminLoginFlow(
+            state_hash=digest(state), browser_hash=digest(browser), config_key=config_key(),
+            data={"nonce": nonce, "verifier": verifier, "next": safe_redirect(next)},
+            expires_at=now() + timedelta(seconds=FLOW_TTL),
+        ))
+        await db.commit()
+    response = RedirectResponse(result["url"], status_code=302)
+    response.set_cookie(FLOW_COOKIE, browser, max_age=FLOW_TTL, path=FLOW_PATH,
+                        secure=True, httponly=True, samesite="lax")
+    return response
+
+
+@router.get("/ui/oidc/callback")
+async def callback(request: Request):
+    if not auth.oidc_enabled():
+        raise HTTPException(404)
+    state = request.query_params.get("state", "")
+    browser = request.cookies.get(FLOW_COOKIE, "")
+    if not state or not browser or len(state) > 256 or len(browser) > 256:
+        return failure("Your sign-in attempt expired or could not be verified. Please start again.")
+    # Atomic consumption prevents replay and concurrent exchanges, including across workers.
+    async with session() as db:
+        flow = (await db.execute(delete(AdminLoginFlow).where(
+            AdminLoginFlow.state_hash == digest(state), AdminLoginFlow.browser_hash == digest(browser),
+            AdminLoginFlow.config_key == config_key(), AdminLoginFlow.expires_at > now(),
+        ).returning(AdminLoginFlow.data))).scalar_one_or_none()
+        await db.commit()
+    if flow is None:
+        return failure("Your sign-in attempt expired or could not be verified. Please start again.")
+    if request.query_params.get("error") or not request.query_params.get("code"):
+        return failure("Sign in was cancelled or denied by Authentik.")
+    try:
+        client = await provider(request)
+        token = await client.fetch_access_token(
+            redirect_uri=callback_url(), code=request.query_params["code"], code_verifier=flow["verifier"],
+        )
+        claims = await client.parse_id_token(
+            token, nonce=flow["nonce"], leeway=30,
+            claims_options={"iss": {"essential": True, "value": settings.oidc_issuer}},
+        )
+        if not claims or not isinstance(claims.get("sub"), str) or not claims["sub"]:
+            raise ValueError("Missing subject")
+        groups = claims.get("groups")
+        if not isinstance(groups, list) or settings.oidc_admin_group not in groups:
+            return failure("Your Authentik account does not have Keywright administrator access.", 403)
+    except (httpx.HTTPError, OAuthError, JoseError, ValueError, KeyError, TypeError) as exc:
+        log.warning("OIDC callback rejected (%s)", type(exc).__name__)
+        return failure("Authentik sign in could not be verified. Please start again.")
+    identity = {"method": "oidc", "issuer": claims["iss"], "subject": claims["sub"],
+                "name": str(claims.get("name") or claims.get("preferred_username") or claims["sub"])[:200]}
+    raw = secrets.token_urlsafe(32)
+    async with session() as db:
+        await revoke_session(request, db)
+        db.add(AdminSession(token_hash=digest(raw), config_key=config_key(), identity=identity,
+                            expires_at=now() + timedelta(seconds=settings.oidc_session_ttl_s)))
+        await audit.record(db, tool="admin.login", decision="allow", detail={"identity": identity})
+    response = RedirectResponse(safe_redirect(flow["next"]), status_code=303)
+    response.set_cookie(auth.COOKIE, "oidc:" + raw, max_age=settings.oidc_session_ttl_s,
+                        secure=True, httponly=True, samesite="lax")
+    response.delete_cookie(FLOW_COOKIE, path=FLOW_PATH, secure=True, httponly=True, samesite="lax")
+    return response
+
+
+async def session_identity(request) -> dict | None:
+    raw = request.cookies.get(auth.COOKIE, "")
+    if not raw.startswith("oidc:") or len(raw) > 256:
+        return None
+    async with session() as db:
+        row = await db.get(AdminSession, digest(raw[5:]))
+        if row and row.expires_at > now() and hmac.compare_digest(row.config_key, config_key()):
+            return dict(row.identity)
+    return None
+
+
+async def revoke_session(request, db) -> None:
+    raw = request.cookies.get(auth.COOKIE, "")
+    if raw.startswith("oidc:") and len(raw) <= 256:
+        await db.execute(delete(AdminSession).where(AdminSession.token_hash == digest(raw[5:])))
+
+
+async def logout(request) -> None:
+    async with session() as db:
+        await revoke_session(request, db)
+        await db.commit()

keywright_server/web/security.py

@@ -0,0 +1,77 @@
+"""Browser request boundaries and response headers for the admin UI."""
+from __future__ import annotations
+
+from urllib.parse import unquote, urlsplit
+
+from fastapi import HTTPException, Request
+from starlette.datastructures import MutableHeaders
+
+
+def _origin(value: str) -> tuple[str, str, int] | None:
+    try:
+        url = urlsplit(value)
+        if url.scheme not in ("http", "https") or not url.hostname or url.username or url.password:
+            return None
+        return url.scheme, url.hostname.lower(), url.port or (443 if url.scheme == "https" else 80)
+    except ValueError:
+        return None
+
+
+async def require_same_origin(request: Request) -> None:
+    """All browser mutations need a matching Origin or Referer; absence fails closed.
+
+    Native scripts using admin cookies must supply Origin explicitly. MCP uses bearer auth
+    through its own ASGI route and does not use browser cookies or this dependency.
+    """
+    if request.method in ("GET", "HEAD", "OPTIONS"):
+        return
+    source = request.headers.get("origin") or request.headers.get("referer")
+    if request.headers.get("sec-fetch-site") in ("cross-site", "same-site"):
+        raise HTTPException(403, "Cross-origin form submission rejected")
+    if not source or _origin(source) is None or _origin(source) != _origin(str(request.url)):
+        raise HTTPException(403, "A same-origin Origin or Referer header is required")
+
+
+def websocket_same_origin(origin: str | None, url: str) -> bool:
+    """A websocket handshake carries the admin cookie but never passes through require_same_origin,
+    which only sees HTTP methods. Browsers always send Origin on a websocket, so a missing or
+    mismatched one fails closed. ws:// and wss:// are normalised to the scheme they upgrade from,
+    because that is what the browser puts in Origin."""
+    scheme, _, rest = url.partition("://")
+    upgraded = {"ws": "http", "wss": "https"}.get(scheme, scheme) + "://" + rest
+    return bool(origin) and _origin(origin) is not None and _origin(origin) == _origin(upgraded)
+
+
+def safe_redirect(value: str) -> str:
+    decoded = unquote(value)
+    if (not decoded.startswith("/") or decoded.startswith("//") or "\\" in decoded
+            or any(ord(c) < 32 for c in decoded)):
+        return "/ui"
+    return value
+
+
+class BrowserSecurityHeaders:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        async def secure_send(message):
+            if message["type"] == "http.response.start":
+                headers = MutableHeaders(scope=message)
+                headers["X-Content-Type-Options"] = "nosniff"
+                headers["X-Frame-Options"] = "DENY"
+                headers["Referrer-Policy"] = "same-origin"
+                headers["Content-Security-Policy"] = "frame-ancestors 'none'; base-uri 'self'; form-action 'self'"
+                if scope["path"].startswith(("/ui", "/d/", "/enroll/")):
+                    headers["Cache-Control"] = "no-store"
+                if scope.get("scheme") == "https":
+                    message["headers"] = [
+                        (key, value + b"; Secure" if key.lower() == b"set-cookie" and b"; secure" not in value.lower()
+                         else value) for key, value in message["headers"]
+                    ]
+            await send(message)
+
+        await self.app(scope, receive, secure_send)

keywright_server/web/templates/_activity_row.html

@@ -0,0 +1,25 @@
+{% from "_icons.html" import icon %}
+{% set failed = e.decision in ['deny', 'denied', 'locked', 'error', 'revoked', 'refused'] or (e.exit_code is not none and e.exit_code != 0) %}
+{% set passed = e.decision in ['allow', 'approved', 'ok'] and not failed %}
+<details class="activity-row" id="event-{{ e.id }}">
+<summary>
+<span class="activity-icon {{ 'failed' if failed else 'passed' if passed else '' }}">{{ icon('deny' if failed else 'check' if passed else 'activity') }}</span>
+<span class="activity-copy"><span class="activity-title">{{ e.patterns[0] if e.patterns else e.tool }}</span><span class="activity-subtitle">{{ e.agent_name or 'System' }} · {{ e.tool }}{% if e.patterns|length > 1 %} · +{{ e.patterns|length - 1 }} scopes{% endif %}</span>{% if e.detail.hazards %}<span class="activity-flag">{{ icon('warning') }} {{ e.detail.hazards|length }} hazard{{ '' if e.detail.hazards|length == 1 else 's' }} flagged</span>{% endif %}</span>
+<span class="activity-meta"><time datetime="{{ e.ts.isoformat() }}" title="{{ e.ts.strftime('%Y-%m-%d %H:%M:%S UTC') }}">{% set age = (now - e.ts).total_seconds() | int %}{% if age < 60 %}just now{% elif age < 3600 %}{{ age // 60 }}m ago{% elif age < 86400 %}{{ age // 3600 }}h ago{% else %}{{ e.ts.strftime('%b %d') }}{% endif %}</time><span class="pill {{ e.decision }}">{{ e.decision }}</span>{% if e.exit_code is not none and e.exit_code != 0 %}<span class="activity-flag">exit {{ e.exit_code }}</span>{% endif %}</span>
+</summary>
+<div class="activity-detail">
+<dl><div><dt>Event</dt><dd><a href="/ui/audit?q=%23{{ e.id }}">#{{ e.id }}</a></dd></div><div><dt>Time</dt><dd>{{ e.ts.strftime('%Y-%m-%d %H:%M:%S UTC') }}</dd></div><div><dt>Agent</dt><dd>{{ e.agent_name or 'System' }}</dd></div><div><dt>Tool</dt><dd>{{ e.tool }}</dd></div>{% if e.session_id %}<div><dt>Session</dt><dd class="mono">{{ e.session_id }}</dd></div>{% endif %}{% if e.exit_code is not none %}<div><dt>Result</dt><dd>exit {{ e.exit_code }}{% if e.duration_ms is not none %} · {{ e.duration_ms }} ms{% endif %}</dd></div>{% endif %}</dl>
+{% for p in e.patterns %}<div class="activity-pattern"><code>{{ p }}</code></div>{% endfor %}
+{% if e.detail.command %}<pre>$ {{ e.detail.command }}</pre>{% endif %}
+{% if e.detail.hazards %}<div class="hazard">{% for h in e.detail.hazards %}<div><span class="pill {{ h.severity }}">{{ h.severity }}</span> {{ h.reason }}</div>{% endfor %}</div>{% endif %}
+{% if e.detail.reason %}<p class="small mut">{{ e.detail.reason }}</p>{% endif %}
+{% if e.detail.error %}<p class="small activity-flag">{{ e.detail.error }}</p>{% endif %}
+{% set delivery = e.detail.get('result_delivery') %}
+{% if delivery and delivery.mode != 'off' %}
+<p class="small"><b>MCP result:</b> upstream {{ 'reported an error' if delivery.upstream_is_error else 'completed without a tool error' }} · delivery <b>{{ delivery.delivery }}</b> · inspection {{ delivery.mode }} · coverage {{ delivery.coverage }}.</p>
+{% if delivery.delivery == 'withheld' %}<p class="small activity-flag">The tool already ran. Withholding its result does not undo its effects; do not automatically retry.</p>{% endif %}
+{% if delivery.findings %}<p class="small">Findings: {{ delivery.findings | join(', ') }}. {{ delivery.matches }} credential matches. Instruction findings are advisory.</p>{% endif %}
+{% if delivery.gaps %}<p class="small">Coverage gaps: {{ delivery.gaps | join(', ') }}.</p>{% endif %}
+{% endif %}
+</div>
+</details>

keywright_server/web/templates/_agent_setup.html

@@ -0,0 +1,50 @@
+<section class="card connection-guide" aria-labelledby="connect-heading">
+<h2 id="connect-heading" style="margin-top:0">Connect an agent</h2>
+<p class="small mut">Run these commands on the machine where your agent runs.{% if not new_token %} Replace <code>kw_YOUR_AGENT_TOKEN</code> with your saved token.{% endif %}</p>
+<details {% if new_token %}open{% endif %}>
+<summary>Any agent: the <code>kw</code> command (recommended)</summary>
+<p class="small">Works from any shell, waits out phone approvals, and scopes "this session" approvals per conversation. Install the client, store the token, set the agent up:</p>
+<pre>pipx install keywright
+kw login {{ mcp_url | shellquote }} --paste   # then paste the token on its own line
+kw setup claude-code      # or: kw setup codex
+kw setup check</pre>
+<p class="small mut">Agents then run <code>kw resources</code>, <code>kw run &lt;host&gt; -r "why" -- &lt;command&gt;</code>, <code>kw put</code>, <code>kw get</code> and <code>kw tool</code>. <code>kw guide</code> prints the full agent guide.</p>
+</details>
+<details>
+<summary>Codex over MCP</summary>
+<p class="small">Export the token, then register Keywright:</p>
+<pre>export KEYWRIGHT_TOKEN={{ (new_token or 'kw_YOUR_AGENT_TOKEN') | shellquote }}
+codex mcp add keywright \
+  --url {{ mcp_url | shellquote }} \
+  --bearer-token-env-var KEYWRIGHT_TOKEN</pre>
+<p class="small">In <code>~/.codex/config.toml</code>, set <code>tool_timeout_sec = 180</code> in the Keywright section to leave time for phone approvals. The section should look like this:</p>
+<pre>[mcp_servers.keywright]
+url = {{ mcp_url | tojson }}
+bearer_token_env_var = "KEYWRIGHT_TOKEN"
+tool_timeout_sec = 180</pre>
+<p class="small mut">Start Codex from the shell where <code>KEYWRIGHT_TOKEN</code> is exported. Set it again in new shells, or supply it through your environment manager. For the IDE extension, the variable must be available to the IDE process. Use <code>/mcp</code> in Codex to check the connection.</p>
+<p class="small"><a href="https://developers.openai.com/codex/mcp/" target="_blank" rel="noreferrer">Codex MCP documentation ↗</a></p>
+</details>
+<details>
+<summary>Claude Code over MCP</summary>
+<pre>claude mcp add --transport http keywright \
+  {{ mcp_url | shellquote }} \
+  --header {{ ('Authorization: Bearer ' ~ (new_token or 'kw_YOUR_AGENT_TOKEN')) | shellquote }}</pre>
+</details>
+{% if gateways %}
+<details>
+<summary>LLM calls through Keywright <span class="small mut">(no provider key on the agent's machine)</span></summary>
+<p class="small">Point the SDK or the agent at a gateway with the same token; every call names a model, and the model is what you approve. <code>kw llm &lt;gateway&gt;</code> prints these lines from a stored profile.</p>
+{% for g in gateways %}<pre># {{ g.name }}: {{ (g.config.models or []) | join(', ') or 'no models listed yet' }}
+export ANTHROPIC_BASE_URL={{ (public_url ~ '/llm/' ~ g.name) | shellquote }}
+export ANTHROPIC_AUTH_TOKEN={{ (new_token or 'kw_YOUR_AGENT_TOKEN') | shellquote }}
+export OPENAI_BASE_URL={{ (public_url ~ '/llm/' ~ g.name ~ '/v1') | shellquote }}
+export OPENAI_API_KEY={{ (new_token or 'kw_YOUR_AGENT_TOKEN') | shellquote }}</pre>{% endfor %}
+<p class="small mut">Unset the real <code>ANTHROPIC_API_KEY</code> / <code>OPENAI_API_KEY</code> there, and rotate them: a key that was ever on the agent's machine is spent.</p>
+</details>
+{% endif %}
+<details>
+<summary>Other MCP clients</summary>
+<p class="small">Use streamable HTTP at <code>{{ mcp_url }}</code> with an <code>Authorization: Bearer &lt;agent token&gt;</code> header.</p>
+</details>
+</section>

keywright_server/web/templates/_collections_style.html

@@ -0,0 +1,88 @@
+/* Compact inventory rows and audit records use flat surfaces and shared spacing. */
+.ui-icon{display:block;flex-shrink:0}
+.collection-heading{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:0 0 6px}
+.collection-heading h1{margin:0}
+.collection-intro{margin:0 0 18px;line-height:1.5}
+.action-menu{position:relative;flex-shrink:0}
+.action-menu>summary{list-style:none;cursor:pointer}
+.action-menu>summary::-webkit-details-marker{display:none}
+.resource-add>summary{white-space:nowrap}
+.action-menu-items{position:absolute;right:0;top:calc(100% + 4px);min-width:190px;padding:4px;border:1px solid var(--line);border-radius:var(--r);background:var(--panel);box-shadow:0 6px 18px #0003;z-index:4}
+.action-menu-items a,.action-menu-items button{display:flex;align-items:center;gap:8px;width:100%;min-height:32px;padding:6px 8px;text-align:left;border:0;border-radius:2px;background:none;color:var(--fg);font:inherit;cursor:pointer}
+.action-menu-items .ui-icon{width:18px;height:18px}
+.action-menu-items a:hover,.action-menu-items button:hover{background:var(--panel-raised);text-decoration:none}
+#resource-filters{display:flex;gap:16px;align-items:center;justify-content:space-between;margin-bottom:12px}
+.resource-tabs{display:flex;gap:0;align-self:stretch;border-bottom:1px solid var(--line)}
+.resource-tabs button{min-height:34px;padding:6px 16px;border:0;border-bottom:2px solid transparent;background:none;color:var(--mut);font:inherit;cursor:pointer}
+.resource-tabs button:hover{color:var(--fg);background:var(--panel)}
+.resource-tabs button[aria-pressed=true]{border-bottom-color:var(--acc);color:var(--fg);font-weight:600}
+.resource-search{display:flex;align-items:center;gap:8px;min-height:34px;max-width:420px;flex:1;padding:0 10px;border:1px solid var(--line);border-radius:var(--r);background:var(--panel);color:var(--mut)}
+.resource-search .ui-icon{width:16px;height:16px}
+.resource-search:focus-within{outline:2px solid var(--acc);outline-offset:2px}
+.resource-search input{width:100%;min-width:0;min-height:32px;padding:5px 0;border:0;background:none;color:var(--fg);font:inherit;outline:none}
+.resource-search input::placeholder{color:var(--mut);opacity:1}
+.resource-list{display:grid;grid-template-columns:minmax(0,1fr);border:1px solid var(--line);border-radius:var(--r);background:var(--panel)}
+.resource-list:not(:has(.resource-card:not([hidden]))){border:0;background:none}
+.resource-card{position:relative;min-width:0;display:grid;grid-template-columns:minmax(0,1fr) minmax(180px,28%) 32px;gap:4px 20px;align-items:center;padding:12px 14px}
+.resource-card:not([hidden])~.resource-card:not([hidden]){border-top:1px solid var(--line)}
+.resource-card:has(.resource-link:hover){background:var(--panel-raised)}
+.resource-link{grid-column:1;grid-row:1;display:grid;grid-template-columns:22px minmax(0,1fr);align-items:start;gap:10px;color:var(--fg);border-radius:2px}
+.resource-link:hover{text-decoration:none}
+.resource-icon{display:flex;align-items:center;justify-content:center;width:22px;height:22px;color:var(--mut)}
+.resource-icon .ui-icon{width:20px;height:20px}
+.resource-copy{min-width:0}.resource-copy h2{margin:0 0 2px;font-size:14px;font-weight:600;line-height:1.4;overflow-wrap:anywhere}
+.resource-endpoint{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;color:var(--mut);line-height:1.5;overflow-wrap:anywhere}
+.resource-chevron{display:none}
+.resource-labels{grid-column:2;grid-row:1/3;display:flex;flex-wrap:wrap;align-items:center;gap:4px 10px;font-size:12px}
+.resource-mode{display:inline-flex;align-items:center;gap:6px;color:var(--mut)}
+.resource-mode>span{width:6px;height:6px;flex-shrink:0;border-radius:50%;background:currentColor}
+.resource-mode.open{color:var(--ok)}.resource-mode.approval,.resource-warning{color:var(--warn)}.resource-mode.locked{color:var(--bad)}
+.resource-description{grid-column:1;grid-row:2;margin:0 0 0 32px;color:var(--mut);font-size:12px;line-height:1.45;overflow-wrap:anywhere}
+.resource-actions{grid-column:3;grid-row:1/3;align-self:center}
+.resource-actions>summary{display:flex;align-items:center;justify-content:center;width:32px;height:32px;border-radius:var(--r);color:var(--mut)}
+.resource-actions .ui-icon{width:18px;height:18px}
+.resource-actions>summary:hover,.resource-actions[open]>summary{background:var(--panel-raised);color:var(--fg)}
+.resource-count{margin:10px 0;text-align:right;font-variant-numeric:tabular-nums}
+.resource-help{color:var(--mut);border-top:1px solid var(--line);margin-top:16px;font-size:12px}
+.resource-help>summary{cursor:pointer;padding:10px 0;min-height:36px}
+.resource-help p{margin:0 0 10px}
+.collection-empty{padding:24px;text-align:center;grid-column:1/-1}
+.collection-empty>.ui-icon{margin:auto;color:var(--mut);width:24px;height:24px}
+.collection-empty .row{justify-content:center}
+.activity-heading{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:20px 0 8px}
+.activity-heading h2{margin:0;font-size:15px}.activity-heading>a{font-size:12px}
+.activity-list.card{padding:0 12px;background:var(--panel)}
+.activity-row+.activity-row{border-top:1px solid var(--line)}
+.activity-row>summary{display:grid;grid-template-columns:20px minmax(0,1fr) auto;gap:10px;align-items:center;min-height:56px;padding:9px 0;list-style:none;cursor:pointer}
+.activity-row>summary::-webkit-details-marker{display:none}
+.activity-row>summary:hover{background:var(--panel-raised)}
+.activity-icon{display:flex;align-items:center;justify-content:center;width:20px;height:20px;color:var(--mut)}
+.activity-icon .ui-icon{width:18px;height:18px}
+.activity-icon.passed{color:var(--ok)}.activity-icon.failed{color:var(--bad)}
+.activity-copy{min-width:0}.activity-title{display:block;font-size:13px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;font-weight:500}
+.activity-subtitle{display:block;font-size:12px;color:var(--mut);margin-top:2px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.activity-meta{display:flex;flex-direction:column;align-items:flex-end;gap:3px;font-size:12px;color:var(--mut);font-variant-numeric:tabular-nums}
+.activity-meta time{white-space:nowrap}.activity-meta .pill{font-size:11px;padding:0 5px;max-width:115px;white-space:normal;overflow-wrap:anywhere;text-align:right}
+.activity-detail{padding:0 0 12px 30px;font-size:13px}
+.activity-row[open] .activity-title,.activity-row[open] .activity-subtitle{white-space:normal;overflow-wrap:anywhere}
+.activity-detail dl{margin:0 0 10px}.activity-detail dl>div{display:grid;grid-template-columns:64px minmax(0,1fr);gap:10px;margin:5px 0}
+.activity-detail dt{color:var(--mut)}.activity-detail dd{margin:0;overflow-wrap:anywhere}
+.activity-pattern{margin:6px 0;overflow-wrap:anywhere}
+.activity-flag{color:var(--bad);font-size:12px}.activity-flag .ui-icon{display:inline-block;vertical-align:-2px;width:14px;height:14px}
+.activity-all{display:flex;margin:2px 0 8px;color:var(--mut);border:0}
+[hidden]{display:none!important}
+@media(max-width:900px){
+  .action-menu-items a,.action-menu-items button{min-height:44px}
+  .collection-heading h1{font-size:20px}.collection-intro{font-size:13px;margin-bottom:14px}
+  #resource-filters{flex-wrap:wrap;gap:10px}.resource-tabs{width:100%}.resource-tabs button{min-height:40px;flex:1}
+  .resource-search{max-width:none;flex-basis:100%;min-height:40px}.resource-search input{font-size:16px;min-height:38px}
+  .resource-card{grid-template-columns:minmax(0,1fr) 40px;gap:5px 8px;padding:12px}
+  .resource-labels{grid-column:1;grid-row:3;margin-left:32px}.resource-actions{grid-column:2;grid-row:1/4}
+  .resource-actions>summary{width:40px;height:44px}
+  .activity-list.card{padding:0 10px}
+}
+@media(max-width:360px){
+  .collection-heading{gap:8px}.resource-add>summary{font-size:12px;padding:5px 8px}
+  .resource-card{padding:10px}.activity-row>summary{gap:8px}
+  .activity-detail{padding-left:0}
+}

keywright_server/web/templates/_constraints.html

@@ -0,0 +1,6 @@
+{% if constraints.host %}<div>Host: <b>{{ constraints.host }}</b>{% if constraints.user %} · as <code>{{ constraints.user }}</code>{% endif %}</div>{% endif %}
+{% if constraints.server %}<div>Server: <b>{{ constraints.server }}</b>{% if constraints.tool %} · <code>{{ constraints.tool }}</code>{% endif %}</div>{% endif %}
+{% if constraints.command %}<pre>$ {{ constraints.command }}</pre>{% endif %}
+{% if constraints.to_path %}<div>Output {{ 'appended to' if constraints.append else 'written to' }} <b>{{ constraints.to_host }}</b> <code>{{ constraints.to_path }}</code>{% if constraints.to_user %} as <code>{{ constraints.to_user }}</code>{% endif %} · not returned to the agent</div>{% endif %}
+{% if constraints.sha256 %}<div>Write <code>{{ constraints.path }}</code> · {{ constraints.bytes }} bytes · sha256 <code>{{ constraints.sha256[:16] }}…</code></div>{% elif constraints.path %}<div>Read <code>{{ constraints.path }}</code></div>{% endif %}
+{% if 'arguments' in constraints %}<pre>{{ constraints.arguments | redact | tojson(indent=2) }}</pre>{% endif %}

keywright_server/web/templates/_decide.html

@@ -0,0 +1,39 @@
+{# Scope is independent of lifetime. Broadening requires an authenticated admin decision. #}
+<form method="post" action="/ui/requests/{{ req.id }}/decide" class="decision-actions">
+<input type="hidden" name="next" value="{{ next or '/ui' }}">
+{% if not in_detail %}{% include "_hazards.html" %}{% endif %}
+{% if hazard_blocks(hazard_level(req.detail)) %}
+<input type="hidden" name="extent" value="exact">
+<button class="btn ok" name="scope" value="once">Allow once (exact operation)</button>
+<div class="decision-deny"><input type="text" name="deny_reason" placeholder="Deny reason (optional)" aria-label="Deny reason (optional)">
+<button class="btn bad" name="scope" value="deny">Deny</button></div>
+<div class="decision-scope row"><button class="btn" name="scope" value="deny_always" onclick="return confirm('Create a standing deny rule for this exact operation?')">Always deny</button><span class="help">Flagged destructive: no timed, session or standing allow is offered.</span></div>
+</form>
+{% else %}
+<div class="decision-scope">
+<label for="extent-{{ req.id }}">What to authorize</label>
+{% if binds_exactly(req.detail) %}
+<select id="extent-{{ req.id }}" name="extent">
+<option value="exact">Exact operation shown above</option>
+<option value="patterns">Listed permission patterns, including other matching arguments</option>
+</select>
+<div class="help">Exact keeps the same command, file contents or tool arguments for every duration{% if operations(req.detail)|length > 1 %}, one grant per operation shown{% endif %}. Pattern access is broader{% if req.detail.user %}; it remains bound to {{ req.detail.user }} on this target{% endif %}.</div>
+{% else %}
+<input type="hidden" name="extent" value="patterns">
+<div>Listed permission patterns, including all matching arguments.</div>
+{% endif %}
+<label>How long to allow it</label>
+</div>
+<button class="btn ok" name="scope" value="once">Allow once</button>
+<button class="btn" name="scope" value="ttl15">15 minutes</button>
+{% if path_scoped(req.detail) %}<button class="btn" name="scope" value="path15" title="Any contents at this path, for 15 minutes">This path, 15 min</button>{% endif %}
+<button class="btn" name="scope" value="ttl30">30 minutes</button>
+<button class="btn" name="scope" value="ttl">1 hour</button>
+{% if req.session_id %}<button class="btn" name="scope" value="session">This session</button>{% endif %}
+<button class="btn" name="scope" value="always" onclick="return confirm('Create a standing allow rule for the selected scope?')">Always allow</button>
+<div class="decision-scope help">{% if req.session_id %}Session access is tied to the client-supplied session ID and expires within {{ session_cap_minutes }} minutes.{% else %}No session ID was provided; use once or timed access.{% endif %} Once applies to each listed permission scope. Expiry and revocation block future calls; running operations continue.</div>
+<div class="decision-deny"><input type="text" name="deny_reason" placeholder="Deny reason (optional)" aria-label="Deny reason (optional)">
+<button class="btn bad" name="scope" value="deny">Deny</button></div>
+<div class="decision-scope row"><button class="btn" name="scope" value="deny_always" onclick="return confirm('Create a standing deny rule for the selected scope?')">Always deny</button><span class="help">Deny rejects this request and suppresses equivalent requests for 10 minutes. Always deny creates a rule.</span></div>
+</form>
+{% endif %}

keywright_server/web/templates/_device_kind_picker.html

@@ -0,0 +1,66 @@
+<style>
+.device-kind{min-width:0}.device-kind.enhanced>select{display:none}.kind-input-row{display:flex;gap:6px}.kind-input-row input{min-width:0;width:100%;flex:1;font-size:16px}.kind-input-row .btn{flex:0 0 44px;min-width:44px;min-height:44px;padding:6px}.kind-results{border:1px solid var(--line);border-radius:6px;background:var(--panel);margin-top:6px;max-height:280px;max-height:min(280px,32svh);overflow:auto;overscroll-behavior:contain}.kind-option{display:block;width:100%;border:0;border-bottom:1px solid var(--line);border-radius:0;padding:11px 12px;min-height:44px;text-align:left;background:transparent;color:var(--fg);font:inherit;cursor:pointer;overflow-wrap:anywhere}.kind-option:last-child{border-bottom:0}.kind-option.active,.kind-option:hover{background:rgba(80,169,255,.15);color:var(--acc)}.kind-option[aria-selected=true]{font-weight:600}.kind-empty{padding:12px;margin:0;color:var(--mut)}.kind-help{margin-top:6px;font-size:12px;color:var(--mut)}
+</style>
+<script>
+(()=>{
+'use strict';
+for(const root of document.querySelectorAll('[data-device-kind]')){
+ const select=root.querySelector('select'),id=select.id;
+ const choices=[...select.options].map(o=>({value:o.value,label:o.textContent}));
+ const make=(tag,cls)=>{const n=document.createElement(tag);if(cls)n.className=cls;return n;};
+ const row=make('div','kind-input-row'),input=make('input'),toggle=make('button','btn');
+ const list=make('div','kind-results'),help=make('div','kind-help');
+ select.id=id+'-native';input.id=id;input.type='text';input.autocomplete='off';input.spellcheck=false;
+ input.setAttribute('role','combobox');input.setAttribute('aria-autocomplete','list');
+ input.setAttribute('aria-expanded','false');input.setAttribute('aria-controls',id+'-options');
+ input.setAttribute('aria-describedby',id+'-help');input.placeholder='Search device types…';
+ list.id=id+'-options';list.setAttribute('role','listbox');list.setAttribute('aria-label','Device types');list.hidden=true;
+ help.id=id+'-help';help.setAttribute('role','status');help.setAttribute('aria-live','polite');
+ toggle.type='button';toggle.textContent='⌄';toggle.setAttribute('aria-label','Browse all device types');
+ row.append(input,toggle);root.append(row,list,help);root.classList.add('enhanced');
+ let filtered=choices,active=-1,editing=false;
+ const selected=()=>choices.find(c=>c.value===select.value)||choices[0];
+ function close(restore=false){
+  list.hidden=true;input.setAttribute('aria-expanded','false');input.removeAttribute('aria-activedescendant');active=-1;
+  if(restore){input.value=selected().label;input.setCustomValidity('');editing=false;}
+  help.textContent=editing?'Choose a matching type, or press Escape to keep '+selected().label+'.':'Type to filter '+choices.length+' device types. Current: '+selected().label+'.';
+ }
+ function choose(choice){select.value=choice.value;select.dispatchEvent(new Event('change',{bubbles:true}));close(true);input.focus({preventScroll:true});}
+ function activate(index){
+  active=index;[...list.querySelectorAll('[role=option]')].forEach((n,i)=>n.classList.toggle('active',i===active));
+  const node=list.children[active];if(node&&filtered.length){input.setAttribute('aria-activedescendant',node.id);node.scrollIntoView({block:'nearest'});}else input.removeAttribute('aria-activedescendant');
+ }
+ function show(query=''){
+  const words=query.toLocaleLowerCase().trim().split(/\s+/).filter(Boolean);
+  filtered=choices.filter(c=>words.every(word=>(c.label+' '+c.value.replaceAll('_',' ')).toLocaleLowerCase().includes(word)));
+  list.replaceChildren();active=-1;input.removeAttribute('aria-activedescendant');
+  for(const [i,choice] of filtered.entries()){
+   const option=make('button','kind-option');option.type='button';option.tabIndex=-1;
+   option.id=id+'-option-'+i;option.setAttribute('role','option');option.setAttribute('aria-selected',String(choice.value===select.value));option.textContent=choice.label;
+   option.addEventListener('pointerdown',e=>e.preventDefault());option.onclick=()=>choose(choice);list.append(option);
+  }
+  if(!filtered.length){const empty=make('p','kind-empty');empty.textContent='No matching types. Try a broader term, or choose Other device.';list.append(empty);}
+  list.hidden=false;input.setAttribute('aria-expanded','true');help.textContent=filtered.length+' matching type'+(filtered.length===1?'':'s')+'. Select one to use it.';
+ }
+ close(true);
+ input.addEventListener('focus',()=>{if(!editing)input.select();});
+ input.addEventListener('click',()=>{if(list.hidden)show(editing?input.value:'');});
+ input.addEventListener('input',()=>{
+  editing=true;input.setCustomValidity('Choose a device type from the matching options.');show(input.value);
+  const exact=choices.find(c=>c.label.toLocaleLowerCase()===input.value.trim().toLocaleLowerCase());
+  if(exact){select.value=exact.value;input.setCustomValidity('');editing=false;select.dispatchEvent(new Event('change',{bubbles:true}));}
+ });
+ input.addEventListener('keydown',e=>{
+  if(e.key==='ArrowDown'||e.key==='ArrowUp'){
+   e.preventDefault();if(list.hidden)show(editing?input.value:'');
+   if(filtered.length)activate(active<0?(e.key==='ArrowDown'?0:filtered.length-1):(active+(e.key==='ArrowDown'?1:-1)+filtered.length)%filtered.length);
+  }else if(e.key==='Enter'&&!list.hidden){e.preventDefault();if(filtered.length)choose(filtered[active<0?0:active]);}
+  else if(e.key==='Escape'){e.preventDefault();close(true);}
+ });
+ toggle.onclick=()=>{if(!list.hidden){close(true);return;}input.focus();input.select();show();};
+ root.addEventListener('focusout',()=>setTimeout(()=>{if(!root.contains(document.activeElement))close();},0));
+ document.addEventListener('pointerdown',e=>{if(!root.contains(e.target))close();});
+ select.form?.addEventListener('reset',()=>setTimeout(()=>close(true),0));
+}
+})();
+</script>