@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/prompt-attachments.js

@@ -0,0 +1,294 @@
+import { backendApi, ApiError } from '../../http/api-client.js';
+import { abortableDelay } from '../../http/abort.js';
+import { platformConfig } from '../../http/config.js';
+import { MAX_PROMPT_ATTACHMENT_BYTES } from '../../attachments/limits.js';
+import { unwrap } from './shared.js';
+const path = (projectId) => `/projects/${encodeURIComponent(projectId)}/attachments`;
+const quiet = { showErrors: false, deadlineCoversBody: true };
+const REQUEST_TIMEOUT_MS = 30_000;
+const COMPLETE_TIMEOUT_MS = 120_000;
+const TRANSIENT_RETRY_BUDGET_MS = 60_000;
+const COMPLETION_RETRY_BUDGET_MS = 5 * 60_000;
+const DIRECT_STALL_MS = 60_000;
+const DIRECT_URL_MARGIN_MS = 60_000;
+function abortedError() {
+    return new ApiError('Request aborted', { name: 'AbortError', code: 'ABORTED' });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortedError();
+}
+function transient(error) {
+    if (!(error instanceof ApiError) || error.code === 'ABORTED')
+        return false;
+    if (error.code === 'attachment_budget_exceeded')
+        return false;
+    return (error.code === 'TIMEOUT' ||
+        error.name === 'TypeError' ||
+        error.status === 429 ||
+        (error.status !== undefined && error.status >= 500));
+}
+async function retry(operation, signal, completion = false) {
+    let deadline;
+    for (let attempt = 0;; attempt++) {
+        throwIfAborted(signal);
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const processing = completion &&
+                error instanceof ApiError &&
+                error.status === 409 &&
+                error.code === 'attachment_processing';
+            if (signal?.aborted || !(transient(error) || processing))
+                throw error;
+            deadline ??=
+                Date.now() + (completion ? COMPLETION_RETRY_BUDGET_MS : TRANSIENT_RETRY_BUDGET_MS);
+            const delay = Math.min(8_000, 500 * 2 ** attempt) * (0.5 + Math.random() / 2);
+            if (Date.now() + delay >= deadline)
+                throw error;
+            try {
+                await abortableDelay(delay, signal);
+            }
+            catch {
+                throwIfAborted(signal);
+                throw error;
+            }
+        }
+    }
+}
+function isStringRecord(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.values(value).every((item) => typeof item === 'string'));
+}
+function checkedHandle(value, file, attachmentId) {
+    const target = value?.upload;
+    const received = value?.received_bytes;
+    const receivedValid = Number.isSafeInteger(received) && received >= 0 && received <= file.size;
+    const targetValid = target?.kind === 'direct'
+        ? typeof target.url === 'string' &&
+            /^https?:\/\//i.test(target.url) &&
+            target.method === 'PUT' &&
+            isStringRecord(target.headers) &&
+            Number.isFinite(Date.parse(target.expires_at)) &&
+            (received === 0 || received === file.size)
+        : target?.kind === 'chunked' &&
+            Number.isSafeInteger(target.chunk_size) &&
+            target.chunk_size > 0 &&
+            (received === file.size || received % target.chunk_size === 0);
+    if (!value?.attachment_id ||
+        (attachmentId !== undefined && value.attachment_id !== attachmentId) ||
+        value.size !== file.size ||
+        !receivedValid ||
+        !targetValid)
+        throw new Error('Invalid attachment upload handle');
+    return value;
+}
+async function begin(projectId, file, signal, attachmentId) {
+    return unwrap(await backendApi.post(path(projectId), {
+        ...(attachmentId ? { attachment_id: attachmentId } : {}),
+        filename: file.name,
+        mime: file.type || 'application/octet-stream',
+        size: file.size,
+    }, { ...quiet, signal, timeout: REQUEST_TIMEOUT_MS }), 'Failed to start attachment upload');
+}
+async function resign(projectId, file, current, options) {
+    const next = checkedHandle({
+        ...(await retry(() => begin(projectId, file, options.signal, current.attachment_id), options.signal)),
+        received_bytes: 0,
+    }, file, current.attachment_id);
+    options.onUpload?.(next);
+    return next;
+}
+function storageError(status, body) {
+    let details;
+    try {
+        details = JSON.parse(body);
+    }
+    catch { }
+    const message = typeof details?.message === 'string'
+        ? details.message
+        : typeof details?.error === 'string'
+            ? details.error
+            : `HTTP ${status}`;
+    return new ApiError(message, { status, details, code: String(details?.statusCode ?? status) });
+}
+function storageStatus(error) {
+    if (!(error instanceof ApiError))
+        return undefined;
+    const reported = Number(error.details?.statusCode);
+    return Number.isInteger(reported) && reported >= 400 ? reported : error.status;
+}
+function putWithXhr(Request, target, file, options) {
+    return new Promise((resolve, reject) => {
+        const request = new Request();
+        let reported = 0;
+        let settled = false;
+        let stall;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (stall)
+                clearTimeout(stall);
+            options.signal?.removeEventListener('abort', onAbort);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        const armStall = () => {
+            if (stall)
+                clearTimeout(stall);
+            stall = setTimeout(() => {
+                finish(new ApiError('Attachment upload stalled', { code: 'TIMEOUT' }));
+                request.abort();
+            }, DIRECT_STALL_MS);
+        };
+        const onAbort = () => {
+            finish(abortedError());
+            request.abort();
+        };
+        request.open(target.method, target.url);
+        for (const [name, value] of Object.entries(target.headers))
+            request.setRequestHeader(name, value);
+        request.upload.onprogress = (event) => {
+            armStall();
+            reported = Math.min(event.loaded, file.size);
+            options.onProgress?.(reported, file.size);
+        };
+        request.onload = () => {
+            if (request.status >= 200 && request.status < 300) {
+                if (reported < file.size)
+                    options.onProgress?.(file.size, file.size);
+                finish();
+            }
+            else
+                finish(storageError(request.status, request.responseText));
+        };
+        request.onerror = () => finish(new ApiError('Network error during attachment upload', { name: 'TypeError' }));
+        request.onabort = () => finish(abortedError());
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        armStall();
+        request.send(file);
+    });
+}
+async function putWithFetch(target, file, options) {
+    const fetchImpl = platformConfig().fetch ?? fetch;
+    let response;
+    try {
+        response = await fetchImpl(target.url, {
+            method: target.method,
+            headers: target.headers,
+            body: file,
+            signal: options.signal,
+            credentials: 'omit',
+        });
+    }
+    catch (error) {
+        if (options.signal?.aborted || (error instanceof Error && error.name === 'AbortError'))
+            throw abortedError();
+        throw new ApiError(error instanceof Error ? error.message : String(error), {
+            name: error instanceof Error ? error.name : 'TypeError',
+        });
+    }
+    if (!response.ok)
+        throw storageError(response.status, await response.text().catch(() => ''));
+    options.onProgress?.(file.size, file.size);
+}
+function putDirect(target, file, options) {
+    throwIfAborted(options.signal);
+    const Request = globalThis.XMLHttpRequest;
+    return typeof Request === 'function'
+        ? putWithXhr(Request, target, file, options)
+        : putWithFetch(target, file, options);
+}
+async function sendDirect(projectId, file, handle, options) {
+    let upload = handle;
+    let resigned = false;
+    options.onProgress?.(0, file.size);
+    while (upload.upload.kind === 'direct') {
+        const target = upload.upload;
+        try {
+            await retry(() => putDirect(target, file, options), options.signal);
+        }
+        catch (error) {
+            const status = storageStatus(error);
+            if (status !== 409) {
+                if (resigned || !(status === 400 || status === 401 || status === 403))
+                    throw error;
+                resigned = true;
+                upload = await resign(projectId, file, upload, options);
+                continue;
+            }
+        }
+        upload = { ...upload, received_bytes: file.size };
+        options.onUpload?.(upload);
+        return upload;
+    }
+    return sendChunks(projectId, file, upload, options);
+}
+async function sendChunks(projectId, file, handle, options) {
+    if (handle.upload.kind !== 'chunked')
+        throw new Error('Invalid attachment upload handle');
+    const chunkSize = handle.upload.chunk_size;
+    const endpoint = `${path(projectId)}/${encodeURIComponent(handle.attachment_id)}`;
+    let upload = handle;
+    while (upload.received_bytes < file.size) {
+        throwIfAborted(options.signal);
+        const offset = upload.received_bytes;
+        const end = Math.min(offset + chunkSize, file.size);
+        const chunk = file.slice(offset, end);
+        const ack = await retry(async () => unwrap(await backendApi.putRaw(`${endpoint}/chunks/${offset / chunkSize}`, chunk, { ...quiet, signal: options.signal, timeout: REQUEST_TIMEOUT_MS }), 'Failed to upload attachment chunk'), options.signal);
+        if (ack.size !== file.size || ack.received_bytes !== end)
+            throw new Error('Invalid attachment chunk acknowledgment');
+        upload = { ...upload, received_bytes: end };
+        options.onUpload?.(upload);
+        options.onProgress?.(end, file.size);
+    }
+    return upload;
+}
+export async function uploadPromptAttachment(projectId, file, options = {}) {
+    if (!projectId)
+        throw new Error('A project is required to upload attachments');
+    if (!Number.isSafeInteger(file.size) || file.size <= 0 || file.size > MAX_PROMPT_ATTACHMENT_BYTES)
+        throw new Error('Attachment must contain 1 byte to 50 MiB');
+    throwIfAborted(options.signal);
+    let upload = options.resume
+        ? checkedHandle({ ...options.resume }, file)
+        : checkedHandle({
+            ...(await retry(() => begin(projectId, file, options.signal), options.signal)),
+            received_bytes: 0,
+        }, file);
+    options.onUpload?.(upload);
+    if (upload.received_bytes < file.size) {
+        if (upload.upload.kind === 'direct' &&
+            Date.parse(upload.upload.expires_at) - Date.now() < DIRECT_URL_MARGIN_MS)
+            upload = await resign(projectId, file, upload, options);
+        upload =
+            upload.upload.kind === 'direct'
+                ? await sendDirect(projectId, file, upload, options)
+                : await sendChunks(projectId, file, upload, options);
+    }
+    options.onProcessing?.();
+    const endpoint = `${path(projectId)}/${encodeURIComponent(upload.attachment_id)}`;
+    try {
+        return await retry(async () => unwrap(await backendApi.post(`${endpoint}/complete`, {}, { ...quiet, signal: options.signal, timeout: COMPLETE_TIMEOUT_MS }), 'Failed to complete attachment upload'), options.signal, true);
+    }
+    catch (error) {
+        if (upload.upload.kind === 'direct' &&
+            error instanceof ApiError &&
+            error.code === 'attachment_not_uploaded')
+            options.onUpload?.({ ...upload, received_bytes: 0 });
+        throw error;
+    }
+}
+export async function deletePromptAttachment(projectId, attachmentId, options = {}) {
+    if (!projectId)
+        throw new Error('A project is required to remove attachments');
+    const response = await backendApi.delete(`${path(projectId)}/${encodeURIComponent(attachmentId)}`, { ...quiet, signal: options.signal });
+    if (!response.success)
+        throw response.error ?? new Error('Failed to remove attachment');
+}

