remote-codex 0.11.2 → 0.11.3

package/apps/supervisor-api/dist/index.js

@@ -80,6 +80,7 @@ function truncateAutoThreadTitle(value) {
 // ../../packages/config/src/index.ts
 var envSchema = z.object({
   NODE_ENV: z.enum(["development", "test", "production"]).optional(),
+  REMOTE_CODEX_MODE: z.enum(["local", "server", "relay"]).optional(),
   HOST: z.string().min(1).optional(),
   PORT: z.coerce.number().int().positive().optional(),
   LOG_LEVEL: z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
@@ -88,6 +89,12 @@ var envSchema = z.object({
   APP_VERSION: z.string().min(1).optional(),
   WORKSPACE_ROOT: z.string().optional(),
   DATABASE_URL: z.string().optional(),
+  REMOTE_CODEX_ADMIN_USERNAME: z.string().min(1).optional(),
+  REMOTE_CODEX_ADMIN_PASSWORD: z.string().min(1).optional(),
+  REMOTE_CODEX_SESSION_SECRET: z.string().min(16).optional(),
+  REMOTE_CODEX_SESSION_TTL_SECONDS: z.coerce.number().int().positive().optional(),
+  REMOTE_CODEX_RELAY_SERVER_URL: z.string().url().optional(),
+  REMOTE_CODEX_RELAY_AGENT_TOKEN: z.string().min(1).optional(),
   CODEX_HOME: z.string().optional(),
   CODEX_COMMAND: z.string().min(1).optional(),
   CODEX_APP_SERVER_START_TIMEOUT_MS: z.coerce.number().int().positive().optional(),
@@ -97,6 +104,31 @@ var envSchema = z.object({
   OPENCODE_COMMAND: z.string().min(1).optional(),
   REMOTE_CODEX_ENABLED_AGENT_PROVIDERS: z.string().optional()
 });
+function optionalNonEmpty(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeOptionalEnv(env) {
+  return {
+    ...env,
+    WORKSPACE_ROOT: optionalNonEmpty(env.WORKSPACE_ROOT),
+    DATABASE_URL: optionalNonEmpty(env.DATABASE_URL),
+    REMOTE_CODEX_ADMIN_USERNAME: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_USERNAME),
+    REMOTE_CODEX_ADMIN_PASSWORD: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_PASSWORD),
+    REMOTE_CODEX_SESSION_SECRET: optionalNonEmpty(env.REMOTE_CODEX_SESSION_SECRET),
+    REMOTE_CODEX_RELAY_SERVER_URL: optionalNonEmpty(env.REMOTE_CODEX_RELAY_SERVER_URL),
+    REMOTE_CODEX_RELAY_AGENT_TOKEN: optionalNonEmpty(env.REMOTE_CODEX_RELAY_AGENT_TOKEN),
+    CODEX_HOME: optionalNonEmpty(env.CODEX_HOME),
+    CODEX_COMMAND: optionalNonEmpty(env.CODEX_COMMAND),
+    CLAUDE_HOME: optionalNonEmpty(env.CLAUDE_HOME),
+    CLAUDE_COMMAND: optionalNonEmpty(env.CLAUDE_COMMAND),
+    OPENCODE_HOME: optionalNonEmpty(env.OPENCODE_HOME),
+    OPENCODE_COMMAND: optionalNonEmpty(env.OPENCODE_COMMAND),
+    REMOTE_CODEX_ENABLED_AGENT_PROVIDERS: optionalNonEmpty(
+      env.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS
+    )
+  };
+}
 function resolveDatabaseUrl(nodeEnv, value) {
   if (value && value.trim()) {
     return path.resolve(value);
@@ -107,8 +139,9 @@ function resolveDatabaseUrl(nodeEnv, value) {
   return path.resolve(".local", "supervisor-dev.sqlite");
 }
 function loadRuntimeConfig(env = process.env) {
-  const parsed = envSchema.parse(env);
+  const parsed = envSchema.parse(normalizeOptionalEnv(env));
   const nodeEnv = parsed.NODE_ENV ?? "development";
+  const mode = parsed.REMOTE_CODEX_MODE ?? "local";
   const workspaceRoot = parsed.WORKSPACE_ROOT?.trim() ? path.resolve(parsed.WORKSPACE_ROOT) : os.homedir();
   const disableRequestLogging = parsed.DISABLE_REQUEST_LOGGING === void 0 ? nodeEnv === "production" : ["1", "true", "yes", "on"].includes(parsed.DISABLE_REQUEST_LOGGING.toLowerCase());
   const enabledProviders = new Set(
@@ -119,6 +152,7 @@ function loadRuntimeConfig(env = process.env) {
   const opencodeHome = parsed.OPENCODE_HOME?.trim() ? path.resolve(parsed.OPENCODE_HOME) : path.join(os.homedir(), agentBackendMetadata.opencode.defaultHomeDir);
   return {
     nodeEnv,
+    mode,
     host: parsed.HOST ?? "127.0.0.1",
     port: parsed.PORT ?? 8787,
     logLevel: parsed.LOG_LEVEL ?? (nodeEnv === "production" ? "warn" : "info"),
@@ -127,6 +161,16 @@ function loadRuntimeConfig(env = process.env) {
     appVersion: parsed.APP_VERSION ?? "0.1.0",
     workspaceRoot,
     databaseUrl: resolveDatabaseUrl(nodeEnv, parsed.DATABASE_URL),
+    auth: {
+      adminUsername: parsed.REMOTE_CODEX_ADMIN_USERNAME ?? null,
+      adminPassword: parsed.REMOTE_CODEX_ADMIN_PASSWORD ?? null,
+      sessionSecret: parsed.REMOTE_CODEX_SESSION_SECRET ?? null,
+      sessionTtlSeconds: parsed.REMOTE_CODEX_SESSION_TTL_SECONDS ?? 60 * 60 * 24 * 7
+    },
+    relay: {
+      serverUrl: parsed.REMOTE_CODEX_RELAY_SERVER_URL ?? null,
+      agentToken: parsed.REMOTE_CODEX_RELAY_AGENT_TOKEN ?? null
+    },
     agentProviders: {
       codex: {
         provider: "codex",
@@ -21207,6 +21251,7 @@ async function registerSystemRoutes(app2) {
     return {
       appName: app2.services.config.appName,
       appVersion: app2.services.config.appVersion,
+      mode: app2.services.config.mode,
       host: app2.services.config.host,
       port: app2.services.config.port,
       workspaceRoot: app2.services.config.workspaceRoot,
@@ -22450,6 +22495,46 @@ async function registerPluginRoutes(app2) {
   });
 }
 
+// src/routes/auth.ts
+import { z as z8 } from "zod";
+var loginSchema = z8.object({
+  username: z8.string().min(1),
+  password: z8.string().min(1)
+});
+async function registerAuthRoutes(app2) {
+  app2.get("/api/auth/session", async (request) => {
+    return app2.services.authService.verifyRequest(request);
+  });
+  app2.post("/api/auth/login", async (request, reply) => {
+    const body = loginSchema.parse(request.body ?? {});
+    const login = app2.services.authService.login(body);
+    if (!login) {
+      reply.status(401).send({
+        code: "unauthorized",
+        message: "Invalid username or password."
+      });
+      return;
+    }
+    if (login.token) {
+      app2.services.authService.attachSessionCookie(reply, login.token);
+    }
+    return {
+      token: login.token,
+      session: login.session
+    };
+  });
+  app2.post("/api/auth/logout", async (_request, reply) => {
+    app2.services.authService.clearSessionCookie(reply);
+    return {
+      authenticated: false,
+      username: null,
+      expiresAt: null,
+      mode: app2.services.authService.mode,
+      authRequired: app2.services.authService.required
+    };
+  });
+}
+
 // src/provider-host-config-service.ts
 import fs18 from "fs/promises";
 import path18 from "path";
@@ -24638,17 +24723,17 @@ var TmuxShellBackend = class {
 };
 
 // src/routes/shells.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 async function registerShellRoutes(app2, options = {}) {
-  const threadIdParams = z8.object({ id: z8.string().uuid() });
-  const shellIdParams = z8.object({ id: z8.string().uuid() });
-  const createShellSchema = z8.object({
-    cols: z8.number().int().positive().optional(),
-    rows: z8.number().int().positive().optional(),
-    label: z8.string().trim().min(1).max(80).optional()
+  const threadIdParams = z9.object({ id: z9.string().uuid() });
+  const shellIdParams = z9.object({ id: z9.string().uuid() });
+  const createShellSchema = z9.object({
+    cols: z9.number().int().positive().optional(),
+    rows: z9.number().int().positive().optional(),
+    label: z9.string().trim().min(1).max(80).optional()
   });
-  const updateShellSchema = z8.object({
-    label: z8.string().trim().min(1).max(80).nullable().optional()
+  const updateShellSchema = z9.object({
+    label: z9.string().trim().min(1).max(80).nullable().optional()
   });
   const routeOptions = options.preHandler ? { preHandler: options.preHandler } : {};
   app2.get("/api/threads/:id/shell", routeOptions, async (request) => {
@@ -24865,9 +24950,362 @@ function makeShellErrorEnvelope(shellId, error) {
   };
 }
 
+// src/auth.ts
+import crypto2 from "crypto";
+var AUTH_COOKIE_NAME = "remote_codex_session";
+var AuthService = class {
+  required;
+  mode;
+  username;
+  password;
+  secret;
+  sessionTtlSeconds;
+  constructor(config) {
+    this.mode = config.mode;
+    this.required = config.mode === "server" || config.mode === "relay";
+    this.username = config.auth.adminUsername;
+    this.password = config.auth.adminPassword;
+    this.secret = config.auth.sessionSecret;
+    this.sessionTtlSeconds = config.auth.sessionTtlSeconds;
+    if (this.required) {
+      const missing = [
+        this.username ? null : "REMOTE_CODEX_ADMIN_USERNAME",
+        this.password ? null : "REMOTE_CODEX_ADMIN_PASSWORD",
+        this.secret ? null : "REMOTE_CODEX_SESSION_SECRET"
+      ].filter(Boolean);
+      if (missing.length > 0) {
+        throw new Error(
+          `${config.mode} mode requires auth configuration: ${missing.join(", ")}.`
+        );
+      }
+    }
+  }
+  login(input) {
+    if (!this.required) {
+      return {
+        token: null,
+        session: {
+          authenticated: true,
+          username: null,
+          expiresAt: null,
+          mode: this.mode,
+          authRequired: false
+        }
+      };
+    }
+    if (!this.username || !this.password || !this.secret) {
+      return null;
+    }
+    if (!constantTimeEqual(input.username, this.username) || !constantTimeEqual(input.password, this.password)) {
+      return null;
+    }
+    return this.createSession(this.username);
+  }
+  verifyRequest(request) {
+    if (!this.required) {
+      return {
+        authenticated: true,
+        username: null,
+        expiresAt: null,
+        mode: this.mode,
+        authRequired: false
+      };
+    }
+    const token = readBearerToken(request) ?? readQueryToken(request) ?? readCookieToken(request);
+    if (!token || !this.secret) {
+      return unauthenticatedSession(this.mode);
+    }
+    return this.verifyToken(token);
+  }
+  attachSessionCookie(reply, token) {
+    reply.header(
+      "set-cookie",
+      `${AUTH_COOKIE_NAME}=${encodeURIComponent(token)}; HttpOnly; SameSite=Lax; Path=/; Max-Age=${this.sessionTtlSeconds}`
+    );
+  }
+  clearSessionCookie(reply) {
+    reply.header(
+      "set-cookie",
+      `${AUTH_COOKIE_NAME}=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0`
+    );
+  }
+  createSession(username) {
+    const expiresAtMs = Date.now() + this.sessionTtlSeconds * 1e3;
+    const payload = {
+      username,
+      expiresAt: expiresAtMs,
+      nonce: crypto2.randomBytes(16).toString("base64url")
+    };
+    const payloadText = Buffer.from(JSON.stringify(payload), "utf8").toString(
+      "base64url"
+    );
+    const signature = this.sign(payloadText);
+    return {
+      token: `${payloadText}.${signature}`,
+      session: {
+        authenticated: true,
+        username,
+        expiresAt: new Date(expiresAtMs).toISOString(),
+        mode: this.mode,
+        authRequired: this.required
+      }
+    };
+  }
+  verifyToken(token) {
+    const [payloadText, signature, extra] = token.split(".");
+    if (!payloadText || !signature || extra !== void 0) {
+      return unauthenticatedSession(this.mode);
+    }
+    if (!constantTimeEqual(signature, this.sign(payloadText))) {
+      return unauthenticatedSession(this.mode);
+    }
+    let payload;
+    try {
+      payload = JSON.parse(
+        Buffer.from(payloadText, "base64url").toString("utf8")
+      );
+    } catch {
+      return unauthenticatedSession(this.mode);
+    }
+    if (!isSessionPayload(payload)) {
+      return unauthenticatedSession(this.mode);
+    }
+    if (payload.expiresAt <= Date.now()) {
+      return unauthenticatedSession(this.mode);
+    }
+    return {
+      authenticated: true,
+      username: payload.username,
+      expiresAt: new Date(payload.expiresAt).toISOString(),
+      mode: this.mode,
+      authRequired: this.required
+    };
+  }
+  sign(payloadText) {
+    return crypto2.createHmac("sha256", this.secret ?? "").update(payloadText).digest("base64url");
+  }
+};
+function unauthorizedPayload() {
+  return {
+    code: "unauthorized",
+    message: "Authentication is required."
+  };
+}
+function readBearerToken(request) {
+  const authorization = request.headers.authorization;
+  if (!authorization) {
+    return null;
+  }
+  const match = /^Bearer\s+(.+)$/i.exec(authorization);
+  return match ? match[1].trim() : null;
+}
+function readCookieToken(request) {
+  const cookie = request.headers.cookie;
+  if (!cookie) {
+    return null;
+  }
+  const entries = cookie.split(";");
+  for (const entry of entries) {
+    const [name, ...valueParts] = entry.trim().split("=");
+    if (name === AUTH_COOKIE_NAME) {
+      return decodeURIComponent(valueParts.join("="));
+    }
+  }
+  return null;
+}
+function readQueryToken(request) {
+  const query = request.query;
+  if (!query || typeof query !== "object" || !("token" in query)) {
+    return null;
+  }
+  const token = query.token;
+  return typeof token === "string" && token.trim() ? token.trim() : null;
+}
+function unauthenticatedSession(mode) {
+  return {
+    authenticated: false,
+    username: null,
+    expiresAt: null,
+    mode,
+    authRequired: mode === "server" || mode === "relay"
+  };
+}
+function isSessionPayload(value) {
+  return typeof value === "object" && value !== null && "username" in value && typeof value.username === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && "nonce" in value && typeof value.nonce === "string";
+}
+function constantTimeEqual(left, right) {
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  if (leftBuffer.length !== rightBuffer.length) {
+    return false;
+  }
+  return crypto2.timingSafeEqual(leftBuffer, rightBuffer);
+}
+
+// src/relay-tunnel-client.ts
+var RELAY_HEARTBEAT_INTERVAL_MS = 3e4;
+var RELAY_RECONNECT_INITIAL_DELAY_MS = 1e3;
+var RELAY_RECONNECT_MAX_DELAY_MS = 3e4;
+var RelayTunnelClient = class {
+  constructor(config, handleRequest, handleClientConnected, handleClientMessage) {
+    this.config = config;
+    this.handleRequest = handleRequest;
+    this.handleClientConnected = handleClientConnected;
+    this.handleClientMessage = handleClientMessage;
+  }
+  config;
+  handleRequest;
+  handleClientConnected;
+  handleClientMessage;
+  socket = null;
+  heartbeatHandle = null;
+  reconnectHandle = null;
+  reconnectDelayMs = RELAY_RECONNECT_INITIAL_DELAY_MS;
+  stopped = false;
+  relayClientCleanup = /* @__PURE__ */ new Map();
+  validateConfig() {
+    if (!this.config.serverUrl || !this.config.agentToken) {
+      throw new Error(
+        "Relay mode requires REMOTE_CODEX_RELAY_SERVER_URL and REMOTE_CODEX_RELAY_AGENT_TOKEN."
+      );
+    }
+  }
+  start() {
+    this.validateConfig();
+    this.stopped = false;
+    this.clearReconnect();
+    if (this.socket) {
+      return;
+    }
+    const url = new URL("/supervisor/tunnel", this.config.serverUrl ?? void 0);
+    url.searchParams.set("token", this.config.agentToken ?? "");
+    url.searchParams.set("deviceToken", this.config.agentToken ?? "");
+    this.socket = new WebSocket(url);
+    this.socket.addEventListener("open", () => {
+      this.reconnectDelayMs = RELAY_RECONNECT_INITIAL_DELAY_MS;
+      this.sendHeartbeat();
+      this.heartbeatHandle = setInterval(() => {
+        this.sendHeartbeat();
+      }, RELAY_HEARTBEAT_INTERVAL_MS);
+    });
+    this.socket.addEventListener("close", () => {
+      this.clearHeartbeat();
+      this.cleanupRelayClients();
+      this.socket = null;
+      this.scheduleReconnect();
+    });
+    this.socket.addEventListener("message", (event) => {
+      void this.handleMessage(String(event.data));
+    });
+  }
+  stop() {
+    this.stopped = true;
+    this.clearHeartbeat();
+    this.clearReconnect();
+    this.cleanupRelayClients();
+    this.socket?.close();
+    this.socket = null;
+  }
+  sendHeartbeat() {
+    if (this.socket?.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    this.socket.send(
+      JSON.stringify({
+        type: "relay.heartbeat",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  async handleMessage(rawMessage) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawMessage);
+    } catch {
+      return;
+    }
+    if (parsed.type !== "relay.request") {
+      if (parsed.type === "relay.client.connected") {
+        const cleanup = this.handleClientConnected(parsed.clientId, (message) => {
+          this.sendClientMessage(parsed.clientId, message);
+        });
+        this.relayClientCleanup.set(parsed.clientId, cleanup);
+        return;
+      }
+      if (parsed.type === "relay.client.disconnected") {
+        this.relayClientCleanup.get(parsed.clientId)?.();
+        this.relayClientCleanup.delete(parsed.clientId);
+        return;
+      }
+      if (parsed.type === "relay.client.message") {
+        await this.handleClientMessage(parsed.clientId, parsed.payload, (message) => {
+          this.sendClientMessage(parsed.clientId, message);
+        });
+        return;
+      }
+      return;
+    }
+    const response = await this.handleRequest(parsed.payload);
+    this.socket?.send(
+      JSON.stringify({
+        type: "relay.response",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: parsed.requestId,
+        payload: response
+      })
+    );
+  }
+  sendClientMessage(clientId, message) {
+    if (this.socket?.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    this.socket.send(
+      JSON.stringify({
+        type: "relay.server.message",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        clientId,
+        payload: message
+      })
+    );
+  }
+  clearHeartbeat() {
+    if (this.heartbeatHandle) {
+      clearInterval(this.heartbeatHandle);
+      this.heartbeatHandle = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.reconnectHandle) {
+      return;
+    }
+    const delayMs = this.reconnectDelayMs;
+    this.reconnectDelayMs = Math.min(
+      this.reconnectDelayMs * 2,
+      RELAY_RECONNECT_MAX_DELAY_MS
+    );
+    this.reconnectHandle = setTimeout(() => {
+      this.reconnectHandle = null;
+      this.start();
+    }, delayMs);
+  }
+  clearReconnect() {
+    if (this.reconnectHandle) {
+      clearTimeout(this.reconnectHandle);
+      this.reconnectHandle = null;
+    }
+  }
+  cleanupRelayClients() {
+    for (const [clientId, cleanup] of this.relayClientCleanup) {
+      cleanup();
+      this.relayClientCleanup.delete(clientId);
+    }
+  }
+};
+
 // src/app.ts
 var MAX_PROMPT_ATTACHMENTS2 = 10;
 var MAX_PROMPT_ATTACHMENT_BYTES2 = 25 * 1024 * 1024;
+var RELAY_FORWARD_HEADER = "x-remote-codex-relay-forwarded";
 var HttpError = class extends Error {
   constructor(statusCode, payload) {
     super(payload.message);
@@ -24927,6 +25365,7 @@ function buildApp(options = {}) {
   const pluginRegistry = new PluginRegistry(builtinPlugins);
   const pluginSettingsStore = new PluginSettingsStore(database.db);
   const pluginService = new PluginService(pluginRegistry, pluginSettingsStore);
+  const authService = new AuthService(config);
   const runtimeBootstrap = options.runtimeBootstrap ?? createAgentRuntimeBootstrap(config);
   const repoRoot = findRepoRoot();
   const agentRuntimes = options.agentRuntimes ?? runtimeBootstrap.agentRuntimes;
@@ -24960,6 +25399,16 @@ function buildApp(options = {}) {
       fileSize: MAX_PROMPT_ATTACHMENT_BYTES2
     }
   });
+  const backendPluginHost = new BackendPluginHost(app2);
+  backendPluginHost.register(createTerminalPluginBackendContribution());
+  const relaySocketBridge = createRelaySocketBridge(app2, eventBus, backendPluginHost);
+  const relayTunnelClient = config.mode === "relay" ? options.relayTunnelClient ?? new RelayTunnelClient(
+    config.relay,
+    createRelayRequestHandler(app2),
+    relaySocketBridge.handleConnected,
+    relaySocketBridge.handleMessage
+  ) : null;
+  relayTunnelClient?.validateConfig();
   app2.decorate("services", {
     config,
     database,
@@ -24971,10 +25420,29 @@ function buildApp(options = {}) {
     providerHostConfigService,
     pluginRegistry,
     pluginService,
+    authService,
+    relayTunnelClient,
     repoRoot
   });
-  const backendPluginHost = new BackendPluginHost(app2);
-  backendPluginHost.register(createTerminalPluginBackendContribution());
+  app2.addHook("onRequest", async (request, reply) => {
+    if (!authService.required) {
+      return;
+    }
+    const requestPath = new URL(request.url, "http://localhost").pathname;
+    if (!requestPath.startsWith("/api/")) {
+      return;
+    }
+    if (requestPath === "/api/auth/login" || requestPath === "/api/auth/logout" || requestPath === "/api/auth/session") {
+      return;
+    }
+    if (config.mode === "relay" && request.headers[RELAY_FORWARD_HEADER] === "1") {
+      return;
+    }
+    const session = authService.verifyRequest(request);
+    if (!session.authenticated) {
+      return reply.status(401).send(unauthorizedPayload());
+    }
+  });
   app2.register(async (realtimeApp) => {
     await realtimeApp.register(websocket);
     realtimeApp.route({
@@ -24986,69 +25454,32 @@ function buildApp(options = {}) {
           message: "Upgrade to websocket is required."
         });
       },
-      wsHandler: (socket) => {
-        const closeHandlers = [];
-        const socketState = /* @__PURE__ */ new Map();
-        const onClose = (handler) => {
-          closeHandlers.push(handler);
-        };
-        function send(message) {
-          if (socket.readyState === 1) {
-            socket.send(JSON.stringify(message));
-          }
+      wsHandler: (socket, request) => {
+        const session = authService.verifyRequest(request);
+        if (!session.authenticated) {
+          socket.close(1008, "Authentication is required.");
+          return;
         }
-        send({
-          type: "supervisor.connected",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        const unsubscribe = eventBus.onThreadEvent((event) => {
-          send(event);
-        });
-        const unsubscribeShell = eventBus.onShellEvent((event) => {
-          send(event);
-        });
-        socket.on("message", async (rawMessage) => {
-          let parsed;
-          try {
-            parsed = JSON.parse(rawMessage.toString());
-          } catch {
-            return;
-          }
-          try {
-            if (parsed.type === "supervisor.ping") {
-              send({
-                type: "supervisor.pong",
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                payload: {
-                  requestTimestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : null
-                }
-              });
-              return;
+        const supervisorSession = createSupervisorSocketSession({
+          app: app2,
+          eventBus,
+          backendPluginHost,
+          send(message) {
+            if (socket.readyState === 1) {
+              socket.send(JSON.stringify(message));
             }
-            const handled = await backendPluginHost.handleSocketMessage({
-              app: app2,
-              send,
-              onClose,
-              state: socketState,
-              message: parsed
-            });
-            if (!handled) {
-              return;
-            }
-          } catch {
-            return;
           }
         });
+        socket.on("message", async (rawMessage) => {
+          await supervisorSession.handleMessage(rawMessage.toString());
+        });
         socket.on("close", () => {
-          for (const handler of closeHandlers.splice(0)) {
-            handler();
-          }
-          unsubscribe();
-          unsubscribeShell();
+          supervisorSession.close();
         });
       }
     });
   });
+  app2.register(registerAuthRoutes);
   app2.register(registerSystemRoutes);
   app2.register(registerAgentRuntimeRoutes);
   app2.register(registerPluginRoutes);
@@ -25157,6 +25588,7 @@ function buildApp(options = {}) {
   });
   app2.addHook("onClose", async () => {
     await shellService.stop();
+    relayTunnelClient?.stop();
     await Promise.all(agentRuntimes.all().map((runtime) => runtime.stop()));
     database.sqlite.close();
   });
@@ -25166,6 +25598,7 @@ function buildApp(options = {}) {
         codexHome: runtimeBootstrap.providerHostHomes.codex ?? null,
         repoRoot
       });
+      relayTunnelClient?.start();
       await Promise.all(agentRuntimes.all().map((runtime) => runtime.start()));
       await shellService.syncShellStateOnStartup();
     } catch (error) {
@@ -25181,6 +25614,117 @@ function requestLog(app2, error) {
   }
   app2.log.error({ error }, "Non-error value reached Fastify error handler.");
 }
+function createRelayRequestHandler(app2) {
+  return async function handleRelayRequest(request) {
+    const response = await app2.inject({
+      method: request.method,
+      url: request.path,
+      headers: {
+        ...request.headers,
+        [RELAY_FORWARD_HEADER]: "1"
+      },
+      ...request.body !== null ? { payload: request.body } : {}
+    });
+    return {
+      statusCode: response.statusCode,
+      headers: relayResponseHeaders(response.headers),
+      body: response.body
+    };
+  };
+}
+function createSupervisorSocketSession(input) {
+  const closeHandlers = [];
+  const socketState = /* @__PURE__ */ new Map();
+  const onClose = (handler) => {
+    closeHandlers.push(handler);
+  };
+  input.send({
+    type: "supervisor.connected",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const unsubscribeThread = input.eventBus.onThreadEvent((event) => {
+    input.send(event);
+  });
+  const unsubscribeShell = input.eventBus.onShellEvent((event) => {
+    input.send(event);
+  });
+  return {
+    async handleMessage(rawMessage) {
+      let parsed;
+      try {
+        parsed = JSON.parse(rawMessage);
+      } catch {
+        return;
+      }
+      try {
+        if (parsed.type === "supervisor.ping") {
+          input.send({
+            type: "supervisor.pong",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            payload: {
+              requestTimestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : null
+            }
+          });
+          return;
+        }
+        await input.backendPluginHost.handleSocketMessage({
+          app: input.app,
+          send: input.send,
+          onClose,
+          state: socketState,
+          message: parsed
+        });
+      } catch {
+        return;
+      }
+    },
+    close() {
+      for (const handler of closeHandlers.splice(0)) {
+        handler();
+      }
+      unsubscribeThread();
+      unsubscribeShell();
+    }
+  };
+}
+function createRelaySocketBridge(app2, eventBus, backendPluginHost) {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    handleConnected(clientId, send) {
+      const existing = sessions.get(clientId);
+      existing?.close();
+      const session = createSupervisorSocketSession({
+        app: app2,
+        eventBus,
+        backendPluginHost,
+        send
+      });
+      sessions.set(clientId, session);
+      return () => {
+        session.close();
+        sessions.delete(clientId);
+      };
+    },
+    async handleMessage(clientId, message) {
+      const session = sessions.get(clientId);
+      if (!session) {
+        return;
+      }
+      await session.handleMessage(JSON.stringify(message));
+    }
+  };
+}
+function relayResponseHeaders(headers) {
+  const output = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      output[name] = value.join(", ");
+    } else if (value !== void 0) {
+      output[name] = String(value);
+    }
+  }
+  return output;
+}
 
 // src/index.ts
 if (fs25.existsSync(".env")) {