@beeuni/sdk 0.1.0

package/dist/react/query-keys.d.ts

@@ -0,0 +1,105 @@
+import type { ListProjectSessionsOptions } from '../core/rest/projects-client/sessions.js';
+type SessionListFilters = Pick<ListProjectSessionsOptions, 'parent' | 'startedBy' | 'q' | 'labels'>;
+export declare const qk: {
+    readonly accounts: {
+        readonly scope: () => readonly ["kx", "accounts"];
+        readonly list: (userId: string | null | undefined) => readonly ["kx", "accounts", string];
+        readonly myInvites: (userId: string | null | undefined) => readonly ["kx", "accounts", "my-invites", string];
+    };
+    readonly notifications: {
+        readonly scope: () => readonly ["kx", "notifications"];
+        readonly inbox: (userId: string | null | undefined, limit: number) => readonly ["kx", "notifications", string, "inbox", number];
+        readonly preferences: (userId: string | null | undefined) => readonly ["kx", "notifications", string, "preferences"];
+        readonly sessionWatch: (userId: string | null | undefined, projectId: string, sessionId: string) => readonly ["kx", "notifications", string, "session-watch", string, string];
+    };
+    readonly projects: {
+        readonly scope: () => readonly ["kx", "projects"];
+        readonly list: (accountId?: string) => readonly ["kx", "projects", string];
+    };
+    readonly drives: {
+        readonly scope: () => readonly ["kx", "drives"];
+        readonly list: (userId: string | null | undefined, scope?: {
+            projectId?: string;
+            accountId?: string;
+        }) => readonly ["kx", "drives", "list", string, string];
+        readonly drive: (driveId: string) => readonly ["kx", "drives", "drive", string];
+        readonly files: (driveId: string, path: string) => readonly ["kx", "drives", "drive", string, "files", string];
+        readonly versions: (driveId: string) => readonly ["kx", "drives", "drive", string, "versions"];
+        readonly grants: (driveId: string) => readonly ["kx", "drives", "drive", string, "grants"];
+        readonly conflicts: (driveId: string) => readonly ["kx", "drives", "drive", string, "conflicts"];
+        readonly session: (projectId: string, sessionId: string) => readonly ["kx", "drives", "session", string, string];
+    };
+    readonly project: {
+        readonly starterSuggestions: (id: string) => readonly ["kx", "project", string, "starter-suggestions"];
+        readonly scope: (id: string) => readonly ["kx", "project", string];
+        readonly needsInput: (id: string) => readonly ["kx", "project", string, "needs-input"];
+        readonly summary: (id: string) => readonly ["kx", "project", string, "summary"];
+        readonly detail: (id: string) => readonly ["kx", "project", string, "detail"];
+        readonly config: (id: string) => readonly ["kx", "project", string, "config"];
+        readonly modelPicker: (id: string) => readonly ["kx", "project", string, "config", "models"];
+        readonly modelAccess: (projectId: string) => readonly ["kx", "project", string, "model-access"];
+        readonly sessionsScope: (id: string) => readonly ["kx", "project", string, "sessions"];
+        readonly sessions: (id: string, scope?: "visible" | "project") => readonly ["kx", "project", string, "sessions", "list", "project" | "visible"];
+        readonly sessionsPaged: (id: string, scope?: "visible" | "project", filters?: SessionListFilters) => readonly ["kx", "project", string, "sessions", "list-paged", "project" | "visible"] | readonly ["kx", "project", string, "sessions", "list-paged", "project" | "visible", {
+            labels?: string[] | undefined;
+            parent: string | null;
+            startedBy: "me" | "others" | "automated" | null;
+            q: string | null;
+        }];
+        readonly sessionChildren: (id: string, parentSessionId: string, q?: string) => readonly ["kx", "project", string, "sessions", "list-children", string, string];
+        readonly session: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string];
+        readonly messages: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "messages"];
+        readonly sessionSandbox: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "sandbox"];
+        readonly sessionParticipants: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "participants"];
+        readonly sessionPrompts: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "prompts"];
+        readonly sessionTurn: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "turn"];
+        readonly sessionRuntimeControl: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "runtime-control"];
+        readonly sessionAuditWatermark: (id: string, sessionId: string) => readonly ["kx", "project", string, "sessions", string, "audit-watermark"];
+        readonly connectors: (id: string) => readonly ["kx", "project", string, "connectors"];
+        readonly connectorConfig: (id: string, slug: string) => readonly ["kx", "project", string, "connectors", string];
+        readonly connectorCall: (id: string, slug: string, action: string, args: unknown, account?: string | null) => readonly ["kx", "project", string, "connectors", string, "call", string, string | null, unknown];
+        readonly connectorOAuth2Discovery: (id: string, slug: string, connection?: string) => readonly ["kx", "project", string, "connectors", string, "oauth2-discovery"] | readonly ["kx", "project", string, "connectors", string, "oauth2-discovery", string];
+        readonly access: (id: string) => readonly ["kx", "project", string, "access"];
+        readonly accessRequests: (id: string) => readonly ["kx", "project", string, "access", "requests"];
+        readonly pendingInvites: (id: string) => readonly ["kx", "project", string, "access", "invites"];
+        readonly groupGrants: (id: string) => readonly ["kx", "project", string, "access", "group-grants"];
+        readonly resourceGrants: (id: string) => readonly ["kx", "project", string, "access", "grants"];
+        readonly secrets: (id: string) => readonly ["kx", "project", string, "secrets"];
+        readonly apps: (id: string) => readonly ["kx", "project", string, "apps"];
+        readonly appAccess: (id: string, appId: string) => readonly ["kx", "project", string, "apps", string, "access"];
+        readonly appAccessSession: (id: string, appId: string) => readonly ["kx", "project", string, "apps", string, "access", "session"];
+        readonly appDeployments: (id: string, appId: string) => readonly ["kx", "project", string, "apps", string, "deployments"];
+        readonly appMachines: (id: string, appId: string) => readonly ["kx", "project", string, "apps", string, "machines"];
+        readonly appVolumes: (id: string, appId: string) => readonly ["kx", "project", string, "apps", string, "volumes"];
+        readonly appVolumeSnapshots: (id: string, appId: string, volumeId: string) => readonly ["kx", "project", string, "apps", string, "volumes", string, "snapshots"];
+        readonly appDeployment: (id: string, appId: string, deploymentId: string) => readonly ["kx", "project", string, "apps", string, "deployments", string];
+        readonly triggers: (id: string) => readonly ["kx", "project", string, "triggers"];
+        readonly triggerEventTypes: (id: string, connector: string) => readonly ["kx", "project", string, "triggers", "event-types", string];
+        readonly triggerEventApps: (id: string) => readonly ["kx", "project", string, "triggers", "event-apps"];
+        readonly reminders: (id: string) => readonly ["kx", "project", string, "reminders"];
+        readonly sessionReminders: (id: string, sessionId: string) => readonly ["kx", "project", string, "reminders", "session", string];
+        readonly sessionMessageAuthors: (id: string, sessionId: string) => readonly ["kx", "project", string, "session-message-authors", string];
+        readonly sessionModelUsage: (id: string, sessionId: string) => readonly ["kx", "project", string, "session-model-usage", string];
+        readonly files: (id: string) => readonly ["kx", "project", string, "files"];
+        readonly fileSource: (id: string, path: string) => readonly ["kx", "project", string, "files", string];
+        readonly branches: (id: string) => readonly ["kx", "project", string, "branches"];
+        readonly policies: (id: string) => readonly ["kx", "project", string, "policies"];
+        readonly executorPolicies: (id: string) => readonly ["kx", "project", string, "executor-policies"];
+        readonly sandboxes: (id: string) => readonly ["kx", "project", string, "sandboxes"];
+        readonly sandboxTemplates: (id: string) => readonly ["kx", "project", string, "sandboxes", "templates"];
+        readonly snapshots: (id: string) => readonly ["kx", "project", string, "snapshots"];
+        readonly gateway: (id: string) => readonly ["kx", "project", string, "gateway"];
+        readonly gatewayOverview: (id: string, days: number) => readonly ["kx", "project", string, "gateway", "overview", number];
+        readonly gatewaySeries: (id: string, days: number) => readonly ["kx", "project", string, "gateway", "series", number];
+        readonly gatewayBreakdown: (id: string, days: number) => readonly ["kx", "project", string, "gateway", "breakdown", number];
+        readonly gatewaySessions: (id: string, days: number) => readonly ["kx", "project", string, "gateway", "sessions", number];
+        readonly gatewayErrors: (id: string, days: number) => readonly ["kx", "project", string, "gateway", "errors", number];
+        readonly gatewayLogs: (id: string, ok: boolean | null) => readonly ["kx", "project", string, "gateway", "logs", boolean | null];
+        readonly gatewayLog: (id: string, logId: string | null) => readonly ["kx", "project", string, "gateway", "log", string | null];
+        readonly gatewayBudgets: (id: string) => readonly ["kx", "project", string, "gateway", "budgets"];
+        readonly gatewayKeys: (id: string) => readonly ["kx", "project", string, "gateway", "keys"];
+    };
+};
+export type ProjectScopeKey = ReturnType<typeof qk.project.scope>;
+export type ProjectsListKey = ReturnType<typeof qk.projects.list>;
+export {};