package/dist/core/rest/projects-client/provider-connections.d.ts

@@ -0,0 +1,54 @@
+import type { ProviderOAuthStart } from './secrets.js';
+export interface UserProviderConnection {
+    connection_id: string;
+    provider_id: string;
+    auth_type: 'api_key' | 'device_oauth';
+    created_at: string;
+    updated_at: string;
+    label?: string;
+}
+export interface UserProviderConnectionOptions {
+    create?: boolean;
+    connection_id?: string;
+    label?: string;
+}
+export interface ProjectPersonalProviderSelection {
+    connection_id?: string;
+    pool?: boolean;
+}
+export interface UserProviderConnections {
+    providers: {
+        provider_id: string;
+        name: string;
+        auth_type: 'api_key' | 'device_oauth';
+    }[];
+    items: UserProviderConnection[];
+}
+export type UserProviderOAuthPoll = {
+    status: 'pending';
+} | {
+    status: 'expired';
+} | {
+    status: 'failed';
+    error: string;
+} | {
+    status: 'success';
+    connection: UserProviderConnection;
+};
+export declare function listUserProviderConnections(): Promise<UserProviderConnections>;
+export declare function saveUserProviderApiKey(provider: string, apiKey: string, options?: UserProviderConnectionOptions): Promise<UserProviderConnection>;
+export declare function deleteUserProviderConnection(provider: string, connectionId?: string): Promise<{
+    ok: boolean;
+}>;
+export declare function startUserProviderOAuth(provider: string, options?: UserProviderConnectionOptions): Promise<ProviderOAuthStart>;
+export declare function pollUserProviderOAuth(provider: string, flowId: string): Promise<UserProviderOAuthPoll>;
+export declare function listProjectPersonalProviders(projectId: string): Promise<{
+    items: {
+        provider_id: string;
+        connection_id: string;
+        pool?: boolean;
+    }[];
+}>;
+export declare function setProjectPersonalProvider(projectId: string, provider: string, enabled: boolean, selection?: ProjectPersonalProviderSelection): Promise<{
+    ok: boolean;
+}>;

