@beeuni/sdk 0.1.0

package/dist/core/session/preview.js

@@ -0,0 +1,66 @@
+function derivePreviewAuthEndpoint(candidateUrl) {
+    try {
+        const url = new URL(candidateUrl);
+        if (/^\/proxy\/\d+(?:\/|$)/.test(url.pathname)) {
+            return `${url.origin}/v1/p/auth`;
+        }
+        const previewIndex = url.pathname.indexOf('/p/');
+        if (previewIndex !== -1) {
+            return `${url.origin}${url.pathname.slice(0, previewIndex)}/p/auth`;
+        }
+        return `${url.origin}/v1/p/auth`;
+    }
+    catch {
+        return null;
+    }
+}
+function isPreviewProxyUrl(candidateUrl, serverUrl) {
+    try {
+        const url = new URL(candidateUrl);
+        const path = url.pathname;
+        const isPreviewPath = /^\/v1\/p\/[^/]+\/\d+(?:\/|$)/.test(path) ||
+            /^\/proxy\/\d+(?:\/|$)/.test(path);
+        if (!isPreviewPath)
+            return false;
+        const trustedOrigins = new Set();
+        if (serverUrl) {
+            try {
+                trustedOrigins.add(new URL(serverUrl).origin);
+            }
+            catch { }
+        }
+        if (typeof window !== 'undefined') {
+            trustedOrigins.add(window.location.origin);
+        }
+        return trustedOrigins.has(url.origin);
+    }
+    catch {
+        return false;
+    }
+}
+export function buildPreviewAuthEndpoint(previewUrl, serverUrl) {
+    if (!isPreviewProxyUrl(previewUrl, serverUrl))
+        return null;
+    return ((serverUrl ? derivePreviewAuthEndpoint(serverUrl) : null) ??
+        derivePreviewAuthEndpoint(previewUrl));
+}
+export function isSubdomainPreviewUrl(candidateUrl) {
+    try {
+        const { hostname } = new URL(candidateUrl);
+        return (/^p\d+-[^.]+\./.test(hostname)
+            || /^(?:dev|staging|prod|preview)-p\d+-[a-z0-9-]+\./i.test(hostname));
+    }
+    catch {
+        return false;
+    }
+}
+export function appendPreviewToken(previewUrl, token) {
+    try {
+        const u = new URL(previewUrl);
+        u.searchParams.set('token', token);
+        return u.toString();
+    }
+    catch {
+        return previewUrl;
+    }
+}

package/dist/core/session/project-session-read.d.ts

@@ -0,0 +1,5 @@
+import { getProjectSession, type ProjectSession } from '../rest/projects-client/sessions.js';
+export declare function readProjectSessionRow(projectId: string, sessionId: string, options: {
+    bundle: boolean;
+    fetchRow?: typeof getProjectSession;
+}): Promise<ProjectSession>;

package/dist/core/session/project-session-read.js

@@ -0,0 +1,12 @@
+import { getProjectSession } from '../rest/projects-client/sessions.js';
+import { claimOpenBundle } from './open-bundle.js';
+export async function readProjectSessionRow(projectId, sessionId, options) {
+    const claimed = options.bundle ? claimOpenBundle(projectId, sessionId) : null;
+    if (claimed) {
+        const bundle = await claimed;
+        if (bundle?.session)
+            return bundle.session;
+    }
+    const fetchRow = options.fetchRow ?? getProjectSession;
+    return fetchRow(projectId, sessionId, { showErrors: false });
+}

package/dist/core/session/rewind.d.ts

@@ -0,0 +1,29 @@
+export interface SessionRewindState {
+    messageId: string;
+    watermark: string;
+    hiddenIds?: readonly string[];
+    staged: boolean;
+}
+export declare function isWithinRewindWindow(id: string, rewind: SessionRewindState): boolean;
+export declare function newestMessageId<T extends {
+    info: {
+        id: string;
+        time?: {
+            created?: number;
+        };
+    };
+}>(messages: T[]): string | null;
+export declare function stageSessionRewind<T extends {
+    info: {
+        id: string;
+        time?: {
+            created?: number;
+        };
+    };
+}>(messages: T[], messageId: string): SessionRewindState;
+export declare function messagesBeforeRewind<T extends {
+    info: {
+        id: string;
+    };
+}>(messages: T[], rewind: SessionRewindState | null): T[];
+export declare function commitSessionRewind(rewind: SessionRewindState | null): SessionRewindState | null;

