@beeuni/sdk 0.1.0

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

@@ -0,0 +1,35 @@
+import { type QueryClient } from '@tanstack/react-query';
+import { type PermissionProbeInput, type ResourceType } from '../core/rest/projects-client/index.js';
+export interface CanResult {
+    allowed: boolean;
+    reason: string | null;
+    isLoading: boolean;
+    isError: boolean;
+}
+export type CanTarget = {
+    accountId: string | undefined;
+    projectId?: undefined;
+    resource?: {
+        type: Exclude<ResourceType, 'account'>;
+        id: string;
+    };
+} | {
+    projectId: string | undefined;
+    accountId?: string;
+    resource?: undefined;
+};
+export interface CanOptions {
+    userId?: string;
+}
+export declare const permissionProbeKey: (accountId: string | undefined, userId: string | undefined, action: string, target?: {
+    resourceType?: string;
+    resourceId?: string;
+}) => readonly ["iam-permission", string | undefined, string | undefined, string, string | null, string | null];
+export declare const permissionProbeBatchKey: (accountId: string | undefined, userId: string | undefined, probes: readonly PermissionProbeInput[]) => readonly ["iam-permission-batch", string | undefined, string | undefined, string];
+export declare function useCan(target: CanTarget, action: string, options?: CanOptions): CanResult;
+export declare function useCans(target: CanTarget, actions: readonly string[], options?: CanOptions): Record<string, CanResult>;
+export declare function usePermissionsFor(accountId: string | undefined, memberUserId: string | undefined, probes: PermissionProbeInput[]): CanResult[];
+export declare function invalidatePermissionProbes(queryClient: Pick<QueryClient, 'invalidateQueries'>, scope: {
+    accountId?: string;
+    userId?: string;
+}): Promise<void>;

package/dist/react/use-can.js

@@ -0,0 +1,129 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getProject, probeEffectivePermission, probeEffectivePermissions, validateToken, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+const PROBE_STALE_MS = 5 * 60_000;
+export const permissionProbeKey = (accountId, userId, action, target) => [
+    'iam-permission',
+    accountId,
+    userId,
+    action,
+    target?.resourceType ?? null,
+    target?.resourceId ?? null,
+];
+export const permissionProbeBatchKey = (accountId, userId, probes) => [
+    'iam-permission-batch',
+    accountId,
+    userId,
+    probes.map((p) => `${p.action}|${p.resourceType ?? ''}|${p.resourceId ?? ''}`).join(','),
+];
+const identityKey = ['iam-identity', 'me'];
+function useProbeUserId(explicit) {
+    const query = useQuery({
+        queryKey: identityKey,
+        queryFn: async () => (await validateToken()).identity ?? null,
+        enabled: !explicit,
+        staleTime: Infinity,
+    });
+    return explicit ?? query.data?.user_id;
+}
+function useOwningAccountId(projectId, accountIdHint) {
+    const { data } = useQuery({
+        queryKey: qk.project.summary(projectId ?? ''),
+        queryFn: () => getProject(projectId),
+        enabled: !!projectId && !accountIdHint,
+        ...contract('config'),
+    });
+    return projectId ? (accountIdHint ?? data?.account_id) : undefined;
+}
+const pending = () => ({
+    allowed: false,
+    reason: null,
+    isLoading: true,
+    isError: false,
+});
+function useResolvedTarget(target) {
+    const isProject = 'projectId' in target && target.projectId !== undefined;
+    const projectId = 'projectId' in target ? target.projectId : undefined;
+    const owningAccountId = useOwningAccountId(projectId, target.accountId);
+    const accountId = isProject ? owningAccountId : target.accountId;
+    const probeTarget = isProject
+        ? { resourceType: 'project', resourceId: projectId }
+        : target.resource
+            ? { resourceType: target.resource.type, resourceId: target.resource.id }
+            : undefined;
+    return { accountId, probeTarget, resolved: !!accountId && (!isProject || !!projectId) };
+}
+export function useCan(target, action, options) {
+    const userId = useProbeUserId(options?.userId);
+    const { accountId, probeTarget, resolved } = useResolvedTarget(target);
+    const enabled = resolved && !!userId;
+    const query = useQuery({
+        queryKey: permissionProbeKey(accountId, userId, action, probeTarget),
+        queryFn: () => probeEffectivePermission(accountId, userId, (probeTarget ? { action, ...probeTarget } : { action })),
+        enabled,
+        staleTime: PROBE_STALE_MS,
+    });
+    if (!enabled)
+        return pending();
+    return {
+        allowed: query.data?.allowed === true,
+        reason: query.data?.reason ?? null,
+        isLoading: query.isLoading,
+        isError: query.isError,
+    };
+}
+export function useCans(target, actions, options) {
+    const userId = useProbeUserId(options?.userId);
+    const { accountId, probeTarget, resolved } = useResolvedTarget(target);
+    const probes = actions.map((action) => (probeTarget ? { action, ...probeTarget } : { action }));
+    const enabled = resolved && !!userId && probes.length > 0;
+    const query = useQuery({
+        queryKey: permissionProbeBatchKey(accountId, userId, probes),
+        queryFn: () => probeEffectivePermissions(accountId, userId, probes),
+        enabled,
+        staleTime: PROBE_STALE_MS,
+    });
+    const map = {};
+    actions.forEach((action, i) => {
+        if (!enabled) {
+            map[action] = pending();
+            return;
+        }
+        const hit = query.data?.[i];
+        map[action] = {
+            allowed: hit?.allowed === true,
+            reason: hit?.reason ?? null,
+            isLoading: query.isLoading,
+            isError: query.isError,
+        };
+    });
+    return map;
+}
+export function usePermissionsFor(accountId, memberUserId, probes) {
+    const enabled = !!accountId && !!memberUserId && probes.length > 0;
+    const query = useQuery({
+        queryKey: permissionProbeBatchKey(accountId, memberUserId, probes),
+        queryFn: () => probeEffectivePermissions(accountId, memberUserId, probes),
+        enabled,
+        staleTime: PROBE_STALE_MS,
+    });
+    return probes.map((_, i) => {
+        if (!enabled)
+            return pending();
+        const hit = query.data?.[i];
+        return {
+            allowed: hit?.allowed === true,
+            reason: hit?.reason ?? null,
+            isLoading: query.isLoading,
+            isError: query.isError,
+        };
+    });
+}
+export function invalidatePermissionProbes(queryClient, scope) {
+    const suffix = [scope.accountId, scope.userId].filter((s) => !!s);
+    queryClient.invalidateQueries({ queryKey: ['iam-permission', ...suffix] });
+    queryClient.invalidateQueries({ queryKey: ['iam-permission-batch', ...suffix] });
+    return Promise.resolve();
+}

