@beeuni/sdk 0.1.0 → 0.3.0

package/dist/core/rest/platform-client/capture.d.ts

@@ -0,0 +1,363 @@
+import type { CaptureExclusionGroup, CaptureLayer, CaptureMaxHeight } from '../../capture/rules.js';
+export * from '../../capture/rules.js';
+export type CaptureLiveState = 'recording' | 'paused' | 'permission_missing' | 'not_recording' | 'offline' | 'unknown' | (string & {});
+export interface CapturePolicy {
+    layers: {
+        screen: boolean;
+        actions: boolean;
+        audio: boolean;
+    };
+    privacy: {
+        redact_pii: boolean;
+        excluded_bundle_ids: string[];
+        excluded_domains: string[];
+        exclusion_groups: CaptureExclusionGroup[];
+        exclude_private_browsing: boolean;
+    };
+    retention: {
+        local_hours: number;
+        remote_days: number;
+    };
+    recording: {
+        paused: boolean;
+        paused_until_ms: number | null;
+        interval_ms?: number | null;
+        max_height?: CaptureMaxHeight | null;
+    };
+    notice: string;
+    experimental?: {
+        privacy_controls: boolean;
+    };
+}
+export interface CapturePolicyRecord {
+    policy: CapturePolicy;
+    updated_at: string | null;
+    updated_by: string | null;
+}
+export interface CaptureDisplay {
+    id: number;
+    name: string | null;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    scale: number | null;
+    main: boolean;
+}
+export interface CaptureFocusSpan {
+    device_id: string;
+    display_id: number;
+    start_at: string;
+    end_at: string;
+}
+export type CaptureHealthReason = 'offline' | 'stalled' | 'error' | 'never_reported' | 'unseen' | 'permission_missing' | 'paused' | 'sync_error' | 'backlog' | 'behind_version';
+export interface CaptureDeviceHealth {
+    state: 'healthy' | 'attention' | 'not_recording';
+    idle: boolean;
+    reasons: CaptureHealthReason[];
+    since: string | null;
+    latest_version: string | null;
+}
+export interface CaptureHealthSummary {
+    recording: number;
+    idle: number;
+    attention: number;
+    not_recording: number;
+    latest_version: string | null;
+}
+export type CaptureHealthBucket = 'recording' | 'idle' | 'attention' | 'not_recording';
+export declare function captureHealthBucket(device: Pick<CaptureDevice, 'health'>): CaptureHealthBucket;
+export interface CaptureDevice {
+    device_id: string;
+    user_id: string | null;
+    name: string | null;
+    os: string | null;
+    os_version: string | null;
+    arch: string | null;
+    app_version: string | null;
+    displays: CaptureDisplay[];
+    live: {
+        state: CaptureLiveState;
+        status: Record<string, unknown> | null;
+        reported_at: string | null;
+    };
+    last_credentials_at: string | null;
+    revoked_at: string | null;
+    health: CaptureDeviceHealth;
+    enrollment_token_id?: string | null;
+    created_at: string;
+}
+export interface CaptureEnrollmentToken {
+    token_id: string;
+    name: string;
+    token_prefix: string;
+    state: 'active' | 'revoked' | 'expired';
+    email_domains: string[];
+    max_devices: number | null;
+    device_count: number;
+    require_approval: boolean;
+    user_id: string | null;
+    expires_at: string | null;
+    revoked_at: string | null;
+    last_used_at: string | null;
+    created_by: string;
+    created_at: string;
+}
+export interface CaptureEnrollmentTokenSecret extends CaptureEnrollmentToken {
+    token: string;
+}
+export interface CaptureEnrollmentTokenInput {
+    name: string;
+    email_domains?: string[];
+    max_devices?: number | null;
+    require_approval?: boolean;
+    expires_in_days?: number | null;
+    user_id?: string | null;
+}
+export type CaptureEnrollmentStatus = 'pending' | 'approved' | 'denied' | 'enrolled';
+export interface CaptureEnrollment {
+    enrollment_id: string;
+    token_id: string;
+    token_name: string | null;
+    status: CaptureEnrollmentStatus;
+    reason: 'approval_required' | null;
+    principal_name: string | null;
+    account_name: string | null;
+    device: {
+        name: string | null;
+        os: string | null;
+        os_version: string | null;
+        arch: string | null;
+        app_version: string | null;
+    };
+    user_id: string | null;
+    device_id: string | null;
+    decided_by: string | null;
+    decided_at: string | null;
+    created_at: string;
+    last_seen_at: string;
+}
+export interface CaptureWindowQuery {
+    day?: string;
+    from?: string;
+    to?: string;
+    userId?: string;
+    deviceId?: string;
+    displayId?: number | 'all';
+}
+export interface CaptureActivityRun {
+    device_id: string;
+    app: string | null;
+    title: string | null;
+    url: string | null;
+    start_at: string;
+    end_at: string;
+    frames: number;
+}
+export interface CaptureChunk {
+    chunk_id: string;
+    device_id: string;
+    kind: 'chunk' | 'audio' | 'actions';
+    start_at: string;
+    end_at: string;
+    item_count: number;
+    encrypted: boolean;
+    display_id: number | null;
+    display: CaptureDisplay | null;
+}
+export interface CaptureTimeline {
+    user_id: string;
+    from: string;
+    to: string;
+    displays: CaptureDisplay[];
+    focus: CaptureFocusSpan[];
+    runs: CaptureActivityRun[];
+    chunks: CaptureChunk[];
+}
+export interface CaptureFrame {
+    frame_id: string;
+    ts: string;
+    device_id: string;
+    chunk_id: string;
+    frame_index: number | null;
+    app: string | null;
+    bundle_id: string | null;
+    title: string | null;
+    url: string | null;
+    domain: string | null;
+    ocr_text: string | null;
+    inactive: boolean;
+    display_id: number | null;
+    focused: boolean;
+    ocr_boxes?: Array<{
+        text: string;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }> | null;
+}
+export interface CaptureAction {
+    action_id: string;
+    ts: string;
+    device_id: string;
+    chunk_id: string;
+    kind: string;
+    app: string | null;
+    window_title: string | null;
+    description: string | null;
+    target: Record<string, unknown> | null;
+    screenshot: string | null;
+}
+export interface CaptureAudioLine {
+    line_id: string;
+    ts: string;
+    end_at: string;
+    device_id: string;
+    chunk_id: string;
+    text: string;
+}
+export interface CaptureTimelineItems {
+    user_id: string;
+    from: string;
+    to: string;
+    frames: CaptureFrame[];
+    actions: CaptureAction[];
+    audio: CaptureAudioLine[];
+}
+export interface CaptureDaysQuery {
+    tz?: string;
+    userId?: string;
+    deviceId?: string;
+}
+export interface CaptureDay {
+    day: string;
+    start_at: string;
+    end_at: string;
+    screen_seconds: number;
+}
+export interface CaptureDays {
+    user_id: string;
+    tz: string;
+    days: CaptureDay[];
+}
+export type CaptureSearchKind = CaptureLayer;
+export interface CaptureSearchQuery extends Omit<CaptureWindowQuery, 'day' | 'displayId'> {
+    q: string;
+    kinds?: CaptureSearchKind[];
+    app?: string;
+    limit?: number;
+    scope?: 'mine' | 'account';
+}
+export interface CaptureSearchHit {
+    kind: CaptureSearchKind;
+    id: string;
+    ts: string;
+    user_id: string;
+    device_id: string;
+    chunk_id: string;
+    app: string | null;
+    title: string | null;
+    url: string | null;
+    display_id: number | null;
+    display_name: string | null;
+    snippet: string;
+}
+export interface CaptureSearchResult {
+    user_id: string | null;
+    q: string;
+    hits: CaptureSearchHit[];
+}
+export interface CaptureSignedUrl {
+    url: string;
+    expires_at: string;
+}
+export interface CaptureMediaUrl extends CaptureSignedUrl {
+    encrypted: boolean;
+}
+export interface CaptureFrameDetail {
+    frame: CaptureFrame;
+    display?: CaptureDisplay | null;
+    video: (CaptureMediaUrl & {
+        offset_ms: number;
+    }) | null;
+    screenshot?: (CaptureMediaUrl & {
+        name: string;
+        ts: string;
+    }) | null;
+}
+export interface CaptureChunkMedia {
+    chunk_id: string;
+    kind: CaptureChunk['kind'];
+    video: CaptureMediaUrl | null;
+    audio: CaptureMediaUrl | null;
+}
+export interface CaptureDeviceGrant {
+    user_code: string;
+    status: 'pending' | 'approved' | 'denied' | 'consumed' | 'expired';
+    expires_at: string;
+    device: {
+        name: string | null;
+        os: string | null;
+        os_version: string | null;
+        arch: string | null;
+        app_version: string | null;
+    };
+    account_id: string | null;
+    device_id: string | null;
+}
+export interface CaptureDeviceGrantDetail extends CaptureDeviceGrant {
+    accounts: {
+        account_id: string;
+        name: string;
+    }[];
+}
+export interface CaptureWorkspace {
+    account_id: string;
+    enabled: boolean;
+    can_read_all: boolean;
+    can_manage: boolean;
+    updated_at: string | null;
+}
+export declare function listCaptureDevices(accountId: string, opts?: {
+    userId?: string;
+    scope?: 'mine' | 'account';
+}): Promise<{
+    devices: CaptureDevice[];
+    health: CaptureHealthSummary;
+}>;
+export declare function revokeCaptureDevice(accountId: string, deviceId: string): Promise<CaptureDevice>;
+export declare function linkCaptureDevice(accountId: string, deviceId: string, userId: string | null): Promise<CaptureDevice>;
+export declare function listCaptureEnrollmentTokens(accountId: string): Promise<{
+    tokens: CaptureEnrollmentToken[];
+}>;
+export declare function createCaptureEnrollmentToken(accountId: string, input: CaptureEnrollmentTokenInput): Promise<CaptureEnrollmentTokenSecret>;
+export declare function revokeCaptureEnrollmentToken(accountId: string, tokenId: string): Promise<CaptureEnrollmentToken>;
+export declare function listCaptureEnrollments(accountId: string, opts?: {
+    status?: CaptureEnrollmentStatus;
+}): Promise<{
+    enrollments: CaptureEnrollment[];
+}>;
+export declare function approveCaptureEnrollment(accountId: string, enrollmentId: string, userId?: string | null): Promise<CaptureEnrollment>;
+export declare function denyCaptureEnrollment(accountId: string, enrollmentId: string): Promise<CaptureEnrollment>;
+export declare function getCapturePolicy(accountId: string): Promise<CapturePolicyRecord>;
+export declare function setCapturePolicy(accountId: string, policy: CapturePolicy): Promise<CapturePolicyRecord>;
+export declare function getCaptureTimeline(accountId: string, query?: CaptureWindowQuery): Promise<CaptureTimeline>;
+export declare function getCaptureTimelineItems(accountId: string, query?: CaptureWindowQuery): Promise<CaptureTimelineItems>;
+export declare function getCaptureDays(accountId: string, query?: CaptureDaysQuery): Promise<CaptureDays>;
+export declare function searchCapture(accountId: string, query: CaptureSearchQuery): Promise<CaptureSearchResult>;
+export declare function getCaptureFrame(accountId: string, frameId: string, opts?: {
+    userId?: string;
+}): Promise<CaptureFrameDetail>;
+export declare function getCaptureChunkMedia(accountId: string, chunkId: string, opts?: {
+    userId?: string;
+}): Promise<CaptureChunkMedia>;
+export declare function getCaptureAssetUrl(accountId: string, deviceId: string, name: string): Promise<CaptureSignedUrl>;
+export declare function getCaptureDeviceGrant(userCode: string): Promise<CaptureDeviceGrantDetail>;
+export declare function approveCaptureDeviceGrant(userCode: string, accountId?: string): Promise<CaptureDeviceGrant>;
+export declare function denyCaptureDeviceGrant(userCode: string): Promise<CaptureDeviceGrant>;
+export declare function getCaptureWorkspace(accountId: string): Promise<CaptureWorkspace>;
+export declare function setCaptureEnabled(accountId: string, enabled: boolean): Promise<CaptureWorkspace>;
+export declare function searchMyCapture(query: CaptureSearchQuery): Promise<CaptureSearchResult>;
+export declare function getMyCaptureTimeline(query?: Omit<CaptureWindowQuery, 'userId'>): Promise<CaptureTimeline>;
+export declare function getMyCaptureFrame(frameId: string): Promise<CaptureFrameDetail>;

