@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/apps-fleet.d.ts

@@ -0,0 +1,82 @@
+export type AppMachineState = 'started' | 'starting' | 'stopped' | 'stopping' | 'provisioning';
+export interface AppMachine {
+    machine_id: string;
+    instance_id: string;
+    process_group: string;
+    state: AppMachineState;
+    release: {
+        deployment_id: string;
+        version: number;
+    };
+    vm: {
+        cpu: number;
+        memory_gb: number;
+        disk_gb: number;
+    };
+    volume: {
+        volume_id: string;
+        name: string | null;
+    } | null;
+    created_at: string;
+    started_at: string | null;
+    stopped_at: string | null;
+}
+export interface AppVolume {
+    volume_id: string;
+    name: string;
+    process_group: string;
+    machine_id: string | null;
+    size_gb: number;
+    status: 'creating' | 'ready' | 'destroying' | 'destroyed' | 'error';
+    attached: boolean;
+    snapshot_retention_days: number;
+    created_at: string;
+}
+export interface AppVolumeSnapshot {
+    snapshot_id: string;
+    kind: 'daily' | 'manual' | 'final';
+    commit_id: string;
+    created_at: string;
+}
+export interface AppExecInput {
+    command: string[];
+    machine_id?: string;
+    timeout_s?: number;
+}
+export interface AppExecResult {
+    machine_id: string;
+    exit_code: number;
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+}
+export interface CreateAppVolumeInput {
+    name: string;
+    size_gb: number;
+    process_group?: string;
+    snapshot_retention_days?: number;
+}
+export declare function listAppMachines(projectId: string, appId: string): Promise<AppMachine[]>;
+export declare const startAppMachine: (projectId: string, appId: string, machineId: string) => Promise<AppMachine[]>;
+export declare const stopAppMachine: (projectId: string, appId: string, machineId: string) => Promise<AppMachine[]>;
+export declare const restartAppMachine: (projectId: string, appId: string, machineId: string) => Promise<AppMachine[]>;
+export declare function destroyAppMachine(projectId: string, appId: string, machineId: string): Promise<AppMachine[]>;
+export declare function scaleApp(projectId: string, appId: string, count: Record<string, number>): Promise<{
+    scale: Record<string, number>;
+    machines: AppMachine[];
+}>;
+export declare function execInApp(projectId: string, appId: string, input: AppExecInput): Promise<AppExecResult>;
+export declare function listAppVolumes(projectId: string, appId: string): Promise<AppVolume[]>;
+export declare function createAppVolume(projectId: string, appId: string, input: CreateAppVolumeInput): Promise<AppVolume>;
+export declare function updateAppVolume(projectId: string, appId: string, volumeId: string, input: {
+    size_gb?: number;
+    snapshot_retention_days?: number;
+}): Promise<AppVolume>;
+export declare function destroyAppVolume(projectId: string, appId: string, volumeId: string, confirmName: string): Promise<void>;
+export declare function listAppVolumeSnapshots(projectId: string, appId: string, volumeId: string): Promise<AppVolumeSnapshot[]>;
+export declare function createAppVolumeSnapshot(projectId: string, appId: string, volumeId: string): Promise<AppVolumeSnapshot>;
+export declare function restoreAppVolume(projectId: string, appId: string, volumeId: string, snapshotId: string): Promise<AppVolume>;
+export declare function forkAppVolume(projectId: string, appId: string, volumeId: string, input: {
+    name: string;
+    snapshot_id?: string;
+}): Promise<AppVolume>;

package/dist/core/rest/projects-client/apps-fleet.js

