@beeuni/sdk 0.1.0

package/dist/react/use-sessions-needing-input.d.ts

@@ -0,0 +1,5 @@
+import { type ProjectSession, type SessionsNeedingInputResponse } from '../core/rest/projects-client/index.js';
+export declare function sessionNeedsInputCount(summary: SessionsNeedingInputResponse | undefined, session: Pick<ProjectSession, 'session_id' | 'runtime_session_id'>): number;
+export declare function useSessionsNeedingInput(projectId: string, options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<SessionsNeedingInputResponse, Error>;

package/dist/react/use-sessions-needing-input.js

@@ -0,0 +1,23 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { listSessionsNeedingInput, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function sessionNeedsInputCount(summary, session) {
+    if (!summary)
+        return 0;
+    return (summary.sessions[session.session_id] ??
+        (session.runtime_session_id ? summary.sessions[session.runtime_session_id] : undefined) ??
+        0);
+}
+export function useSessionsNeedingInput(projectId, options) {
+    const enabled = Boolean(projectId) && options?.enabled !== false;
+    return useQuery({
+        queryKey: qk.project.needsInput(projectId),
+        queryFn: () => listSessionsNeedingInput(projectId),
+        enabled,
+        ...contract('volatile'),
+        refetchInterval: enabled ? 30_000 : false,
+        refetchOnWindowFocus: true,
+    });
+}

package/dist/react/use-static-file-preview.d.ts

@@ -0,0 +1,9 @@
+export type StaticFilePreviewStatus = 'checking' | 'ready' | 'unavailable';
+export interface StaticFilePreview {
+    url: string | null;
+    status: StaticFilePreviewStatus;
+    retry: () => void;
+}
+export declare function useStaticFilePreview(path: string | undefined, options?: {
+    enabled?: boolean;
+}): StaticFilePreview;

package/dist/react/use-static-file-preview.js

@@ -0,0 +1,72 @@
+'use client';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { getAuthToken } from '../core/http/auth.js';
+import { appendPreviewToken, isSubdomainPreviewUrl } from '../core/session/preview.js';
+import { shouldAttachPreviewToken } from '../core/session/preview-origin-trust.js';
+import { probePreviewPort } from '../core/session/preview-probe.js';
+import { STATIC_FILE_HEALTH_RETRY_MS, authenticatedUrlAddresses, shouldRetryStaticFileHealth, staticFilePreviewTargets, } from '../core/session/static-file-preview.js';
+import { useActiveSandboxProxyContext } from './runtime-actions.js';
+import { useAuthenticatedPreviewUrl } from './use-authenticated-preview-url.js';
+export function useStaticFilePreview(path, options) {
+    const enabled = options?.enabled !== false;
+    const { subdomainOpts } = useActiveSandboxProxyContext();
+    const targets = useMemo(() => (enabled ? staticFilePreviewTargets(path, subdomainOpts) : null), [enabled, path, subdomainOpts]);
+    const authenticatedUrl = useAuthenticatedPreviewUrl(targets?.previewUrl ?? '');
+    const [status, setStatus] = useState('checking');
+    const [retryNonce, setRetryNonce] = useState(0);
+    const retry = useCallback(() => setRetryNonce((n) => n + 1), []);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        let cancelled = false;
+        let attempts = 0;
+        let timer = null;
+        setStatus('checking');
+        function waitOrGiveUp() {
+            if (cancelled)
+                return;
+            if (!shouldRetryStaticFileHealth(attempts)) {
+                setStatus('unavailable');
+                return;
+            }
+            timer = setTimeout(tick, STATIC_FILE_HEALTH_RETRY_MS);
+        }
+        async function tick() {
+            if (cancelled)
+                return;
+            attempts += 1;
+            if (!targets) {
+                waitOrGiveUp();
+                return;
+            }
+            let url = targets.healthUrl;
+            if (isSubdomainPreviewUrl(url) && (await shouldAttachPreviewToken(url))) {
+                const token = await getAuthToken();
+                if (cancelled)
+                    return;
+                if (token)
+                    url = appendPreviewToken(url, token);
+            }
+            const verdict = await probePreviewPort(url);
+            if (cancelled)
+                return;
+            if (verdict === 'reachable') {
+                setStatus('ready');
+                return;
+            }
+            waitOrGiveUp();
+        }
+        void tick();
+        return () => {
+            cancelled = true;
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [enabled, targets, retryNonce]);
+    const addressesThisFile = authenticatedUrlAddresses(authenticatedUrl, targets?.previewUrl);
+    return {
+        url: status === 'ready' && addressesThisFile ? authenticatedUrl : null,
+        status,
+        retry,
+    };
+}

package/dist/react/use-system-status.d.ts

@@ -0,0 +1,38 @@
+export interface MaintenanceNotice {
+    enabled: boolean;
+    start_time?: string | null;
+    end_time?: string | null;
+}
+export interface TechnicalIssue {
+    enabled: boolean;
+    message?: string | null;
+    status_url?: string | null;
+    affected_services?: string[] | null;
+    description?: string | null;
+    estimated_resolution?: string | null;
+    severity?: 'degraded' | 'outage' | 'maintenance' | null;
+}
+export interface SystemStatus {
+    maintenance_notice: MaintenanceNotice;
+    technical_issue: TechnicalIssue;
+    updated_at?: string | null;
+    updated_by?: string | null;
+}
+export interface UpdateMaintenanceRequest {
+    enabled: boolean;
+    start_time?: string | null;
+    end_time?: string | null;
+}
+export interface UpdateTechnicalIssueRequest {
+    enabled: boolean;
+    message?: string | null;
+    status_url?: string | null;
+    affected_services?: string[] | null;
+    description?: string | null;
+    estimated_resolution?: string | null;
+    severity?: 'degraded' | 'outage' | 'maintenance' | null;
+}
+export declare const useSystemStatus: () => import("@tanstack/react-query").UseQueryResult<SystemStatus, Error>;
+export declare const useUpdateMaintenanceNotice: () => import("@tanstack/react-query").UseMutationResult<SystemStatus | undefined, Error, UpdateMaintenanceRequest>;
+export declare const useUpdateTechnicalIssue: () => import("@tanstack/react-query").UseMutationResult<SystemStatus | undefined, Error, UpdateTechnicalIssueRequest>;
+export declare const useClearSystemStatus: () => import("@tanstack/react-query").UseMutationResult<SystemStatus | undefined, Error, void>;

package/dist/react/use-system-status.js

@@ -0,0 +1,5 @@
+import { useRetiredMutation, useRetiredQuery } from './retired-endpoint.js';
+export const useSystemStatus = () => useRetiredQuery('useSystemStatus', ['admin-system-status']);
+export const useUpdateMaintenanceNotice = () => useRetiredMutation('useUpdateMaintenanceNotice');
+export const useUpdateTechnicalIssue = () => useRetiredMutation('useUpdateTechnicalIssue');
+export const useClearSystemStatus = () => useRetiredMutation('useClearSystemStatus');

package/dist/react/use-teams-installations.d.ts

@@ -0,0 +1,41 @@
+export type TeamsPublishState = 'publishing' | 'published' | 'review' | 'failed';
+export interface TeamsInstallation {
+    tenantId: string;
+    teamId: string | null;
+    teamName: string | null;
+    botId: string | null;
+    serviceUrl: string | null;
+    byo: boolean;
+    orgInstalled: boolean;
+    catalogAppId: string | null;
+    publishState?: TeamsPublishState | null;
+    publishError?: string | null;
+    appVersion?: string | null;
+    latestAppVersion?: string;
+    appUpdateAvailable?: boolean;
+    installedAt: string;
+}
+export interface TeamsMode {
+    enabled: boolean;
+    available: boolean;
+    appId: string | null;
+    messagingEndpoint: string | null;
+    adminConsentUrl: string | null;
+    deepLinkUrl: string | null;
+    orgConsentUrl: string | null;
+    orgInstalled: boolean;
+    byo: boolean;
+}
+export declare function useTeamsInstall(projectId: string | null): import("@tanstack/react-query").UseQueryResult<TeamsInstallation | null, Error>;
+export declare function useTeamsMode(projectId: string | null): import("@tanstack/react-query").UseQueryResult<TeamsMode, Error>;
+export declare function useTeamsManifest(projectId: string | null): import("@tanstack/react-query").UseQueryResult<string | null, Error>;
+interface ConnectInput {
+    projectId: string;
+    tenant_id: string;
+    team_name?: string;
+    app_id?: string;
+    app_password?: string;
+}
+export declare function useConnectTeams(): import("@tanstack/react-query").UseMutationResult<TeamsInstallation, Error, ConnectInput, unknown>;
+export declare function useDisconnectTeams(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export {};

package/dist/react/use-teams-installations.js

@@ -0,0 +1,95 @@
+'use client';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { backendApi } from '../core/http/api-client.js';
+import { teamsInstallRefetchInterval } from './teams-install-polling.js';
+const key = (projectId) => ['channels', 'teams-install', projectId ?? 'none'];
+const modeKey = (projectId) => ['channels', 'teams-mode', projectId ?? 'none'];
+const manifestKey = (projectId) => ['channels', 'teams-manifest', projectId ?? 'none'];
+export function useTeamsInstall(projectId) {
+    return useQuery({
+        queryKey: key(projectId),
+        enabled: !!projectId,
+        staleTime: 30_000,
+        refetchInterval: (query) => teamsInstallRefetchInterval(query.state.data),
+        queryFn: async () => {
+            if (!projectId)
+                return null;
+            const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/teams/installation`, { showErrors: false });
+            if (!res.success)
+                return null;
+            return res.data ?? null;
+        },
+    });
+}
+export function useTeamsMode(projectId) {
+    return useQuery({
+        queryKey: modeKey(projectId),
+        enabled: !!projectId,
+        staleTime: 60_000,
+        queryFn: async () => {
+            const fallback = {
+                enabled: false,
+                available: false,
+                appId: null,
+                messagingEndpoint: null,
+                adminConsentUrl: null,
+                deepLinkUrl: null,
+                orgConsentUrl: null,
+                orgInstalled: false,
+                byo: false,
+            };
+            if (!projectId)
+                return fallback;
+            const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/teams/mode`, { showErrors: false });
+            if (!res.success || !res.data)
+                return fallback;
+            return res.data;
+        },
+    });
+}
+export function useTeamsManifest(projectId) {
+    return useQuery({
+        queryKey: manifestKey(projectId),
+        enabled: !!projectId,
+        staleTime: 60_000,
+        queryFn: async () => {
+            if (!projectId)
+                return null;
+            const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/teams/manifest`, { showErrors: false });
+            if (!res.success || !res.data) {
+                throw new Error(res.error?.message ?? 'Failed to load Teams manifest');
+            }
+            return JSON.stringify(res.data, null, 2);
+        },
+    });
+}
+export function useConnectTeams() {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ projectId, ...body }) => {
+            const res = await backendApi.post(`/projects/${encodeURIComponent(projectId)}/channels/teams/connect`, body, { showErrors: false });
+            if (!res.success || !res.data) {
+                throw new Error(res.error?.message ?? 'Failed to connect');
+            }
+            return res.data;
+        },
+        onSuccess: (_data, { projectId }) => {
+            qc.invalidateQueries({ queryKey: key(projectId) });
+            qc.invalidateQueries({ queryKey: modeKey(projectId) });
+            qc.invalidateQueries({ queryKey: manifestKey(projectId) });
+        },
+    });
+}
+export function useDisconnectTeams() {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: async (projectId) => {
+            const res = await backendApi.delete(`/projects/${encodeURIComponent(projectId)}/channels/teams/installation`, { showErrors: false });
+            if (!res.success)
+                throw new Error(res.error?.message ?? 'Failed to disconnect');
+        },
+        onSuccess: (_data, projectId) => {
+            qc.invalidateQueries({ queryKey: key(projectId) });
+        },
+    });
+}

package/dist/react/use-tunnel.d.ts

@@ -0,0 +1,165 @@
+import { type ConnectorConnectOwner } from '../core/rest/projects-client/index.js';
+export interface TunnelConnection {
+    tunnelId: string;
+    accountId: string;
+    sandboxId: string | null;
+    name: string;
+    status: 'online' | 'offline' | 'connecting';
+    capabilities: string[];
+    machineInfo: Record<string, unknown>;
+    lastHeartbeatAt: string | null;
+    isLive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    ownerUserId?: string | null;
+    access?: ComputerAccess | null;
+}
+export interface ComputerAccess {
+    mode: 'ask' | 'always' | 'off';
+    grantedUntil: string | null;
+    deniedUntil?: string | null;
+    keepAwake?: boolean;
+    keepAwakeSupported?: boolean;
+    pendingRequest?: {
+        capability: string;
+        requestedAt: string;
+        change?: ComputerAccessChange;
+    } | null;
+    desktopPermissions?: {
+        accessibility: boolean;
+        screenRecording: boolean;
+    } | null;
+    controllable: boolean;
+}
+export interface ComputerAccessChange {
+    mode?: ComputerAccess['mode'];
+    grantMinutes?: number;
+    revoke?: boolean;
+    deny?: boolean;
+    keepAwake?: boolean;
+}
+export interface TunnelPermission {
+    permissionId: string;
+    tunnelId: string;
+    accountId: string;
+    capability: string;
+    scope: Record<string, unknown>;
+    status: 'active' | 'revoked' | 'expired';
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TunnelPermissionRequest {
+    requestId: string;
+    tunnelId: string;
+    accountId: string;
+    capability: string;
+    requestedScope: Record<string, unknown>;
+    reason: string | null;
+    status: 'pending' | 'approved' | 'denied' | 'expired';
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TunnelAuditLog {
+    logId: string;
+    tunnelId: string;
+    accountId: string;
+    capability: string;
+    operation: string;
+    requestSummary: Record<string, unknown>;
+    success: boolean;
+    durationMs: number | null;
+    bytesTransferred: number | null;
+    errorMessage: string | null;
+    createdAt: string;
+}
+export interface AuditLogPage {
+    data: TunnelAuditLog[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export declare const tunnelKeys: {
+    all: readonly ["tunnel"];
+    connections: () => readonly ["tunnel", "connections"];
+    connection: (id: string) => readonly ["tunnel", "connection", string];
+    permissions: (tunnelId: string) => readonly ["tunnel", "permissions", string];
+    permissionRequests: () => readonly ["tunnel", "permission-requests"];
+    auditLogs: (tunnelId: string, page: number) => readonly ["tunnel", "audit", string, number];
+    deviceAuth: (code: string) => readonly ["tunnel", "device-auth", string];
+};
+export declare function useTunnelConnections(options?: {
+    refetchInterval?: number | false;
+}): import("@tanstack/react-query").UseQueryResult<TunnelConnection[], Error>;
+export declare function useTunnelConnection(tunnelId: string): import("@tanstack/react-query").UseQueryResult<TunnelConnection, Error>;
+export interface TunnelConnectionCreateResponse extends TunnelConnection {
+    setupToken: string;
+}
+export declare function useCreateTunnelConnection(): import("@tanstack/react-query").UseMutationResult<TunnelConnectionCreateResponse, Error, {
+    name: string;
+    sandboxId?: string;
+    capabilities?: string[];
+}>;
+export declare function useUpdateTunnelConnection(): import("@tanstack/react-query").UseMutationResult<TunnelConnection, Error, {
+    tunnelId: string;
+    name?: string;
+    capabilities?: string[];
+}, unknown>;
+export declare function useDeleteTunnelConnection(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare function useSetComputerAccess(): import("@tanstack/react-query").UseMutationResult<ComputerAccess, Error, ComputerAccessChange & {
+    tunnelId: string;
+}, unknown>;
+export declare function useTunnelPermissions(tunnelId: string): import("@tanstack/react-query").UseQueryResult<TunnelPermission[], Error>;
+export declare function useGrantTunnelPermission(): import("@tanstack/react-query").UseMutationResult<TunnelPermission, Error, {
+    tunnelId: string;
+    capability: string;
+    scope?: Record<string, unknown>;
+    expiresAt?: string;
+}>;
+export declare function useRevokeTunnelPermission(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    tunnelId: string;
+    permissionId: string;
+}>;
+export declare function useTunnelPermissionRequests(): import("@tanstack/react-query").UseQueryResult<TunnelPermissionRequest[], Error>;
+export declare function useApprovePermissionRequest(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    requestId: string;
+    scope?: Record<string, unknown>;
+    expiresAt?: string;
+}>;
+export declare function useDenyPermissionRequest(): import("@tanstack/react-query").UseMutationResult<void, Error, string>;
+export declare function useAddComputerToProject(): import("@tanstack/react-query").UseMutationResult<import("../index.js").Connection, Error, {
+    projectId: string;
+    tunnelId: string;
+    share?: ConnectorConnectOwner;
+}, unknown>;
+export interface DeviceAuthInfo {
+    deviceCode: string;
+    machineHostname: string | null;
+    projectId?: string | null;
+    status: 'pending' | 'approved' | 'denied' | 'expired';
+    expiresAt: string;
+    createdAt: string;
+    registered?: {
+        tunnelId: string;
+        name: string;
+        capabilities: string[];
+        isLive: boolean;
+    } | null;
+}
+export declare function useDeviceAuthInfo(code: string): import("@tanstack/react-query").UseQueryResult<DeviceAuthInfo, Error>;
+export declare function useApproveDeviceAuth(): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+    tunnelId: string;
+    connectionId?: string | null;
+}, Error, {
+    code: string;
+    name?: string;
+    capabilities?: string[];
+    projectId?: string;
+    share?: ConnectorConnectOwner;
+}, unknown>;
+export declare function useDenyDeviceAuth(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare function useTunnelAuditLogs(tunnelId: string, page?: number, _limit?: number): import("@tanstack/react-query").UseQueryResult<AuditLogPage, Error>;

package/dist/react/use-tunnel.js

@@ -0,0 +1,186 @@
+'use client';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { backendApi } from '../core/http/api-client.js';
+import { addComputerToProject } from '../core/rest/projects-client/index.js';
+import { useRetiredMutation, useRetiredQuery } from './retired-endpoint.js';
+export const tunnelKeys = {
+    all: ['tunnel'],
+    connections: () => [...tunnelKeys.all, 'connections'],
+    connection: (id) => [...tunnelKeys.all, 'connection', id],
+    permissions: (tunnelId) => [...tunnelKeys.all, 'permissions', tunnelId],
+    permissionRequests: () => [...tunnelKeys.all, 'permission-requests'],
+    auditLogs: (tunnelId, page) => [...tunnelKeys.all, 'audit', tunnelId, page],
+    deviceAuth: (code) => [...tunnelKeys.all, 'device-auth', code],
+};
+export function useTunnelConnections(options = {}) {
+    return useQuery({
+        queryKey: tunnelKeys.connections(),
+        queryFn: async () => {
+            const res = await backendApi.get('/tunnel/connections', {
+                showErrors: false,
+                timeout: 10_000,
+            });
+            if (!res.success)
+                throw res.error ?? new Error('Failed to fetch connections');
+            return res.data;
+        },
+        staleTime: 2_000,
+        refetchInterval: options.refetchInterval ?? 5_000,
+        refetchIntervalInBackground: false,
+        refetchOnMount: 'always',
+        refetchOnWindowFocus: 'always',
+    });
+}
+export function useTunnelConnection(tunnelId) {
+    return useQuery({
+        queryKey: tunnelKeys.connection(tunnelId),
+        queryFn: async () => {
+            const res = await backendApi.get(`/tunnel/connections/${tunnelId}`, {
+                showErrors: false,
+                timeout: 10_000,
+            });
+            if (!res.success)
+                throw res.error ?? new Error('Failed to fetch connection');
+            return res.data;
+        },
+        enabled: !!tunnelId,
+        staleTime: 2_000,
+        refetchInterval: 5_000,
+        refetchIntervalInBackground: false,
+        refetchOnMount: 'always',
+        refetchOnWindowFocus: 'always',
+    });
+}
+export function useCreateTunnelConnection() {
+    return useRetiredMutation('useCreateTunnelConnection');
+}
+export function useUpdateTunnelConnection() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ tunnelId, ...data }) => {
+            const res = await backendApi.patch(`/tunnel/connections/${tunnelId}`, data);
+            if (!res.success)
+                throw new Error(res.error?.message || 'Failed to update connection');
+            return res.data;
+        },
+        onSuccess: (_, vars) => {
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connections() });
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connection(vars.tunnelId) });
+        },
+    });
+}
+export function useDeleteTunnelConnection() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (tunnelId) => {
+            const res = await backendApi.delete(`/tunnel/connections/${tunnelId}`);
+            if (!res.success)
+                throw new Error(res.error?.message || 'Failed to delete connection');
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connections() });
+            queryClient.invalidateQueries({ queryKey: ['connections'] });
+        },
+    });
+}
+export function useSetComputerAccess() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ tunnelId, ...change }) => {
+            const res = await backendApi.post(`/tunnel/connections/${tunnelId}/access`, change, {
+                showErrors: false,
+                timeout: 60_000,
+            });
+            if (!res.success)
+                throw res.error ?? new Error('Failed to change computer access');
+            return res.data;
+        },
+        onSuccess: (_, vars) => {
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connections() });
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connection(vars.tunnelId) });
+        },
+        onError: () => { },
+    });
+}
+export function useTunnelPermissions(tunnelId) {
+    return useRetiredQuery('useTunnelPermissions', tunnelKeys.permissions(tunnelId), !!tunnelId);
+}
+export function useGrantTunnelPermission() {
+    return useRetiredMutation('useGrantTunnelPermission');
+}
+export function useRevokeTunnelPermission() {
+    return useRetiredMutation('useRevokeTunnelPermission');
+}
+export function useTunnelPermissionRequests() {
+    return useRetiredQuery('useTunnelPermissionRequests', tunnelKeys.permissionRequests());
+}
+export function useApprovePermissionRequest() {
+    return useRetiredMutation('useApprovePermissionRequest');
+}
+export function useDenyPermissionRequest() {
+    return useRetiredMutation('useDenyPermissionRequest');
+}
+export function useAddComputerToProject() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ...input }) => addComputerToProject(projectId, input),
+        onSuccess: (_, vars) => {
+            queryClient.invalidateQueries({ queryKey: ['connections', vars.projectId] });
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connections() });
+        },
+    });
+}
+export function useDeviceAuthInfo(code) {
+    return useQuery({
+        queryKey: tunnelKeys.deviceAuth(code),
+        queryFn: async () => {
+            const res = await backendApi.get(`/tunnel/device-auth/${code}/info`, {
+                showErrors: false,
+                timeout: 10_000,
+            });
+            if (!res.success)
+                throw res.error ?? new Error('Failed to fetch device auth info');
+            return res.data;
+        },
+        enabled: !!code,
+        staleTime: 2_000,
+        refetchInterval: 5_000,
+    });
+}
+export function useApproveDeviceAuth() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ code, projectId, share, ...data }) => {
+            const res = await backendApi.post(`/tunnel/device-auth/${code}/approve`, {
+                ...data,
+                ...(projectId ? { project_id: projectId } : {}),
+                ...(share ? { share } : {}),
+            });
+            if (!res.success)
+                throw new Error(res.error?.message || 'Failed to approve device');
+            return res.data;
+        },
+        onSuccess: (_, vars) => {
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.deviceAuth(vars.code) });
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.connections() });
+            if (vars.projectId)
+                queryClient.invalidateQueries({ queryKey: ['connections', vars.projectId] });
+        },
+    });
+}
+export function useDenyDeviceAuth() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (code) => {
+            const res = await backendApi.post(`/tunnel/device-auth/${code}/deny`);
+            if (!res.success)
+                throw new Error(res.error?.message || 'Failed to deny device');
+        },
+        onSuccess: (_, code) => {
+            queryClient.invalidateQueries({ queryKey: tunnelKeys.deviceAuth(code) });
+        },
+    });
+}
+export function useTunnelAuditLogs(tunnelId, page = 1, _limit = 50) {
+    return useRetiredQuery('useTunnelAuditLogs', tunnelKeys.auditLogs(tunnelId, page), !!tunnelId);
+}

package/dist/react/use-visible-agents.d.ts

@@ -0,0 +1,9 @@
+import type { Agent } from '../core/runtime/runtime-types.js';
+export declare function useVisibleAgents(options?: {
+    directory?: string;
+    projectId?: string | null;
+}): Agent[];
+export declare function useAllVisibleAgents(options?: {
+    directory?: string;
+    projectId?: string | null;
+}): Agent[];

package/dist/react/use-visible-agents.js

@@ -0,0 +1,12 @@
+'use client';
+import { useMemo } from 'react';
+import { useRuntimeAgents } from './use-opencode-sessions/index.js';
+import { isSelectableAgent } from '../core/rest/projects-client/project-agents.js';
+export function useVisibleAgents(options) {
+    const { data: agents = [] } = useRuntimeAgents(options);
+    return useMemo(() => agents.filter(isSelectableAgent), [agents]);
+}
+export function useAllVisibleAgents(options) {
+    const { data: agents = [] } = useRuntimeAgents(options);
+    return useMemo(() => agents.filter((a) => isSelectableAgent({ ...a, mode: null })), [agents]);
+}