@beeuni/sdk 0.1.0

package/dist/core/rest/platform-client/host-boundary.js

@@ -0,0 +1,188 @@
+import { retiredEndpointError } from '../../http/api/errors.js';
+import { auditFilterQuery } from '../projects-client/audit-filter.js';
+import { platformApiBase } from './shared.js';
+export class HostBoundaryError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = 'HostBoundaryError';
+    }
+}
+function requestHeaders(options, json) {
+    const headers = new Headers(options.headers);
+    headers.set('Accept', 'application/json');
+    if (json)
+        headers.set('Content-Type', 'application/json');
+    if (options.accessToken) {
+        headers.set('Authorization', `Bearer ${options.accessToken}`);
+    }
+    return headers;
+}
+async function parseResponseBody(response) {
+    const text = await response.text().catch(() => '');
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function errorMessage(response, body) {
+    if (body && typeof body === 'object') {
+        const record = body;
+        for (const key of ['error_description', 'error', 'message']) {
+            if (typeof record[key] === 'string' && record[key])
+                return record[key];
+        }
+    }
+    if (typeof body === 'string' && body)
+        return body;
+    return response.statusText || `HTTP ${response.status}`;
+}
+async function requestJson(path, options, init) {
+    const json = init?.body !== undefined;
+    const response = await fetch(`${platformApiBase(options.backendUrl)}${path}`, {
+        method: init?.method ?? 'GET',
+        headers: requestHeaders(options, json),
+        ...(json ? { body: JSON.stringify(init.body) } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.cache ? { cache: options.cache } : {}),
+        ...(options.next ? { next: options.next } : {}),
+    });
+    const body = await parseResponseBody(response);
+    if (!response.ok) {
+        throw new HostBoundaryError(errorMessage(response, body), response.status, body);
+    }
+    return body;
+}
+function marketplaceQuery(input) {
+    const params = new URLSearchParams();
+    if (input?.query)
+        params.set('query', input.query);
+    if (input?.type)
+        params.set('type', input.type);
+    if (input?.source)
+        params.set('source', input.source);
+    if (input?.limit !== undefined)
+        params.set('limit', String(input.limit));
+    if (input?.offset !== undefined)
+        params.set('offset', String(input.offset));
+    const query = params.toString();
+    return query ? `?${query}` : '';
+}
+export function listPublicMarketplaceItems(options, query) {
+    return requestJson(`/marketplace/items${marketplaceQuery(query)}`, options);
+}
+export function listPublicMarketplaces(options) {
+    return requestJson('/marketplace/marketplaces', options);
+}
+export function getPublicMarketplaceItem(id, options) {
+    return requestJson(`/marketplace/items/${encodeURIComponent(id)}`, options);
+}
+export function getPublicMarketplaceItemFile(id, path, options) {
+    return requestJson(`/marketplace/items/${encodeURIComponent(id)}/file?path=${encodeURIComponent(path)}`, options);
+}
+export function checkAccessEmail(email, options) {
+    return requestJson('/access/check-email', options, {
+        method: 'POST',
+        body: { email },
+    });
+}
+export function submitAccessRequest(input, options) {
+    return requestJson('/access/request-access', options, {
+        method: 'POST',
+        body: input,
+    });
+}
+export function recordPlatformLogout(options) {
+    return requestJson('/auth/logout', options, { method: 'POST', body: {} });
+}
+export function getOAuthConsentRequest(requestId, options) {
+    return requestJson(`/oauth/authorize/consent/${encodeURIComponent(requestId)}`, options);
+}
+export function submitOAuthConsent(input, options) {
+    return requestJson('/oauth/authorize/consent', options, {
+        method: 'POST',
+        body: { request_id: input.requestId, approved: input.approved },
+    });
+}
+export function getConnectorSetupLink(token, options) {
+    return requestJson(`/setup-links/connectors/${encodeURIComponent(token)}`, options);
+}
+export function startConnectorSetupLink(token, options) {
+    return requestJson(`/setup-links/connectors/${encodeURIComponent(token)}/start`, options, {
+        method: 'POST',
+        body: {},
+    });
+}
+export function finalizeConnectorSetupLink(token, options, input = {}) {
+    return requestJson(`/setup-links/connectors/${encodeURIComponent(token)}/finalize`, options, {
+        method: 'POST',
+        body: input.connectionId ? { connection_id: input.connectionId } : {},
+    });
+}
+export function getSecretSetupLink(token, options) {
+    return requestJson(`/setup-links/secret/${encodeURIComponent(token)}`, options);
+}
+export function submitSecretSetupLink(token, values, options, audience) {
+    return requestJson(`/setup-links/secret/${encodeURIComponent(token)}`, options, {
+        method: 'POST',
+        body: { values, ...(audience?.only_requester ? { only_requester: true } : {}) },
+    });
+}
+export function getPublicShareByToken(token, options) {
+    return requestJson(`/p/public-share/${encodeURIComponent(token)}`, options);
+}
+export function startSessionWithToken(projectId, sessionId, options) {
+    return requestJson(`/projects/${encodeURIComponent(projectId)}/sessions/${encodeURIComponent(sessionId)}/start`, options, { method: 'POST', body: {} });
+}
+export function getMaintenanceConfig(options) {
+    return requestJson('/system/maintenance', options);
+}
+export function setMaintenanceConfig(config, options) {
+    return requestJson('/system/maintenance', options, {
+        method: 'PUT',
+        body: config,
+    });
+}
+export function getUserRolesWithToken(options) {
+    return requestJson('/user-roles', options);
+}
+export function submitDemoRequest(input, options) {
+    return requestJson('/system/demo-request', options, {
+        method: 'POST',
+        body: input,
+    });
+}
+export async function downloadAccountAudit(accountId, query, options) {
+    const response = await fetch(`${platformApiBase(options.backendUrl)}/accounts/${encodeURIComponent(accountId)}/audit/export?${auditFilterQuery(query)}`, {
+        headers: requestHeaders(options, false),
+        ...(options.signal ? { signal: options.signal } : {}),
+    });
+    if (!response.ok) {
+        const body = await parseResponseBody(response);
+        throw new HostBoundaryError(errorMessage(response, body), response.status, body);
+    }
+    return {
+        blob: await response.blob(),
+        filename: response.headers.get('content-disposition')?.match(/filename="([^"]+)"/)?.[1] ?? null,
+        capped: response.headers.get('x-audit-capped') === 'true',
+        rowCount: response.headers.get('x-audit-row-count'),
+        complete: response.headers.get('x-audit-complete') !== 'false',
+        nextCursor: response.headers.get('x-audit-next-cursor') || null,
+    };
+}
+export async function openStressTestStream(_input, _options) {
+    throw retiredEndpointError('openStressTestStream');
+}
+export function buildPublicTemplateUrl(_backendUrl, _shareId) {
+    throw retiredEndpointError('buildPublicTemplateUrl');
+}
+export async function getPublicTemplate(_backendUrl, _shareId, _signal) {
+    throw retiredEndpointError('getPublicTemplate');
+}

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

