@roamcode.ai/server 1.1.0 → 1.2.0

package/dist/start.js

@@ -595,9 +595,27 @@ var RateLimiter = class {
 };
 
 // src/data-dir.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import {
+  closeSync,
+  constants as constants2,
+  existsSync,
+  fchmodSync,
+  fstatSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
 import { randomBytes } from "crypto";
-import { join as join2 } from "path";
+import { dirname, join as join2 } from "path";
+var ACCESS_TOKEN_FILE = "token";
+var MAX_ACCESS_TOKEN_BYTES = 4 * 1024;
+var MAX_ACCESS_TOKEN_FILE_BYTES = MAX_ACCESS_TOKEN_BYTES + 2;
 function resolveDataDir(env, exists = existsSync) {
   if (env.ROAMCODE_DATA_DIR) return env.ROAMCODE_DATA_DIR;
   if (env.REMOTE_CODER_DATA_DIR) return env.REMOTE_CODER_DATA_DIR;
@@ -613,29 +631,186 @@ function ensureDataDir(dir) {
 function generateAccessToken() {
   return randomBytes(32).toString("base64url");
 }
+function fsyncDirectory(path) {
+  let descriptor;
+  try {
+    descriptor = openSync(path, constants2.O_RDONLY);
+    fsyncSync(descriptor);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EINVAL" && code !== "ENOTSUP" && !(process.platform === "win32" && code === "EPERM")) {
+      throw error;
+    }
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+  }
+}
+function existingTokenStat(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function validateAccessToken(token) {
+  if (!token || Buffer.byteLength(token, "utf8") > MAX_ACCESS_TOKEN_BYTES || /[\u0000-\u0020\u007f]/u.test(token)) {
+    throw new Error("access token must be non-empty printable text without whitespace");
+  }
+  return token;
+}
+function decodePersistedAccessToken(content) {
+  let token = content;
+  if (token.endsWith("\n")) token = token.slice(0, -1);
+  if (token.endsWith("\r")) token = token.slice(0, -1);
+  return validateAccessToken(token);
+}
+function readPersistedAccessToken(path) {
+  const before = existingTokenStat(path);
+  if (!before) return void 0;
+  if (!before.isFile() || before.isSymbolicLink()) throw new Error("access token path must be a regular file");
+  if (before.size > MAX_ACCESS_TOKEN_FILE_BYTES) throw new Error("access token file is too large");
+  if (typeof process.getuid === "function" && before.uid !== process.getuid()) {
+    throw new Error("access token file must be owned by the current user");
+  }
+  let descriptor;
+  try {
+    descriptor = openSync(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+    const opened = fstatSync(descriptor);
+    if (!opened.isFile() || opened.size > MAX_ACCESS_TOKEN_FILE_BYTES || opened.dev !== before.dev || opened.ino !== before.ino || typeof process.getuid === "function" && opened.uid !== process.getuid()) {
+      throw new Error("access token changed while it was being opened");
+    }
+    fchmodSync(descriptor, 384);
+    return decodePersistedAccessToken(readFileSync(descriptor, "utf8"));
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("access token ")) throw error;
+    throw new Error("access token file could not be read safely");
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+  }
+}
+function stageAccessToken(path, token) {
+  const temporary = `${path}.${randomBytes(12).toString("hex")}.tmp`;
+  let descriptor;
+  let failed = false;
+  let failure;
+  try {
+    descriptor = openSync(
+      temporary,
+      constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY | (constants2.O_NOFOLLOW ?? 0),
+      384
+    );
+    fchmodSync(descriptor, 384);
+    writeFileSync(descriptor, `${validateAccessToken(token)}
+`, "utf8");
+    fsyncSync(descriptor);
+  } catch (error) {
+    failed = true;
+    failure = error;
+  }
+  if (descriptor !== void 0) {
+    try {
+      closeSync(descriptor);
+    } catch (error) {
+      if (!failed) {
+        failed = true;
+        failure = error;
+      }
+    }
+    descriptor = void 0;
+  }
+  if (failed) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw failure;
+  }
+  return temporary;
+}
 function persistAccessToken(dataDir, token) {
   ensureDataDir(dataDir);
-  const tokenPath = join2(dataDir, "token");
-  writeFileSync(tokenPath, token + "\n", { mode: 384 });
-  chmodSync(tokenPath, 384);
+  const tokenPath = join2(dataDir, ACCESS_TOKEN_FILE);
+  const existing = existingTokenStat(tokenPath);
+  if (existing) {
+    if (!existing.isFile() || existing.isSymbolicLink()) throw new Error("access token path must be a regular file");
+    if (typeof process.getuid === "function" && existing.uid !== process.getuid()) {
+      throw new Error("access token file must be owned by the current user");
+    }
+  }
+  const temporary = stageAccessToken(tokenPath, token);
+  try {
+    renameSync(temporary, tokenPath);
+    try {
+      fsyncDirectory(dirname(tokenPath));
+    } catch (error) {
+      let visible;
+      try {
+        visible = readPersistedAccessToken(tokenPath);
+      } catch {
+      }
+      if (visible !== token) throw error;
+    }
+  } finally {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+  }
 }
-function resolveAccessToken(opts) {
-  if (opts.configured) return { token: opts.configured, generated: false };
-  const tokenPath = join2(opts.dataDir, "token");
+function installAccessTokenIfMissing(dataDir, token) {
+  ensureDataDir(dataDir);
+  const tokenPath = join2(dataDir, ACCESS_TOKEN_FILE);
+  const temporary = stageAccessToken(tokenPath, token);
+  let installed = false;
   try {
-    const existing = readFileSync(tokenPath, "utf8").trim();
-    if (existing) return { token: existing, generated: false };
-  } catch {
+    try {
+      linkSync(temporary, tokenPath);
+      installed = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  } finally {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
   }
-  const token = (opts.generate ?? generateAccessToken)();
-  persistAccessToken(opts.dataDir, token);
-  return { token, generated: true };
+  if (installed) fsyncDirectory(dirname(tokenPath));
+  return installed;
+}
+function resolveAccessToken(opts) {
+  if (opts.configured) return { token: opts.configured, generated: false };
+  const tokenPath = join2(opts.dataDir, ACCESS_TOKEN_FILE);
+  const existing = readPersistedAccessToken(tokenPath);
+  if (existing) return { token: existing, generated: false };
+  const token = validateAccessToken((opts.generate ?? generateAccessToken)());
+  if (installAccessTokenIfMissing(opts.dataDir, token)) return { token, generated: true };
+  const winner = readPersistedAccessToken(tokenPath);
+  if (!winner) throw new Error("access token initialization raced with removal; retry startup");
+  return { token: winner, generated: false };
 }
 
 // src/static-routes.ts
 import fastifyStatic from "@fastify/static";
 import { existsSync as existsSync2 } from "fs";
 import { resolve as resolve2, sep as sep2 } from "path";
+var PWA_BOOT_WATCHDOG_SHA256 = "sha256-tcgQYptaPeNGqJtts8Ft/5H4tf+s+jfSWQSguIhTp8k=";
+var PWA_CONTENT_SECURITY_POLICY = [
+  "default-src 'self'",
+  `script-src 'self' '${PWA_BOOT_WATCHDOG_SHA256}'`,
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob:",
+  "font-src 'self' data:",
+  "connect-src 'self' https: wss: http://localhost:* http://127.0.0.1:* ws://localhost:* ws://127.0.0.1:*",
+  "worker-src 'self' blob:",
+  "manifest-src 'self'",
+  "frame-src 'self' https: blob:",
+  "object-src 'none'",
+  "base-uri 'none'",
+  "form-action 'none'",
+  "frame-ancestors 'none'"
+].join("; ");
 var API_PATH_DENYLIST = [
   /^\/sessions/,
   /^\/resumable/,
@@ -690,6 +865,9 @@ function registerStatic(app, opts) {
   app.register(fastifyStatic, { root: opts.webDir, wildcard: false });
   app.addHook("onSend", (request, reply, payload, done) => {
     const contentType = String(reply.getHeader("content-type") ?? "");
+    if (isPublicForRequest(request.url)) {
+      reply.header("content-security-policy", PWA_CONTENT_SECURITY_POLICY).header("permissions-policy", "camera=(), microphone=(), geolocation=(), payment=(), usb=()").header("referrer-policy", "no-referrer").header("x-content-type-options", "nosniff").header("x-frame-options", "DENY").header("x-permitted-cross-domain-policies", "none");
+    }
     if (pathForGate(request.url) === "/sw.js" || contentType.includes("text/html")) {
       reply.header("cache-control", "no-store, no-cache, must-revalidate");
     }
@@ -1239,6 +1417,7 @@ function establishRelayChannel(options) {
 var require2 = createRequire(import.meta.url);
 var PAIRING_TTL_MS = 5 * 60 * 1e3;
 var LAST_SEEN_WRITE_INTERVAL_MS = 60 * 1e3;
+var UNSAFE_DISPLAY_TEXT = /[\p{Cc}\p{Zl}\p{Zp}\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/u;
 var DevicePairingError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -1294,7 +1473,7 @@ function randomCredential(prefix) {
 function normalizeDeviceName(value) {
   if (typeof value !== "string") return void 0;
   const normalized = value.trim().replace(/\s+/g, " ");
-  if (!normalized || normalized.length > 80 || /[\p{Cc}\p{Zl}\p{Zp}]/u.test(normalized)) return void 0;
+  if (!normalized || normalized.length > 80 || UNSAFE_DISPLAY_TEXT.test(normalized)) return void 0;
   return normalized;
 }
 function inMemoryStore(opts) {
@@ -1325,6 +1504,7 @@ function inMemoryStore(opts) {
       }
       throw new Error("could not allocate a unique pairing credential");
     },
+    cancelPairing: (secret) => pairings.delete(digest(secret)),
     claimPairing(secret, rawName, now = Date.now(), relayIdentityPublicKey) {
       const name = normalizeDeviceName(rawName);
       if (!name) return void 0;
@@ -1374,13 +1554,46 @@ function inMemoryStore(opts) {
       prune(now);
       return [...pairings.values()].some((pairing) => pairing.deviceId === deviceId && pairing.expiresAt >= now);
     },
+    beginRelayPairingCancellation(deviceId, now = Date.now()) {
+      prune(now);
+      const pairing = [...pairings.values()].find((candidate) => candidate.deviceId === deviceId);
+      if (!pairing || pairing.expiresAt < now) return { status: "missing" };
+      if (pairing.cancellationId) return { status: "busy" };
+      const reservation = { deviceId, reservationId: randomUUID2() };
+      pairing.cancellationId = reservation.reservationId;
+      return { status: "reserved", reservation };
+    },
+    releaseRelayPairingCancellation(reservation) {
+      const pairing = [...pairings.values()].find((candidate) => candidate.deviceId === reservation.deviceId);
+      if (pairing?.cancellationId !== reservation.reservationId) return false;
+      delete pairing.cancellationId;
+      return true;
+    },
+    finishRelayPairingCancellation(reservation) {
+      for (const [secretHash, pairing] of pairings) {
+        if (pairing.deviceId === reservation.deviceId && pairing.cancellationId === reservation.reservationId) {
+          pairings.delete(secretHash);
+          return true;
+        }
+      }
+      return false;
+    },
+    cancelRelayPairing(deviceId) {
+      for (const [secretHash, pairing] of pairings) {
+        if (pairing.deviceId === deviceId) {
+          pairings.delete(secretHash);
+          return true;
+        }
+      }
+      return false;
+    },
     claimRelayPairing(secret, token, rawName, relayIdentityPublicKey, now = Date.now()) {
       const name = normalizeDeviceName(rawName);
       if (!name || !/^rcd_[A-Za-z0-9_-]{43}$/.test(token)) return void 0;
       prune(now);
       const secretHash = digest(secret);
       const pairing = pairings.get(secretHash);
-      if (!pairing?.deviceId || !pairing.tokenHash || pairing.expiresAt < now || pairing.tokenHash !== digest(token))
+      if (!pairing?.deviceId || !pairing.tokenHash || pairing.cancellationId || pairing.expiresAt < now || pairing.tokenHash !== digest(token))
         return void 0;
       const relayIdentity = relayIdentityForClaim(pairing.scopes, relayIdentityPublicKey);
       pairings.delete(secretHash);
@@ -1464,7 +1677,8 @@ function openDeviceStore(opts) {
       expires_at INTEGER NOT NULL,
       scopes_json TEXT NOT NULL DEFAULT '["direct"]',
       device_id TEXT,
-      token_hash TEXT
+      token_hash TEXT,
+      cancellation_id TEXT
     );
     CREATE INDEX IF NOT EXISTS devices_last_seen_idx ON devices(last_seen_at DESC);
     CREATE INDEX IF NOT EXISTS pairing_expiry_idx ON pairing_sessions(expires_at);
@@ -1489,6 +1703,9 @@ function openDeviceStore(opts) {
   if (!pairingColumns.some((column) => column.name === "token_hash")) {
     db.exec("ALTER TABLE pairing_sessions ADD COLUMN token_hash TEXT");
   }
+  if (!pairingColumns.some((column) => column.name === "cancellation_id")) {
+    db.exec("ALTER TABLE pairing_sessions ADD COLUMN cancellation_id TEXT");
+  }
   db.exec(`
     CREATE UNIQUE INDEX IF NOT EXISTS pairing_device_id_idx ON pairing_sessions(device_id) WHERE device_id IS NOT NULL;
     CREATE UNIQUE INDEX IF NOT EXISTS pairing_token_hash_idx ON pairing_sessions(token_hash) WHERE token_hash IS NOT NULL;
@@ -1503,12 +1720,26 @@ function openDeviceStore(opts) {
     "INSERT INTO pairing_sessions (secret_hash, created_at, expires_at, scopes_json, device_id, token_hash) VALUES (?, ?, ?, ?, ?, ?)"
   );
   const prunePairings = db.prepare("DELETE FROM pairing_sessions WHERE expires_at < ?");
+  const cancelPairing = db.prepare("DELETE FROM pairing_sessions WHERE secret_hash = ?");
   const findPairing = db.prepare(
-    "SELECT secret_hash, expires_at, scopes_json, device_id, token_hash FROM pairing_sessions WHERE secret_hash = ?"
+    "SELECT secret_hash, expires_at, scopes_json, device_id, token_hash, cancellation_id FROM pairing_sessions WHERE secret_hash = ?"
   );
   const findPendingRelayPairing = db.prepare(
     "SELECT 1 FROM pairing_sessions WHERE device_id = ? AND expires_at >= ? LIMIT 1"
   );
+  const cancelRelayPairing = db.prepare("DELETE FROM pairing_sessions WHERE device_id = ?");
+  const findRelayPairingByDevice = db.prepare(
+    "SELECT secret_hash, expires_at, scopes_json, device_id, token_hash, cancellation_id FROM pairing_sessions WHERE device_id = ?"
+  );
+  const reserveRelayPairingCancellation = db.prepare(
+    "UPDATE pairing_sessions SET cancellation_id = ? WHERE device_id = ? AND cancellation_id IS NULL"
+  );
+  const releaseRelayPairingCancellation = db.prepare(
+    "UPDATE pairing_sessions SET cancellation_id = NULL WHERE device_id = ? AND cancellation_id = ?"
+  );
+  const finishRelayPairingCancellation = db.prepare(
+    "DELETE FROM pairing_sessions WHERE device_id = ? AND cancellation_id = ?"
+  );
   const deletePairing = db.prepare("DELETE FROM pairing_sessions WHERE secret_hash = ?");
   const insertDevice = db.prepare(
     "INSERT INTO devices (id, name, token_hash, created_at, last_seen_at, scopes_json, relay_public_key, relay_fingerprint) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
@@ -1555,7 +1786,7 @@ function openDeviceStore(opts) {
     (secretHash, token, name, now, relayIdentityPublicKey) => {
       prunePairings.run(now);
       const pairing = findPairing.get(secretHash);
-      if (!pairing?.device_id || !pairing.token_hash || pairing.expires_at < now || pairing.token_hash !== digest(token))
+      if (!pairing?.device_id || !pairing.token_hash || pairing.cancellation_id || pairing.expires_at < now || pairing.token_hash !== digest(token))
         return void 0;
       const scopes = scopesFromJson(pairing.scopes_json);
       const relayIdentity = relayIdentityForClaim(scopes, relayIdentityPublicKey);
@@ -1602,6 +1833,7 @@ function openDeviceStore(opts) {
       }
       throw new Error("could not allocate a unique pairing credential");
     },
+    cancelPairing: (secret) => cancelPairing.run(digest(secret)).changes > 0,
     claimPairing(secret, rawName, now = Date.now(), relayIdentityPublicKey) {
       const name = normalizeDeviceName(rawName);
       if (!name) return void 0;
@@ -1635,6 +1867,20 @@ function openDeviceStore(opts) {
       prunePairings.run(now);
       return findPendingRelayPairing.get(deviceId, now) !== void 0;
     },
+    beginRelayPairingCancellation(deviceId, now = Date.now()) {
+      prunePairings.run(now);
+      const pairing = findRelayPairingByDevice.get(deviceId);
+      if (!pairing || pairing.expires_at < now) return { status: "missing" };
+      if (pairing.cancellation_id) return { status: "busy" };
+      const reservation = { deviceId, reservationId: randomUUID2() };
+      if (reserveRelayPairingCancellation.run(reservation.reservationId, deviceId).changes !== 1) {
+        return findRelayPairingByDevice.get(deviceId) ? { status: "busy" } : { status: "missing" };
+      }
+      return { status: "reserved", reservation };
+    },
+    releaseRelayPairingCancellation: (reservation) => releaseRelayPairingCancellation.run(reservation.deviceId, reservation.reservationId).changes === 1,
+    finishRelayPairingCancellation: (reservation) => finishRelayPairingCancellation.run(reservation.deviceId, reservation.reservationId).changes === 1,
+    cancelRelayPairing: (deviceId) => cancelRelayPairing.run(deviceId).changes > 0,
     claimRelayPairing(secret, token, rawName, relayIdentityPublicKey, now = Date.now()) {
       const name = normalizeDeviceName(rawName);
       if (!name || !/^rcd_[A-Za-z0-9_-]{43}$/.test(token)) return void 0;
@@ -1683,7 +1929,7 @@ function generateRelayCredential(prefix = "rrd") {
 
 // src/relay-pairing.ts
 function isLoopback(hostname) {
-  return hostname === "localhost" || hostname === "::1" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
+  return hostname === "localhost" || hostname === "::1" || hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
 }
 function normalizeRelayAppUrl(value) {
   const url = new URL(value.trim());
@@ -2931,35 +3177,35 @@ import {
   renameSync as nodeRenameSync,
   writeFileSync as nodeWriteFileSync
 } from "fs";
-import { dirname as dirname3, join as join6 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 import { fileURLToPath } from "url";
 
 // src/managed-runtime.ts
 import { spawn } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import {
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync2,
   existsSync as existsSync4,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync3,
-  openSync,
-  closeSync,
+  openSync as openSync2,
+  closeSync as closeSync2,
   readdirSync,
   readFileSync as readFileSync3,
   realpathSync,
-  renameSync,
+  renameSync as renameSync2,
   rmSync,
   symlinkSync,
-  unlinkSync,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir2, tmpdir } from "os";
-import { basename as basename3, dirname as dirname2, join as join5, relative, resolve as resolve5 } from "path";
+import { basename as basename3, dirname as dirname3, join as join5, relative, resolve as resolve5 } from "path";
 
 // src/service-install.ts
-import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir, platform } from "os";
-import { dirname, join as join4 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 import { spawnSync } from "child_process";
 
 // src/managed-runtime.ts
@@ -3034,7 +3280,7 @@ function readPreviousVersion(root) {
 }
 
 // src/updater.ts
-var RUNNING_VERSION = "1.1.0" ? "1.1.0".replace(/^v/, "") : packageVersion();
+var RUNNING_VERSION = "1.2.0" ? "1.2.0".replace(/^v/, "") : packageVersion();
 var RELEASES_API = "https://api.github.com/repos/burakgon/roamcode/releases?per_page=100";
 var RELEASE_MANIFEST_ASSET = "roamcode-release.json";
 var CHECK_CACHE_MS = 15 * 6e4;
@@ -3149,7 +3395,7 @@ function manifestIntegrities(value, version) {
   return integrities;
 }
 function moduleDir() {
-  return dirname3(fileURLToPath(import.meta.url));
+  return dirname4(fileURLToPath(import.meta.url));
 }
 var Updater = class {
   fs;
@@ -3535,7 +3781,7 @@ function createClaudeVersionProbe(deps) {
 }
 
 // src/terminal-manager.ts
-import { unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
+import { unlinkSync as unlinkSync3, readdirSync as readdirSync2 } from "fs";
 import { join as join9 } from "path";
 
 // src/terminal-process.ts
@@ -3544,17 +3790,21 @@ import { EventEmitter } from "events";
 import { createRequire as createRequire6 } from "module";
 
 // src/node-pty-runtime.ts
-import { chmodSync as chmodSync4, existsSync as existsSync5 } from "fs";
+import { accessSync, chmodSync as chmodSync3, constants as constants3, existsSync as existsSync5 } from "fs";
 import { createRequire as createRequire5 } from "module";
-import { dirname as dirname4, join as join7, resolve as resolve6 } from "path";
+import { dirname as dirname5, join as join7, resolve as resolve6 } from "path";
 var require6 = createRequire5(import.meta.url);
 function ensureNodePtySpawnHelperExecutable(resolveNodePty = () => require6.resolve("node-pty"), platform2 = process.platform, arch = process.arch) {
-  if (platform2 !== "darwin") return;
+  if (platform2 !== "darwin") return true;
   try {
-    const packageRoot = resolve6(dirname4(resolveNodePty()), "..");
+    const packageRoot = resolve6(dirname5(resolveNodePty()), "..");
     const helper = join7(packageRoot, "prebuilds", `${platform2}-${arch}`, "spawn-helper");
-    if (existsSync5(helper)) chmodSync4(helper, 493);
+    if (!existsSync5(helper)) return true;
+    chmodSync3(helper, 493);
+    accessSync(helper, constants3.X_OK);
+    return true;
   } catch {
+    return false;
   }
 }
 
@@ -3731,7 +3981,7 @@ var TerminalProcess = class extends EventEmitter {
   }
 };
 var defaultPtySpawn = (file, args, opts) => {
-  ensureNodePtySpawnHelperExecutable();
+  if (!ensureNodePtySpawnHelperExecutable()) throw new Error("node-pty spawn helper is not executable");
   const pty = require7("node-pty");
   return pty.spawn(file, args, opts);
 };
@@ -5779,7 +6029,7 @@ var TerminalManager = class {
       const sessionId = m?.[1] ?? (name.startsWith(CODEX_MCP_TOKEN_PREFIX) ? name.slice(CODEX_MCP_TOKEN_PREFIX.length) : void 0);
       if (!sessionId || liveIds.has(sessionId)) continue;
       try {
-        unlinkSync2(join9(dir, name));
+        unlinkSync3(join9(dir, name));
         removed += 1;
       } catch {
       }
@@ -6440,7 +6690,9 @@ function tmuxOnPath() {
 }
 function ptyLoads() {
   try {
-    require9.resolve("node-pty");
+    const entry = require9.resolve("node-pty");
+    if (!ensureNodePtySpawnHelperExecutable(() => entry)) return false;
+    require9("node-pty");
     return true;
   } catch {
     return false;
@@ -6472,11 +6724,11 @@ function listTmuxSessions(run = defaultRun) {
 }
 
 // src/providers/provider-artifacts.ts
-import { chmodSync as chmodSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
+import { chmodSync as chmodSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "fs";
 function cleanupProviderArtifacts(paths) {
   for (const path of paths) {
     try {
-      unlinkSync3(path);
+      unlinkSync4(path);
     } catch {
     }
   }
@@ -6491,7 +6743,7 @@ function writeProviderArtifact0600(path, content, context, ownedPaths) {
   ownedPaths.push(path);
   try {
     writeFileSync4(path, content, { mode: 384 });
-    chmodSync5(path, 384);
+    chmodSync4(path, 384);
     return true;
   } catch {
     cleanupProviderArtifacts([path]);
@@ -7515,6 +7767,30 @@ function buildOpenApiDocument(options) {
           }
         }
       },
+      "/api/v1/relay/pairing/cancel": {
+        post: {
+          operationId: "cancelRelayPairing",
+          description: "Revokes an unused broker bootstrap before deleting its local one-use pairing state. A raced completed enrollment is never silently revoked.",
+          parameters: [idempotency],
+          requestBody: {
+            required: true,
+            content: json({
+              type: "object",
+              required: ["deviceId"],
+              additionalProperties: false,
+              properties: { deviceId: { type: "string", minLength: 1, maxLength: 128 } }
+            })
+          },
+          responses: { "204": response("Cancelled remote pairing"), ...errorResponses }
+        }
+      },
+      "/api/v1/relay/status": {
+        get: {
+          operationId: "getRelayStatus",
+          description: "Returns privacy-bounded host connector health without routing identifiers or capabilities.",
+          responses: { "200": response("Relay connector health", ref("RelayStatus")), ...errorResponses }
+        }
+      },
       "/api/v1/team": {
         get: {
           operationId: "getTeam",
@@ -8070,6 +8346,18 @@ function buildOpenApiDocument(options) {
             hostIdentityFingerprint: { type: "string", pattern: "^sha256:[A-Za-z0-9_-]{43}$" }
           }
         },
+        RelayStatus: {
+          type: "object",
+          required: ["configured", "pairingAvailable", "status", "activeDevices", "reconnects"],
+          additionalProperties: false,
+          properties: {
+            configured: { type: "boolean" },
+            pairingAvailable: { type: "boolean" },
+            status: { enum: ["not-configured", "idle", "connecting", "online", "reconnecting", "stopped"] },
+            activeDevices: { type: "integer", minimum: 0 },
+            reconnects: { type: "integer", minimum: 0 }
+          }
+        },
         WorkspaceCreate: {
           type: "object",
           required: ["cwd"],
@@ -8772,7 +9060,7 @@ function buildOpenApiDocument(options) {
 // src/worktree-service.ts
 import { spawn as spawn4 } from "child_process";
 import { realpath as realpath2, stat as stat2 } from "fs/promises";
-import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve7 } from "path";
+import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve7 } from "path";
 var MAX_GIT_OUTPUT_BYTES = 256 * 1024;
 var GIT_TIMEOUT_MS = 6e4;
 var WorktreeError = class extends Error {
@@ -8813,7 +9101,7 @@ function createWorktreeService(options) {
   };
   const confinedTarget = async (value) => {
     const lexical = resolve7(value);
-    const parent = await realpath2(dirname5(lexical)).catch(() => void 0);
+    const parent = await realpath2(dirname6(lexical)).catch(() => void 0);
     if (!parent || !inside(await root(), parent)) {
       throw new WorktreeError("WORKTREE_OUTSIDE_ROOT", "worktree parent is outside FS_ROOT", 403);
     }
@@ -8888,7 +9176,7 @@ function createWorktreeService(options) {
     const gitRaw = (await runGit(candidate, ["rev-parse", "--git-dir"])).stdout.trim();
     const commonDir = await realpath2(resolve7(candidate, commonRaw));
     const gitDir = await realpath2(resolve7(candidate, gitRaw));
-    const repositoryPath = dirname5(commonDir);
+    const repositoryPath = dirname6(commonDir);
     if (!inside(await root(), repositoryPath)) {
       throw new WorktreeError("WORKTREE_OUTSIDE_ROOT", "repository metadata is outside FS_ROOT", 403);
     }
@@ -9184,7 +9472,7 @@ function createInstalledAdapterProvider(options) {
 import { createHash as createHash5, createPublicKey as createPublicKey2, verify as verifySignature } from "crypto";
 import { createRequire as createRequire9 } from "module";
 import { access, mkdir as mkdir2, open as open2, opendir, readFile as readFile2, realpath as realpath4, rename as rename2, rm, stat as stat4 } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute5, join as join10, relative as relative4, resolve as resolve9 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute5, join as join10, relative as relative4, resolve as resolve9 } from "path";
 import { z as z5 } from "zod";
 var require10 = createRequire9(import.meta.url);
 var MAX_PACKAGE_FILES = 512;
@@ -9456,7 +9744,7 @@ async function materialize(snapshot, target) {
   try {
     for (const file of snapshot.files) {
       const output = join10(temporary, ...file.path.split("/"));
-      await mkdir2(dirname6(output), { recursive: true, mode: 448 });
+      await mkdir2(dirname7(output), { recursive: true, mode: 448 });
       const handle = await open2(output, "wx", file.mode);
       try {
         await handle.writeFile(file.bytes);
@@ -9464,7 +9752,7 @@ async function materialize(snapshot, target) {
         await handle.close();
       }
     }
-    await mkdir2(dirname6(target), { recursive: true, mode: 448 });
+    await mkdir2(dirname7(target), { recursive: true, mode: 448 });
     await rename2(temporary, target).catch(async (error) => {
       if (error.code !== "EEXIST" && error.code !== "ENOTEMPTY")
         throw error;
@@ -10926,7 +11214,7 @@ function openPolicyStore(options) {
 
 // src/peer-store.ts
 import { randomBytes as randomBytes9 } from "crypto";
-import { chmodSync as chmodSync6 } from "fs";
+import { chmodSync as chmodSync5 } from "fs";
 import { createRequire as createRequire12 } from "module";
 var require13 = createRequire12(import.meta.url);
 var PeerRevisionConflictError = class extends Error {
@@ -10953,7 +11241,7 @@ function safeLabel(value) {
   return label;
 }
 function isLoopback2(hostname) {
-  return hostname === "localhost" || hostname === "::1" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
+  return hostname === "localhost" || hostname === "::1" || hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
 }
 function normalizePeerBaseUrl(value) {
   if (typeof value !== "string") throw new Error("peer URL is required");
@@ -11151,7 +11439,7 @@ function openPeerStore(options) {
     return createMemoryStore5(options);
   }
   const db = new Database(options.dbPath);
-  if (options.dbPath !== ":memory:") chmodSync6(options.dbPath, 384);
+  if (options.dbPath !== ":memory:") chmodSync5(options.dbPath, 384);
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
   db.exec(`
@@ -12382,6 +12670,10 @@ function createServer(config, deps = {}) {
     if (device) return { actorType: "device", actorId: device.id, label: device.name };
     return hostPrincipal();
   };
+  const currentDeviceIdForRequest = (request) => {
+    const principal = authenticatedPrincipals.get(request);
+    return principal?.actorType === "device" || principal?.actorType === "relay" ? principal.actorId : void 0;
+  };
   const teamResourceForSession = (sessionId) => ({
     hostId: commandStore.getHost().id,
     ...commandStore.placementForSession(sessionId)?.workspaceId ? { workspaceId: commandStore.placementForSession(sessionId).workspaceId } : {}
@@ -13313,6 +13605,25 @@ function createServer(config, deps = {}) {
       reply.code(500).send({ error: "could not start device pairing" });
     }
   });
+  app.post("/pairing/cancel", { bodyLimit: 8 * 1024 }, async (request, reply) => {
+    const secret = request.body?.secret;
+    if (typeof secret !== "string" || !/^rcp_[A-Za-z0-9_-]{43}$/.test(secret)) {
+      reply.code(400).send({ code: "INVALID_PAIRING", error: "valid pairing capability is required" });
+      return;
+    }
+    let cancelled = false;
+    try {
+      cancelled = deviceStore.cancelPairing(secret);
+    } catch {
+      reply.code(500).send({ code: "PAIRING_CANCEL_FAILED", error: "could not cancel pairing" });
+      return;
+    }
+    if (!cancelled) {
+      reply.code(404).send({ code: "PAIRING_NOT_FOUND", error: "pairing is expired, cancelled, or already used" });
+      return;
+    }
+    reply.header("cache-control", "no-store").code(204).send();
+  });
   app.post("/api/v1/relay/pairing", async (_request, reply) => {
     const relay = deps.relayPairing;
     if (!relay) {
@@ -13322,9 +13633,14 @@ function createServer(config, deps = {}) {
       });
       return;
     }
+    let pendingDeviceId;
     try {
       const pairing = deviceStore.issueRelayPairing();
+      pendingDeviceId = pairing.deviceId;
       const deviceCredential = (relay.generateDeviceCredential ?? (() => generateRelayCredential("rrd")))();
+      if (!/^rrd_[A-Za-z0-9_-]{43}$/.test(deviceCredential)) {
+        throw new Error("invalid generated relay device credential");
+      }
       await relay.provisioner.putDevice(pairing.deviceId, relayCredentialHash(deviceCredential), pairing.expiresAt);
       const payload = {
         v: 1,
@@ -13341,9 +13657,65 @@ function createServer(config, deps = {}) {
       };
       reply.header("cache-control", "no-store").code(201).send({ pairing: payload, url: buildRelayPairingUrl(relay.appUrl, payload) });
     } catch {
+      if (pendingDeviceId) {
+        try {
+          deviceStore.cancelRelayPairing(pendingDeviceId);
+        } catch {
+        }
+        await relay.provisioner.revokeDevice(pendingDeviceId).catch(() => {
+        });
+      }
       reply.code(502).send({ code: "RELAY_PAIRING_FAILED", error: "could not prepare relay pairing" });
     }
   });
+  app.post(
+    "/api/v1/relay/pairing/cancel",
+    { bodyLimit: 8 * 1024 },
+    async (request, reply) => {
+      const relay = deps.relayPairing;
+      if (!relay) {
+        reply.code(409).send({ code: "RELAY_PAIRING_UNAVAILABLE", error: "relay pairing is not configured" });
+        return;
+      }
+      const deviceId = request.body?.deviceId;
+      if (typeof deviceId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(deviceId)) {
+        reply.code(400).send({ code: "INVALID_RELAY_DEVICE", error: "valid relay device id is required" });
+        return;
+      }
+      try {
+        const cancellation = deviceStore.beginRelayPairingCancellation(deviceId);
+        if (cancellation.status === "busy") {
+          reply.code(409).send({ code: "RELAY_PAIRING_CANCEL_IN_PROGRESS", error: "relay pairing cancellation is in progress" });
+          return;
+        }
+        if (cancellation.status === "missing") {
+          reply.code(404).send({ code: "RELAY_PAIRING_NOT_FOUND", error: "relay pairing is expired or already used" });
+          return;
+        }
+        try {
+          await relay.provisioner.revokeDevice(deviceId);
+        } catch {
+          deviceStore.releaseRelayPairingCancellation(cancellation.reservation);
+          throw new Error("broker revocation failed");
+        }
+        deviceStore.finishRelayPairingCancellation(cancellation.reservation);
+        reply.header("cache-control", "no-store").code(204).send();
+      } catch {
+        reply.code(502).send({ code: "RELAY_PAIRING_CANCEL_FAILED", error: "could not cancel relay pairing" });
+      }
+    }
+  );
+  app.get("/api/v1/relay/status", async (_request, reply) => {
+    const configured = deps.relayEnabled === true;
+    const metrics = configured ? deps.relayStatus?.() : void 0;
+    return reply.header("cache-control", "no-store").send({
+      configured,
+      pairingAvailable: configured && deps.relayPairing !== void 0,
+      status: configured ? metrics?.status ?? "connecting" : "not-configured",
+      activeDevices: metrics?.activeChannels ?? 0,
+      reconnects: metrics?.reconnects ?? 0
+    });
+  });
   app.post(
     "/pairing/claim",
     { bodyLimit: 8 * 1024 },
@@ -13378,8 +13750,7 @@ function createServer(config, deps = {}) {
     }
   );
   app.get("/devices", async (request, reply) => {
-    const presented = extractBearerToken(request.headers.authorization);
-    const currentDeviceId = presented ? deviceStore.authenticate(presented)?.id : void 0;
+    const currentDeviceId = currentDeviceIdForRequest(request);
     reply.header("cache-control", "no-store").send({
       devices: deviceStore.list(),
       ...currentDeviceId ? { currentDeviceId } : {}
@@ -14751,8 +15122,7 @@ data: ${JSON.stringify(data)}
     }
   });
   app.get("/api/v1/devices", async (request, reply) => {
-    const presented = extractBearerToken(request.headers.authorization);
-    const currentDeviceId = presented ? deviceStore.authenticate(presented)?.id : void 0;
+    const currentDeviceId = currentDeviceIdForRequest(request);
     reply.header("cache-control", "no-store").send({
       devices: deviceStore.list(),
       ...currentDeviceId ? { currentDeviceId } : {}
@@ -16914,7 +17284,7 @@ function assertConfigAllowsStart(cfg) {
 }
 
 // src/vapid.ts
-import { chmodSync as chmodSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { chmodSync as chmodSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
 import { join as join12 } from "path";
 import webpush from "web-push";
 function defaultGenerate() {
@@ -16933,7 +17303,7 @@ function resolveVapidKeys(opts) {
   const keys = (opts.generate ?? defaultGenerate)();
   ensureDataDir(opts.dataDir);
   writeFileSync5(path, JSON.stringify(keys), { mode: 384 });
-  chmodSync7(path, 384);
+  chmodSync6(path, 384);
   return keys;
 }
 
@@ -17193,7 +17563,7 @@ function createUsageRunner(opts) {
     let child;
     try {
       const ptySpawn = opts.ptySpawn ?? ((file, args, options) => {
-        ensureNodePtySpawnHelperExecutable();
+        if (!ensureNodePtySpawnHelperExecutable()) throw new Error("node-pty spawn helper is not executable");
         const pty = require15("node-pty");
         return pty.spawn(file, args, options);
       });
@@ -19154,10 +19524,10 @@ var CodexLatestService = class {
 
 // src/providers/codex-executable.ts
 import { execFile } from "child_process";
-import { constants as constants2 } from "fs";
+import { constants as constants4 } from "fs";
 import { access as access2, chmod, copyFile, link, realpath as realpath7, rename as rename3, rm as rm2, rmdir as rmdir2, stat as stat7 } from "fs/promises";
 import { randomUUID as randomUUID10 } from "crypto";
-import { basename as basename5, delimiter, dirname as dirname7, isAbsolute as isAbsolute9, join as join14, sep as sep5 } from "path";
+import { basename as basename5, delimiter, dirname as dirname8, isAbsolute as isAbsolute9, join as join14, sep as sep5 } from "path";
 var CODEX_EXECUTABLE_PROBE_TIMEOUT_MS = 5e3;
 var OPENAI_CODE_SIGNING_TEAM_ID = "2DC432GLL2";
 var MAX_CODEX_BYTES = 1024 * 1024 * 1024;
@@ -19209,7 +19579,7 @@ async function defaultResolveExecutable(command, env) {
   const candidates = isAbsolute9(command) || command.includes(sep5) ? [command] : (env.PATH ?? process.env.PATH ?? "").split(delimiter).filter(Boolean).map((entry) => join14(entry, command));
   for (const candidate of candidates) {
     try {
-      await access2(candidate, constants2.X_OK);
+      await access2(candidate, constants4.X_OK);
       return await realpath7(candidate);
     } catch {
     }
@@ -19267,7 +19637,7 @@ async function removeLegacyManagedCopy(dataDir) {
 async function repairHomebrewExecutable(source, sourceStat, env, deps) {
   if (!await deps.verifyOfficialSignature(source)) return false;
   const nonce = randomUUID10();
-  const directory = dirname7(source);
+  const directory = dirname8(source);
   const name = basename5(source);
   const temporary = join14(directory, `.${name}.roamcode-repair-${nonce}`);
   const backup = join14(directory, `.${name}.roamcode-backup-${nonce}`);
@@ -19276,7 +19646,7 @@ async function repairHomebrewExecutable(source, sourceStat, env, deps) {
   let committed = false;
   let preserveBackup = false;
   try {
-    await copyFile(source, temporary, constants2.COPYFILE_EXCL);
+    await copyFile(source, temporary, constants4.COPYFILE_EXCL);
     await chmod(temporary, sourceStat.mode & 511);
     if (!await deps.clearExtendedAttributes(temporary)) return false;
     if (!await deps.verifyOfficialSignature(temporary)) return false;
@@ -19402,7 +19772,7 @@ function safeId6(value, field) {
   return value;
 }
 function isLoopback3(hostname) {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+  return hostname === "localhost" || hostname === "[::1]" || hostname === "::1" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
 }
 function relayConnectUrl(raw) {
   let url;
@@ -20164,50 +20534,66 @@ function createRelayHostConnector(options) {
 
 // src/relay-host-config.ts
 import {
-  chmodSync as chmodSync9,
-  closeSync as closeSync3,
-  constants as constants4,
-  fsyncSync as fsyncSync2,
-  lstatSync as lstatSync3,
-  openSync as openSync3,
+  closeSync as closeSync4,
+  constants as constants6,
+  fchmodSync as fchmodSync3,
+  fstatSync as fstatSync3,
+  fsyncSync as fsyncSync3,
+  lstatSync as lstatSync4,
+  openSync as openSync4,
   readFileSync as readFileSync6,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync5,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync7
 } from "fs";
 import { randomBytes as randomBytes12 } from "crypto";
-import { join as join16 } from "path";
+import { dirname as dirname10, join as join16 } from "path";
 
 // src/relay-identity-store.ts
 import {
-  chmodSync as chmodSync8,
-  closeSync as closeSync2,
-  constants as constants3,
+  closeSync as closeSync3,
+  constants as constants5,
   existsSync as existsSync6,
-  fsyncSync,
-  linkSync,
-  lstatSync as lstatSync2,
-  openSync as openSync2,
+  fchmodSync as fchmodSync2,
+  fstatSync as fstatSync2,
+  fsyncSync as fsyncSync2,
+  linkSync as linkSync2,
+  lstatSync as lstatSync3,
+  openSync as openSync3,
   readFileSync as readFileSync5,
-  unlinkSync as unlinkSync4,
+  unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync6
 } from "fs";
 import { randomBytes as randomBytes11 } from "crypto";
-import { join as join15 } from "path";
+import { dirname as dirname9, join as join15 } from "path";
 var RELAY_IDENTITY_FILE = "relay-identity.json";
+var MAX_IDENTITY_BYTES = 32 * 1024;
 function readIdentity(path) {
-  let stat8;
+  let before;
   try {
-    stat8 = lstatSync2(path);
+    before = lstatSync3(path);
   } catch {
     throw new Error("relay identity could not be read");
   }
-  if (!stat8.isFile() || stat8.isSymbolicLink()) throw new Error("relay identity path must be a regular file");
+  if (!before.isFile() || before.isSymbolicLink()) throw new Error("relay identity path must be a regular file");
+  if (before.size > MAX_IDENTITY_BYTES) throw new Error("relay identity file is too large");
+  if (typeof process.getuid === "function" && before.uid !== process.getuid()) {
+    throw new Error("relay identity must be owned by the current user");
+  }
+  let descriptor;
   let document;
   try {
-    document = JSON.parse(readFileSync5(path, "utf8"));
+    descriptor = openSync3(path, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0));
+    const opened = fstatSync2(descriptor);
+    if (!opened.isFile() || opened.size > MAX_IDENTITY_BYTES || opened.dev !== before.dev || opened.ino !== before.ino || typeof process.getuid === "function" && opened.uid !== process.getuid()) {
+      throw new Error("relay identity changed while it was being opened");
+    }
+    fchmodSync2(descriptor, 384);
+    document = JSON.parse(readFileSync5(descriptor, "utf8"));
   } catch {
     throw new Error("relay identity file is corrupt; restore it from backup instead of replacing it");
+  } finally {
+    if (descriptor !== void 0) closeSync3(descriptor);
   }
   if (document.version !== 1 || !Number.isSafeInteger(document.createdAt) || document.createdAt < 0) {
     throw new Error("relay identity file has an unsupported format");
@@ -20218,34 +20604,54 @@ function readIdentity(path) {
   } catch {
     throw new Error("relay identity file contains an invalid or mismatched keypair");
   }
-  chmodSync8(path, 384);
   return { identity: identity2, createdAt: document.createdAt, path, generated: false };
 }
+function fsyncDirectory2(path) {
+  let descriptor;
+  try {
+    descriptor = openSync3(path, constants5.O_RDONLY);
+    fsyncSync2(descriptor);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EINVAL" && code !== "ENOTSUP" && !(process.platform === "win32" && code === "EPERM")) {
+      throw error;
+    }
+  } finally {
+    if (descriptor !== void 0) closeSync3(descriptor);
+  }
+}
 function writeDurably(path, document) {
   const temporary = `${path}.${randomBytes11(12).toString("hex")}.tmp`;
   let descriptor;
+  let installed = false;
   try {
-    descriptor = openSync2(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
+    descriptor = openSync3(
+      temporary,
+      constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY | (constants5.O_NOFOLLOW ?? 0),
+      384
+    );
+    fchmodSync2(descriptor, 384);
     writeFileSync6(descriptor, `${JSON.stringify(document)}
 `, "utf8");
-    fsyncSync(descriptor);
-    closeSync2(descriptor);
+    fsyncSync2(descriptor);
+    closeSync3(descriptor);
     descriptor = void 0;
-    chmodSync8(temporary, 384);
     try {
-      linkSync(temporary, path);
-      return true;
+      linkSync2(temporary, path);
+      installed = true;
     } catch (error) {
       if (error.code === "EEXIST") return false;
       throw error;
     }
   } finally {
-    if (descriptor !== void 0) closeSync2(descriptor);
+    if (descriptor !== void 0) closeSync3(descriptor);
     try {
-      unlinkSync4(temporary);
+      unlinkSync5(temporary);
     } catch {
     }
   }
+  if (installed) fsyncDirectory2(dirname9(path));
+  return installed;
 }
 function loadOrCreateRelayIdentity(options) {
   ensureDataDir(options.dataDir);
@@ -20262,10 +20668,11 @@ function loadOrCreateRelayIdentity(options) {
 // src/relay-host-config.ts
 var RELAY_HOST_CONFIG_FILE = "relay-host.json";
 var MAX_CONFIG_BYTES2 = 16 * 1024;
+var UNSAFE_DISPLAY_TEXT2 = /[\p{Cc}\p{Zl}\p{Zp}\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/u;
 function safeHostLabel(value) {
   if (typeof value !== "string") throw new Error("relay host label is required");
   const normalized = value.trim().replace(/\s+/g, " ");
-  if (!normalized || normalized.length > 80 || /[\p{Cc}\p{Zl}\p{Zp}]/u.test(normalized)) {
+  if (!normalized || normalized.length > 80 || UNSAFE_DISPLAY_TEXT2.test(normalized)) {
     throw new Error("relay host label must be 1-80 printable characters");
   }
   return normalized;
@@ -20292,7 +20699,7 @@ function relayHostConfigPath(dataDir) {
 }
 function existingConfigStat(path) {
   try {
-    return lstatSync3(path);
+    return lstatSync4(path);
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
@@ -20300,15 +20707,27 @@ function existingConfigStat(path) {
 }
 function readRelayHostConfig(dataDir) {
   const path = relayHostConfigPath(dataDir);
-  const stat8 = existingConfigStat(path);
-  if (!stat8) return void 0;
-  if (!stat8.isFile() || stat8.isSymbolicLink()) throw new Error("relay host config path must be a regular file");
-  if (stat8.size > MAX_CONFIG_BYTES2) throw new Error("relay host config is too large");
+  const before = existingConfigStat(path);
+  if (!before) return void 0;
+  if (!before.isFile() || before.isSymbolicLink()) throw new Error("relay host config path must be a regular file");
+  if (before.size > MAX_CONFIG_BYTES2) throw new Error("relay host config is too large");
+  if (typeof process.getuid === "function" && before.uid !== process.getuid()) {
+    throw new Error("relay host config must be owned by the current user");
+  }
+  let descriptor;
   let value;
   try {
-    value = JSON.parse(readFileSync6(path, "utf8"));
+    descriptor = openSync4(path, constants6.O_RDONLY | (constants6.O_NOFOLLOW ?? 0));
+    const opened = fstatSync3(descriptor);
+    if (!opened.isFile() || opened.size > MAX_CONFIG_BYTES2 || opened.dev !== before.dev || opened.ino !== before.ino || typeof process.getuid === "function" && opened.uid !== process.getuid()) {
+      throw new Error("relay host config changed while it was being opened");
+    }
+    fchmodSync3(descriptor, 384);
+    value = JSON.parse(readFileSync6(descriptor, "utf8"));
   } catch {
     throw new Error("relay host config is corrupt");
+  } finally {
+    if (descriptor !== void 0) closeSync4(descriptor);
   }
   if (value.version !== 1) throw new Error("relay host config has an unsupported version");
   const validated = validateCore({
@@ -20318,7 +20737,6 @@ function readRelayHostConfig(dataDir) {
     appUrl: value.appUrl,
     hostLabel: value.hostLabel
   });
-  chmodSync9(path, 384);
   return { version: 1, ...validated };
 }
 function resolveRelayHostConfig(env, dataDir) {
@@ -20516,6 +20934,7 @@ function createLoopbackRelayHttpOpener(options) {
 
 // src/relay-provision.ts
 var RESPONSE_LIMIT = 16 * 1024;
+var UNSAFE_TERMINAL_TEXT = /[\p{Cc}\p{Zl}\p{Zp}\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/u;
 function safeId7(value, field) {
   if (!/^[A-Za-z0-9._:-]{1,256}$/.test(value)) throw new Error(`invalid relay ${field}`);
   return value;
@@ -20530,13 +20949,44 @@ function relayHttpOrigin(raw) {
 }
 async function boundedError(response2) {
   const declared = Number(response2.headers.get("content-length"));
-  if (Number.isFinite(declared) && declared > RESPONSE_LIMIT) return `relay returned ${response2.status}`;
+  if (Number.isFinite(declared) && declared > RESPONSE_LIMIT) {
+    await discardBody(response2);
+    return `relay returned ${response2.status}`;
+  }
+  if (!response2.body) return `relay returned ${response2.status}`;
+  const chunks = [];
+  let total = 0;
+  const reader = response2.body.getReader();
   try {
-    const body = (await response2.text()).slice(0, RESPONSE_LIMIT);
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      if (!next.value) continue;
+      total += next.value.byteLength;
+      if (total > RESPONSE_LIMIT) {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        return `relay returned ${response2.status}`;
+      }
+      chunks.push(Buffer.from(next.value));
+    }
+    const body = Buffer.concat(chunks, total).toString("utf8");
     const parsed = JSON.parse(body);
-    return typeof parsed.error === "string" && parsed.error.length <= 200 ? parsed.error : `relay returned ${response2.status}`;
+    if (typeof parsed.error !== "string") return `relay returned ${response2.status}`;
+    const message = parsed.error.trim().replace(/\s+/g, " ");
+    return message && message.length <= 200 && !UNSAFE_TERMINAL_TEXT.test(message) && !/\brr[a-z]_[A-Za-z0-9_-]{20,}\b|\bsha256:[A-Za-z0-9_-]{43}\b|\bBearer\s+/i.test(message) ? message : `relay returned ${response2.status}`;
   } catch {
     return `relay returned ${response2.status}`;
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function discardBody(response2) {
+  try {
+    await response2.body?.cancel();
+  } catch {
   }
 }
 function createRelayDeviceProvisioner(options) {
@@ -20562,19 +21012,24 @@ function createRelayDeviceProvisioner(options) {
           "content-type": "application/json"
         },
         body: JSON.stringify({ credentialHash, ...expiresAt === void 0 ? {} : { expiresAt } }),
+        redirect: "error",
         ...requestSignal ? { signal: requestSignal } : {}
       });
       if (!response2.ok) throw new Error(`could not provision relay device: ${await boundedError(response2)}`);
+      await discardBody(response2);
     },
     async revokeDevice(deviceId) {
       const requestSignal = signal();
       const response2 = await request(endpoint(deviceId), {
         method: "DELETE",
         headers: { authorization: `Bearer ${options.hostCredential}` },
+        redirect: "error",
         ...requestSignal ? { signal: requestSignal } : {}
       });
-      if (!response2.ok && response2.status !== 404)
+      if (!response2.ok && response2.status !== 404) {
         throw new Error(`could not revoke relay device: ${await boundedError(response2)}`);
+      }
+      await discardBody(response2);
     }
   };
 }
@@ -20937,6 +21392,11 @@ async function startServer(env = process.env) {
     codexThreadResolver: (cwd) => new CodexThreadResolver({ inventory: createCodexThreadInventory(codexRpc, { cwd }) }),
     disposeProviders: () => codexClient.stop(),
     relayEnabled: relayConfig !== void 0,
+    relayStatus: () => relayHost?.metrics() ?? {
+      status: relayConfig ? "connecting" : "stopped",
+      activeChannels: 0,
+      reconnects: 0
+    },
     relayPairing: relayConfig?.appUrl && relayProvisioner ? {
       appUrl: relayConfig.appUrl,
       label: relayConfig.hostLabel,