@beeuni/sdk 0.1.0

package/dist/react/use-admin-providers.d.ts

@@ -0,0 +1,20 @@
+import { type AdminBootModePolicy } from '../core/rest/projects-client/admin-providers.js';
+export declare function useAdminProviderDistribution(): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminProviderDistribution, Error>;
+export declare function useAdminProviderSandboxes(): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminProviderSandboxesResponse, Error>;
+export declare function useAdminProviderAnalytics(days: number, enabled: boolean): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminProviderAnalytics, Error>;
+export declare function useAdminProviderFallback(): import("@tanstack/react-query").UseQueryResult<{
+    enabled: boolean;
+}, Error>;
+export interface AdminProviderMutationOptions {
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+}
+export interface AdminProviderMigrationVariables {
+    sessionId: string;
+    targetProvider: string;
+}
+export declare function useSetAdminProviderDistribution(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, Record<string, number>, unknown>;
+export declare function useMigrateAdminSandboxProvider(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, AdminProviderMigrationVariables, unknown>;
+export declare function useSetAdminProviderFallback(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, boolean, unknown>;
+export declare function useAdminBootModes(): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminBootModes, Error>;
+export declare function useSetAdminBootModes(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<import("../index.js").AdminBootModes, Error, AdminBootModePolicy, unknown>;

package/dist/react/use-admin-providers.js

@@ -0,0 +1,45 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { getAdminProviderDistribution, listAdminSandboxes, getAdminProviderAnalytics, getAdminProviderFallback, setAdminProviderDistribution, migrateAdminSandboxProvider, setAdminProviderFallback, getAdminBootModes, setAdminBootModes } from '../core/rest/projects-client/admin-providers.js';
+export function useAdminProviderDistribution() {
+    return useQuery({ queryKey: ['admin', 'provider-distribution'], queryFn: () => getAdminProviderDistribution() });
+}
+export function useAdminProviderSandboxes() {
+    return useQuery({ queryKey: ['admin', 'sandboxes'], queryFn: () => listAdminSandboxes(300), refetchInterval: 10_000 });
+}
+export function useAdminProviderAnalytics(days, enabled) {
+    return useQuery({ queryKey: ['admin', 'provider-analytics', days], queryFn: () => getAdminProviderAnalytics(days), enabled, refetchInterval: enabled ? 30_000 : false });
+}
+export function useAdminProviderFallback() {
+    return useQuery({ queryKey: ['admin', 'provider-fallback'], queryFn: () => getAdminProviderFallback() });
+}
+export function useSetAdminProviderDistribution(options = {}) {
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: (weights) => setAdminProviderDistribution(weights), onError: options.onError, onSuccess: () => {
+            options.onSuccess?.();
+            void qc.invalidateQueries({ queryKey: ['admin', 'provider-distribution'] });
+        } });
+}
+export function useMigrateAdminSandboxProvider(options = {}) {
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: ({ sessionId, targetProvider }) => migrateAdminSandboxProvider(sessionId, targetProvider), onError: options.onError, onSuccess: () => {
+            options.onSuccess?.();
+            void qc.invalidateQueries({ queryKey: ['admin', 'sandboxes'] });
+        } });
+}
+export function useSetAdminProviderFallback(options = {}) {
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: (enabled) => setAdminProviderFallback(enabled), onError: options.onError, onSuccess: () => {
+            options.onSuccess?.();
+            void qc.invalidateQueries({ queryKey: ['admin', 'provider-fallback'] });
+        } });
+}
+export function useAdminBootModes() {
+    return useQuery({ queryKey: ['admin', 'boot-modes'], queryFn: () => getAdminBootModes(), refetchInterval: 30_000 });
+}
+export function useSetAdminBootModes(options = {}) {
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: (policy) => setAdminBootModes(policy), onError: options.onError, onSuccess: (data) => {
+            options.onSuccess?.();
+            qc.setQueryData(['admin', 'boot-modes'], data);
+        } });
+}

package/dist/react/use-admin-role.d.ts

@@ -0,0 +1,4 @@
+import { type UseQueryOptions } from '@tanstack/react-query';
+import { type AdminRole } from '../core/rest/projects-client/account-lifecycle.js';
+export declare const ADMIN_ROLE_QUERY_KEY = "admin-role";
+export declare function useAdminRole(userId: string | null | undefined, options?: Partial<UseQueryOptions<AdminRole>>): import("@tanstack/react-query").UseQueryResult<AdminRole, Error>;