package/dist/react/use-canonical-opencode-session.d.ts

@@ -0,0 +1,21 @@
+import { type Session } from './use-opencode-sessions/index.js';
+export declare function clearRuntimeEnsureGuard(): void;
+export interface CanonicalRuntimeSession {
+    rootSessionId: string | null;
+    pinSettled: boolean;
+    sessions: Session[];
+    isLoading: boolean;
+    isError: boolean;
+    listed: boolean;
+    error: unknown;
+}
+export declare function useCanonicalRuntimeSession(params: {
+    projectId: string;
+    sessionId: string;
+    pinFromStart?: string | null;
+    initialPin?: string | null;
+    listRuntimeSessions?: boolean;
+}): CanonicalRuntimeSession;
+export type CanonicalOpenCodeSession = CanonicalRuntimeSession;
+export declare const clearOpencodeEnsureGuard: typeof clearRuntimeEnsureGuard;
+export declare const useCanonicalOpenCodeSession: typeof useCanonicalRuntimeSession;

package/dist/react/use-canonical-opencode-session.js

@@ -0,0 +1,44 @@
+'use client';
+import { useEffect, useLayoutEffect, useState } from 'react';
+import { readPersistedSessionPin, resolvePersistedPin, resolveSessionPin, writePersistedSessionPin, } from './initial-session-pin.js';
+import { useRuntimeSessions } from './use-opencode-sessions/index.js';
+import { useProjectSession } from './use-project-session.js';
+const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+export function clearRuntimeEnsureGuard() {
+}
+export function useCanonicalRuntimeSession(params) {
+    const { projectId, sessionId, pinFromStart, initialPin, listRuntimeSessions = true } = params;
+    const sessionsQuery = useRuntimeSessions(listRuntimeSessions);
+    const projectSessionQuery = useProjectSession(projectId, sessionId, {
+        enabled: !pinFromStart && !initialPin,
+    });
+    const networkPin = projectSessionQuery.data?.runtime_session_id ??
+        projectSessionQuery.data?.opencode_session_id ??
+        null;
+    const [cachedPin, setCachedPin] = useState(null);
+    useIsomorphicLayoutEffect(() => {
+        setCachedPin(readPersistedSessionPin(projectId, sessionId));
+    }, [projectId, sessionId]);
+    const pin = resolvePersistedPin({ networkPin, cachedPin });
+    const rootSessionId = resolveSessionPin({
+        startPin: pinFromStart,
+        initialPin,
+        persistedPin: pin,
+    });
+    const freshPin = pinFromStart ?? initialPin ?? null;
+    useEffect(() => {
+        if (freshPin)
+            writePersistedSessionPin(projectId, sessionId, freshPin);
+    }, [projectId, sessionId, freshPin]);
+    return {
+        rootSessionId,
+        pinSettled: rootSessionId !== null || (projectSessionQuery.isFetched && !projectSessionQuery.isFetching),
+        sessions: sessionsQuery.data ?? [],
+        isLoading: sessionsQuery.isLoading,
+        isError: sessionsQuery.isError,
+        listed: sessionsQuery.isSuccess,
+        error: sessionsQuery.error ?? null,
+    };
+}
+export const clearOpencodeEnsureGuard = clearRuntimeEnsureGuard;
+export const useCanonicalOpenCodeSession = useCanonicalRuntimeSession;