package/dist/core/rest/platform-client/capture.js

@@ -0,0 +1,116 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from '../projects-client/shared.js';
+export * from '../../capture/rules.js';
+export function captureHealthBucket(device) {
+    const { state, idle } = device.health;
+    if (state === 'healthy')
+        return idle ? 'idle' : 'recording';
+    return state;
+}
+const base = (accountId) => `/accounts/${accountId}/capture`;
+function captureQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== '')
+            search.set(key, String(value));
+    }
+    const query = search.toString();
+    return query ? `?${query}` : '';
+}
+const searchParams = (query) => captureQuery({
+    q: query.q,
+    kinds: query.kinds?.join(','),
+    app: query.app,
+    limit: query.limit,
+    from: query.from,
+    to: query.to,
+    user_id: query.userId,
+    device_id: query.deviceId,
+    scope: query.scope,
+});
+const windowParams = (query = {}) => ({
+    day: query.day,
+    from: query.from,
+    to: query.to,
+    user_id: query.userId,
+    device_id: query.deviceId,
+    display_id: query.displayId,
+});
+export async function listCaptureDevices(accountId, opts = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/devices${captureQuery({ user_id: opts.userId, scope: opts.scope })}`));
+}
+export async function revokeCaptureDevice(accountId, deviceId) {
+    return unwrap(await backendApi.delete(`${base(accountId)}/devices/${deviceId}`));
+}
+export async function linkCaptureDevice(accountId, deviceId, userId) {
+    return unwrap(await backendApi.put(`${base(accountId)}/devices/${deviceId}/link`, { user_id: userId }));
+}
+export async function listCaptureEnrollmentTokens(accountId) {
+    return unwrap(await backendApi.get(`${base(accountId)}/enrollment-tokens`));
+}
+export async function createCaptureEnrollmentToken(accountId, input) {
+    return unwrap(await backendApi.post(`${base(accountId)}/enrollment-tokens`, input));
+}
+export async function revokeCaptureEnrollmentToken(accountId, tokenId) {
+    return unwrap(await backendApi.delete(`${base(accountId)}/enrollment-tokens/${tokenId}`));
+}
+export async function listCaptureEnrollments(accountId, opts = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/enrollments${captureQuery({ status: opts.status })}`));
+}
+export async function approveCaptureEnrollment(accountId, enrollmentId, userId) {
+    return unwrap(await backendApi.post(`${base(accountId)}/enrollments/${enrollmentId}/approve`, userId ? { user_id: userId } : {}));
+}
+export async function denyCaptureEnrollment(accountId, enrollmentId) {
+    return unwrap(await backendApi.post(`${base(accountId)}/enrollments/${enrollmentId}/deny`, {}));
+}
+export async function getCapturePolicy(accountId) {
+    return unwrap(await backendApi.get(`${base(accountId)}/policy`));
+}
+export async function setCapturePolicy(accountId, policy) {
+    return unwrap(await backendApi.put(`${base(accountId)}/policy`, { policy }));
+}
+export async function getCaptureTimeline(accountId, query = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/timeline${captureQuery(windowParams(query))}`));
+}
+export async function getCaptureTimelineItems(accountId, query = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/timeline/items${captureQuery(windowParams(query))}`));
+}
+export async function getCaptureDays(accountId, query = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/days${captureQuery({ tz: query.tz, user_id: query.userId, device_id: query.deviceId })}`));
+}
+export async function searchCapture(accountId, query) {
+    return unwrap(await backendApi.get(`${base(accountId)}/search${searchParams(query)}`));
+}
+export async function getCaptureFrame(accountId, frameId, opts = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/frames/${frameId}${captureQuery({ user_id: opts.userId })}`));
+}
+export async function getCaptureChunkMedia(accountId, chunkId, opts = {}) {
+    return unwrap(await backendApi.get(`${base(accountId)}/chunks/${chunkId}/media${captureQuery({ user_id: opts.userId })}`));
+}
+export async function getCaptureAssetUrl(accountId, deviceId, name) {
+    return unwrap(await backendApi.get(`${base(accountId)}/devices/${deviceId}/assets/${encodeURIComponent(name)}`));
+}
+export async function getCaptureDeviceGrant(userCode) {
+    return unwrap(await backendApi.get(`/capture/device/grants/${encodeURIComponent(userCode)}`));
+}
+export async function approveCaptureDeviceGrant(userCode, accountId) {
+    return unwrap(await backendApi.post(`/capture/device/grants/${encodeURIComponent(userCode)}/approve`, accountId ? { account_id: accountId } : {}));
+}
+export async function denyCaptureDeviceGrant(userCode) {
+    return unwrap(await backendApi.post(`/capture/device/grants/${encodeURIComponent(userCode)}/deny`, {}));
+}
+export async function getCaptureWorkspace(accountId) {
+    return unwrap(await backendApi.get(base(accountId)));
+}
+export async function setCaptureEnabled(accountId, enabled) {
+    return unwrap(await backendApi.patch(base(accountId), { enabled }));
+}
+export async function searchMyCapture(query) {
+    return unwrap(await backendApi.get(`/capture/me/search${searchParams(query)}`));
+}
+export async function getMyCaptureTimeline(query = {}) {
+    return unwrap(await backendApi.get(`/capture/me/timeline${captureQuery(windowParams(query))}`));
+}
+export async function getMyCaptureFrame(frameId) {
+    return unwrap(await backendApi.get(`/capture/me/frames/${frameId}`));
+}

