@beeuni/sdk 0.1.0

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

@@ -0,0 +1,92 @@
+import { platformConfig } from '../../http/config.js';
+import { stripTrailingSlashes } from '../../../platform/strings.js';
+import { platformApiBase } from './shared.js';
+export class HeadlessAuthError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'HeadlessAuthError';
+    }
+}
+async function call(path, init, opts) {
+    const fetchImpl = opts?.fetch ?? platformConfig().fetch ?? ((input, i) => fetch(input, i));
+    const raw = stripTrailingSlashes(opts?.backendUrl ?? platformConfig().backendUrl ?? '');
+    if (!raw)
+        throw new HeadlessAuthError('not_configured', 'backendUrl is not configured (configureBeeuni / createBeeuni first)', 0);
+    const headers = { accept: 'application/json' };
+    if (init.body !== undefined)
+        headers['content-type'] = 'application/json';
+    if (init.bearer)
+        headers.authorization = `Bearer ${init.bearer}`;
+    const res = await fetchImpl(`${platformApiBase(raw)}${path}`, {
+        method: init.method ?? (init.body !== undefined ? 'POST' : 'GET'),
+        headers,
+        ...(init.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
+        ...(opts?.signal ? { signal: opts.signal } : {}),
+    });
+    const text = await res.text().catch(() => '');
+    let body = null;
+    try {
+        body = text ? JSON.parse(text) : null;
+    }
+    catch {
+        body = text;
+    }
+    if (!res.ok) {
+        const r = (body && typeof body === 'object' ? body : {});
+        throw new HeadlessAuthError(typeof r.error === 'string' ? r.error : 'auth_error', typeof r.error_description === 'string' && r.error_description
+            ? r.error_description
+            : typeof r.error === 'string'
+                ? r.error
+                : res.statusText || `HTTP ${res.status}`, res.status);
+    }
+    return body;
+}
+export function signUp(input, opts) {
+    return call('/auth/signup', { body: input }, opts);
+}
+export function signInWithPassword(input, opts) {
+    return call('/auth/sign-in/password', { body: input }, opts);
+}
+export function sendMagicLink(input, opts) {
+    return call('/auth/sign-in/magic-link', { body: input }, opts);
+}
+export function verifyOtp(input, opts) {
+    return call('/auth/verify-otp', { body: input }, opts);
+}
+export function signInWithProvider(input, opts) {
+    return call('/auth/sign-in/oauth', { body: input }, opts);
+}
+export function exchangeCode(input, opts) {
+    return call('/auth/oauth/exchange', { body: input }, opts);
+}
+export function refreshSession(input, opts) {
+    return call('/auth/refresh', { body: input }, opts);
+}
+export function resetPassword(input, opts) {
+    return call('/auth/password/reset', { body: input }, opts);
+}
+export function updatePassword(input, accessToken, opts) {
+    return call('/auth/password/update', { body: input, bearer: accessToken }, opts);
+}
+export function authUser(accessToken, opts) {
+    return call('/auth/user', { bearer: accessToken }, opts);
+}
+export function updateUserMetadata(input, accessToken, opts) {
+    return call('/auth/user', { method: 'PATCH', body: input, bearer: accessToken }, opts);
+}
+export function signInWithSso(input, opts) {
+    return call('/auth/sign-in/sso', { body: input }, opts);
+}
+export const authMfa = {
+    enroll: (input, accessToken, opts) => call('/auth/mfa/factors', { body: input, bearer: accessToken }, opts),
+    challenge: (factorId, input = {}, accessToken, opts) => call(`/auth/mfa/factors/${encodeURIComponent(factorId)}/challenge`, { body: input, bearer: accessToken }, opts),
+    verify: (factorId, input, accessToken, opts) => call(`/auth/mfa/factors/${encodeURIComponent(factorId)}/verify`, { body: input, bearer: accessToken }, opts),
+    unenroll: (factorId, accessToken, opts) => call(`/auth/mfa/factors/${encodeURIComponent(factorId)}`, { method: 'DELETE', bearer: accessToken }, opts),
+};
+export function signOut(accessToken, input = {}, opts) {
+    return call('/auth/sign-out', { body: input, bearer: accessToken }, opts);
+}

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

@@ -0,0 +1,18 @@
+export interface BackupInfo {
+    id: string;
+    description: string;
+    created: string;
+    size: number;
+    status: string;
+}
+export interface BackupListResponse {
+    backups: BackupInfo[];
+    backups_enabled: boolean;
+}
+export declare function listBackups(sandboxId: string): Promise<BackupListResponse>;
+export declare function createBackup(sandboxId: string, description?: string): Promise<{
+    backup_id: string;
+    status: string;
+}>;
+export declare function restoreBackup(sandboxId: string, backupId: string): Promise<void>;
+export declare function deleteBackup(sandboxId: string, backupId: string): Promise<void>;

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

@@ -0,0 +1,12 @@
+export async function listBackups(sandboxId) {
+    throw new Error('Backups are not exposed for project-session sandboxes');
+}
+export async function createBackup(sandboxId, description) {
+    throw new Error('Backups are not exposed for project-session sandboxes');
+}
+export async function restoreBackup(sandboxId, backupId) {
+    throw new Error('Backups are not exposed for project-session sandboxes');
+}
+export async function deleteBackup(sandboxId, backupId) {
+    throw new Error('Backups are not exposed for project-session sandboxes');
+}

package/dist/core/rest/platform-client/connector-setup.d.ts

@@ -0,0 +1,35 @@
+import type { ConnectorSetupLinkInfo, ConnectorSetupLinkFinalize, ConnectorSetupLinkStart } from './host-boundary.js';
+export interface LinkInfoStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export declare function createConnectorLinkInfoCache(fetchInfo: (token: string) => Promise<ConnectorSetupLinkInfo>, { storage }?: {
+    storage?: LinkInfoStorage | null;
+}): {
+    peek(token: string): ConnectorSetupLinkInfo | undefined;
+    load(token: string): Promise<ConnectorSetupLinkInfo>;
+};
+export type ConnectorStartOutcome = {
+    kind: 'popup';
+    url: string;
+} | {
+    kind: 'connected';
+    alreadyConnected: boolean;
+    connectedAs: string | null;
+} | {
+    kind: 'error';
+    message: string;
+};
+export declare function resolveConnectorStart(input: {
+    start: () => Promise<ConnectorSetupLinkStart>;
+    finalize: () => Promise<ConnectorSetupLinkFinalize>;
+}): Promise<ConnectorStartOutcome>;
+export declare const CONNECTOR_POLL_FIRST_DELAY_MS = 3000;
+export declare const CONNECTOR_POLL_INTERVAL_MS = 5000;
+export declare const CONNECTOR_POLL_WINDOW_MS: number;
+export declare function nextConnectorPollDelay(attempt: number, elapsedMs: number): number | null;
+export declare function connectorHeadline(info: ConnectorSetupLinkInfo): {
+    app: string;
+    project: string | null;
+};

package/dist/core/rest/platform-client/connector-setup.js

@@ -0,0 +1,105 @@
+const STORAGE_PREFIX = 'beeuni:connect-link:';
+function storageKey(token) {
+    let a = 0x811c9dc5;
+    let b = 0x01000193 ^ token.length;
+    for (let i = 0; i < token.length; i += 1) {
+        const c = token.charCodeAt(i);
+        a = Math.imul(a ^ c, 0x01000193) >>> 0;
+        b = Math.imul(b ^ c, 0x5bd1e995) >>> 0;
+    }
+    return `${STORAGE_PREFIX}${a.toString(36)}${b.toString(36)}`;
+}
+export function createConnectorLinkInfoCache(fetchInfo, { storage } = {}) {
+    const requests = new Map();
+    const settled = new Map();
+    const readStored = (token) => {
+        if (!storage)
+            return undefined;
+        try {
+            const raw = storage.getItem(storageKey(token));
+            if (!raw)
+                return undefined;
+            const value = JSON.parse(raw);
+            if (Date.parse(value.expires_at) <= Date.now()) {
+                storage.removeItem(storageKey(token));
+                return undefined;
+            }
+            return value;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const writeStored = (token, value) => {
+        if (!storage)
+            return;
+        try {
+            storage.setItem(storageKey(token), JSON.stringify(value));
+        }
+        catch {
+        }
+    };
+    return {
+        peek(token) {
+            const inMemory = settled.get(token);
+            if (inMemory)
+                return inMemory;
+            const stored = readStored(token);
+            if (stored)
+                settled.set(token, stored);
+            return stored;
+        },
+        load(token) {
+            const pending = requests.get(token);
+            if (pending)
+                return pending;
+            const request = fetchInfo(token).then((value) => {
+                settled.set(token, value);
+                writeStored(token, value);
+                return value;
+            }, (cause) => {
+                requests.delete(token);
+                throw cause;
+            });
+            requests.set(token, request);
+            return request;
+        },
+    };
+}
+const START_FAILED = 'Could not start the connect flow.';
+export async function resolveConnectorStart(input) {
+    let started;
+    try {
+        started = await input.start();
+    }
+    catch (cause) {
+        return { kind: 'error', message: cause instanceof Error ? cause.message : START_FAILED };
+    }
+    if (started.connect_url)
+        return { kind: 'popup', url: started.connect_url };
+    if (!started.connected)
+        return { kind: 'error', message: START_FAILED };
+    let connectedAs = null;
+    try {
+        connectedAs = (await input.finalize()).connected_as ?? null;
+    }
+    catch {
+    }
+    return { kind: 'connected', alreadyConnected: started.already_connected === true, connectedAs };
+}
+export const CONNECTOR_POLL_FIRST_DELAY_MS = 3_000;
+export const CONNECTOR_POLL_INTERVAL_MS = 5_000;
+export const CONNECTOR_POLL_WINDOW_MS = 5 * 60_000;
+export function nextConnectorPollDelay(attempt, elapsedMs) {
+    const delay = attempt === 0 ? CONNECTOR_POLL_FIRST_DELAY_MS : CONNECTOR_POLL_INTERVAL_MS;
+    if (elapsedMs + delay > CONNECTOR_POLL_WINDOW_MS)
+        return null;
+    return delay;
+}
+export function connectorHeadline(info) {
+    const project = info.project_name?.trim();
+    return {
+        app: info.name?.trim() || info.app?.trim() || info.slug,
+        project: project && project !== 'this project' ? project : null,
+    };
+}

package/dist/core/rest/platform-client/github-app.d.ts

@@ -0,0 +1,45 @@
+export interface GitHubAppStatus {
+    configured: boolean;
+    owner: string | null;
+    slug: string | null;
+    installation_id: string | null;
+    source: 'db' | 'env' | 'pat' | 'none';
+    oauth_configured: boolean;
+    identity_source: 'env' | 'db' | 'none';
+    backend_source: 'env' | 'db' | 'none';
+    mutable: boolean;
+    install_url: string | null;
+    env_owned_by: string[];
+}
+export declare function getGitHubAppStatus(): Promise<GitHubAppStatus>;
+export interface GitHubAppManifestStartInput {
+    org?: string;
+}
+export interface GitHubAppManifestStart {
+    github_create_url: string;
+    manifest: Record<string, unknown>;
+    state: string;
+}
+export declare function startGitHubAppManifest(input?: GitHubAppManifestStartInput): Promise<GitHubAppManifestStart>;
+export interface GitHubAppExistingInput {
+    appId: string;
+    privateKey: string;
+    installationId: string;
+    slug?: string;
+    clientId?: string;
+    clientSecret?: string;
+}
+export declare function setGitHubAppFromExisting(input: GitHubAppExistingInput): Promise<{
+    ok: true;
+    owner: string;
+}>;
+export interface GitHubAppPatInput {
+    token: string;
+    owner: string;
+}
+export declare function setGitHubAppPat(input: GitHubAppPatInput): Promise<{
+    ok: true;
+}>;
+export declare function disconnectGitHubApp(): Promise<{
+    ok: true;
+}>;

package/dist/core/rest/platform-client/github-app.js

@@ -0,0 +1,54 @@
+import { backendApi } from '../../http/api-client.js';
+export async function getGitHubAppStatus() {
+    const response = await backendApi.get('/platform/github-app/status', {
+        showErrors: false,
+    });
+    if (response.error)
+        throw response.error;
+    if (!response.data)
+        throw new Error('GitHub App status request failed');
+    return response.data;
+}
+export async function startGitHubAppManifest(input = {}) {
+    const response = await backendApi.post('/platform/github-app/manifest-start', input, { showErrors: false });
+    if (response.error)
+        throw response.error;
+    if (!response.data)
+        throw new Error('GitHub App manifest-start request failed');
+    return response.data;
+}
+export async function setGitHubAppFromExisting(input) {
+    const response = await backendApi.post('/platform/github-app/app', {
+        app_id: input.appId,
+        private_key: input.privateKey,
+        installation_id: input.installationId,
+        slug: input.slug,
+        client_id: input.clientId,
+        client_secret: input.clientSecret,
+    }, { showErrors: false });
+    if (response.error)
+        throw response.error;
+    if (!response.data)
+        throw new Error('GitHub App configuration request failed');
+    return response.data;
+}
+export async function setGitHubAppPat(input) {
+    const response = await backendApi.post('/platform/github-app/pat', input, {
+        showErrors: false,
+    });
+    if (response.error)
+        throw response.error;
+    if (!response.data)
+        throw new Error('GitHub token configuration request failed');
+    return response.data;
+}
+export async function disconnectGitHubApp() {
+    const response = await backendApi.delete('/platform/github-app', {
+        showErrors: false,
+    });
+    if (response.error)
+        throw response.error;
+    if (!response.data)
+        throw new Error('GitHub App disconnect request failed');
+    return response.data;
+}

package/dist/core/rest/platform-client/host-boundary.d.ts

@@ -0,0 +1,140 @@
+import { auditFilterQuery } from '../projects-client/audit-filter.js';
+export interface HostRequestOptions {
+    backendUrl: string;
+    accessToken?: string | null;
+    signal?: AbortSignal;
+    cache?: RequestCache;
+    next?: {
+        revalidate?: number | false;
+        tags?: string[];
+    };
+    headers?: HeadersInit;
+}
+export declare class HostBoundaryError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface PublicMarketplaceQuery {
+    query?: string;
+    type?: string;
+    source?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare function listPublicMarketplaceItems<T = {
+    items: unknown[];
+    total?: number;
+    hasMore?: boolean;
+    loading?: boolean;
+    pending?: number;
+    sources?: unknown[];
+}>(options: HostRequestOptions, query?: PublicMarketplaceQuery): Promise<T>;
+export declare function listPublicMarketplaces<T = {
+    marketplaces: unknown[];
+    loading?: boolean;
+    pending?: number;
+    sources?: unknown[];
+}>(options: HostRequestOptions): Promise<T>;
+export declare function getPublicMarketplaceItem<T = Record<string, unknown>>(id: string, options: HostRequestOptions): Promise<T>;
+export declare function getPublicMarketplaceItemFile<T = Record<string, unknown>>(id: string, path: string, options: HostRequestOptions): Promise<T>;
+export declare function checkAccessEmail<T = Record<string, unknown>>(email: string, options: HostRequestOptions): Promise<T>;
+export declare function submitAccessRequest(input: {
+    email: string;
+    company?: string;
+    useCase?: string;
+}, options: HostRequestOptions): Promise<unknown>;
+export declare function recordPlatformLogout(options: HostRequestOptions): Promise<unknown>;
+export interface OAuthConsentRequest {
+    client_id?: string;
+    client_name?: string;
+    client_type?: 'confidential' | 'public' | string;
+    scopes?: unknown[];
+    scope?: string;
+    remembered?: boolean;
+    self_registered?: boolean;
+    redirect_to?: string;
+}
+export declare function getOAuthConsentRequest(requestId: string, options: HostRequestOptions): Promise<OAuthConsentRequest>;
+export declare function submitOAuthConsent(input: {
+    requestId: string;
+    approved: boolean;
+}, options: HostRequestOptions): Promise<{
+    redirect_uri?: string;
+}>;
+export interface ConnectorSetupLinkInfo {
+    project_id?: string;
+    project_name: string;
+    label?: string | null;
+    owner?: 'me' | 'project';
+    slug: string;
+    app: string | null;
+    name?: string | null;
+    icon_url?: string | null;
+    connected?: boolean;
+    expires_at: string;
+}
+export declare function getConnectorSetupLink(token: string, options: HostRequestOptions): Promise<ConnectorSetupLinkInfo>;
+export interface ConnectorSetupLinkStart {
+    connect_url: string | null;
+    connected?: boolean;
+    already_connected?: boolean;
+}
+export interface ConnectorSetupLinkFinalize {
+    connected: boolean;
+    connected_as?: string | null;
+    connection_id?: string;
+    label?: string;
+}
+export interface FinalizeConnectorSetupLinkInput {
+    connectionId?: string;
+}
+export declare function startConnectorSetupLink(token: string, options: HostRequestOptions): Promise<ConnectorSetupLinkStart>;
+export declare function finalizeConnectorSetupLink(token: string, options: HostRequestOptions, input?: FinalizeConnectorSetupLinkInput): Promise<ConnectorSetupLinkFinalize>;
+export interface SecretSetupLinkInfo {
+    project_name: string;
+    fields: Array<{
+        name: string;
+        label: string | null;
+        description: string | null;
+    }>;
+    expires_at: string;
+    requester?: {
+        label: string | null;
+    } | null;
+}
+export declare function getSecretSetupLink(token: string, options: HostRequestOptions): Promise<SecretSetupLinkInfo>;
+export type SecretWithheldReason = 'agent_grant' | 'session_allowlist';
+export interface SecretSetupLinkWithheld {
+    name: string;
+    reason: SecretWithheldReason;
+}
+export interface SecretSetupLinkSubmitResult {
+    ok: boolean;
+    saved: string[];
+    agent?: string;
+    withheld?: SecretSetupLinkWithheld[];
+}
+export declare function submitSecretSetupLink(token: string, values: Record<string, string>, options: HostRequestOptions, audience?: {
+    only_requester?: boolean;
+}): Promise<SecretSetupLinkSubmitResult>;
+export declare function getPublicShareByToken<T = Record<string, unknown>>(token: string, options: HostRequestOptions): Promise<T>;
+export declare function startSessionWithToken(projectId: string, sessionId: string, options: HostRequestOptions): Promise<unknown>;
+export declare function getMaintenanceConfig<T>(options: HostRequestOptions): Promise<T>;
+export declare function setMaintenanceConfig<T>(config: T, options: HostRequestOptions): Promise<T>;
+export declare function getUserRolesWithToken<T = unknown[]>(options: HostRequestOptions): Promise<T>;
+export declare function submitDemoRequest(input: Record<string, unknown>, options: HostRequestOptions): Promise<unknown>;
+export interface AccountAuditExport {
+    blob: Blob;
+    filename: string | null;
+    capped: boolean;
+    rowCount: string | null;
+    complete?: boolean;
+    nextCursor?: string | null;
+}
+export declare function downloadAccountAudit(accountId: string, query: Parameters<typeof auditFilterQuery>[0] & {
+    format: 'csv' | 'jsonl';
+}, options: HostRequestOptions): Promise<AccountAuditExport>;
+export declare function openStressTestStream(_input: Record<string, unknown>, _options: HostRequestOptions): Promise<ReadableStream<Uint8Array>>;
+export declare function buildPublicTemplateUrl(_backendUrl: string, _shareId: string): URL | null;
+export declare function getPublicTemplate<T>(_backendUrl: string, _shareId: string, _signal?: AbortSignal): Promise<T>;