package/dist/core/session/rewind.js

@@ -0,0 +1,53 @@
+export function isWithinRewindWindow(id, rewind) {
+    if (rewind.hiddenIds)
+        return rewind.hiddenIds.includes(id);
+    return id >= rewind.messageId && id <= rewind.watermark;
+}
+export function newestMessageId(messages) {
+    let bestId = null;
+    let bestCreated;
+    for (const message of messages) {
+        const { id } = message.info;
+        const created = message.info.time?.created;
+        if (bestId === null) {
+            bestId = id;
+            bestCreated = created;
+            continue;
+        }
+        if (created !== undefined && bestCreated !== undefined) {
+            if (created > bestCreated || (created === bestCreated && id > bestId)) {
+                bestId = id;
+                bestCreated = created;
+            }
+            continue;
+        }
+        if (created !== undefined && bestCreated === undefined) {
+            bestId = id;
+            bestCreated = created;
+            continue;
+        }
+        if (created === undefined && bestCreated === undefined && id > bestId) {
+            bestId = id;
+        }
+    }
+    return bestId;
+}
+export function stageSessionRewind(messages, messageId) {
+    const boundary = messages.findIndex((message) => message.info.id === messageId);
+    const hiddenIds = boundary === -1 ? [messageId] : messages.slice(boundary).map((message) => message.info.id);
+    return {
+        messageId,
+        watermark: newestMessageId(messages) ?? messageId,
+        hiddenIds,
+        staged: true,
+    };
+}
+export function messagesBeforeRewind(messages, rewind) {
+    if (!rewind)
+        return messages;
+    const kept = messages.filter((message) => !isWithinRewindWindow(message.info.id, rewind));
+    return kept.length === messages.length ? messages : kept;
+}
+export function commitSessionRewind(rewind) {
+    return rewind?.staged ? { ...rewind, staged: false } : rewind;
+}

package/dist/core/session/runtime-gone.d.ts

@@ -0,0 +1,5 @@
+type Listener = (runtimeUrl: string) => void;
+export declare function isRuntimeGoneResponse(status: number, body: string): boolean;
+export declare function noteRuntimeGone(runtimeUrl: string): void;
+export declare function onRuntimeGone(listener: Listener): () => void;
+export {};

package/dist/core/session/runtime-gone.js

@@ -0,0 +1,14 @@
+const listeners = new Set();
+export function isRuntimeGoneResponse(status, body) {
+    return status === 404 && /sandbox not found/i.test(body);
+}
+export function noteRuntimeGone(runtimeUrl) {
+    for (const listener of listeners)
+        listener(runtimeUrl);
+}
+export function onRuntimeGone(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}

package/dist/core/session/runtime-sessions.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectRuntimeSession, ProjectSession } from '../rest/projects-client/sessions.js';
+type SessionTree = Pick<ProjectSession, 'runtime_sessions' | 'opencode_sessions' | 'runtime_session_id' | 'opencode_session_id'>;
+export declare function runtimeSessionsOf(session: SessionTree): ProjectRuntimeSession[];
+export declare function rootRuntimeSession(session: SessionTree): ProjectRuntimeSession | null;
+export declare function directSubsessions(session: SessionTree): ProjectRuntimeSession[];
+export declare function projectSessionForRuntimeId<S extends SessionTree & Pick<ProjectSession, 'session_id'>>(sessions: readonly S[], runtimeId: string | null): S | null;
+export {};

package/dist/core/session/runtime-sessions.js

