letagents 0.12.11 → 0.12.12

package/dist/mcp/local-state/agent-sessions.js

@@ -26,6 +26,21 @@ export function getCurrentAgentSession(roomId) {
     }
     return best;
 }
+/**
+ * Every stored session (active or ended) this identity had in the room,
+ * most recently updated first. Re-registration consults the FULL lineage so a
+ * replayed prior label reuses the base recorded when that exact label was
+ * allocated — a latest-only lookup would lose an older concurrent sibling's
+ * base and misread its restart as a deliberate rename.
+ */
+export function getStoredAgentSessionsForRoomIdentity(roomId, agentKey) {
+    if (!roomId || !agentKey)
+        return [];
+    const state = readLocalState();
+    return Object.values(state.agent_sessions ?? {})
+        .filter((session) => session.room_id === roomId && session.agent_key === agentKey)
+        .sort((left, right) => right.updated_at.localeCompare(left.updated_at));
+}
 export function saveAgentSession(session, makeCurrent = true) {
     updateLocalState((state) => {
         state.agent_sessions = state.agent_sessions ?? {};

package/dist/mcp/server/register-tools.js

@@ -4,16 +4,27 @@ import { registerOnboardingTools } from "./tools/onboarding.js";
 import { registerRentalTools } from "./tools/rental.js";
 import { registerRepoInitializationTool, registerRepoVisibilityTool, registerRoomInspectionTools, registerRoomJoinTools, registerRoomResumeTool, } from "./tools/rooms.js";
 import { registerTaskTools } from "./tools/tasks.js";
-export function registerTools(server) {
-    registerRoomJoinTools(server);
-    registerAgentSessionTools(server);
-    registerRoomInspectionTools(server);
-    registerStatusTools(server);
-    registerTaskTools(server);
-    registerRepoInitializationTool(server);
-    registerMessageTools(server);
-    registerOnboardingTools(server);
-    registerRoomResumeTool(server);
-    registerRentalTools(server);
-    registerRepoVisibilityTool(server);
+import { registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
+import { toolSurfaceForExecutionProfile } from "./runtime/tool-surface-policy.js";
+import { profileAwareToolServer } from "./supervised-tool-facade.js";
+export function registerTools(server, profile = "autonomous_mcp_worker", supervisedProvider = process.env.LETAGENTS_SUPERVISOR_PROVIDER?.trim() || null) {
+    const tools = profileAwareToolServer(server, profile, undefined, supervisedProvider);
+    const surface = toolSurfaceForExecutionProfile(profile);
+    registerRoomJoinTools(tools);
+    if (surface.agentSessionLifecycle)
+        registerAgentSessionTools(tools);
+    registerRoomInspectionTools(tools);
+    registerStatusTools(tools);
+    registerTaskTools(tools);
+    registerRepoInitializationTool(tools);
+    registerMessageTools(tools, { includeDeliveryLoop: surface.deliveryLoop });
+    if (profile === "supervised_room_turn" && supervisedProvider === "cursor")
+        registerSupervisedRoomTurnTools(tools);
+    if (surface.onboarding)
+        registerOnboardingTools(tools);
+    if (surface.roomResume)
+        registerRoomResumeTool(tools);
+    if (surface.rental)
+        registerRentalTools(tools);
+    registerRepoVisibilityTool(tools);
 }

package/dist/mcp/server/runtime/agent-sessions.js

@@ -5,13 +5,15 @@ import { normalizeAgentBaseName } from "../../../shared/codenames.js";
 import { formatOwnerAttribution } from "../../../shared/agent-identity.js";
 import { LETAGENTS_AGENT_SESSION_ID_HEADER, LETAGENTS_AGENT_SESSION_TOKEN_HEADER, } from "../../../shared/request-headers.js";
 import { AGENT_INSTANCE_UUID, detectAgentIdeLabel, detectAgentRuntimeLabel, ensureAgentIdentity, } from "./identity.js";
-import { requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { isSupervisedBoundedTurn, requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { resolveCurrentSupervisedWorkerSession } from "./supervisor-bridge.js";
 // A worker bearer already represents a server-side worker session. This local
 // marker lets the MCP tool contract stay session-shaped without persisting or
 // transmitting a second set of credentials.
 export const WORKER_BEARER_AGENT_SESSION_ID = "worker_bearer";
 export function buildAgentDeliveryHeaders(agentSession) {
-    if (!agentSession || requireValidWorkerBearerRuntime().mode === "worker") {
+    const runtime = requireValidWorkerBearerRuntime();
+    if (!agentSession || runtime.mode === "worker" || runtime.mode === "supervised") {
         return {};
     }
     return {
@@ -62,6 +64,33 @@ export function resolveAgentSession(roomId, sessionId) {
     }
     return session;
 }
+/**
+ * The stable base this client declares as `requested_base_display_name` when
+ * registering. Rules (task_66):
+ * - An explicit display_name that replays the EXACT label of any prior stored
+ *   session for this room+identity is a resume, not a rename: reuse the base
+ *   recorded when THAT label was allocated, so a server-decorated label
+ *   converges. The whole lineage is consulted (most recent first) because a
+ *   latest-only lookup would lose an older concurrent sibling's base and
+ *   misread its restart as a deliberate rename.
+ * - Any other explicit display_name is deliberate intent and IS the base —
+ *   a numeric-ending custom name ("Agent 47") is therefore never demoted.
+ * - With no explicit name, fall back to the most recent recorded base in the
+ *   lineage, then to the durable identity's display name.
+ */
+export function resolveClientRequestedBase(input) {
+    const explicit = input.explicitDisplayName?.trim() || "";
+    const lineage = input.priorSessions ?? [];
+    if (explicit) {
+        const replayed = lineage.find((session) => session.display_name?.trim() === explicit);
+        const replayedBase = replayed?.requested_base_display_name?.trim() || "";
+        return replayedBase || explicit;
+    }
+    const latestBase = lineage
+        .map((session) => session.requested_base_display_name?.trim() || "")
+        .find((base) => base.length > 0);
+    return latestBase || input.identityDisplayName.trim();
+}
 export function identityFromAgentSession(session) {
     return {
         name: normalizeAgentBaseName(session.display_name),
@@ -88,7 +117,17 @@ export function requireWorkerAgentSession(roomId, sessionId) {
     return session;
 }
 export async function resolveWorkerToolIdentity(input) {
-    if (requireValidWorkerBearerRuntime().mode === "worker" &&
+    const runtimeMode = requireValidWorkerBearerRuntime().mode;
+    if (runtimeMode === "supervised") {
+        const agentSession = await resolveCurrentSupervisedWorkerSession(input.roomId);
+        if (input.agentSessionId
+            && input.agentSessionId !== WORKER_BEARER_AGENT_SESSION_ID
+            && input.agentSessionId !== agentSession.session_id) {
+            throw new Error(`Daemon-supervised worker session is ${agentSession.session_id}, not ${input.agentSessionId}.`);
+        }
+        return { identity: identityFromAgentSession(agentSession), agentSession };
+    }
+    if (runtimeMode === "worker" &&
         (!input.agentSessionId || input.agentSessionId === WORKER_BEARER_AGENT_SESSION_ID)) {
         const identity = await ensureAgentIdentity();
         const now = new Date().toISOString();
@@ -121,7 +160,7 @@ export async function resolveWorkerToolIdentity(input) {
     }
     const agentSession = input.agentSessionId
         ? requireWorkerAgentSession(input.roomId, input.agentSessionId)
-        : input.roomId && await isLocalRoomStorageEnabled(input.roomId)
+        : input.roomId && !isSupervisedBoundedTurn() && await isLocalRoomStorageEnabled(input.roomId)
             ? await ensureLocalWorkerAgentSession(input.roomId)
             : requireWorkerAgentSession(input.roomId, input.agentSessionId);
     return {
@@ -163,7 +202,8 @@ export function getAgentSessionRepoBranch(cwd) {
     return getGitCurrentBranch(workingDir);
 }
 export function agentSessionCredentials(agentSession) {
-    if (requireValidWorkerBearerRuntime().mode === "worker") {
+    const runtime = requireValidWorkerBearerRuntime();
+    if (runtime.mode === "worker" || runtime.mode === "supervised") {
         return {};
     }
     return {

package/dist/mcp/server/runtime/api.js

@@ -1,9 +1,30 @@
 import { clearAuthenticatedAccountCache } from "./auth-cache.js";
 import { requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { borrowCurrentSupervisedWorkerCredential, } from "./supervisor-bridge.js";
 let ownerAuthStoreLoader = () => import("../../local-state.js");
+let supervisedCredentialBorrower = () => borrowCurrentSupervisedWorkerCredential();
 export function setOwnerAuthStoreLoaderForTest(loader) {
     ownerAuthStoreLoader = loader ?? (() => import("../../local-state.js"));
 }
+export function setSupervisedCredentialBorrowerForTest(borrower) {
+    supervisedCredentialBorrower = borrower ?? (() => borrowCurrentSupervisedWorkerCredential());
+}
+export class SupervisedWorkerCredentialError extends Error {
+    code;
+    constructor(code) {
+        super(code === "SUPERVISED_CREDENTIAL_UNAVAILABLE"
+            ? "The daemon-supervised worker credential is not available yet."
+            : "The daemon-supervised worker credential is stale or missing its exact context.");
+        this.code = code;
+        this.name = "SupervisedWorkerCredentialError";
+    }
+}
+async function getSupervisedCredential() {
+    const result = await supervisedCredentialBorrower();
+    if (result.state === "available")
+        return result.credential;
+    throw new SupervisedWorkerCredentialError(result.state === "deferred" ? "SUPERVISED_CREDENTIAL_UNAVAILABLE" : "SUPERVISED_CREDENTIAL_STALE");
+}
 export const API_URL = (process.env.LETAGENTS_API_URL || "http://localhost:3001").replace(/\/+$/, "");
 export class ApiError extends Error {
     status;
@@ -20,6 +41,8 @@ export async function getLetagentsToken() {
     if (runtime.mode === "worker") {
         return runtime.bearer;
     }
+    if (runtime.mode === "supervised")
+        return getSupervisedCredential();
     const envToken = process.env.LETAGENTS_TOKEN?.trim();
     if (envToken) {
         return envToken;
@@ -75,6 +98,11 @@ export async function apiCall(path, options) {
         // every caller spelling of Authorization is overwritten.
         headers.set("Authorization", `Bearer ${runtime.bearer}`);
     }
+    else if (runtime.mode === "supervised") {
+        // Resolve on every API request: the daemon may rotate the in-memory
+        // credential while Codex remains running.
+        headers.set("Authorization", `Bearer ${await getSupervisedCredential()}`);
+    }
     else {
         const authorizationHeader = await getAuthorizationHeader();
         if (authorizationHeader && !headers.has("Authorization")) {
@@ -87,7 +115,7 @@ export async function apiCall(path, options) {
     });
     if (!res.ok) {
         const body = await res.text();
-        if (res.status === 401 && requireValidWorkerBearerRuntime().mode !== "worker") {
+        if (res.status === 401 && requireValidWorkerBearerRuntime().mode === "owner") {
             // Only clear on 401 (invalid/expired credential), NOT on 403
             // (valid credential but insufficient permissions, e.g., private repo access)
             const { clearStoredAuth } = await ownerAuthStoreLoader();

package/dist/mcp/server/runtime/execution-profile.js

@@ -0,0 +1,19 @@
+export const EXECUTION_PROFILES = [
+    "supervised_room_turn",
+    "autonomous_mcp_worker",
+    "interactive_desktop",
+];
+export const LETAGENTS_EXECUTION_PROFILE_ENV = "LETAGENTS_EXECUTION_PROFILE";
+export const LETAGENTS_SUPERVISED_BOUNDED_TURNS_ENV = "LETAGENTS_SUPERVISED_BOUNDED_TURNS";
+export function executionProfile(env = process.env) {
+    const configured = env[LETAGENTS_EXECUTION_PROFILE_ENV]?.trim();
+    const bounded = env[LETAGENTS_SUPERVISED_BOUNDED_TURNS_ENV]?.trim() === "1";
+    if (configured && !EXECUTION_PROFILES.includes(configured)) {
+        throw new Error(`Invalid ${LETAGENTS_EXECUTION_PROFILE_ENV}: ${configured}`);
+    }
+    const profile = (configured || "autonomous_mcp_worker");
+    if (bounded !== (profile === "supervised_room_turn")) {
+        throw new Error(`${LETAGENTS_EXECUTION_PROFILE_ENV}=supervised_room_turn and ${LETAGENTS_SUPERVISED_BOUNDED_TURNS_ENV}=1 must be configured together.`);
+    }
+    return profile;
+}

package/dist/mcp/server/runtime/identity/directory.js

@@ -5,7 +5,7 @@ import { requireValidWorkerBearerRuntime } from "../worker-bearer.js";
 import { getAuthenticatedAccountCache, setAuthenticatedAccountCache, } from "../auth-cache.js";
 import { AGENT_OWNER_LABEL, readCommandOutput, } from "./config.js";
 export async function getAuthenticatedAgentDirectory() {
-    if (requireValidWorkerBearerRuntime().mode === "worker") {
+    if (requireValidWorkerBearerRuntime().mode !== "owner") {
         return null;
     }
     try {
@@ -25,7 +25,7 @@ export async function getAuthenticatedAgentDirectory() {
     }
 }
 async function getAuthenticatedAccountProfile() {
-    if (requireValidWorkerBearerRuntime().mode === "worker") {
+    if (requireValidWorkerBearerRuntime().mode !== "owner") {
         return null;
     }
     const envToken = (process.env.LETAGENTS_TOKEN || "").trim();

package/dist/mcp/server/runtime/presence.js

@@ -4,6 +4,7 @@ import { isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, touchRoo
 import { apiCall, isMissingRouteError } from "./api.js";
 import { agentSessionCredentials, identityFromAgentSession } from "./agent-sessions.js";
 import { getSessionLivenessRegistration } from "./identity.js";
+import { isSupervisedBoundedTurn } from "./worker-bearer.js";
 const roomPresenceByIdentity = new Map();
 export function getRememberedRoomPresence(roomId, identity) {
     if (!roomId || !identity) {
@@ -18,7 +19,7 @@ export async function syncRoomPresence(roomId, identity, presence, agentSession)
     }
     roomPresenceByIdentity.set(getRoomIdentityPresenceCacheKey(roomId, resolvedIdentity.actor_label), presence);
     const { localRoomId, cloudRoomId } = await resolveLocalRoomStorageIdentifiers(roomId);
-    if (await isLocalRoomStorageEnabled(roomId)) {
+    if (!isSupervisedBoundedTurn() && await isLocalRoomStorageEnabled(roomId)) {
         touchRoomSession(localRoomId || roomId);
         return;
     }
@@ -38,7 +39,8 @@ export async function syncRoomPresence(roomId, identity, presence, agentSession)
                 ...agentSessionCredentials(agentSession),
             }),
         });
-        touchRoomSession(apiRoomId);
+        if (!isSupervisedBoundedTurn())
+            touchRoomSession(apiRoomId);
     }
     catch (error) {
         if (isMissingRouteError(error)) {

package/dist/mcp/server/runtime/room-api.js

@@ -3,13 +3,24 @@ import { LETAGENTS_ORIGIN_ROOM_ID_HEADER } from "../../../shared/request-headers
 import { apiCall, isMissingRouteError, } from "./api.js";
 import { maybeHandleRepoRoomAuthRequired } from "./device-auth.js";
 import { getLastMessageId } from "./messages.js";
-import { currentRoom } from "./room-state.js";
+import { currentRoom, getCurrentSupervisedRoomAuthority } from "./room-state.js";
+import { isSupervisedBoundedTurn } from "./worker-bearer.js";
 export async function roomScopedApiCall(input) {
+    const supervised = isSupervisedBoundedTurn();
+    const exactRoomAuthority = supervised ? getCurrentSupervisedRoomAuthority() : null;
+    if (supervised && (!exactRoomAuthority || input.room_id !== exactRoomAuthority)) {
+        throw new Error("The daemon-supervised API request is missing its exact per-call room authority.");
+    }
     const headers = {
         ...input.options?.headers,
     };
-    if (currentRoom?.room_id &&
-        !Object.keys(headers).some((key) => key.toLowerCase() === LETAGENTS_ORIGIN_ROOM_ID_HEADER.toLowerCase())) {
+    const originHeaderKey = Object.keys(headers).find((key) => key.toLowerCase() === LETAGENTS_ORIGIN_ROOM_ID_HEADER.toLowerCase());
+    if (exactRoomAuthority) {
+        if (originHeaderKey)
+            delete headers[originHeaderKey];
+        headers[LETAGENTS_ORIGIN_ROOM_ID_HEADER] = exactRoomAuthority;
+    }
+    else if (currentRoom?.room_id && !originHeaderKey) {
         headers[LETAGENTS_ORIGIN_ROOM_ID_HEADER] = currentRoom.room_id;
     }
     const options = {
@@ -17,16 +28,20 @@ export async function roomScopedApiCall(input) {
         headers,
     };
     if (input.room_id) {
-        const { cloudRoomId } = await resolveLocalRoomStorageIdentifiers(input.room_id);
+        const cloudRoomId = supervised
+            ? null
+            : (await resolveLocalRoomStorageIdentifiers(input.room_id)).cloudRoomId;
         const apiRoomId = cloudRoomId || input.room_id;
         try {
             const result = await apiCall(input.room_path(apiRoomId), options);
-            touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+            if (!supervised) {
+                touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+            }
             return result;
         }
         catch (error) {
             await maybeHandleRepoRoomAuthRequired(error, apiRoomId);
-            if (!input.project_id || !isMissingRouteError(error)) {
+            if (supervised || !input.project_id || !isMissingRouteError(error)) {
                 throw error;
             }
         }
@@ -36,7 +51,9 @@ export async function roomScopedApiCall(input) {
     }
     const result = await apiCall(input.project_path(input.project_id), options);
     if (input.room_id) {
-        touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+        if (!supervised) {
+            touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+        }
     }
     return result;
 }

package/dist/mcp/server/runtime/room-state.js

@@ -3,6 +3,8 @@ import { getStoredAgentIdentity, saveRoomSession, touchRoomSession, } from "../.
 import { getCanonicalRoomWebPath, } from "../../room-id.js";
 import { API_URL, getLetagentsToken } from "./api.js";
 import { AGENT_INSTANCE_UUID, currentAgentIdentity, currentAgentIdentityKey, } from "./identity.js";
+import { isSupervisedBoundedTurn } from "./worker-bearer.js";
+import { getCurrentSupervisedRoomAuthority, runWithSupervisedRoomAuthority, } from "./supervised-room-authority.js";
 let mcpServer = null;
 let sseClient = null;
 export let currentRoom = null;
@@ -85,6 +87,8 @@ export function toPublicRoomResponse(response, fallbackRoomId) {
 }
 export function rememberRoom(state, lastMessageId) {
     currentRoom = state;
+    if (isSupervisedBoundedTurn())
+        return state;
     saveRoomSession({
         room_id: state.room_id,
         project_id: state.project_id ?? null,
@@ -109,14 +113,56 @@ export function rememberRoom(state, lastMessageId) {
     return state;
 }
 export function touchCurrentRoom(lastMessageId) {
+    if (isSupervisedBoundedTurn())
+        return;
     if (!currentRoom) {
         return;
     }
     touchRoomSession(currentRoom.room_id, lastMessageId);
 }
 export function getTargetRoomId(roomId) {
+    if (isSupervisedBoundedTurn()) {
+        const exactRoomAuthority = getCurrentSupervisedRoomAuthority();
+        if (!exactRoomAuthority) {
+            throw new Error("The daemon-supervised tool has not received its exact room authority.");
+        }
+        if (roomId && roomId !== exactRoomAuthority) {
+            throw new Error(`The daemon-supervised tool is authorized for ${exactRoomAuthority}, not ${roomId}.`);
+        }
+        return exactRoomAuthority;
+    }
     return roomId || currentRoom?.room_id || null;
 }
+/** The last room authority returned by this process's exact daemon effect. */
+export { getCurrentSupervisedRoomAuthority } from "./supervised-room-authority.js";
+/** Public room metadata without inventing join provenance or locality. */
+export function toPublicCurrentRoomState() {
+    const exactRoomAuthority = getCurrentSupervisedRoomAuthority();
+    if (!exactRoomAuthority)
+        return toPublicRoomState(currentRoom);
+    return {
+        ...toPublicRoomState(toRoomState({ room_id: exactRoomAuthority, joined_via: "join_room" })),
+        joined_via: null,
+        is_local: null,
+    };
+}
+/**
+ * Bind only the in-memory default used by one supervised MCP process. The
+ * daemon response is the authority; this performs no join, storage, SSE, or
+ * repository inspection and can safely rebind after a durable room move.
+ */
+export function runWithCurrentSupervisedRoom(roomId, callback) {
+    if (!isSupervisedBoundedTurn()) {
+        throw new Error("Only a daemon-supervised bounded turn can bind supervisor room authority.");
+    }
+    const normalized = roomId.trim();
+    if (!normalized || normalized.length > 1_024 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+        throw new Error("The daemon-supervised room authority is malformed.");
+    }
+    return runWithSupervisedRoomAuthority(normalized, callback);
+}
 export function getFallbackProjectId() {
+    if (isSupervisedBoundedTurn())
+        return null;
     return currentRoom?.project_id ?? null;
 }

package/dist/mcp/server/runtime/rooms.js

@@ -9,7 +9,7 @@ import { ensureAgentIdentity, toPublicAgentIdentity, withAgentIdentity, } from "
 import { withJoinRoomAgentPrompt } from "./messages.js";
 import { syncRoomPresence } from "./presence.js";
 import { rememberRoom, toPublicRoomResponse, toRoomState, } from "./room-state.js";
-import { requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { isSupervisedBoundedTurn, requireValidWorkerBearerRuntime } from "./worker-bearer.js";
 export function normalizeJoinSessionMode(value) {
     return String(value || "").trim().toLowerCase() === "live" ? "live" : "current";
 }
@@ -30,6 +30,9 @@ function parseGeneratedGitRefRoomIdentifier(identifier) {
     };
 }
 export async function joinRoomIdentifier(identifier, joinedVia, options = {}) {
+    if (isSupervisedBoundedTurn()) {
+        throw new Error("Room joins and creation are disabled during a daemon-supervised bounded turn.");
+    }
     const roomId = joinedVia === "join_code" ? normalizeInviteCode(identifier) : identifier.trim();
     if (joinedVia !== "join_code" && await isLocalRoomStorageEnabled(roomId)) {
         if (options.allowCreate === false && !getStoredRoomSession(roomId)) {
@@ -187,6 +190,9 @@ export async function joinRoomIdentifierWithoutImplicitGitRefCreate(identifier,
     }));
 }
 export async function createInviteRoom() {
+    if (isSupervisedBoundedTurn()) {
+        throw new Error("Room joins and creation are disabled during a daemon-supervised bounded turn.");
+    }
     const project = await apiCall("/projects", { method: "POST" });
     const roomId = typeof project.code === "string"
         ? project.code
@@ -301,7 +307,15 @@ function bindWorkerRoomFromContext() {
 }
 export async function autoJoinFromContext() {
     try {
-        if (requireValidWorkerBearerRuntime().mode === "worker") {
+        const workerRuntime = requireValidWorkerBearerRuntime();
+        if (workerRuntime.mode === "supervised") {
+            // The exact room may change after a durable daemon-owned room move.
+            // Bind it per tool effect from the supervisor response, never from
+            // ambient repository, persisted state, or launch-time environment.
+            console.error("ℹ️ Daemon-supervised bounded turn leaves room selection to its exact supervisor context.");
+            return;
+        }
+        if (workerRuntime.mode === "worker") {
             const bound = bindWorkerRoomFromContext();
             if (bound) {
                 console.error(`🏠 Bound worker bearer to room '${bound.room.room_id}' (from ${bound.source}; no join/create request).`);

package/dist/mcp/server/runtime/supervised-room-authority.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const exactRoomAuthority = new AsyncLocalStorage();
+export function getCurrentSupervisedRoomAuthority() {
+    return exactRoomAuthority.getStore() ?? null;
+}
+export function runWithSupervisedRoomAuthority(roomId, callback) {
+    return exactRoomAuthority.run(roomId, callback);
+}