package/dist/core/rest/projects-client/provider-connections.js

@@ -0,0 +1,28 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+const path = (provider) => `/provider-connections/${encodeURIComponent(provider)}`;
+const bindingsPath = (projectId) => `/projects/${encodeURIComponent(projectId)}/personal-providers`;
+export async function listUserProviderConnections() {
+    return unwrap(await backendApi.get('/provider-connections'));
+}
+export async function saveUserProviderApiKey(provider, apiKey, options = {}) {
+    return unwrap(await backendApi.put(path(provider), { api_key: apiKey, ...options }));
+}
+export async function deleteUserProviderConnection(provider, connectionId) {
+    const target = connectionId
+        ? `${path(provider)}/connections/${encodeURIComponent(connectionId)}`
+        : path(provider);
+    return unwrap(await backendApi.delete(target));
+}
+export async function startUserProviderOAuth(provider, options = {}) {
+    return unwrap(await backendApi.post(`${path(provider)}/start`, options));
+}
+export async function pollUserProviderOAuth(provider, flowId) {
+    return unwrap(await backendApi.post(`${path(provider)}/poll`, { flow_id: flowId }));
+}
+export async function listProjectPersonalProviders(projectId) {
+    return unwrap(await backendApi.get(bindingsPath(projectId)));
+}
+export async function setProjectPersonalProvider(projectId, provider, enabled, selection = {}) {
+    return unwrap(await backendApi.put(`${bindingsPath(projectId)}/${encodeURIComponent(provider)}`, { enabled, ...selection }));
+}