@@ -0,0 +1,12 @@
+export * from './types.js';
+export * from './urls.js';
+export * from './lifecycle.js';
+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 * from './connector-setup.js';
+export * from './github-app.js';

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

@@ -0,0 +1,12 @@
+export * from './types.js';
+export * from './urls.js';
+export * from './lifecycle.js';
+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 * from './connector-setup.js';
+export * from './github-app.js';

package/dist/core/rest/platform-client/instance-admin.d.ts

@@ -0,0 +1,53 @@
+export interface ServerType {
+    name: string;
+    description: string;
+    cores: number;
+    memory: number;
+    disk: number;
+    cpuType: 'shared' | 'dedicated';
+    architecture: 'x86' | 'arm';
+    priceMonthly: number;
+    priceMonthlyMarkup: number;
+    location: string;
+}
+export interface ServerTypesResponse {
+    serverTypes: ServerType[];
+    location: string;
+    defaultServerType?: string;
+    defaultLocation?: string;
+}
+export declare function getJustavpsServerTypes(location?: string): Promise<ServerTypesResponse>;
+export interface CreateInstanceRequest {
+    provider: 'justavps';
+    serverType?: string;
+    location?: string;
+    name?: string;
+    backgroundProvisioning?: boolean;
+}
+export declare function createInstance(_request: CreateInstanceRequest): Promise<never>;
+export declare function deleteInstance(_sandboxId: string): Promise<{
+    success: boolean;
+}>;
+export declare function markInstanceError(_sandboxId: string, _errorMessage: string): Promise<void>;
+export declare function claimComputer(): Promise<any>;
+export interface SandboxProvisionStageInfo {
+    id: string;
+    progress: number;
+    message: string;
+}
+export interface SandboxProvisionStatus {
+    status: 'provisioning' | 'active' | 'error' | 'stopped' | 'archived' | 'not_found';
+    stage: string | null;
+    stageProgress: number | null;
+    stageMessage: string | null;
+    machineInfo: {
+        ip: string;
+        serverType: string;
+        location: string;
+    } | null;
+    stages: SandboxProvisionStageInfo[] | null;
+    error?: string | null;
+    startedAt: string | null;
+}
+export declare function getSandboxProvisionStatus(_sandboxId: string): Promise<SandboxProvisionStatus | null>;
+export declare function getSandboxProvisionStreamUrl(_sandboxId: string, _token: string): string;