package/dist/core/rest/platform-client/client-policy.d.ts

@@ -0,0 +1,8 @@
+import type { AuthRequestOptions } from './auth.js';
+export interface MobileClientPolicy {
+    minimum_version: string | null;
+    store_url_ios: string | null;
+    store_url_android: string | null;
+}
+export declare function getMobileClientPolicy(opts?: AuthRequestOptions): Promise<MobileClientPolicy>;
+export declare function compareSemver(a: string, b: string): -1 | 0 | 1 | null;

package/dist/core/rest/platform-client/client-policy.js

@@ -0,0 +1,30 @@
+import { ApiError } from '../../http/api/errors.js';
+import { platformConfig } from '../../http/config.js';
+import { platformApiBase } from './shared.js';
+export async function getMobileClientPolicy(opts) {
+    const fetchImpl = opts?.fetch ?? platformConfig().fetch ?? ((input, init) => fetch(input, init));
+    const backendUrl = opts?.backendUrl ?? platformConfig().backendUrl;
+    const res = await fetchImpl(`${platformApiBase(backendUrl)}/clients/mobile`, {
+        headers: { accept: 'application/json' },
+        ...(opts?.signal ? { signal: opts.signal } : {}),
+    });
+    if (!res.ok) {
+        throw new ApiError(`Mobile client policy request failed (HTTP ${res.status})`, { status: res.status, response: res });
+    }
+    return (await res.json());
+}
+const SEMVER = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:[-+].*)?$/i;
+export function compareSemver(a, b) {
+    const parts = (v) => {
+        const m = SEMVER.exec(v.trim());
+        return m ? [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)] : null;
+    };
+    const pa = parts(a);
+    const pb = parts(b);
+    if (!pa || !pb)
+        return null;
+    for (let i = 0; i < 3; i++)
+        if (pa[i] !== pb[i])
+            return pa[i] < pb[i] ? -1 : 1;
+    return 0;
+}

