letagents 0.12.9 → 0.12.11

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

@@ -0,0 +1,374 @@
+import { getRoomFromConfig } from "../../config-reader.js";
+import { buildActiveGitRoomContext, getGitCurrentBranch, getGitDefaultBranch, getGitRoomContext, } from "../../git-remote.js";
+import { encodeRoomIdPath, looksLikeInviteCode, normalizeInviteCode, } from "../../room-id.js";
+import { isLocalRoomStorageEnabled, getStoredCurrentRoom, getStoredRoomSession, } from "../../local-state.js";
+import { getDefaultManagedAgentProvider, toManagedAgentStartResponse, } from "../../managed-agent-providers.js";
+import { ApiError, apiCall, isMissingRouteError, } from "./api.js";
+import { RepoRoomAuthRequiredError, maybeHandleRepoRoomAuthRequired, } from "./device-auth.js";
+import { ensureAgentIdentity, toPublicAgentIdentity, withAgentIdentity, } from "./identity.js";
+import { withJoinRoomAgentPrompt } from "./messages.js";
+import { syncRoomPresence } from "./presence.js";
+import { rememberRoom, toPublicRoomResponse, toRoomState, } from "./room-state.js";
+import { requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+export function normalizeJoinSessionMode(value) {
+    return String(value || "").trim().toLowerCase() === "live" ? "live" : "current";
+}
+export function getCurrentLiveSessionPayload(roomId) {
+    return getDefaultManagedAgentProvider().getCurrentLiveSessionPayload(roomId);
+}
+function isNotFoundApiError(error) {
+    return error instanceof ApiError && error.status === 404;
+}
+function parseGeneratedGitRefRoomIdentifier(identifier) {
+    const match = /^git-room:github\.com:([^/:\s]+\/[^/:\s]+):(branch|tag):[A-Za-z0-9_-]+$/.exec(identifier.trim());
+    if (!match) {
+        return null;
+    }
+    return {
+        repoRoom: `github.com/${match[1].toLowerCase()}`,
+        refType: match[2],
+    };
+}
+export async function joinRoomIdentifier(identifier, joinedVia, options = {}) {
+    const roomId = joinedVia === "join_code" ? normalizeInviteCode(identifier) : identifier.trim();
+    if (joinedVia !== "join_code" && await isLocalRoomStorageEnabled(roomId)) {
+        if (options.allowCreate === false && !getStoredRoomSession(roomId)) {
+            throw new ApiError(404, JSON.stringify({ error: "Room not found", room_id: roomId }));
+        }
+        const agentIdentity = await ensureAgentIdentity();
+        const room = rememberRoom(toRoomState({
+            room_id: roomId,
+            project_id: null,
+            code: null,
+            display_name: roomId,
+            joined_via: joinedVia,
+            is_local: true,
+        }));
+        return {
+            room,
+            response: {
+                room_id: roomId,
+                display_name: roomId,
+                joined_via: joinedVia,
+                is_local: true,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
+            },
+        };
+    }
+    try {
+        const createQuery = options.allowCreate === false ? "?create=false" : "";
+        const response = await apiCall(`/rooms/${encodeRoomIdPath(roomId)}/join${createQuery}`, { method: "POST" });
+        const joinedRoomId = typeof response.room_id === "string"
+            ? response.room_id
+            : roomId;
+        const agentIdentity = await ensureAgentIdentity();
+        const room = rememberRoom(toRoomState({
+            room_id: joinedRoomId,
+            project_id: typeof response.project_id === "string" ? response.project_id : null,
+            code: typeof response.code === "string"
+                ? response.code
+                : looksLikeInviteCode(joinedRoomId)
+                    ? joinedRoomId
+                    : null,
+            display_name: typeof response.display_name === "string" ? response.display_name : null,
+            git_room: response.git_room ?? null,
+            joined_via: joinedVia,
+        }));
+        await syncRoomPresence(room.room_id, agentIdentity, {
+            status: "idle",
+            status_text: "available in room",
+        });
+        return {
+            room,
+            response: {
+                ...response,
+                room_id: joinedRoomId,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
+            },
+        };
+    }
+    catch (error) {
+        await maybeHandleRepoRoomAuthRequired(error, roomId);
+        if (options.allowCreate === false) {
+            throw error;
+        }
+        if (!isMissingRouteError(error)) {
+            throw error;
+        }
+    }
+    if (joinedVia === "join_code") {
+        const project = await apiCall(`/projects/join/${encodeURIComponent(roomId)}`);
+        const legacyRoomId = typeof project.code === "string"
+            ? project.code
+            : roomId;
+        const agentIdentity = await ensureAgentIdentity();
+        const room = rememberRoom(toRoomState({
+            room_id: legacyRoomId,
+            project_id: typeof project.id === "string" ? project.id : null,
+            code: typeof project.code === "string" ? project.code : legacyRoomId,
+            display_name: typeof project.display_name === "string" ? project.display_name : null,
+            git_room: project.git_room ?? null,
+            joined_via: joinedVia,
+        }));
+        await syncRoomPresence(room.room_id, agentIdentity, {
+            status: "idle",
+            status_text: "available in room",
+        });
+        return {
+            room,
+            response: {
+                ...project,
+                room_id: legacyRoomId,
+                project_id: typeof project.id === "string" ? project.id : null,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
+            },
+        };
+    }
+    const project = await apiCall(`/projects/room/${encodeURIComponent(roomId)}`, { method: "POST" });
+    const legacyRoomId = typeof project.name === "string" && project.name.trim()
+        ? project.name
+        : typeof project.code === "string" && project.code.trim()
+            ? project.code
+            : roomId;
+    const agentIdentity = await ensureAgentIdentity();
+    const room = rememberRoom(toRoomState({
+        room_id: legacyRoomId,
+        project_id: typeof project.id === "string" ? project.id : null,
+        code: typeof project.code === "string"
+            ? project.code
+            : looksLikeInviteCode(legacyRoomId)
+                ? legacyRoomId
+                : null,
+        display_name: typeof project.display_name === "string" ? project.display_name : null,
+        git_room: project.git_room ?? null,
+        joined_via: joinedVia,
+    }));
+    await syncRoomPresence(room.room_id, agentIdentity, {
+        status: "idle",
+        status_text: "available in room",
+    });
+    return {
+        room,
+        response: {
+            ...project,
+            room_id: legacyRoomId,
+            project_id: typeof project.id === "string" ? project.id : null,
+            agent_identity: toPublicAgentIdentity(agentIdentity),
+        },
+    };
+}
+async function joinExistingRoomIdentifier(identifier, joinedVia) {
+    try {
+        return await joinRoomIdentifier(identifier, joinedVia, { allowCreate: false });
+    }
+    catch (error) {
+        if (isNotFoundApiError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function joinRoomIdentifierWithoutImplicitGitRefCreate(identifier, joinedVia, options = {}) {
+    const gitRefRoom = parseGeneratedGitRefRoomIdentifier(identifier);
+    if (!gitRefRoom) {
+        return joinRoomIdentifier(identifier, joinedVia);
+    }
+    const joined = await joinExistingRoomIdentifier(identifier, joinedVia);
+    if (joined) {
+        return joined;
+    }
+    if (options.fallbackToRepo) {
+        return joinRoomIdentifier(gitRefRoom.repoRoom, joinedVia);
+    }
+    throw new ApiError(404, JSON.stringify({
+        error: "Room not found",
+        code: "ROOM_NOT_FOUND",
+        room_id: identifier.trim(),
+    }));
+}
+export async function createInviteRoom() {
+    const project = await apiCall("/projects", { method: "POST" });
+    const roomId = typeof project.code === "string"
+        ? project.code
+        : typeof project.id === "string"
+            ? project.id
+            : "unknown-room";
+    const room = rememberRoom(toRoomState({
+        room_id: roomId,
+        project_id: typeof project.id === "string" ? project.id : null,
+        code: typeof project.code === "string" ? project.code : roomId,
+        display_name: typeof project.display_name === "string" ? project.display_name : null,
+        joined_via: "join_code",
+    }));
+    const agentIdentity = await ensureAgentIdentity();
+    await syncRoomPresence(room.room_id, agentIdentity, {
+        status: "idle",
+        status_text: "available in room",
+    });
+    return {
+        room,
+        response: {
+            ...toPublicRoomResponse(project, roomId),
+            agent_identity: toPublicAgentIdentity(agentIdentity),
+        },
+    };
+}
+export async function buildJoinResponse(input) {
+    const basePayload = await withAgentIdentity({
+        ...toPublicRoomResponse(input.joined.response, input.joined.room.room_id),
+        joined_via: input.joined_via,
+        session_mode: input.session_mode,
+    });
+    if (input.session_mode === "current") {
+        return withJoinRoomAgentPrompt(basePayload);
+    }
+    const provider = getDefaultManagedAgentProvider();
+    const liveSession = await provider.startLocalSession({
+        room_id: input.joined.room.room_id,
+        room_identifier: input.room_identifier,
+        room_code: input.joined.room.code ?? null,
+        room_display_name: input.joined.room.display_name ?? null,
+        joined_via: input.joined_via,
+        cwd: process.cwd(),
+    });
+    return withJoinRoomAgentPrompt({
+        ...basePayload,
+        ...toManagedAgentStartResponse(provider, liveSession),
+    });
+}
+export async function joinInviteCode(code, sessionMode) {
+    const joined = await joinRoomIdentifier(code, "join_code");
+    return buildJoinResponse({
+        joined,
+        room_identifier: normalizeInviteCode(code),
+        joined_via: "join_code",
+        session_mode: sessionMode,
+    });
+}
+export async function joinNamedRoom(name, sessionMode) {
+    const joined = await joinRoomIdentifier(name, "join_room");
+    return buildJoinResponse({
+        joined,
+        room_identifier: name.trim(),
+        joined_via: "join_room",
+        session_mode: sessionMode,
+    });
+}
+function bindWorkerRoomFromContext() {
+    const configRoom = getRoomFromConfig();
+    if (configRoom) {
+        const gitContext = buildActiveGitRoomContext({
+            repoRoom: configRoom,
+            currentBranch: getGitCurrentBranch(),
+            defaultBranch: getGitDefaultBranch(),
+        });
+        const roomId = gitContext.activeRoom ?? configRoom;
+        return {
+            room: rememberRoom(toRoomState({
+                room_id: roomId,
+                display_name: roomId,
+                joined_via: "config",
+            })),
+            source: ".letagents.json",
+        };
+    }
+    const gitContext = getGitRoomContext();
+    if (gitContext.activeRoom) {
+        return {
+            room: rememberRoom(toRoomState({
+                room_id: gitContext.activeRoom,
+                display_name: gitContext.activeRoom,
+                joined_via: "git-remote",
+            })),
+            source: "git remote",
+        };
+    }
+    const savedCurrentRoom = getStoredCurrentRoom();
+    if (!savedCurrentRoom) {
+        return null;
+    }
+    return {
+        room: rememberRoom(toRoomState({
+            room_id: savedCurrentRoom.room_id,
+            project_id: savedCurrentRoom.project_id,
+            code: savedCurrentRoom.code,
+            display_name: savedCurrentRoom.display_name,
+            git_room: savedCurrentRoom.git_room,
+            joined_via: savedCurrentRoom.joined_via,
+        })),
+        source: "saved local room state",
+    };
+}
+export async function autoJoinFromContext() {
+    try {
+        if (requireValidWorkerBearerRuntime().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).`);
+            }
+            else {
+                console.error("ℹ️ Worker bearer has no .letagents.json, git remote, or saved room to bind locally.");
+            }
+            return;
+        }
+        const configRoom = getRoomFromConfig();
+        if (configRoom) {
+            const gitContext = buildActiveGitRoomContext({
+                repoRoom: configRoom,
+                currentBranch: getGitCurrentBranch(),
+                defaultBranch: getGitDefaultBranch(),
+            });
+            if (gitContext.activeRefRoom && gitContext.currentBranch) {
+                const joinedBranchRoom = await joinExistingRoomIdentifier(gitContext.activeRefRoom, "config");
+                if (joinedBranchRoom) {
+                    await ensureAgentIdentity();
+                    console.error(`🏠 Auto-joined existing branch room '${gitContext.activeRefRoom}' (from .letagents.json + branch '${gitContext.currentBranch}')`);
+                    return;
+                }
+            }
+            await joinRoomIdentifier(configRoom, "config");
+            await ensureAgentIdentity();
+            const branchNote = gitContext.activeRefRoom && gitContext.currentBranch
+                ? `; branch '${gitContext.currentBranch}' has no existing Git Room`
+                : "";
+            console.error(`🏠 Auto-joined room '${configRoom}' (from .letagents.json${branchNote})`);
+            return;
+        }
+        const gitContext = getGitRoomContext();
+        if (gitContext.repoRoom) {
+            if (gitContext.activeRefRoom && gitContext.currentBranch) {
+                const joinedBranchRoom = await joinExistingRoomIdentifier(gitContext.activeRefRoom, "git-remote");
+                if (joinedBranchRoom) {
+                    await ensureAgentIdentity();
+                    console.error(`🏠 Auto-joined existing branch room '${gitContext.activeRefRoom}' (inferred from git remote and branch '${gitContext.currentBranch}' — consider adding a .letagents.json)`);
+                    return;
+                }
+            }
+            await joinRoomIdentifier(gitContext.repoRoom, "git-remote");
+            await ensureAgentIdentity();
+            const branchNote = gitContext.activeRefRoom && gitContext.currentBranch
+                ? `; branch '${gitContext.currentBranch}' has no existing Git Room`
+                : "";
+            console.error(`🏠 Auto-joined room '${gitContext.repoRoom}' (inferred from git remote${branchNote} — consider adding a .letagents.json)`);
+            return;
+        }
+        const savedCurrentRoom = getStoredCurrentRoom();
+        if (savedCurrentRoom) {
+            const joined = await joinRoomIdentifierWithoutImplicitGitRefCreate(savedCurrentRoom.room_id, savedCurrentRoom.joined_via, { fallbackToRepo: true });
+            await ensureAgentIdentity();
+            const fallbackNote = joined.room.room_id !== savedCurrentRoom.room_id
+                ? `; saved Git ref room '${savedCurrentRoom.room_id}' was missing`
+                : "";
+            console.error(`🏠 Rejoined saved room '${joined.room.room_id}' (from local state${fallbackNote})`);
+            return;
+        }
+        console.error("ℹ️ No .letagents.json, git remote, or saved room found — use create_room, join_code, or join_room to connect.");
+    }
+    catch (err) {
+        if (err instanceof RepoRoomAuthRequiredError) {
+            console.error(`🔐 Repo room auth required for '${err.roomId}'. Open ${err.pendingAuth.verification_uri} and enter code ${err.pendingAuth.user_code}, then run poll_device_auth.`);
+            return;
+        }
+        console.error("⚠️ Auto-join failed (server still running):", err instanceof Error ? err.message : err);
+    }
+}

package/dist/mcp/server/runtime/supervisor-bridge.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { createConnection } from "node:net";
+const NEGOTIATION_PROTOCOL_VERSION = 1;
+const SUPPORTED_SUPERVISOR_PROTOCOL_VERSIONS = new Set([1, 2]);
+const DEFAULT_REQUEST_TIMEOUT_MS = 5_000;
+/** Bind the exact worker credential minted by registration to its daemon lane. */
+export async function bindSupervisedWorkerSession(session, env = process.env, options = {}) {
+    const entryId = env.LETAGENTS_SUPERVISOR_ENTRY_ID?.trim();
+    const socketPath = env.LETAGENTS_SUPERVISOR_DAEMON_SOCKET?.trim();
+    const workAttemptId = env.LETAGENTS_SUPERVISOR_WORK_ATTEMPT_ID?.trim();
+    const executionGenerationId = env.LETAGENTS_SUPERVISOR_EXECUTION_GENERATION_ID?.trim();
+    if (!entryId && !socketPath && !workAttemptId && !executionGenerationId)
+        return false;
+    if (!entryId || !socketPath || !workAttemptId || !executionGenerationId)
+        throw new Error("Supervised worker bridge environment is incomplete.");
+    if (session.session_kind !== "worker")
+        throw new Error("A supervised provider must register a worker session.");
+    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1)
+        throw new Error("Supervisor bridge timeout must be a positive integer.");
+    const negotiation = await supervisorRequest(socketPath, {
+        version: NEGOTIATION_PROTOCOL_VERSION,
+        id: randomUUID(),
+        method: "daemon.negotiate",
+    }, timeoutMs);
+    if (!negotiation.ok)
+        throw new Error(negotiation.error || "Supervisor protocol negotiation failed.");
+    const protocolVersion = negotiationProtocolVersion(negotiation.result);
+    if (negotiation.version !== protocolVersion)
+        throw new Error("Supervisor negotiation response version does not match its negotiated protocol.");
+    const response = await supervisorRequest(socketPath, {
+        version: protocolVersion,
+        id: randomUUID(),
+        method: "supervisor.bind_worker_session",
+        params: {
+            entry_id: entryId,
+            room_id: session.room_id,
+            work_attempt_id: workAttemptId,
+            execution_generation_id: executionGenerationId,
+            agent_session_id: session.session_id,
+            agent_session_token: session.session_token,
+            api_url: env.LETAGENTS_API_URL?.trim() || "https://letagents.chat",
+        },
+    }, timeoutMs);
+    if (!response.ok)
+        throw new Error(response.error || "Supervisor rejected the worker session binding.");
+    if (response.version !== protocolVersion)
+        throw new Error("Supervisor binding response used an unexpected protocol version.");
+    return true;
+}
+function negotiationProtocolVersion(result) {
+    if (!result || typeof result !== "object")
+        throw new Error("Supervisor protocol negotiation returned a malformed result.");
+    const protocolVersion = result.protocol_version;
+    if (typeof protocolVersion !== "number" || !Number.isSafeInteger(protocolVersion)
+        || !SUPPORTED_SUPERVISOR_PROTOCOL_VERSIONS.has(protocolVersion)) {
+        throw new Error(`Supervisor protocol negotiation returned unsupported version ${String(protocolVersion)}.`);
+    }
+    return protocolVersion;
+}
+function supervisorRequest(socketPath, request, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(socketPath);
+        let buffer = "";
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error("Timed out communicating with the supervisor daemon."));
+        }, timeoutMs);
+        timer.unref();
+        const finish = (operation) => {
+            clearTimeout(timer);
+            operation();
+        };
+        socket.setEncoding("utf8");
+        socket.once("error", (error) => finish(() => reject(error)));
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            socket.end();
+            try {
+                const response = JSON.parse(buffer.slice(0, newline));
+                finish(() => response.id === request.id
+                    ? resolve(response)
+                    : reject(new Error("Supervisor response id does not match its request.")));
+            }
+            catch (error) {
+                finish(() => reject(error));
+            }
+        });
+        socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+    });
+}

package/dist/mcp/server/runtime/worker-bearer.js

@@ -0,0 +1,67 @@
+export const LETAGENTS_AGENT_SESSION_BEARER_ENV = "LETAGENTS_AGENT_SESSION_BEARER";
+export class WorkerBearerRuntimeConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WorkerBearerRuntimeConfigurationError";
+    }
+}
+export function getWorkerBearerRuntime() {
+    const bearer = process.env.LETAGENTS_AGENT_SESSION_BEARER?.trim();
+    if (!bearer) {
+        return { mode: "owner" };
+    }
+    const apiUrl = process.env.LETAGENTS_API_URL?.trim();
+    if (!apiUrl) {
+        return {
+            mode: "invalid",
+            error: "Worker bearer mode requires an explicit LETAGENTS_API_URL.",
+        };
+    }
+    try {
+        const parsed = new URL(apiUrl);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            throw new Error("unsupported protocol");
+        }
+        const loopbackHosts = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+        if (parsed.protocol === "http:" && !loopbackHosts.has(parsed.hostname.toLowerCase())) {
+            return {
+                mode: "invalid",
+                error: "Worker bearer mode requires HTTPS unless LETAGENTS_API_URL uses an exact loopback host.",
+            };
+        }
+    }
+    catch {
+        return {
+            mode: "invalid",
+            error: "Worker bearer mode requires LETAGENTS_API_URL to be a valid HTTP(S) URL.",
+        };
+    }
+    if (process.env.LETAGENTS_TOKEN?.trim()) {
+        return {
+            mode: "invalid",
+            error: "Worker bearer mode refuses LETAGENTS_TOKEN. Remove the owner token from this process before starting the worker.",
+        };
+    }
+    return { mode: "worker", bearer };
+}
+export function requireValidWorkerBearerRuntime() {
+    const runtime = getWorkerBearerRuntime();
+    if (runtime.mode === "invalid") {
+        throw new WorkerBearerRuntimeConfigurationError(runtime.error);
+    }
+    return runtime;
+}
+export function workerModeDisabledToolResult(toolDescription = "This owner-auth onboarding tool") {
+    const runtime = getWorkerBearerRuntime();
+    if (runtime.mode === "invalid") {
+        return { success: false, error: "worker_bearer_configuration_invalid", message: runtime.error };
+    }
+    if (runtime.mode === "worker") {
+        return {
+            success: false,
+            error: "worker_bearer_mode",
+            message: `${toolDescription} is disabled while LETAGENTS_AGENT_SESSION_BEARER is configured.`,
+        };
+    }
+    return null;
+}

package/dist/mcp/server/runtime.js

@@ -0,0 +1,14 @@
+// Compatibility facade for MCP server runtime helpers. The implementation lives
+// in src/mcp/server/runtime/* so tool modules can import focused responsibilities
+// without turning this file back into the runtime god module.
+export { API_URL, ApiError, apiCall, getAuthorizationHeader, getLetagentsToken, isMissingRouteError, parseApiErrorPayload, resolveApiPath, } from "./runtime/api.js";
+export { clearAuthenticatedAccountCache, getAuthenticatedAccountCache, setAuthenticatedAccountCache, } from "./runtime/auth-cache.js";
+export { RepoRoomAuthRequiredError, maybeHandleRepoRoomAuthRequired, startPendingDeviceAuth, toRepoRoomAuthRequiredResult, } from "./runtime/device-auth.js";
+export { AGENT_INSTANCE_UUID, currentAgentIdentity, currentAgentIdentityKey, detectAgentIdeLabel, detectAgentRuntimeLabel, ensureAgentIdentity, getConversationIdentity, getSessionLivenessRegistration, resolveOwnerContext, setConversationIdentity, storeCurrentAgentIdentity, toPublicAgentIdentity, withAgentIdentity, } from "./runtime/identity.js";
+export { agentSessionCredentials, buildAgentDeliveryHeaders, ensureLocalWorkerAgentSession, getAgentSessionRepoBranch, identityFromAgentSession, requireWorkerAgentSession, resolveAgentSession, resolveWorkerToolIdentity, toPublicAgentSession, WORKER_BEARER_AGENT_SESSION_ID, } from "./runtime/agent-sessions.js";
+export { appendIncludePromptOnly, getLastMessageId, normalizeOptionalToolString, toAgentReadableMessages, withJoinRoomAgentPrompt, } from "./runtime/messages.js";
+export { currentRoom, attachMcpServer, getFallbackProjectId, getTargetRoomId, rememberRoom, shutdownRuntime, toPublicRoomResponse, toPublicRoomState, toPublicStoredRoomSession, toRoomState, touchCurrentRoom, withCanonicalRoomLink, } from "./runtime/room-state.js";
+export { getRememberedRoomPresence, heartbeatRoomPresence, syncRoomPresence, } from "./runtime/presence.js";
+export { roomScopedApiCall } from "./runtime/room-api.js";
+export { autoJoinFromContext, buildJoinResponse, createInviteRoom, getCurrentLiveSessionPayload, joinInviteCode, joinNamedRoom, joinRoomIdentifier, joinRoomIdentifierWithoutImplicitGitRefCreate, normalizeJoinSessionMode, } from "./runtime/rooms.js";
+export { clearPendingDeviceAuth, clearStoredAuth, clearStoredAuth as clearStoredAuthorization, endStoredAgentSession, getCurrentAgentSession, getLocalStatePath, getPendingDeviceAuth, getStoredAgentIdentity, getStoredAgentSession, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, listStoredCodexLiveSessions, saveAgentSession, setPendingDeviceAuth, setStoredAuth, setStoredAgentIdentity, touchRoomSession, addLocalChatMessage, addLocalTask, claimLocalTaskReviewLease, getLatestLocalChatMessages, getLocalChatMessages, getLocalTask, listLocalTasks, isLocalChatStorageEnabled, isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, releaseLocalTaskReviewLease, updateLocalTask, waitForLocalChatMessages, } from "../local-state.js";