@@ -0,0 +1,45 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+const app = (projectId, appId) => `/projects/${projectId}/apps/${appId}`;
+export async function listAppMachines(projectId, appId) {
+    return unwrap(await backendApi.get(`${app(projectId, appId)}/machines`), 'Failed to list machines').machines;
+}
+async function machineAction(projectId, appId, machineId, action) {
+    return unwrap(await backendApi.post(`${app(projectId, appId)}/machines/${machineId}/${action}`, {}), `Failed to ${action} the machine`).machines;
+}
+export const startAppMachine = (projectId, appId, machineId) => machineAction(projectId, appId, machineId, 'start');
+export const stopAppMachine = (projectId, appId, machineId) => machineAction(projectId, appId, machineId, 'stop');
+export const restartAppMachine = (projectId, appId, machineId) => machineAction(projectId, appId, machineId, 'restart');
+export async function destroyAppMachine(projectId, appId, machineId) {
+    return unwrap(await backendApi.delete(`${app(projectId, appId)}/machines/${machineId}`), 'Failed to destroy the machine').machines;
+}
+export async function scaleApp(projectId, appId, count) {
+    return unwrap(await backendApi.put(`${app(projectId, appId)}/scale`, { count }), 'Failed to scale the App');
+}
+export async function execInApp(projectId, appId, input) {
+    return unwrap(await backendApi.post(`${app(projectId, appId)}/exec`, input), 'Failed to run the command');
+}
+export async function listAppVolumes(projectId, appId) {
+    return unwrap(await backendApi.get(`${app(projectId, appId)}/volumes`), 'Failed to list volumes').volumes;
+}
+export async function createAppVolume(projectId, appId, input) {
+    return unwrap(await backendApi.post(`${app(projectId, appId)}/volumes`, input), 'Failed to create the volume');
+}
+export async function updateAppVolume(projectId, appId, volumeId, input) {
+    return unwrap(await backendApi.patch(`${app(projectId, appId)}/volumes/${volumeId}`, input), 'Failed to update the volume');
+}
+export async function destroyAppVolume(projectId, appId, volumeId, confirmName) {
+    unwrap(await backendApi.delete(`${app(projectId, appId)}/volumes/${volumeId}?confirm=${encodeURIComponent(confirmName)}`), 'Failed to destroy the volume');
+}
+export async function listAppVolumeSnapshots(projectId, appId, volumeId) {
+    return unwrap(await backendApi.get(`${app(projectId, appId)}/volumes/${volumeId}/snapshots`), 'Failed to list snapshots').snapshots;
+}
+export async function createAppVolumeSnapshot(projectId, appId, volumeId) {
+    return unwrap(await backendApi.post(`${app(projectId, appId)}/volumes/${volumeId}/snapshots`, {}), 'Failed to take the snapshot');
+}
+export async function restoreAppVolume(projectId, appId, volumeId, snapshotId) {
+    return unwrap(await backendApi.post(`${app(projectId, appId)}/volumes/${volumeId}/restore`, { snapshot_id: snapshotId }), 'Failed to restore the volume');
+}
+export async function forkAppVolume(projectId, appId, volumeId, input) {
+    return unwrap(await backendApi.post(`${app(projectId, appId)}/volumes/${volumeId}/fork`, input), 'Failed to fork the volume');
+}

package/dist/core/rest/projects-client/apps.d.ts