package/dist/core/rest/platform-client/index.d.ts

@@ -5,8 +5,8 @@ export * from './members.js';
 export * from './invites.js';
 export * from './backups.js';
 export * from './ssh.js';
-export * from './updates.js';
-export * from './instance-admin.js';
-export * from './host-boundary.js';
+export { getLatestSandboxVersion, getFullChangelog, getAllVersions, type ChangelogChange, type ChangelogArtifact, type ChangelogEntry, type VersionChannel, type VersionEntry, type AllVersionsResponse, type SandboxVersionInfo, } from './updates.js';
+export { HostBoundaryError, listPublicMarketplaceItems, listPublicMarketplaces, getPublicMarketplaceItem, getPublicMarketplaceItemFile, checkAccessEmail, submitAccessRequest, recordPlatformLogout, getOAuthConsentRequest, submitOAuthConsent, getConnectorSetupLink, startConnectorSetupLink, finalizeConnectorSetupLink, getSecretSetupLink, submitSecretSetupLink, getPublicShareByToken, startSessionWithToken, submitDemoRequest, downloadAccountAudit, buildPublicTemplateUrl, getPublicTemplate, type HostRequestOptions, type PublicMarketplaceQuery, type OAuthConsentRequest, type ConnectorSetupLinkInfo, type ConnectorSetupLinkStart, type ConnectorSetupLinkFinalize, type FinalizeConnectorSetupLinkInput, type SecretSetupLinkInfo, type SecretWithheldReason, type SecretSetupLinkWithheld, type SecretSetupLinkSubmitResult, type AccountAuditExport, } from './host-boundary.js';
 export * from './connector-setup.js';