package/dist/core/rest/platform-client/instance-admin.js

@@ -0,0 +1,20 @@
+import { retiredEndpointError } from '../../http/api/errors.js';
+export async function getJustavpsServerTypes(location) {
+    return { serverTypes: [], location: location || 'hel1' };
+}
+export async function createInstance(_request) {
+    throw new Error('Retired instance provisioning is unavailable. Create a project session with daytona, platinum, or e2b.');
+}
+export async function deleteInstance(_sandboxId) {
+    throw retiredEndpointError('deleteInstance');
+}
+export async function markInstanceError(_sandboxId, _errorMessage) { }
+export async function claimComputer() {
+    throw retiredEndpointError('claimComputer');
+}
+export async function getSandboxProvisionStatus(_sandboxId) {
+    return null;
+}
+export function getSandboxProvisionStreamUrl(_sandboxId, _token) {
+    throw retiredEndpointError('getSandboxProvisionStreamUrl');
+}

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

@@ -0,0 +1,31 @@
+export interface InviteDetailsVisible {
+    invite_id: string;
+    sandbox_id: string;
+    sandbox_name: string | null;
+    email: string;
+    inviter_email: string | null;
+    created_at: string;
+    expires_at: string;
+    accepted_at: string | null;
+    email_matches_caller: true;
+    expired: boolean;
+}
+export interface InviteDetailsRedacted {
+    invite_id: string;
+    sandbox_id: null;
+    sandbox_name: null;
+    email: null;
+    inviter_email: null;
+    created_at: null;
+    expires_at: null;
+    accepted_at: string | null;
+    email_matches_caller: false;
+    expired: boolean;
+}
+export type InviteDetails = InviteDetailsVisible | InviteDetailsRedacted;
+export declare function getInvite(_inviteId: string): Promise<InviteDetails>;
+export declare function acceptInvite(_inviteId: string): Promise<{
+    status: string;
+    sandbox_id: string;
+}>;
+export declare function declineInvite(_inviteId: string): Promise<void>;

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

@@ -0,0 +1,11 @@
+import { retiredEndpointError } from '../../http/api/errors.js';
+const INSTEAD = 'Use the account invite functions (acceptAccountInvite, declineAccountInvite).';
+export async function getInvite(_inviteId) {
+    throw retiredEndpointError('getInvite', INSTEAD);
+}
+export async function acceptInvite(_inviteId) {
+    throw retiredEndpointError('acceptInvite', INSTEAD);
+}
+export async function declineInvite(_inviteId) {
+    throw retiredEndpointError('declineInvite', INSTEAD);
+}

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