@@ -0,0 +1,26 @@
+export function runtimeSessionsOf(session) {
+    return session.runtime_sessions ?? session.opencode_sessions ?? [];
+}
+export function rootRuntimeSession(session) {
+    const conversations = runtimeSessionsOf(session);
+    const rootId = session.runtime_session_id ?? session.opencode_session_id;
+    if (rootId)
+        return conversations.find((item) => item.id === rootId) ?? null;
+    return conversations.find((item) => !item.parent_id) ?? null;
+}
+export function directSubsessions(session) {
+    const root = rootRuntimeSession(session);
+    if (!root)
+        return [];
+    return runtimeSessionsOf(session)
+        .filter((item) => item.parent_id === root.id && !item.archived_at)
+        .sort((a, b) => (b.updated_at ?? 0) - (a.updated_at ?? 0) || a.id.localeCompare(b.id));
+}
+export function projectSessionForRuntimeId(sessions, runtimeId) {
+    if (!runtimeId)
+        return null;
+    const direct = sessions.find((session) => session.session_id === runtimeId || (session.runtime_session_id ?? session.opencode_session_id) === runtimeId);
+    if (direct)
+        return direct;
+    return sessions.find((session) => runtimeSessionsOf(session).some((item) => item.id === runtimeId)) ?? null;
+}

package/dist/core/session/runtime-verbs.d.ts

@@ -0,0 +1,34 @@
+import type { BeeuniMessage, BeeuniSessionStatus, RuntimePermissionReply, RuntimePermissionRequest, RuntimeQuestionAnswer, RuntimeQuestionRequest } from '../runtime/transcript-types.js';
+export interface RuntimeVerbsInput {
+    runtimeUrl: string;
+    rootId: string;
+    fetch: typeof fetch;
+}
+export interface TranscriptPage {
+    messages: BeeuniMessage[];
+    hasMore: boolean;
+}
+export interface PendingInteractions {
+    statuses: Record<string, BeeuniSessionStatus>;
+    permissions: RuntimePermissionRequest[];
+    questions: RuntimeQuestionRequest[];
+}
+export declare function createRuntimeVerbs(input: RuntimeVerbsInput): {
+    messages: (options?: {
+        conversationId?: string;
+        limit?: number;
+        before?: string;
+        signal?: AbortSignal;
+    }) => Promise<TranscriptPage>;
+    pending: () => Promise<PendingInteractions>;
+    answerPermission: (requestId: string, reply: RuntimePermissionReply, message?: string) => Promise<void>;
+    answerQuestion: (requestId: string, answers: RuntimeQuestionAnswer[] | null) => Promise<void>;
+    compact: (model?: {
+        providerID: string;
+        modelID: string;
+    }) => Promise<{
+        providerID: string;
+        modelID: string;
+    }>;
+};
+export type RuntimeVerbs = ReturnType<typeof createRuntimeVerbs>;

package/dist/core/session/runtime-verbs.js