@@ -0,0 +1,356 @@
+export type AppHostingProvider = 'daytona' | 'platinum' | 'e2b';
+export type AppDesiredState = 'running' | 'stopped';
+export type AppAccessMode = 'private' | 'project' | 'restricted' | 'public' | 'password';
+export type AppArtifactKind = 'archive' | 'oci_image';
+export type AppArtifactStatus = 'uploading' | 'uploaded' | 'ready' | 'rejected' | 'deleted';
+export type AppSourceKind = 'static' | 'bundle' | 'dockerfile' | 'oci_image';
+export type AppCapability = 'deployments' | 'rollback' | 'preview' | 'sleep' | 'static' | 'member_tokens' | 'machines' | 'scale' | 'exec' | 'volumes' | 'snapshots';
+export type AppDeployStrategy = 'rolling' | 'immediate' | 'bluegreen' | 'canary';
+export type AppAutoStop = 'off' | 'stop' | 'suspend';
+export type AppServiceAccess = 'public' | 'app' | 'admins';
+export interface AppCheck {
+    type: 'http' | 'tcp';
+    port?: number;
+    path?: string;
+    interval_s: number;
+    timeout_s: number;
+    grace_period_s: number;
+}
+export interface AppServiceConfig {
+    name: string;
+    internal_port: number;
+    protocol: 'http' | 'tcp';
+    access: AppServiceAccess;
+    auto_stop_machines: AppAutoStop;
+    auto_start_machines: boolean;
+    min_machines_running: number;
+    processes: string[];
+    checks: AppCheck[];
+}
+export interface AppMountConfig {
+    source: string;
+    destination: string;
+    initial_size_gb: number;
+    snapshot_retention_days: number;
+    processes: string[];
+}
+export interface AppVmConfig {
+    cpu: number;
+    memory_gb: number;
+    disk_gb: number;
+    processes: string[];
+}
+export interface AppReleaseConfig {
+    processes: Record<string, string>;
+    services: AppServiceConfig[];
+    mounts: AppMountConfig[];
+    vm: AppVmConfig[];
+    deploy: {
+        strategy: AppDeployStrategy;
+        release_command: string | null;
+    };
+}
+type Partial2<T> = {
+    [K in keyof T]?: T[K] extends Array<infer U> ? Array<Partial<U>> : T[K];
+};
+export interface AppReleaseConfigInput {
+    processes?: Record<string, string>;
+    http_service?: Partial2<Omit<AppServiceConfig, 'name'>>;
+    services?: Array<Partial2<AppServiceConfig>>;
+    mounts?: Array<Partial<AppMountConfig>>;
+    vm?: Partial<AppVmConfig> | Array<Partial<AppVmConfig>>;
+    deploy?: {
+        strategy?: AppDeployStrategy;
+        release_command?: string | null;
+    };
+    port?: number;
+    command?: string;
+    readiness_path?: string;
+    always_on?: boolean;
+    resources?: {
+        cpu?: number;
+        memory_gb?: number;
+        disk_gb?: number;
+    };
+}
+export interface AppServiceSummary {
+    name: string;
+    protocol: 'http' | 'tcp';
+    access: AppServiceAccess;
+    internal_port: number;
+    processes: string[];
+    url: string | null;
+}
+export interface AppAuth {
+    issuer: string;
+    audience: string;
+    jwks_uri: string;
+}
+export type AppDeploymentStatus = 'queued' | 'validating' | 'building' | 'provisioning' | 'checking' | 'ready' | 'failed' | 'cancelled';
+export interface AppMachineSpec {
+    cpu: number;
+    memory_gb: number;
+    disk_gb: number;
+}
+export interface App {
+    app_id: string;
+    account_id: string;
+    project_id: string;
+    capabilities?: AppCapability[];
+    slug: string;
+    name: string;
+    url: string;
+    access_mode: AppAccessMode;
+    access_revision: number;
+    desired_state: AppDesiredState;
+    active_deployment_id: string | null;
+    machine: AppMachineSpec;
+    idle_timeout_seconds: number;
+    always_on?: boolean;
+    estimated_monthly_usd?: number;
+    hosting_type?: 'sandbox' | 'static' | null;
+    retained_deployments?: number;
+    warnings?: Array<{
+        code: string;
+        message: string;
+    }>;
+    last_request_at: string | null;
+    viewer_can_access?: boolean;
+    uses?: string[];
+    used_by?: string[];
+    auth?: AppAuth;
+    labels?: string[];
+    scale?: Record<string, number>;
+    services?: AppServiceSummary[];
+    machines?: {
+        total: number;
+        running: number;
+        stopped: number;
+    };
+    volumes?: {
+        count: number;
+        size_gb: number;
+    };
+    config?: AppReleaseConfig | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateAppInput {
+    slug: string;
+    name: string;
+    cpu?: number;
+    memory_gb?: number;
+    disk_gb?: number;
+    idle_timeout_seconds?: number;
+    always_on?: boolean;
+    uses?: string[];
+}
+export interface UpdateAppInput {
+    name?: string;
+    cpu?: number;
+    memory_gb?: number;
+    disk_gb?: number;
+    idle_timeout_seconds?: number;
+    always_on?: boolean;
+    uses?: string[];
+    labels?: string[];
+}
+export type AppViewerTokenScope = 'off' | 'identity' | 'api';
+export interface AppAccessConfig {
+    mode: AppAccessMode;
+    revision: number;
+    member_ids: string[];
+    group_ids: string[];
+    password_configured: boolean;
+    viewer_token_scope: AppViewerTokenScope;
+}
+export interface UpdateAppAccessInput {
+    mode: AppAccessMode;
+    member_ids?: string[];
+    group_ids?: string[];
+    password?: string;
+    viewer_token_scope?: AppViewerTokenScope;
+}
+export interface AppAccessSession {
+    url: string;
+    expires_at: string;
+}
+export interface AppArtifact {
+    artifact_id: string;
+    project_id: string;
+    kind: AppArtifactKind;
+    status: AppArtifactStatus;
+    image_reference: string | null;
+    sha256: string | null;
+    size_bytes: number | null;
+    media_type: string | null;
+    error: string | null;
+    created_at: string;
+}
+export type RegisterAppArtifactInput = {
+    kind: 'archive';
+    media_type?: string;
+} | {
+    kind: 'oci_image';
+    image: string;
+};
+export interface RegisterAppArtifactResponse {
+    artifact: AppArtifact;
+    upload: {
+        url: string;
+        max_bytes: number;
+    } | null;
+}
+export interface FinalizeAppArtifactInput {
+    sha256: string;
+    size_bytes: number;
+}
+interface BaseAppSource {
+    readiness_path?: string;
+}
+export interface StaticAppSource extends BaseAppSource {
+    kind: 'static';
+    root?: string;
+    spa?: boolean;
+}
+export interface BundleAppSource extends BaseAppSource {
+    kind: 'bundle';
+    install_command?: string;
+    build_command?: string;
+    output_dir?: string;
+    spa?: boolean;
+}
+export interface DockerfileAppSource extends BaseAppSource {
+    kind: 'dockerfile';
+    dockerfile?: string;
+    command: string[];
+    port?: number;
+    restart_limit?: number;
+}
+export interface OciImageAppSource extends BaseAppSource {
+    kind: 'oci_image';
+    image: string;
+    command: string[];
+    port?: number;
+    restart_limit?: number;
+}
+export type AppSource = StaticAppSource | BundleAppSource | DockerfileAppSource | OciImageAppSource;
+export type CreateAppDeploymentInput = CreateAppBuildInput;
+export interface CreateAppBuildInput {
+    artifact_id: string;
+    source: AppSource;
+    provider?: AppHostingProvider;
+    environment?: Record<string, string>;
+    secrets?: Record<string, string>;
+    config?: AppReleaseConfigInput;
+}
+export interface AppDeployment {
+    deployment_id: string;
+    app_id: string;
+    artifact_id: string | null;
+    version: number;
+    status: AppDeploymentStatus;
+    source_kind: AppSourceKind;
+    hosting_type: 'sandbox' | 'static';
+    hosting_provider: AppHostingProvider | null;
+    runtime_spec: Record<string, unknown>;
+    build_spec: Record<string, unknown>;
+    error_code: string | null;
+    error: string | null;
+    attempt_count: number;
+    started_at: string | null;
+    ready_at: string | null;
+    failed_at: string | null;
+    created_by: string;
+    source_session_id: string | null;
+    actor_type: 'human' | 'agent' | 'service_account' | 'system';
+    config: AppReleaseConfig | null;
+    strategy: AppDeployStrategy | null;
+    release_command_status: 'running' | 'succeeded' | 'failed' | null;
+    created_at: string;
+    updated_at: string;
+}
+export type AppRollback = App & {
+    deployment: AppDeployment;
+};
+export interface AppDeploymentEvent {
+    event_id: string;
+    runtime_id: string | null;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    type: string;
+    message: string;
+    data: Record<string, unknown>;
+    created_at: string;
+}
+export interface AppDeploymentDetail {
+    deployment: AppDeployment;
+    events: AppDeploymentEvent[];
+}
+export interface AppLogEntry {
+    cursor: number;
+    time: string;
+    source: 'app' | 'appd' | 'caddy' | string;
+    line: string;
+}
+export interface AppLogsResponse {
+    entries: AppLogEntry[];
+    next_cursor: number;
+}
+export interface AppLogsOptions {
+    after?: number;
+    limit?: number;
+}
+export declare function listApps(projectId: string): Promise<App[]>;
+export declare function createApp(projectId: string, input: CreateAppInput): Promise<App>;
+export declare function getApp(projectId: string, appId: string): Promise<App>;
+export declare function updateApp(projectId: string, appId: string, input: UpdateAppInput): Promise<App>;
+export interface AppImageRelease {
+    released: number;
+    pending: number;
+}
+export declare function deleteApp(projectId: string, appId: string): Promise<{
+    ok: boolean;
+    images?: AppImageRelease;
+}>;
+export interface AppToken {
+    token: string;
+    expires_at: string;
+}
+export declare function createAppToken(projectId: string, appId: string): Promise<AppToken>;
+export interface AppAuthEnv {
+    BEEUNI_AUTH_ISSUER: string;
+    BEEUNI_AUTH_AUDIENCE: string;
+    BEEUNI_AUTH_JWKS: string;
+}
+export declare function getAppAuthEnv(projectId: string, appId: string): Promise<AppAuthEnv>;
+export declare function getAppAccess(projectId: string, appId: string): Promise<AppAccessConfig>;
+export interface AppAgentAccess {
+    agent_name: string;
+    grant: 'all' | 'listed';
+    path: string;
+}
+export declare function listAppAgents(projectId: string, appId: string): Promise<AppAgentAccess[]>;
+export declare function updateAppAccess(projectId: string, appId: string, input: UpdateAppAccessInput): Promise<AppAccessConfig>;
+export declare function createAppAccessSession(projectId: string, appId: string): Promise<AppAccessSession>;
+export declare function registerAppArtifact(projectId: string, input: RegisterAppArtifactInput): Promise<RegisterAppArtifactResponse>;
+export declare function finalizeAppArtifact(projectId: string, artifactId: string, input: FinalizeAppArtifactInput): Promise<AppArtifact>;
+export interface UploadAppArtifactOptions {
+    mediaType?: string;
+    signal?: AbortSignal;
+    onProgress?: (uploadedBytes: number, totalBytes: number) => void;
+}
+export declare function uploadAppArtifactArchive(projectId: string, input: Blob | Uint8Array, options?: UploadAppArtifactOptions): Promise<AppArtifact>;
+export declare function createAppDeployment(projectId: string, appId: string, input: CreateAppDeploymentInput): Promise<AppDeployment>;
+export declare function listAppDeployments(projectId: string, appId: string): Promise<AppDeployment[]>;
+export declare function getAppDeployment(projectId: string, appId: string, deploymentId: string): Promise<AppDeploymentDetail>;
+export declare function getAppDeploymentLogs(projectId: string, appId: string, deploymentId: string, options?: AppLogsOptions): Promise<AppLogsResponse>;
+export declare function startApp(projectId: string, appId: string): Promise<App>;
+export declare function stopApp(projectId: string, appId: string): Promise<App>;
+export interface DeleteAppDeploymentResult {
+    ok: boolean;
+    deployment_id: string;
+    image: 'released' | 'pending' | 'none';
+}
+export declare function deleteAppDeployment(projectId: string, appId: string, deploymentId: string): Promise<DeleteAppDeploymentResult>;
+export declare function rollbackApp(projectId: string, appId: string, deploymentId: string): Promise<AppRollback>;
+export {};

package/dist/core/rest/projects-client/apps.js

@@ -0,0 +1,126 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listApps(projectId) {
+    const data = unwrap(await backendApi.get(`/projects/${projectId}/apps`), 'Failed to list Apps');
+    return data.apps;
+}
+export async function createApp(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps`, input), 'Failed to create App');
+}
+export async function getApp(projectId, appId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/apps/${appId}`), 'Failed to load App');
+}
+export async function updateApp(projectId, appId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/apps/${appId}`, input), 'Failed to update App');
+}
+export async function deleteApp(projectId, appId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/apps/${appId}`), 'Failed to delete App');
+}
+export async function createAppToken(projectId, appId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/${appId}/token`, {}), 'Failed to mint an App token');
+}
+export async function getAppAuthEnv(projectId, appId) {
+    const app = await getApp(projectId, appId);
+    if (!app.auth)
+        throw new Error('This server does not report sign-in values for Apps.');
+    const keySet = unwrap(await backendApi.get(`/projects/${projectId}/jwks.json`), 'Failed to read the project key set');
+    const bytes = new TextEncoder().encode(JSON.stringify(keySet));
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return {
+        BEEUNI_AUTH_ISSUER: app.auth.issuer,
+        BEEUNI_AUTH_AUDIENCE: app.auth.audience,
+        BEEUNI_AUTH_JWKS: `data:application/json;base64,${btoa(binary)}`,
+    };
+}
+export async function getAppAccess(projectId, appId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/apps/${appId}/access`), 'Failed to load App access policy');
+}
+export async function listAppAgents(projectId, appId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/apps/${appId}/agents`), 'Failed to load the agents with access to this App').agents;
+}
+export async function updateAppAccess(projectId, appId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/apps/${appId}/access`, input), 'Failed to update App access policy');
+}
+export async function createAppAccessSession(projectId, appId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/${appId}/access-session`, {}), 'Failed to create App access session');
+}
+export async function registerAppArtifact(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/artifacts`, input), 'Failed to register App artifact');
+}
+export async function finalizeAppArtifact(projectId, artifactId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/artifacts/${artifactId}/finalize`, input), 'Failed to finalize App artifact');
+}
+async function archiveBytes(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    return new Uint8Array(await input.arrayBuffer());
+}
+async function sha256Hex(bytes) {
+    const copy = Uint8Array.from(bytes);
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', copy.buffer);
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+export async function uploadAppArtifactArchive(projectId, input, options = {}) {
+    const bytes = await archiveBytes(input);
+    const mediaType = options.mediaType ?? 'application/gzip';
+    const registered = await registerAppArtifact(projectId, { kind: 'archive', media_type: mediaType });
+    if (!registered.upload)
+        throw new Error('App artifact registration did not return an upload URL');
+    if (bytes.byteLength > registered.upload.max_bytes) {
+        throw new Error(`App artifact exceeds ${registered.upload.max_bytes} bytes`);
+    }
+    options.onProgress?.(0, bytes.byteLength);
+    const upload = await fetch(registered.upload.url, {
+        method: 'PUT',
+        body: new Blob([Uint8Array.from(bytes).buffer], { type: mediaType }),
+        signal: options.signal,
+        headers: {
+            'content-type': mediaType,
+            'x-upsert': 'false',
+        },
+    });
+    if (!upload.ok) {
+        const detail = await upload.text().catch(() => '');
+        throw new Error(`App artifact upload failed with HTTP ${upload.status}${detail ? `: ${detail}` : ''}`);
+    }
+    options.onProgress?.(bytes.byteLength, bytes.byteLength);
+    return finalizeAppArtifact(projectId, registered.artifact.artifact_id, {
+        sha256: await sha256Hex(bytes),
+        size_bytes: bytes.byteLength,
+    });
+}
+export async function createAppDeployment(projectId, appId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/${appId}/deployments`, input), 'Failed to create App deployment');
+}
+export async function listAppDeployments(projectId, appId) {
+    const data = unwrap(await backendApi.get(`/projects/${projectId}/apps/${appId}/deployments`), 'Failed to list App deployments');
+    return data.deployments;
+}
+export async function getAppDeployment(projectId, appId, deploymentId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/apps/${appId}/deployments/${deploymentId}`), 'Failed to load App deployment');
+}
+export async function getAppDeploymentLogs(projectId, appId, deploymentId, options = {}) {
+    const query = new URLSearchParams();
+    if (options.after !== undefined)
+        query.set('after', String(options.after));
+    if (options.limit !== undefined)
+        query.set('limit', String(options.limit));
+    const suffix = query.size ? `?${query.toString()}` : '';
+    return unwrap(await backendApi.get(`/projects/${projectId}/apps/${appId}/deployments/${deploymentId}/logs${suffix}`), 'Failed to load App logs');
+}
+export async function startApp(projectId, appId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/${appId}/start`, {}), 'Failed to start App');
+}
+export async function stopApp(projectId, appId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/${appId}/stop`, {}), 'Failed to stop App');
+}
+export async function deleteAppDeployment(projectId, appId, deploymentId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/apps/${appId}/deployments/${deploymentId}`), 'Failed to delete App deployment');
+}
+export async function rollbackApp(projectId, appId, deploymentId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/apps/${appId}/rollback`, {
+        deployment_id: deploymentId,
+    }), 'Failed to roll back App');
+}

package/dist/core/rest/projects-client/assignments.d.ts

@@ -0,0 +1,73 @@
+export type AssignmentPrincipalType = 'user' | 'group' | 'service_account' | 'pending' | 'project';
+export type AssignmentScopeType = 'account' | 'project';
+export type AssignmentObjectType = 'agent' | 'skill' | 'secret' | 'app' | 'trigger' | 'connection';
+export type AssignmentSource = 'manual' | 'scim' | 'sso' | 'invite' | 'system';
+export interface PrincipalRef {
+    type: AssignmentPrincipalType;
+    id: string;
+}
+export interface RoleAssignment {
+    assignment_id: string;
+    account_id: string;
+    principal_type: AssignmentPrincipalType;
+    principal_id: string;
+    role_id: string;
+    role_key: string;
+    role_is_system: boolean;
+    scope_type: AssignmentScopeType;
+    scope_id: string | null;
+    object_type: AssignmentObjectType | null;
+    object_id: string | null;
+    expires_at: string | null;
+    granted_by: string | null;
+    source: AssignmentSource;
+    created_at: string;
+    updated_at: string;
+}
+export type AssignmentInput = {
+    principal: PrincipalRef;
+    scope: {
+        type: 'account';
+        id?: null;
+    } | {
+        type: 'project';
+        id: string;
+    };
+    object?: {
+        type: AssignmentObjectType;
+        id: string;
+    };
+    expiresAt?: string | null;
+} & ({
+    roleId: string;
+    roleKey?: never;
+} | {
+    roleKey: string;
+    roleId?: never;
+});
+export interface ListAssignmentsFilter {
+    principalType?: AssignmentPrincipalType;
+    principalId?: string;
+    scopeType?: AssignmentScopeType;
+    scopeId?: string;
+    objectType?: AssignmentObjectType;
+    objectId?: string;
+    roleId?: string;
+    includeExpired?: boolean;
+}
+export interface Permission {
+    action: string;
+    scope_type: AssignmentScopeType;
+    resource_type: string;
+    delegable: boolean;
+    description: string;
+    area: string;
+    level: string;
+    implies: string[];
+}
+export declare function listAssignments(accountId: string, filter?: ListAssignmentsFilter): Promise<RoleAssignment[]>;
+export declare function createAssignment(accountId: string, input: AssignmentInput): Promise<RoleAssignment>;
+export declare function revokeAssignment(accountId: string, assignmentId: string): Promise<RoleAssignment>;
+export declare function listPermissions(accountId: string, options?: {
+    scopeType?: AssignmentScopeType;
+}): Promise<Permission[]>;