@@ -0,0 +1,27 @@
+import type { SandboxInfo, SandboxProviderName, ServerTypeOption, ProvidersInfo } from './types.js';
+export declare function getProviders(): Promise<ProvidersInfo>;
+export declare function ensureSandbox(opts?: {
+    provider?: SandboxProviderName;
+    serverType?: ServerTypeOption;
+}): Promise<{
+    sandbox: SandboxInfo;
+    created: boolean;
+}>;
+export declare function getSandbox(): Promise<SandboxInfo | null>;
+export declare function createSandbox(opts?: {
+    provider?: SandboxProviderName;
+    serverType?: ServerTypeOption;
+    name?: string;
+}): Promise<{
+    sandbox: SandboxInfo;
+}>;
+export declare function getSandboxById(sandboxId: unknown): Promise<SandboxInfo | null>;
+export declare function renameSandbox(sandboxId: string, _name: string): Promise<SandboxInfo>;
+export declare function listSandboxes(sandboxId?: unknown): Promise<SandboxInfo[]>;
+export declare function discoverLocalSandbox(): Promise<SandboxInfo | null>;
+export declare function restartSandbox(sandboxId?: string): Promise<void>;
+export declare function stopSandbox(sandboxId?: string): Promise<void>;
+export declare function cancelSandbox(sandboxId?: string): Promise<{
+    cancel_at: string | null;
+}>;
+export declare function reactivateSandbox(sandboxId?: string): Promise<void>;

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

@@ -0,0 +1,80 @@
+import { createProjectSession, startProjectSession, listProjects, restartProjectSession, stopProjectSession, } from '../projects-client/index.js';
+import { backendApi } from '../../http/api-client.js';
+import { findProjectSessionSandbox, listProjectSessionSandboxes, projectSessionToSandboxInfo, normalizeSandboxId, } from './shared.js';
+export async function getProviders() {
+    const response = await backendApi.get('/setup/sandbox-providers');
+    if (response.error)
+        throw response.error;
+    return response.data;
+}
+export async function ensureSandbox(opts) {
+    const existing = await findProjectSessionSandbox();
+    if (existing)
+        return { sandbox: existing.sandbox, created: false };
+    const projects = await listProjects();
+    const project = projects[0];
+    if (!project) {
+        throw new Error('Create a project before starting a sandbox');
+    }
+    const session = await createProjectSession(project.project_id, {
+        ...(opts?.provider ? { provider: opts.provider } : {}),
+    });
+    const runtime = (await startProjectSession(project.project_id, session.session_id))?.sandbox ?? null;
+    return { sandbox: projectSessionToSandboxInfo(project, session, runtime), created: true };
+}
+export async function getSandbox() {
+    const row = await findProjectSessionSandbox().catch(() => null);
+    return row?.sandbox ?? null;
+}
+export async function createSandbox(opts) {
+    const result = await ensureSandbox(opts);
+    return { sandbox: result.sandbox };
+}
+export async function getSandboxById(sandboxId) {
+    const normalizedSandboxId = normalizeSandboxId(sandboxId);
+    if (!normalizedSandboxId)
+        return null;
+    const row = await findProjectSessionSandbox(normalizedSandboxId).catch(() => null);
+    return row?.sandbox ?? null;
+}
+export async function renameSandbox(sandboxId, _name) {
+    const row = await findProjectSessionSandbox(sandboxId);
+    if (!row)
+        throw new Error('Project session sandbox not found');
+    throw new Error('Renaming project-session sandboxes is not exposed by the current API');
+}
+export async function listSandboxes(sandboxId) {
+    const normalizedSandboxId = normalizeSandboxId(sandboxId);
+    const rows = await listProjectSessionSandboxes().catch(() => []);
+    return rows
+        .map((row) => row.sandbox)
+        .filter((sandbox) => !normalizedSandboxId ||
+        sandbox.sandbox_id === normalizedSandboxId ||
+        sandbox.external_id === normalizedSandboxId);
+}
+export async function discoverLocalSandbox() {
+    return null;
+}
+export async function restartSandbox(sandboxId) {
+    if (!sandboxId) {
+        throw new Error('No sandbox selected for workload restart');
+    }
+    const row = await findProjectSessionSandbox(sandboxId);
+    if (!row)
+        throw new Error('Project session sandbox not found');
+    await restartProjectSession(row.project.project_id, row.session.session_id);
+}
+export async function stopSandbox(sandboxId) {
+    if (!sandboxId)
+        throw new Error('No sandbox selected to stop');
+    const row = await findProjectSessionSandbox(sandboxId);
+    if (!row)
+        throw new Error('Project session sandbox not found');
+    await stopProjectSession(row.project.project_id, row.session.session_id);
+}
+export async function cancelSandbox(sandboxId) {
+    throw new Error('Cancellation is not exposed for project-session sandboxes');
+}
+export async function reactivateSandbox(sandboxId) {
+    throw new Error('Reactivation is not exposed for project-session sandboxes');
+}

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