package/dist/react/use-admin-role.js

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { getAdminRole } from '../core/rest/projects-client/account-lifecycle.js';
+export const ADMIN_ROLE_QUERY_KEY = 'admin-role';
+export function useAdminRole(userId, options) {
+    return useQuery({
+        queryKey: [ADMIN_ROLE_QUERY_KEY, userId],
+        queryFn: async () => (userId ? getAdminRole() : { isAdmin: false, role: null }),
+        enabled: !!userId && options?.enabled !== false,
+        staleTime: 30 * 1000,
+        gcTime: 5 * 60 * 1000,
+        refetchOnWindowFocus: true,
+        refetchOnMount: true,
+        ...options,
+    });
+}

package/dist/react/use-admin-sandboxes.d.ts

@@ -0,0 +1,156 @@
+import { type UseQueryOptions } from '@tanstack/react-query';
+export interface AdminSandbox {
+    sandboxId: string;
+    accountId: string | null;
+    name: string | null;
+    provider: string | null;
+    externalId: string | null;
+    status: string | null;
+    baseUrl: string | null;
+    metadata: unknown;
+    createdAt: string;
+    updatedAt: string;
+    lastUsedAt: string | null;
+    accountName: string | null;
+    ownerEmail: string | null;
+    initStatus?: 'pending' | 'provisioning' | 'retrying' | 'ready' | 'failed';
+    healthStatus?: 'healthy' | 'degraded' | 'offline' | 'unknown';
+    initAttempts?: number;
+    lastInitError?: string | null;
+}
+export interface AdminSandboxesParams {
+    search?: string;
+    status?: string;
+    provider?: string;
+    page?: number;
+    limit?: number;
+}
+interface AdminSandboxesResponse {
+    sandboxes: AdminSandbox[];
+    total: number;
+    page: number;
+    limit: number;
+    error?: string;
+}
+export declare function useAdminSandboxes(params?: AdminSandboxesParams, options?: Partial<UseQueryOptions<AdminSandboxesResponse>>): import("@tanstack/react-query").UseQueryResult<AdminSandboxesResponse, Error>;
+export interface AdminSandboxDetail {
+    sandbox: AdminSandbox & {
+        config: unknown;
+    };
+    provider_detail: ProviderMachineDetail | null;
+    provider_error: string | null;
+}
+export type AdminInstanceLayerStatus = 'healthy' | 'degraded' | 'offline' | 'unknown';
+export interface AdminInstanceLayerAction {
+    action: 'start_host' | 'reboot_host' | 'stop_host' | 'start_workload' | 'restart_workload' | 'stop_workload' | 'reinitialize' | 'restart_runtime' | 'restart_service';
+    label: string;
+    serviceId?: string;
+}
+export interface AdminInstanceLayerHealth {
+    key: 'host' | 'workload' | 'runtime';
+    label: string;
+    status: AdminInstanceLayerStatus;
+    summary: string;
+    actions: AdminInstanceLayerAction[];
+    details: Record<string, unknown>;
+}
+export interface AdminSandboxHealth {
+    sandbox_id: string;
+    overall_status: 'healthy' | 'degraded' | 'offline' | 'unknown';
+    recommended_action: AdminInstanceLayerAction['action'] | null;
+    last_heartbeat_at?: string | null;
+    layers: {
+        host: AdminInstanceLayerHealth;
+        workload: AdminInstanceLayerHealth;
+        runtime: AdminInstanceLayerHealth;
+    };
+}
+export interface AdminSandboxHealthBatchResponse {
+    items: AdminSandboxHealth[];
+}
+export interface ProviderMachineDetail {
+    id: string;
+    slug: string;
+    name: string | null;
+    status: string;
+    provisioning_stage: string | null;
+    provider: string;
+    server_type: string | null;
+    region: string | null;
+    ip: string | null;
+    daemon_version: string | null;
+    created_at: string;
+    ready_at: string | null;
+    last_heartbeat_at?: string | null;
+    health: {
+        cpu?: number;
+        memory?: number;
+        disk?: number;
+        services?: Record<string, boolean>;
+        network?: {
+            rate_in?: number;
+            rate_out?: number;
+            connections?: number;
+        };
+        security?: {
+            ufw_active?: boolean;
+            fail2ban_active?: boolean;
+            ssh_key_only?: boolean;
+        };
+        last_heartbeat_at?: string | null;
+    } | null;
+    urls?: {
+        proxy?: string;
+        terminal?: string;
+    } | null;
+    ssh?: {
+        command?: string | null;
+        setup_command?: string | null;
+    } | null;
+    connect?: {
+        ssh_command?: string | null;
+        setup_command?: string | null;
+        vscode_url?: string | null;
+    } | null;
+    ssh_key?: {
+        setup_command?: string | null;
+        key_path?: string | null;
+    } | null;
+}
+export declare function useAdminSandboxDetail(sandboxId: string | null): import("@tanstack/react-query").UseQueryResult<AdminSandboxDetail, Error>;
+export declare function useAdminSandboxHealth(sandboxId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<AdminSandboxHealth, Error>;
+export declare function useAdminSandboxHealthBatch(sandboxIds: string[], enabled?: boolean): import("@tanstack/react-query").UseQueryResult<AdminSandboxHealthBatchResponse, Error>;
+export interface ExecResult {
+    stdout?: string;
+    stderr?: string;
+    exit_code?: number;
+    duration_ms?: number;
+    error?: string;
+}
+export declare function useAdminSandboxExec(): import("@tanstack/react-query").UseMutationResult<ExecResult, Error, {
+    sandboxId: string;
+    command: string;
+    timeout?: number;
+}>;
+export interface ProxyTokenResult {
+    token: string;
+    token_id: string;
+    expires_at: number;
+    terminal_url: string | null;
+    proxy_url: string | null;
+}
+export declare function fetchAdminSandboxProxyToken(_sandboxId: string): Promise<ProxyTokenResult>;
+export declare function useAdminSandboxAction(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    sandboxId: string;
+    action: "reboot" | "stop" | "start";
+}>;
+export declare function useAdminSandboxRepair(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    sandboxId: string;
+    action: AdminInstanceLayerAction["action"];
+    serviceId?: string;
+}>;
+export declare function useDeleteAdminSandbox(): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+    sandboxId: string;
+}, Error, string>;
+export {};