package/dist/core/rest/projects-client/public-session-shares.d.ts

@@ -0,0 +1,49 @@
+export declare class PublicSessionShareError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export interface PublicSessionShareMeta {
+    share: {
+        share_id: string;
+        session_id: string;
+        project_id: string;
+        resource_type: string;
+        label: string;
+        sandbox_status: string | null;
+        expires_at: string | null;
+    };
+    session: {
+        session_id: string;
+        title: string | null;
+        status: string;
+        created_at: string;
+        updated_at: string;
+    };
+}
+export interface PublicSessionTranscriptToolCall {
+    tool: string;
+    status: string | null;
+}
+export interface PublicSessionTranscriptMessage {
+    role: string;
+    created: string | null;
+    completed: string | null;
+    text: string;
+    tools: PublicSessionTranscriptToolCall[];
+    files: Array<{
+        filename: string | null;
+        mime: string | null;
+    }>;
+    reasoning_omitted: boolean;
+}
+export interface PublicSessionTranscript {
+    available: boolean;
+    reason: string | null;
+    source?: 'live' | 'mirror' | 'none';
+    captured_at?: string | null;
+    opencode_session_id: string | null;
+    message_count: number;
+    messages: PublicSessionTranscriptMessage[];
+}
+export declare function getPublicSessionShare(shareId: string): Promise<PublicSessionShareMeta>;
+export declare function getPublicSessionShareMessages(shareId: string): Promise<PublicSessionTranscript>;