@@ -0,0 +1,94 @@
+import { ApiError } from '../http/api/errors.js';
+import { createRuntimeRestClient } from '../runtime/runtime-rest-client.js';
+const MESSAGE_PAGE_MAX = 200;
+async function errorMessage(response) {
+    const text = await response.text().catch(() => '');
+    try {
+        const body = JSON.parse(text);
+        return body.data?.message || body.error || body.message || text || `HTTP ${response.status}`;
+    }
+    catch {
+        return text || `HTTP ${response.status}`;
+    }
+}
+function unwrap(result, what) {
+    if (result.error === undefined)
+        return result.data;
+    const error = result.error;
+    const detail = typeof error === 'string' ? error : error?.data?.message || error?.message || error?.error || 'request failed';
+    throw new ApiError(`${what}: ${detail}`, {
+        ...(result.response ? { status: result.response.status, response: result.response } : {}),
+    });
+}
+export function createRuntimeVerbs(input) {
+    const base = input.runtimeUrl.replace(/\/$/, '');
+    const client = createRuntimeRestClient({ baseUrl: base, fetch: input.fetch });
+    return {
+        messages: async (options = {}) => {
+            const conversation = encodeURIComponent(options.conversationId ?? input.rootId);
+            const readPage = async (limit, before) => {
+                const query = new URLSearchParams();
+                if (limit !== undefined)
+                    query.set('limit', String(limit));
+                if (before)
+                    query.set('before', before);
+                const suffix = `/messages/${conversation}${query.size ? `?${query}` : ''}`;
+                const read = (mount) => input.fetch(new Request(`${base}${mount}${suffix}`, { method: 'GET', ...(options.signal ? { signal: options.signal } : {}) }));
+                let response = await read('/beeuni/runtime');
+                if (response.status === 404 || (response.headers.get('content-type') ?? '').startsWith('text/html')) {
+                    response = await read('/beeuni/opencode');
+                }
+                if (!response.ok) {
+                    throw new ApiError(`Reading the session transcript failed: ${await errorMessage(response)}`, {
+                        status: response.status,
+                        response,
+                    });
+                }
+                const body = (await response.json());
+                return { messages: body.messages ?? [], hasMore: body.has_more === true };
+            };
+            let page = await readPage(options.limit === undefined ? undefined : Math.min(options.limit, MESSAGE_PAGE_MAX), options.before);
+            const messages = [...page.messages];
+            while (options.limit !== undefined && messages.length < options.limit && page.hasMore && messages.length > 0) {
+                page = await readPage(Math.min(options.limit - messages.length, MESSAGE_PAGE_MAX), messages[0].info.id);
+                if (!page.messages.length)
+                    break;
+                messages.unshift(...page.messages);
+            }
+            return { messages, hasMore: page.hasMore };
+        },
+        pending: async () => {
+            const [statuses, permissions, questions] = await Promise.all([
+                client.session.status().then((r) => unwrap(r, 'Reading the session status failed')),
+                client.permission.list().then((r) => unwrap(r, 'Reading permission requests failed')),
+                client.question.list().then((r) => unwrap(r, 'Reading questions failed')),
+            ]);
+            return { statuses: statuses ?? {}, permissions: permissions ?? [], questions: questions ?? [] };
+        },
+        answerPermission: async (requestId, reply, message) => {
+            unwrap(await client.permission.reply({ requestID: requestId, reply, ...(message !== undefined ? { message } : {}) }), 'Answering the permission request failed');
+        },
+        answerQuestion: async (requestId, answers) => {
+            if (answers === null) {
+                unwrap(await client.question.reject({ requestID: requestId }), 'Dismissing the question failed');
+                return;
+            }
+            unwrap(await client.question.reply({ requestID: requestId, answers }), 'Answering the question failed');
+        },
+        compact: async (model) => {
+            let chosen = model;
+            if (!chosen) {
+                const config = await client.global.config.get().then((result) => (result.error === undefined ? result.data : null));
+                const reference = typeof config?.model === 'string' ? config.model : '';
+                const slash = reference.indexOf('/');
+                if (slash > 0 && slash < reference.length - 1) {
+                    chosen = { providerID: reference.slice(0, slash), modelID: reference.slice(slash + 1) };
+                }
+            }
+            if (!chosen)
+                throw new ApiError('Cannot compact: no model is set for this session', { code: 'MODEL_REQUIRED' });
+            unwrap(await client.session.summarize({ sessionID: input.rootId, providerID: chosen.providerID, modelID: chosen.modelID }), 'Compacting the session failed');
+            return chosen;
+        },
+    };
+}

package/dist/core/session/server-store/active.d.ts

@@ -0,0 +1,7 @@
+import { type ResolvedPreviewOptions } from '../preview-options.js';
+export declare function getActiveRuntimeUrl(): string;
+export declare function getActiveSandboxId(): string | undefined;
+export declare function getActiveDbSandboxId(): string | undefined;
+export declare function getBackendPort(): number;
+export declare function deriveSubdomainOpts(): ResolvedPreviewOptions;
+export declare const getActiveOpenCodeUrl: typeof getActiveRuntimeUrl;

package/dist/core/session/server-store/active.js