package/dist/react/use-admin-sandboxes.js

@@ -0,0 +1,52 @@
+import { useQuery } from '@tanstack/react-query';
+import { backendApi } from '../core/http/api-client.js';
+import { retiredEndpointError } from '../core/http/api/errors.js';
+import { useRetiredMutation, useRetiredQuery } from './retired-endpoint.js';
+export function useAdminSandboxes(params = {}, options) {
+    const { search = '', status = '', provider = '', page = 1, limit = 50 } = params;
+    return useQuery({
+        queryKey: ['admin', 'sandboxes', search, status, provider, page, limit],
+        queryFn: async () => {
+            const q = new URLSearchParams();
+            if (search)
+                q.set('search', search);
+            if (status)
+                q.set('status', status);
+            if (provider)
+                q.set('provider', provider);
+            q.set('page', String(page));
+            q.set('limit', String(limit));
+            const response = await backendApi.get(`/admin/api/sandboxes?${q.toString()}`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        staleTime: 15_000,
+        placeholderData: (prev) => prev,
+        ...options,
+    });
+}
+export function useAdminSandboxDetail(sandboxId) {
+    return useRetiredQuery('useAdminSandboxDetail', ['admin', 'sandbox-detail', sandboxId], !!sandboxId);
+}
+export function useAdminSandboxHealth(sandboxId, enabled = true) {
+    return useRetiredQuery('useAdminSandboxHealth', ['admin', 'sandbox-health', sandboxId], !!sandboxId && enabled);
+}
+export function useAdminSandboxHealthBatch(sandboxIds, enabled = true) {
+    return useRetiredQuery('useAdminSandboxHealthBatch', ['admin', 'sandbox-health-batch', sandboxIds], enabled && sandboxIds.length > 0);
+}
+export function useAdminSandboxExec() {
+    return useRetiredMutation('useAdminSandboxExec');
+}
+export async function fetchAdminSandboxProxyToken(_sandboxId) {
+    throw retiredEndpointError('fetchAdminSandboxProxyToken');
+}
+export function useAdminSandboxAction() {
+    return useRetiredMutation('useAdminSandboxAction');
+}
+export function useAdminSandboxRepair() {
+    return useRetiredMutation('useAdminSandboxRepair');
+}
+export function useDeleteAdminSandbox() {
+    return useRetiredMutation('useDeleteAdminSandbox');
+}

package/dist/react/use-authenticated-preview-url.d.ts

@@ -0,0 +1,3 @@
+import { buildPreviewAuthEndpoint, isSubdomainPreviewUrl, appendPreviewToken } from '../core/session/preview.js';
+export { buildPreviewAuthEndpoint, isSubdomainPreviewUrl, appendPreviewToken };
+export declare function useAuthenticatedPreviewUrl(previewUrl: string): string | null;

package/dist/react/use-authenticated-preview-url.js

@@ -0,0 +1,96 @@
+'use client';
+import { useEffect, useState } from 'react';
+import { getAuthToken } from '../core/http/auth.js';
+import { useServerStore } from '../browser/stores/server-store.js';
+import { buildPreviewAuthEndpoint, isSubdomainPreviewUrl, appendPreviewToken, } from '../core/session/preview.js';
+import { shouldAttachPreviewToken } from '../core/session/preview-origin-trust.js';
+import { isInternalLocalhostUrl } from '../core/session/url.js';
+export { buildPreviewAuthEndpoint, isSubdomainPreviewUrl, appendPreviewToken };
+export function useAuthenticatedPreviewUrl(previewUrl) {
+    const [authenticatedUrl, setAuthenticatedUrl] = useState(null);
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    useEffect(() => {
+        if (!previewUrl || isInternalLocalhostUrl(previewUrl)) {
+            setAuthenticatedUrl(null);
+            return;
+        }
+        let cancelled = false;
+        async function authenticateAndExpose() {
+            const token = await getAuthToken();
+            if (cancelled)
+                return;
+            if (!token) {
+                setAuthenticatedUrl(previewUrl);
+                return;
+            }
+            if (isSubdomainPreviewUrl(previewUrl)) {
+                const trusted = await shouldAttachPreviewToken(previewUrl, { serverUrl });
+                if (cancelled)
+                    return;
+                setAuthenticatedUrl(trusted ? appendPreviewToken(previewUrl, token) : previewUrl);
+                return;
+            }
+            const authEndpoint = buildPreviewAuthEndpoint(previewUrl, serverUrl);
+            if (!authEndpoint) {
+                setAuthenticatedUrl(previewUrl);
+                return;
+            }
+            try {
+                await fetch(authEndpoint, {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+            catch {
+            }
+            try {
+                await fetch(previewUrl, {
+                    method: 'HEAD',
+                    credentials: 'include',
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                    },
+                });
+            }
+            catch {
+            }
+            if (cancelled)
+                return;
+            setAuthenticatedUrl(previewUrl);
+        }
+        setAuthenticatedUrl(null);
+        authenticateAndExpose();
+        const interval = setInterval(() => {
+            (async () => {
+                const token = await getAuthToken();
+                if (cancelled || !token)
+                    return;
+                const authEndpoint = buildPreviewAuthEndpoint(previewUrl, serverUrl);
+                if (!authEndpoint) {
+                    return;
+                }
+                try {
+                    await fetch(authEndpoint, {
+                        method: 'POST',
+                        credentials: 'include',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json',
+                        },
+                    });
+                }
+                catch {
+                }
+            })();
+        }, 55_000);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [previewUrl, serverUrl]);
+    return authenticatedUrl;
+}

package/dist/react/use-beeuni-app-viewer.d.ts

@@ -0,0 +1,12 @@
+import { type BeeuniAppViewerOptions, type BeeuniAppViewerSession } from '../core/auth/app-viewer.js';
+export type BeeuniAppViewerState = {
+    status: 'loading';
+    viewer: null;
+} | {
+    status: 'anonymous';
+    viewer: null;
+} | {
+    status: 'viewer';
+    viewer: BeeuniAppViewerSession;
+};
+export declare function useBeeuniAppViewer(options?: BeeuniAppViewerOptions): BeeuniAppViewerState;

package/dist/react/use-beeuni-app-viewer.js

@@ -0,0 +1,19 @@
+'use client';
+import { useEffect, useState } from 'react';
+import { fetchBeeuniAppViewer, } from '../core/auth/app-viewer.js';
+export function useBeeuniAppViewer(options = {}) {
+    const path = options.path;
+    const [state, setState] = useState({ status: 'loading', viewer: null });
+    useEffect(() => {
+        let cancelled = false;
+        fetchBeeuniAppViewer({ path }).then((viewer) => {
+            if (cancelled)
+                return;
+            setState(viewer ? { status: 'viewer', viewer } : { status: 'anonymous', viewer: null });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [path]);
+    return state;
+}