package/dist/react/use-change-requests.d.ts

@@ -0,0 +1,291 @@
+import { mergeChangeRequest, type ChangeRequest, type ChangeRequestStatus } from '../core/rest/projects-client/index.js';
+export declare const changeRequestsKey: (projectId: string | null | undefined) => readonly ["project-change-requests", string | null | undefined];
+export declare function useChangeRequests(projectId: string | null | undefined, status?: ChangeRequestStatus | 'all'): {
+    open: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, {
+        title: string;
+        description?: string;
+        head_ref: string;
+        base_ref?: string;
+        session_id?: string;
+    }, unknown>;
+    merge: import("@tanstack/react-query").UseMutationResult<import("../index.js").ChangeRequestMergeResponse, Error, {
+        crId: string;
+        input?: Parameters<typeof mergeChangeRequest>[2];
+    }, unknown>;
+    close: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, string, unknown>;
+    requestChanges: import("@tanstack/react-query").UseMutationResult<{
+        change_request: ChangeRequest;
+        delivering: boolean;
+    }, Error, {
+        crId: string;
+        feedback: string;
+    }, unknown>;
+    data: {
+        change_requests: ChangeRequest[];
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        change_requests: ChangeRequest[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    open: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, {
+        title: string;
+        description?: string;
+        head_ref: string;
+        base_ref?: string;
+        session_id?: string;
+    }, unknown>;
+    merge: import("@tanstack/react-query").UseMutationResult<import("../index.js").ChangeRequestMergeResponse, Error, {
+        crId: string;
+        input?: Parameters<typeof mergeChangeRequest>[2];
+    }, unknown>;
+    close: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, string, unknown>;
+    requestChanges: import("@tanstack/react-query").UseMutationResult<{
+        change_request: ChangeRequest;
+        delivering: boolean;
+    }, Error, {
+        crId: string;
+        feedback: string;
+    }, unknown>;
+    data: {
+        change_requests: ChangeRequest[];
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        change_requests: ChangeRequest[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    open: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, {
+        title: string;
+        description?: string;
+        head_ref: string;
+        base_ref?: string;
+        session_id?: string;
+    }, unknown>;
+    merge: import("@tanstack/react-query").UseMutationResult<import("../index.js").ChangeRequestMergeResponse, Error, {
+        crId: string;
+        input?: Parameters<typeof mergeChangeRequest>[2];
+    }, unknown>;
+    close: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, string, unknown>;
+    requestChanges: import("@tanstack/react-query").UseMutationResult<{
+        change_request: ChangeRequest;
+        delivering: boolean;
+    }, Error, {
+        crId: string;
+        feedback: string;
+    }, unknown>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        change_requests: ChangeRequest[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    open: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, {
+        title: string;
+        description?: string;
+        head_ref: string;
+        base_ref?: string;
+        session_id?: string;
+    }, unknown>;
+    merge: import("@tanstack/react-query").UseMutationResult<import("../index.js").ChangeRequestMergeResponse, Error, {
+        crId: string;
+        input?: Parameters<typeof mergeChangeRequest>[2];
+    }, unknown>;
+    close: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, string, unknown>;
+    requestChanges: import("@tanstack/react-query").UseMutationResult<{
+        change_request: ChangeRequest;
+        delivering: boolean;
+    }, Error, {
+        crId: string;
+        feedback: string;
+    }, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        change_requests: ChangeRequest[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    open: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, {
+        title: string;
+        description?: string;
+        head_ref: string;
+        base_ref?: string;
+        session_id?: string;
+    }, unknown>;
+    merge: import("@tanstack/react-query").UseMutationResult<import("../index.js").ChangeRequestMergeResponse, Error, {
+        crId: string;
+        input?: Parameters<typeof mergeChangeRequest>[2];
+    }, unknown>;
+    close: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, string, unknown>;
+    requestChanges: import("@tanstack/react-query").UseMutationResult<{
+        change_request: ChangeRequest;
+        delivering: boolean;
+    }, Error, {
+        crId: string;
+        feedback: string;
+    }, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        change_requests: ChangeRequest[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    open: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, {
+        title: string;
+        description?: string;
+        head_ref: string;
+        base_ref?: string;
+        session_id?: string;
+    }, unknown>;
+    merge: import("@tanstack/react-query").UseMutationResult<import("../index.js").ChangeRequestMergeResponse, Error, {
+        crId: string;
+        input?: Parameters<typeof mergeChangeRequest>[2];
+    }, unknown>;
+    close: import("@tanstack/react-query").UseMutationResult<ChangeRequest, Error, string, unknown>;
+    requestChanges: import("@tanstack/react-query").UseMutationResult<{
+        change_request: ChangeRequest;
+        delivering: boolean;
+    }, Error, {
+        crId: string;
+        feedback: string;
+    }, unknown>;
+    data: {
+        change_requests: ChangeRequest[];
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        change_requests: ChangeRequest[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/react/use-change-requests.js

@@ -0,0 +1,31 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { closeChangeRequest, listChangeRequests, mergeChangeRequest, openChangeRequest, requestChangesOnChangeRequest, } from '../core/rest/projects-client/index.js';
+export const changeRequestsKey = (projectId) => ['project-change-requests', projectId];
+export function useChangeRequests(projectId, status) {
+    const queryClient = useQueryClient();
+    const queryKey = [...changeRequestsKey(projectId), status ?? 'open'];
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listChangeRequests(projectId, status),
+        enabled: !!projectId,
+    });
+    const invalidate = () => queryClient.invalidateQueries({ queryKey: changeRequestsKey(projectId) });
+    const open = useMutation({
+        mutationFn: (input) => openChangeRequest(projectId, input),
+        onSuccess: invalidate,
+    });
+    const merge = useMutation({
+        mutationFn: (args) => mergeChangeRequest(projectId, args.crId, args.input),
+        onSuccess: invalidate,
+    });
+    const close = useMutation({
+        mutationFn: (crId) => closeChangeRequest(projectId, crId),
+        onSuccess: invalidate,
+    });
+    const requestChanges = useMutation({
+        mutationFn: (args) => requestChangesOnChangeRequest(projectId, args.crId, args.feedback),
+        onSuccess: invalidate,
+    });
+    return { ...query, open, merge, close, requestChanges };
+}

package/dist/react/use-connector-query.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectorArgs, ConnectorResult } from '../core/rest/projects-client/connectors.js';
+export interface ConnectorQueryOptions {
+    account?: string | null;
+    enabled?: boolean;
+    staleTime?: number;
+}
+export declare function useConnectorQuery<S extends string, A extends string>(projectId: string | null | undefined, slug: S, action: A, args: ConnectorArgs<S, A>, options?: ConnectorQueryOptions): import("@tanstack/react-query").UseQueryResult<ConnectorResult<S, A>, Error>;

package/dist/react/use-connector-query.js

@@ -0,0 +1,23 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { ConnectorCallError, runConnector, } from '../core/rest/projects-client/connector-run.js';
+import { qk } from './query-keys.js';
+const MAX_RETRY_DELAY_MS = 30_000;
+export function useConnectorQuery(projectId, slug, action, args, options = {}) {
+    return useQuery({
+        queryKey: qk.project.connectorCall(projectId ?? '', slug, action, args, options.account),
+        queryFn: ({ signal }) => runConnector(projectId, slug, action, args, {
+            account: options.account,
+            signal,
+        }),
+        enabled: Boolean(projectId) && options.enabled !== false,
+        staleTime: options.staleTime ?? 30_000,
+        refetchOnWindowFocus: false,
+        retry: (failureCount, error) => failureCount < 2 &&
+            error instanceof ConnectorCallError &&
+            (error.status === 429 || error.status === 503),
+        retryDelay: (attempt, error) => Math.min((error instanceof ConnectorCallError && error.retryAfterSeconds !== null
+            ? error.retryAfterSeconds * 1000
+            : 1000 * 2 ** attempt), MAX_RETRY_DELAY_MS),
+    });
+}

package/dist/react/use-current-runtime.d.ts

@@ -0,0 +1,2 @@
+import { type CurrentRuntimeState } from '../core/session/current-runtime.js';
+export declare function useCurrentRuntime<T>(selector: (state: CurrentRuntimeState) => T): T;

package/dist/react/use-current-runtime.js

@@ -0,0 +1,6 @@
+'use client';
+import { useSyncExternalStore } from 'react';
+import { currentRuntimeStore } from '../core/session/current-runtime.js';
+export function useCurrentRuntime(selector) {
+    return useSyncExternalStore(currentRuntimeStore.subscribe, () => selector(currentRuntimeStore.getState()), () => selector(currentRuntimeStore.getState()));
+}

package/dist/react/use-feature-flag.d.ts

@@ -0,0 +1,6 @@
+import type { FeatureFlagKey } from '../core/rest/projects-client/index.js';
+export interface FeatureFlagState {
+    enabled: boolean;
+    isLoading: boolean;
+}
+export declare function useFeatureFlag(projectId: string | null | undefined, key: FeatureFlagKey): FeatureFlagState;

package/dist/react/use-feature-flag.js

@@ -0,0 +1,25 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getProjectDetail } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+const GRADUATED_FEATURE_FLAG_KEYS = new Set([
+    'review_center',
+    'agent_tunnel',
+    'session_transcript_history',
+    'teams',
+    'config_releases',
+]);
+export function useFeatureFlag(projectId, key) {
+    const query = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        enabled: !!projectId,
+        ...contract('config'),
+        refetchOnWindowFocus: false,
+    });
+    return {
+        enabled: GRADUATED_FEATURE_FLAG_KEYS.has(key) || query.data?.project?.experimental?.[key] === true,
+        isLoading: query.isLoading,
+    };
+}

package/dist/react/use-gateway-catalog-sync.d.ts

@@ -0,0 +1 @@
+export declare function useGatewayCatalogSync(projectId: string | null | undefined): void;

package/dist/react/use-gateway-catalog-sync.js

@@ -0,0 +1,40 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { listProjectSecrets } from '../core/rest/projects-client/index.js';
+import { refreshProjectProviderState } from './provider-refresh.js';
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+const REFETCH_DELAYS_MS = [0, 1200, 3000, 6000];
+export function useGatewayCatalogSync(projectId) {
+    const queryClient = useQueryClient();
+    const runtimeReady = useSandboxConnectionStore((s) => s.status === 'connected' && s.healthy === true);
+    const secretsQuery = useQuery({
+        queryKey: qk.project.secrets(projectId ?? ''),
+        queryFn: () => listProjectSecrets(projectId),
+        enabled: !!projectId && runtimeReady,
+        ...contract('config'),
+    });
+    const signature = (() => {
+        const data = secretsQuery.data;
+        const items = Array.isArray(data) ? data : (data?.items ?? []);
+        return items.map((item) => item.name).sort().join(',');
+    })();
+    const previous = useRef(null);
+    useEffect(() => {
+        if (!projectId || secretsQuery.data === undefined)
+            return;
+        if (previous.current === null) {
+            previous.current = signature;
+            return;
+        }
+        if (previous.current === signature)
+            return;
+        previous.current = signature;
+        const timers = REFETCH_DELAYS_MS.map((delay) => setTimeout(() => {
+            refreshProjectProviderState(queryClient, projectId);
+        }, delay));
+        return () => timers.forEach(clearTimeout);
+    }, [projectId, signature, secretsQuery.data, queryClient]);
+}