@@ -0,0 +1,35 @@
+import { platformConfig } from '../../http/config.js';
+import { getCurrentRuntimeDbSandboxId, getCurrentRuntimeSandboxId, getCurrentRuntimeUrl, } from '../current-runtime.js';
+import { getBackendUrl, getDefaultSandboxUrl } from './url-helpers.js';
+import { resolvePreviewOptions } from '../preview-options.js';
+export function getActiveRuntimeUrl() {
+    const current = getCurrentRuntimeUrl();
+    if (current)
+        return current;
+    if (platformConfig().billingEnabled ?? false)
+        return '';
+    return getDefaultSandboxUrl();
+}
+export function getActiveSandboxId() {
+    return getCurrentRuntimeSandboxId() ?? platformConfig().sandboxId ?? undefined;
+}
+export function getActiveDbSandboxId() {
+    return getCurrentRuntimeDbSandboxId() ?? undefined;
+}
+export function getBackendPort() {
+    try {
+        const url = new URL(getBackendUrl());
+        return Number.parseInt(url.port, 10) || (url.protocol === 'https:' ? 443 : 80);
+    }
+    catch {
+        return 8008;
+    }
+}
+export function deriveSubdomainOpts() {
+    return resolvePreviewOptions({
+        sandboxId: getActiveSandboxId() || '',
+        backendPort: getBackendPort(),
+        apiBaseUrl: getBackendUrl(),
+    });
+}
+export const getActiveOpenCodeUrl = getActiveRuntimeUrl;

package/dist/core/session/server-store/types.d.ts

@@ -0,0 +1,4 @@
+export interface ServerStore {
+    getActiveServerUrl: () => string;
+}
+export declare const PATH_PROXY_URL_REGEX: RegExp;

package/dist/core/session/server-store/types.js

@@ -0,0 +1 @@
+export const PATH_PROXY_URL_REGEX = /^https?:\/\/[^/]+\/v1\/p\/([^/]+)\/(\d+)(\/.*)?$/;

package/dist/core/session/server-store/url-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function getBackendUrl(): string;
+export declare function getDefaultSandboxUrl(): string;
+export declare function getSandboxServerUrl(sandboxId: string, port?: number): string;
+export declare function getSandboxUrlForExternalId(externalId: string, port?: number): string;
+export declare function getPublicShareUrlForToken(token: string, port: number): string;

package/dist/core/session/server-store/url-helpers.js

@@ -0,0 +1,25 @@
+import { platformConfig } from '../../http/config.js';
+function stripTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s.charCodeAt(end - 1) === 47)
+        end--;
+    return s.slice(0, end);
+}
+export function getBackendUrl() {
+    return stripTrailingSlashes(platformConfig().backendUrl || 'http://localhost:8008/v1');
+}
+export function getDefaultSandboxUrl() {
+    const sandboxId = platformConfig().sandboxId;
+    if (!sandboxId)
+        return '';
+    return `${getBackendUrl()}/p/${sandboxId}/8000`;
+}
+export function getSandboxServerUrl(sandboxId, port = 8000) {
+    return `${getBackendUrl()}/p/${sandboxId}/${port}`;
+}
+export function getSandboxUrlForExternalId(externalId, port = 8000) {
+    return getSandboxServerUrl(externalId, port);
+}
+export function getPublicShareUrlForToken(token, port) {
+    return `${getBackendUrl()}/p/public-share/${token}/${port}`;
+}

package/dist/core/session/session-runtime-registry.d.ts

@@ -0,0 +1,9 @@
+export interface SessionRuntimeEntry {
+    runtimeSessionId: string;
+    opencodeSessionId: string;
+    runtimeUrl: string;
+    sandboxId: string;
+}
+export declare function getSessionRuntime(projectId: string, sessionId: string): SessionRuntimeEntry | undefined;
+export declare function setSessionRuntime(projectId: string, sessionId: string, entry: SessionRuntimeEntry): void;
+export declare function clearSessionRuntime(projectId: string, sessionId: string): void;

package/dist/core/session/session-runtime-registry.js

