pycodex-ws 0.4.1__tar.gz → 0.4.3__tar.gz

{pycodex_ws-0.4.1 → pycodex_ws-0.4.3}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: pycodex-ws
-Version: 0.4.1
+Version: 0.4.3
 Summary: Browser workspace and optional Feishu integration for python-codex
 License-File: LICENSE
 Requires-Python: >=3.7
 Requires-Dist: pillow>=9.0.0
-Requires-Dist: python-codex==0.4.1
+Requires-Dist: python-codex==0.4.3
 Requires-Dist: websockets<16,>=11
 Description-Content-Type: text/markdown
 

pycodex_ws-0.4.3/pycodex_router/browser.py

@@ -0,0 +1,107 @@
+"""Browser access checks for trusted devices sharing a router origin."""
+
+import ipaddress
+import re
+from urllib.parse import urlencode, urlsplit
+
+from starlette.exceptions import HTTPException
+from starlette.requests import HTTPConnection
+from starlette.responses import JSONResponse, RedirectResponse
+
+from .protocol import route_path
+
+
+def request_origin(connection):
+    try:
+        parsed = urlsplit("//" + connection.headers["host"])
+        port = parsed.port
+    except ValueError:
+        raise HTTPException(400, "Invalid router host.")
+    host = parsed.hostname
+    if (
+        not host
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.path
+        or parsed.query
+        or parsed.fragment
+    ):
+        raise HTTPException(400, "Invalid router host.")
+    try:
+        ipaddress.ip_address(host)
+    except ValueError:
+        if len(host) > 253 or any(
+            not re.fullmatch(r"[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?", label)
+            for label in host.split(".")
+        ):
+            raise HTTPException(400, "Invalid router host.")
+    scheme = "https" if connection.scope["scheme"] in {"https", "wss"} else "http"
+    suffix = "" if port in (None, 443 if scheme == "https" else 80) else ":" + str(port)
+    authority = "[" + host + "]" if ":" in host else host
+    return scheme + "://" + authority + suffix
+
+
+class BrowserAccess:
+    def __init__(self, router, app):
+        self.router = router
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        connection = HTTPConnection(scope)
+        origin = request_origin(connection)
+
+        async def secured_send(message):
+            if message["type"] == "http.response.start":
+                message = dict(
+                    message,
+                    headers=list(message["headers"])
+                    + [
+                        (b"content-security-policy", b"frame-ancestors 'self'"),
+                        (b"x-frame-options", b"SAMEORIGIN"),
+                        (b"x-content-type-options", b"nosniff"),
+                        (b"referrer-policy", b"no-referrer"),
+                        (b"permissions-policy", b"document-domain=()"),
+                        (b"origin-agent-cluster", b"?1"),
+                    ],
+                )
+            await send(message)
+
+        try:
+            if connection.client.host in self.router.blocked_ips:
+                raise HTTPException(
+                    403,
+                    "Too many incorrect passwords. This IP is blocked "
+                    "until the router restarts.",
+                )
+            if connection.headers.get("origin") not in (None, origin):
+                raise HTTPException(
+                    403, "Cross-origin router requests are not allowed."
+                )
+            await self.app(scope, receive, secured_send)
+        except HTTPException as exc:
+            if scope["type"] == "websocket":
+                await send({"type": "websocket.close", "code": 1008})
+            else:
+                await JSONResponse({"error": exc.detail}, exc.status_code)(
+                    scope, receive, secured_send
+                )
+
+
+async def require_login(scope, receive, send):
+    connection = HTTPConnection(scope)
+    if scope["type"] == "websocket":
+        await send({"type": "websocket.close", "code": 1008})
+    elif "/api/" in route_path(scope) or scope["method"] not in {"GET", "HEAD"}:
+        await JSONResponse({"error": "authentication required"}, 401)(
+            scope, receive, send
+        )
+    else:
+        node_id = scope["path_params"]["node_id"]
+        prefix = scope.get("root_path", "")
+        root = prefix[: -len("/n/" + node_id)]
+        target = prefix + route_path(scope)
+        if connection.url.query:
+            target += "?" + connection.url.query
+        await RedirectResponse(
+            root + "/login?" + urlencode({"next": target}), 303
+        )(scope, receive, send)

{pycodex_ws-0.4.1 → pycodex_ws-0.4.3}/pycodex_router/client.py

@@ -4,9 +4,10 @@ import secrets
 import socket
 from contextlib import asynccontextmanager
 