package/dist/react/query-keys.js

@@ -0,0 +1,115 @@
+function normalizeSessionListFilters(filters) {
+    const q = filters?.q?.trim();
+    const labels = filters?.labels?.length ? [...filters.labels].sort() : null;
+    if (!filters?.parent && !filters?.startedBy && !q && !labels)
+        return undefined;
+    return {
+        parent: filters?.parent ?? null,
+        startedBy: filters?.startedBy ?? null,
+        q: q ?? null,
+        ...(labels ? { labels } : {}),
+    };
+}
+export const qk = {
+    accounts: {
+        scope: () => ['kx', 'accounts'],
+        list: (userId) => [...qk.accounts.scope(), userId ?? 'anonymous'],
+        myInvites: (userId) => [...qk.accounts.scope(), 'my-invites', userId ?? 'anonymous'],
+    },
+    notifications: {
+        scope: () => ['kx', 'notifications'],
+        inbox: (userId, limit) => [...qk.notifications.scope(), userId ?? 'anonymous', 'inbox', limit],
+        preferences: (userId) => [...qk.notifications.scope(), userId ?? 'anonymous', 'preferences'],
+        sessionWatch: (userId, projectId, sessionId) => [...qk.notifications.scope(), userId ?? 'anonymous', 'session-watch', projectId, sessionId],
+    },
+    projects: {
+        scope: () => ['kx', 'projects'],
+        list: (accountId) => [...qk.projects.scope(), accountId ?? 'all'],
+    },
+    drives: {
+        scope: () => ['kx', 'drives'],
+        list: (userId, scope) => [
+            ...qk.drives.scope(),
+            'list',
+            userId ?? 'anonymous',
+            scope?.projectId ? `project:${scope.projectId}` : scope?.accountId ? `account:${scope.accountId}` : 'primary',
+        ],
+        drive: (driveId) => [...qk.drives.scope(), 'drive', driveId],
+        files: (driveId, path) => [...qk.drives.drive(driveId), 'files', path],
+        versions: (driveId) => [...qk.drives.drive(driveId), 'versions'],
+        grants: (driveId) => [...qk.drives.drive(driveId), 'grants'],
+        conflicts: (driveId) => [...qk.drives.drive(driveId), 'conflicts'],
+        session: (projectId, sessionId) => [...qk.drives.scope(), 'session', projectId, sessionId],
+    },
+    project: {
+        starterSuggestions: (id) => [...qk.project.scope(id), 'starter-suggestions'],
+        scope: (id) => ['kx', 'project', id],
+        needsInput: (id) => [...qk.project.scope(id), 'needs-input'],
+        summary: (id) => [...qk.project.scope(id), 'summary'],
+        detail: (id) => [...qk.project.scope(id), 'detail'],
+        config: (id) => [...qk.project.scope(id), 'config'],
+        modelPicker: (id) => [...qk.project.config(id), 'models'],
+        modelAccess: (projectId) => [...qk.project.scope(projectId), 'model-access'],
+        sessionsScope: (id) => [...qk.project.scope(id), 'sessions'],
+        sessions: (id, scope = 'visible') => [...qk.project.sessionsScope(id), 'list', scope],
+        sessionsPaged: (id, scope = 'visible', filters) => {
+            const key = [...qk.project.sessionsScope(id), 'list-paged', scope];
+            const normalized = normalizeSessionListFilters(filters);
+            return normalized ? [...key, normalized] : key;
+        },
+        sessionChildren: (id, parentSessionId, q) => [...qk.project.sessionsScope(id), 'list-children', parentSessionId, q?.trim() ?? ''],
+        session: (id, sessionId) => [...qk.project.sessionsScope(id), sessionId],
+        messages: (id, sessionId) => [...qk.project.session(id, sessionId), 'messages'],
+        sessionSandbox: (id, sessionId) => [...qk.project.session(id, sessionId), 'sandbox'],
+        sessionParticipants: (id, sessionId) => [...qk.project.session(id, sessionId), 'participants'],
+        sessionPrompts: (id, sessionId) => [...qk.project.session(id, sessionId), 'prompts'],
+        sessionTurn: (id, sessionId) => [...qk.project.session(id, sessionId), 'turn'],
+        sessionRuntimeControl: (id, sessionId) => [...qk.project.session(id, sessionId), 'runtime-control'],
+        sessionAuditWatermark: (id, sessionId) => [...qk.project.session(id, sessionId), 'audit-watermark'],
+        connectors: (id) => [...qk.project.scope(id), 'connectors'],
+        connectorConfig: (id, slug) => [...qk.project.connectors(id), slug],
+        connectorCall: (id, slug, action, args, account) => [...qk.project.connectorConfig(id, slug), 'call', action, account ?? null, args],
+        connectorOAuth2Discovery: (id, slug, connection) => connection === undefined
+            ? [...qk.project.connectorConfig(id, slug), 'oauth2-discovery']
+            : [...qk.project.connectorConfig(id, slug), 'oauth2-discovery', connection],
+        access: (id) => [...qk.project.scope(id), 'access'],
+        accessRequests: (id) => [...qk.project.access(id), 'requests'],
+        pendingInvites: (id) => [...qk.project.access(id), 'invites'],
+        groupGrants: (id) => [...qk.project.access(id), 'group-grants'],
+        resourceGrants: (id) => [...qk.project.access(id), 'grants'],
+        secrets: (id) => [...qk.project.scope(id), 'secrets'],
+        apps: (id) => [...qk.project.scope(id), 'apps'],
+        appAccess: (id, appId) => [...qk.project.apps(id), appId, 'access'],
+        appAccessSession: (id, appId) => [...qk.project.appAccess(id, appId), 'session'],
+        appDeployments: (id, appId) => [...qk.project.apps(id), appId, 'deployments'],
+        appMachines: (id, appId) => [...qk.project.apps(id), appId, 'machines'],
+        appVolumes: (id, appId) => [...qk.project.apps(id), appId, 'volumes'],
+        appVolumeSnapshots: (id, appId, volumeId) => [...qk.project.appVolumes(id, appId), volumeId, 'snapshots'],
+        appDeployment: (id, appId, deploymentId) => [...qk.project.appDeployments(id, appId), deploymentId],
+        triggers: (id) => [...qk.project.scope(id), 'triggers'],
+        triggerEventTypes: (id, connector) => [...qk.project.triggers(id), 'event-types', connector],
+        triggerEventApps: (id) => [...qk.project.triggers(id), 'event-apps'],
+        reminders: (id) => [...qk.project.scope(id), 'reminders'],
+        sessionReminders: (id, sessionId) => [...qk.project.reminders(id), 'session', sessionId],
+        sessionMessageAuthors: (id, sessionId) => [...qk.project.scope(id), 'session-message-authors', sessionId],
+        sessionModelUsage: (id, sessionId) => [...qk.project.scope(id), 'session-model-usage', sessionId],
+        files: (id) => [...qk.project.scope(id), 'files'],
+        fileSource: (id, path) => [...qk.project.files(id), path],
+        branches: (id) => [...qk.project.scope(id), 'branches'],
+        policies: (id) => [...qk.project.scope(id), 'policies'],
+        executorPolicies: (id) => [...qk.project.scope(id), 'executor-policies'],
+        sandboxes: (id) => [...qk.project.scope(id), 'sandboxes'],
+        sandboxTemplates: (id) => [...qk.project.sandboxes(id), 'templates'],
+        snapshots: (id) => [...qk.project.scope(id), 'snapshots'],
+        gateway: (id) => [...qk.project.scope(id), 'gateway'],
+        gatewayOverview: (id, days) => [...qk.project.gateway(id), 'overview', days],
+        gatewaySeries: (id, days) => [...qk.project.gateway(id), 'series', days],
+        gatewayBreakdown: (id, days) => [...qk.project.gateway(id), 'breakdown', days],
+        gatewaySessions: (id, days) => [...qk.project.gateway(id), 'sessions', days],
+        gatewayErrors: (id, days) => [...qk.project.gateway(id), 'errors', days],
+        gatewayLogs: (id, ok) => [...qk.project.gateway(id), 'logs', ok],
+        gatewayLog: (id, logId) => [...qk.project.gateway(id), 'log', logId],
+        gatewayBudgets: (id) => [...qk.project.gateway(id), 'budgets'],
+        gatewayKeys: (id) => [...qk.project.gateway(id), 'keys'],
+    },
+};