@@ -0,0 +1,28 @@
+const MAX_ENTRIES = 512;
+const registry = new Map();
+function registryKey(projectId, sessionId) {
+    return `${projectId}::${sessionId}`;
+}
+function touch(key, entry) {
+    registry.delete(key);
+    registry.set(key, entry);
+}
+export function getSessionRuntime(projectId, sessionId) {
+    const key = registryKey(projectId, sessionId);
+    const entry = registry.get(key);
+    if (entry)
+        touch(key, entry);
+    return entry;
+}
+export function setSessionRuntime(projectId, sessionId, entry) {
+    const key = registryKey(projectId, sessionId);
+    if (!registry.has(key) && registry.size >= MAX_ENTRIES) {
+        const oldestKey = registry.keys().next().value;
+        if (oldestKey !== undefined)
+            registry.delete(oldestKey);
+    }
+    touch(key, entry);
+}
+export function clearSessionRuntime(projectId, sessionId) {
+    registry.delete(registryKey(projectId, sessionId));
+}

package/dist/core/session/single-flight.d.ts

@@ -0,0 +1,3 @@
+type Schedule = (callback: () => void) => void;
+export declare function createTickSingleFlight<T>(schedule?: Schedule): (key: string, read: () => Promise<T>) => Promise<T>;
+export {};

package/dist/core/session/single-flight.js

@@ -0,0 +1,22 @@
+const defaultSchedule = (callback) => {
+    setTimeout(callback, 0);
+};
+export function createTickSingleFlight(schedule = defaultSchedule) {
+    const flights = new Map();
+    return function run(key, read) {
+        const current = flights.get(key);
+        if (current?.joinable)
+            return current.promise;
+        const flight = { promise: read(), joinable: true };
+        flights.set(key, flight);
+        schedule(() => {
+            flight.joinable = false;
+        });
+        const drop = () => {
+            if (flights.get(key) === flight)
+                flights.delete(key);
+        };
+        flight.promise.then(drop, drop);
+        return flight.promise;
+    };
+}

package/dist/core/session/static-file-preview.d.ts

@@ -0,0 +1,10 @@
+import { type SubdomainUrlOptions } from './url.js';
+export interface StaticFilePreviewTargets {
+    previewUrl: string;
+    healthUrl: string;
+}
+export declare function staticFilePreviewTargets(path: string | undefined, options: SubdomainUrlOptions): StaticFilePreviewTargets | null;
+export declare const STATIC_FILE_HEALTH_RETRY_MS = 1500;
+export declare const STATIC_FILE_HEALTH_MAX_ATTEMPTS = 20;
+export declare function shouldRetryStaticFileHealth(attempts: number): boolean;
+export declare function authenticatedUrlAddresses(authenticatedUrl: string | null | undefined, previewUrl: string | undefined): boolean;

package/dist/core/session/static-file-preview.js