-from websockets.exceptions import ConnectionClosed, InvalidHandshake
+from websockets.exceptions import ConnectionClosed, InvalidHandshake, InvalidStatusCode
 from websockets.legacy.client import connect
-from .protocol import decode, device_id, encode, send_event, tunnel_url
+
+from .protocol import decode, device_id, encode, parse_target, send_event, tunnel_url
 
 
 class NodeIdInUse(Exception):
@@ -25,8 +26,9 @@ class RouterClient:
         reconnect_seconds=1.0,
     ):
         self.app = app
-        self.control_url = tunnel_url(target, "control")
-        self.data_url = tunnel_url(target, "data")
+        address, self._registration_key = parse_target(target)
+        self.control_url = tunnel_url(address, "control")
+        self.data_url = tunnel_url(address, "data")
         self._identity_key = secrets.token_hex(32)
         self.node_id = device_id(self._identity_key)
         self.name = name
@@ -43,6 +45,7 @@ class RouterClient:
     def _connect(self, url):
         return connect(
             url,
+            extra_headers={"Authorization": "Bearer " + self._registration_key},
             open_timeout=10,
             close_timeout=2,
             ping_interval=20,
@@ -101,6 +104,8 @@ class RouterClient:
             )
             if isinstance(failure, ConnectionClosed) and failure.rcvd is not None:
                 reason += ", close_code={0}".format(failure.rcvd.code)
+            elif isinstance(failure, InvalidStatusCode):
+                reason += ", status_code={0}".format(failure.status_code)
             self._logger.warning(
                 "Router node %s disconnected (%s); retrying in %g seconds",
                 self.name,
@@ -230,6 +235,7 @@ def attach_router(app, registry, target, port):
                 "enable_board": workspace["enable_board"],
                 "session_count": len(workspace["sessions"]),
                 "running": any(session["running"] for session in workspace["sessions"]),
+                "unread": any(session["unread"] for session in workspace["sessions"]),
             }
             for workspace in registry.list_workspaces()
         ]

{pycodex_ws-0.4.1 → pycodex_ws-0.4.3}/pycodex_router/index.html

@@ -36,9 +36,9 @@
     * { box-sizing: border-box; }
     body { margin: 0; min-height: 100vh; background: var(--bg); color: var(--ink); font-size: 13px; }
     a { color: inherit; text-decoration: none; }