package/dist/react/reset-identity-state.d.ts

@@ -0,0 +1,2 @@
+import './use-model-store.js';
+export declare function resetIdentityState(): void;

package/dist/react/reset-identity-state.js

@@ -0,0 +1,19 @@
+import { useDiagnosticsStore } from '../browser/stores/diagnostics-store.js';
+import { useRuntimePendingStore } from '../browser/stores/opencode-pending-store.js';
+import { useSessionWorkingStore } from '../browser/stores/session-working-store.js';
+import { useSyncStore } from '../browser/stores/sync-store.js';
+import { resetSessionCacheOwnership } from '../browser/session-sync/session-cache-ownership.js';
+import { resetSessionSyncControllers } from '../browser/session-sync/session-sync-registry.js';
+import { registerIdentityReset, runIdentityResets } from './identity-reset-registry.js';
+import { resetSessionOpenPrefetches } from './prefetch-session-open.js';
+import './use-model-store.js';
+registerIdentityReset(() => useSyncStore.getState().reset());
+registerIdentityReset(() => useRuntimePendingStore.getState().clear());
+registerIdentityReset(() => useSessionWorkingStore.getState().reset());
+registerIdentityReset(() => useDiagnosticsStore.getState().clearAll());
+registerIdentityReset(resetSessionSyncControllers);
+registerIdentityReset(resetSessionCacheOwnership);
+registerIdentityReset(resetSessionOpenPrefetches);
+export function resetIdentityState() {
+    runIdentityResets();
+}