@@ -0,0 +1,14 @@
+import type { SandboxInfo } from './types.js';
+export interface SandboxProjectMember {
+    user_id: string;
+    role: 'owner' | 'admin' | 'member';
+    added_by: string | null;
+    added_at: string;
+}
+export interface SandboxProjectMembersResponse {
+    project_id: string;
+    members: SandboxProjectMember[];
+}
+export declare function listSandboxProjectMembers(sandbox: SandboxInfo, projectId: string): Promise<SandboxProjectMembersResponse>;
+export declare function grantSandboxProjectAccess(sandbox: SandboxInfo, projectId: string, userId: string, role?: 'admin' | 'member'): Promise<void>;
+export declare function revokeSandboxProjectAccess(sandbox: SandboxInfo, projectId: string, userId: string): Promise<void>;

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

@@ -0,0 +1,28 @@
+import { authenticatedFetch } from '../../http/auth.js';
+import { stripTrailingSlashes } from '../../../platform/strings.js';
+import { getSandboxUrl } from './urls.js';
+async function fetchBeeuniMaster(sandbox, path, init) {
+    const base = getSandboxUrl(sandbox);
+    const res = await authenticatedFetch(`${stripTrailingSlashes(base)}${path}`, {
+        signal: AbortSignal.timeout(8_000),
+        headers: { 'Content-Type': 'application/json' },
+        ...init,
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(body || `Request failed (${res.status})`);
+    }
+    return (await res.json());
+}
+export async function listSandboxProjectMembers(sandbox, projectId) {
+    return fetchBeeuniMaster(sandbox, `/beeuni/projects/${encodeURIComponent(projectId)}/members`, { method: 'GET' });
+}
+export async function grantSandboxProjectAccess(sandbox, projectId, userId, role = 'member') {
+    await fetchBeeuniMaster(sandbox, `/beeuni/projects/${encodeURIComponent(projectId)}/members`, {
+        method: 'POST',
+        body: JSON.stringify({ user_id: userId, role }),
+    });
+}
+export async function revokeSandboxProjectAccess(sandbox, projectId, userId) {
+    await fetchBeeuniMaster(sandbox, `/beeuni/projects/${encodeURIComponent(projectId)}/members/${encodeURIComponent(userId)}`, { method: 'DELETE' });
+}

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

@@ -0,0 +1,18 @@
+import { type BeeuniProject, type ProjectSession, type ProjectSessionSandbox } from '../projects-client/index.js';
+import { type SandboxInfo } from './types.js';
+export declare function getPlatformUrl(): string;
+export declare function platformApiBase(backendUrl: string): string;
+export declare function normalizeSandboxId(value: unknown): string | undefined;
+export declare function projectSessionToSandboxInfo(project: BeeuniProject, session: ProjectSession, runtime?: ProjectSessionSandbox | null): SandboxInfo;
+export declare function listProjectSessionSandboxes(): Promise<Array<{
+    project: BeeuniProject;
+    session: ProjectSession;
+    runtime: ProjectSessionSandbox | null;
+    sandbox: SandboxInfo;
+}>>;
+export declare function findProjectSessionSandbox(sandboxId?: string): Promise<{
+    project: BeeuniProject;
+    session: ProjectSession;
+    runtime: ProjectSessionSandbox | null;
+    sandbox: SandboxInfo;
+} | null>;

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

@@ -0,0 +1,99 @@
+import { platformConfig } from '../../http/config.js';
+import { safeEnv } from '../../http/env.js';
+import { stripTrailingSlashes } from '../../../platform/strings.js';
+import { listProjectSessions, listProjects, } from '../projects-client/index.js';
+import { SANDBOX_PORTS } from './types.js';
+export function getPlatformUrl() {
+    const backendUrl = safeEnv('BACKEND_URL') || platformConfig().backendUrl;
+    if (backendUrl) {
+        return backendUrl;
+    }
+    return 'http://localhost:8008/v1';
+}
+export function platformApiBase(backendUrl) {
+    const base = stripTrailingSlashes(backendUrl);
+    return base.endsWith('/v1') ? base : `${base}/v1`;
+}
+export function normalizeSandboxId(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const normalized = normalizeSandboxId(item);
+            if (normalized)
+                return normalized;
+        }
+        return undefined;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return normalizeSandboxId(record.sandboxId ?? record.id ?? record.slug ?? Object.values(record)[0]);
+    }
+    return undefined;
+}
+function normalizeSessionStatus(status) {
+    if (status === 'running' || status === 'active')
+        return 'active';
+    if (status === 'queued' || status === 'branching' || status === 'provisioning')
+        return 'provisioning';
+    if (status === 'failed' || status === 'error')
+        return 'error';
+    if (status === 'stopped' || status === 'completed' || status === 'archived')
+        return 'stopped';
+    return status || 'unknown';
+}
+export function projectSessionToSandboxInfo(project, session, runtime) {
+    const externalId = runtime?.external_id || session.sandbox_url?.match(/\/p\/([^/]+)\//)?.[1] || session.sandbox_id || '';
+    return {
+        sandbox_id: runtime?.sandbox_id || session.sandbox_id || session.session_id,
+        external_id: externalId,
+        name: session.name || `${project.name} session`,
+        provider: runtime?.provider || session.sandbox_provider || 'daytona',
+        base_url: runtime?.base_url || session.sandbox_url || (runtime?.external_id ? `${getPlatformUrl()}/p/${runtime.external_id}/${SANDBOX_PORTS.BEEUNI_MASTER}` : ''),
+        status: normalizeSessionStatus(runtime?.status || session.status),
+        metadata: {
+            ...(session.metadata ?? {}),
+            project_id: project.project_id,
+            session_id: session.session_id,
+            project_name: project.name,
+            runtime_status: runtime?.status,
+            error: session.error,
+        },
+        created_at: runtime?.created_at || session.created_at,
+        updated_at: runtime?.updated_at || session.updated_at,
+    };
+}
+export async function listProjectSessionSandboxes() {
+    const projects = await listProjects();
+    const rows = [];
+    for (const project of projects) {
+        const sessions = await listProjectSessions(project.project_id).catch(() => []);
+        for (const session of sessions) {
+            const runtime = null;
+            rows.push({
+                project,
+                session,
+                runtime,
+                sandbox: projectSessionToSandboxInfo(project, session, runtime),
+            });
+        }
+    }
+    return rows.sort((a, b) => {
+        const priority = { active: 0, provisioning: 1, stopped: 2, error: 3 };
+        const statusDelta = (priority[a.sandbox.status] ?? 99) - (priority[b.sandbox.status] ?? 99);
+        if (statusDelta !== 0)
+            return statusDelta;
+        return Date.parse(b.sandbox.updated_at) - Date.parse(a.sandbox.updated_at);
+    });
+}
+export async function findProjectSessionSandbox(sandboxId) {
+    const rows = await listProjectSessionSandboxes();
+    if (!sandboxId)
+        return rows[0] ?? null;
+    return rows.find((row) => row.sandbox.sandbox_id === sandboxId ||
+        row.sandbox.external_id === sandboxId ||
+        row.session.session_id === sandboxId ||
+        row.runtime?.external_id === sandboxId) ?? null;
+}

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

@@ -0,0 +1,21 @@
+export interface SSHConnectionInfo {
+    host: string;
+    port: number;
+    username: string;
+    provider: string;
+    key_name: string;
+    host_alias: string;
+    reconnect_command: string;
+    ssh_command: string;
+    ssh_config_entry: string;
+    ssh_config_command: string;
+}
+export interface SSHSetupResult extends SSHConnectionInfo {
+    private_key: string;
+    public_key: string;
+    setup_command: string;
+    agent_prompt: string;
+    key_comment: string;
+}
+export declare function setupSSH(sandboxId?: string): Promise<SSHSetupResult>;
+export declare function getSSHConnection(sandboxId?: string): Promise<SSHConnectionInfo>;

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

@@ -0,0 +1,6 @@
+export async function setupSSH(sandboxId) {
+    throw new Error('SSH setup is not exposed for project-session sandboxes');
+}
+export async function getSSHConnection(sandboxId) {
+    throw new Error('SSH connection details are not exposed for project-session sandboxes');
+}