clay-server 4.7.0 → 4.7.1-beta.2

package/README.md

@@ -73,6 +73,12 @@ Clay Studio does not relay project traffic through a Clay-hosted cloud. Your cod
 
 The `d.clay.studio` hostname used for local HTTPS is a DNS-only service: no application data passes through it. See [clay-dns](clay-dns/) for the implementation and threat model.
 
+### Reverse proxies and tunnels
+
+If your proxy rewrites the upstream `Host` header, open **Server Settings → Network → Reverse proxy & tunnels** and add your browser-facing origin, for example `https://clay.example.com`. Enter one HTTP or HTTPS origin per line, with a port when needed and no path or wildcard. Only server administrators can edit this setting in multi-user mode. Saving applies to new WebSocket connections without a restart; existing connections stay open until they reconnect, and authentication remains required. When Clay refuses a WebSocket because of its origin, the daemon log notes the refused origin (at most once a minute).
+
+If the tunnel cannot connect yet, use a working local connection to configure it. Alternatively, stop the daemon, add `"allowedOrigins": ["https://clay.example.com"]` to the existing `~/.clay/daemon.json` (or the daemon config in your `CLAY_HOME`), preserving its other fields, and start Clay again. Direct connections and proxies that preserve `Host` normally need no additional origins. Forwarded headers are not trusted automatically.
+
 ## Common CLI commands
 
 ```bash

package/lib/daemon.js

@@ -789,6 +789,10 @@ var relay = createServer({
     }
     return { ok: false, error: "Project not found" };
   },
+  onGetAllowedOrigins: function () { return config.allowedOrigins || []; },
+  onSetAllowedOrigins: function (origins) {
+    require("./network-origins").saveAllowedOrigins(config, origins, saveConfig);
+  },
   onGetDaemonConfig: function () {
     return {
       port: config.port,

package/lib/network-origin-diagnostics.js

@@ -0,0 +1,38 @@
+// Rate-limited log hint for rejected WebSocket origins. State is fixed-size
+// (one timestamp and one counter), so hostile traffic cannot grow memory or
+// flood the daemon log. Only Origin and Host are logged, never cookies or tokens.
+var DEFAULT_INTERVAL_MS = 60000;
+var MAX_VALUE_LENGTH = 200;
+
+function safeValue(value) {
+  if (typeof value !== "string") return "(none)";
+  var text = value.length > MAX_VALUE_LENGTH ? value.slice(0, MAX_VALUE_LENGTH) + "..." : value;
+  // JSON quoting escapes newlines and control characters, preventing log injection.
+  return JSON.stringify(text);
+}
+
+function createOriginRejectionLogger(options) {
+  var opts = options || {};
+  var intervalMs = opts.intervalMs || DEFAULT_INTERVAL_MS;
+  var now = opts.now || Date.now;
+  var log = opts.log || function (message) { console.warn(message); };
+  var lastLoggedAt = null;
+  var suppressed = 0;
+
+  return function logRejectedOrigin(origin, host) {
+    var current = now();
+    if (lastLoggedAt !== null && current - lastLoggedAt < intervalMs) {
+      suppressed++;
+      return false;
+    }
+    var message = "[network] Rejected WebSocket connection from origin " + safeValue(origin) +
+      " (Host " + safeValue(host) + "). If this is your reverse proxy or tunnel address, an administrator can add it in Server Settings > Network.";
+    if (suppressed > 0) message += " " + suppressed + " similar rejection(s) were not logged.";
+    lastLoggedAt = current;
+    suppressed = 0;
+    log(message);
+    return true;
+  };
+}
+
+module.exports = { createOriginRejectionLogger: createOriginRejectionLogger };

package/lib/network-origins.js

@@ -0,0 +1,90 @@
+// Shared validation for configured browser origins and WebSocket handshakes.
+var MAX_ORIGINS = 100;
+var MAX_ORIGIN_LENGTH = 2048;
+
+function invalid(reason) {
+  var error = new Error(reason);
+  error.reason = reason;
+  return error;
+}
+
+function normalizeOrigin(value) {
+  if (typeof value !== "string") throw invalid("must be text, for example https://clay.example.com.");
+  if (value.length > MAX_ORIGIN_LENGTH) throw invalid("is longer than " + MAX_ORIGIN_LENGTH + " characters.");
+  if (value.indexOf("*") !== -1) throw invalid("cannot contain wildcards (*). List each address separately.");
+  if (!/^https?:\/\//i.test(value)) throw invalid("must start with http:// or https://.");
+  if (!/^https?:\/\/[^\s/?#\\]+\/?$/i.test(value)) {
+    throw invalid("cannot include a path, query, fragment, or spaces. Use only the scheme, host, and optional port.");
+  }
+  var url;
+  try { url = new URL(value); } catch (e) { throw invalid("is not a valid address. Check the host name and port."); }
+  if (url.username || url.password) throw invalid("cannot include a username or password.");
+  return url.origin;
+}
+
+function normalizeAllowedOrigins(values) {
+  if (!Array.isArray(values)) throw invalid("Allowed origins must be a list.");
+  if (values.length > MAX_ORIGINS) throw invalid("Enter at most " + MAX_ORIGINS + " allowed origins.");
+  var normalized = [];
+  for (var i = 0; i < values.length; i++) {
+    try {
+      normalized.push(normalizeOrigin(values[i]));
+    } catch (e) {
+      var error = invalid("Entry " + (i + 1) + " " + e.reason);
+      error.index = i;
+      error.entryReason = e.reason;
+      throw error;
+    }
+  }
+  return Array.from(new Set(normalized));
+}
+
+// Describes stored entries for the editor without dropping invalid manual edits.
+function describeConfiguredOrigins(raw) {
+  if (raw === undefined || raw === null) return { allowedOrigins: [], invalid: [] };
+  var list = Array.isArray(raw) ? raw : [raw];
+  var entries = [];
+  var problems = [];
+  for (var i = 0; i < list.length; i++) {
+    var value = list[i];
+    entries.push(typeof value === "string" ? value : JSON.stringify(value) || String(value));
+    try { normalizeOrigin(value); } catch (e) { problems.push({ index: i, reason: e.reason }); }
+  }
+  if (!Array.isArray(raw)) problems.unshift({ index: 0, reason: "is not stored as a list. Save to store it correctly." });
+  return { allowedOrigins: entries, invalid: problems };
+}
+
+function isAllowedOrigin(origin, host, allowedOrigins) {
+  // Non-browser clients may omit Origin; authentication is still required.
+  if (origin === undefined) return true;
+  try {
+    var normalized = normalizeOrigin(origin);
+    var configured = Array.isArray(allowedOrigins) ? allowedOrigins : [];
+    for (var i = 0; i < configured.length; i++) {
+      try {
+        if (normalizeOrigin(configured[i]) === normalized) return true;
+      } catch (e) { /* Invalid manual config entries never grant access. */ }
+    }
+    // Preserve Host-based access through TLS-terminating proxies. Forwarded
+    // headers are deliberately not trusted; rewritten hosts need an allowlist.
+    if (typeof host !== "string" || !host.trim()) return false;
+    var protocol = new URL(normalized).protocol;
+    return normalizeOrigin(protocol + "//" + host) === normalized;
+  } catch (e) {
+    return false;
+  }
+}
+
+function saveAllowedOrigins(config, origins, saveConfig) {
+  var normalized = normalizeAllowedOrigins(origins);
+  var nextConfig = Object.assign({}, config, { allowedOrigins: normalized });
+  saveConfig(nextConfig);
+  config.allowedOrigins = normalized;
+}
+
+module.exports = {
+  normalizeAllowedOrigins: normalizeAllowedOrigins,
+  describeConfiguredOrigins: describeConfiguredOrigins,
+  isAllowedOrigin: isAllowedOrigin,
+  saveAllowedOrigins: saveAllowedOrigins,
+};

package/lib/public/app.js

@@ -267,6 +267,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
 
   // --- Initialize store (single source of truth for client state) ---
   createStore({
+    networkSettings: { loaded: false, busy: false, confirming: false, draft: "", saved: "", status: "", errorKind: "", requestId: 0 },
     // session / routing
     basePath: basePath,
     wsPath: wsPath,

package/lib/public/css/server-network-settings.css

@@ -0,0 +1,41 @@
+.settings-network-origins {
+  box-sizing: border-box;
+  width: 100%;
+  min-height: 128px;
+  margin-top: 12px;
+  padding: 12px;
+  resize: vertical;
+  border: 1px solid var(--border-subtle);
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  color: var(--text);
+  font-family: var(--font-mono, monospace);
+  font-size: 13px;
+  line-height: 1.7;
+}
+
+.settings-network-origins:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+
+.settings-network-origins:disabled { opacity: 0.6; }
+
+.settings-network-actions {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 12px;
+  margin-top: 12px;
+}
+
+.settings-network-error { color: var(--error, #ef6464); }
+
+.settings-network-actions .settings-btn-sm:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
+}
+
+/* The shared confirm modal normally sits below the Settings overlay. */
+#confirm-modal.confirm-above-settings { z-index: 700; }

package/lib/public/index.html

@@ -1250,6 +1250,7 @@
             <option value="overview" selected>Status</option>
             <option value="notifications">Notifications</option>
             <option value="security">Security</option>
+            <option value="network">Network</option>
           </optgroup>
           <optgroup label="Config">
             <option value="claudemd">Instructions</option>
@@ -1273,6 +1274,7 @@
           <button class="settings-nav-item active" data-section="overview"><span>Status</span></button>
           <button class="settings-nav-item" data-section="notifications"><span>Notifications</span></button>
           <button class="settings-nav-item" data-section="security"><span>Security</span></button>
+          <button class="settings-nav-item" data-section="network"><span>Network</span></button>
           <div class="settings-nav-separator"></div>
           <div class="settings-nav-category">Config</div>
           <button class="settings-nav-item" data-section="claudemd"><span>Instructions</span></button>
@@ -1401,6 +1403,23 @@
             </div>
           </div>
         </div>
+        <div class="server-settings-section" data-section="network">
+          <h2>Network</h2>
+          <h3>Reverse proxy &amp; tunnels</h3>
+          <p class="settings-hint">Connect to Clay through an external address, even when your proxy changes the upstream host.</p>
+          <form id="settings-network-form" class="settings-card">
+            <div class="settings-field">
+              <label class="settings-label" for="settings-network-origins">Allowed external origins</label>
+              <p class="settings-hint" id="settings-network-help">Enter one address per line, including http:// or https:// and a port if needed. Do not include paths or wildcards. Leave empty if you connect directly.</p>
+              <textarea id="settings-network-origins" class="settings-network-origins" rows="5" placeholder="https://clay.example.com" spellcheck="false" autocapitalize="off" autocomplete="off" aria-describedby="settings-network-help settings-network-status" disabled></textarea>
+              <div class="settings-network-actions">
+                <span id="settings-network-status" class="settings-hint" role="status" aria-live="polite"></span>
+                <button type="submit" id="settings-network-save" class="settings-btn-sm" disabled>Save changes</button>
+              </div>
+            </div>
+          </form>
+          <p class="settings-hint">Applies to the entire server. Saved changes take effect on new connections without restarting; existing connections stay open until they reconnect. Login requirements stay unchanged.</p>
+        </div>
         <div class="server-settings-section" data-section="notifications">
           <h2>Notifications</h2>
           <div class="settings-card">

package/lib/public/modules/app-misc.js

@@ -9,6 +9,7 @@ import { initPasteModal } from './paste-modal.js';
 
 // --- Module-owned state ---
 var confirmCallback = null;
+var confirmCancelCallback = null;
 var _extRequestCallbacks = {};
 
 // Queue for extension messages that arrived before WS was ready
@@ -51,6 +52,7 @@ export function initMisc() {
   var confirmCancel = document.getElementById("confirm-cancel");
 
   confirmOk.addEventListener("click", function () {
+    confirmCancelCallback = null;
     if (confirmCallback) confirmCallback();
     hideConfirm();
   });
@@ -259,12 +261,17 @@ export function closeImageModal() {
   if (modal) modal.classList.add("hidden");
 }
 
-export function showConfirm(text, onConfirm, okLabel, destructive) {
+// onCancel (optional) runs when the dialog is dismissed or replaced without confirming.
+export function showConfirm(text, onConfirm, okLabel, destructive, onCancel) {
   var confirmText = document.getElementById("confirm-text");
   var confirmOk = document.getElementById("confirm-ok");
   var confirmModal = document.getElementById("confirm-modal");
+  var replaced = confirmCancelCallback;
+  confirmCancelCallback = null;
+  if (replaced) replaced();
   confirmText.textContent = text;
   confirmCallback = onConfirm;
+  confirmCancelCallback = onCancel || null;
   confirmOk.textContent = okLabel || "Delete";
   confirmOk.className = "confirm-btn " + (destructive === false ? "confirm-ok" : "confirm-delete");
   confirmModal.classList.remove("hidden");
@@ -274,6 +281,9 @@ export function hideConfirm() {
   var confirmModal = document.getElementById("confirm-modal");
   confirmModal.classList.add("hidden");
   confirmCallback = null;
+  var cancelled = confirmCancelCallback;
+  confirmCancelCallback = null;
+  if (cancelled) cancelled();
 }
 
 export function showForceChangePinOverlay() {

package/lib/public/modules/network-origin-guard.js

@@ -0,0 +1,56 @@
+// Pure helpers for the Network settings editor. Mirrors lib/network-origins.js
+// closely enough to compare spellings; the server remains the authority.
+
+export function normalizeOriginForCompare(value) {
+  if (typeof value !== 'string' || value.indexOf('*') !== -1 ||
+      !/^https?:\/\/[^\s/?#\\]+\/?$/i.test(value)) return null;
+  try {
+    var url = new URL(value);
+    if (url.username || url.password) return null;
+    return url.origin;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Returns trimmed non-empty entries plus the 1-based textarea line of each.
+export function parseOriginDraft(draft) {
+  var origins = [];
+  var lines = [];
+  var rows = String(draft || '').split('\n');
+  for (var i = 0; i < rows.length; i++) {
+    var value = rows[i].trim();
+    if (!value) continue;
+    origins.push(value);
+    lines.push(i + 1);
+  }
+  return { origins: origins, lines: lines };
+}
+
+function normalizedSet(values) {
+  var set = {};
+  for (var i = 0; i < values.length; i++) {
+    var origin = normalizeOriginForCompare(values[i]);
+    if (origin) set[origin] = true;
+  }
+  return set;
+}
+
+// Returns the page's normalized origin when the saved list allowed it and the
+// next list does not; otherwise null. Equivalent spellings count as kept.
+export function removesCurrentOrigin(savedText, nextOrigins, currentOrigin) {
+  var current = normalizeOriginForCompare(currentOrigin);
+  if (!current) return null;
+  if (!normalizedSet(parseOriginDraft(savedText).origins)[current]) return null;
+  if (normalizedSet(nextOrigins)[current]) return null;
+  return current;
+}
+
+// Turns stored-entry problems into a status message using textarea line numbers.
+export function describeInvalidEntries(invalid) {
+  if (!Array.isArray(invalid) || !invalid.length) return '';
+  var first = invalid[0];
+  var message = 'Line ' + (first.index + 1) + ' ' + first.reason;
+  if (invalid.length > 1) message += ' ' + (invalid.length - 1) + ' more line(s) also need correction.';
+  return message + ' Invalid lines are ignored until corrected.';
+}

package/lib/public/modules/server-network-settings.js

@@ -0,0 +1,133 @@
+import { store } from './store.js';
+import { showConfirm, hideConfirm } from './app-misc.js';
+import { parseOriginDraft, removesCurrentOrigin, describeInvalidEntries } from './network-origin-guard.js';
+
+// errorKind: 'validation' marks the textarea invalid; 'request' covers
+// network, authorization, and disk failures that are not the input's fault.
+function updateNetworkState(values) {
+  store.set({ networkSettings: Object.assign({}, store.get('networkSettings'), values) });
+  renderNetworkSettings();
+}
+
+function renderNetworkSettings() {
+  var state = store.get('networkSettings');
+  var input = document.getElementById('settings-network-origins');
+  var button = document.getElementById('settings-network-save');
+  var status = document.getElementById('settings-network-status');
+  if (!input || !state) return;
+  var locked = state.busy || state.confirming || !state.loaded;
+  if (input.value !== state.draft) input.value = state.draft;
+  input.disabled = locked;
+  button.disabled = locked || state.draft === state.saved;
+  button.textContent = state.busy && state.loaded ? 'Saving...' : 'Save changes';
+  status.textContent = state.status;
+  status.classList.toggle('settings-network-error', !!state.errorKind);
+  input.setAttribute('aria-invalid', state.errorKind === 'validation' ? 'true' : 'false');
+}
+
+async function requestNetworkSettings(options) {
+  var response = await fetch('/api/server/network', Object.assign({ credentials: 'same-origin' }, options));
+  var data;
+  try { data = await response.json(); } catch (e) { data = {}; }
+  if (!response.ok) {
+    var error = new Error(data.error || 'Could not reach network settings (HTTP ' + response.status + ').');
+    if (typeof data.index === 'number') error.index = data.index;
+    error.reason = data.reason;
+    throw error;
+  }
+  return data;
+}
+
+function loadedState(data, extra) {
+  var value = (data.allowedOrigins || []).join('\n');
+  var invalidMessage = describeInvalidEntries(data.invalid);
+  return Object.assign({ loaded: true, busy: false, draft: value, saved: value,
+    status: invalidMessage, errorKind: invalidMessage ? 'validation' : '' }, extra || {});
+}
+
+export async function loadNetworkSettings() {
+  var current = store.get('networkSettings');
+  if (current.busy || current.confirming || (current.loaded && current.draft !== current.saved)) return;
+  var requestId = current.requestId + 1;
+  updateNetworkState({ busy: true, loaded: false, status: 'Loading...', errorKind: '', requestId: requestId });
+  try {
+    var data = await requestNetworkSettings();
+    if (store.get('networkSettings').requestId !== requestId) return;
+    updateNetworkState(loadedState(data));
+  } catch (e) {
+    if (store.get('networkSettings').requestId !== requestId) return;
+    updateNetworkState({ loaded: false, busy: false, draft: '', saved: '', status: e.message, errorKind: 'request' });
+  }
+}
+
+async function submitOrigins(parsed) {
+  updateNetworkState({ busy: true, status: 'Saving...', errorKind: '' });
+  try {
+    var data = await requestNetworkSettings({
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json', 'X-Clay-Network-Settings': '1' },
+      body: JSON.stringify({ allowedOrigins: parsed.origins }),
+    });
+    updateNetworkState(loadedState(data, { status: 'Saved. Applies to new connections; existing connections stay open.' }));
+  } catch (e) {
+    if (typeof e.index === 'number' && e.reason) {
+      var line = parsed.lines[e.index] || e.index + 1;
+      updateNetworkState({ busy: false, status: 'Line ' + line + ' ' + e.reason, errorKind: 'validation' });
+    } else {
+      updateNetworkState({ busy: false, status: e.message, errorKind: 'request' });
+    }
+  }
+}
+
+function confirmCurrentOriginRemoval(origin, parsed) {
+  var modal = document.getElementById('confirm-modal');
+  function settle() { if (modal) modal.classList.remove('confirm-above-settings'); }
+  updateNetworkState({ confirming: true });
+  if (modal) modal.classList.add('confirm-above-settings');
+  showConfirm('This removes ' + origin + ', the address you are using now. Your current connection stays open, ' +
+    'but the next reconnect or page reload from this address may be refused, and you may need local access to Clay to add it back.',
+  function () {
+    settle();
+    updateNetworkState({ confirming: false });
+    submitOrigins(parsed);
+  }, 'Remove and save', true, function () {
+    settle();
+    updateNetworkState({ confirming: false, status: 'Not saved. Your edits are still here.', errorKind: '' });
+    var input = document.getElementById('settings-network-origins');
+    if (input) input.focus();
+  });
+  // Default keyboard focus to the safe choice.
+  var cancel = document.getElementById('confirm-cancel');
+  if (cancel) cancel.focus();
+}
+
+// Escape cancels a pending removal instead of closing Settings underneath it.
+function handleConfirmEscape(event) {
+  if (event.key !== 'Escape' || !store.get('networkSettings').confirming) return;
+  event.preventDefault();
+  event.stopImmediatePropagation();
+  hideConfirm();
+}
+
+export function saveNetworkSettings(event) {
+  if (event) event.preventDefault();
+  var state = store.get('networkSettings');
+  if (!state.loaded || state.busy || state.confirming) return;
+  var parsed = parseOriginDraft(state.draft);
+  var removed = removesCurrentOrigin(state.saved, parsed.origins, window.location.origin);
+  if (removed) {
+    confirmCurrentOriginRemoval(removed, parsed);
+    return;
+  }
+  return submitOrigins(parsed);
+}
+
+export function initNetworkSettings() {
+  var form = document.getElementById('settings-network-form');
+  if (!form) return;
+  form.addEventListener('submit', saveNetworkSettings);
+  window.addEventListener('keydown', handleConfirmEscape, true);
+  document.getElementById('settings-network-origins').addEventListener('input', function () {
+    updateNetworkState({ draft: this.value, status: '', errorKind: '' });
+  });
+}

package/lib/public/modules/server-settings.js

@@ -4,6 +4,7 @@ import { showToast, copyToClipboard } from './utils.js';
 import { parseEnvString, looksLikeEnv, serializeEnvValue } from './project-settings.js';
 import { checkAdminAccess, loadAdminSection } from './admin.js';
 import { closeFileViewer } from './filebrowser.js';
+import { initNetworkSettings, loadNetworkSettings } from './server-network-settings.js';
 
 var ctx = null;
 var settingsEl = null;
@@ -24,6 +25,8 @@ export function initServerSettings(appCtx) {
   navItems = settingsEl.querySelectorAll(".settings-nav-item");
   sections = settingsEl.querySelectorAll(".server-settings-section");
 
+  initNetworkSettings();
+
   // Open settings
   settingsBtn.addEventListener("click", function () {
     openSettings();
@@ -240,6 +243,8 @@ function switchSection(sectionName) {
     sections[j].classList.toggle("active", isActive2);
   }
 
+  if (sectionName === "network") loadNetworkSettings();
+
   // Lazy-load section data
   if (sectionName === "claudemd") loadGlobalClaudeMd();
   if (sectionName === "environment") loadSharedEnv();
@@ -255,6 +260,7 @@ function openSettings() {
   settingsBtn.classList.add("active");
   refreshIcons(settingsEl);
   populateSettings();
+  if (settingsEl.querySelector('.server-settings-section.active[data-section="network"]')) loadNetworkSettings();
   requestDaemonConfig();
   resetRestartButton();
   resetShutdownForm();

package/lib/public/style.css

@@ -21,6 +21,7 @@
 @import url("css/diff.css");
 @import url("css/highlight.css");
 @import url("css/server-settings.css");
+@import url("css/server-network-settings.css");
 @import url("css/sticky-notes.css");
 @import url("css/skills.css");
 @import url("css/mobile-nav.css?v=20260407");

package/lib/sdk-bridge.js

@@ -539,9 +539,10 @@ function createSDKBridge(opts) {
       return { behavior: "allow", updatedInput: input };
     }
 
-    // Session search is read-only; its handler enforces project and session access.
-    if (toolName === "search_other_driver_sessions"
-        || toolName === "mcp__clay-handoff__search_other_driver_sessions") {
+    // Session discovery and reads enforce project and session access in their handlers.
+    if (["list_other_driver_sessions", "search_other_driver_sessions", "read_other_driver_session"].some(function (name) {
+      return toolName === name || toolName === "mcp__clay-handoff__" + name;
+    })) {
       return { behavior: "allow", updatedInput: input };
     }
 

package/lib/server-network-settings.js

@@ -0,0 +1,99 @@
+var { normalizeAllowedOrigins, describeConfiguredOrigins } = require("./network-origins");
+
+var MAX_BODY_BYTES = 220000;
+
+function attachNetworkSettings(ctx) {
+  function reply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(data));
+  }
+
+  function authorized(req, res) {
+    if (!ctx.isRequestAuthed(req)) {
+      reply(res, 401, { error: "Authentication required." });
+      return false;
+    }
+    if (ctx.users.isMultiUser()) {
+      var user = ctx.getMultiUserFromReq(req);
+      if (!user || user.role !== "admin") {
+        reply(res, 403, { error: "Only server administrators can manage network settings." });
+        return false;
+      }
+    }
+    return true;
+  }
+
+  function handleRequest(req, res, fullUrl) {
+    if (fullUrl !== "/api/server/network") return false;
+    if (!authorized(req, res)) return true;
+    if (req.method === "GET") {
+      reply(res, 200, describeConfiguredOrigins(ctx.getConfiguredOrigins()));
+      return true;
+    }
+    if (req.method !== "PUT") {
+      reply(res, 405, { error: "Method not allowed." });
+      return true;
+    }
+    // A custom header forces cross-origin browsers to preflight. OPTIONS never
+    // reaches this handler: the global preflight handler in server.js answers
+    // first and allows only GET and Content-Type, so a cross-origin PUT with
+    // this header is refused by the browser. Keep both checks below, and keep
+    // that handler from allowing PUT or custom headers (see the preflight test).
+    if (req.headers["x-clay-network-settings"] !== "1" ||
+        (req.headers["content-type"] || "").split(";")[0].trim().toLowerCase() !== "application/json" ||
+        (req.headers["sec-fetch-site"] && ["same-origin", "none"].indexOf(req.headers["sec-fetch-site"]) === -1)) {
+      reply(res, 403, { error: "Save network settings from the Clay settings page." });
+      return true;
+    }
+    var body = "";
+    var size = 0;
+    var oversized = false;
+    // Decode as a stream so multibyte characters split across chunks stay intact.
+    req.setEncoding("utf8");
+    req.on("data", function (chunk) {
+      size += Buffer.byteLength(chunk);
+      if (size > MAX_BODY_BYTES) {
+        if (!oversized) reply(res, 413, { error: "Network settings are too large." });
+        oversized = true;
+        return;
+      }
+      body += chunk;
+    });
+    req.on("end", function () {
+      if (oversized) return;
+      if (!authorized(req, res)) return;
+      var data;
+      try { data = JSON.parse(body); } catch (e) {
+        reply(res, 400, { error: "The request was not valid JSON." });
+        return;
+      }
+      var origins;
+      try {
+        origins = normalizeAllowedOrigins(data && data.allowedOrigins);
+      } catch (e) {
+        var result = { error: e.message };
+        if (typeof e.index === "number") {
+          result.index = e.index;
+          result.reason = e.entryReason;
+        }
+        reply(res, 400, result);
+        return;
+      }
+      try {
+        if (typeof ctx.opts.onSetAllowedOrigins !== "function") {
+          reply(res, 503, { error: "Network settings cannot be saved in this server runtime." });
+          return;
+        }
+        ctx.opts.onSetAllowedOrigins(origins);
+        reply(res, 200, { allowedOrigins: origins, invalid: [] });
+      } catch (e) {
+        reply(res, 500, { error: "Could not save network settings. Your previous settings are unchanged." });
+      }
+    });
+    return true;
+  }
+
+  return { handleRequest: handleRequest };
+}
+
+module.exports = { attachNetworkSettings: attachNetworkSettings };

package/lib/server-speech.js

@@ -3,6 +3,7 @@ var catalog = require('./speech-catalog');
 var attachSpeechStore = require('./speech-store').attachSpeechStore;
 var transcribe = require('./speech-transcribe').transcribe;
 var openSpeechStream = require('./speech-stream').openSpeechStream;
+var isAllowedOrigin = require('./network-origins').isAllowedOrigin;
 var MAX_AUDIO = 10 * 1024 * 1024;
 
 function attachSpeech(ctx) {
@@ -18,8 +19,7 @@ function attachSpeech(ctx) {
   }
   function sameOrigin(req) {
     if (req.headers['sec-fetch-site'] === 'cross-site') return false;
-    if (!req.headers.origin) return true;
-    try { return new URL(req.headers.origin).host === req.headers.host; } catch (error) { return false; }
+    return isAllowedOrigin(req.headers.origin, req.headers.host, ctx.getAllowedOrigins ? ctx.getAllowedOrigins() : []);
   }
   function json(res, status, body) {
     if (res.destroyed || res.writableEnded) return;

package/lib/server.js

@@ -23,6 +23,9 @@ var serverCursorSharing = require("./server-cursor-sharing");
 var serverTools = require("./server-tools");
 var serverAdmin = require("./server-admin");
 var serverSettings = require("./server-settings");
+var { attachNetworkSettings } = require("./server-network-settings");
+var { isAllowedOrigin } = require("./network-origins");
+var { createOriginRejectionLogger } = require("./network-origin-diagnostics");
 var serverSpeech = require("./server-speech");
 var serverPalette = require("./server-palette");
 var workspaceQueryModule = require("./workspace-query-service");
@@ -441,7 +444,22 @@ function createServer(opts) {
   });
 
   var speech = serverSpeech.attachSpeech({ users: users, getMultiUserFromReq: getMultiUserFromReq,
-    isRequestAuthed: isRequestAuthed, CONFIG_DIR: CONFIG_DIR });
+    isRequestAuthed: isRequestAuthed, CONFIG_DIR: CONFIG_DIR, getAllowedOrigins: getAllowedOrigins });
+
+  function getConfiguredOrigins() {
+    return opts.onGetAllowedOrigins ? opts.onGetAllowedOrigins() : opts.allowedOrigins;
+  }
+
+  function getAllowedOrigins() {
+    var origins = getConfiguredOrigins();
+    return Array.isArray(origins) ? origins : [];
+  }
+
+  var networkSettings = attachNetworkSettings({
+    users: users, getMultiUserFromReq: getMultiUserFromReq,
+    isRequestAuthed: isRequestAuthed, opts: opts, getConfiguredOrigins: getConfiguredOrigins,
+  });
+  var logRejectedOrigin = createOriginRejectionLogger({ log: opts.onOriginRejectedLog });
 
   var settings = serverSettings.attachSettings({
     users: users,
@@ -644,6 +662,7 @@ function createServer(opts) {
     }
 
     // CORS preflight for cross-origin requests (HTTP onboarding → HTTPS)
+    // Network settings PUT relies on this never allowing PUT or custom headers.
     if (req.method === "OPTIONS") {
       res.writeHead(204, {
         "Access-Control-Allow-Origin": "*",
@@ -780,6 +799,7 @@ function createServer(opts) {
     }
 
     if (speech.handleRequest(req, res, fullUrl)) return;
+    if (networkSettings.handleRequest(req, res, fullUrl)) return;
     if (settings.handleRequest(req, res, fullUrl)) return;
 
     // --- Admin API endpoints (multi-user mode only) ---
@@ -1114,33 +1134,11 @@ function createServer(opts) {
     if (speech.handleUpgrade(req, socket, head)) return;
     var wsRequest = parseWsRequestUrl(req.url);
     var wsPathname = wsRequest.path;
-    // Origin validation (CSRF prevention)
-    var origin = req.headers.origin;
-    if (origin) {
-      try {
-        var originUrl = new URL(origin);
-        var originPort = String(originUrl.port || (originUrl.protocol === "https:" ? "443" : "80"));
-        // Extract port from Host header for reverse proxy support.
-        // Use URL parser to correctly handle IPv6 addresses (e.g. [::1])
-        // and infer default port from origin protocol (not backend tlsOptions)
-        // so TLS-terminating proxies on :443 with HTTP backends work.
-        var hostPort;
-        try {
-          var hostUrl = new URL(originUrl.protocol + "//" + (req.headers.host || ""));
-          hostPort = String(hostUrl.port || (originUrl.protocol === "https:" ? "443" : "80"));
-        } catch (e2) {
-          hostPort = String(portNum);
-        }
-        if (originPort !== String(portNum) && originPort !== hostPort) {
-          socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
-          socket.destroy();
-          return;
-        }
-      } catch (e) {
-        socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
-        socket.destroy();
-        return;
-      }
+    if (!isAllowedOrigin(req.headers.origin, req.headers.host, getAllowedOrigins())) {
+      logRejectedOrigin(req.headers.origin, req.headers.host);
+      socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+      socket.destroy();
+      return;
     }
 
     if (!isRequestAuthed(req)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.7.0",
+  "version": "4.7.1-beta.2",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"