package/dist/react/retired-endpoint.d.ts

@@ -0,0 +1,3 @@
+import { type UseMutationResult, type UseQueryResult } from '@tanstack/react-query';
+export declare function useRetiredQuery<T>(name: string, queryKey: readonly unknown[], enabled?: boolean): UseQueryResult<T, Error>;
+export declare function useRetiredMutation<TData = unknown, TVariables = void>(name: string): UseMutationResult<TData, Error, TVariables>;

package/dist/react/retired-endpoint.js

@@ -0,0 +1,15 @@
+import { useMutation, useQuery, } from '@tanstack/react-query';
+import { retiredEndpointError } from '../core/http/api/errors.js';
+export function useRetiredQuery(name, queryKey, enabled = true) {
+    return useQuery({
+        queryKey,
+        queryFn: () => Promise.reject(retiredEndpointError(name)),
+        enabled,
+        retry: false,
+    });
+}
+export function useRetiredMutation(name) {
+    return useMutation({
+        mutationFn: () => Promise.reject(retiredEndpointError(name)),
+    });
+}

package/dist/react/route-project.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from 'react';
+export declare function BeeuniProjectProvider(props: {
+    projectId: string | null;
+    children?: ReactNode;
+}): ReactNode;
+export declare function useBeeuniRouteProjectId(): string | null;