-    a:focus-visible { outline: 2px solid var(--accent); outline-offset: 5px; border-radius: 3px; }
+    a:focus-visible, .device-label:focus-visible { outline: 2px solid var(--accent); outline-offset: 5px; border-radius: 3px; }
     svg { width: 20px; height: 20px; flex: 0 0 auto; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
-    h1, h2, h3, p { margin: 0; }
+    h1, h2, h3, h4, p { margin: 0; }
     code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
     .page { width: min(1440px, calc(100% - 48px)); margin: 0 auto; padding-bottom: 32px; }
     .topbar { display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 16px 0; border-bottom: 1px solid var(--line); }
@@ -55,36 +55,58 @@
     .intro { display: flex; flex-wrap: wrap; align-items: baseline; gap: 8px 18px; padding: 24px 0; }
     h1 { font-size: 24px; line-height: 1.3; font-weight: 650; letter-spacing: -.7px; }
     .intro p { color: var(--muted); font-size: 12px; line-height: 1.6; }
+    .registration { max-width: 640px; margin-bottom: 24px; }
+    .registration summary { width: fit-content; color: var(--accent); cursor: pointer; }
+    .registration-content { display: grid; gap: 8px; margin-top: 12px; }
+    .registration input { width: 100%; min-width: 0; padding: 8px 10px; border: 1px solid var(--line); border-radius: 6px; background: var(--panel); color: var(--ink); font: 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+    .registration p { color: var(--muted); font-size: 12px; line-height: 1.6; overflow-wrap: anywhere; }
+    #alias-status { margin-bottom: 12px; color: var(--danger); font-size: 12px; }
+    #alias-status:empty { display: none; }
     .layout { display: grid; grid-template-columns: minmax(0, 1fr) 280px; gap: 20px; align-items: start; }
     .layout > * { min-width: 0; }
     .section-heading { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 12px; }
     h2 { display: flex; align-items: center; gap: 9px; font-size: 13px; font-weight: 600; }
     .count { min-width: 23px; padding: 2px 7px; border-radius: 6px; background: var(--soft); color: var(--muted); font-size: 11px; text-align: center; font-variant-numeric: tabular-nums; }
     #activity { color: var(--green); font-size: 12px; }
+    #workspaces { display: grid; gap: 16px; }
     .workspace-table, .nodes { background: var(--panel); border: 1px solid var(--line); border-radius: 9px; }
-    .list-head, .workspace-row { display: grid; grid-template-columns: minmax(94px, .85fr) minmax(120px, 1.35fr) minmax(110px, 1fr) 60px 44px; gap: 12px; align-items: center; padding: 10px 14px; }
-    .list-head { position: sticky; top: 0; z-index: 1; border-radius: 9px 9px 0 0; background: var(--soft); color: var(--muted); font-size: 10px; font-weight: 550; letter-spacing: .3px; }
-    .workspace-row { min-height: 62px; border-top: 1px solid var(--line); }
+    .workspace-group-heading { display: flex; align-items: center; gap: 10px; padding: 12px 14px; }
+    .workspace-group-name { flex: 1; min-width: 0; font-size: 12px; font-weight: 600; line-height: 1.6; overflow-wrap: anywhere; }
+    .workspace-group-heading .count { flex: 0 0 auto; }
+    .list-head, .workspace-row { display: grid; grid-template-columns: minmax(94px, .85fr) minmax(120px, 1.85fr) 76px 44px; gap: 12px; align-items: center; padding: 10px 14px; }
+    .list-head { position: sticky; top: 0; z-index: 1; background: var(--soft); color: var(--muted); font-size: 10px; font-weight: 550; letter-spacing: .3px; }
+    .workspace-row { position: relative; min-height: 62px; border-top: 1px solid var(--line); }
     .workspace-row > * { min-width: 0; }
     .workspace-row:hover { background: var(--soft); }
     .workspace-row:last-child { border-radius: 0 0 9px 9px; }
-    .activity-badge { justify-self: start; display: inline-flex; align-items: center; gap: 5px; padding: 3px 6px; border-radius: 4px; color: var(--muted); background: var(--soft); font-size: 10px; font-weight: 500; }
+    .activity-badge { display: inline-flex; align-items: center; gap: 5px; padding: 3px 6px; border-radius: 4px; color: var(--muted); background: var(--soft); font-size: 10px; font-weight: 500; }
     .activity-badge[data-state="working"] { color: var(--green); background: var(--green-soft); }
-    .activity-badge[data-state="working"]::before { content: ""; width: 5px; height: 5px; border-radius: 50%; background: currentColor; }
+    .activity-badge[data-state="working"]::before { content: ""; width: 5px; height: 5px; border-radius: 50%; background: currentColor; animation: spinner-pulse 1.2s cubic-bezier(0.4, 0, 0.2, 1) infinite; }
+    @keyframes spinner-pulse {
+      0%, 100% { opacity: .45; transform: scale(.82); }
+      50% { opacity: 1; transform: scale(1.08); }
+    }
+    @media (prefers-reduced-motion: reduce) {
+      .activity-badge[data-state="working"]::before { animation: none; opacity: .8; transform: none; }
+    }
+    .workspace-status { display: inline-flex; align-items: center; gap: 6px; justify-self: start; }
+    .unread-dot { flex: 0 0 6px; width: 6px; height: 6px; border-radius: 50%; background: var(--danger); }
     .workspace-title { font-size: 12px; line-height: 1.6; font-weight: 600; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
     .workspace-path, .state-path { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 11px; line-height: 1.8; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
     .state-path { color: var(--muted); }
-    .workspace-device { color: var(--muted); }
-    .workspace-device code { display: block; min-width: 0; font-size: 11px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
     .session-count { color: var(--muted); font-size: 11px; line-height: 1.7; }
     .open-link, .manage-link { display: inline-flex; align-items: center; justify-content: flex-end; gap: 4px; min-height: 28px; color: var(--accent); font-size: 11px; font-weight: 550; white-space: nowrap; }
     .open-link svg, .manage-link svg { width: 13px; height: 13px; }
+    .open-link::after { content: ""; position: absolute; inset: 0; }
     .open-link:hover, .manage-link:hover { text-decoration: underline; text-underline-offset: 4px; }
     .device { min-width: 0; padding: 12px 14px; }
     .device + .device { border-top: 1px solid var(--line); }
     .device-heading { display: flex; align-items: start; gap: 9px; }
     .device-heading svg { width: 17px; height: 17px; margin-top: 1px; color: var(--muted); }
     .device-name { flex: 1; min-width: 0; font-size: 11px; font-weight: 500; line-height: 1.6; overflow-wrap: anywhere; }
+    .device-label { display: block; width: 100%; padding: 0; border: 0; background: none; color: inherit; font: inherit; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; text-align: left; overflow-wrap: anywhere; cursor: text; }
+    .device-label[hidden] { display: none; }
+    .device-alias-input { width: 100%; min-width: 0; padding: 3px 6px; border: 1px solid var(--accent); border-radius: 4px; background: var(--panel); color: var(--ink); font: inherit; outline: none; }
     .online-dot { margin-top: 7px; }
     .device-footer { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 2px 8px; margin-top: 6px; }
     .device-detail { color: var(--muted); font-size: 10px; line-height: 1.5; }
@@ -104,10 +126,8 @@
       .intro { padding: 20px 0; }
       .list-head { display: none; }
       .workspace-row { grid-template-columns: minmax(0, 1fr) auto auto; gap: 6px 10px; padding: 10px 12px; }
-      .workspace-row:first-child { border-top: 0; border-radius: 9px 9px 0 0; }
       .workspace-paths { grid-column: 1 / -1; grid-row: 2; }
-      .workspace-device { grid-column: 1 / -1; grid-row: 3; }
-      .activity-badge { grid-column: 2; grid-row: 1; }
+      .workspace-status { grid-column: 2; grid-row: 1; }
       .open-link { grid-column: 3; grid-row: 1; min-height: 36px; }
     }
   </style>
@@ -130,19 +150,24 @@
         <h1>Your workspaces</h1>
         <p>Across your connected devices.</p>
       </div>
+      <details id="device-connection" class="registration">
+        <summary>Connect a trusted device</summary>
+        <div class="registration-content">
+          <label for="registration-key">Registration key</label>
+          <input id="registration-key" readonly autocomplete="off" spellcheck="false">
+          <p id="registration-status" role="status"></p>
+          <p>On the device, use <code>pycodex-ws --listen-to KEY@ROUTER_ADDRESS:6000</code>. Replace <code>KEY</code> with this key and use your router's device port.</p>
+        </div>
+      </details>
+      <p id="alias-status" role="alert"></p>
       <div class="layout">
         <section aria-labelledby="workspace-heading">
           <div class="section-heading">
             <h2 id="workspace-heading">Workspaces <span id="workspace-count" class="count">—</span></h2>
             <span id="activity"></span>
           </div>
-          <div class="workspace-table">
-            <div class="list-head" aria-hidden="true">
-              <span>Workspace</span><span>Directory / state</span><span>Device</span><span>Status</span><span></span>
-            </div>
-            <div id="workspaces" aria-busy="true">
-              <div class="empty"><h3>Loading workspaces…</h3></div>
-            </div>
+          <div id="workspaces" aria-busy="true">
+            <div class="empty"><h3>Loading workspaces…</h3></div>
           </div>
         </section>
         <aside aria-labelledby="device-heading">
@@ -154,20 +179,32 @@
       </div>
     </main>
   </div>
+  <template id="workspace-group-template">
+    <section class="workspace-table workspace-group">
+      <header class="workspace-group-heading">
+        <h3 class="workspace-group-name"><button type="button" class="device-label"></button></h3>
+        <span class="count"></span>
+      </header>
+      <div class="list-head" aria-hidden="true">
+        <span>Workspace</span><span>Directory / state</span><span>Status</span><span></span>
+      </div>
+      <div class="workspace-group-list"></div>
+    </section>
+  </template>
   <template id="workspace-template">
     <article class="workspace-row">
       <div class="workspace-main">
-        <h3 class="workspace-title"></h3>
+        <h4 class="workspace-title"></h4>
         <span class="session-count"></span>
       </div>
       <div class="workspace-paths">
         <p class="workspace-path"></p>
         <p class="state-path"></p>
       </div>
-      <div class="workspace-device">
-        <code></code>
-      </div>
-      <span class="activity-badge"></span>
+      <span class="workspace-status">
+        <span class="unread-dot" role="img" aria-label="Unread reply" title="Unread reply"></span>
+        <span class="activity-badge"></span>
+      </span>
       <a class="open-link">Open <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M5 12h14m-6-6 6 6-6 6"/></svg></a>
     </article>
   </template>
@@ -175,7 +212,7 @@
     <article class="device">
       <div class="device-heading">
         <svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="4" width="18" height="12" rx="2"/><path d="M8 20h8m-4-4v4"/></svg>
-        <h3 class="device-name"><code></code></h3>
+        <h3 class="device-name"><button type="button" class="device-label"></button></h3>
         <span class="online-dot" aria-label="Online"></span>
       </div>
       <div class="device-footer">
@@ -198,11 +235,36 @@
       const layout = document.querySelector(".layout");
       const workspaces = document.getElementById("workspaces");
       const nodes = document.getElementById("nodes");
+      const workspaceGroupTemplate = document.getElementById("workspace-group-template");
       const workspaceTemplate = document.getElementById("workspace-template");
       const deviceTemplate = document.getElementById("device-template");
       const emptyTemplate = document.getElementById("empty-template");
+      const deviceConnection = document.getElementById("device-connection");
+      const registrationKey = document.getElementById("registration-key");
+      const registrationStatus = document.getElementById("registration-status");
+      const aliasStatus = document.getElementById("alias-status");
       let refreshing = false;
       let signature = "";
+      let editingDevice = null;
+      let aliasRevision = 0;
+
+      registrationKey.addEventListener("focus", () => registrationKey.select());
+      deviceConnection.addEventListener("toggle", async () => {
+        registrationKey.value = "";
+        registrationStatus.textContent = "";
+        if (!deviceConnection.open) return;
+        registrationStatus.textContent = "Loading…";
+        try {
+          const response = await fetch("api/registration-key", {cache: "no-store"});
+          if (!response.ok) throw new Error(`HTTP ${response.status}`);
+          const data = await response.json();
+          if (!deviceConnection.open) return;
+          registrationKey.value = data.key;
+          registrationStatus.textContent = "Select the key to copy it.";
+        } catch (error) {
+          if (deviceConnection.open) registrationStatus.textContent = `Could not load key · ${error.message}`;
+        }
+      });
 
       function countLabel(count, label) {
         return `${count} ${label}${count === 1 ? "" : "s"}`;
@@ -221,30 +283,104 @@
         layout.dataset.stale = String(state === "error");
       }
 
+      function bindDeviceLabel(label, node, data) {
+        label.textContent = node.alias || node.name;
+        label.title = `${node.name}\nClick to rename device`;
+        label.setAttribute("aria-label", `Rename device ${node.alias || node.name}`);
+        label.addEventListener("click", () => editDeviceAlias(label, node, data));
+      }
+
+      function editDeviceAlias(label, node, data) {
+        if (editingDevice !== null) return;
+        editingDevice = node.id;
+        aliasStatus.textContent = "";
+        const input = document.createElement("input");
+        input.type = "text";
+        input.className = "device-alias-input";
+        input.maxLength = 128;
+        input.setAttribute("aria-label", "Device alias");
+        input.title = "Leave empty to use the original device name.";
+        input.value = node.alias || "";
+        input.placeholder = node.name;
+        label.hidden = true;
+        label.before(input);
+        let finished = false;
+        const finish = async save => {
+          if (finished) return;
+          finished = true;
+          const alias = input.value.trim();
+          input.remove();
+          label.hidden = false;
+          try {
+            if (save && alias !== (node.alias || "")) {
+              const response = await fetch(`api/nodes/${encodeURIComponent(node.id)}/alias`, {
+                method: "POST",
+                headers: {"Content-Type": "application/json"},
+                body: JSON.stringify({alias}),
+              });
+              if (!response.ok) throw new Error(await response.text());
+              const result = await response.json();
+              node.alias = result.alias;
+              aliasRevision += 1;
+              render(data);
+              signature = JSON.stringify(data);
+            }
+          } catch (error) {
+            aliasStatus.textContent = `Could not rename device: ${error.message}`;
+          } finally {
+            editingDevice = null;
+            refresh();
+          }
+        };
+        input.addEventListener("keydown", event => {
+          if (event.isComposing) return;
+          if (event.key === "Enter" || event.key === "Escape") {
+            event.preventDefault();
+            finish(event.key === "Enter");
+            label.focus();
+          }
+        });
+        input.addEventListener("blur", () => finish(true));
+        input.focus();
+        input.select();
+      }
+
       function render(data) {
         const workspaceList = document.createDocumentFragment();
+        const groups = new Map();
+        for (const node of data.nodes) {
+          const group = workspaceGroupTemplate.content.firstElementChild.cloneNode(true);
+          group.setAttribute("aria-label", node.alias || node.name);
+          bindDeviceLabel(group.querySelector(".device-label"), node, data);
+          groups.set(node.id, {node, group});
+        }
         for (const workspace of data.workspaces) {
           const card = workspaceTemplate.content.firstElementChild.cloneNode(true);
           const title = card.querySelector(".workspace-title");
           title.textContent = workspace.id;
           title.title = workspace.id;
+          card.querySelector(".unread-dot").hidden = !workspace.unread;
           const path = card.querySelector(".workspace-path");
           path.textContent = workspace.work_dir;
           path.title = workspace.work_dir;
           const statePath = card.querySelector(".state-path");
           statePath.textContent = workspace.state_path;
           statePath.title = workspace.state_path;
-          const device = card.querySelector(".workspace-device code");
-          device.textContent = workspace.node_name;
-          device.title = workspace.node_name;
           const activity = card.querySelector(".activity-badge");
           activity.dataset.state = workspace.running ? "working" : "ready";
           activity.textContent = workspace.running ? "Working" : "Ready";
           card.querySelector(".session-count").textContent = countLabel(workspace.session_count, "session");
           const link = card.querySelector(".open-link");
           link.href = workspace.url;
-          link.setAttribute("aria-label", `Open ${workspace.id} on ${workspace.node_name}`);
-          workspaceList.append(card);
+          const {node, group} = groups.get(workspace.node_id);
+          link.setAttribute("aria-label", `Open ${workspace.id} on ${node.alias || node.name}`);
+          group.querySelector(".workspace-group-list").append(card);
+        }
+        for (const {group} of groups.values()) {
+          const count = group.querySelector(".workspace-group-list").childElementCount;
+          if (!count) continue;
+          group.querySelector(".count").textContent = countLabel(count, "workspace");
+          workspaceList.append(group);
         }
         if (!data.workspaces.length) {
           workspaceList.append(empty("No workspaces yet", data.nodes.length
@@ -255,13 +391,13 @@
         const nodeList = document.createDocumentFragment();
         for (const node of data.nodes) {
           const card = deviceTemplate.content.firstElementChild.cloneNode(true);
-          card.querySelector(".device-name code").textContent = node.name;
+          bindDeviceLabel(card.querySelector(".device-label"), node, data);
           const owned = data.workspaces.filter(workspace => workspace.node_id === node.id);
           const sessions = owned.reduce((total, workspace) => total + workspace.session_count, 0);
           card.querySelector(".device-detail").textContent = `${countLabel(owned.length, "workspace")} · ${countLabel(sessions, "session")}`;
           const link = card.querySelector(".manage-link");
           link.href = node.url;
-          link.setAttribute("aria-label", `Manage workspaces on ${node.name}`);
+          link.setAttribute("aria-label", `Manage workspaces on ${node.alias || node.name}`);
           nodeList.append(card);
         }
         if (!data.nodes.length) {
@@ -278,6 +414,7 @@
       async function refresh() {
         if (refreshing) return;
         refreshing = true;
+        const revision = aliasRevision;
         try {
           const response = await fetch("api/workspaces", {cache: "no-store"});
           if (response.status === 401) {
@@ -287,7 +424,7 @@
           if (!response.ok) throw new Error(`HTTP ${response.status}`);
           const data = await response.json();
           const next = JSON.stringify(data);
-          if (next !== signature) {
+          if (editingDevice === null && revision === aliasRevision && next !== signature) {
             render(data);
             signature = next;
           }

{pycodex_ws-0.4.1 → pycodex_ws-0.4.3}/pycodex_router/protocol.py

@@ -48,6 +48,33 @@ def tunnel_url(target, endpoint):
     )
 
 
+def parse_target(target):
+    """Separate a registration key from the address used on the wire."""
+    try:
+        has_scheme = "://" in target
+        parsed = urlsplit(target if has_scheme else "ws://" + target)
+        key = parsed.username
+        if (
+            not key
+            or not re.fullmatch("[1-9A-HJ-NP-Za-km-z]{1,22}", key)
+            or parsed.password is not None
+        ):
+            raise ValueError("invalid registration key")
+        authority = parsed.netloc.rsplit("@", 1)[1]
+        if not has_scheme and parsed.port is None:
+            authority += ":6000"
+        address = urlunsplit(
+            (parsed.scheme, authority, parsed.path, parsed.query, parsed.fragment)
+        )
+        tunnel_url(address, "control")
+    except ValueError:
+        raise ValueError(
+            "router address must be KEY@host[:port] or ws(s)://KEY@host[:port], "
+            "using the router-generated registration key"
+        ) from None
+    return address, key
+
+
 def encode(value):
     def binary(item):
         if isinstance(item, bytes):