-export * from './github-app.js';
+export * from './client-policy.js';
+export * from './capture.js';

package/dist/core/rest/platform-client/index.js

@@ -5,8 +5,8 @@ export * from './members.js';
 export * from './invites.js';
 export * from './backups.js';
 export * from './ssh.js';
-export * from './updates.js';
-export * from './instance-admin.js';
-export * from './host-boundary.js';
+export { getLatestSandboxVersion, getFullChangelog, getAllVersions, } from './updates.js';
+export { HostBoundaryError, listPublicMarketplaceItems, listPublicMarketplaces, getPublicMarketplaceItem, getPublicMarketplaceItemFile, checkAccessEmail, submitAccessRequest, recordPlatformLogout, getOAuthConsentRequest, submitOAuthConsent, getConnectorSetupLink, startConnectorSetupLink, finalizeConnectorSetupLink, getSecretSetupLink, submitSecretSetupLink, getPublicShareByToken, startSessionWithToken, submitDemoRequest, downloadAccountAudit, buildPublicTemplateUrl, getPublicTemplate, } from './host-boundary.js';
 export * from './connector-setup.js';
-export * from './github-app.js';
+export * from './client-policy.js';
+export * from './capture.js';

package/dist/core/rest/platform-client/lifecycle.js

@@ -1,6 +1,6 @@
-import { createProjectSession, startProjectSession, listProjects, restartProjectSession, stopProjectSession, } from '../projects-client/index.js';
+import { createProjectSession, getProject, startProjectSession, listProjects, restartProjectSession, stopProjectSession, } from '../projects-client/index.js';
 import { backendApi } from '../../http/api-client.js';