package/dist/react/route-project.js

@@ -0,0 +1,9 @@
+'use client';
+import { createContext, createElement, useContext } from 'react';
+const BeeuniProjectContext = createContext(null);
+export function BeeuniProjectProvider(props) {
+    return createElement(BeeuniProjectContext.Provider, { value: props.projectId }, props.children);
+}
+export function useBeeuniRouteProjectId() {
+    return useContext(BeeuniProjectContext);
+}

package/dist/react/run-pty-command.d.ts

@@ -0,0 +1,4 @@
+export declare function runPtyCommand(command: string, options?: {
+    timeoutMs?: number;
+    title?: string;
+}): Promise<string>;

package/dist/react/run-pty-command.js

@@ -0,0 +1,41 @@
+import { createBeeuniPty, getBeeuniPtyWebSocketUrl, removeBeeuniPty, } from '../core/runtime/pty.js';
+import { getActiveRuntimeUrl } from '../browser/stores/server-store.js';
+export async function runPtyCommand(command, options) {
+    const baseUrl = getActiveRuntimeUrl();
+    const pty = await createBeeuniPty(baseUrl, {
+        command: '/bin/sh',
+        args: ['-c', command],
+        title: options?.title ?? '__sdk-command__',
+    });
+    const connectUrl = await getBeeuniPtyWebSocketUrl(pty.id, baseUrl);
+    const timeoutMs = options?.timeoutMs ?? 15_000;
+    try {
+        return await new Promise((resolve) => {
+            const chunks = [];
+            let settled = false;
+            const socket = new WebSocket(connectUrl);
+            socket.binaryType = 'arraybuffer';
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(chunks.join(''));
+            };
+            const timer = setTimeout(() => {
+                socket.close();
+                finish();
+            }, timeoutMs);
+            socket.onmessage = (event) => {
+                chunks.push(event.data instanceof ArrayBuffer
+                    ? new TextDecoder().decode(event.data)
+                    : String(event.data));
+            };
+            socket.onclose = finish;
+            socket.onerror = finish;
+        });
+    }
+    finally {
+        void removeBeeuniPty(baseUrl, pty.id).catch(() => { });
+    }
+}

