@rubytech/create-sitedesk-code 0.1.526 → 0.1.527

package/payload/platform/plugins/linkedin-extension/extension/options/options.js

@@ -1,15 +1,59 @@
-// Options-page glue. Reads existing values, saves on click.
+// Options-page glue. Reads existing values, requests browser access for the
+// configured admin host, probes it, then saves.
+//
+// Task 2185 — the manifest's static host_permissions cover linkedin.com only,
+// so a service-worker fetch to the admin host is an ordinary cross-origin
+// request that Chrome preflights and the admin route never answers. The
+// runtime grant requested here is what makes that fetch permission-exempt.
+// Without it every capture dies in the browser and the server sees nothing.
 
 const $host = document.getElementById('admin-host')
 const $key = document.getElementById('session-key')
 const $btn = document.getElementById('save')
 const $status = document.getElementById('status')
 
+const TAG = '[linkedin-ext-options]'
+
 function setStatus(text, isError) {
   $status.textContent = text
   $status.classList.toggle('error', !!isError)
 }
 
+// Chrome match pattern covering every path on the admin host's origin.
+function originPattern(adminHost) {
+  return new URL(adminHost).origin + '/*'
+}
+
+// What the operator reads when the probe fails. The reason tokens are for the
+// console; this page says what actually went wrong in plain words.
+const PROBE_COPY = {
+  unreachable: 'that host did not answer',
+  auth: 'that host rejected the session key',
+  server: 'that host answered with an unexpected status',
+}
+
+// Config-time probe. The body carries none of the five envelope fields, so
+// the route answers 400 {error:'schema', reason:'envelope', missing:[all
+// five]} — a signature no real capture can produce, because both content
+// scripts always set all five. Nothing is dispatched and nothing is written.
+async function probe(adminHost, sessionKey) {
+  let res
+  try {
+    res = await fetch(adminHost + '/api/admin/linkedin-ingest', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ session_key: sessionKey }),
+    })
+  } catch (err) {
+    return { ok: false, reason: 'unreachable', detail: err && err.message ? err.message : String(err) }
+  }
+  if (res.status === 401) return { ok: false, reason: 'auth', detail: 'session-rejected' }
+  let body = null
+  try { body = await res.json() } catch { /* non-JSON body */ }
+  if (res.status === 400 && body && body.error === 'schema') return { ok: true }
+  return { ok: false, reason: 'server', detail: 'http-' + res.status }
+}
+
 async function load() {
   const stored = await chrome.storage.local.get(['adminHost', 'sessionKey'])
   if (typeof stored.adminHost === 'string') $host.value = stored.adminHost
@@ -17,13 +61,44 @@ async function load() {
 }
 
 async function save() {
-  const adminHost = $host.value.trim()
+  const adminHost = $host.value.trim().replace(/\/+$/, '')
   const sessionKey = $key.value.trim()
   if (!adminHost) return setStatus('Admin host is required.', true)
   if (!/^https?:\/\//.test(adminHost)) return setStatus('Admin host must start with http(s)://.', true)
   if (!sessionKey) return setStatus('Session key is required.', true)
+
+  let origin
+  try {
+    origin = originPattern(adminHost)
+  } catch {
+    return setStatus('Admin host is not a valid URL.', true)
+  }
+
+  // A rejected request() is not a refusal — it means Chrome would not even ask
+  // (a malformed match pattern, no user gesture). Left uncaught it aborts save()
+  // with no status at all, so the operator clicks Save and sees nothing happen.
+  let granted
+  try {
+    granted = await chrome.permissions.request({ origins: [origin] })
+  } catch (err) {
+    const detail = err && err.message ? err.message : String(err)
+    console.error(TAG + ' op=permission origin=' + origin + ' granted=error detail=' + detail)
+    return setStatus('Chrome refused to ask for access to ' + origin + ': ' + detail, true)
+  }
+  console.log(TAG + ' op=permission origin=' + origin + ' granted=' + granted)
+  if (!granted) {
+    return setStatus(
+      'Access to ' + origin + ' was declined, so nothing was saved. The pill cannot post without it.',
+      true,
+    )
+  }
+
+  const reachable = await probe(adminHost, sessionKey)
   await chrome.storage.local.set({ adminHost: adminHost, sessionKey: sessionKey })
-  setStatus('Saved.', false)
+  if (reachable.ok) {
+    return setStatus('Saved. The admin host is reachable and accepted the session key.', false)
+  }
+  setStatus('Saved, but ' + PROBE_COPY[reachable.reason] + ' (' + reachable.detail + ')', true)
 }
 
 $btn.addEventListener('click', save)

package/payload/server/{chunk-WT2PFGY4.js → chunk-KY3BBT67.js}

@@ -4075,6 +4075,214 @@ var clientIpMiddleware = async (c, next) => {
   await next();
 };
 
+// app/lib/cdp-screencast.ts
+var CDP_WS_PATH = "/cdp-screencast";
+var TARGET_ID_RE = /^[0-9A-Fa-f]{32}$/;
+function selectPageTargets(parsed) {
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const raw2 of parsed) {
+    if (raw2?.type !== "page") continue;
+    const id = typeof raw2.id === "string" ? raw2.id : "";
+    if (!TARGET_ID_RE.test(id)) continue;
+    const url = typeof raw2.url === "string" ? raw2.url : "";
+    const title = typeof raw2.title === "string" && raw2.title.length > 0 ? raw2.title : url;
+    out.push({ id, title, url });
+  }
+  return out;
+}
+var CLIENT_SCREENCAST_OPS = [
+  "request",
+  "screencast-started",
+  "start-failed",
+  "send-failed",
+  "frame",
+  "input",
+  "teardown"
+];
+function isClientScreencastOp(v) {
+  return typeof v === "string" && CLIENT_SCREENCAST_OPS.includes(v);
+}
+
+// app/lib/cdp-screencast-server.ts
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var DROP_UPSTREAM = /* @__PURE__ */ new Set(["origin", "cookie"]);
+function decideCdpUpgrade(input) {
+  const corrId = newCorrId();
+  const qsIndex = input.url.indexOf("?");
+  const pathname = qsIndex === -1 ? input.url : input.url.slice(0, qsIndex);
+  const query = qsIndex === -1 ? "" : input.url.slice(qsIndex + 1);
+  const sid = sanitizeClientCorrId(parseQueryParam(query, "sid"));
+  if (pathname !== CDP_WS_PATH) {
+    return { allow: false, reason: "wrong-path", status: 0, sid, corrId };
+  }
+  const access = input.canAccess({
+    host: input.host,
+    remoteAddress: input.remoteAddress,
+    xForwardedFor: input.xForwardedFor,
+    cookieHeader: input.cookieHeader,
+    isPublicHost: input.isPublicHost
+  });
+  if (!access.allow) {
+    const publicHost = access.reason === "public-host";
+    return {
+      allow: false,
+      reason: publicHost ? "public-host" : "unauthorized",
+      status: publicHost ? 404 : 401,
+      sid,
+      corrId
+    };
+  }
+  const originHost = parseOriginHost(input.origin);
+  if (!originHost) {
+    return { allow: false, reason: "origin-missing-or-invalid", status: 403, sid, corrId };
+  }
+  if (originHost !== input.host) {
+    return { allow: false, reason: "origin-mismatch", status: 403, sid, corrId };
+  }
+  if (input.isPublicHost(originHost)) {
+    return { allow: false, reason: "origin-public-host", status: 403, sid, corrId };
+  }
+  if (input.isOperatorHost(originHost)) {
+    return { allow: false, reason: "origin-operator-host", status: 403, sid, corrId };
+  }
+  const targetId = parseQueryParam(query, "targetId");
+  if (!targetId || !TARGET_ID_RE.test(targetId)) {
+    return { allow: false, reason: "target-id-invalid", status: 400, sid, corrId };
+  }
+  return { allow: true, targetId, sid, corrId };
+}
+function buildCdpUpstreamRequest(input) {
+  const lines = [];
+  lines.push(`${input.method} /devtools/page/${input.targetId} HTTP/${input.httpVersion}`);
+  lines.push(`host: ${input.upstreamHost}:${input.upstreamPort}`);
+  for (const [rawName, value] of Object.entries(input.headers)) {
+    const name = rawName.toLowerCase();
+    if (name === "host") continue;
+    if (HOP_BY_HOP.has(name)) continue;
+    if (DROP_UPSTREAM.has(name)) continue;
+    if (value == null) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) lines.push(`${name}: ${v}`);
+    } else {
+      lines.push(`${name}: ${value}`);
+    }
+  }
+  const upgrade = headerString(input.headers.upgrade);
+  const connection = headerString(input.headers.connection);
+  if (upgrade) lines.push(`upgrade: ${upgrade}`);
+  if (connection) lines.push(`connection: ${connection}`);
+  return lines.join("\r\n") + "\r\n\r\n";
+}
+async function fetchPageTargets(deps) {
+  if (deps.platform !== "linux") {
+    return {
+      ok: false,
+      status: 501,
+      error: "The device browser is available on the Linux display stack only."
+    };
+  }
+  let res;
+  try {
+    res = await deps.fetchImpl(`http://127.0.0.1:${deps.cdpPort}/json/list`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+    return { ok: false, status: 502, error: "Chromium is not reachable on this device." };
+  }
+  if (!res.ok) {
+    return { ok: false, status: 502, error: `CDP /json/list returned ${res.status}` };
+  }
+  let parsed;
+  try {
+    parsed = await res.json();
+  } catch {
+    return { ok: false, status: 502, error: "CDP /json/list response was not JSON." };
+  }
+  return { ok: true, targets: selectPageTargets(parsed) };
+}
+var EVENT_DETAIL_KEYS = [
+  "seq",
+  "kind",
+  "count",
+  "format",
+  "everyNthFrame",
+  "stopSent",
+  "ackMs",
+  "err",
+  "method"
+];
+var DETAIL_MAX_LEN = 128;
+function parseScreencastEvent(body) {
+  if (typeof body !== "object" || body === null) return { ok: false };
+  const raw2 = body;
+  if (!isClientScreencastOp(raw2.op)) return { ok: false };
+  const detail = {
+    sid: sanitizeClientCorrId(typeof raw2.sid === "string" ? raw2.sid : null)
+  };
+  for (const key of EVENT_DETAIL_KEYS) {
+    const v = raw2[key];
+    if (typeof v === "number" || typeof v === "boolean") {
+      detail[key] = v;
+    } else if (typeof v === "string") {
+      detail[key] = sanitizeLogValue(v);
+    }
+  }
+  return { ok: true, op: raw2.op, detail };
+}
+function sanitizeLogValue(v) {
+  return v.replace(/[\r\n]+/g, " ").slice(0, DETAIL_MAX_LEN);
+}
+function renderFields(fields) {
+  return Object.entries(fields).filter(([, v]) => v !== void 0).map(([k, v]) => {
+    const s = v === null ? "null" : String(v);
+    return `${k}=${sanitizeLogValue(s)}`;
+  }).join(" ");
+}
+function screencastLog(op, fields = {}) {
+  const rendered = renderFields(fields);
+  console.error(`[browser/screencast] op=${sanitizeLogValue(op)}${rendered ? " " + rendered : ""}`);
+}
+function cdpWsCensusLog(fields) {
+  console.error(`[cdp-ws-census] ${renderFields(fields)}`);
+}
+function parseQueryParam(query, key) {
+  if (!query) return null;
+  for (const pair of query.split("&")) {
+    const eq = pair.indexOf("=");
+    const k = eq === -1 ? pair : pair.slice(0, eq);
+    if (k !== key) continue;
+    const v = eq === -1 ? "" : pair.slice(eq + 1);
+    try {
+      return decodeURIComponent(v);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function headerString(value) {
+  if (value == null) return void 0;
+  return Array.isArray(value) ? value[0] : value;
+}
+function parseOriginHost(origin) {
+  if (!origin) return null;
+  try {
+    return new URL(origin).hostname;
+  } catch {
+    return null;
+  }
+}
+
 export {
   HTTPException,
   HtmlEscapedCallbackPhase,
@@ -4137,5 +4345,12 @@ export {
   requireAdminSession,
   tryCookieBridgeForConversation,
   requireAdminCookie,
-  clientIpMiddleware
+  clientIpMiddleware,
+  CDP_WS_PATH,
+  decideCdpUpgrade,
+  buildCdpUpstreamRequest,
+  fetchPageTargets,
+  parseScreencastEvent,
+  screencastLog,
+  cdpWsCensusLog
 };

package/payload/server/maxy-edge.js

@@ -1,8 +1,12 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
+  CDP_WS_PATH,
   Hono,
+  buildCdpUpstreamRequest,
   canAccessAdmin,
+  cdpWsCensusLog,
   clientIpMiddleware,
+  decideCdpUpgrade,
   describeRemoteSession,
   getOperatorDomains,
   getRequestListener,
@@ -12,10 +16,12 @@ import {
   requireAdminCookie,
   requirePortEnv,
   sanitizeClientCorrId,
+  screencastLog,
   vncLog,
   websockifyLog
-} from "./chunk-WT2PFGY4.js";
+} from "./chunk-KY3BBT67.js";
 import {
+  CDP_PORT,
   LOG_DIR,
   WEBSOCKIFY_PORT
 } from "./chunk-XCR5D2G3.js";
@@ -23,7 +29,7 @@ import "./chunk-PFF6I7KP.js";
 
 // server/edge.ts
 import { createServer, request as httpRequest } from "http";
-import { createConnection as createConnection2 } from "net";
+import { createConnection as createConnection3 } from "net";
 import { readFileSync as readFileSync4, existsSync as existsSync4, watchFile } from "fs";
 import { homedir } from "os";
 import { join as join4 } from "path";
@@ -315,10 +321,10 @@ function parseOriginHost(origin) {
     return null;
   }
 }
-function writeStatusAndDestroy(socket, status, statusText) {
+function writeStatusAndDestroy(socket, status, statusText2) {
   try {
     socket.write(
-      `HTTP/1.1 ${status} ${statusText}\r
+      `HTTP/1.1 ${status} ${statusText2}\r
 Connection: close\r
 Content-Length: 0\r
 \r
@@ -329,6 +335,215 @@ Content-Length: 0\r
   socket.destroy();
 }
 
+// server/cdp-ws-proxy.ts
+import { createConnection as createConnection2 } from "net";
+var UPSTREAM_TIMEOUT_MS2 = 5e3;
+var REAP_INTERVAL_MS = 6e4;
+var liveSockets = /* @__PURE__ */ new Set();
+var reaper = null;
+function cdpSessionCount() {
+  const sids = /* @__PURE__ */ new Set();
+  for (const e of liveSockets) sids.add(e.sid);
+  return sids.size;
+}
+function ensureReaperArmed() {
+  if (reaper) return;
+  reaper = setInterval(sweepOrphans, REAP_INTERVAL_MS);
+  if (typeof reaper.unref === "function") reaper.unref();
+}
+function disarmReaperIfIdle() {
+  if (liveSockets.size > 0 || !reaper) return;
+  clearInterval(reaper);
+  reaper = null;
+}
+function sweepOrphans() {
+  reapOrphanedCdpSockets();
+  disarmReaperIfIdle();
+}
+function registerCdpSocket(entry) {
+  liveSockets.add(entry);
+  ensureReaperArmed();
+  cdpWsCensusLog({ liveSockets: liveSockets.size, sessions: cdpSessionCount() });
+}
+function unregisterCdpSocket(entry) {
+  if (!liveSockets.delete(entry)) return;
+  disarmReaperIfIdle();
+  cdpWsCensusLog({ liveSockets: liveSockets.size, sessions: cdpSessionCount() });
+}
+function reapOrphanedCdpSockets() {
+  let reaped = 0;
+  for (const entry of [...liveSockets]) {
+    if (!entry.client.destroyed) continue;
+    if (!entry.upstream.destroyed) {
+      try {
+        entry.upstream.destroy();
+      } catch {
+      }
+    }
+    liveSockets.delete(entry);
+    reaped += 1;
+  }
+  if (reaped > 0) {
+    screencastLog("orphan-reap", { closed: reaped, liveSockets: liveSockets.size });
+    cdpWsCensusLog({ liveSockets: liveSockets.size, sessions: cdpSessionCount() });
+  }
+  return reaped;
+}
+function attachCdpWsProxy(server2, opts) {
+  const upstreamHost = opts.upstreamHost ?? "127.0.0.1";
+  const upstreamPort = opts.upstreamPort ?? CDP_PORT;
+  const isOperatorHost2 = opts.isOperatorHost ?? (() => false);
+  server2.on("upgrade", (req, clientSocket, head) => {
+    try {
+      handleCdpUpgrade(req, clientSocket, head, {
+        isPublicHost: opts.isPublicHost,
+        isOperatorHost: isOperatorHost2,
+        upstreamHost,
+        upstreamPort
+      });
+    } catch (err) {
+      screencastLog("gate", { decision: "reject-handler-exception", err: err.message });
+      clientSocket.destroy();
+    }
+  });
+}
+function handleCdpUpgrade(req, clientSocket, head, opts) {
+  const host = (req.headers.host ?? "").split(":")[0];
+  const decision = decideCdpUpgrade({
+    url: req.url ?? "",
+    host,
+    origin: headerString2(req.headers.origin),
+    cookieHeader: headerString2(req.headers.cookie),
+    remoteAddress: req.socket.remoteAddress,
+    xForwardedFor: headerString2(req.headers["x-forwarded-for"]),
+    isPublicHost: opts.isPublicHost,
+    isOperatorHost: opts.isOperatorHost,
+    canAccess: canAccessAdmin
+  });
+  if (!decision.allow && decision.reason === "wrong-path") return;
+  if (!decision.allow) {
+    screencastLog("gate", {
+      sid: decision.sid,
+      corrId: decision.corrId,
+      decision: `reject-${decision.reason}`,
+      host,
+      ip: req.socket.remoteAddress
+    });
+    writeStatusAndDestroy2(clientSocket, decision.status, statusText(decision.status));
+    return;
+  }
+  const sid = decision.sid ?? decision.corrId;
+  screencastLog("gate", {
+    sid,
+    corrId: decision.corrId,
+    decision: "allow",
+    host,
+    cdpPort: opts.upstreamPort
+  });
+  const upstream = createConnection2({ host: opts.upstreamHost, port: opts.upstreamPort });
+  upstream.setTimeout(UPSTREAM_TIMEOUT_MS2);
+  const entry = {
+    sid,
+    client: clientSocket,
+    upstream
+  };
+  let bytesClientToUpstream = 0;
+  let bytesUpstreamToClient = 0;
+  let closedBy = null;
+  let proxyOpened = false;
+  const openedAt = Date.now();
+  const finish = (side, reason) => {
+    if (closedBy) return;
+    closedBy = side;
+    if (proxyOpened) {
+      unregisterCdpSocket(entry);
+      screencastLog("socket-closed", {
+        sid,
+        closedBy: side,
+        reason,
+        clientBytes: bytesClientToUpstream,
+        upstreamBytes: bytesUpstreamToClient,
+        durationMs: Date.now() - openedAt,
+        liveSockets: liveSockets.size
+      });
+    }
+    clientSocket.destroy();
+    upstream.destroy();
+  };
+  upstream.once("connect", () => {
+    upstream.setTimeout(0);
+    proxyOpened = true;
+    registerCdpSocket(entry);
+    screencastLog("cdp-connected", {
+      sid,
+      wsTarget: `/devtools/page/${decision.targetId}`,
+      liveSockets: liveSockets.size
+    });
+    upstream.write(
+      buildCdpUpstreamRequest({
+        method: req.method ?? "GET",
+        httpVersion: req.httpVersion,
+        headers: req.headers,
+        targetId: decision.targetId,
+        upstreamHost: opts.upstreamHost,
+        upstreamPort: opts.upstreamPort
+      })
+    );
+    if (head && head.length > 0) upstream.write(head);
+    clientSocket.on("data", (chunk) => {
+      bytesClientToUpstream += chunk.length;
+    });
+    upstream.on("data", (chunk) => {
+      bytesUpstreamToClient += chunk.length;
+    });
+    clientSocket.pipe(upstream);
+    upstream.pipe(clientSocket);
+    clientSocket.once("close", (hadError) => finish("client", hadError ? "error" : "normal"));
+    upstream.once("close", (hadError) => finish("upstream", hadError ? "error" : "normal"));
+    clientSocket.once("error", (err) => {
+      screencastLog("socket-error", { sid, side: "client", err: err.message });
+      finish("client", "error");
+    });
+    upstream.once("error", (err) => {
+      screencastLog("socket-error", { sid, side: "upstream", err: err.message });
+      finish("upstream", "error");
+    });
+  });
+  upstream.once("timeout", () => {
+    if (proxyOpened) return;
+    screencastLog("cdp-connect-failed", { sid, err: "timeout", timeoutMs: UPSTREAM_TIMEOUT_MS2 });
+    writeStatusAndDestroy2(clientSocket, 504, "Gateway Timeout");
+    upstream.destroy();
+  });
+  upstream.once("error", (err) => {
+    if (proxyOpened) return;
+    screencastLog("cdp-connect-failed", { sid, err: err.message });
+    writeStatusAndDestroy2(clientSocket, 502, "Bad Gateway");
+    upstream.destroy();
+  });
+}
+function headerString2(value) {
+  if (value == null) return void 0;
+  return Array.isArray(value) ? value[0] : value;
+}
+function statusText(status) {
+  if (status === 400) return "Bad Request";
+  if (status === 401) return "Unauthorized";
+  if (status === 404) return "Not Found";
+  return "Forbidden";
+}
+function writeStatusAndDestroy2(socket, status, text) {
+  try {
+    socket.write(`HTTP/1.1 ${status} ${text}\r
+Connection: close\r
+Content-Length: 0\r
+\r
+`);
+  } catch {
+  }
+  socket.destroy();
+}
+
 // server/routes/admin/version.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { resolve, join as join2 } from "path";
@@ -764,7 +979,7 @@ function forwardHttp(clientReq, clientRes) {
   clientReq.pipe(upstream);
 }
 function forwardUpgrade(req, clientSocket, head) {
-  const upstream = createConnection2({ host: UPSTREAM_HOST, port: UPSTREAM_PORT });
+  const upstream = createConnection3({ host: UPSTREAM_HOST, port: UPSTREAM_PORT });
   upstream.setTimeout(5e3);
   upstream.once("connect", () => {
     upstream.setTimeout(0);
@@ -838,16 +1053,21 @@ attachVncWsProxy(server, {
   upstreamPort: WEBSOCKIFY_PORT2,
   brand: BRAND.productName
 });
+attachCdpWsProxy(server, {
+  isPublicHost,
+  isOperatorHost: (h) => isOperatorHost(h, getOperatorDomains())
+});
 server.on("upgrade", (req, socket, head) => {
   const url = req.url ?? "";
   const qsIndex = url.indexOf("?");
   const pathname = qsIndex === -1 ? url : url.slice(0, qsIndex);
-  if (pathname === "/websockify") return;
+  if (pathname === "/websockify" || pathname === CDP_WS_PATH) return;
   forwardUpgrade(req, socket, head);
 });
 server.listen(EDGE_PORT, EDGE_HOSTNAME, () => {
   console.log(`[edge] listening on http://${EDGE_HOSTNAME}:${EDGE_PORT}`);
   console.log(`[edge] brand=${BRAND.productName} holding-logo=${BRAND.logoDataUri ? "inlined" : "missing"} assets-dir=${BRAND_ASSETS_DIR || "(none)"}`);
   console.log(`[edge] /websockify \u2192 ${WEBSOCKIFY_HOST}:${WEBSOCKIFY_PORT2}`);
+  console.log(`[edge] ${CDP_WS_PATH} \u2192 127.0.0.1:${CDP_PORT} (screencast)`);
   console.log(`[edge] everything else \u2192 ${UPSTREAM_HOST}:${UPSTREAM_PORT}`);
 });

package/payload/server/public/activity.html

@@ -5,12 +5,12 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Activity — Maxy</title>
   <link rel="icon" href="/favicon.ico">
-  <script type="module" crossorigin src="/assets/activity-DGQt5ys_.js"></script>
+  <script type="module" crossorigin src="/assets/activity-aVvbaVd4.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/chunk-CltuBf4Z.js">
-  <link rel="modulepreload" crossorigin href="/assets/useSubAccountSwitcher-CnpeWIYq.js">
-  <link rel="modulepreload" crossorigin href="/assets/AdminShell-YctTrR-D.js">
-  <link rel="modulepreload" crossorigin href="/assets/triangle-alert--PCKaewD.js">
-  <link rel="stylesheet" crossorigin href="/assets/useSubAccountSwitcher-BYfe9vj8.css">
+  <link rel="modulepreload" crossorigin href="/assets/useSubAccountSwitcher-BRHYXwGO.js">
+  <link rel="modulepreload" crossorigin href="/assets/AdminShell-MM3_yp3N.js">
+  <link rel="modulepreload" crossorigin href="/assets/triangle-alert-CpwrbdYq.js">
+  <link rel="stylesheet" crossorigin href="/assets/useSubAccountSwitcher-CJzJ9xV3.css">
   <link rel="stylesheet" href="/brand-defaults.css">
 </head>
 <body>

package/payload/server/public/agents.html

@@ -5,11 +5,11 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Agents — Maxy</title>
   <link rel="icon" href="/favicon.ico">
-  <script type="module" crossorigin src="/assets/agents-Bc2LZjwC.js"></script>
+  <script type="module" crossorigin src="/assets/agents-CrpVTPRG.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/chunk-CltuBf4Z.js">
-  <link rel="modulepreload" crossorigin href="/assets/useSubAccountSwitcher-CnpeWIYq.js">
-  <link rel="modulepreload" crossorigin href="/assets/AdminShell-YctTrR-D.js">
-  <link rel="stylesheet" crossorigin href="/assets/useSubAccountSwitcher-BYfe9vj8.css">
+  <link rel="modulepreload" crossorigin href="/assets/useSubAccountSwitcher-BRHYXwGO.js">
+  <link rel="modulepreload" crossorigin href="/assets/AdminShell-MM3_yp3N.js">
+  <link rel="stylesheet" crossorigin href="/assets/useSubAccountSwitcher-CJzJ9xV3.css">
   <link rel="stylesheet" href="/brand-defaults.css">
 </head>
 <body>