-import { findProjectSessionSandbox, listProjectSessionSandboxes, projectSessionToSandboxInfo, normalizeSandboxId, } from './shared.js';
+import { findProjectSessionSandbox, getSessionById, listProjectSessionSandboxes, projectSessionToSandboxInfo, normalizeSandboxId, resolveProjectSessionId, } from './shared.js';
 export async function getProviders() {
     const response = await backendApi.get('/setup/sandbox-providers');
     if (response.error)
@@ -34,12 +34,18 @@ export async function getSandboxById(sandboxId) {
     const normalizedSandboxId = normalizeSandboxId(sandboxId);
     if (!normalizedSandboxId)
         return null;
-    const row = await findProjectSessionSandbox(normalizedSandboxId).catch(() => null);
-    return row?.sandbox ?? null;
+    try {
+        const session = await getSessionById(normalizedSandboxId);
+        if (!session)
+            return (await findProjectSessionSandbox(normalizedSandboxId))?.sandbox ?? null;
+        return projectSessionToSandboxInfo(await getProject(session.project_id), session, null);
+    }
+    catch {
+        return null;
+    }
 }
 export async function renameSandbox(sandboxId, _name) {
-    const row = await findProjectSessionSandbox(sandboxId);
-    if (!row)
+    if (!(await resolveProjectSessionId(sandboxId)))
         throw new Error('Project session sandbox not found');
     throw new Error('Renaming project-session sandboxes is not exposed by the current API');
 }
@@ -59,18 +65,18 @@ export async function restartSandbox(sandboxId) {
     if (!sandboxId) {
         throw new Error('No sandbox selected for workload restart');
     }
-    const row = await findProjectSessionSandbox(sandboxId);
-    if (!row)
+    const target = await resolveProjectSessionId(sandboxId);
+    if (!target)
         throw new Error('Project session sandbox not found');
-    await restartProjectSession(row.project.project_id, row.session.session_id);
+    await restartProjectSession(target.projectId, target.sessionId);
 }
 export async function stopSandbox(sandboxId) {
     if (!sandboxId)
         throw new Error('No sandbox selected to stop');
-    const row = await findProjectSessionSandbox(sandboxId);
-    if (!row)
+    const target = await resolveProjectSessionId(sandboxId);
+    if (!target)
         throw new Error('Project session sandbox not found');
-    await stopProjectSession(row.project.project_id, row.session.session_id);
+    await stopProjectSession(target.projectId, target.sessionId);
 }
 export async function cancelSandbox(sandboxId) {
     throw new Error('Cancellation is not exposed for project-session sandboxes');

package/dist/core/rest/platform-client/shared.d.ts

@@ -10,6 +10,11 @@ export declare function listProjectSessionSandboxes(): Promise<Array<{
     runtime: ProjectSessionSandbox | null;
     sandbox: SandboxInfo;
 }>>;
+export declare function getSessionById(sessionId: string): Promise<ProjectSession | null>;
+export declare function resolveProjectSessionId(id: string): Promise<{
+    projectId: string;
+    sessionId: string;
+} | null>;
 export declare function findProjectSessionSandbox(sandboxId?: string): Promise<{
     project: BeeuniProject;
     session: ProjectSession;

package/dist/core/rest/platform-client/shared.js

@@ -1,3 +1,4 @@
+import { backendApi } from '../../http/api-client.js';
 import { platformConfig } from '../../http/config.js';
 import { safeEnv } from '../../http/env.js';
 import { stripTrailingSlashes } from '../../../platform/strings.js';
@@ -88,6 +89,23 @@ export async function listProjectSessionSandboxes() {
         return Date.parse(b.sandbox.updated_at) - Date.parse(a.sandbox.updated_at);
     });
 }
+export async function getSessionById(sessionId) {
+    const response = await backendApi.get(`/sessions/${encodeURIComponent(sessionId)}`, {
+        showErrors: false,
+    });
+    if (response.success && response.data)
+        return response.data;
+    if (response.error?.status === 400 || response.error?.status === 404)
+        return null;
+    throw response.error ?? new Error('Session request failed');
+}
+export async function resolveProjectSessionId(id) {
+    const session = await getSessionById(id);
+    if (session)
+        return { projectId: session.project_id, sessionId: session.session_id };
+    const row = await findProjectSessionSandbox(id);
+    return row ? { projectId: row.project.project_id, sessionId: row.session.session_id } : null;
+}
 export async function findProjectSessionSandbox(sandboxId) {
     const rows = await listProjectSessionSandboxes();
     if (!sandboxId)

package/dist/core/rest/platform-client/types.d.ts

@@ -8,7 +8,7 @@ export declare const SANDBOX_PORTS: {
     readonly BROWSER_VIEWER: "9224";
     readonly SSH: "22";
 };
-export type SandboxProviderName = 'daytona' | 'platinum' | 'e2b';
+export type SandboxProviderName = string;
 export type ServerTypeOption = string;
 export interface SandboxCreateProgress {
     status: 'pulling';

package/dist/core/rest/projects-client/account-secret-resources.d.ts

@@ -1,4 +1,4 @@
-import type { SecretConsumer, SecretDeliveryStrategy } from './secrets.js';
+import type { SecretConsumer, SecretDeliveryStrategy, SecretValueStatus } from './secrets.js';
 export interface AccountSecretResource {
     secret_id: string;
     account_id: string;
@@ -17,6 +17,7 @@ export interface AccountSecretResource {
     updated_at: string;
     granted_user_ids: string[];
     can_use: boolean;
+    status?: SecretValueStatus;
 }
 export interface CreateAccountSecretResourceInput {
     project_id?: string;