package/dist/react/runtime-actions.d.ts

@@ -0,0 +1,31 @@
+import type { Config, FileContent, Path as RuntimePathInfo, Project as RuntimeProjectInfo, ProviderAuthAuthorization, ProviderAuthMethod } from '../core/runtime/client.js';
+import type { SubdomainUrlOptions } from '../core/session/url.js';
+export declare function getRuntimeProjectInfo(): Promise<RuntimeProjectInfo>;
+export declare function getRuntimePathInfo(): Promise<RuntimePathInfo>;
+export declare function readRuntimeTextFile(path: string): Promise<string | FileContent>;
+export declare function getRuntimeProviderAuthMethods(): Promise<Record<string, ProviderAuthMethod[]>>;
+export declare function authorizeRuntimeProvider(providerID: string, method: number): Promise<ProviderAuthAuthorization>;
+export declare function completeRuntimeProviderOAuth(providerID: string, method?: number, code?: string): Promise<boolean>;
+export declare function setRuntimeProviderApiKey(providerID: string, key: string): Promise<boolean>;
+export declare function getRuntimeConfig(): Promise<Config>;
+export declare function updateRuntimeConfig(config: Config): Promise<Config>;
+export declare function refreshRuntimeConfiguration(): Promise<void>;
+export declare function logRuntimeEvent(input: {
+    service: string;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    extra?: Record<string, unknown>;
+}): void;
+export declare function getRuntimeCacheKey(): string;
+export interface ActiveSandboxProxyContext {
+    serverUrl: string;
+    subdomainOpts: SubdomainUrlOptions;
+    isReady: boolean;
+}
+export declare function createActiveSandboxProxyContext(): ActiveSandboxProxyContext;
+export declare function useActiveSandboxProxyContext(): ActiveSandboxProxyContext;
+export declare function getActiveStaticFilePreviewUrl(path: string): string;
+export declare function getActiveStaticFileHealthUrl(): string;
+export declare function useRuntimeProjectInfo(options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<RuntimeProjectInfo, Error>;

package/dist/react/runtime-actions.js

@@ -0,0 +1,87 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { getClient } from '../core/runtime/client.js';
+import { deriveSubdomainOpts, getActiveRuntimeUrl, } from '../browser/stores/server-store.js';
+import { buildStaticFileHealthPreviewUrl, buildStaticFilePreviewUrl, hasPreviewTarget, } from '../core/session/url.js';
+import { useCurrentRuntime } from './use-current-runtime.js';
+import { runtimeKeys, useRuntimeReady } from './use-opencode-sessions/keys.js';
+function unwrapRuntimeResult(result) {
+    if (result.error) {
+        const error = result.error;
+        throw new Error(error.data?.message || error.message || 'Runtime request failed');
+    }
+    return result.data;
+}
+export function getRuntimeProjectInfo() {
+    return getClient().project.current().then(unwrapRuntimeResult);
+}
+export function getRuntimePathInfo() {
+    return getClient().path.get().then(unwrapRuntimeResult);
+}
+export function readRuntimeTextFile(path) {
+    return getClient().file.read({ path }).then(unwrapRuntimeResult);
+}
+export function getRuntimeProviderAuthMethods() {
+    return getClient().provider.auth().then(unwrapRuntimeResult);
+}
+export function authorizeRuntimeProvider(providerID, method) {
+    return getClient().provider.oauth.authorize({ providerID, method }).then(unwrapRuntimeResult);
+}
+export function completeRuntimeProviderOAuth(providerID, method, code) {
+    return getClient().provider.oauth.callback({
+        providerID,
+        method,
+        ...(code ? { code } : {}),
+    }).then(unwrapRuntimeResult);
+}
+export function setRuntimeProviderApiKey(providerID, key) {
+    return getClient().auth.set({
+        providerID,
+        auth: { type: 'api', key },
+    }).then(unwrapRuntimeResult);
+}
+export function getRuntimeConfig() {
+    return getClient().global.config.get().then(unwrapRuntimeResult);
+}
+export function updateRuntimeConfig(config) {
+    return getClient().global.config.update({ config }).then(unwrapRuntimeResult);
+}
+export async function refreshRuntimeConfiguration() {
+    unwrapRuntimeResult(await getClient().global.dispose());
+}
+export function logRuntimeEvent(input) {
+    void getClient().app.log(input);
+}
+export function getRuntimeCacheKey() {
+    return getActiveRuntimeUrl();
+}
+export function createActiveSandboxProxyContext() {
+    const subdomainOpts = deriveSubdomainOpts();
+    return {
+        serverUrl: getActiveRuntimeUrl(),
+        subdomainOpts,
+        isReady: hasPreviewTarget(subdomainOpts),
+    };
+}
+export function useActiveSandboxProxyContext() {
+    const version = useCurrentRuntime((state) => state.version);
+    return useMemo(() => createActiveSandboxProxyContext(), [version]);
+}
+export function getActiveStaticFilePreviewUrl(path) {
+    return buildStaticFilePreviewUrl(path, deriveSubdomainOpts()) ?? '';
+}
+export function getActiveStaticFileHealthUrl() {
+    return buildStaticFileHealthPreviewUrl(deriveSubdomainOpts());
+}
+export function useRuntimeProjectInfo(options) {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.currentProject(),
+        queryFn: getRuntimeProjectInfo,
+        enabled: runtimeReady && options?.enabled !== false,
+        staleTime: Infinity,
+        gcTime: 5 * 60_000,
+        refetchOnWindowFocus: false,
+    });
+}