package/dist/core/rest/projects-client/public-session-shares.js

@@ -0,0 +1,35 @@
+import { getBackendUrl } from '../../session/server-store/url-helpers.js';
+export class PublicSessionShareError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'PublicSessionShareError';
+    }
+}
+function publicSessionShareUrl(shareId, suffix = '') {
+    return `${getBackendUrl()}/public/session-shares/${encodeURIComponent(shareId)}${suffix}`;
+}
+async function getJson(url) {
+    const res = await fetch(url, { method: 'GET', headers: { Accept: 'application/json' } });
+    const text = await res.text().catch(() => '');
+    let body = null;
+    try {
+        body = text ? JSON.parse(text) : null;
+    }
+    catch {
+    }
+    if (!res.ok) {
+        const message = (body && typeof body === 'object' && 'error' in body && typeof body.error === 'string'
+            ? body.error
+            : null) || res.statusText || `HTTP ${res.status}`;
+        throw new PublicSessionShareError(message, res.status);
+    }
+    return body;
+}
+export async function getPublicSessionShare(shareId) {
+    return getJson(publicSessionShareUrl(shareId));
+}
+export async function getPublicSessionShareMessages(shareId) {
+    return getJson(publicSessionShareUrl(shareId, '/messages'));
+}

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

@@ -0,0 +1,52 @@
+export interface ReferralCodeResponse {
+    referral_code: string;
+    referral_url: string;
+}
+export interface ReferralStats {
+    referral_code: string;
+    total_referrals: number;
+    successful_referrals: number;
+    total_credits_earned: number;
+    last_referral_at: string | null;
+    remaining_earnable_credits: number;
+    max_earnable_credits: number;
+    has_reached_limit: boolean;
+}
+export interface Referral {
+    id: string;
+    referred_account_id: string;
+    credits_awarded: number;
+    status: string;
+    created_at: string;
+    completed_at: string | null;
+}
+export interface ReferralListResponse {
+    referrals: Referral[];
+    total_count: number;
+}
+export interface ValidateReferralCodeResponse {
+    valid: boolean;
+    referrer_id?: string;
+    message?: string;
+}
+export interface ReferralEmailResult {
+    email: string;
+    success: boolean;
+    message?: string;
+}
+export interface ReferralEmailResponse {
+    success: boolean;
+    message?: string;
+    results?: ReferralEmailResult[];
+    success_count?: number;
+    total_count?: number;
+}
+export declare function getReferralCode(): Promise<ReferralCodeResponse>;
+export declare function refreshReferralCode(): Promise<ReferralCodeResponse>;
+export declare function validateReferralCode(_code: string): Promise<ValidateReferralCodeResponse>;
+export declare function getReferralStats(): Promise<ReferralStats>;
+export declare function listReferrals(_options?: {
+    limit?: number;
+    offset?: number;
+}): Promise<ReferralListResponse>;
+export declare function sendReferralEmails(_emails: string[]): Promise<ReferralEmailResponse>;

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

@@ -0,0 +1,19 @@
+import { retiredEndpointError } from '../../http/api/errors.js';
+export async function getReferralCode() {
+    throw retiredEndpointError('getReferralCode');
+}
+export async function refreshReferralCode() {
+    throw retiredEndpointError('refreshReferralCode');
+}
+export async function validateReferralCode(_code) {
+    throw retiredEndpointError('validateReferralCode');
+}
+export async function getReferralStats() {
+    throw retiredEndpointError('getReferralStats');
+}
+export async function listReferrals(_options = {}) {
+    throw retiredEndpointError('listReferrals');
+}
+export async function sendReferralEmails(_emails) {
+    throw retiredEndpointError('sendReferralEmails');
+}

package/dist/core/rest/projects-client/review-items.d.ts

