remote-codex 0.11.30 → 0.11.32

package/apps/relay-server/dist/index.js

@@ -9,6 +9,7 @@ import fs2 from "fs";
 import fsp from "fs/promises";
 import path2 from "path";
 import { randomUUID } from "crypto";
+import crypto3 from "crypto";
 import { z } from "zod";
 
 // src/request-broker.ts
@@ -59,6 +60,282 @@ var RelayRequestBroker = class {
   }
 };
 
+// src/hosted-sandbox-provider.ts
+var HostedSandboxProviderError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var DisabledHostedSandboxProvider = class {
+  async capability() {
+    return {
+      provider: "disabled",
+      configured: false,
+      reachable: false,
+      available: false,
+      reasonCode: "hosted_sandbox_disabled",
+      reason: "Hosted supervisor VMs are not configured on this relay.",
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  inventory() {
+    return this.disabled();
+  }
+  createCredential(_openaiApiKey, _idempotencyKey) {
+    return this.disabled();
+  }
+  createCodexCredential(_files, _idempotencyKey) {
+    return this.disabled();
+  }
+  deleteCredential(_credentialRef, _idempotencyKey) {
+    return this.disabled();
+  }
+  create(_input, _idempotencyKey) {
+    return this.disabled();
+  }
+  status(_id) {
+    return this.disabled();
+  }
+  start(_id, _idempotencyKey) {
+    return this.disabled();
+  }
+  stop(_id, _idempotencyKey) {
+    return this.disabled();
+  }
+  snapshot(_id, _name, _idempotencyKey) {
+    return this.disabled();
+  }
+  delete(_id, _idempotencyKey) {
+    return this.disabled();
+  }
+  provision(_input, _idempotencyKey) {
+    return this.disabled();
+  }
+  readCodexFiles(_id) {
+    return this.disabled();
+  }
+  writeCodexFiles(_id, _files, _idempotencyKey) {
+    return this.disabled();
+  }
+  disabled() {
+    return Promise.reject(new Error("Hosted sandbox provider is disabled."));
+  }
+};
+var IncusHostedSandboxProvider = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  config;
+  async capability(signal) {
+    const result = await this.request("/v1/capability", signal ? { signal } : {});
+    const available = result.available && result.credentialStoreReady === true;
+    return {
+      provider: "incus",
+      configured: true,
+      reachable: true,
+      available,
+      reasonCode: available ? null : "incus_host_agent_not_ready",
+      reason: available ? null : "Incus or encrypted credential storage is not ready.",
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...result.limits ? { limits: result.limits } : {},
+      ...result.capacity ? { capacity: result.capacity } : {},
+      ...result.metrics ? { metrics: result.metrics } : {},
+      ...result.alerts ? { alerts: result.alerts } : {}
+    };
+  }
+  inventory() {
+    return this.request("/v1/inventory");
+  }
+  async createCredential(openaiApiKey, idempotencyKey) {
+    const result = await this.request(
+      "/v1/credentials",
+      { method: "POST", idempotencyKey, body: { openaiApiKey } }
+    );
+    return result.credentialRef;
+  }
+  async createCodexCredential(files, idempotencyKey) {
+    const result = await this.request(
+      "/v1/credentials",
+      { method: "POST", idempotencyKey, body: { codexFiles: files } }
+    );
+    return result.credentialRef;
+  }
+  async deleteCredential(credentialRef, idempotencyKey) {
+    await this.request(`/v1/credentials/${encodeURIComponent(credentialRef)}`, {
+      method: "DELETE",
+      idempotencyKey
+    });
+  }
+  create(input, idempotencyKey) {
+    return this.request("/v1/instances", {
+      method: "POST",
+      idempotencyKey,
+      body: input
+    });
+  }
+  status(id) {
+    return this.request(
+      `/v1/instances/${encodeURIComponent(id)}`
+    );
+  }
+  start(id, idempotencyKey) {
+    return this.instanceMutation(id, "start", idempotencyKey);
+  }
+  stop(id, idempotencyKey) {
+    return this.instanceMutation(id, "stop", idempotencyKey);
+  }
+  async snapshot(id, name, idempotencyKey) {
+    await this.request(`/v1/instances/${encodeURIComponent(id)}/snapshots`, {
+      method: "POST",
+      idempotencyKey,
+      body: { name }
+    });
+  }
+  async delete(id, idempotencyKey) {
+    await this.request(`/v1/instances/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      idempotencyKey
+    });
+  }
+  async provision(input, idempotencyKey) {
+    await this.request(
+      `/v1/instances/${encodeURIComponent(input.id)}/provision`,
+      {
+        method: "POST",
+        idempotencyKey,
+        body: {
+          relayServerUrl: input.relayServerUrl,
+          relayAgentToken: input.relayAgentToken,
+          credentialRef: input.credentialRef,
+          codexConfig: input.codexConfig,
+          localAdminUsername: input.localAdminUsername ?? "admin"
+        }
+      }
+    );
+  }
+  readCodexFiles(id) {
+    return this.request(
+      `/v1/instances/${encodeURIComponent(id)}/backends/codex/files`
+    );
+  }
+  async writeCodexFiles(id, files, idempotencyKey) {
+    await this.request(
+      `/v1/instances/${encodeURIComponent(id)}/backends/codex/files`,
+      { method: "PUT", idempotencyKey, body: files }
+    );
+  }
+  instanceMutation(id, action, idempotencyKey) {
+    return this.request(
+      `/v1/instances/${encodeURIComponent(id)}/${action}`,
+      { method: "POST", idempotencyKey }
+    );
+  }
+  async request(pathname, options = {}) {
+    if (!this.config.agentUrl || !this.config.agentToken) {
+      throw new Error("Incus host-agent is not configured.");
+    }
+    const headers = {
+      authorization: `Bearer ${this.config.agentToken}`
+    };
+    if (options.idempotencyKey) {
+      headers["idempotency-key"] = options.idempotencyKey;
+    }
+    if (options.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    const request = {
+      method: options.method ?? "GET",
+      headers,
+      ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) },
+      ...options.signal ? { signal: options.signal } : {}
+    };
+    const response = await fetch(
+      `${this.config.agentUrl.replace(/\/$/, "")}${pathname}`,
+      request
+    );
+    if (!response.ok) {
+      const payload = await response.json().catch(() => null);
+      const detail = typeof payload?.message === "string" && payload.message.trim() ? payload.message.trim() : `Incus host-agent request failed with ${response.status}.`;
+      throw new HostedSandboxProviderError(
+        typeof payload?.code === "string" ? payload.code : "provider_request_failed",
+        detail
+      );
+    }
+    return await response.json();
+  }
+};
+function createHostedSandboxProvider(config2) {
+  return config2.provider === "incus" ? new IncusHostedSandboxProvider(config2) : new DisabledHostedSandboxProvider();
+}
+var HostedSandboxCapabilityService = class {
+  constructor(provider, options) {
+    this.provider = provider;
+    this.options = options;
+  }
+  provider;
+  options;
+  consecutiveFailures = 0;
+  circuitOpenedAt = null;
+  async read() {
+    const now = this.options.now ?? Date.now;
+    const failureThreshold = this.options.failureThreshold ?? 2;
+    const circuitResetMs = this.options.circuitResetMs ?? 3e4;
+    if (this.circuitOpenedAt !== null && now() - this.circuitOpenedAt < circuitResetMs) {
+      return unavailableCapability(
+        "hosted_provider_circuit_open",
+        "Hosted supervisor VM operations are temporarily unavailable after repeated provider failures."
+      );
+    }
+    if (this.circuitOpenedAt !== null) {
+      this.circuitOpenedAt = null;
+      this.consecutiveFailures = 0;
+    }
+    const controller = new AbortController();
+    let timeout = null;
+    try {
+      const capability = await Promise.race([
+        this.provider.capability(controller.signal),
+        new Promise((_resolve, reject) => {
+          timeout = setTimeout(() => {
+            controller.abort();
+            reject(new Error("Hosted sandbox provider request timed out."));
+          }, this.options.timeoutMs);
+        })
+      ]);
+      this.consecutiveFailures = 0;
+      this.circuitOpenedAt = null;
+      return capability;
+    } catch (error) {
+      this.consecutiveFailures += 1;
+      if (this.consecutiveFailures >= failureThreshold) {
+        this.circuitOpenedAt = now();
+      }
+      const timedOut = controller.signal.aborted;
+      return unavailableCapability(
+        timedOut ? "hosted_provider_timeout" : "hosted_provider_unreachable",
+        timedOut ? "The hosted supervisor VM provider did not respond in time." : "The hosted supervisor VM provider could not be reached."
+      );
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+};
+function unavailableCapability(reasonCode, reason) {
+  return {
+    provider: "incus",
+    configured: true,
+    reachable: false,
+    available: false,
+    reasonCode,
+    reason,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // src/relay-store.ts
 import crypto from "crypto";
 import fs from "fs";
@@ -75,6 +352,7 @@ var RelayStore = class _RelayStore {
     this.sqlite.pragma("foreign_keys = ON");
     this.migrate();
     this.importLegacyJson(legacyJsonPath);
+    this.migrateHostedSandboxMembers();
     this.ensureRegistrationSetting(registrationEnabled);
   }
   databasePath;
@@ -105,7 +383,11 @@ var RelayStore = class _RelayStore {
   }
   register(input) {
     if (!this.registrationEnabled()) {
-      throw new RelayStoreError(403, "forbidden", "Registration is currently disabled.");
+      throw new RelayStoreError(
+        403,
+        "forbidden",
+        "Registration is currently disabled."
+      );
     }
     const user = this.createStoredUser({
       email: input.email,
@@ -118,21 +400,41 @@ var RelayStore = class _RelayStore {
   }
   requestRegistrationApproval(input) {
     if (!this.registrationEnabled()) {
-      throw new RelayStoreError(403, "forbidden", "Registration is currently disabled.");
+      throw new RelayStoreError(
+        403,
+        "forbidden",
+        "Registration is currently disabled."
+      );
     }
     const email = input.email.trim().toLowerCase();
     const username = normalizeUsername(input.username);
     if (!email.includes("@")) {
-      throw new RelayStoreError(400, "bad_request", "A valid email address is required.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "A valid email address is required."
+      );
     }
     if (username.length < 3) {
-      throw new RelayStoreError(400, "bad_request", "Username must be at least 3 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Username must be at least 3 characters."
+      );
     }
     if (input.password.length < 8) {
-      throw new RelayStoreError(400, "bad_request", "Password must be at least 8 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Password must be at least 8 characters."
+      );
     }
     if (this.getUserByIdentifier(email) || this.getUserByUsername(username)) {
-      throw new RelayStoreError(409, "conflict", "A user with that email or username already exists.");
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "A user with that email or username already exists."
+      );
     }
     const existing = this.rowToPendingRegistration(
       this.sqlite.prepare(
@@ -158,19 +460,64 @@ var RelayStore = class _RelayStore {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: "pending",
       reviewedAt: null,
-      reviewedByUserId: null
+      reviewedByUserId: null,
+      provider: input.provider ?? "password",
+      providerSubject: input.providerSubject ?? null
     };
     this.insertPendingRegistration(record);
     return this.publicPendingRegistration(record);
   }
+  authenticateExternalIdentity(identity, approvalRequired) {
+    const linked = this.sqlite.prepare(
+      "SELECT user_id FROM relay_user_identities WHERE provider = ? AND provider_subject = ?"
+    ).get(identity.provider, identity.subject);
+    if (linked) {
+      const user2 = this.requireUser(linked.user_id);
+      if (!user2.enabled) throw new RelayStoreError(401, "unauthorized", "This relay account is disabled.");
+      return { kind: "login", result: this.createLoginResult(user2) };
+    }
+    if (!this.registrationEnabled()) {
+      throw new RelayStoreError(403, "forbidden", "Registration is currently disabled.");
+    }
+    if (this.getUserByIdentifier(identity.email)) {
+      throw new RelayStoreError(409, "conflict", "An account with this email already exists. Sign in with its current method before linking OAuth.");
+    }
+    const username = this.availableUsername(identity.username);
+    const password = crypto.randomBytes(32).toString("base64url");
+    if (approvalRequired) {
+      const request = this.requestRegistrationApproval({
+        email: identity.email,
+        username,
+        password,
+        provider: identity.provider,
+        providerSubject: identity.subject
+      });
+      return { kind: "pending", request };
+    }
+    const user = this.createStoredUser({ email: identity.email, username, password, role: "user" });
+    const create = this.sqlite.transaction(() => {
+      this.insertUser(user);
+      this.insertIdentity(user.id, identity.provider, identity.subject, identity.email);
+    });
+    create();
+    return { kind: "login", result: this.createLoginResult(user) };
+  }
   login(input) {
     const normalizedIdentifier = input.identifier.trim().toLowerCase();
     const user = this.getUserByIdentifier(normalizedIdentifier);
     if (!user || !user.enabled) {
-      throw new RelayStoreError(401, "unauthorized", "Invalid username or password.");
+      throw new RelayStoreError(
+        401,
+        "unauthorized",
+        "Invalid username or password."
+      );
     }
     if (!verifySecret(input.password, user.passwordSalt, user.passwordHash)) {
-      throw new RelayStoreError(401, "unauthorized", "Invalid username or password.");
+      throw new RelayStoreError(
+        401,
+        "unauthorized",
+        "Invalid username or password."
+      );
     }
     return this.createLoginResult(user);
   }
@@ -210,12 +557,446 @@ var RelayStore = class _RelayStore {
       token
     };
   }
+  createHostedSandboxRequested(input) {
+    const admin = this.requireUser(input.createdByAdminUserId);
+    const assignedUsers = this.requireHostedSandboxMembers(
+      input.assignedUserIds
+    );
+    const sandboxId = crypto.randomUUID();
+    const operationId = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let deviceResult = null;
+    const create = this.sqlite.transaction(() => {
+      deviceResult = this.createDevice(admin.id, {
+        name: input.deviceName
+      });
+      this.sqlite.prepare(
+        `
+            INSERT INTO relay_hosted_sandboxes (
+              id, device_id, assigned_user_id, created_by_admin_user_id,
+              provider, provider_instance_id, image_version,
+              cpu_count, memory_mib, disk_gib, status, credential_ref,
+              codex_config_json,
+              last_error_code, last_error_message, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, 'incus', NULL, ?, ?, ?, ?, 'requested', ?, ?, NULL, NULL, ?, ?)
+          `
+      ).run(
+        sandboxId,
+        deviceResult.device.id,
+        admin.id,
+        input.createdByAdminUserId,
+        input.imageVersion,
+        input.resources.cpuCount,
+        input.resources.memoryMiB,
+        input.resources.diskGiB,
+        input.credentialRef,
+        JSON.stringify(input.codexConfig ?? parseHostedCodexConfig(null)),
+        now,
+        now
+      );
+      const insertMember = this.sqlite.prepare(
+        `INSERT INTO relay_hosted_sandbox_members
+          (sandbox_id, user_id, position, created_at) VALUES (?, ?, ?, ?)`
+      );
+      assignedUsers.forEach(
+        (user, position) => insertMember.run(sandboxId, user.id, position, now)
+      );
+      this.insertHostedOperation({
+        id: operationId,
+        sandboxId,
+        action: "create",
+        status: "pending",
+        errorCode: null,
+        errorMessage: null,
+        createdAt: now,
+        updatedAt: now
+      });
+    });
+    create();
+    const context = this.getHostedProvisionContext(sandboxId);
+    if (!context || !deviceResult) {
+      throw new Error("Hosted sandbox transaction did not persist.");
+    }
+    return {
+      sandbox: this.getHostedSandboxDetail(sandboxId),
+      operation: this.getHostedOperation(operationId),
+      deviceToken: context.deviceToken
+    };
+  }
+  listHostedSandboxes() {
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_hosted_sandboxes ORDER BY created_at DESC"
+    ).all().map((row) => this.rowToHostedSandbox(row));
+  }
+  setHostedSandboxMembers(id, userIds) {
+    if (!this.getHostedSandboxDetail(id)) {
+      throw new RelayStoreError(404, "not_found", "Hosted VM was not found.");
+    }
+    const users = this.requireHostedSandboxMembers(userIds);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.sqlite.transaction(() => {
+      this.sqlite.prepare(
+        "DELETE FROM relay_hosted_sandbox_members WHERE sandbox_id = ?"
+      ).run(id);
+      const insert = this.sqlite.prepare(
+        `INSERT INTO relay_hosted_sandbox_members
+          (sandbox_id, user_id, position, created_at) VALUES (?, ?, ?, ?)`
+      );
+      users.forEach((user, position) => insert.run(id, user.id, position, now));
+      this.sqlite.prepare(
+        "UPDATE relay_hosted_sandboxes SET updated_at = ? WHERE id = ?"
+      ).run(now, id);
+    })();
+    return this.getHostedSandboxDetail(id);
+  }
+  setHostedWorkspaceIsolation(id, enabled) {
+    const result = this.sqlite.prepare(
+      `UPDATE relay_hosted_sandboxes
+         SET workspace_isolation_enabled = ?, updated_at = ? WHERE id = ?`
+    ).run(enabled ? 1 : 0, (/* @__PURE__ */ new Date()).toISOString(), id);
+    if (result.changes === 0) {
+      throw new RelayStoreError(404, "not_found", "Hosted VM was not found.");
+    }
+    return this.getHostedSandboxDetail(id);
+  }
+  hostedWorkspaceIsolation(deviceId) {
+    const row = this.sqlite.prepare(
+      `SELECT id, workspace_isolation_enabled
+         FROM relay_hosted_sandboxes WHERE device_id = ?`
+    ).get(deviceId);
+    return row ? { sandboxId: row.id, enabled: Boolean(row.workspace_isolation_enabled) } : null;
+  }
+  hostedWorkspaceIsolationForUser(deviceId, userId) {
+    const row = this.sqlite.prepare(
+      `SELECT hs.id, hs.workspace_isolation_enabled
+         FROM relay_hosted_sandboxes hs
+         JOIN relay_hosted_sandbox_members m ON m.sandbox_id = hs.id
+         WHERE hs.device_id = ? AND m.user_id = ?`
+    ).get(deviceId, userId);
+    return row ? { sandboxId: row.id, enabled: Boolean(row.workspace_isolation_enabled) } : null;
+  }
+  hostedUserWorkspaceIds(sandboxId, userId) {
+    return this.sqlite.prepare(
+      `SELECT workspace_id FROM relay_hosted_user_workspaces
+           WHERE sandbox_id = ? AND user_id = ? ORDER BY created_at`
+    ).all(sandboxId, userId).map((row) => row.workspace_id);
+  }
+  recordHostedUserWorkspace(sandboxId, userId, workspaceId, initial = false) {
+    this.sqlite.prepare(
+      `INSERT OR IGNORE INTO relay_hosted_user_workspaces
+          (sandbox_id, user_id, workspace_id, initial_workspace, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(sandboxId, userId, workspaceId, initial ? 1 : 0, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  ownsHostedWorkspace(sandboxId, userId, workspaceId) {
+    return Boolean(
+      this.sqlite.prepare(
+        `SELECT 1 FROM relay_hosted_user_workspaces
+           WHERE sandbox_id = ? AND user_id = ? AND workspace_id = ?`
+      ).get(sandboxId, userId, workspaceId)
+    );
+  }
+  recordHostedUserThread(sandboxId, userId, threadId, workspaceId) {
+    this.sqlite.prepare(
+      `INSERT OR IGNORE INTO relay_hosted_user_threads
+          (sandbox_id, user_id, thread_id, workspace_id, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(sandboxId, userId, threadId, workspaceId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  ownsHostedThread(sandboxId, userId, threadId) {
+    return Boolean(
+      this.sqlite.prepare(
+        `SELECT 1 FROM relay_hosted_user_threads
+           WHERE sandbox_id = ? AND user_id = ? AND thread_id = ?`
+      ).get(sandboxId, userId, threadId)
+    );
+  }
+  listHostedProviderRecords() {
+    return this.sqlite.prepare(
+      "SELECT id, credential_ref FROM relay_hosted_sandboxes ORDER BY id"
+    ).all().map((row) => ({ id: row.id, credentialRef: row.credential_ref }));
+  }
+  getHostedSandboxDetail(id) {
+    const row = this.sqlite.prepare("SELECT * FROM relay_hosted_sandboxes WHERE id = ?").get(id);
+    if (!row) {
+      return null;
+    }
+    return {
+      ...this.rowToHostedSandbox(row),
+      operations: this.getHostedOperations(id)
+    };
+  }
+  getHostedProvisionContext(id) {
+    const row = this.sqlite.prepare(
+      `
+          SELECT hs.*, d.token AS device_token
+          FROM relay_hosted_sandboxes hs
+          JOIN relay_devices d ON d.id = hs.device_id
+          WHERE hs.id = ?
+        `
+    ).get(id);
+    if (!row || !row.device_token) {
+      return null;
+    }
+    return {
+      sandbox: this.rowToHostedSandbox(row),
+      deviceToken: row.device_token,
+      credentialRef: row.credential_ref,
+      codexConfig: parseHostedCodexConfig(row.codex_config_json)
+    };
+  }
+  listHostedSandboxesNeedingReconciliation() {
+    return this.sqlite.prepare(
+      `
+          SELECT id FROM relay_hosted_sandboxes
+          WHERE status IN ('requested', 'creating', 'starting', 'provisioning')
+          ORDER BY created_at ASC
+        `
+    ).all().map((row) => row.id);
+  }
+  updateHostedSandboxStatus(id, status, options = {}) {
+    const result = this.sqlite.prepare(
+      `
+          UPDATE relay_hosted_sandboxes
+          SET status = ?,
+              provider_instance_id = COALESCE(?, provider_instance_id),
+              last_error_code = ?,
+              last_error_message = ?,
+              running_since = CASE
+                WHEN ? = 'stopped' THEN NULL
+                WHEN ? = 'starting' AND running_since IS NULL THEN ?
+                ELSE running_since
+              END,
+              updated_at = ?
+          WHERE id = ?
+        `
+    ).run(
+      status,
+      options.providerInstanceId ?? null,
+      options.errorCode ?? null,
+      options.errorMessage ?? null,
+      status,
+      status,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      (/* @__PURE__ */ new Date()).toISOString(),
+      id
+    );
+    if (result.changes < 1) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+  }
+  updateHostedOperation(id, status, error) {
+    const result = this.sqlite.prepare(
+      `
+          UPDATE relay_hosted_operations
+          SET status = ?, error_code = ?, error_message = ?, updated_at = ?
+          WHERE id = ?
+        `
+    ).run(
+      status,
+      error?.code ?? null,
+      error?.message ?? null,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      id
+    );
+    if (result.changes < 1) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted operation was not found."
+      );
+    }
+  }
+  createHostedOperation(sandboxId, action) {
+    if (!this.getHostedSandboxDetail(sandboxId)) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const operation = {
+      id: crypto.randomUUID(),
+      sandboxId,
+      action,
+      status: "pending",
+      errorCode: null,
+      errorMessage: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.insertHostedOperation(operation);
+    return operation;
+  }
+  markHostedDeviceOnline(deviceId) {
+    this.sqlite.prepare(
+      `
+          UPDATE relay_hosted_sandboxes
+          SET status = 'online', last_error_code = NULL,
+              last_error_message = NULL,
+              running_since = COALESCE(running_since, ?), updated_at = ?
+          WHERE device_id = ? AND status != 'deleting'
+        `
+    ).run((/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString(), deviceId);
+  }
+  getHostedSandboxByDeviceId(deviceId) {
+    const row = this.sqlite.prepare("SELECT * FROM relay_hosted_sandboxes WHERE device_id = ?").get(deviceId);
+    return row ? this.rowToHostedSandbox(row) : null;
+  }
+  recordHostedUserActivity(deviceId, idleTimeoutMs) {
+    const row = this.sqlite.prepare("SELECT * FROM relay_hosted_sandboxes WHERE device_id = ?").get(deviceId);
+    if (!row) return null;
+    const now = /* @__PURE__ */ new Date();
+    const deadline = row.active_turn_count === 0 ? new Date(now.getTime() + idleTimeoutMs).toISOString() : null;
+    this.sqlite.prepare(
+      `
+          UPDATE relay_hosted_sandboxes
+          SET last_user_activity_at = ?, idle_deadline_at = ?,
+              lifecycle_generation = lifecycle_generation + 1, updated_at = ?
+          WHERE id = ?
+        `
+    ).run(now.toISOString(), deadline, now.toISOString(), row.id);
+    return this.getHostedSandboxDetail(row.id);
+  }
+  recordHostedTurnActivity(input) {
+    const row = this.sqlite.prepare("SELECT * FROM relay_hosted_sandboxes WHERE device_id = ?").get(input.deviceId);
+    if (!row) return null;
+    const update = this.sqlite.transaction(() => {
+      if (input.kind === "turn_started") {
+        this.sqlite.prepare(
+          `
+              INSERT OR IGNORE INTO relay_hosted_active_turns (
+                sandbox_id, thread_id, turn_id, started_at
+              ) VALUES (?, ?, ?, ?)
+            `
+        ).run(row.id, input.threadId, input.turnId, (/* @__PURE__ */ new Date()).toISOString());
+      } else {
+        this.sqlite.prepare(
+          `
+              DELETE FROM relay_hosted_active_turns
+              WHERE sandbox_id = ? AND thread_id = ? AND turn_id = ?
+            `
+        ).run(row.id, input.threadId, input.turnId);
+      }
+      const active = this.sqlite.prepare(
+        "SELECT COUNT(*) AS count FROM relay_hosted_active_turns WHERE sandbox_id = ?"
+      ).get(row.id);
+      const now = /* @__PURE__ */ new Date();
+      const deadline = active.count === 0 ? new Date(now.getTime() + input.idleTimeoutMs).toISOString() : null;
+      this.sqlite.prepare(
+        `
+            UPDATE relay_hosted_sandboxes
+            SET active_turn_count = ?, idle_deadline_at = ?,
+                lifecycle_generation = lifecycle_generation + 1, updated_at = ?
+            WHERE id = ?
+          `
+      ).run(active.count, deadline, now.toISOString(), row.id);
+    });
+    update();
+    return this.getHostedSandboxDetail(row.id);
+  }
+  armHostedIdleDeadline(id, idleTimeoutMs) {
+    const now = /* @__PURE__ */ new Date();
+    const current = this.getHostedSandboxDetail(id);
+    if (!current || current.activeTurnCount > 0) {
+      return current;
+    }
+    const activityDeadline = current.lastUserActivityAt ? new Date(
+      new Date(current.lastUserActivityAt).getTime() + idleTimeoutMs
+    ).toISOString() : null;
+    const deadline = activityDeadline ? current.idleDeadlineAt && current.idleDeadlineAt < activityDeadline ? current.idleDeadlineAt : activityDeadline : current.idleDeadlineAt ?? new Date(now.getTime() + idleTimeoutMs).toISOString();
+    if (deadline === current.idleDeadlineAt) {
+      return current;
+    }
+    this.sqlite.prepare(
+      `
+          UPDATE relay_hosted_sandboxes
+          SET idle_deadline_at = ?, lifecycle_generation = lifecycle_generation + 1,
+              updated_at = ?
+          WHERE id = ? AND active_turn_count = 0
+        `
+    ).run(deadline, now.toISOString(), id);
+    return this.getHostedSandboxDetail(id);
+  }
+  listHostedIdleDeadlines() {
+    return this.sqlite.prepare(
+      `
+          SELECT id, idle_deadline_at, lifecycle_generation
+          FROM relay_hosted_sandboxes
+          WHERE idle_deadline_at IS NOT NULL AND active_turn_count = 0
+            AND status = 'online'
+        `
+    ).all().map((row) => ({
+      id: row.id,
+      deadlineAt: row.idle_deadline_at,
+      generation: row.lifecycle_generation
+    }));
+  }
+  claimHostedIdleStop(id, generation, now) {
+    const result = this.sqlite.prepare(
+      `
+          UPDATE relay_hosted_sandboxes
+          SET status = 'stopping', idle_deadline_at = NULL,
+              lifecycle_generation = lifecycle_generation + 1, updated_at = ?
+          WHERE id = ? AND lifecycle_generation = ? AND active_turn_count = 0
+            AND status = 'online' AND idle_deadline_at <= ?
+        `
+    ).run(now.toISOString(), id, generation, now.toISOString());
+    return result.changes === 1;
+  }
   deleteDevice(userId, deviceId) {
+    const hosted = this.sqlite.prepare("SELECT id FROM relay_hosted_sandboxes WHERE device_id = ?").get(deviceId);
+    if (hosted) {
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "Hosted devices must be deleted from the Hosted supervisor VM admin panel."
+      );
+    }
     const result = this.sqlite.prepare("DELETE FROM relay_devices WHERE id = ? AND owner_user_id = ?").run(deviceId, userId);
     if (result.changes < 1) {
       throw new RelayStoreError(404, "not_found", "Device was not found.");
     }
   }
+  deleteHostedSandboxRecord(id) {
+    const context = this.getHostedProvisionContext(id);
+    if (!context) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+    const remove = this.sqlite.transaction(() => {
+      this.sqlite.prepare("DELETE FROM relay_hosted_sandboxes WHERE id = ?").run(id);
+      this.sqlite.prepare("DELETE FROM relay_devices WHERE id = ?").run(context.sandbox.deviceId);
+    });
+    remove();
+    return {
+      id,
+      deviceId: context.sandbox.deviceId,
+      credentialRef: context.credentialRef
+    };
+  }
+  replaceHostedCredentialRef(id, credentialRef) {
+    const context = this.getHostedProvisionContext(id);
+    if (!context) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+    this.sqlite.prepare(
+      "UPDATE relay_hosted_sandboxes SET credential_ref = ?, updated_at = ? WHERE id = ?"
+    ).run(credentialRef, (/* @__PURE__ */ new Date()).toISOString(), id);
+    return context.credentialRef;
+  }
   verifyDeviceToken(token) {
     if (!token) {
       return null;
@@ -236,7 +1017,11 @@ var RelayStore = class _RelayStore {
       throw new RelayStoreError(404, "not_found", "Target user was not found.");
     }
     if (target.id === ownerUserId) {
-      throw new RelayStoreError(400, "bad_request", "You cannot share a session with yourself.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "You cannot share a session with yourself."
+      );
     }
     const existing = this.rowToShare(
       this.sqlite.prepare(
@@ -295,16 +1080,28 @@ var RelayStore = class _RelayStore {
       throw new RelayStoreError(404, "not_found", "Target user was not found.");
     }
     if (target.id === ownerUserId) {
-      throw new RelayStoreError(400, "bad_request", "You cannot share access with yourself.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "You cannot share access with yourself."
+      );
     }
     const scope = normalizeShareScope(input.scope);
     const threadId = scope === "thread" ? input.threadId?.trim() || null : null;
     const workspaceId = scope === "workspace" ? input.workspaceId?.trim() || null : null;
     if (scope === "thread" && !threadId) {
-      throw new RelayStoreError(400, "bad_request", "threadId is required for thread grants.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "threadId is required for thread grants."
+      );
     }
     if (scope === "workspace" && !workspaceId) {
-      throw new RelayStoreError(400, "bad_request", "workspaceId is required for workspace grants.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "workspaceId is required for workspace grants."
+      );
     }
     const existing = this.rowToGrant(
       this.sqlite.prepare(
@@ -318,7 +1115,14 @@ var RelayStore = class _RelayStore {
               AND COALESCE(workspace_id, '') = COALESCE(?, '')
               AND revoked_at IS NULL
           `
-      ).get(ownerUserId, target.id, input.deviceId, scope, threadId, workspaceId)
+      ).get(
+        ownerUserId,
+        target.id,
+        input.deviceId,
+        scope,
+        threadId,
+        workspaceId
+      )
     );
     if (existing) {
       return this.updateGrantRecord(existing.id, {
@@ -362,7 +1166,9 @@ var RelayStore = class _RelayStore {
   }
   updateShare(userId, shareId, input) {
     const share = this.rowToShare(
-      this.sqlite.prepare("SELECT * FROM relay_shares WHERE id = ? AND owner_user_id = ? AND revoked_at IS NULL").get(shareId, userId)
+      this.sqlite.prepare(
+        "SELECT * FROM relay_shares WHERE id = ? AND owner_user_id = ? AND revoked_at IS NULL"
+      ).get(shareId, userId)
     );
     if (!share) {
       throw new RelayStoreError(404, "not_found", "Share was not found.");
@@ -379,7 +1185,9 @@ var RelayStore = class _RelayStore {
   }
   revokeShare(userId, shareId) {
     const share = this.rowToShare(
-      this.sqlite.prepare("SELECT * FROM relay_shares WHERE id = ? AND owner_user_id = ?").get(shareId, userId)
+      this.sqlite.prepare(
+        "SELECT * FROM relay_shares WHERE id = ? AND owner_user_id = ?"
+      ).get(shareId, userId)
     );
     if (!share) {
       throw new RelayStoreError(404, "not_found", "Share was not found.");
@@ -390,7 +1198,9 @@ var RelayStore = class _RelayStore {
   }
   updateGrant(userId, grantId, input) {
     const grant = this.rowToGrant(
-      this.sqlite.prepare("SELECT * FROM relay_access_grants WHERE id = ? AND owner_user_id = ? AND revoked_at IS NULL").get(grantId, userId)
+      this.sqlite.prepare(
+        "SELECT * FROM relay_access_grants WHERE id = ? AND owner_user_id = ? AND revoked_at IS NULL"
+      ).get(grantId, userId)
     );
     if (!grant) {
       throw new RelayStoreError(404, "not_found", "Grant was not found.");
@@ -409,7 +1219,9 @@ var RelayStore = class _RelayStore {
   }
   revokeGrant(userId, grantId) {
     const grant = this.rowToGrant(
-      this.sqlite.prepare("SELECT * FROM relay_access_grants WHERE id = ? AND owner_user_id = ?").get(grantId, userId)
+      this.sqlite.prepare(
+        "SELECT * FROM relay_access_grants WHERE id = ? AND owner_user_id = ?"
+      ).get(grantId, userId)
     );
     if (!grant) {
       throw new RelayStoreError(404, "not_found", "Grant was not found.");
@@ -433,6 +1245,25 @@ var RelayStore = class _RelayStore {
         canCreateThreads: true
       };
     }
+    const hostedMember = this.sqlite.prepare(
+      `SELECT 1
+         FROM relay_hosted_sandbox_members m
+         JOIN relay_hosted_sandboxes hs ON hs.id = m.sandbox_id
+         WHERE m.user_id = ? AND hs.device_id = ?`
+    ).get(userId, deviceId);
+    if (hostedMember) {
+      return {
+        kind: "owner",
+        share: null,
+        grant: null,
+        scope: "owner",
+        threadAccess: "control",
+        workspaceAccess: "write",
+        workspaceId: null,
+        workspaceScope: null,
+        canCreateThreads: true
+      };
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (scope.threadId) {
       const share = this.rowToShare(
@@ -515,23 +1346,34 @@ var RelayStore = class _RelayStore {
   }
   portalSummary(userId, connectedDevices) {
     const user = this.requireUser(userId);
-    const devices = this.getDevicesByOwner(userId);
+    const devices = [
+      ...this.getDevicesByOwner(userId),
+      ...this.getHostedDevicesByMember(userId)
+    ].filter(
+      (device, index, all) => all.findIndex((item) => item.id === device.id) === index
+    );
     const sharedWithMe = this.getSharesByTarget(userId);
     const sharedByMe = this.getSharesByOwner(userId);
     const grantsWithMe = this.getGrantsByTarget(userId);
     const grantsByMe = this.getGrantsByOwner(userId);
     return {
       user: this.publicUser(user),
-      devices: devices.map((device) => this.publicDevice(device, connectedDevices.get(device.id) ?? null)),
+      devices: devices.map(
+        (device) => this.publicDevice(device, connectedDevices.get(device.id) ?? null)
+      ),
       sharedWithMe: sharedWithMe.map((share) => this.publicShare(share)),
       sharedByMe: sharedByMe.map((share) => this.publicShare(share)),
       sharedDevicesWithMe: grantsWithMe.filter((grant) => grant.scope === "device").map((grant) => this.publicGrant(grant)),
       sharedThreadsWithMe: [
-        ...sharedWithMe.map((share) => this.publicGrant(this.grantFromShare(share))),
+        ...sharedWithMe.map(
+          (share) => this.publicGrant(this.grantFromShare(share))
+        ),
         ...grantsWithMe.filter((grant) => grant.scope !== "device").map((grant) => this.publicGrant(grant))
       ],
       grantsByMe: [
-        ...sharedByMe.map((share) => this.publicGrant(this.grantFromShare(share))),
+        ...sharedByMe.map(
+          (share) => this.publicGrant(this.grantFromShare(share))
+        ),
         ...grantsByMe.map((grant) => this.publicGrant(grant))
       ]
     };
@@ -540,17 +1382,39 @@ var RelayStore = class _RelayStore {
     return this.getSharesByTarget(userId).filter((share) => share.deviceId === deviceId).map((share) => this.publicShare(share));
   }
   adminSummary(connectedDevices, options = {}) {
-    const conversationWindowDays = normalizeConversationWindowDays(options.conversationWindowDays);
+    const conversationWindowDays = normalizeConversationWindowDays(
+      options.conversationWindowDays
+    );
     const users = this.getUsers();
     const devices = this.getDevices();
     const deviceCounts = /* @__PURE__ */ new Map();
+    const hostedDeviceIds = new Set(
+      this.sqlite.prepare("SELECT device_id FROM relay_hosted_sandboxes").all().map((row) => row.device_id)
+    );
     for (const device of devices) {
-      deviceCounts.set(device.ownerUserId, (deviceCounts.get(device.ownerUserId) ?? 0) + 1);
+      if (hostedDeviceIds.has(device.id)) continue;
+      deviceCounts.set(
+        device.ownerUserId,
+        (deviceCounts.get(device.ownerUserId) ?? 0) + 1
+      );
+    }
+    const hostedMemberships = this.sqlite.prepare("SELECT user_id FROM relay_hosted_sandbox_members").all();
+    for (const membership of hostedMemberships) {
+      deviceCounts.set(
+        membership.user_id,
+        (deviceCounts.get(membership.user_id) ?? 0) + 1
+      );
     }
-    const conversationCounts = this.conversationCountsByUser(conversationWindowDays);
+    const conversationCounts = this.conversationCountsByUser(
+      conversationWindowDays
+    );
     return {
       users: users.map(
-        (user) => this.publicAdminUser(user, deviceCounts.get(user.id) ?? 0, conversationCounts.get(user.id) ?? 0)
+        (user) => this.publicAdminUser(
+          user,
+          deviceCounts.get(user.id) ?? 0,
+          conversationCounts.get(user.id) ?? 0
+        )
       ),
       devices: devices.map((device) => {
         const owner = users.find((user) => user.id === device.ownerUserId);
@@ -561,7 +1425,9 @@ var RelayStore = class _RelayStore {
           options.metadata
         );
       }),
-      shares: this.getShares({ includeRevoked: true }).map((share) => this.publicShare(share)),
+      shares: this.getShares({ includeRevoked: true }).map(
+        (share) => this.publicShare(share)
+      ),
       pendingRegistrations: this.pendingRegistrations(),
       settings: this.registrationSettings(),
       conversationWindowDays,
@@ -576,7 +1442,13 @@ var RelayStore = class _RelayStore {
     return {
       enabled: this.registrationEnabled(),
       registrationPassword: this.getSetting("registrationPassword"),
-      approvalRequired: this.getSetting("registrationApprovalRequired") === "true"
+      approvalRequired: this.getSetting("registrationApprovalRequired") === "true",
+      googleAuthEnabled: this.getSetting("googleAuthEnabled") === "true",
+      githubAuthEnabled: this.getSetting("githubAuthEnabled") === "true",
+      emailVerificationEnabled: this.getSetting("emailVerificationEnabled") === "true",
+      googleAuthAvailable: false,
+      githubAuthAvailable: false,
+      emailVerificationAvailable: false
     };
   }
   updateRegistrationSettings(input) {
@@ -586,7 +1458,11 @@ var RelayStore = class _RelayStore {
     if (input.registrationPassword !== void 0) {
       const password = input.registrationPassword?.trim() || null;
       if (password !== null && password.length < 8) {
-        throw new RelayStoreError(400, "bad_request", "Registration password must be at least 8 characters.");
+        throw new RelayStoreError(
+          400,
+          "bad_request",
+          "Registration password must be at least 8 characters."
+        );
       }
       if (password === null) {
         this.deleteSetting("registrationPassword");
@@ -595,10 +1471,21 @@ var RelayStore = class _RelayStore {
       }
     }
     if (input.approvalRequired !== void 0) {
-      this.setSetting("registrationApprovalRequired", input.approvalRequired ? "true" : "false");
+      this.setSetting(
+        "registrationApprovalRequired",
+        input.approvalRequired ? "true" : "false"
+      );
+    }
+    for (const key of ["googleAuthEnabled", "githubAuthEnabled", "emailVerificationEnabled"]) {
+      if (input[key] !== void 0) this.setSetting(key, input[key] ? "true" : "false");
     }
     return this.registrationSettings();
   }
+  ensureAuthSettings(input) {
+    if (this.getSetting("googleAuthEnabled") === null) this.setSetting("googleAuthEnabled", input.google ? "true" : "false");
+    if (this.getSetting("githubAuthEnabled") === null) this.setSetting("githubAuthEnabled", input.github ? "true" : "false");
+    if (this.getSetting("emailVerificationEnabled") === null) this.setSetting("emailVerificationEnabled", "false");
+  }
   ensureRegistrationPassword(password) {
     if (!password || this.getSetting("registrationPassword") !== null) {
       return;
@@ -620,6 +1507,9 @@ var RelayStore = class _RelayStore {
     };
     const approve = this.sqlite.transaction(() => {
       this.insertUser(user);
+      if (record.providerSubject && record.provider !== "password") {
+        this.insertIdentity(user.id, record.provider, record.providerSubject, record.email);
+      }
       this.sqlite.prepare(
         `
             UPDATE relay_pending_registrations
@@ -664,7 +1554,11 @@ var RelayStore = class _RelayStore {
   setUserEnabled(userId, enabled) {
     const user = this.requireUser(userId);
     if (user.role === "admin" && !enabled) {
-      throw new RelayStoreError(400, "bad_request", "The admin user cannot be disabled.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "The admin user cannot be disabled."
+      );
     }
     this.sqlite.prepare("UPDATE relay_users SET enabled = ? WHERE id = ?").run(enabled ? 1 : 0, userId);
     return this.publicUser({ ...user, enabled });
@@ -672,21 +1566,51 @@ var RelayStore = class _RelayStore {
   deleteUser(userId) {
     const user = this.requireUser(userId);
     if (user.role === "admin") {
-      throw new RelayStoreError(400, "bad_request", "The admin user cannot be deleted.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "The admin user cannot be deleted."
+      );
+    }
+    const soleMembership = this.sqlite.prepare(
+      `SELECT hs.id
+         FROM relay_hosted_sandbox_members m
+         JOIN relay_hosted_sandboxes hs ON hs.id = m.sandbox_id
+         WHERE m.user_id = ?
+           AND (SELECT COUNT(*) FROM relay_hosted_sandbox_members all_members
+                WHERE all_members.sandbox_id = m.sandbox_id) = 1
+         LIMIT 1`
+    ).get(userId);
+    if (soleMembership) {
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "Reassign or delete the user's hosted VM before deleting this account."
+      );
     }
     this.sqlite.prepare("DELETE FROM relay_users WHERE id = ?").run(userId);
   }
   adminResetUserPassword(userId, password) {
     const user = this.requireUser(userId);
     if (user.role === "admin") {
-      throw new RelayStoreError(400, "bad_request", "The admin user password cannot be reset here.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "The admin user password cannot be reset here."
+      );
     }
     if (password.length < 8) {
-      throw new RelayStoreError(400, "bad_request", "Password must be at least 8 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Password must be at least 8 characters."
+      );
     }
     const passwordSalt = crypto.randomBytes(16).toString("base64url");
     const passwordHash = hashSecret(password, passwordSalt);
-    this.sqlite.prepare("UPDATE relay_users SET password_salt = ?, password_hash = ? WHERE id = ?").run(passwordSalt, passwordHash, user.id);
+    this.sqlite.prepare(
+      "UPDATE relay_users SET password_salt = ?, password_hash = ? WHERE id = ?"
+    ).run(passwordSalt, passwordHash, user.id);
     return this.publicUser({
       ...user,
       passwordSalt,
@@ -697,11 +1621,19 @@ var RelayStore = class _RelayStore {
     const user = this.requireUser(userId);
     const username = input.username !== void 0 ? normalizeUsername(input.username) : user.username;
     if (username.length < 3) {
-      throw new RelayStoreError(400, "bad_request", "Username must be at least 3 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Username must be at least 3 characters."
+      );
     }
     const existingUsername = this.getUserByUsername(username);
     if (existingUsername && existingUsername.id !== user.id) {
-      throw new RelayStoreError(409, "conflict", "A user with that username already exists.");
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "A user with that username already exists."
+      );
     }
     this.sqlite.prepare("UPDATE relay_users SET username = ? WHERE id = ?").run(username, user.id);
     return this.publicUser({ ...user, username });
@@ -709,14 +1641,24 @@ var RelayStore = class _RelayStore {
   updatePassword(userId, input) {
     const user = this.requireUser(userId);
     if (!verifySecret(input.currentPassword, user.passwordSalt, user.passwordHash)) {
-      throw new RelayStoreError(403, "forbidden", "Current password is incorrect.");
+      throw new RelayStoreError(
+        403,
+        "forbidden",
+        "Current password is incorrect."
+      );
     }
     if (input.newPassword.length < 8) {
-      throw new RelayStoreError(400, "bad_request", "Password must be at least 8 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Password must be at least 8 characters."
+      );
     }
     const passwordSalt = crypto.randomBytes(16).toString("base64url");
     const passwordHash = hashSecret(input.newPassword, passwordSalt);
-    this.sqlite.prepare("UPDATE relay_users SET password_salt = ?, password_hash = ? WHERE id = ?").run(passwordSalt, passwordHash, user.id);
+    this.sqlite.prepare(
+      "UPDATE relay_users SET password_salt = ?, password_hash = ? WHERE id = ?"
+    ).run(passwordSalt, passwordHash, user.id);
     return this.publicUser({
       ...user,
       passwordSalt,
@@ -731,16 +1673,25 @@ var RelayStore = class _RelayStore {
     };
   }
   publicDevice(device, status) {
+    const hosted = this.sqlite.prepare(
+      `
+          SELECT status, active_turn_count, idle_deadline_at
+          FROM relay_hosted_sandboxes WHERE device_id = ?
+        `
+    ).get(device.id);
     return {
       id: device.id,
       ownerUserId: device.ownerUserId,
       name: device.name,
-      token: device.token,
+      token: hosted ? null : device.token,
       tokenPreview: device.tokenPreview,
       connected: Boolean(status?.connected),
       connectedAt: status?.connectedAt ?? null,
       lastHeartbeatAt: status?.lastHeartbeatAt ?? null,
-      createdAt: device.createdAt
+      createdAt: device.createdAt,
+      hostedStatus: hosted?.status ?? null,
+      hostedActiveTurnCount: hosted?.active_turn_count ?? 0,
+      hostedIdleDeadlineAt: hosted?.idle_deadline_at ?? null
     };
   }
   publicAdminUser(user, deviceCount, conversationCount) {
@@ -772,7 +1723,14 @@ var RelayStore = class _RelayStore {
             id, share_id, user_id, username, kind, accessed_at
           ) VALUES (?, ?, ?, ?, ?, ?)
         `
-    ).run(crypto.randomUUID(), share.id, user.id, user.username, kind, accessedAt);
+    ).run(
+      crypto.randomUUID(),
+      share.id,
+      user.id,
+      user.username,
+      kind,
+      accessedAt
+    );
   }
   recordGrantAccess(grant, user, kind = "access") {
     if (grant.revokedAt || grant.expiresAt && grant.expiresAt <= (/* @__PURE__ */ new Date()).toISOString()) {
@@ -785,7 +1743,14 @@ var RelayStore = class _RelayStore {
             id, grant_id, user_id, username, kind, accessed_at
           ) VALUES (?, ?, ?, ?, ?, ?)
         `
-    ).run(crypto.randomUUID(), grant.id, user.id, user.username, kind, accessedAt);
+    ).run(
+      crypto.randomUUID(),
+      grant.id,
+      user.id,
+      user.username,
+      kind,
+      accessedAt
+    );
   }
   publicShare(share) {
     const owner = this.getUser(share.ownerUserId);
@@ -850,6 +1815,97 @@ var RelayStore = class _RelayStore {
 
       CREATE INDEX IF NOT EXISTS relay_devices_owner_idx ON relay_devices(owner_user_id);
 
+      CREATE TABLE IF NOT EXISTS relay_hosted_sandboxes (
+        id TEXT PRIMARY KEY,
+        device_id TEXT NOT NULL UNIQUE REFERENCES relay_devices(id) ON DELETE CASCADE,
+        assigned_user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE RESTRICT,
+        created_by_admin_user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE RESTRICT,
+        provider TEXT NOT NULL CHECK (provider IN ('incus')),
+        provider_instance_id TEXT,
+        image_version TEXT NOT NULL,
+        cpu_count INTEGER NOT NULL,
+        memory_mib INTEGER NOT NULL,
+        disk_gib INTEGER NOT NULL,
+        status TEXT NOT NULL CHECK (status IN (
+          'requested', 'creating', 'starting', 'provisioning', 'stopped',
+          'online', 'stopping', 'error', 'deleting'
+        )),
+        credential_ref TEXT NOT NULL,
+        codex_config_json TEXT,
+        last_error_code TEXT,
+        last_error_message TEXT,
+        active_turn_count INTEGER NOT NULL DEFAULT 0,
+        last_user_activity_at TEXT,
+        idle_deadline_at TEXT,
+        lifecycle_generation INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS relay_hosted_sandboxes_assigned_idx
+        ON relay_hosted_sandboxes(assigned_user_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS relay_hosted_sandboxes_status_idx
+        ON relay_hosted_sandboxes(status, updated_at);
+
+      CREATE TABLE IF NOT EXISTS relay_hosted_sandbox_members (
+        sandbox_id TEXT NOT NULL REFERENCES relay_hosted_sandboxes(id) ON DELETE CASCADE,
+        user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE CASCADE,
+        position INTEGER NOT NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (sandbox_id, user_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS relay_hosted_sandbox_members_user_idx
+        ON relay_hosted_sandbox_members(user_id, sandbox_id);
+
+      CREATE TABLE IF NOT EXISTS relay_hosted_user_workspaces (
+        sandbox_id TEXT NOT NULL REFERENCES relay_hosted_sandboxes(id) ON DELETE CASCADE,
+        user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE CASCADE,
+        workspace_id TEXT NOT NULL,
+        initial_workspace INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (sandbox_id, workspace_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS relay_hosted_user_workspaces_user_idx
+        ON relay_hosted_user_workspaces(sandbox_id, user_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS relay_hosted_user_threads (
+        sandbox_id TEXT NOT NULL REFERENCES relay_hosted_sandboxes(id) ON DELETE CASCADE,
+        user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE CASCADE,
+        thread_id TEXT NOT NULL,
+        workspace_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (sandbox_id, thread_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS relay_hosted_user_threads_user_idx
+        ON relay_hosted_user_threads(sandbox_id, user_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS relay_hosted_operations (
+        id TEXT PRIMARY KEY,
+        sandbox_id TEXT NOT NULL REFERENCES relay_hosted_sandboxes(id) ON DELETE CASCADE,
+        action TEXT NOT NULL CHECK (action IN (
+          'create', 'start', 'stop', 'snapshot', 'delete', 'rotate_credential'
+        )),
+        status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'succeeded', 'failed')),
+        error_code TEXT,
+        error_message TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS relay_hosted_operations_sandbox_idx
+        ON relay_hosted_operations(sandbox_id, created_at DESC);
+
+      CREATE TABLE IF NOT EXISTS relay_hosted_active_turns (
+        sandbox_id TEXT NOT NULL REFERENCES relay_hosted_sandboxes(id) ON DELETE CASCADE,
+        thread_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        PRIMARY KEY (sandbox_id, thread_id, turn_id)
+      );
+
       CREATE TABLE IF NOT EXISTS relay_shares (
         id TEXT PRIMARY KEY,
         owner_user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE CASCADE,
@@ -947,21 +2003,84 @@ var RelayStore = class _RelayStore {
         reviewed_by_user_id TEXT
       );
 
+      CREATE TABLE IF NOT EXISTS relay_user_identities (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL REFERENCES relay_users(id) ON DELETE CASCADE,
+        provider TEXT NOT NULL CHECK (provider IN ('google', 'github')),
+        provider_subject TEXT NOT NULL,
+        provider_email TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        UNIQUE(provider, provider_subject)
+      );
+
       CREATE INDEX IF NOT EXISTS relay_pending_registrations_status_idx ON relay_pending_registrations(status, created_at DESC);
     `);
     this.ensureColumn("relay_users", "last_seen_at", "TEXT");
+    this.ensureColumn("relay_pending_registrations", "provider", "TEXT NOT NULL DEFAULT 'password'");
+    this.ensureColumn("relay_pending_registrations", "provider_subject", "TEXT");
     this.ensureColumn("relay_devices", "token", "TEXT");
+    this.ensureColumn(
+      "relay_hosted_sandboxes",
+      "active_turn_count",
+      "INTEGER NOT NULL DEFAULT 0"
+    );
+    this.ensureColumn(
+      "relay_hosted_sandboxes",
+      "last_user_activity_at",
+      "TEXT"
+    );
+    this.ensureColumn("relay_hosted_sandboxes", "idle_deadline_at", "TEXT");
+    this.ensureColumn(
+      "relay_hosted_sandboxes",
+      "lifecycle_generation",
+      "INTEGER NOT NULL DEFAULT 0"
+    );
+    this.ensureColumn("relay_hosted_sandboxes", "codex_config_json", "TEXT");
+    this.ensureColumn(
+      "relay_hosted_sandboxes",
+      "workspace_isolation_enabled",
+      "INTEGER NOT NULL DEFAULT 0"
+    );
+    this.ensureColumn("relay_hosted_sandboxes", "running_since", "TEXT");
     this.ensureColumn("relay_shares", "thread_title", "TEXT");
     this.ensureColumn("relay_shares", "workspace_id", "TEXT");
     this.ensureColumn("relay_shares", "workspace_label", "TEXT");
-    this.ensureColumn("relay_shares", "thread_access", "TEXT NOT NULL DEFAULT 'control'");
-    this.ensureColumn("relay_shares", "workspace_access", "TEXT NOT NULL DEFAULT 'none'");
+    this.ensureColumn(
+      "relay_shares",
+      "thread_access",
+      "TEXT NOT NULL DEFAULT 'control'"
+    );
+    this.ensureColumn(
+      "relay_shares",
+      "workspace_access",
+      "TEXT NOT NULL DEFAULT 'none'"
+    );
     this.ensureColumn("relay_shares", "expires_at", "TEXT");
-    this.ensureColumn("relay_access_grants", "workspace_scope", "TEXT NOT NULL DEFAULT 'all'");
-    this.ensureColumn("relay_access_grants", "workspace_ids", "TEXT NOT NULL DEFAULT '[]'");
-    this.ensureColumn("relay_access_grants", "can_create_threads", "INTEGER NOT NULL DEFAULT 0");
-    this.ensureColumn("relay_share_access_events", "kind", "TEXT NOT NULL DEFAULT 'access'");
-    this.ensureColumn("relay_access_grant_events", "kind", "TEXT NOT NULL DEFAULT 'access'");
+    this.ensureColumn(
+      "relay_access_grants",
+      "workspace_scope",
+      "TEXT NOT NULL DEFAULT 'all'"
+    );
+    this.ensureColumn(
+      "relay_access_grants",
+      "workspace_ids",
+      "TEXT NOT NULL DEFAULT '[]'"
+    );
+    this.ensureColumn(
+      "relay_access_grants",
+      "can_create_threads",
+      "INTEGER NOT NULL DEFAULT 0"
+    );
+    this.ensureColumn(
+      "relay_share_access_events",
+      "kind",
+      "TEXT NOT NULL DEFAULT 'access'"
+    );
+    this.ensureColumn(
+      "relay_access_grant_events",
+      "kind",
+      "TEXT NOT NULL DEFAULT 'access'"
+    );
   }
   ensureColumn(table, column, definition) {
     const columns = this.sqlite.prepare(`PRAGMA table_info(${table})`).all();
@@ -970,6 +2089,59 @@ var RelayStore = class _RelayStore {
     }
     this.sqlite.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
   }
+  migrateHostedSandboxMembers() {
+    this.sqlite.transaction(() => {
+      const legacyRows = this.sqlite.prepare(
+        `SELECT id, device_id, assigned_user_id, created_by_admin_user_id, created_at
+           FROM relay_hosted_sandboxes`
+      ).all();
+      const insertMember = this.sqlite.prepare(
+        `INSERT OR IGNORE INTO relay_hosted_sandbox_members
+          (sandbox_id, user_id, position, created_at) VALUES (?, ?, 0, ?)`
+      );
+      const updateSandbox = this.sqlite.prepare(
+        `UPDATE relay_hosted_sandboxes SET assigned_user_id = ? WHERE id = ?`
+      );
+      const updateDevice = this.sqlite.prepare(
+        `UPDATE relay_devices SET owner_user_id = ? WHERE id = ?`
+      );
+      for (const row of legacyRows) {
+        if (row.assigned_user_id !== row.created_by_admin_user_id) {
+          insertMember.run(row.id, row.assigned_user_id, row.created_at);
+        }
+        updateSandbox.run(row.created_by_admin_user_id, row.id);
+        updateDevice.run(row.created_by_admin_user_id, row.device_id);
+      }
+    })();
+  }
+  requireHostedSandboxMembers(userIds) {
+    const uniqueIds = [...new Set(userIds)];
+    if (uniqueIds.length < 1 || uniqueIds.length > 20) {
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "A hosted VM requires between 1 and 20 assigned users."
+      );
+    }
+    if (uniqueIds.length !== userIds.length) {
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Assigned users must be unique."
+      );
+    }
+    return uniqueIds.map((userId) => {
+      const user = this.requireUser(userId);
+      if (user.role !== "user" || !user.enabled) {
+        throw new RelayStoreError(
+          400,
+          "bad_request",
+          "Hosted VMs can only be assigned to enabled user accounts."
+        );
+      }
+      return user;
+    });
+  }
   importLegacyJson(legacyJsonPath) {
     if (!legacyJsonPath || !fs.existsSync(legacyJsonPath)) {
       return;
@@ -979,7 +2151,9 @@ var RelayStore = class _RelayStore {
     if (existingUsers.count > 0 || imported === legacyJsonPath) {
       return;
     }
-    const parsed = JSON.parse(fs.readFileSync(legacyJsonPath, "utf8"));
+    const parsed = JSON.parse(
+      fs.readFileSync(legacyJsonPath, "utf8")
+    );
     const data = {
       registrationEnabled: typeof parsed.registrationEnabled === "boolean" ? parsed.registrationEnabled : true,
       users: Array.isArray(parsed.users) ? parsed.users : [],
@@ -987,7 +2161,10 @@ var RelayStore = class _RelayStore {
       shares: Array.isArray(parsed.shares) ? parsed.shares : []
     };
     const importData = this.sqlite.transaction(() => {
-      this.setSetting("registrationEnabled", data.registrationEnabled ? "true" : "false");
+      this.setSetting(
+        "registrationEnabled",
+        data.registrationEnabled ? "true" : "false"
+      );
       for (const user of data.users) {
         this.insertUser(user);
       }
@@ -1003,7 +2180,10 @@ var RelayStore = class _RelayStore {
   }
   ensureRegistrationSetting(registrationEnabled) {
     if (this.getSetting("registrationEnabled") === null) {
-      this.setSetting("registrationEnabled", registrationEnabled ? "true" : "false");
+      this.setSetting(
+        "registrationEnabled",
+        registrationEnabled ? "true" : "false"
+      );
     }
   }
   registrationEnabled() {
@@ -1014,7 +2194,9 @@ var RelayStore = class _RelayStore {
     return row?.value ?? null;
   }
   setSetting(key, value) {
-    this.sqlite.prepare("INSERT INTO relay_settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+    this.sqlite.prepare(
+      "INSERT INTO relay_settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run(key, value);
   }
   deleteSetting(key) {
     this.sqlite.prepare("DELETE FROM relay_settings WHERE key = ?").run(key);
@@ -1023,16 +2205,32 @@ var RelayStore = class _RelayStore {
     const email = input.email.trim().toLowerCase();
     const username = normalizeUsername(input.username);
     if (!email.includes("@")) {
-      throw new RelayStoreError(400, "bad_request", "A valid email address is required.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "A valid email address is required."
+      );
     }
     if (username.length < 3) {
-      throw new RelayStoreError(400, "bad_request", "Username must be at least 3 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Username must be at least 3 characters."
+      );
     }
     if (input.password.length < 8) {
-      throw new RelayStoreError(400, "bad_request", "Password must be at least 8 characters.");
+      throw new RelayStoreError(
+        400,
+        "bad_request",
+        "Password must be at least 8 characters."
+      );
     }
     if (this.getUserByIdentifier(email) || this.getUserByUsername(username)) {
-      throw new RelayStoreError(409, "conflict", "A user with that email or username already exists.");
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "A user with that email or username already exists."
+      );
     }
     const passwordSalt = crypto.randomBytes(16).toString("base64url");
     return {
@@ -1064,7 +2262,9 @@ var RelayStore = class _RelayStore {
       expiresAt: Date.now() + SESSION_TTL_MS,
       nonce: crypto.randomBytes(16).toString("base64url")
     };
-    const payloadText = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    const payloadText = Buffer.from(JSON.stringify(payload), "utf8").toString(
+      "base64url"
+    );
     const signature = crypto.createHmac("sha256", this.sessionSecret).update(payloadText).digest("base64url");
     return `${payloadText}.${signature}`;
   }
@@ -1078,7 +2278,9 @@ var RelayStore = class _RelayStore {
       return null;
     }
     try {
-      const payload = JSON.parse(Buffer.from(payloadText, "base64url").toString("utf8"));
+      const payload = JSON.parse(
+        Buffer.from(payloadText, "base64url").toString("utf8")
+      );
       if (typeof payload?.userId !== "string" || typeof payload?.expiresAt !== "number" || typeof payload?.nonce !== "string" || payload.expiresAt <= Date.now()) {
         return null;
       }
@@ -1140,6 +2342,34 @@ var RelayStore = class _RelayStore {
       device.createdAt
     );
   }
+  insertHostedOperation(operation) {
+    this.sqlite.prepare(
+      `
+          INSERT INTO relay_hosted_operations (
+            id, sandbox_id, action, status, error_code, error_message,
+            created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `
+    ).run(
+      operation.id,
+      operation.sandboxId,
+      operation.action,
+      operation.status,
+      operation.errorCode,
+      operation.errorMessage,
+      operation.createdAt,
+      operation.updatedAt
+    );
+  }
+  getHostedOperation(id) {
+    const row = this.sqlite.prepare("SELECT * FROM relay_hosted_operations WHERE id = ?").get(id);
+    return row ? this.rowToHostedOperation(row) : null;
+  }
+  getHostedOperations(sandboxId) {
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_hosted_operations WHERE sandbox_id = ? ORDER BY created_at DESC"
+    ).all(sandboxId).map((row) => this.rowToHostedOperation(row));
+  }
   insertShare(share) {
     this.sqlite.prepare(
       `
@@ -1308,7 +2538,9 @@ var RelayStore = class _RelayStore {
     );
   }
   getUser(id) {
-    return this.rowToUser(this.sqlite.prepare("SELECT * FROM relay_users WHERE id = ?").get(id));
+    return this.rowToUser(
+      this.sqlite.prepare("SELECT * FROM relay_users WHERE id = ?").get(id)
+    );
   }
   getUserByIdentifier(identifier) {
     return this.rowToUser(
@@ -1324,19 +2556,37 @@ var RelayStore = class _RelayStore {
     return this.sqlite.prepare("SELECT * FROM relay_users ORDER BY created_at ASC").all().map((row) => this.rowToUser(row)).filter((user) => Boolean(user));
   }
   getDevice(id) {
-    return this.rowToDevice(this.sqlite.prepare("SELECT * FROM relay_devices WHERE id = ?").get(id));
+    return this.rowToDevice(
+      this.sqlite.prepare("SELECT * FROM relay_devices WHERE id = ?").get(id)
+    );
   }
   getDevices() {
     return this.sqlite.prepare("SELECT * FROM relay_devices ORDER BY created_at ASC").all().map((row) => this.rowToDevice(row)).filter((device) => Boolean(device));
   }
   getDevicesByOwner(ownerUserId) {
-    return this.sqlite.prepare("SELECT * FROM relay_devices WHERE owner_user_id = ? ORDER BY created_at ASC").all(ownerUserId).map((row) => this.rowToDevice(row)).filter((device) => Boolean(device));
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_devices WHERE owner_user_id = ? ORDER BY created_at ASC"
+    ).all(ownerUserId).map((row) => this.rowToDevice(row)).filter((device) => Boolean(device));
+  }
+  getHostedDevicesByMember(userId) {
+    return this.sqlite.prepare(
+      `SELECT d.*
+           FROM relay_hosted_sandbox_members m
+           JOIN relay_hosted_sandboxes hs ON hs.id = m.sandbox_id
+           JOIN relay_devices d ON d.id = hs.device_id
+           WHERE m.user_id = ?
+           ORDER BY d.created_at ASC`
+    ).all(userId).map((row) => this.rowToDevice(row)).filter((device) => Boolean(device));
   }
   getSharesByOwner(ownerUserId) {
-    return this.sqlite.prepare("SELECT * FROM relay_shares WHERE owner_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC").all(ownerUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToShare(row)).filter((share) => Boolean(share));
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_shares WHERE owner_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC"
+    ).all(ownerUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToShare(row)).filter((share) => Boolean(share));
   }
   getSharesByTarget(targetUserId) {
-    return this.sqlite.prepare("SELECT * FROM relay_shares WHERE target_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC").all(targetUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToShare(row)).filter((share) => Boolean(share));
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_shares WHERE target_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC"
+    ).all(targetUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToShare(row)).filter((share) => Boolean(share));
   }
   getShares(options = {}) {
     const sql = options.includeRevoked ? "SELECT * FROM relay_shares ORDER BY created_at DESC" : "SELECT * FROM relay_shares WHERE revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at DESC";
@@ -1344,10 +2594,14 @@ var RelayStore = class _RelayStore {
     return rows.map((row) => this.rowToShare(row)).filter((share) => Boolean(share));
   }
   getGrantsByOwner(ownerUserId) {
-    return this.sqlite.prepare("SELECT * FROM relay_access_grants WHERE owner_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC").all(ownerUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToGrant(row)).filter((grant) => Boolean(grant));
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_access_grants WHERE owner_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC"
+    ).all(ownerUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToGrant(row)).filter((grant) => Boolean(grant));
   }
   getGrantsByTarget(targetUserId) {
-    return this.sqlite.prepare("SELECT * FROM relay_access_grants WHERE target_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC").all(targetUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToGrant(row)).filter((grant) => Boolean(grant));
+    return this.sqlite.prepare(
+      "SELECT * FROM relay_access_grants WHERE target_user_id = ? AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at ASC"
+    ).all(targetUserId, (/* @__PURE__ */ new Date()).toISOString()).map((row) => this.rowToGrant(row)).filter((grant) => Boolean(grant));
   }
   findBestGrant(userId, deviceId, scope) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1372,7 +2626,9 @@ var RelayStore = class _RelayStore {
         `
     ).all(userId, deviceId, now);
     const grants = rows.map((row) => this.rowToGrant(row)).filter((grant) => Boolean(grant));
-    const matchingGrants = grants.filter((grant) => this.grantMatchesScope(grant, scope));
+    const matchingGrants = grants.filter(
+      (grant) => this.grantMatchesScope(grant, scope)
+    );
     return matchingGrants.length > 0 ? mergeMatchingGrants(matchingGrants, scope) : null;
   }
   grantMatchesScope(grant, scope) {
@@ -1445,7 +2701,9 @@ var RelayStore = class _RelayStore {
     };
   }
   conversationCountsByUser(days) {
-    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    const since = new Date(
+      Date.now() - days * 24 * 60 * 60 * 1e3
+    ).toISOString();
     const rows = this.sqlite.prepare(
       `
           SELECT user_id, COUNT(*) AS count
@@ -1467,13 +2725,23 @@ var RelayStore = class _RelayStore {
   }
   requirePendingRegistration(id) {
     const record = this.rowToPendingRegistration(
-      this.sqlite.prepare("SELECT * FROM relay_pending_registrations WHERE id = ? AND status = 'pending'").get(id)
+      this.sqlite.prepare(
+        "SELECT * FROM relay_pending_registrations WHERE id = ? AND status = 'pending'"
+      ).get(id)
     );
     if (!record) {
-      throw new RelayStoreError(404, "not_found", "Pending registration was not found.");
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Pending registration was not found."
+      );
     }
     if (this.getUserByIdentifier(record.email) || this.getUserByUsername(record.username)) {
-      throw new RelayStoreError(409, "conflict", "A user with that email or username already exists.");
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "A user with that email or username already exists."
+      );
     }
     return record;
   }
@@ -1482,7 +2750,8 @@ var RelayStore = class _RelayStore {
       id: record.id,
       email: record.email,
       username: record.username,
-      createdAt: record.createdAt
+      createdAt: record.createdAt,
+      provider: record.provider
     };
   }
   insertPendingRegistration(record) {
@@ -1490,8 +2759,8 @@ var RelayStore = class _RelayStore {
       `
           INSERT INTO relay_pending_registrations (
             id, email, username, password_salt, password_hash,
-            created_at, status, reviewed_at, reviewed_by_user_id
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            created_at, status, reviewed_at, reviewed_by_user_id, provider, provider_subject
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `
     ).run(
       record.id,
@@ -1502,9 +2771,32 @@ var RelayStore = class _RelayStore {
       record.createdAt,
       record.status,
       record.reviewedAt,
-      record.reviewedByUserId
+      record.reviewedByUserId,
+      record.provider,
+      record.providerSubject
     );
   }
+  insertIdentity(userId, provider, subject, email) {
+    this.sqlite.prepare(`
+      INSERT INTO relay_user_identities (
+        id, user_id, provider, provider_subject, provider_email, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run(crypto.randomUUID(), userId, provider, subject, email, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  availableUsername(input) {
+    const base = normalizeUsername(input).slice(0, 48) || "user";
+    let candidate = base.length >= 3 ? base : `${base}user`;
+    let suffix = 1;
+    const isTaken = (username) => Boolean(
+      this.getUserByUsername(username) || this.sqlite.prepare(
+        "SELECT 1 FROM relay_pending_registrations WHERE username = ? AND status = 'pending' LIMIT 1"
+      ).get(username)
+    );
+    while (isTaken(candidate)) {
+      candidate = `${base.slice(0, 42)}-${suffix++}`;
+    }
+    return candidate;
+  }
   rowToUser(row) {
     if (!row) return null;
     return {
@@ -1531,6 +2823,60 @@ var RelayStore = class _RelayStore {
       createdAt: row.created_at
     };
   }
+  rowToHostedSandbox(row) {
+    const assignedUsers = this.sqlite.prepare(
+      `SELECT u.*
+           FROM relay_hosted_sandbox_members m
+           JOIN relay_users u ON u.id = m.user_id
+           WHERE m.sandbox_id = ?
+           ORDER BY m.position ASC, m.created_at ASC`
+    ).all(row.id).map((userRow) => this.rowToUser(userRow)).filter((user) => Boolean(user)).map((user) => ({
+      userId: user.id,
+      username: user.username,
+      email: user.email
+    }));
+    const primaryUser = assignedUsers[0];
+    const device = this.getDevice(row.device_id);
+    return {
+      id: row.id,
+      deviceId: row.device_id,
+      deviceName: device?.name ?? "Hosted supervisor VM",
+      assignedUserId: primaryUser?.userId ?? row.assigned_user_id,
+      assignedUsername: primaryUser?.username ?? "unknown",
+      assignedUsers,
+      workspaceIsolationEnabled: Boolean(row.workspace_isolation_enabled),
+      createdByAdminUserId: row.created_by_admin_user_id,
+      provider: "incus",
+      providerInstanceId: row.provider_instance_id,
+      imageVersion: row.image_version,
+      resources: {
+        cpuCount: row.cpu_count,
+        memoryMiB: row.memory_mib,
+        diskGiB: row.disk_gib
+      },
+      status: row.status,
+      lastErrorCode: row.last_error_code,
+      lastErrorMessage: row.last_error_message,
+      activeTurnCount: row.active_turn_count,
+      lastUserActivityAt: row.last_user_activity_at,
+      idleDeadlineAt: row.idle_deadline_at,
+      runningSince: row.running_since,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToHostedOperation(row) {
+    return {
+      id: row.id,
+      sandboxId: row.sandbox_id,
+      action: row.action,
+      status: row.status,
+      errorCode: row.error_code,
+      errorMessage: row.error_message,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
   rowToShare(row) {
     if (!row) return null;
     return {
@@ -1596,10 +2942,32 @@ var RelayStore = class _RelayStore {
       createdAt: row.created_at,
       status: row.status,
       reviewedAt: row.reviewed_at ?? null,
-      reviewedByUserId: row.reviewed_by_user_id ?? null
+      reviewedByUserId: row.reviewed_by_user_id ?? null,
+      provider: row.provider ?? "password",
+      providerSubject: row.provider_subject ?? null
     };
   }
 };
+function parseHostedCodexConfig(value) {
+  const fallback = {
+    modelProvider: "OpenAI",
+    model: "gpt-5.4",
+    reviewModel: "gpt-5.4",
+    reasoningEffort: "medium",
+    baseUrl: "https://api.openai.com/v1",
+    wireApi: "responses",
+    requiresOpenaiAuth: true,
+    disableResponseStorage: true,
+    networkAccess: "enabled",
+    goals: true
+  };
+  if (!value) return fallback;
+  try {
+    return { ...fallback, ...JSON.parse(value) };
+  } catch {
+    return fallback;
+  }
+}
 var RelayStoreError = class extends Error {
   constructor(statusCode, code, message) {
     super(message);
@@ -1634,7 +3002,9 @@ function normalizeWorkspaceIds(values) {
   if (!Array.isArray(values)) {
     return [];
   }
-  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean))).sort();
+  return Array.from(
+    new Set(values.map((value) => value.trim()).filter(Boolean))
+  ).sort();
 }
 function mergeMatchingGrants(grants, scope) {
   const sorted = [...grants].sort(compareGrantCapability);
@@ -1710,7 +3080,9 @@ function parseWorkspaceIds(value) {
   }
   try {
     const parsed = JSON.parse(value);
-    return normalizeWorkspaceIds(Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : []);
+    return normalizeWorkspaceIds(
+      Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : []
+    );
   } catch {
     return [];
   }
@@ -1755,10 +3127,554 @@ function safeEqual(left, right) {
   return crypto.timingSafeEqual(leftBuffer, rightBuffer);
 }
 
+// src/hosted-sandbox-reconciler.ts
+var HostedSandboxReconciler = class {
+  constructor(store, provider, config2) {
+    this.store = store;
+    this.provider = provider;
+    this.config = config2;
+  }
+  store;
+  provider;
+  config;
+  latest = emptyReport();
+  timer = null;
+  inFlight = null;
+  start() {
+    if (this.timer || this.config.provider === "disabled") return;
+    void this.run();
+    this.timer = setInterval(
+      () => void this.run(),
+      this.config.reconcileIntervalMs
+    );
+    this.timer.unref?.();
+  }
+  close() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+  read() {
+    return this.latest;
+  }
+  run() {
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = this.performAudit().finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  async deleteOrphanInstance(id) {
+    const report = await this.run();
+    if (!report.orphanInstances.some((instance) => instance.id === id)) {
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "The instance is no longer an orphan."
+      );
+    }
+    await this.provider.delete(id, `relay-orphan-instance-delete-${id}`);
+    return this.performAudit();
+  }
+  async deleteOrphanCredential(credentialRef) {
+    const report = await this.run();
+    if (!report.orphanCredentials.some(
+      (credential) => credential.credentialRef === credentialRef
+    )) {
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "The credential is no longer an orphan."
+      );
+    }
+    await this.provider.deleteCredential(
+      credentialRef,
+      `relay-orphan-credential-delete-${credentialRef}`
+    );
+    return this.performAudit();
+  }
+  async performAudit() {
+    try {
+      const expected = this.store.listHostedProviderRecords();
+      const inventory = await this.provider.inventory();
+      const expectedIds = new Set(expected.map((record) => record.id));
+      const expectedCredentials = new Set(
+        expected.map((record) => record.credentialRef)
+      );
+      const instanceIds = new Set(
+        inventory.instances.map((instance) => instance.id)
+      );
+      const credentialRefs = new Set(
+        inventory.credentials.map((credential) => credential.credentialRef)
+      );
+      const orphanInstances = inventory.instances.filter(
+        (instance) => !expectedIds.has(instance.id)
+      );
+      const orphanCredentials = inventory.credentials.filter(
+        (credential) => !expectedCredentials.has(credential.credentialRef)
+      );
+      const missingInstanceSandboxIds = expected.filter((record) => !instanceIds.has(record.id)).map((record) => record.id);
+      const missingCredentialSandboxIds = expected.filter((record) => !credentialRefs.has(record.credentialRef)).map((record) => record.id);
+      const hasIssues = orphanInstances.length > 0 || orphanCredentials.length > 0 || missingInstanceSandboxIds.length > 0 || missingCredentialSandboxIds.length > 0;
+      this.latest = {
+        status: hasIssues ? "issues" : "healthy",
+        checkedAt: inventory.checkedAt,
+        errorCode: null,
+        missingInstanceSandboxIds,
+        missingCredentialSandboxIds,
+        orphanInstances,
+        orphanCredentials,
+        orphanSnapshotCount: orphanInstances.reduce(
+          (count, instance) => count + instance.snapshots.length,
+          0
+        )
+      };
+    } catch {
+      this.latest = {
+        ...emptyReport(),
+        status: "unavailable",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        errorCode: "hosted_inventory_unavailable"
+      };
+    }
+    return this.latest;
+  }
+};
+function emptyReport() {
+  return {
+    status: "never_run",
+    checkedAt: null,
+    errorCode: null,
+    missingInstanceSandboxIds: [],
+    missingCredentialSandboxIds: [],
+    orphanInstances: [],
+    orphanCredentials: [],
+    orphanSnapshotCount: 0
+  };
+}
+
+// src/hosted-sandbox-service.ts
+import crypto2 from "crypto";
+var HostedSandboxService = class {
+  constructor(store, provider, config2) {
+    this.store = store;
+    this.provider = provider;
+    this.config = config2;
+  }
+  store;
+  provider;
+  config;
+  running = /* @__PURE__ */ new Map();
+  idleTimers = /* @__PURE__ */ new Map();
+  list() {
+    return this.store.listHostedSandboxes();
+  }
+  detail(id) {
+    const detail = this.store.getHostedSandboxDetail(id);
+    if (!detail) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+    return detail;
+  }
+  async create(input) {
+    this.requireConfiguredRelayUrl();
+    const requestId = crypto2.randomUUID();
+    const credentialRef = await this.provider.createCodexCredential(
+      input.codexFiles,
+      `relay-credential-${requestId}`
+    );
+    try {
+      const created = this.store.createHostedSandboxRequested({
+        createdByAdminUserId: input.createdByAdminUserId,
+        assignedUserIds: input.assignedUserIds,
+        deviceName: input.deviceName,
+        imageVersion: input.imageVersion,
+        resources: input.resources,
+        credentialRef
+      });
+      this.schedule(created.sandbox.id, created.operation.id);
+      return {
+        sandbox: created.sandbox,
+        operation: created.operation
+      };
+    } catch (error) {
+      await this.provider.deleteCredential(
+        credentialRef,
+        `relay-credential-compensate-${requestId}`
+      ).catch(() => void 0);
+      throw error;
+    }
+  }
+  updateMembers(id, userIds) {
+    return this.store.setHostedSandboxMembers(id, userIds);
+  }
+  readCodexFiles(id) {
+    this.detail(id);
+    return this.provider.readCodexFiles(id);
+  }
+  async writeCodexFiles(id, files) {
+    this.detail(id);
+    await this.provider.writeCodexFiles(
+      id,
+      files,
+      `relay-codex-files-${crypto2.randomUUID()}`
+    );
+    return { updated: true };
+  }
+  retry(id) {
+    this.detail(id);
+    const operation = this.store.createHostedOperation(id, "create");
+    this.store.updateHostedSandboxStatus(id, "requested");
+    this.schedule(id, operation.id);
+    return operation;
+  }
+  start(id) {
+    const detail = this.detail(id);
+    this.store.recordHostedUserActivity(
+      detail.deviceId,
+      this.config.idleTimeoutMs
+    );
+    const operation = this.store.createHostedOperation(id, "start");
+    this.scheduleLifecycle(id, operation, async () => {
+      this.store.updateHostedSandboxStatus(id, "starting");
+      await this.provider.start(
+        id,
+        `relay-sandbox-start-action-${operation.id}`
+      );
+      this.store.updateHostedSandboxStatus(id, "starting");
+    });
+    return operation;
+  }
+  stop(id) {
+    this.detail(id);
+    const operation = this.store.createHostedOperation(id, "stop");
+    this.scheduleLifecycle(id, operation, async () => {
+      this.store.updateHostedSandboxStatus(id, "stopping");
+      await this.provider.stop(id, `relay-sandbox-stop-action-${operation.id}`);
+      this.store.updateHostedSandboxStatus(id, "stopped");
+    });
+    return operation;
+  }
+  snapshot(id, name) {
+    this.detail(id);
+    const operation = this.store.createHostedOperation(id, "snapshot");
+    this.scheduleLifecycle(
+      id,
+      operation,
+      () => this.provider.snapshot(
+        id,
+        name,
+        `relay-sandbox-snapshot-${operation.id}`
+      )
+    );
+    return operation;
+  }
+  delete(id) {
+    const context = this.store.getHostedProvisionContext(id);
+    if (!context) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+    const operation = this.store.createHostedOperation(id, "delete");
+    this.scheduleLifecycle(
+      id,
+      operation,
+      async () => {
+        this.store.updateHostedSandboxStatus(id, "deleting");
+        await this.provider.delete(id, `relay-sandbox-delete-${operation.id}`);
+        await this.provider.deleteCredential(
+          context.credentialRef,
+          `relay-credential-delete-${operation.id}`
+        );
+        this.store.updateHostedOperation(operation.id, "succeeded");
+        this.store.deleteHostedSandboxRecord(id);
+      },
+      { operationCompletesInside: true }
+    );
+    return operation;
+  }
+  async rotateCredential(id, openaiApiKey) {
+    const context = this.store.getHostedProvisionContext(id);
+    if (!context) {
+      throw new RelayStoreError(
+        404,
+        "not_found",
+        "Hosted sandbox was not found."
+      );
+    }
+    if (this.running.has(id)) {
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "Another Hosted supervisor VM operation is already running."
+      );
+    }
+    const relayServerUrl = this.requireConfiguredRelayUrl();
+    const operation = this.store.createHostedOperation(id, "rotate_credential");
+    let credentialRef;
+    try {
+      credentialRef = await this.provider.createCredential(
+        openaiApiKey,
+        `relay-credential-rotate-${operation.id}`
+      );
+    } catch {
+      this.store.updateHostedOperation(operation.id, "failed", {
+        code: "hosted_sandbox_rotate_credential_failed",
+        message: "Hosted supervisor VM credential rotation failed."
+      });
+      throw new RelayStoreError(
+        502,
+        "service_unavailable",
+        "Hosted supervisor VM credential rotation failed."
+      );
+    }
+    this.scheduleLifecycle(id, operation, async () => {
+      await this.provider.provision(
+        {
+          id,
+          relayServerUrl,
+          relayAgentToken: context.deviceToken,
+          credentialRef,
+          codexConfig: context.codexConfig
+        },
+        `relay-sandbox-reprovision-${operation.id}`
+      );
+      const previousRef = this.store.replaceHostedCredentialRef(
+        id,
+        credentialRef
+      );
+      await this.provider.deleteCredential(
+        previousRef,
+        `relay-credential-retire-${operation.id}`
+      );
+    });
+    return operation;
+  }
+  reconcilePending() {
+    for (const id of this.store.listHostedSandboxesNeedingReconciliation()) {
+      const detail = this.store.getHostedSandboxDetail(id);
+      const operation = detail?.operations.find((candidate) => candidate.action === "create") ?? this.store.createHostedOperation(id, "create");
+      this.schedule(id, operation.id);
+    }
+    this.restoreIdleTimers();
+  }
+  close() {
+    for (const timer of this.idleTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.idleTimers.clear();
+  }
+  markOnline(deviceId) {
+    this.store.markHostedDeviceOnline(deviceId);
+    const sandbox = this.store.getHostedSandboxByDeviceId(deviceId);
+    if (!sandbox) return;
+    const armed = this.store.armHostedIdleDeadline(
+      sandbox.id,
+      this.config.idleTimeoutMs
+    );
+    if (armed?.idleDeadlineAt) {
+      this.scheduleIdleTimer(armed.id, armed.idleDeadlineAt);
+    }
+  }
+  recordUserActivity(deviceId) {
+    const sandbox = this.store.recordHostedUserActivity(
+      deviceId,
+      this.config.idleTimeoutMs
+    );
+    if (!sandbox) return { hosted: false, waking: false };
+    if (sandbox.idleDeadlineAt && sandbox.status === "online") {
+      this.scheduleIdleTimer(sandbox.id, sandbox.idleDeadlineAt);
+    }
+    if (sandbox.status === "stopped") {
+      this.start(sandbox.id);
+      return { hosted: true, waking: true };
+    }
+    return {
+      hosted: true,
+      waking: ["requested", "creating", "starting", "provisioning"].includes(
+        sandbox.status
+      )
+    };
+  }
+  wakeIfStopped(deviceId) {
+    const sandbox = this.store.getHostedSandboxByDeviceId(deviceId);
+    if (!sandbox) return { hosted: false, waking: false };
+    if (sandbox.status === "stopped") {
+      this.start(sandbox.id);
+      return { hosted: true, waking: true };
+    }
+    return {
+      hosted: true,
+      waking: ["requested", "creating", "starting", "provisioning"].includes(
+        sandbox.status
+      )
+    };
+  }
+  recordTurnActivity(input) {
+    const sandbox = this.store.recordHostedTurnActivity({
+      ...input,
+      idleTimeoutMs: this.config.idleTimeoutMs
+    });
+    if (!sandbox) return;
+    if (sandbox.activeTurnCount > 0) {
+      this.clearIdleTimer(sandbox.id);
+    } else if (sandbox.idleDeadlineAt && sandbox.status === "online") {
+      this.scheduleIdleTimer(sandbox.id, sandbox.idleDeadlineAt);
+    }
+  }
+  schedule(sandboxId, operationId) {
+    if (this.running.has(sandboxId)) {
+      return;
+    }
+    const promise = this.runCreateSaga(sandboxId, operationId).finally(() => {
+      this.running.delete(sandboxId);
+    });
+    this.running.set(sandboxId, promise);
+  }
+  scheduleLifecycle(sandboxId, operation, action, options = {}) {
+    if (this.running.has(sandboxId)) {
+      throw new RelayStoreError(
+        409,
+        "conflict",
+        "Another Hosted supervisor VM operation is already running."
+      );
+    }
+    const promise = (async () => {
+      try {
+        this.store.updateHostedOperation(operation.id, "running");
+        await action();
+        if (!options.operationCompletesInside) {
+          this.store.updateHostedOperation(operation.id, "succeeded");
+        }
+      } catch {
+        const error = {
+          code: `hosted_sandbox_${operation.action}_failed`,
+          message: `Hosted supervisor VM ${operation.action} failed.`
+        };
+        this.store.updateHostedOperation(operation.id, "failed", error);
+        this.store.updateHostedSandboxStatus(sandboxId, "error", {
+          errorCode: error.code,
+          errorMessage: error.message
+        });
+      }
+    })().finally(() => this.running.delete(sandboxId));
+    this.running.set(sandboxId, promise);
+  }
+  restoreIdleTimers() {
+    for (const candidate of this.store.listHostedIdleDeadlines()) {
+      const normalized = this.store.armHostedIdleDeadline(
+        candidate.id,
+        this.config.idleTimeoutMs
+      );
+      if (normalized?.idleDeadlineAt && normalized.status === "online") {
+        this.scheduleIdleTimer(normalized.id, normalized.idleDeadlineAt);
+      }
+    }
+  }
+  scheduleIdleTimer(sandboxId, deadlineAt) {
+    this.clearIdleTimer(sandboxId);
+    const delay = Math.max(0, new Date(deadlineAt).getTime() - Date.now());
+    const timer = setTimeout(() => {
+      this.idleTimers.delete(sandboxId);
+      void this.handleIdleDeadline(sandboxId);
+    }, delay);
+    timer.unref?.();
+    this.idleTimers.set(sandboxId, timer);
+  }
+  clearIdleTimer(sandboxId) {
+    const timer = this.idleTimers.get(sandboxId);
+    if (timer) clearTimeout(timer);
+    this.idleTimers.delete(sandboxId);
+  }
+  async handleIdleDeadline(sandboxId) {
+    if (this.running.has(sandboxId)) return;
+    const candidate = this.store.listHostedIdleDeadlines().find((entry) => entry.id === sandboxId);
+    if (!candidate || !this.store.claimHostedIdleStop(
+      sandboxId,
+      candidate.generation,
+      /* @__PURE__ */ new Date()
+    )) {
+      return;
+    }
+    const operation = this.store.createHostedOperation(sandboxId, "stop");
+    this.scheduleLifecycle(sandboxId, operation, async () => {
+      await this.provider.stop(
+        sandboxId,
+        `relay-sandbox-idle-stop-${operation.id}`
+      );
+      this.store.updateHostedSandboxStatus(sandboxId, "stopped");
+    });
+  }
+  async runCreateSaga(sandboxId, operationId) {
+    try {
+      const context = this.store.getHostedProvisionContext(sandboxId);
+      if (!context) {
+        throw new Error("Hosted sandbox provision context is unavailable.");
+      }
+      const relayServerUrl = this.requireConfiguredRelayUrl();
+      this.store.updateHostedOperation(operationId, "running");
+      this.store.updateHostedSandboxStatus(sandboxId, "creating");
+      const instance = await this.provider.create(
+        {
+          id: sandboxId,
+          imageVersion: context.sandbox.imageVersion,
+          resources: context.sandbox.resources
+        },
+        `relay-sandbox-create-${sandboxId}`
+      );
+      this.store.updateHostedSandboxStatus(sandboxId, "starting", {
+        providerInstanceId: instance.name
+      });
+      await this.provider.start(sandboxId, `relay-sandbox-start-${sandboxId}`);
+      this.store.updateHostedSandboxStatus(sandboxId, "provisioning");
+      await this.provider.provision(
+        {
+          id: sandboxId,
+          relayServerUrl,
+          relayAgentToken: context.deviceToken,
+          credentialRef: context.credentialRef,
+          codexConfig: context.codexConfig
+        },
+        `relay-sandbox-provision-${sandboxId}`
+      );
+      this.store.updateHostedOperation(operationId, "succeeded");
+      this.store.updateHostedSandboxStatus(sandboxId, "starting");
+    } catch (caught) {
+      const detail = caught instanceof HostedSandboxProviderError && caught.code === "running_instance_limit_reached" ? caught.message : null;
+      const error = {
+        code: "hosted_sandbox_create_failed",
+        message: detail ? `Hosted supervisor VM creation failed: ${detail}` : "Hosted supervisor VM creation failed."
+      };
+      this.store.updateHostedOperation(operationId, "failed", error);
+      this.store.updateHostedSandboxStatus(sandboxId, "error", {
+        errorCode: error.code,
+        errorMessage: error.message
+      });
+    }
+  }
+  requireConfiguredRelayUrl() {
+    if (!this.config.relayServerUrl) {
+      throw new RelayStoreError(
+        503,
+        "service_unavailable",
+        "Hosted supervisor VM relay URL is not configured."
+      );
+    }
+    return this.config.relayServerUrl;
+  }
+};
+
 // src/app.ts
 var RELAY_REQUEST_TIMEOUT_MS = 3e4;
 var RELAY_PORTAL_METADATA_TIMEOUT_MS = 900;
 var WEBSOCKET_OPEN = 1;
+var hostedBootstrapPromises = /* @__PURE__ */ new Map();
 var RELAY_COOKIE_NAME = "remote_codex_relay_session";
 var threadAccessSchema = z.enum(["read", "control"]);
 var workspaceAccessSchema = z.enum(["none", "read", "write"]);
@@ -1777,6 +3693,62 @@ var registerSchema = z.object({
 var createDeviceSchema = z.object({
   name: z.string().trim().min(1).max(120)
 });
+var hostedCodexConfigSchema = z.object({
+  modelProvider: z.string().regex(/^[A-Za-z][A-Za-z0-9_-]{0,31}$/),
+  model: z.string().trim().min(1).max(120),
+  reviewModel: z.string().trim().min(1).max(120),
+  reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]),
+  baseUrl: z.string().url().refine((value) => value.startsWith("https://"), "HTTPS is required."),
+  wireApi: z.literal("responses"),
+  requiresOpenaiAuth: z.boolean(),
+  disableResponseStorage: z.boolean(),
+  networkAccess: z.enum(["enabled", "disabled"]),
+  goals: z.boolean()
+}).strict().default({
+  modelProvider: "OpenAI",
+  model: "gpt-5.4",
+  reviewModel: "gpt-5.4",
+  reasoningEffort: "medium",
+  baseUrl: "https://api.openai.com/v1",
+  wireApi: "responses",
+  requiresOpenaiAuth: true,
+  disableResponseStorage: true,
+  networkAccess: "enabled",
+  goals: true
+});
+var createHostedSandboxSchema = z.object({
+  assignedUserIds: z.array(z.string().uuid()).min(1).max(20),
+  deviceName: z.string().trim().min(1).max(120),
+  imageVersion: z.enum([
+    "ubuntu-24.04-v1",
+    "ubuntu-24.04-v2",
+    "ubuntu-24.04-v3",
+    "ubuntu-24.04-v4",
+    "ubuntu-24.04-v5"
+  ]),
+  resources: z.object({
+    cpuCount: z.number().int().min(1).max(2),
+    memoryMiB: z.number().int().min(1024).max(2048),
+    diskGiB: z.number().int().min(10).max(12)
+  }),
+  backends: z.array(z.literal("codex")).length(1),
+  codexFiles: z.object({
+    configToml: z.string().min(1).max(128 * 1024),
+    authJson: z.string().min(2).max(128 * 1024)
+  })
+}).strict();
+var updateHostedSandboxMembersSchema = z.object({
+  assignedUserIds: z.array(z.string().uuid()).min(1).max(20)
+}).strict();
+var updateHostedSandboxSettingsSchema = z.object({ workspaceIsolationEnabled: z.boolean() }).strict();
+var hostedSnapshotSchema = z.object({
+  name: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,62}$/)
+});
+var rotateHostedCredentialSchema = z.object({ openaiApiKey: z.string().min(20).max(512) }).strict();
+var hostedCodexFilesSchema = z.object({
+  configToml: z.string().min(1).max(128 * 1024),
+  authJson: z.string().min(2).max(128 * 1024)
+}).strict();
 var createShareSchema = z.object({
   targetIdentifier: z.string().trim().min(1).optional(),
   targetUsername: z.string().trim().min(3).optional(),
@@ -1818,10 +3790,13 @@ var createGrantSchema = z.object({
 }).refine((input) => input.scope !== "thread" || Boolean(input.threadId), {
   message: "threadId is required for thread grants.",
   path: ["threadId"]
-}).refine((input) => input.scope !== "workspace" || Boolean(input.workspaceId), {
-  message: "workspaceId is required for workspace grants.",
-  path: ["workspaceId"]
-});
+}).refine(
+  (input) => input.scope !== "workspace" || Boolean(input.workspaceId),
+  {
+    message: "workspaceId is required for workspace grants.",
+    path: ["workspaceId"]
+  }
+);
 var updateGrantSchema = z.object({
   workspaceId: z.string().uuid().nullable().optional(),
   workspaceScope: workspaceScopeSchema.optional(),
@@ -1844,7 +3819,10 @@ var adminQuerySchema = z.object({
 var updateRegistrationSettingsSchema = z.object({
   enabled: z.boolean().optional(),
   registrationPassword: z.string().nullable().optional(),
-  approvalRequired: z.boolean().optional()
+  approvalRequired: z.boolean().optional(),
+  googleAuthEnabled: z.boolean().optional(),
+  githubAuthEnabled: z.boolean().optional(),
+  emailVerificationEnabled: z.boolean().optional()
 });
 var updateAccountSchema = z.object({
   username: z.string().trim().min(3).optional()
@@ -1865,10 +3843,7 @@ var DEFAULT_WEBVIEW_CORS_ORIGINS = /* @__PURE__ */ new Set([
   "http://localhost",
   "https://localhost"
 ]);
-var WEBVIEW_CORS_ALLOW_HEADERS = [
-  "authorization",
-  "content-type"
-].join(", ");
+var WEBVIEW_CORS_ALLOW_HEADERS = ["authorization", "content-type"].join(", ");
 var WEBVIEW_CORS_ALLOW_METHODS = [
   "GET",
   "POST",
@@ -1931,9 +3906,13 @@ var RELAY_RESPONSE_HEADER_BLOCKLIST = /* @__PURE__ */ new Set([
 ]);
 function buildRelayServer(config2, options = {}) {
   const app2 = Fastify({ logger: false });
-  app2.addContentTypeParser("*", { parseAs: "buffer" }, (_request, body, done) => {
-    done(null, body);
-  });
+  app2.addContentTypeParser(
+    "*",
+    { parseAs: "buffer" },
+    (_request, body, done) => {
+      done(null, body);
+    }
+  );
   const store = RelayStore.fromDataDir(
     config2.dataDir,
     config2.sessionSecret,
@@ -1943,6 +3922,12 @@ function buildRelayServer(config2, options = {}) {
     store.setRegistrationEnabled(config2.registrationEnabled);
   }
   store.ensureRegistrationPassword(config2.registrationPassword);
+  const googleAvailable = Boolean(config2.googleOAuthClientId && config2.googleOAuthClientSecret);
+  const githubAvailable = Boolean(config2.githubOAuthClientId && config2.githubOAuthClientSecret);
+  store.ensureAuthSettings({
+    google: googleAvailable && config2.googleOAuthEnabled !== false,
+    github: githubAvailable && config2.githubOAuthEnabled !== false
+  });
   store.seedAdmin({
     username: config2.adminUsername,
     email: config2.adminEmail,
@@ -1951,7 +3936,28 @@ function buildRelayServer(config2, options = {}) {
   const state = {
     supervisors: /* @__PURE__ */ new Map()
   };
-  const allowedWebViewCorsOrigins = webViewCorsOrigins(options.env ?? process.env);
+  const hostedSandboxProvider = options.hostedSandboxProvider ?? createHostedSandboxProvider(config2.hostedSandbox);
+  const hostedSandboxCapability = new HostedSandboxCapabilityService(
+    hostedSandboxProvider,
+    { timeoutMs: config2.hostedSandbox.requestTimeoutMs }
+  );
+  const hostedSandboxService = new HostedSandboxService(
+    store,
+    hostedSandboxProvider,
+    config2.hostedSandbox
+  );
+  const hostedSandboxReconciler = new HostedSandboxReconciler(
+    store,
+    hostedSandboxProvider,
+    config2.hostedSandbox
+  );
+  const allowedWebViewCorsOrigins = webViewCorsOrigins(
+    options.env ?? process.env
+  );
+  app2.addHook("onReady", () => {
+    queueMicrotask(() => hostedSandboxService.reconcilePending());
+    queueMicrotask(() => hostedSandboxReconciler.start());
+  });
   app2.addHook("onRequest", async (request, reply) => {
     if (!allowedWebViewCorsOrigins) {
       return;
@@ -1975,8 +3981,55 @@ function buildRelayServer(config2, options = {}) {
       supervisorCount: state.supervisors.size
     };
   });
+  const authSettings = () => ({
+    ...store.registrationSettings(),
+    googleAuthAvailable: googleAvailable,
+    githubAuthAvailable: githubAvailable,
+    emailVerificationAvailable: config2.emailVerificationConfigured
+  });
   app2.get("/relay/auth/session", async (request) => {
-    return store.verifySession(readRelaySessionToken(request));
+    return { ...verifyRelayRequestSession(request, store), registrationSettings: authSettings() };
+  });
+  app2.get("/relay/auth/oauth/:provider/start", async (request, reply) => {
+    const { provider } = z.object({ provider: z.enum(["google", "github"]) }).parse(request.params);
+    const settings = authSettings();
+    if (provider === "google" ? !settings.googleAuthEnabled || !googleAvailable : !settings.githubAuthEnabled || !githubAvailable) {
+      reply.status(403).send({ code: "forbidden", message: `${provider === "google" ? "Google" : "GitHub"} authentication is disabled.` });
+      return;
+    }
+    const state2 = signOAuthState(provider, config2.sessionSecret);
+    const callback = oauthCallbackUrl(request, config2, provider);
+    const url = provider === "google" ? new URL("https://accounts.google.com/o/oauth2/v2/auth") : new URL("https://github.com/login/oauth/authorize");
+    url.searchParams.set("client_id", provider === "google" ? config2.googleOAuthClientId : config2.githubOAuthClientId);
+    url.searchParams.set("redirect_uri", callback);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("state", state2);
+    url.searchParams.set("scope", provider === "google" ? "openid email profile" : "read:user user:email");
+    if (provider === "google") url.searchParams.set("prompt", "select_account");
+    reply.redirect(url.toString());
+  });
+  app2.get("/relay/auth/oauth/:provider/callback", async (request, reply) => {
+    const { provider } = z.object({ provider: z.enum(["google", "github"]) }).parse(request.params);
+    const query = z.object({ code: z.string().min(1), state: z.string().min(1) }).parse(request.query);
+    if (!verifyOAuthState(query.state, provider, config2.sessionSecret)) {
+      reply.redirect("/relay-portal?oauthError=OAuth%20request%20expired%20or%20was%20invalid.");
+      return;
+    }
+    try {
+      const identity = provider === "google" ? await fetchGoogleIdentity(query.code, oauthCallbackUrl(request, config2, provider), config2) : await fetchGitHubIdentity(query.code, oauthCallbackUrl(request, config2, provider), config2);
+      const outcome = store.authenticateExternalIdentity(identity, store.registrationSettings().approvalRequired);
+      if (outcome.kind === "pending") {
+        reply.redirect("/relay-portal?oauthPending=1");
+        return;
+      }
+      store.recordUserSeen(outcome.result.session.user.id);
+      attachRelayCookie(reply, outcome.result.token);
+      reply.redirect("/relay-portal");
+    } catch (error) {
+      request.log.error(error);
+      const message = error instanceof RelayStoreError ? error.message : "OAuth authentication failed.";
+      reply.redirect(`/relay-portal?oauthError=${encodeURIComponent(message)}`);
+    }
   });
   app2.post("/relay/auth/register", async (request, reply) => {
     const body = registerSchema.parse(request.body ?? {});
@@ -2039,7 +4092,11 @@ function buildRelayServer(config2, options = {}) {
     if (!user) {
       return;
     }
-    return enrichPortalSummary(store.portalSummary(user.id, connectionStatus(state)), state, store);
+    return enrichPortalSummary(
+      store.portalSummary(user.id, connectionStatus(state)),
+      state,
+      store
+    );
   });
   app2.get("/relay/access", async (request, reply) => {
     const user = requireRelayUser(request, reply, store);
@@ -2158,22 +4215,228 @@ function buildRelayServer(config2, options = {}) {
     const baseSummary = store.adminSummary(connectionStatus(state), {
       ...query.days !== void 0 ? { conversationWindowDays: query.days } : {}
     });
-    return enrichAdminSummary(baseSummary, state, store, query.days);
+    const summary = await enrichAdminSummary(baseSummary, state, store, query.days);
+    return { ...summary, settings: authSettings() };
+  });
+  app2.get(
+    "/relay/admin/hosted-sandboxes/capability",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      return hostedSandboxCapability.read();
+    }
+  );
+  app2.get("/relay/admin/hosted-sandboxes", async (request, reply) => {
+    const user = requireRelayUser(request, reply, store, { admin: true });
+    if (!user) {
+      return;
+    }
+    return { sandboxes: hostedSandboxService.list() };
+  });
+  app2.get(
+    "/relay/admin/hosted-sandboxes/reconciliation",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      return hostedSandboxReconciler.read();
+    }
+  );
+  app2.post(
+    "/relay/admin/hosted-sandboxes/reconciliation/run",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      return hostedSandboxReconciler.run();
+    }
+  );
+  app2.delete(
+    "/relay/admin/hosted-sandboxes/reconciliation/orphan-instances/:sandboxId",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return hostedSandboxReconciler.deleteOrphanInstance(sandboxId);
+    }
+  );
+  app2.delete(
+    "/relay/admin/hosted-sandboxes/reconciliation/orphan-credentials/:credentialRef",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { credentialRef } = z.object({
+        credentialRef: z.string().regex(/^rcc_[A-Za-z0-9_-]{32}$/)
+      }).parse(request.params);
+      return hostedSandboxReconciler.deleteOrphanCredential(credentialRef);
+    }
+  );
+  app2.get(
+    "/relay/admin/hosted-sandboxes/:sandboxId",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return hostedSandboxService.detail(sandboxId);
+    }
+  );
+  app2.post("/relay/admin/hosted-sandboxes", async (request, reply) => {
+    const user = requireRelayUser(request, reply, store, { admin: true });
+    if (!user) {
+      return;
+    }
+    const body = createHostedSandboxSchema.parse(request.body ?? {});
+    const result = await hostedSandboxService.create({
+      createdByAdminUserId: user.id,
+      ...body
+    });
+    return reply.code(202).send(result);
   });
+  app2.put(
+    "/relay/admin/hosted-sandboxes/:sandboxId/members",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      const body = updateHostedSandboxMembersSchema.parse(request.body ?? {});
+      return hostedSandboxService.updateMembers(
+        sandboxId,
+        body.assignedUserIds
+      );
+    }
+  );
+  app2.patch(
+    "/relay/admin/hosted-sandboxes/:sandboxId/settings",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      const body = updateHostedSandboxSettingsSchema.parse(request.body ?? {});
+      return store.setHostedWorkspaceIsolation(
+        sandboxId,
+        body.workspaceIsolationEnabled
+      );
+    }
+  );
+  app2.post(
+    "/relay/admin/hosted-sandboxes/:sandboxId/retry",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return reply.code(202).send({
+        sandbox: hostedSandboxService.detail(sandboxId),
+        operation: hostedSandboxService.retry(sandboxId)
+      });
+    }
+  );
+  app2.post(
+    "/relay/admin/hosted-sandboxes/:sandboxId/start",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return reply.code(202).send({
+        operation: hostedSandboxService.start(sandboxId)
+      });
+    }
+  );
+  app2.post(
+    "/relay/admin/hosted-sandboxes/:sandboxId/stop",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return reply.code(202).send({
+        operation: hostedSandboxService.stop(sandboxId)
+      });
+    }
+  );
+  app2.post(
+    "/relay/admin/hosted-sandboxes/:sandboxId/snapshots",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      const { name } = hostedSnapshotSchema.parse(request.body ?? {});
+      return reply.code(202).send({
+        operation: hostedSandboxService.snapshot(sandboxId, name)
+      });
+    }
+  );
+  app2.delete(
+    "/relay/admin/hosted-sandboxes/:sandboxId",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return reply.code(202).send({
+        operation: hostedSandboxService.delete(sandboxId)
+      });
+    }
+  );
+  app2.post(
+    "/relay/admin/hosted-sandboxes/:sandboxId/rotate-credential",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      const { openaiApiKey } = rotateHostedCredentialSchema.parse(
+        request.body ?? {}
+      );
+      return reply.code(202).send({
+        operation: await hostedSandboxService.rotateCredential(
+          sandboxId,
+          openaiApiKey
+        )
+      });
+    }
+  );
+  app2.get(
+    "/relay/admin/hosted-sandboxes/:sandboxId/backends/codex/files",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      return hostedSandboxService.readCodexFiles(sandboxId);
+    }
+  );
+  app2.put(
+    "/relay/admin/hosted-sandboxes/:sandboxId/backends/codex/files",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) return;
+      const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
+      const body = hostedCodexFilesSchema.parse(request.body ?? {});
+      return hostedSandboxService.writeCodexFiles(sandboxId, body);
+    }
+  );
   app2.patch("/relay/admin/settings/registration", async (request, reply) => {
     const user = requireRelayUser(request, reply, store, { admin: true });
     if (!user) {
       return;
     }
     const body = updateRegistrationSettingsSchema.parse(request.body ?? {});
+    if (body.googleAuthEnabled && !googleAvailable) throw new RelayStoreError(400, "bad_request", "Google OAuth credentials are not configured.");
+    if (body.githubAuthEnabled && !githubAvailable) throw new RelayStoreError(400, "bad_request", "GitHub OAuth credentials are not configured.");
+    if (body.emailVerificationEnabled && !config2.emailVerificationConfigured) throw new RelayStoreError(400, "bad_request", "Email verification is not configured.");
     const settings = store.updateRegistrationSettings({
       ...body.enabled !== void 0 ? { enabled: body.enabled } : {},
       ...body.registrationPassword !== void 0 ? { registrationPassword: body.registrationPassword } : {},
-      ...body.approvalRequired !== void 0 ? { approvalRequired: body.approvalRequired } : {}
+      ...body.approvalRequired !== void 0 ? { approvalRequired: body.approvalRequired } : {},
+      ...body.googleAuthEnabled !== void 0 ? { googleAuthEnabled: body.googleAuthEnabled } : {},
+      ...body.githubAuthEnabled !== void 0 ? { githubAuthEnabled: body.githubAuthEnabled } : {},
+      ...body.emailVerificationEnabled !== void 0 ? { emailVerificationEnabled: body.emailVerificationEnabled } : {}
     });
     return {
       registrationEnabled: settings.enabled,
-      settings
+      settings: { ...settings, googleAuthAvailable: googleAvailable, githubAuthAvailable: githubAvailable, emailVerificationAvailable: config2.emailVerificationConfigured }
     };
   });
   app2.patch("/relay/admin/users/:userId", async (request, reply) => {
@@ -2194,31 +4457,40 @@ function buildRelayServer(config2, options = {}) {
     store.deleteUser(userId);
     return { id: userId };
   });
-  app2.post("/relay/admin/users/:userId/reset-password", async (request, reply) => {
-    const user = requireRelayUser(request, reply, store, { admin: true });
-    if (!user) {
-      return;
+  app2.post(
+    "/relay/admin/users/:userId/reset-password",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      const { userId } = z.object({ userId: z.string().uuid() }).parse(request.params);
+      const body = adminResetPasswordSchema.parse(request.body ?? {});
+      return store.adminResetUserPassword(userId, body.password);
     }
-    const { userId } = z.object({ userId: z.string().uuid() }).parse(request.params);
-    const body = adminResetPasswordSchema.parse(request.body ?? {});
-    return store.adminResetUserPassword(userId, body.password);
-  });
-  app2.post("/relay/admin/registrations/:requestId/approve", async (request, reply) => {
-    const user = requireRelayUser(request, reply, store, { admin: true });
-    if (!user) {
-      return;
+  );
+  app2.post(
+    "/relay/admin/registrations/:requestId/approve",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      const { requestId } = z.object({ requestId: z.string().uuid() }).parse(request.params);
+      return store.approvePendingRegistration(user.id, requestId);
     }
-    const { requestId } = z.object({ requestId: z.string().uuid() }).parse(request.params);
-    return store.approvePendingRegistration(user.id, requestId);
-  });
-  app2.post("/relay/admin/registrations/:requestId/reject", async (request, reply) => {
-    const user = requireRelayUser(request, reply, store, { admin: true });
-    if (!user) {
-      return;
+  );
+  app2.post(
+    "/relay/admin/registrations/:requestId/reject",
+    async (request, reply) => {
+      const user = requireRelayUser(request, reply, store, { admin: true });
+      if (!user) {
+        return;
+      }
+      const { requestId } = z.object({ requestId: z.string().uuid() }).parse(request.params);
+      return store.rejectPendingRegistration(user.id, requestId);
     }
-    const { requestId } = z.object({ requestId: z.string().uuid() }).parse(request.params);
-    return store.rejectPendingRegistration(user.id, requestId);
-  });
+  );
   app2.all("/relay/devices/:deviceId/api/*", async (request, reply) => {
     const user = requireRelayUser(request, reply, store);
     if (!user) {
@@ -2231,6 +4503,7 @@ function buildRelayServer(config2, options = {}) {
       reply,
       state,
       store,
+      hostedSandboxService,
       user,
       deviceId,
       targetPath
@@ -2247,6 +4520,7 @@ function buildRelayServer(config2, options = {}) {
       reply,
       state,
       store,
+      hostedSandboxService,
       user,
       deviceId,
       targetPath: "/healthz"
@@ -2271,6 +4545,7 @@ function buildRelayServer(config2, options = {}) {
       reply,
       state,
       store,
+      hostedSandboxService,
       user,
       deviceId,
       targetPath
@@ -2298,12 +4573,16 @@ function buildRelayServer(config2, options = {}) {
         }
         const connectedAt = (/* @__PURE__ */ new Date()).toISOString();
         const existing = state.supervisors.get(deviceId);
-        existing?.socket.send(JSON.stringify({
-          type: "relay.connected",
-          timestamp: connectedAt,
-          deviceId
-        }));
-        existing?.clientSockets.forEach((clientConnection) => clientConnection.socket.close());
+        existing?.socket.send(
+          JSON.stringify({
+            type: "relay.connected",
+            timestamp: connectedAt,
+            deviceId
+          })
+        );
+        existing?.clientSockets.forEach(
+          (clientConnection) => clientConnection.socket.close()
+        );
         const connection = {
           deviceId,
           socket,
@@ -2315,6 +4594,7 @@ function buildRelayServer(config2, options = {}) {
           ipAddress: relayClientIp(request)
         };
         state.supervisors.set(deviceId, connection);
+        hostedSandboxService.markOnline(deviceId);
         socket.send(
           JSON.stringify({
             type: "relay.connected",
@@ -2325,7 +4605,9 @@ function buildRelayServer(config2, options = {}) {
         socket.on("message", (rawMessage) => {
           let parsed;
           try {
-            parsed = JSON.parse(rawMessage.toString());
+            parsed = JSON.parse(
+              rawMessage.toString()
+            );
           } catch {
             return;
           }
@@ -2333,21 +4615,54 @@ function buildRelayServer(config2, options = {}) {
             connection.lastHeartbeatAt = parsed.timestamp;
             return;
           }
+          if (parsed.type === "relay.activity") {
+            hostedSandboxService.recordTurnActivity({
+              deviceId,
+              threadId: parsed.payload.threadId,
+              turnId: parsed.payload.turnId,
+              kind: parsed.payload.kind
+            });
+            return;
+          }
           if (parsed.type === "relay.server.message") {
-            const clientConnection = connection.clientSockets.get(parsed.clientId);
+            const clientConnection = connection.clientSockets.get(
+              parsed.clientId
+            );
+            const eventThreadId = threadIdFromSocketPayload(parsed.payload);
             if (clientConnection) {
-              const eventThreadId = threadIdFromSocketPayload(parsed.payload);
-              const freshAccess = store.effectiveAccess(clientConnection.user.id, clientConnection.deviceId, {
-                threadId: clientConnection.threadId ?? eventThreadId
-              });
+              const freshAccess = store.effectiveAccess(
+                clientConnection.user.id,
+                clientConnection.deviceId,
+                {
+                  threadId: clientConnection.threadId ?? eventThreadId
+                }
+              );
               if (!freshAccess) {
                 connection.clientSockets.delete(parsed.clientId);
-                clientConnection.socket.close(1008, "Shared access is no longer allowed.");
+                clientConnection.socket.close(
+                  1008,
+                  "Shared access is no longer allowed."
+                );
                 return;
               }
               clientConnection.access = freshAccess;
+              const isolation = store.hostedWorkspaceIsolationForUser(
+                clientConnection.deviceId,
+                clientConnection.user.id
+              );
+              const connectionControlEvent = parsed.payload.type === "supervisor.connected" || parsed.payload.type === "supervisor.pong";
+              if (isolation?.enabled && !connectionControlEvent && (!eventThreadId || !store.ownsHostedThread(
+                isolation.sandboxId,
+                clientConnection.user.id,
+                eventThreadId
+              ))) {
+                return;
+              }
             }
-            if (clientConnection && clientConnection.socket.readyState === WEBSOCKET_OPEN && shouldForwardSocketEvent(parsed.payload, clientConnection.threadId)) {
+            if (clientConnection && clientConnection.socket.readyState === WEBSOCKET_OPEN && shouldForwardSocketEvent(
+              parsed.payload,
+              clientConnection.threadId
+            )) {
               clientConnection.socket.send(JSON.stringify(parsed.payload));
             }
             return;
@@ -2358,7 +4673,9 @@ function buildRelayServer(config2, options = {}) {
           if (state.supervisors.get(deviceId)?.socket === socket) {
             state.supervisors.delete(deviceId);
           }
-          connection.requestBroker.rejectAll(new Error("Supervisor tunnel closed."));
+          connection.requestBroker.rejectAll(
+            new Error("Supervisor tunnel closed.")
+          );
           for (const [clientId, clientConnection] of connection.clientSockets) {
             connection.clientSockets.delete(clientId);
             clientConnection.socket.close();
@@ -2376,27 +4693,55 @@ function buildRelayServer(config2, options = {}) {
         });
       },
       wsHandler: (socket, request) => {
-        const session = store.verifySession(readRelaySessionToken(request));
+        const session = verifyRelayRequestSession(request, store);
         const deviceId = pathParam(request.params, "deviceId");
         const threadId = queryString(request.query, "threadId");
         if (!session.authenticated || !session.user || !deviceId) {
           socket.close(1008, "Relay login is required.");
           return;
         }
-        const access = store.effectiveAccess(session.user.id, deviceId, { threadId });
+        const access = store.effectiveAccess(session.user.id, deviceId, {
+          threadId
+        });
         if (!access) {
           socket.close(1008, "Device access is not allowed.");
           return;
         }
+        const isolation = store.hostedWorkspaceIsolationForUser(
+          deviceId,
+          session.user.id
+        );
+        if (isolation?.enabled && threadId && !store.ownsHostedThread(isolation.sandboxId, session.user.id, threadId)) {
+          socket.close(1008, "This thread belongs to another VM user.");
+          return;
+        }
+        const lifecycle = hostedSandboxService.wakeIfStopped(deviceId);
+        if (lifecycle.waking) {
+          socket.close(1013, "Hosted supervisor VM is starting.");
+          return;
+        }
         const supervisor = state.supervisors.get(deviceId);
         if (!supervisor || supervisor.socket.readyState !== WEBSOCKET_OPEN) {
           socket.close(1013, "No supervisor is connected for this device.");
           return;
         }
         if (access.kind === "shared") {
-          recordRelayAccess(store, access, session.user, threadId ? "open_thread" : "open_device");
+          recordRelayAccess(
+            store,
+            access,
+            session.user,
+            threadId ? "open_thread" : "open_device"
+          );
         }
-        connectRelayWebsocket(supervisor, socket, store, session.user, deviceId, threadId, access);
+        connectRelayWebsocket(
+          supervisor,
+          socket,
+          store,
+          session.user,
+          deviceId,
+          threadId,
+          access
+        );
       }
     });
     realtimeApp.route({
@@ -2409,17 +4754,25 @@ function buildRelayServer(config2, options = {}) {
         });
       },
       wsHandler: (socket, request) => {
-        const session = store.verifySession(readRelaySessionToken(request));
+        const session = verifyRelayRequestSession(request, store);
         if (!session.authenticated || !session.user) {
           socket.close(1008, "Relay login is required.");
           return;
         }
         const threadId = queryString(request.query, "threadId");
-        const deviceId = firstAccessibleConnectedDevice(state, store, session.user.id, threadId);
+        const deviceId = firstAccessibleConnectedDevice(
+          state,
+          store,
+          session.user.id,
+          threadId
+        );
         const supervisor = deviceId ? state.supervisors.get(deviceId) : null;
         const access = deviceId ? store.effectiveAccess(session.user.id, deviceId, { threadId }) : null;
         if (!deviceId || !supervisor || supervisor.socket.readyState !== WEBSOCKET_OPEN) {
-          socket.close(1013, "No accessible supervisor is connected to this relay.");
+          socket.close(
+            1013,
+            "No accessible supervisor is connected to this relay."
+          );
           return;
         }
         if (!access) {
@@ -2427,15 +4780,32 @@ function buildRelayServer(config2, options = {}) {
           return;
         }
         if (access.kind === "shared") {
-          recordRelayAccess(store, access, session.user, threadId ? "open_thread" : "open_device");
+          recordRelayAccess(
+            store,
+            access,
+            session.user,
+            threadId ? "open_thread" : "open_device"
+          );
         }
-        connectRelayWebsocket(supervisor, socket, store, session.user, deviceId, threadId, access);
+        connectRelayWebsocket(
+          supervisor,
+          socket,
+          store,
+          session.user,
+          deviceId,
+          threadId,
+          access
+        );
       }
     });
   });
   if (config2.webDistDir) {
     registerRelayWebApp(app2, config2.webDistDir);
   }
+  app2.addHook("onClose", () => {
+    hostedSandboxService.close();
+    hostedSandboxReconciler.close();
+  });
   app2.setErrorHandler((error, _request, reply) => {
     if (error instanceof RelayStoreError) {
       reply.status(error.statusCode).send({
@@ -2445,9 +4815,12 @@ function buildRelayServer(config2, options = {}) {
       return;
     }
     if (error instanceof z.ZodError) {
+      const firstIssue = error.issues[0];
+      const field = firstIssue?.path[0];
+      const message = field === "password" ? "Password must be at least 8 characters." : field === "username" ? "Username must be at least 3 characters." : field === "email" ? "Enter a valid email address." : "The request payload is invalid.";
       reply.status(400).send({
         code: "bad_request",
-        message: "The request payload is invalid.",
+        message,
         details: {
           issues: error.issues
         }
@@ -2466,7 +4839,9 @@ function webViewCorsOrigins(env) {
     return null;
   }
   const configured = env.REMOTE_CODEX_WEBVIEW_CORS_ORIGINS?.split(",").map((origin) => origin.trim()).filter(Boolean);
-  return new Set(configured?.length ? configured : DEFAULT_WEBVIEW_CORS_ORIGINS);
+  return new Set(
+    configured?.length ? configured : DEFAULT_WEBVIEW_CORS_ORIGINS
+  );
 }
 function applyWebViewCorsHeaders(reply, origin) {
   reply.header("access-control-allow-origin", origin);
@@ -2549,6 +4924,18 @@ async function forwardRelayHttp(input) {
       workspaceId: conversationEvent.workspaceId
     });
   }
+  const lifecycle = isHostedUserActivityRequest(
+    input.request.method,
+    input.targetPath
+  ) ? input.hostedSandboxService.recordUserActivity(input.deviceId) : input.hostedSandboxService.wakeIfStopped(input.deviceId);
+  if (lifecycle.waking) {
+    input.reply.status(503).send({
+      code: "service_unavailable",
+      message: "Hosted supervisor VM is starting. Retry shortly.",
+      details: { reason: "hosted_sandbox_starting" }
+    });
+    return;
+  }
   const supervisor = input.state.supervisors.get(input.deviceId);
   if (!supervisor || supervisor.socket.readyState !== WEBSOCKET_OPEN) {
     input.reply.status(503).send({
@@ -2558,6 +4945,64 @@ async function forwardRelayHttp(input) {
     return;
   }
   try {
+    const isolation = input.store.hostedWorkspaceIsolationForUser(
+      input.deviceId,
+      input.user.id
+    );
+    if (isolation?.enabled) {
+      if (input.request.method.toUpperCase() === "GET" && (targetUrl.pathname === "/api/workspaces" || targetUrl.pathname === "/api/threads")) {
+        await ensureHostedUserBootstrap({
+          store: input.store,
+          supervisor,
+          deviceId: input.deviceId,
+          sandboxId: isolation.sandboxId,
+          user: input.user
+        });
+      }
+      if (workspaceId && !input.store.ownsHostedWorkspace(
+        isolation.sandboxId,
+        input.user.id,
+        workspaceId
+      )) {
+        input.reply.status(403).send({
+          code: "forbidden",
+          message: "This workspace belongs to another VM user."
+        });
+        return;
+      }
+      if (threadId && !input.store.ownsHostedThread(
+        isolation.sandboxId,
+        input.user.id,
+        threadId
+      )) {
+        input.reply.status(403).send({
+          code: "forbidden",
+          message: "This thread belongs to another VM user."
+        });
+        return;
+      }
+      if (input.request.method.toUpperCase() === "POST" && targetUrl.pathname === "/api/threads/start") {
+        const requestedWorkspaceId = isObject(input.request.body) && typeof input.request.body.workspaceId === "string" ? input.request.body.workspaceId : null;
+        if (!requestedWorkspaceId || !input.store.ownsHostedWorkspace(
+          isolation.sandboxId,
+          input.user.id,
+          requestedWorkspaceId
+        )) {
+          input.reply.status(403).send({
+            code: "forbidden",
+            message: "Create threads only in your own workspace."
+          });
+          return;
+        }
+      }
+      if (input.request.method.toUpperCase() === "POST" && targetUrl.pathname === "/api/threads/import") {
+        input.reply.status(403).send({
+          code: "forbidden",
+          message: "Thread import is unavailable while user workspace isolation is enabled."
+        });
+        return;
+      }
+    }
     const requestId = randomUUID();
     const requestBody = relayRequestBody(input.request.body);
     const response = await supervisor.requestBroker.forward(supervisor.socket, {
@@ -2578,6 +5023,18 @@ async function forwardRelayHttp(input) {
         input.reply.header(name, value);
       }
     }
+    if (isolation?.enabled && response.statusCode >= 200 && response.statusCode < 300) {
+      const transformed = transformHostedIsolatedResponse({
+        store: input.store,
+        sandboxId: isolation.sandboxId,
+        userId: input.user.id,
+        method: input.request.method,
+        pathname: targetUrl.pathname,
+        response
+      });
+      input.reply.status(response.statusCode).send(transformed);
+      return;
+    }
     input.reply.status(response.statusCode).send(relayResponseBody(response));
   } catch (error) {
     const message = error instanceof Error ? error.message : "Relay request failed.";
@@ -2609,7 +5066,162 @@ async function forwardSharedThreadList(input) {
       return isObject(thread) ? thread : null;
     })
   );
-  input.reply.send(threads.filter((thread) => Boolean(thread)));
+  input.reply.send(
+    threads.filter(
+      (thread) => Boolean(thread)
+    )
+  );
+}
+async function ensureHostedUserBootstrap(input) {
+  if (input.store.hostedUserWorkspaceIds(input.sandboxId, input.user.id).length) {
+    return;
+  }
+  const key = `${input.sandboxId}:${input.user.id}`;
+  const existing = hostedBootstrapPromises.get(key);
+  if (existing) return existing;
+  const pending = (async () => {
+    const slug = input.user.username.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "user";
+    const directory = `${slug}-${input.user.id.slice(0, 8)}`;
+    const absoluteDirectory = `/home/remote-codex/workspaces/${directory}`;
+    const label = `${input.user.username}'s workspace`;
+    const current = await forwardSupervisorCommandJson(
+      input.supervisor,
+      input.deviceId,
+      "GET",
+      "/api/workspaces"
+    );
+    const currentWorkspaces = Array.isArray(current) ? current : [];
+    let workspace = currentWorkspaces.find(
+      (candidate) => isObject(candidate) && typeof candidate.absPath === "string" && candidate.absPath === absoluteDirectory
+    );
+    if (!workspace) {
+      workspace = await forwardSupervisorCommandJson(
+        input.supervisor,
+        input.deviceId,
+        "POST",
+        "/api/workspaces",
+        { absPath: absoluteDirectory, label }
+      );
+    }
+    const workspaceId = stringField(workspace, "id");
+    if (!workspaceId) throw new Error("Initial workspace creation returned no id.");
+    const thread = await forwardSupervisorCommandJson(
+      input.supervisor,
+      input.deviceId,
+      "POST",
+      "/api/threads/start",
+      {
+        workspaceId,
+        title: "Getting started",
+        provider: "codex",
+        model: "gpt-5.6-sol",
+        reasoningEffort: "low",
+        approvalMode: "yolo"
+      }
+    );
+    const threadId = stringField(thread, "id");
+    if (!threadId) throw new Error("Initial thread creation returned no id.");
+    input.store.recordHostedUserWorkspace(
+      input.sandboxId,
+      input.user.id,
+      workspaceId,
+      true
+    );
+    input.store.recordHostedUserThread(
+      input.sandboxId,
+      input.user.id,
+      threadId,
+      workspaceId
+    );
+  })().finally(() => hostedBootstrapPromises.delete(key));
+  hostedBootstrapPromises.set(key, pending);
+  return pending;
+}
+async function forwardSupervisorCommandJson(supervisor, deviceId, method, path4, body) {
+  const response = await supervisor.requestBroker.forward(supervisor.socket, {
+    type: "relay.request",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: randomUUID(),
+    deviceId,
+    payload: {
+      method,
+      path: path4,
+      headers: body === void 0 ? {} : { "content-type": "application/json" },
+      body: body === void 0 ? null : JSON.stringify(body)
+    }
+  });
+  if (response.statusCode < 200 || response.statusCode >= 300) {
+    let detail = relayJsonBody(response);
+    try {
+      const payload = JSON.parse(detail);
+      detail = isObject(payload) && typeof payload.message === "string" ? payload.message : detail;
+    } catch {
+    }
+    throw new Error(
+      `Supervisor bootstrap request failed with ${response.statusCode}: ${detail.slice(0, 300)}`
+    );
+  }
+  return JSON.parse(relayJsonBody(response));
+}
+function transformHostedIsolatedResponse(input) {
+  const raw = relayJsonBody(input.response);
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return relayResponseBody(input.response);
+  }
+  const method = input.method.toUpperCase();
+  if (method === "GET" && input.pathname === "/api/workspaces" && Array.isArray(payload)) {
+    const owned = new Set(
+      input.store.hostedUserWorkspaceIds(input.sandboxId, input.userId)
+    );
+    return payload.filter(
+      (workspace) => isObject(workspace) && owned.has(stringField(workspace, "id") ?? "")
+    );
+  }
+  if (method === "POST" && input.pathname === "/api/workspaces" && isObject(payload)) {
+    const workspaceId = stringField(payload, "id");
+    if (workspaceId) {
+      input.store.recordHostedUserWorkspace(
+        input.sandboxId,
+        input.userId,
+        workspaceId
+      );
+    }
+    return payload;
+  }
+  if (method === "GET" && input.pathname === "/api/threads" && Array.isArray(payload)) {
+    const ownedWorkspaces = new Set(
+      input.store.hostedUserWorkspaceIds(input.sandboxId, input.userId)
+    );
+    return payload.filter((thread) => {
+      if (!isObject(thread)) return false;
+      const threadId = stringField(thread, "id");
+      const workspaceId = stringField(thread, "workspaceId");
+      if (!threadId || !workspaceId || !ownedWorkspaces.has(workspaceId)) return false;
+      input.store.recordHostedUserThread(
+        input.sandboxId,
+        input.userId,
+        threadId,
+        workspaceId
+      );
+      return true;
+    });
+  }
+  if (method === "POST" && input.pathname === "/api/threads/start" && isObject(payload)) {
+    const threadId = stringField(payload, "id");
+    const workspaceId = stringField(payload, "workspaceId");
+    if (threadId && workspaceId) {
+      input.store.recordHostedUserThread(
+        input.sandboxId,
+        input.userId,
+        threadId,
+        workspaceId
+      );
+    }
+  }
+  return payload;
 }
 function relayResponseBody(response) {
   if (response.bodyEncoding === "base64") {
@@ -2619,7 +5231,13 @@ function relayResponseBody(response) {
 }
 function connectRelayWebsocket(supervisor, socket, store, user, deviceId, threadId, access) {
   const clientId = randomUUID();
-  supervisor.clientSockets.set(clientId, { socket, threadId, deviceId, user, access });
+  supervisor.clientSockets.set(clientId, {
+    socket,
+    threadId,
+    deviceId,
+    user,
+    access
+  });
   sendToSupervisor(supervisor, {
     type: "relay.client.connected",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2711,7 +5329,9 @@ function registerRelayWebApp(app2, distDirInput) {
       return reply.send(payload);
     }
     const stat = await fsp.stat(assetPath);
-    reply.header("cache-control", "public, max-age=31536000, immutable").header("content-length", stat.size).type(mimeTypes.get(path2.extname(assetPath).toLowerCase()) ?? "application/octet-stream");
+    reply.header("cache-control", "public, max-age=31536000, immutable").header("content-length", stat.size).type(
+      mimeTypes.get(path2.extname(assetPath).toLowerCase()) ?? "application/octet-stream"
+    );
     return reply.send(fs2.createReadStream(assetPath));
   });
 }
@@ -2747,7 +5367,7 @@ async function resolveAssetPath(distDir, indexFile, pathname) {
   return indexFile;
 }
 function requireRelayUser(request, reply, store, options = {}) {
-  const session = store.verifySession(readRelaySessionToken(request));
+  const session = verifyRelayRequestSession(request, store);
   if (!session.authenticated || !session.user) {
     reply.status(401).send({
       code: "unauthorized",
@@ -2773,8 +5393,19 @@ function requireRelayUser(request, reply, store, options = {}) {
   request.relayUser = session.user;
   return session.user;
 }
-function readRelaySessionToken(request) {
-  return bearerToken(request.headers.authorization) ?? queryToken(request.query, "relaySession") ?? queryToken(request.query, "token") ?? readCookie(request.headers.cookie, RELAY_COOKIE_NAME);
+function verifyRelayRequestSession(request, store) {
+  const candidates = [
+    bearerToken(request.headers.authorization),
+    queryToken(request.query, "relaySession"),
+    queryToken(request.query, "token"),
+    readCookie(request.headers.cookie, RELAY_COOKIE_NAME)
+  ];
+  for (const token of candidates) {
+    if (!token) continue;
+    const session = store.verifySession(token);
+    if (session.authenticated) return session;
+  }
+  return store.emptySession();
 }
 function attachRelayCookie(reply, token) {
   reply.header(
@@ -2788,6 +5419,66 @@ function clearRelayCookie(reply) {
     `${RELAY_COOKIE_NAME}=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0`
   );
 }
+function oauthCallbackUrl(request, config2, provider) {
+  const configured = config2.publicBaseUrl?.replace(/^ws:/, "http:").replace(/^wss:/, "https:");
+  const forwardedProto = String(request.headers["x-forwarded-proto"] ?? "").split(",")[0]?.trim();
+  const protocol = forwardedProto || request.protocol;
+  const host = String(request.headers["x-forwarded-host"] ?? request.headers.host ?? "localhost:8788").split(",")[0]?.trim();
+  const base = configured || `${protocol}://${host}`;
+  return `${base}/relay/auth/oauth/${provider}/callback`;
+}
+function signOAuthState(provider, secret) {
+  const payload = Buffer.from(JSON.stringify({ provider, expiresAt: Date.now() + 10 * 6e4, nonce: crypto3.randomBytes(18).toString("base64url") })).toString("base64url");
+  const signature = crypto3.createHmac("sha256", secret).update(payload).digest("base64url");
+  return `${payload}.${signature}`;
+}
+function verifyOAuthState(state, provider, secret) {
+  const [payload, signature] = state.split(".");
+  if (!payload || !signature) return false;
+  const expected = crypto3.createHmac("sha256", secret).update(payload).digest();
+  const actual = Buffer.from(signature, "base64url");
+  if (actual.length !== expected.length || !crypto3.timingSafeEqual(actual, expected)) return false;
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    return parsed.provider === provider && typeof parsed.expiresAt === "number" && parsed.expiresAt > Date.now();
+  } catch {
+    return false;
+  }
+}
+async function fetchGoogleIdentity(code, redirectUri, config2) {
+  const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ code, client_id: config2.googleOAuthClientId, client_secret: config2.googleOAuthClientSecret, redirect_uri: redirectUri, grant_type: "authorization_code" })
+  });
+  if (!tokenResponse.ok) throw new Error("Google token exchange failed.");
+  const tokens = await tokenResponse.json();
+  const response = await fetch("https://openidconnect.googleapis.com/v1/userinfo", { headers: { authorization: `Bearer ${tokens.access_token}` } });
+  if (!response.ok) throw new Error("Google profile lookup failed.");
+  const profile = await response.json();
+  if (!profile.sub || !profile.email || !profile.email_verified) throw new Error("Google did not provide a verified email address.");
+  return { provider: "google", subject: profile.sub, email: profile.email.toLowerCase(), username: profile.email.split("@")[0] || profile.name || "google-user" };
+}
+async function fetchGitHubIdentity(code, redirectUri, config2) {
+  const tokenResponse = await fetch("https://github.com/login/oauth/access_token", {
+    method: "POST",
+    headers: { accept: "application/json", "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ code, client_id: config2.githubOAuthClientId, client_secret: config2.githubOAuthClientSecret, redirect_uri: redirectUri })
+  });
+  if (!tokenResponse.ok) throw new Error("GitHub token exchange failed.");
+  const tokens = await tokenResponse.json();
+  const headers = { accept: "application/vnd.github+json", authorization: `Bearer ${tokens.access_token}`, "user-agent": "remote-codex-relay" };
+  const [userResponse, emailsResponse] = await Promise.all([
+    fetch("https://api.github.com/user", { headers }),
+    fetch("https://api.github.com/user/emails", { headers })
+  ]);
+  if (!userResponse.ok || !emailsResponse.ok) throw new Error("GitHub profile lookup failed.");
+  const user = await userResponse.json();
+  const emails = await emailsResponse.json();
+  const email = emails.find((item) => item.primary && item.verified)?.email ?? emails.find((item) => item.verified)?.email;
+  if (!user.id || !user.login || !email) throw new Error("GitHub did not provide a verified email address.");
+  return { provider: "github", subject: String(user.id), email: email.toLowerCase(), username: user.login };
+}
 function connectionStatus(state) {
   const statuses = /* @__PURE__ */ new Map();
   for (const [deviceId, supervisor] of state.supervisors) {
@@ -2814,7 +5505,9 @@ async function enrichAdminSummary(summary, state, store, conversationWindowDays)
         fetchRelayThreads(supervisor, device.id)
       ]);
       workspacesByDeviceId.set(device.id, workspaces);
-      const workspaceLabelById = new Map(workspaces.map((workspace) => [workspace.id, workspace.label]));
+      const workspaceLabelById = new Map(
+        workspaces.map((workspace) => [workspace.id, workspace.label])
+      );
       threadsByDeviceId.set(
         device.id,
         threads.map((thread) => ({
@@ -2845,7 +5538,11 @@ async function enrichAdminSummary(summary, state, store, conversationWindowDays)
   };
 }
 async function fetchRelayWorkspaces(supervisor, deviceId) {
-  const payload = await forwardSupervisorJson(supervisor, deviceId, "/api/workspaces");
+  const payload = await forwardSupervisorJson(
+    supervisor,
+    deviceId,
+    "/api/workspaces"
+  );
   const rows = Array.isArray(payload) ? payload : [];
   const workspaces = [];
   for (const workspace of rows.filter(isObject)) {
@@ -2863,7 +5560,11 @@ async function fetchRelayWorkspaces(supervisor, deviceId) {
   return workspaces.slice(0, 50);
 }
 async function fetchRelayThreads(supervisor, deviceId) {
-  const payload = await forwardSupervisorJson(supervisor, deviceId, "/api/threads");
+  const payload = await forwardSupervisorJson(
+    supervisor,
+    deviceId,
+    "/api/threads"
+  );
   const rows = Array.isArray(payload) ? payload : [];
   const threads = [];
   for (const thread of rows.filter(isObject)) {
@@ -2896,7 +5597,11 @@ async function enrichPortalSummary(portal, state, store) {
     const threadCacheKey = `${share.deviceId}:${share.threadId}`;
     let threadTitlePromise = threadCache.get(threadCacheKey);
     if (!threadTitlePromise) {
-      threadTitlePromise = fetchRelayThreadTitle(supervisor, share.deviceId, share.threadId);
+      threadTitlePromise = fetchRelayThreadTitle(
+        supervisor,
+        share.deviceId,
+        share.threadId
+      );
       threadCache.set(threadCacheKey, threadTitlePromise);
     }
     let workspaceLabelPromise = Promise.resolve(null);
@@ -2950,7 +5655,11 @@ async function fetchRelayThreadTitle(supervisor, deviceId, threadId) {
   return stringField(thread, "title");
 }
 async function fetchRelayWorkspaceLabel(supervisor, deviceId, workspaceId) {
-  const payload = await forwardSupervisorJson(supervisor, deviceId, `/api/workspaces/${encodeURIComponent(workspaceId)}`);
+  const payload = await forwardSupervisorJson(
+    supervisor,
+    deviceId,
+    `/api/workspaces/${encodeURIComponent(workspaceId)}`
+  );
   return stringField(payload, "label");
 }
 function stableShareThreadTitle(share) {
@@ -3049,7 +5758,7 @@ function isAllowedSharedRuntimeMetadataRequest(method, pathname) {
   if (pathname === "/api/plugins") {
     return true;
   }
-  return /^\/api\/agent-runtimes\/[^/]+\/(?:status|models)$/.test(pathname);
+  return /^\/api\/agent-runtimes\/[^/]+\/(?:status|models|subscription-usage)$/.test(pathname);
 }
 function threadIdFromPath(pathValue) {
   const pathname = new URL(pathValue, "http://relay.local").pathname;
@@ -3081,6 +5790,13 @@ function conversationEventFromRequest(method, pathValue, body) {
   }
   return null;
 }
+function isHostedUserActivityRequest(method, pathValue) {
+  const methodName = method.toUpperCase();
+  if (["GET", "HEAD", "OPTIONS"].includes(methodName)) {
+    return false;
+  }
+  return new URL(pathValue, "http://relay.local").pathname.startsWith("/api/");
+}
 function relayAccessEventKindFromRequest(method, pathValue) {
   const methodName = method.toUpperCase();
   const pathname = new URL(pathValue, "http://relay.local").pathname;
@@ -3096,7 +5812,9 @@ function relayAccessEventKindFromRequest(method, pathValue) {
   if (methodName === "GET" && /^\/api\/workspaces\/[^/]+$/.test(pathname)) {
     return "open_device";
   }
-  if (methodName === "GET" && /^\/api\/workspaces\/[^/]+\/(?:files\/(?:tree|preview|raw|download)|artifacts(?:\/[^/]+(?:\/download)?)?)$/.test(pathname)) {
+  if (methodName === "GET" && /^\/api\/workspaces\/[^/]+\/(?:files\/(?:tree|preview|raw|download)|artifacts(?:\/[^/]+(?:\/download)?)?)$/.test(
+    pathname
+  )) {
     return "read_workspace_file";
   }
   if (["POST", "PUT", "PATCH", "DELETE"].includes(methodName) && /^\/api\/workspaces\/[^/]+\/files(?:\/(?:upload|move))?$/.test(pathname)) {
@@ -3135,7 +5853,12 @@ function isAllowedForRelayAccess(access, method, pathValue) {
   }
   const workspaceId = workspaceIdFromPath(pathValue);
   if (workspaceId) {
-    return isAllowedSharedWorkspacePath(access, methodName, pathname, workspaceId);
+    return isAllowedSharedWorkspacePath(
+      access,
+      methodName,
+      pathname,
+      workspaceId
+    );
   }
   if (access.scope === "device") {
     if (methodName === "GET" && (pathname === "/api/threads" || pathname === "/api/workspaces")) {
@@ -3220,7 +5943,9 @@ function isAllowedSharedWorkspacePath(access, methodName, pathname, workspaceId)
     new RegExp(`^/api/workspaces/${escapedWorkspaceId}/files/download$`),
     new RegExp(`^/api/workspaces/${escapedWorkspaceId}/artifacts$`),
     new RegExp(`^/api/workspaces/${escapedWorkspaceId}/artifacts/[^/]+$`),
-    new RegExp(`^/api/workspaces/${escapedWorkspaceId}/artifacts/[^/]+/download$`)
+    new RegExp(
+      `^/api/workspaces/${escapedWorkspaceId}/artifacts/[^/]+/download$`
+    )
   ];
   if (methodName === "GET" && readPatterns.some((pattern) => pattern.test(pathname))) {
     return true;
@@ -3349,7 +6074,23 @@ var envSchema = z2.object({
   REMOTE_CODEX_RELAY_SESSION_SECRET: z2.string().min(16).optional(),
   REMOTE_CODEX_RELAY_REGISTRATION_ENABLED: z2.string().optional(),
   REMOTE_CODEX_RELAY_REGISTRATION_PASSWORD: z2.string().min(8).optional(),
-  REMOTE_CODEX_RELAY_WEB_DIST_DIR: z2.string().min(1).optional()
+  REMOTE_CODEX_PUBLIC_BASE_URL: z2.string().url().optional(),
+  REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_ID: z2.string().min(1).optional(),
+  REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_SECRET: z2.string().min(1).optional(),
+  REMOTE_CODEX_GOOGLE_OAUTH_ENABLED: z2.string().optional(),
+  REMOTE_CODEX_GITHUB_OAUTH_CLIENT_ID: z2.string().min(1).optional(),
+  REMOTE_CODEX_GITHUB_OAUTH_CLIENT_SECRET: z2.string().min(1).optional(),
+  REMOTE_CODEX_GITHUB_OAUTH_ENABLED: z2.string().optional(),
+  REMOTE_CODEX_EMAIL_VERIFICATION_SECRET: z2.string().min(16).optional(),
+  REMOTE_CODEX_POSTMARK_SERVER_TOKEN: z2.string().min(1).optional(),
+  REMOTE_CODEX_RELAY_WEB_DIST_DIR: z2.string().min(1).optional(),
+  REMOTE_CODEX_HOSTED_SANDBOX_PROVIDER: z2.enum(["disabled", "incus"]).optional(),
+  REMOTE_CODEX_INCUS_HOST_AGENT_URL: z2.string().url().optional(),
+  REMOTE_CODEX_INCUS_HOST_AGENT_TOKEN: z2.string().min(16).optional(),
+  REMOTE_CODEX_HOSTED_RELAY_SERVER_URL: z2.string().url().refine((value) => value.startsWith("ws://") || value.startsWith("wss://")).optional(),
+  REMOTE_CODEX_INCUS_HOST_AGENT_TIMEOUT_MS: z2.coerce.number().int().positive().max(3e4).optional(),
+  REMOTE_CODEX_HOSTED_IDLE_TIMEOUT_MS: z2.coerce.number().int().positive().max(24 * 60 * 6e4).optional(),
+  REMOTE_CODEX_HOSTED_RECONCILE_INTERVAL_MS: z2.coerce.number().int().min(1e4).max(24 * 60 * 6e4).optional()
 });
 function optionalNonEmpty(value) {
   const normalized = value?.trim();
@@ -3369,7 +6110,9 @@ function normalizeOptionalEnv(env) {
       env.REMOTE_CODEX_RELAY_CLIENT_TOKEN
     ),
     REMOTE_CODEX_ADMIN_EMAIL: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_EMAIL),
-    REMOTE_CODEX_RELAY_DATA_DIR: optionalNonEmpty(env.REMOTE_CODEX_RELAY_DATA_DIR),
+    REMOTE_CODEX_RELAY_DATA_DIR: optionalNonEmpty(
+      env.REMOTE_CODEX_RELAY_DATA_DIR
+    ),
     REMOTE_CODEX_RELAY_SESSION_SECRET: optionalNonEmpty(
       env.REMOTE_CODEX_RELAY_SESSION_SECRET
     ),
@@ -3379,8 +6122,38 @@ function normalizeOptionalEnv(env) {
     REMOTE_CODEX_RELAY_REGISTRATION_PASSWORD: optionalNonEmpty(
       env.REMOTE_CODEX_RELAY_REGISTRATION_PASSWORD
     ),
+    REMOTE_CODEX_PUBLIC_BASE_URL: optionalNonEmpty(env.REMOTE_CODEX_PUBLIC_BASE_URL),
+    REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_ID: optionalNonEmpty(env.REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_ID),
+    REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_SECRET: optionalNonEmpty(env.REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_SECRET),
+    REMOTE_CODEX_GOOGLE_OAUTH_ENABLED: optionalNonEmpty(env.REMOTE_CODEX_GOOGLE_OAUTH_ENABLED),
+    REMOTE_CODEX_GITHUB_OAUTH_CLIENT_ID: optionalNonEmpty(env.REMOTE_CODEX_GITHUB_OAUTH_CLIENT_ID),
+    REMOTE_CODEX_GITHUB_OAUTH_CLIENT_SECRET: optionalNonEmpty(env.REMOTE_CODEX_GITHUB_OAUTH_CLIENT_SECRET),
+    REMOTE_CODEX_GITHUB_OAUTH_ENABLED: optionalNonEmpty(env.REMOTE_CODEX_GITHUB_OAUTH_ENABLED),
+    REMOTE_CODEX_EMAIL_VERIFICATION_SECRET: optionalNonEmpty(env.REMOTE_CODEX_EMAIL_VERIFICATION_SECRET),
+    REMOTE_CODEX_POSTMARK_SERVER_TOKEN: optionalNonEmpty(env.REMOTE_CODEX_POSTMARK_SERVER_TOKEN),
     REMOTE_CODEX_RELAY_WEB_DIST_DIR: optionalNonEmpty(
       env.REMOTE_CODEX_RELAY_WEB_DIST_DIR
+    ),
+    REMOTE_CODEX_HOSTED_SANDBOX_PROVIDER: optionalNonEmpty(
+      env.REMOTE_CODEX_HOSTED_SANDBOX_PROVIDER
+    ),
+    REMOTE_CODEX_INCUS_HOST_AGENT_URL: optionalNonEmpty(
+      env.REMOTE_CODEX_INCUS_HOST_AGENT_URL
+    ),
+    REMOTE_CODEX_INCUS_HOST_AGENT_TOKEN: optionalNonEmpty(
+      env.REMOTE_CODEX_INCUS_HOST_AGENT_TOKEN
+    ),
+    REMOTE_CODEX_HOSTED_RELAY_SERVER_URL: optionalNonEmpty(
+      env.REMOTE_CODEX_HOSTED_RELAY_SERVER_URL
+    ),
+    REMOTE_CODEX_INCUS_HOST_AGENT_TIMEOUT_MS: optionalNonEmpty(
+      env.REMOTE_CODEX_INCUS_HOST_AGENT_TIMEOUT_MS
+    ),
+    REMOTE_CODEX_HOSTED_IDLE_TIMEOUT_MS: optionalNonEmpty(
+      env.REMOTE_CODEX_HOSTED_IDLE_TIMEOUT_MS
+    ),
+    REMOTE_CODEX_HOSTED_RECONCILE_INTERVAL_MS: optionalNonEmpty(
+      env.REMOTE_CODEX_HOSTED_RECONCILE_INTERVAL_MS
     )
   };
 }
@@ -3401,7 +6174,26 @@ function loadRelayServerConfig(env = process.env) {
     ),
     registrationEnabledConfigured: parsed.REMOTE_CODEX_RELAY_REGISTRATION_ENABLED !== void 0,
     registrationPassword: parsed.REMOTE_CODEX_RELAY_REGISTRATION_PASSWORD ?? null,
-    webDistDir: parsed.REMOTE_CODEX_RELAY_WEB_DIST_DIR ?? defaultRelayWebDistDir()
+    publicBaseUrl: parsed.REMOTE_CODEX_PUBLIC_BASE_URL?.replace(/\/$/, "") ?? null,
+    googleOAuthClientId: parsed.REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_ID ?? null,
+    googleOAuthClientSecret: parsed.REMOTE_CODEX_GOOGLE_OAUTH_CLIENT_SECRET ?? null,
+    googleOAuthEnabled: parsed.REMOTE_CODEX_GOOGLE_OAUTH_ENABLED !== "false",
+    githubOAuthClientId: parsed.REMOTE_CODEX_GITHUB_OAUTH_CLIENT_ID ?? null,
+    githubOAuthClientSecret: parsed.REMOTE_CODEX_GITHUB_OAUTH_CLIENT_SECRET ?? null,
+    githubOAuthEnabled: parsed.REMOTE_CODEX_GITHUB_OAUTH_ENABLED !== "false",
+    emailVerificationConfigured: Boolean(
+      parsed.REMOTE_CODEX_EMAIL_VERIFICATION_SECRET && parsed.REMOTE_CODEX_POSTMARK_SERVER_TOKEN
+    ),
+    webDistDir: parsed.REMOTE_CODEX_RELAY_WEB_DIST_DIR ?? defaultRelayWebDistDir(),
+    hostedSandbox: {
+      provider: parsed.REMOTE_CODEX_HOSTED_SANDBOX_PROVIDER ?? "disabled",
+      agentUrl: parsed.REMOTE_CODEX_INCUS_HOST_AGENT_URL ?? null,
+      agentToken: parsed.REMOTE_CODEX_INCUS_HOST_AGENT_TOKEN ?? null,
+      relayServerUrl: parsed.REMOTE_CODEX_HOSTED_RELAY_SERVER_URL ?? null,
+      requestTimeoutMs: parsed.REMOTE_CODEX_INCUS_HOST_AGENT_TIMEOUT_MS ?? 1500,
+      idleTimeoutMs: parsed.REMOTE_CODEX_HOSTED_IDLE_TIMEOUT_MS ?? 30 * 6e4,
+      reconcileIntervalMs: parsed.REMOTE_CODEX_HOSTED_RECONCILE_INTERVAL_MS ?? 5 * 6e4
+    }
   };
 }
 function defaultRelayWebDistDir() {