package/dist/react/self-heal-poll-gate.d.ts

@@ -0,0 +1,8 @@
+import type { SandboxConnectionStatus } from '../browser/stores/sandbox-connection-store.js';
+export declare function shouldRunSelfHealPoll(input: {
+    enabled: boolean;
+    hasCandidate: boolean;
+    pendingCount: number;
+    sandboxStatus: SandboxConnectionStatus;
+    parked: boolean;
+}): boolean;

package/dist/react/self-heal-poll-gate.js

@@ -0,0 +1,5 @@
+export function shouldRunSelfHealPoll(input) {
+    if (!input.enabled || !input.hasCandidate || input.pendingCount > 0)
+        return false;
+    return input.sandboxStatus === 'connected' && !input.parked;
+}

package/dist/react/session-agent-name-guard.d.ts

@@ -0,0 +1 @@
+export declare function shouldSetSessionAgentName(current: string | undefined, next: string | undefined): boolean;

package/dist/react/session-agent-name-guard.js

@@ -0,0 +1,5 @@
+export function shouldSetSessionAgentName(current, next) {
+    const normalizedNext = next ? next : undefined;
+    const normalizedCurrent = current ? current : undefined;
+    return normalizedNext !== normalizedCurrent;
+}

package/dist/react/session-cache-write.d.ts

@@ -0,0 +1,8 @@
+import type { QueryClient } from '@tanstack/react-query';
+import { type ProjectSession } from '../core/rest/projects-client/sessions.js';
+export type ProjectSessionsUpdater = (sessions: ProjectSession[]) => ProjectSession[];
+export declare function applyToCachedSessionShape(cached: unknown, update: ProjectSessionsUpdater): unknown;
+export declare function updateCachedProjectSessions(queryClient: QueryClient, projectId: string, update: ProjectSessionsUpdater): void;
+export declare function upsertIntoCachedSessionShape(cached: unknown, session: ProjectSession): unknown;
+export declare function removeCachedProjectSession(queryClient: QueryClient, projectId: string, sessionId: string): () => void;
+export declare function upsertCachedProjectSession(queryClient: QueryClient, projectId: string, session: ProjectSession): void;

package/dist/react/session-cache-write.js

