@opengeni/api-router 3.0.1 → 3.1.2

package/src/sandbox/enrollment.ts

@@ -28,7 +28,7 @@
 // FLAG GATE: the whole feature is behind sandboxSelfhostedEnabled (default OFF) —
 // when off the routes 404 (the surface is invisible) and boot is unaffected.
 
-import { randomBytes } from "node:crypto";
+import { createPublicKey, randomBytes, verify } from "node:crypto";
 import {
   resolveEnrollmentSigningSecret,
   resolveRelayTokenSecret,
@@ -36,10 +36,13 @@ import {
 } from "@opengeni/config";
 import {
   DeviceEnrollmentState,
+  enrollmentRenewalProof,
   signEnrollmentBearer,
   signEnrollToken,
   signRelayToken,
   verifyEnrollToken,
+  verifyEnrollmentBearer,
+  type RenewEnrollmentRequest,
   type DeviceEnrollmentLookupResponse,
   type DeviceEnrollmentPollResponse,
   type DeviceEnrollmentStartResponse,
@@ -52,11 +55,14 @@ import {
   consumeDeviceEnrollmentRequest,
   createDeviceEnrollmentRequest,
   denyDeviceEnrollmentRequest,
+  EnrollTokenAlreadyRedeemedError,
+  EnrollTokenOwnerUnavailableError,
   finalizeEnrollmentByToken,
   getDeviceEnrollmentRequestByDeviceCode,
   getEnrollment,
   getPendingDeviceEnrollmentRequestByUserCode,
   getPendingDeviceEnrollmentRequestByUserCodeGlobal,
+  PersonalMachineConnectedElsewhereError,
   type Database,
   type DeviceEnrollmentRequestRecord,
   type EnrollmentOs,
@@ -71,7 +77,8 @@ export const DEVICE_POLL_INTERVAL_SECONDS = 5;
 // The bearer the agent presents to the NATS auth-callout. A bring-your-own-compute
 // machine is PERSISTENT (unlike an ephemeral Modal box, whose lifetime ~= an agent
 // token's hour), so this is long-lived — 30 days, matching the relay token below —
-// and re-minted on every poll/re-enroll. The old 1-hour value (sized for a Modal
+// and renewed automatically by install-key proof, or re-minted on poll/re-enroll.
+// The old 1-hour value (sized for a Modal
 // box) caused a self-hosted agent to drop PERMANENTLY one hour after connecting: the
 // bearer expired and the auth-callout rejected every reconnect ("re-enroll may be
 // required"). A long-lived bearer is safe because the auth-callout RE-CHECKS the
@@ -83,10 +90,69 @@ export const ENROLLMENT_BEARER_TTL_SECONDS = 30 * 24 * 3600;
 // NOT per-stream: the agent presents it on every channel registration for the life
 // of its run, and the producer side has no per-viewer epoch fence (that is the
 // VIEWER's `ogs_` token's job). So it is long-lived — 30 days — re-minted on every
-// poll/re-enroll. The relay re-verifies it (authenticity + the channel-key ws+agent
+// renewal/poll/re-enroll. The relay re-verifies it (authenticity + the channel-key ws+agent
 // scope) on every StreamOpen; a revoked enrollment's machine goes offline at the
 // control plane regardless, so a long-lived relay token cannot reach a dead agent.
 export const RELAY_TOKEN_TTL_SECONDS = 30 * 24 * 3600;
+
+/** Renew an existing grant, including after a long offline interval. The expired
+ * bearer is only an authenticated enrollment/generation locator here: current
+ * install-key possession and live enrollment authority are both required. Normal
+ * NATS/relay authentication continues to reject expired transport credentials.
+ * Nothing creates/reactivates an enrollment or changes its consent or scope. */
+export async function renewEnrollmentCredentials(
+  services: EnrollmentServices,
+  input: RenewEnrollmentRequest,
+  nowSeconds = Math.floor(Date.now() / 1000),
+): Promise<EnrollmentCredentialsResponse | null> {
+  if (Math.abs(nowSeconds - input.signedAt) > 120) return null;
+  const secret = resolveEnrollmentSigningSecret(services.settings);
+  if (!secret) return null;
+  const claims = await verifyEnrollmentBearer(secret, input.bearer, 0);
+  if (
+    !claims ||
+    claims.agentId !== claims.enrollmentId ||
+    claims.subjectPrefix !== `agent.${claims.workspaceId}.${claims.agentId}`
+  )
+    return null;
+  const enrollment = await getEnrollment(services.db, claims.workspaceId, claims.enrollmentId);
+  if (
+    !enrollment ||
+    enrollment.status !== "active" ||
+    enrollment.credentialGeneration !== claims.credentialGeneration
+  )
+    return null;
+  try {
+    const rawKey = Buffer.from(enrollment.pubkey, "base64");
+    const signature = Buffer.from(input.signature, "base64");
+    if (rawKey.length !== 32 || signature.length !== 64) return null;
+    const key = createPublicKey({
+      key: Buffer.concat([Buffer.from("302a300506032b6570032100", "hex"), rawKey]),
+      format: "der",
+      type: "spki",
+    });
+    if (
+      !verify(
+        null,
+        Buffer.from(enrollmentRenewalProof(input.bearer, input.signedAt)),
+        key,
+        signature,
+      )
+    )
+      return null;
+  } catch {
+    return null;
+  }
+  // A concurrent revoke/re-enrollment still wins: issued credentials retain the
+  // captured generation, which the control-plane claim rechecks transactionally.
+  return buildEnrollmentCredentials(services, {
+    secret,
+    workspaceId: enrollment.workspaceId,
+    agentId: enrollment.id,
+    credentialGeneration: enrollment.credentialGeneration,
+    consentedScreenControl: enrollment.allowScreenControl,
+  });
+}
 // The headless enroll token (`oget_`; design 11 §A2.1) TTL. 1h: long enough to
 // script a fleet rollout, short enough to bound exposure of a workspace-scoped
 // secret that IS the grant (no human approve). Re-mintable by an authorized user.
@@ -294,15 +360,19 @@ export async function denyDeviceEnrollment(
 }
 
 /** MINT a headless enroll token (design 11 §A2.2). Signs an `oget_` token bound to
- *  the workspace + account + the screen-control consent, with a 1h TTL. Returns
- *  null when the credential plane is disabled (no signing secret) so the route can
- *  mirror poll's "disabled" handling. The token value is NEVER logged. */
+ *  the workspace + account + the screen-control consent, with a 1h TTL. With an
+ *  `ownerSubjectId` the token is personal (`enroll_user`): the machine it connects
+ *  belongs to that person. Callers must pass only an authenticated human's own
+ *  subject. Returns null when the credential plane is disabled (no signing secret)
+ *  so the route can mirror poll's "disabled" handling. The token value is NEVER
+ *  logged. */
 export async function mintEnrollToken(
   services: EnrollmentServices,
   input: {
     accountId: string;
     workspaceId: string;
     allowScreenControl: boolean;
+    ownerSubjectId?: string | null;
   },
 ): Promise<MintEnrollTokenResponse | null> {
   const { settings } = services;
@@ -312,18 +382,28 @@ export async function mintEnrollToken(
   }
   const nowSeconds = Math.floor(Date.now() / 1000);
   const exp = nowSeconds + ENROLL_TOKEN_TTL_SECONDS;
-  const token = await signEnrollToken(secret, {
-    typ: "enroll",
+  const claims = {
     workspaceId: input.workspaceId,
     accountId: input.accountId,
     allowScreenControl: input.allowScreenControl,
     iat: nowSeconds,
     exp,
-  });
+    // Single-use: the exchange records this id, so the token connects one machine.
+    jti: randomBytes(18).toString("base64url"),
+  };
+  const ownerSubjectId = input.ownerSubjectId ?? null;
+  const token = await signEnrollToken(
+    secret,
+    ownerSubjectId !== null
+      ? { typ: "enroll_user", ownerSubjectId, ...claims }
+      : { typ: "enroll", ...claims },
+  );
   return {
     token,
     expiresAt: new Date(exp * 1000).toISOString(),
     expiresInSeconds: ENROLL_TOKEN_TTL_SECONDS,
+    scope: ownerSubjectId !== null ? "user" : "workspace",
+    allowScreenControl: input.allowScreenControl,
   };
 }
 
@@ -331,7 +411,11 @@ export async function mintEnrollToken(
 export type ExchangeEnrollTokenResult =
   | { ok: true; credentials: EnrollTokenExchangeResponse["credentials"] }
   | { ok: false; reason: "disabled" }
-  | { ok: false; reason: "invalid" };
+  | { ok: false; reason: "invalid" }
+  | { ok: false; reason: "used" }
+  | { ok: false; reason: "owner_unavailable" }
+  | { ok: false; reason: "connected_elsewhere" }
+  | { ok: false; reason: "busy" };
 
 /** EXCHANGE a headless enroll token (design 11 §A2.3) — the UNAUTHENTICATED path
  *  where the token IS the auth. Verifies the `oget_` token, then performs the SAME
@@ -366,18 +450,43 @@ export async function exchangeEnrollToken(
 
   // The SAME finalize as approve, but driven by the token's claims (no pending row).
   const sandboxName = (input.machineName?.trim() || `${input.os} machine`).slice(0, 256);
-  const { enrollment } = await finalizeEnrollmentByToken(db, {
-    accountId: claims.accountId,
-    workspaceId: claims.workspaceId,
-    pubkey: input.publicKey,
-    hasDisplay: input.canOfferDisplay,
-    // The token's allowScreenControl is the AUTHORITATIVE consent (NOT the agent's
-    // requestsScreenControl) — it was baked in at mint by the authorizing user.
-    allowScreenControl: claims.allowScreenControl,
-    os: input.os,
-    arch: input.arch,
-    sandboxName,
-  });
+  let enrollment: Awaited<ReturnType<typeof finalizeEnrollmentByToken>>["enrollment"];
+  try {
+    ({ enrollment } = await finalizeEnrollmentByToken(db, {
+      accountId: claims.accountId,
+      workspaceId: claims.workspaceId,
+      // A personal token connects the signed owner's own machine; the finalizer
+      // rechecks that person's live membership and workspace access.
+      ...(claims.typ === "enroll_user" ? { ownerSubjectId: claims.ownerSubjectId } : {}),
+      pubkey: input.publicKey,
+      hasDisplay: input.canOfferDisplay,
+      // The token's allowScreenControl is the AUTHORITATIVE consent (NOT the agent's
+      // requestsScreenControl) — it was baked in at mint by the authorizing user.
+      allowScreenControl: claims.allowScreenControl,
+      os: input.os,
+      arch: input.arch,
+      sandboxName,
+      // A token with an id connects one machine; the same machine may retry.
+      ...(claims.jti ? { tokenId: claims.jti, tokenExpiresAt: new Date(claims.exp * 1000) } : {}),
+    }));
+  } catch (error) {
+    if (error instanceof EnrollTokenAlreadyRedeemedError) {
+      return { ok: false, reason: "used" };
+    }
+    if (error instanceof EnrollTokenOwnerUnavailableError) {
+      return { ok: false, reason: "owner_unavailable" };
+    }
+    if (error instanceof PersonalMachineConnectedElsewhereError) {
+      // The owner's personal enrollment for this machine lives in another
+      // workspace; nothing was written and the token was not claimed.
+      return { ok: false, reason: "connected_elsewhere" };
+    }
+    if ((error as { code?: unknown } | null)?.code === "55P03") {
+      // The owner's organization membership is changing right now.
+      return { ok: false, reason: "busy" };
+    }
+    throw error;
+  }
 
   const credentials = await buildEnrollmentCredentials(services, {
     secret,

package/src/sandbox/machine-audience.ts

@@ -0,0 +1,192 @@
+// Changing who can use a Connected Machine (Workspace or Only me) in place.
+// The routes in ../routes/machines.ts stay thin: this module owns who may ask
+// for which change, and the public shape of the preview and its refusals. The
+// database functions recompute everything under the machine lock, so these
+// checks only decide whether the caller may ask at all.
+
+import {
+  ChangeMachineAudienceResponse,
+  MachineAudiencePreview,
+  type MachineAudience,
+} from "@opengeni/contracts";
+import type {
+  MachineAudienceChangeRecord,
+  MachineAudiencePreviewRecord,
+  MachineAudienceRefusal,
+} from "@opengeni/db";
+import { ApiHttpError } from "../http/api-error";
+
+type AudienceCaller = {
+  subjectId: string;
+  permissions: readonly string[];
+};
+
+type AudienceMachine = {
+  workspaceId: string;
+  scope: "organization" | "workspace" | "user";
+};
+
+/**
+ * Decide whether the caller may ask for this change and who would own the
+ * machine. Narrowing to Only me: the person who will own it, or a workspace
+ * admin acting for that person. Sharing with the workspace: a workspace admin
+ * (the database also requires the caller to be the machine's owner, so nobody
+ * can expose another person's Only me machine).
+ */
+export function machineAudienceRequestFor(
+  caller: AudienceCaller,
+  routeWorkspaceId: string,
+  machine: AudienceMachine,
+  request: { audience: MachineAudience; ownerSubjectId?: string | undefined },
+): { ownerSubjectId: string | null } {
+  if (machine.scope === "organization") {
+    throw new ApiHttpError(422, {
+      code: "validation_failed",
+      message:
+        "Organization machines are shared with the whole organization and can't be changed here.",
+      retryable: false,
+    });
+  }
+  if (machine.workspaceId !== routeWorkspaceId) {
+    throw new ApiHttpError(409, {
+      code: "conflict",
+      message: "Change who can use this machine from the workspace it was connected to.",
+      retryable: false,
+      details: { machineWorkspaceId: machine.workspaceId },
+    });
+  }
+  const workspaceAdmin = caller.permissions.includes("workspace:admin");
+  if (request.audience === "workspace") {
+    if (request.ownerSubjectId !== undefined) {
+      throw new ApiHttpError(400, {
+        code: "validation_failed",
+        message: "A machine shared with the workspace has no single owner.",
+        retryable: false,
+      });
+    }
+    if (!workspaceAdmin) {
+      throw new ApiHttpError(403, {
+        code: "forbidden",
+        message: "missing permission: workspace:admin",
+        retryable: false,
+      });
+    }
+    return { ownerSubjectId: null };
+  }
+  const ownerSubjectId = request.ownerSubjectId ?? caller.subjectId;
+  if (ownerSubjectId !== caller.subjectId && !workspaceAdmin) {
+    throw new ApiHttpError(403, {
+      code: "forbidden",
+      message: "missing permission: workspace:admin",
+      retryable: false,
+    });
+  }
+  return { ownerSubjectId };
+}
+
+const REFUSALS: Record<MachineAudienceRefusal, { status: number; message: string }> = {
+  machine_not_found: { status: 404, message: "machine not found in this access scope" },
+  organization_machine: {
+    status: 422,
+    message:
+      "Organization machines are shared with the whole organization and can't be changed here.",
+  },
+  invalid_target: { status: 400, message: "Choose Workspace or Only me." },
+  already_target: { status: 409, message: "The machine already has this audience." },
+  owner_not_member: {
+    status: 422,
+    message: "The new owner must be an active member of this organization.",
+  },
+  owner_lacks_workspace_access: {
+    status: 422,
+    message: "The new owner must be able to use this workspace.",
+  },
+  not_machine_owner: {
+    status: 403,
+    message: "Only the machine's owner can share it with the workspace.",
+  },
+};
+
+export function machineAudienceRefusalError(refusal: MachineAudienceRefusal): ApiHttpError {
+  const known = REFUSALS[refusal] ?? { status: 409, message: "The machine can't change now." };
+  return new ApiHttpError(known.status, {
+    code:
+      known.status === 404
+        ? "not_found"
+        : known.status === 403
+          ? "forbidden"
+          : known.status === 409
+            ? "conflict"
+            : "validation_failed",
+    message: known.message,
+    retryable: false,
+    details: { refusal },
+  });
+}
+
+export function machineAudiencePreview(
+  record: MachineAudiencePreviewRecord,
+): MachineAudiencePreview {
+  return MachineAudiencePreview.parse({
+    enrollmentId: record.enrollmentId,
+    sandboxId: record.sandboxId,
+    machineName: record.machineName,
+    currentAudience: record.currentAudience,
+    targetAudience: record.targetAudience,
+    generation: record.generation,
+    ownerSubjectId: record.targetAudience === "only_me" ? record.ownerSubjectId : null,
+    summary: record.summary,
+    ready: record.ready,
+    items: record.items.map((item) => ({
+      kind: item.kind,
+      action: item.action,
+      sessionId: item.sessionId ?? null,
+      scheduledTaskId: item.scheduledTaskId ?? null,
+      enrollmentId: item.enrollmentId ?? null,
+      workspaceId: item.workspaceId ?? null,
+      relation: item.relation ?? null,
+      visibility: item.visibility ?? null,
+      title: (item.kind === "schedule" ? item.name : item.title) ?? null,
+      ownerSubjectId: item.ownerSubjectId ?? null,
+      stopsTurn: item.stopsTurn ?? false,
+      stopsCommands: item.stopsCommands ?? 0,
+    })),
+  });
+}
+
+/** Map an applied change, or explain why nothing changed. */
+export function machineAudienceChangeResponse(
+  record: MachineAudienceChangeRecord,
+): ChangeMachineAudienceResponse {
+  switch (record.outcome) {
+    case "changed":
+      return ChangeMachineAudienceResponse.parse({
+        enrollmentId: record.enrollmentId,
+        sandboxId: record.sandboxId,
+        previousAudience: record.previousAudience,
+        audience: record.audience,
+        ownerSubjectId: record.ownerSubjectId,
+        generation: record.generation,
+        summary: record.summary,
+        detachedSessionIds: record.detachedSessionIds,
+        keptSessionIds: record.keptSessionIds,
+      });
+    case "stale":
+      throw new ApiHttpError(409, {
+        code: "conflict",
+        message: "The machine changed since you reviewed it. Review the list again.",
+        retryable: false,
+        details: { reason: "stale", generation: record.generation },
+      });
+    case "blocked":
+      throw new ApiHttpError(409, {
+        code: "conflict",
+        message:
+          "This computer is also connected as a separate machine. Remove that copy first, then try again.",
+        retryable: false,
+        details: { reason: "blocked", preview: machineAudiencePreview(record.preview) },
+      });
+    case "refused":
+      throw machineAudienceRefusalError(record.refusal);
+  }
+}

package/src/sandbox/machines.ts

@@ -21,6 +21,7 @@
 
 import type { Settings } from "@opengeni/config";
 import {
+  enrollmentMacPermissions,
   getSession,
   getLiveEnrollmentConnection,
   listEnrollments,
@@ -32,8 +33,13 @@ import {
   type EnrollmentRecord,
   type MachineMetricsRow,
 } from "@opengeni/db";
-import { MachineView, MetricSample, type MachinesResponse } from "@opengeni/contracts";
-import { managedSessionGroupBackend } from "@opengeni/core";
+import {
+  MachineView,
+  MetricSample,
+  type MachineRuntime,
+  type MachinesResponse,
+} from "@opengeni/contracts";
+import { managedSessionGroupBackend, sessionGroupMachinePresentation } from "@opengeni/core";
 import { selfhostedHeartbeatLiveness } from "@opengeni/runtime/sandbox";
 
 export type MachinesServices = {
@@ -41,7 +47,7 @@ export type MachinesServices = {
   settings: Settings;
 };
 
-const ACTIVE_UPDATE_STATUSES = new Set([
+export const ACTIVE_UPDATE_STATUSES: ReadonlySet<string> = new Set([
   "requested",
   "accepted",
   "waiting_for_idle",
@@ -51,7 +57,7 @@ const ACTIVE_UPDATE_STATUSES = new Set([
   "restarting",
 ]);
 
-function compareAgentVersions(left: string, right: string): number | null {
+export function compareAgentVersions(left: string, right: string): number | null {
   const parse = (value: string): { core: number[]; prerelease: string | null } | null => {
     const match = /^(?:v)?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(value.trim());
     if (!match) return null;
@@ -73,28 +79,57 @@ function compareAgentVersions(left: string, right: string): number | null {
   return a.prerelease.localeCompare(b.prerelease);
 }
 
-function runtimeFor(settings: Settings, enrollment: EnrollmentRecord): MachineView["runtime"] {
-  const desiredVersion =
-    enrollment.agentUpdateChannel === "beta"
-      ? (settings.agentBetaVersion ?? settings.agentStableVersion)
-      : settings.agentStableVersion;
-  const update = enrollment.agentUpdate;
-  const activeUpdate = update ? ACTIVE_UPDATE_STATUSES.has(update.status) : false;
+/** The build the operator promoted for a machine's update channel. */
+export function promotedAgentVersion(
+  settings: Pick<Settings, "agentStableVersion" | "agentBetaVersion">,
+  channel: string | null,
+): string {
+  return channel === "beta"
+    ? (settings.agentBetaVersion ?? settings.agentStableVersion)
+    : settings.agentStableVersion;
+}
+
+/** Older Mac updaters replace a single file inside a sealed app. They must
+ * bootstrap once through the official whole-app installer, never an RPC swap. */
+export function machineUpdateBlockedReason(os: string, version: string | null): string | null {
+  if (os !== "macos") return null;
+  const order = version ? compareAgentVersions(version, "0.1.29") : null;
+  return order !== null && order >= 0
+    ? null
+    : "Install Opengeni Agent 0.1.29 or newer with the official Mac installer first. This older updater cannot preserve the signed application.";
+}
+
+type AgentUpdateRecord = EnrollmentRecord["agentUpdate"];
+
+/** Where the installed agent stands against the promoted build. A failed update
+ * stops mattering once its target (or newer) is installed, and a busy machine
+ * postponing an update (`update_busy_*`) has not failed: it is still outdated. */
+export function agentVersionState(
+  installedVersion: string | null,
+  desiredVersion: string | null,
+  update: AgentUpdateRecord,
+): MachineRuntime["versionState"] {
+  if (update && ACTIVE_UPDATE_STATUSES.has(update.status)) return "updating";
+  if (
+    update?.status === "failed" &&
+    !update.errorCode?.startsWith("update_busy") &&
+    !(installedVersion && (compareAgentVersions(installedVersion, update.targetVersion) ?? -1) >= 0)
+  ) {
+    return "update_failed";
+  }
   const order =
-    enrollment.agentVersion && desiredVersion
-      ? compareAgentVersions(enrollment.agentVersion, desiredVersion)
+    installedVersion && desiredVersion
+      ? compareAgentVersions(installedVersion, desiredVersion)
       : null;
-  const versionState = activeUpdate
-    ? "updating"
-    : update?.status === "failed"
-      ? "update_failed"
-      : order === null
-        ? "unknown"
-        : order === 0
-          ? "current"
-          : order < 0
-            ? "outdated"
-            : "ahead";
+  if (order === null) return "unknown";
+  if (order === 0) return "current";
+  return order < 0 ? "outdated" : "ahead";
+}
+
+function runtimeFor(settings: Settings, enrollment: EnrollmentRecord): MachineView["runtime"] {
+  const desiredVersion = promotedAgentVersion(settings, enrollment.agentUpdateChannel);
+  const update = enrollment.agentUpdate;
+  const versionState = agentVersionState(enrollment.agentVersion, desiredVersion, update);
   const capability = (name: string): boolean => enrollment.agentCapabilities[name] === true;
   return {
     installedVersion: enrollment.agentVersion,
@@ -102,6 +137,7 @@ function runtimeFor(settings: Settings, enrollment: EnrollmentRecord): MachineVi
     updateChannel: enrollment.agentUpdateChannel,
     desiredVersion,
     versionState,
+    updateBlockedReason: machineUpdateBlockedReason(enrollment.os, enrollment.agentVersion),
     capabilities: {
       exec: capability("exec"),
       filesystem: capability("filesystem"),
@@ -113,8 +149,15 @@ function runtimeFor(settings: Settings, enrollment: EnrollmentRecord): MachineVi
       operationResourcePolicy: capability("operationResourcePolicy"),
       operationCpuQuota: capability("operationCpuQuota"),
       transactionalFsWrite: capability("transactionalFsWrite"),
+      credentialRenew: capability("credentialRenew"),
+      screenControl:
+        typeof enrollment.agentCapabilities.screenControl === "boolean"
+          ? enrollment.agentCapabilities.screenControl
+          : null,
     },
     update,
+    macPermissions:
+      enrollment.os === "macos" ? enrollmentMacPermissions(enrollment.agentCapabilities) : null,
   };
 }
 
@@ -258,23 +301,24 @@ export async function listMachines(
   if (session && groupBackend) {
     const groupActive = activeSandboxId === null;
     const groupLease = await readLease(db, workspaceId, session.sandboxGroupId);
+    const presentation = sessionGroupMachinePresentation(groupBackend);
+    const localHost = groupBackend === "local";
     machines.push(
       MachineView.parse({
         sandboxId: session.sandboxGroupId,
         enrollmentId: null,
-        name: "session sandbox",
-        kind: groupBackend === "opensandbox" ? "opensandbox" : "modal",
+        name: presentation.name,
+        kind: presentation.kind,
         state: "online",
         active: groupActive,
         isSessionGroup: true,
         workspaceGeneration: groupLease?.workspaceGeneration ?? null,
         archiveGeneration: groupLease?.archiveGeneration ?? null,
         archiveComplete: groupLease?.archiveComplete ?? false,
-        // The Modal group box is a cloud Linux box; its precise OS/arch is not
-        // surfaced as a metric, so the dashboard shows the canonical linux/x86_64.
-        os: "linux",
-        arch: "x86_64",
-        hasDisplay: false,
+        // A local sandbox is this machine. Other managed providers run a Linux box.
+        os: localHost ? process.platform : "linux",
+        arch: localHost ? process.arch : "x86_64",
+        hasDisplay: localHost,
         desktopUnavailableReason: null,
         allowScreenControl: false,
         sharedSessionCount: 1,