@beeuni/sdk 0.1.0

package/dist/browser/stores/diagnostics-store.d.ts

@@ -0,0 +1,61 @@
+export type DiagnosticSeverity = 1 | 2 | 3 | 4;
+export interface LspDiagnostic {
+    file: string;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+    severity: DiagnosticSeverity;
+    message: string;
+    source?: string;
+}
+export interface DiagnosticsState {
+    byFile: Record<string, LspDiagnostic[]>;
+    setFileDiagnostics: (file: string, diagnostics: LspDiagnostic[]) => void;
+    setFromLspEvent: (diagnosticsByFile: Record<string, RawDiagnostic[]>) => void;
+    clearFile: (file: string) => void;
+    clearAll: () => void;
+    getErrorCount: () => number;
+    getWarningCount: () => number;
+    getAllDiagnostics: () => LspDiagnostic[];
+}
+export interface RawDiagnostic {
+    range?: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end?: {
+            line: number;
+            character: number;
+        };
+    };
+    line?: number;
+    column?: number;
+    character?: number;
+    endLine?: number;
+    endColumn?: number;
+    severity?: number;
+    message: string;
+    source?: string;
+}
+export declare function findDiagnosticsForFile(byFile: Record<string, LspDiagnostic[]>, filePath: string): LspDiagnostic[] | undefined;
+export declare function buildDiagnosticCountsMap(byFile: Record<string, LspDiagnostic[]>): Record<string, {
+    errors: number;
+    warnings: number;
+}>;
+export declare function getRelativePath(absPath: string): string;
+export declare function parseDiagnosticsFromToolOutput(output: string): Record<string, LspDiagnostic[]>;
+export declare const useDiagnosticsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<DiagnosticsState>, "setState" | "persist"> & {
+    setState(partial: DiagnosticsState | Partial<DiagnosticsState> | ((state: DiagnosticsState) => DiagnosticsState | Partial<DiagnosticsState>), replace?: false | undefined): unknown;
+    setState(state: DiagnosticsState | ((state: DiagnosticsState) => DiagnosticsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<DiagnosticsState, DiagnosticsState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DiagnosticsState) => void) => () => void;
+        onFinishHydration: (fn: (state: DiagnosticsState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<DiagnosticsState, DiagnosticsState, unknown>>;
+    };
+}>;

package/dist/browser/stores/diagnostics-store.js

@@ -0,0 +1,216 @@
+'use client';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { createSafeSessionJSONStorage } from '../../platform/storage/managed-storage.js';
+export function findDiagnosticsForFile(byFile, filePath) {
+    if (byFile[filePath])
+        return byFile[filePath];
+    const cleanPath = filePath.replace(/^file:\/\//, '').replace(/^\/+/, '');
+    for (const key of Object.keys(byFile)) {
+        const cleanKey = key.replace(/^file:\/\//, '').replace(/^\/+/, '');
+        if (cleanKey === cleanPath)
+            return byFile[key];
+        if (cleanKey.endsWith('/' + cleanPath))
+            return byFile[key];
+        if (cleanPath.endsWith('/' + cleanKey))
+            return byFile[key];
+    }
+    return undefined;
+}
+export function buildDiagnosticCountsMap(byFile) {
+    const map = {};
+    for (const [key, diags] of Object.entries(byFile)) {
+        if (!diags || diags.length === 0)
+            continue;
+        let errors = 0;
+        let warnings = 0;
+        for (const d of diags) {
+            if (d.severity === 1)
+                errors++;
+            else if (d.severity === 2)
+                warnings++;
+        }
+        if (errors === 0 && warnings === 0)
+            continue;
+        const counts = { errors, warnings };
+        const cleanKey = key.replace(/^file:\/\//, '');
+        const parts = cleanKey.split('/').filter(Boolean);
+        map[parts.join('/')] = counts;
+        if (cleanKey.startsWith('/')) {
+            map[cleanKey] = counts;
+        }
+        for (let i = 1; i < parts.length; i++) {
+            const suffix = parts.slice(i).join('/');
+            if (!map[suffix]) {
+                map[suffix] = counts;
+            }
+        }
+    }
+    return map;
+}
+const PROJECT_ROOT_MARKERS = new Set([
+    'src',
+    'lib',
+    'app',
+    'pages',
+    'components',
+    'public',
+    'test',
+    'tests',
+    'pkg',
+    'cmd',
+    'internal',
+]);
+export function getRelativePath(absPath) {
+    const clean = absPath.replace(/^file:\/\//, '');
+    if (clean.startsWith('/')) {
+        const parts = clean.split('/').filter(Boolean);
+        for (let i = 0; i < parts.length; i++) {
+            if (PROJECT_ROOT_MARKERS.has(parts[i])) {
+                return parts.slice(i).join('/');
+            }
+        }
+        if (parts.length > 3) {
+            return parts.slice(-3).join('/');
+        }
+        return parts.join('/');
+    }
+    return clean;
+}
+export function parseDiagnosticsFromToolOutput(output) {
+    const result = {};
+    const tagPattern = /<(?:file_diagnostics|project_diagnostics)>([\s\S]*?)<\/(?:file_diagnostics|project_diagnostics)>/g;
+    let tagMatch;
+    const allLines = [];
+    while ((tagMatch = tagPattern.exec(output)) !== null) {
+        const content = tagMatch[1].trim();
+        if (content) {
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('...')) {
+                    allLines.push(trimmed);
+                }
+            }
+        }
+    }
+    if (allLines.length === 0)
+        return result;
+    const linePattern = /^(Error|Warn|Info|Hint):\s+(.+?):(\d+):(\d+)\s+\[([^\]]*)\](.*)$/;
+    for (const line of allLines) {
+        const match = linePattern.exec(line);
+        if (!match)
+            continue;
+        const [, severityStr, filePath, lineStr, colStr, source, rest] = match;
+        const severity = severityStr === 'Error' ? 1 :
+            severityStr === 'Warn' ? 2 :
+                severityStr === 'Hint' ? 4 : 3;
+        let message = rest.trim();
+        message = message.replace(/^\[\w+\]\s*/, '');
+        message = message.replace(/^\([^)]*\)\s*/, '');
+        const lineNum = parseInt(lineStr, 10) - 1;
+        const colNum = parseInt(colStr, 10) - 1;
+        const diag = {
+            file: filePath,
+            line: Math.max(0, lineNum),
+            column: Math.max(0, colNum),
+            severity,
+            message: message || `${severityStr} at ${lineStr}:${colStr}`,
+            source: source || undefined,
+        };
+        if (!result[filePath]) {
+            result[filePath] = [];
+        }
+        result[filePath].push(diag);
+    }
+    return result;
+}
+function normalizeRawDiagnostic(file, raw) {
+    const line = raw.range?.start?.line ?? raw.line ?? 0;
+    const column = raw.range?.start?.character ?? raw.column ?? raw.character ?? 0;
+    const endLine = raw.range?.end?.line ?? raw.endLine;
+    const endColumn = raw.range?.end?.character ?? raw.endColumn;
+    const severity = (raw.severity ?? 1);
+    return {
+        file,
+        line,
+        column,
+        endLine,
+        endColumn,
+        severity,
+        message: raw.message,
+        source: raw.source,
+    };
+}
+export const useDiagnosticsStore = create()(persist((set, get) => ({
+    byFile: {},
+    setFileDiagnostics: (file, diagnostics) => set((state) => ({
+        byFile: {
+            ...state.byFile,
+            [file]: diagnostics,
+        },
+    })),
+    setFromLspEvent: (diagnosticsByFile) => set((state) => {
+        const next = { ...state.byFile };
+        for (const [file, rawDiags] of Object.entries(diagnosticsByFile)) {
+            if (!Array.isArray(rawDiags))
+                continue;
+            const normalized = rawDiags.map((d) => normalizeRawDiagnostic(file, d));
+            if (normalized.length === 0) {
+                delete next[file];
+            }
+            else {
+                next[file] = normalized;
+            }
+        }
+        return { byFile: next };
+    }),
+    clearFile: (file) => set((state) => {
+        const { [file]: _, ...rest } = state.byFile;
+        return { byFile: rest };
+    }),
+    clearAll: () => set({ byFile: {} }),
+    getErrorCount: () => {
+        const { byFile } = get();
+        let count = 0;
+        for (const diags of Object.values(byFile)) {
+            for (const d of diags) {
+                if (d.severity === 1)
+                    count++;
+            }
+        }
+        return count;
+    },
+    getWarningCount: () => {
+        const { byFile } = get();
+        let count = 0;
+        for (const diags of Object.values(byFile)) {
+            for (const d of diags) {
+                if (d.severity === 2)
+                    count++;
+            }
+        }
+        return count;
+    },
+    getAllDiagnostics: () => {
+        const { byFile } = get();
+        const all = [];
+        for (const diags of Object.values(byFile)) {
+            all.push(...diags);
+        }
+        all.sort((a, b) => {
+            if (a.severity !== b.severity)
+                return a.severity - b.severity;
+            if (a.file !== b.file)
+                return a.file.localeCompare(b.file);
+            return a.line - b.line;
+        });
+        return all;
+    },
+}), {
+    name: 'beeuni-diagnostics',
+    storage: createSafeSessionJSONStorage(),
+    partialize: (state) => ({ byFile: state.byFile }),
+}));
+if (typeof window !== 'undefined') {
+    window.__diagStore = useDiagnosticsStore;
+}

package/dist/browser/stores/opencode-compaction-store.d.ts

@@ -0,0 +1,7 @@
+interface OpenCodeCompactionState {
+    compactingBySession: Record<string, number>;
+    startCompaction: (sessionId: string) => void;
+    stopCompaction: (sessionId: string) => void;
+}
+export declare const useOpenCodeCompactionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<OpenCodeCompactionState>>;
+export {};

package/dist/browser/stores/opencode-compaction-store.js

@@ -0,0 +1,21 @@
+'use client';
+import { create } from 'zustand';
+export const useOpenCodeCompactionStore = create()((set) => ({
+    compactingBySession: {},
+    startCompaction: (sessionId) => set((state) => {
+        if (sessionId in state.compactingBySession)
+            return state;
+        return {
+            compactingBySession: {
+                ...state.compactingBySession,
+                [sessionId]: Date.now(),
+            },
+        };
+    }),
+    stopCompaction: (sessionId) => set((state) => {
+        if (!(sessionId in state.compactingBySession))
+            return state;
+        const { [sessionId]: _, ...rest } = state.compactingBySession;
+        return { compactingBySession: rest };
+    }),
+}));

package/dist/browser/stores/opencode-pending-store.d.ts

@@ -0,0 +1,19 @@
+import type { PermissionRequest, QuestionRequest } from '../../core/runtime/runtime-types.js';
+interface OpenCodePendingState {
+    permissions: Record<string, PermissionRequest>;
+    questions: Record<string, QuestionRequest>;
+    resolvedQuestionIds: string[];
+    resolvedPermissionIds: string[];
+    autoApproveAllSessions: Record<string, true>;
+    addPermission: (req: PermissionRequest) => void;
+    removePermission: (requestId: string) => void;
+    addQuestion: (req: QuestionRequest) => void;
+    removeQuestion: (requestId: string) => void;
+    setAutoApproveAll: (sessionId: string, enabled: boolean) => void;
+    clear: () => void;
+    getSessionPendingCount: (sessionId: string) => number;
+    getTotalPendingCount: () => number;
+}
+export declare const useRuntimePendingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<OpenCodePendingState>>;
+export declare const useOpenCodePendingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<OpenCodePendingState>>;
+export {};

package/dist/browser/stores/opencode-pending-store.js

@@ -0,0 +1,65 @@
+'use client';
+import { create } from 'zustand';
+const RESOLVED_REQUEST_LIMIT = 200;
+function recordResolved(ids, requestId) {
+    if (ids.includes(requestId))
+        return ids;
+    return [...ids, requestId].slice(-RESOLVED_REQUEST_LIMIT);
+}
+export const useRuntimePendingStore = create()((set, get) => ({
+    permissions: {},
+    questions: {},
+    resolvedQuestionIds: [],
+    resolvedPermissionIds: [],
+    autoApproveAllSessions: {},
+    addPermission: (req) => set((state) => {
+        if (state.resolvedPermissionIds.includes(req.id))
+            return state;
+        return { permissions: { ...state.permissions, [req.id]: req } };
+    }),
+    removePermission: (requestId) => set((state) => {
+        const { [requestId]: _, ...rest } = state.permissions;
+        return {
+            permissions: rest,
+            resolvedPermissionIds: recordResolved(state.resolvedPermissionIds, requestId),
+        };
+    }),
+    addQuestion: (req) => set((state) => {
+        if (state.resolvedQuestionIds.includes(req.id))
+            return state;
+        return { questions: { ...state.questions, [req.id]: req } };
+    }),
+    removeQuestion: (requestId) => set((state) => {
+        const { [requestId]: _, ...rest } = state.questions;
+        return {
+            questions: rest,
+            resolvedQuestionIds: recordResolved(state.resolvedQuestionIds, requestId),
+        };
+    }),
+    setAutoApproveAll: (sessionId, enabled) => set((state) => {
+        const { [sessionId]: _, ...rest } = state.autoApproveAllSessions;
+        return { autoApproveAllSessions: enabled ? { ...rest, [sessionId]: true } : rest };
+    }),
+    clear: () => set({
+        permissions: {},
+        questions: {},
+        resolvedQuestionIds: [],
+        resolvedPermissionIds: [],
+        autoApproveAllSessions: {},
+    }),
+    getSessionPendingCount: (sessionId) => {
+        const s = get();
+        const permCount = Object.values(s.permissions).filter((p) => p.sessionID === sessionId).length;
+        const qCount = Object.values(s.questions)
+            .filter((q) => q.sessionID === sessionId)
+            .reduce((sum, q) => sum + (q.questions?.length || 1), 0);
+        return permCount + qCount;
+    },
+    getTotalPendingCount: () => {
+        const s = get();
+        const permCount = Object.keys(s.permissions).length;
+        const qCount = Object.values(s.questions).reduce((sum, q) => sum + (q.questions?.length || 1), 0);
+        return permCount + qCount;
+    },
+}));
+export const useOpenCodePendingStore = useRuntimePendingStore;

package/dist/browser/stores/sandbox-connection-store.d.ts

@@ -0,0 +1,35 @@
+export type SandboxConnectionStatus = "connecting" | "connected" | "unreachable";
+interface SandboxConnectionStore {
+    status: SandboxConnectionStatus;
+    failCount: number;
+    initialCheckDone: boolean;
+    wasConnected: boolean;
+    reconnectAttempts: number;
+    disconnectedAt: number | null;
+    openCodeVersion: string | null;
+    healthy: boolean | null;
+    runtimeError: string | null;
+    runtimeCapabilities: readonly string[] | null;
+    manualRetryNonce: number;
+    lastRuntimeEvidenceAt: number | null;
+    bootingSinceAt: number | null;
+    parked: boolean;
+    streamDriven: boolean;
+}
+export declare const useSandboxConnectionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SandboxConnectionStore>>;
+export declare function setConnectionStreamDriven(streamDriven: boolean): void;
+export declare function setRuntimeCapabilities(capabilities: readonly string[] | null): void;
+export declare function seedConnectionFromReadyStart(serverUrl: string, capabilities?: readonly string[] | null): void;
+export declare function requestRuntimeReconnect(): void;
+export declare function setSandboxStatus(next: SandboxConnectionStatus): void;
+export declare function markInitialCheckDone(): void;
+export declare function incrementSandboxFail(): void;
+export declare function resetSandboxFail(): void;
+export declare function resetForServerSwitch(serverUrl?: string): void;
+export declare function noteRuntimeEvidence(at?: number): void;
+export declare function markRuntimeReadyVerified(): void;
+export declare function setRuntimeHealth(healthy: boolean, version?: string, runtimeError?: string | null, options?: {
+    parked?: boolean;
+}): void;
+export declare const setOpenCodeHealth: typeof setRuntimeHealth;
+export {};

package/dist/browser/stores/sandbox-connection-store.js

@@ -0,0 +1,230 @@
+import { create } from "zustand";
+import { logger } from "../../core/http/logger.js";
+const STORAGE_KEY = "beeuni-runtime-was-connected";
+const RUNTIME_READY_VERIFIED_KEY = "beeuni-runtime-ready";
+function loadWasConnected() {
+    try {
+        return sessionStorage.getItem(STORAGE_KEY) === "1";
+    }
+    catch {
+        return false;
+    }
+}
+function saveWasConnected(value) {
+    try {
+        if (value) {
+            sessionStorage.setItem(STORAGE_KEY, "1");
+        }
+        else {
+            sessionStorage.removeItem(STORAGE_KEY);
+        }
+    }
+    catch {
+    }
+}
+function loadRuntimeReadyVerified() {
+    try {
+        return sessionStorage.getItem(RUNTIME_READY_VERIFIED_KEY) === "1";
+    }
+    catch {
+        return false;
+    }
+}
+function clearRuntimeReadyVerified() {
+    try {
+        sessionStorage.removeItem(RUNTIME_READY_VERIFIED_KEY);
+    }
+    catch {
+    }
+}
+export const useSandboxConnectionStore = create(() => ({
+    status: "connecting",
+    failCount: 0,
+    initialCheckDone: false,
+    wasConnected: loadWasConnected(),
+    reconnectAttempts: 0,
+    disconnectedAt: null,
+    openCodeVersion: null,
+    healthy: null,
+    runtimeError: null,
+    runtimeCapabilities: null,
+    manualRetryNonce: 0,
+    lastRuntimeEvidenceAt: null,
+    bootingSinceAt: null,
+    parked: false,
+    streamDriven: false,
+}));
+export function setConnectionStreamDriven(streamDriven) {
+    if (useSandboxConnectionStore.getState().streamDriven === streamDriven)
+        return;
+    useSandboxConnectionStore.setState({ streamDriven });
+}
+export function setRuntimeCapabilities(capabilities) {
+    const current = useSandboxConnectionStore.getState().runtimeCapabilities;
+    const same = current === capabilities ||
+        (current !== null &&
+            capabilities !== null &&
+            current.length === capabilities.length &&
+            current.every((entry, index) => entry === capabilities[index]));
+    if (!same)
+        useSandboxConnectionStore.setState({ runtimeCapabilities: capabilities });
+}
+export function seedConnectionFromReadyStart(serverUrl, capabilities) {
+    resetForServerSwitch(serverUrl);
+    setSandboxStatus("connected");
+    setRuntimeHealth(true);
+    if (capabilities)
+        setRuntimeCapabilities(capabilities);
+}
+export function requestRuntimeReconnect() {
+    useSandboxConnectionStore.setState((state) => ({
+        parked: false,
+        status: "connecting", healthy: null, failCount: 0, runtimeError: null,
+        disconnectedAt: state.disconnectedAt ?? Date.now(), manualRetryNonce: state.manualRetryNonce + 1,
+        bootingSinceAt: Date.now(),
+    }));
+}
+export function setSandboxStatus(next) {
+    const state = useSandboxConnectionStore.getState();
+    if (state.status === next)
+        return;
+    const updates = { status: next };
+    if (next === "connected") {
+        updates.failCount = 0;
+        updates.wasConnected = true;
+        updates.reconnectAttempts = 0;
+        updates.disconnectedAt = null;
+        saveWasConnected(true);
+        if (state.status === "unreachable") {
+            logger.info("Sandbox connection restored", {
+                previousStatus: state.status,
+                reconnectAttempts: state.reconnectAttempts,
+            });
+        }
+    }
+    else if (next === "unreachable") {
+        if (!state.disconnectedAt) {
+            updates.disconnectedAt = Date.now();
+        }
+        logger.warn("Sandbox became unreachable", {
+            failCount: state.failCount,
+            reconnectAttempts: state.reconnectAttempts,
+            wasConnected: state.wasConnected,
+        });
+    }
+    else if (next === "connecting") {
+        if (!state.disconnectedAt) {
+            updates.disconnectedAt = Date.now();
+        }
+    }
+    useSandboxConnectionStore.setState(updates);
+}
+export function markInitialCheckDone() {
+    if (useSandboxConnectionStore.getState().initialCheckDone)
+        return;
+    useSandboxConnectionStore.setState({ initialCheckDone: true });
+}
+export function incrementSandboxFail() {
+    const state = useSandboxConnectionStore.getState();
+    logger.warn("Sandbox health-check failed", {
+        failCount: state.failCount + 1,
+        reconnectAttempts: state.reconnectAttempts + 1,
+    });
+    useSandboxConnectionStore.setState((s) => ({
+        failCount: s.failCount + 1,
+        reconnectAttempts: s.reconnectAttempts + 1,
+    }));
+}
+export function resetSandboxFail() {
+    const { failCount } = useSandboxConnectionStore.getState();
+    if (failCount === 0)
+        return;
+    useSandboxConnectionStore.setState({ failCount: 0 });
+}
+let lastResetServerUrl = null;
+export function resetForServerSwitch(serverUrl) {
+    const runtimeReady = loadRuntimeReadyVerified();
+    if (serverUrl && serverUrl === lastResetServerUrl && !runtimeReady)
+        return;
+    lastResetServerUrl = serverUrl || null;
+    clearRuntimeReadyVerified();
+    if (runtimeReady) {
+        useSandboxConnectionStore.setState({
+            status: "connected",
+            failCount: 0,
+            initialCheckDone: true,
+            wasConnected: true,
+            reconnectAttempts: 0,
+            disconnectedAt: null,
+            openCodeVersion: null,
+            healthy: true,
+            runtimeError: null,
+            runtimeCapabilities: null,
+            manualRetryNonce: 0,
+            lastRuntimeEvidenceAt: null,
+            bootingSinceAt: null,
+            parked: false,
+        });
+        saveWasConnected(true);
+        return;
+    }
+    useSandboxConnectionStore.setState({
+        status: "connecting",
+        failCount: 0,
+        initialCheckDone: false,
+        wasConnected: false,
+        reconnectAttempts: 0,
+        disconnectedAt: null,
+        openCodeVersion: null,
+        healthy: null,
+        runtimeError: null,
+        runtimeCapabilities: null,
+        manualRetryNonce: 0,
+        lastRuntimeEvidenceAt: null,
+        bootingSinceAt: Date.now(),
+        parked: false,
+    });
+    saveWasConnected(false);
+}
+export function noteRuntimeEvidence(at = Date.now()) {
+    const previous = useSandboxConnectionStore.getState().lastRuntimeEvidenceAt;
+    if (previous !== null && at - previous < 1_000)
+        return;
+    useSandboxConnectionStore.setState({ lastRuntimeEvidenceAt: at });
+}
+export function markRuntimeReadyVerified() {
+    try {
+        sessionStorage.setItem(RUNTIME_READY_VERIFIED_KEY, "1");
+    }
+    catch {
+    }
+}
+export function setRuntimeHealth(healthy, version, runtimeError, options) {
+    const state = useSandboxConnectionStore.getState();
+    const updates = {};
+    if (state.healthy !== healthy)
+        updates.healthy = healthy;
+    const nextParked = healthy ? false : options?.parked === true;
+    if (state.parked !== nextParked)
+        updates.parked = nextParked;
+    if (version !== undefined && state.openCodeVersion !== version)
+        updates.openCodeVersion = version;
+    const nextRuntimeError = healthy ? null : runtimeError;
+    if (runtimeError !== undefined && state.runtimeError !== nextRuntimeError) {
+        updates.runtimeError = nextRuntimeError;
+    }
+    else if (healthy && state.runtimeError !== null) {
+        updates.runtimeError = null;
+    }
+    if (healthy || options?.parked) {
+        if (state.bootingSinceAt !== null)
+            updates.bootingSinceAt = null;
+    }
+    else if (state.bootingSinceAt === null) {
+        updates.bootingSinceAt = Date.now();
+    }
+    if (Object.keys(updates).length > 0) {
+        useSandboxConnectionStore.setState(updates);
+    }
+}
+export const setOpenCodeHealth = setRuntimeHealth;

package/dist/browser/stores/server-store.d.ts

@@ -0,0 +1,4 @@
+import type { ServerStore } from '../../core/session/server-store/types.js';
+export { getSandboxUrlForExternalId, getPublicShareUrlForToken } from '../../core/session/server-store/url-helpers.js';
+export { deriveSubdomainOpts, getActiveDbSandboxId, getActiveOpenCodeUrl, getActiveRuntimeUrl, getActiveSandboxId, getBackendPort, } from '../../core/session/server-store/active.js';
+export declare const useServerStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ServerStore>>;

package/dist/browser/stores/server-store.js

@@ -0,0 +1,7 @@
+import { create } from 'zustand';
+import { getActiveRuntimeUrl } from '../../core/session/server-store/active.js';
+export { getSandboxUrlForExternalId, getPublicShareUrlForToken } from '../../core/session/server-store/url-helpers.js';
+export { deriveSubdomainOpts, getActiveDbSandboxId, getActiveOpenCodeUrl, getActiveRuntimeUrl, getActiveSandboxId, getBackendPort, } from '../../core/session/server-store/active.js';
+export const useServerStore = create(() => ({
+    getActiveServerUrl: () => getActiveRuntimeUrl(),
+}));