@@ -0,0 +1,116 @@
+import { sessionParentId } from '../core/rest/projects-client/sessions.js';
+import { qk } from './query-keys.js';
+function isSessionCacheKey(projectId, query) {
+    const prefix = qk.project.sessionsScope(projectId);
+    const rest = query.queryKey.slice(prefix.length);
+    if (rest[0] === 'list')
+        return rest.length === 2;
+    if (rest[0] === 'list-paged')
+        return rest.length === 2 || rest.length === 3;
+    if (rest[0] === 'list-children')
+        return rest.length === 3;
+    return rest.length === 1 && typeof rest[0] === 'string';
+}
+function sessionBelongsInList(projectId, query, session) {
+    const rest = query.queryKey.slice(qk.project.sessionsScope(projectId).length);
+    const parentId = sessionParentId(session);
+    if (rest[0] === 'list-children')
+        return !rest[2] && parentId === rest[1];
+    const filters = rest[0] === 'list-paged' ? rest[2] : undefined;
+    if (!filters)
+        return true;
+    if (filters.q)
+        return false;
+    if (filters.parent === 'root' && parentId !== null)
+        return false;
+    if (filters.parent && filters.parent !== 'root')
+        return parentId === filters.parent;
+    if (!filters.startedBy)
+        return true;
+    const isMember = (session.initiator?.type ?? 'member') === 'member';
+    if (filters.startedBy === 'automated')
+        return !isMember;
+    return isMember && (filters.startedBy === 'me') === (session.is_owner !== false);
+}
+function isPagedSessionCache(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Array.isArray(value.pages));
+}
+function isSessionRow(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.session_id === 'string');
+}
+export function applyToCachedSessionShape(cached, update) {
+    if (Array.isArray(cached))
+        return update(cached);
+    if (isPagedSessionCache(cached)) {
+        let changed = false;
+        const pages = cached.pages.map((page) => {
+            const items = update(page.items);
+            if (items === page.items)
+                return page;
+            changed = true;
+            return { ...page, items };
+        });
+        return changed ? { ...cached, pages } : cached;
+    }
+    if (isSessionRow(cached)) {
+        const updated = update([cached]);
+        return updated.find((row) => row.session_id === cached.session_id) ?? cached;
+    }
+    return cached;
+}
+export function updateCachedProjectSessions(queryClient, projectId, update) {
+    queryClient.setQueriesData({
+        queryKey: qk.project.sessionsScope(projectId),
+        predicate: (query) => isSessionCacheKey(projectId, query),
+    }, (cached) => applyToCachedSessionShape(cached, update));
+}
+export function upsertIntoCachedSessionShape(cached, session) {
+    const upsert = (items) => {
+        const index = items.findIndex((row) => row.session_id === session.session_id);
+        if (index === -1)
+            return [session, ...items];
+        const next = items.slice();
+        next[index] = session;
+        return next;
+    };
+    if (Array.isArray(cached))
+        return upsert(cached);
+    if (isPagedSessionCache(cached)) {
+        const index = cached.pages.findIndex((page) => page.items.some((row) => row.session_id === session.session_id));
+        const target = index === -1 ? 0 : index;
+        return {
+            ...cached,
+            pages: cached.pages.map((page, i) => i === target ? { ...page, items: upsert(page.items) } : page),
+        };
+    }
+    if (isSessionRow(cached)) {
+        return cached.session_id === session.session_id ? session : cached;
+    }
+    return cached;
+}
+export function removeCachedProjectSession(queryClient, projectId, sessionId) {
+    const filter = {
+        queryKey: qk.project.sessionsScope(projectId),
+        predicate: (query) => isSessionCacheKey(projectId, query),
+    };
+    const previous = queryClient.getQueriesData(filter);
+    updateCachedProjectSessions(queryClient, projectId, (rows) => {
+        const kept = rows.filter((row) => row.session_id !== sessionId);
+        return kept.length === rows.length ? rows : kept;
+    });
+    queryClient.removeQueries({ queryKey: qk.project.session(projectId, sessionId), exact: true });
+    return () => {
+        for (const [queryKey, data] of previous)
+            queryClient.setQueryData(queryKey, data);
+    };
+}
+export function upsertCachedProjectSession(queryClient, projectId, session) {
+    queryClient.setQueriesData({
+        queryKey: qk.project.sessionsScope(projectId),
+        predicate: (query) => isSessionCacheKey(projectId, query) && sessionBelongsInList(projectId, query, session),
+    }, (cached) => upsertIntoCachedSessionShape(cached, session));
+}

package/dist/react/session-start-giveup.d.ts

@@ -0,0 +1,4 @@
+export declare function startGiveUpExpiryAtMs(input: {
+    inconclusiveSinceMs: number | null;
+    budgetMs: number;
+}): number | null;

package/dist/react/session-start-giveup.js

@@ -0,0 +1,5 @@
+export function startGiveUpExpiryAtMs(input) {
+    if (input.inconclusiveSinceMs === null)
+        return null;
+    return input.inconclusiveSinceMs + input.budgetMs;
+}