@@ -0,0 +1,34 @@
+import { buildStaticFileHealthPreviewUrl, buildStaticFilePreviewUrl, hasPreviewTarget, } from './url.js';
+export function staticFilePreviewTargets(path, options) {
+    if (!path)
+        return null;
+    if (!hasPreviewTarget(options))
+        return null;
+    const previewUrl = buildStaticFilePreviewUrl(path, options);
+    if (!previewUrl)
+        return null;
+    return { previewUrl, healthUrl: buildStaticFileHealthPreviewUrl(options) };
+}
+export const STATIC_FILE_HEALTH_RETRY_MS = 1_500;
+export const STATIC_FILE_HEALTH_MAX_ATTEMPTS = 20;
+export function shouldRetryStaticFileHealth(attempts) {
+    return attempts < STATIC_FILE_HEALTH_MAX_ATTEMPTS;
+}
+function normalizeAddress(candidate) {
+    try {
+        const url = new URL(candidate);
+        url.searchParams.delete('token');
+        url.searchParams.sort();
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+export function authenticatedUrlAddresses(authenticatedUrl, previewUrl) {
+    if (!authenticatedUrl || !previewUrl)
+        return false;
+    const authenticated = normalizeAddress(authenticatedUrl);
+    const wanted = normalizeAddress(previewUrl);
+    return authenticated !== null && authenticated === wanted;
+}

package/dist/core/session/status-vocabulary.d.ts

@@ -0,0 +1,23 @@
+import type { ProjectSession } from '../rest/projects-client/sessions.js';
+import type { SessionConnection } from './connection.js';
+export type StatusTone = 'actionable' | 'live' | 'progress' | 'muted' | 'danger';
+export interface StatusWording {
+    label: string;
+    tone: StatusTone;
+}
+export type SessionListStatus = 'needs-you' | 'starting' | 'running' | 'done' | 'stopped' | 'failed' | 'legacy';
+export declare const SESSION_LIST_STATUS: Readonly<Record<SessionListStatus, StatusWording & {
+    description: string;
+}>>;
+export declare function isLegacyMigratedSession(session: Pick<ProjectSession, 'metadata'>): boolean;
+export declare function sessionListStatus(session: Pick<ProjectSession, 'status' | 'metadata'>, reviewCount?: number): SessionListStatus;
+export declare function sessionConnectionLabel(connection: SessionConnection): StatusWording | null;
+export declare const SESSION_NOTICE: {
+    readonly unreachable: "Lost contact with this session's computer. Messages you send are queued until it reconnects.";
+    readonly unreachableMidTurn: "Lost contact with this session's computer while a turn is still open. Messages you send stay queued until it answers.";
+    readonly stalled: "Waking this session's computer is taking longer than usual. Messages you send are queued.";
+    readonly starting: "Starting this session's computer. Your message sends automatically.";
+    readonly idle: "This session's computer is asleep. Your next message wakes it up and is delivered.";
+    readonly waking: "Waking this session's computer. Messages you send are queued and go out automatically.";
+};
+export declare function turnRetryLabel(secondsLeft: number | null): string;

package/dist/core/session/status-vocabulary.js

@@ -0,0 +1,59 @@
+export const SESSION_LIST_STATUS = {
+    'needs-you': { label: 'Needs you', tone: 'actionable', description: 'Waiting for your review' },
+    starting: { label: 'Starting', tone: 'progress', description: 'Its computer is starting' },
+    running: { label: 'Running', tone: 'live', description: 'Its computer is up' },
+    done: { label: 'Done', tone: 'muted', description: 'Finished' },
+    stopped: { label: 'Stopped', tone: 'muted', description: 'Asleep. Opening it wakes its computer' },
+    failed: { label: 'Failed', tone: 'danger', description: "Its computer didn't start" },
+    legacy: { label: 'Legacy', tone: 'muted', description: 'Imported. Open it to restore' },
+};
+export function isLegacyMigratedSession(session) {
+    const meta = (session.metadata ?? {});
+    return Boolean(meta.legacy_migration);
+}
+export function sessionListStatus(session, reviewCount = 0) {
+    if (reviewCount > 0)
+        return 'needs-you';
+    switch (session.status) {
+        case 'queued':
+        case 'branching':
+        case 'provisioning':
+            return 'starting';
+        case 'running':
+            return 'running';
+        case 'completed':
+        case 'stopped':
+            if (isLegacyMigratedSession(session))
+                return 'legacy';
+            return session.status === 'completed' ? 'done' : 'stopped';
+        case 'failed':
+            return 'failed';
+        default:
+            return 'stopped';
+    }
+}
+export function sessionConnectionLabel(connection) {
+    switch (connection) {
+        case 'waking':
+            return { label: 'Waking computer', tone: 'progress' };
+        case 'connecting':
+            return { label: 'Connecting', tone: 'progress' };
+        case 'unreachable':
+            return { label: "Can't reach computer", tone: 'danger' };
+        default:
+            return null;
+    }
+}
+export const SESSION_NOTICE = {
+    unreachable: "Lost contact with this session's computer. Messages you send are queued until it reconnects.",
+    unreachableMidTurn: "Lost contact with this session's computer while a turn is still open. Messages you send stay queued until it answers.",
+    stalled: "Waking this session's computer is taking longer than usual. Messages you send are queued.",
+    starting: "Starting this session's computer. Your message sends automatically.",
+    idle: "This session's computer is asleep. Your next message wakes it up and is delivered.",
+    waking: "Waking this session's computer. Messages you send are queued and go out automatically.",
+};
+export function turnRetryLabel(secondsLeft) {
+    if (secondsLeft === null)
+        return 'Waiting to retry';
+    return secondsLeft > 0 ? `Retrying in ${secondsLeft}s` : 'Retrying now';
+}