@@ -0,0 +1,139 @@
+import type { ApiReviewItem, ReviewItemRisk, ReviewItemSource, ReviewItemStatus, ReviewSegment, ReviewVerdict } from './review.js';
+export interface ReviewRequestedChange {
+    text: string;
+    by?: string;
+    at?: string;
+}
+export interface ReviewChangeDetail {
+    crId?: string;
+    number?: number;
+    whatChanged: string[];
+    impact: string;
+    verification: {
+        label: string;
+        tone: 'success' | 'warning' | 'neutral' | 'info';
+    }[];
+    previewUrl?: string;
+    conflicts?: string[];
+    requestedChanges?: ReviewRequestedChange[];
+    advanced: {
+        headRef: string;
+        baseRef: string;
+        headSha: string;
+        baseSha: string;
+        additions: number;
+        deletions: number;
+        files: {
+            path: string;
+            status: 'added' | 'modified' | 'deleted';
+            additions: number;
+            deletions: number;
+        }[];
+        mergeMode: string;
+    };
+}
+export type ReviewApprovalActionIcon = 'email' | 'charge' | 'command' | 'data' | 'generic';
+export interface ReviewApprovalAction {
+    id: string;
+    title: string;
+    connector: string;
+    action: string;
+    consequence: string;
+    risk: ReviewItemRisk;
+    icon: ReviewApprovalActionIcon;
+    argsPreview: {
+        key: string;
+        value: string;
+    }[];
+    actionPath?: string;
+    rawArgsPreview?: Record<string, unknown>;
+    reviewComplete?: boolean;
+    previewAuthorized?: boolean;
+    approvalContext?: string;
+    connectorRisk?: string | null;
+    policySource: string;
+    decided?: 'approved' | 'denied';
+}
+export interface ReviewApprovalDetail {
+    actions: ReviewApprovalAction[];
+}
+export interface ReviewOutputDetail {
+    artifactKind: 'page' | 'document' | 'api_result' | 'image' | 'data';
+    artifactLabel: string;
+    previewUrl?: string;
+    preview?: string;
+    files?: {
+        path: string;
+        note?: string;
+    }[];
+    note: string;
+}
+export interface ReviewDecisionOption {
+    id: string;
+    label: string;
+    description?: string;
+    recommended?: boolean;
+}
+export interface ReviewDecisionDetail {
+    question: string;
+    context?: string;
+    options: ReviewDecisionOption[];
+}
+export interface ReviewBatchChild {
+    id: string;
+    title: string;
+    status: 'done' | 'needs_review';
+}
+export interface ReviewBatchDetail {
+    note: string;
+    children: ReviewBatchChild[];
+}
+interface ReviewItemBase {
+    id: string;
+    title: string;
+    summary: string;
+    risk: ReviewItemRisk;
+    status: ReviewItemStatus;
+    source: ReviewItemSource;
+    agent: string;
+    createdAt: string;
+    sessionId?: string;
+}
+export type ReviewItem = (ReviewItemBase & {
+    kind: 'change';
+    detail: ReviewChangeDetail;
+}) | (ReviewItemBase & {
+    kind: 'approval';
+    detail: ReviewApprovalDetail;
+}) | (ReviewItemBase & {
+    kind: 'output';
+    detail: ReviewOutputDetail;
+}) | (ReviewItemBase & {
+    kind: 'decision';
+    detail: ReviewDecisionDetail;
+}) | (ReviewItemBase & {
+    kind: 'batch';
+    detail: ReviewBatchDetail;
+});
+export interface MapApiReviewItemOptions {
+    sessionLabels?: Record<string, string>;
+}
+export type ReviewItemTarget = {
+    type: 'review_item';
+    reviewItemId: string;
+} | {
+    type: 'change_request';
+    changeRequestId: string;
+} | {
+    type: 'connector_call';
+    executionId: string;
+};
+export declare function reviewItemTarget(id: string): ReviewItemTarget;
+export declare function reviewSegmentForStatus(status: ReviewItemStatus): ReviewSegment;
+export declare function countReviewItemsBySegment(items: Iterable<{
+    status: ReviewItemStatus;
+}>): Record<ReviewSegment, number>;
+export declare function reviewVerdictForStatus(status: ReviewItemStatus): ReviewVerdict | null;
+export declare function humanizeReviewActionPath(path: string): string;
+export declare function mapApiReviewItem(row: ApiReviewItem, options?: MapApiReviewItemOptions): ReviewItem;
+export {};