@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/review-items.js

@@ -0,0 +1,217 @@
+const CHANGE_REQUEST_ID_PREFIX = 'cr:';
+const CONNECTOR_CALL_ID_PREFIX = 'call:';
+export function reviewItemTarget(id) {
+    if (id.startsWith(CHANGE_REQUEST_ID_PREFIX) && id.length > CHANGE_REQUEST_ID_PREFIX.length) {
+        return { type: 'change_request', changeRequestId: id.slice(CHANGE_REQUEST_ID_PREFIX.length) };
+    }
+    if (id.startsWith(CONNECTOR_CALL_ID_PREFIX) && id.length > CONNECTOR_CALL_ID_PREFIX.length) {
+        return { type: 'connector_call', executionId: id.slice(CONNECTOR_CALL_ID_PREFIX.length) };
+    }
+    return { type: 'review_item', reviewItemId: id };
+}
+export function reviewSegmentForStatus(status) {
+    if (status === 'needs_you')
+        return 'needs_you';
+    if (status === 'waiting')
+        return 'waiting';
+    return 'done';
+}
+export function countReviewItemsBySegment(items) {
+    const counts = { needs_you: 0, waiting: 0, done: 0 };
+    for (const item of items)
+        counts[reviewSegmentForStatus(item.status)] += 1;
+    return counts;
+}
+export function reviewVerdictForStatus(status) {
+    switch (status) {
+        case 'approved':
+            return 'approve';
+        case 'rejected':
+            return 'reject';
+        case 'changes_requested':
+            return 'changes';
+        case 'done':
+            return 'answer';
+        case 'dismissed':
+            return 'dismiss';
+        default:
+            return null;
+    }
+}
+function titleCase(slug) {
+    return slug
+        .split(/[._-]/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+export function humanizeReviewActionPath(path) {
+    const dot = path.indexOf('.');
+    if (dot <= 0)
+        return titleCase(path);
+    return `(${titleCase(path.slice(0, dot))}) ${titleCase(path.slice(dot + 1))}`;
+}
+function splitActionPath(path) {
+    const dot = path.indexOf('.');
+    return dot > 0
+        ? { connector: path.slice(0, dot), action: path.slice(dot + 1) }
+        : { connector: path, action: '' };
+}
+const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const asString = (value) => typeof value === 'string' && value ? value : undefined;
+const asArray = (value) => Array.isArray(value) ? value : undefined;
+const asNumber = (value) => (typeof value === 'number' ? value : 0);
+const nonEmptyLines = (text) => text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+function changeDetail(detail, row) {
+    const advanced = asRecord(detail.advanced);
+    const description = asString(detail.description);
+    const whatChanged = asArray(detail.whatChanged) ??
+        (description ? nonEmptyLines(description) : row.summary ? [row.summary] : []);
+    return {
+        crId: asString(detail.cr_id),
+        number: typeof detail.number === 'number' ? detail.number : undefined,
+        whatChanged,
+        impact: asString(detail.impact) ?? '',
+        verification: asArray(detail.verification) ?? [],
+        previewUrl: asString(detail.previewUrl) ?? asString(detail.preview_url),
+        conflicts: asArray(detail.conflicts),
+        requestedChanges: asArray(detail.requested_changes) ?? [],
+        advanced: {
+            headRef: asString(advanced.headRef) ?? asString(detail.head_ref) ?? '',
+            baseRef: asString(advanced.baseRef) ?? asString(detail.base_ref) ?? '',
+            headSha: asString(advanced.headSha) ??
+                asString(detail.head_sha) ??
+                asString(detail.head_commit_sha) ??
+                '',
+            baseSha: asString(advanced.baseSha) ?? asString(detail.base_sha) ?? '',
+            additions: asNumber(advanced.additions),
+            deletions: asNumber(advanced.deletions),
+            files: asArray(advanced.files) ?? [],
+            mergeMode: asString(advanced.mergeMode) ?? 'merge',
+        },
+    };
+}
+function approvalDetail(detail, row) {
+    const given = asArray(detail.actions);
+    if (given) {
+        return {
+            actions: given.map((action, index) => ({
+                id: asString(action.id) ?? `${row.review_item_id}-${index}`,
+                title: asString(action.title) ?? 'Action',
+                connector: asString(action.connector) ?? '',
+                action: asString(action.action) ?? '',
+                consequence: asString(action.consequence) ?? '',
+                risk: asString(action.risk) ?? row.risk,
+                icon: asString(action.icon) ?? 'generic',
+                argsPreview: asArray(action.argsPreview) ?? [],
+                policySource: asString(action.policySource) ?? 'Requires approval',
+                decided: action.decided === 'approved' || action.decided === 'denied' ? action.decided : undefined,
+            })),
+        };
+    }
+    const path = asString(detail.action_path) ?? '';
+    const { connector, action } = splitActionPath(path);
+    const rawArgsPreview = asRecord(detail.args_preview);
+    const hasArgsPreview = Object.keys(rawArgsPreview).length > 0;
+    return {
+        actions: [
+            {
+                id: asString(detail.execution_id) ?? row.review_item_id,
+                title: path ? humanizeReviewActionPath(path) : row.title || 'Run action',
+                connector,
+                action,
+                consequence: 'Runs against the real connector once you approve',
+                risk: row.risk,
+                icon: 'generic',
+                argsPreview: Object.entries(rawArgsPreview).map(([key, value]) => ({
+                    key,
+                    value: value === '[redacted]'
+                        ? 'Hidden credential'
+                        : typeof value === 'string'
+                            ? value
+                            : JSON.stringify(value, null, 2),
+                })),
+                actionPath: path,
+                rawArgsPreview: hasArgsPreview ? rawArgsPreview : undefined,
+                reviewComplete: detail.args_preview_complete === true,
+                previewAuthorized: detail.args_preview_authorized !== false,
+                approvalContext: asString(detail.approval_context),
+                connectorRisk: asString(detail.risk) ?? null,
+                policySource: 'Requires approval',
+            },
+        ],
+    };
+}
+function outputDetail(detail, row) {
+    return {
+        artifactKind: asString(detail.artifactKind) ??
+            'document',
+        artifactLabel: asString(detail.artifactLabel) ?? 'Output',
+        previewUrl: asString(detail.previewUrl) ?? asString(detail.preview_url),
+        preview: asString(detail.preview),
+        files: asArray(detail.files),
+        note: asString(detail.note) ?? row.summary ?? '',
+    };
+}
+function decisionDetail(detail, row) {
+    return {
+        question: asString(detail.question) ?? row.title ?? '',
+        context: asString(detail.context),
+        options: asArray(detail.options) ?? [],
+    };
+}
+function batchDetail(detail, row) {
+    return {
+        note: asString(detail.note) ?? row.summary ?? '',
+        children: asArray(detail.children) ?? [],
+    };
+}
+function normalizeDetail(row) {
+    const detail = asRecord(row.detail);
+    switch (row.kind) {
+        case 'change':
+            return changeDetail(detail, row);
+        case 'approval':
+            return approvalDetail(detail, row);
+        case 'output':
+            return outputDetail(detail, row);
+        case 'decision':
+            return decisionDetail(detail, row);
+        case 'batch':
+            return batchDetail(detail, row);
+    }
+}
+function changeSummary(detail, fallback) {
+    const number = typeof detail.number === 'number' ? detail.number : undefined;
+    const base = asString(detail.base_ref);
+    if (number != null && base)
+        return `#${number} → ${base}`;
+    return fallback;
+}
+export function mapApiReviewItem(row, options = {}) {
+    const detail = asRecord(row.detail);
+    const sessionId = row.origin_session_id ?? undefined;
+    const sessionLabel = sessionId ? options.sessionLabels?.[sessionId] : undefined;
+    const actionPath = row.kind === 'approval' ? asString(detail.action_path) : undefined;
+    const summary = row.kind === 'change'
+        ? changeSummary(detail, row.summary)
+        : row.kind === 'approval'
+            ? (sessionLabel ?? (sessionId ? 'From a running session' : row.summary))
+            : row.summary;
+    return {
+        id: row.review_item_id,
+        kind: row.kind,
+        title: actionPath ? humanizeReviewActionPath(actionPath) : row.title,
+        summary,
+        risk: row.risk,
+        status: row.status,
+        source: row.source,
+        agent: row.agent || 'Agent',
+        createdAt: row.created_at,
+        sessionId,
+        detail: normalizeDetail(row),
+    };
+}

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

@@ -0,0 +1,56 @@
+export type ReviewItemKind = 'change' | 'approval' | 'output' | 'decision' | 'batch';
+export type ReviewItemStatus = 'needs_you' | 'waiting' | 'approved' | 'changes_requested' | 'rejected' | 'done' | 'dismissed';
+export type ReviewItemRisk = 'none' | 'low' | 'medium' | 'high';
+export type ReviewItemSource = 'web' | 'slack' | 'agent';
+export type ReviewVerdict = 'approve' | 'reject' | 'changes' | 'answer' | 'dismiss';
+export type ReviewSegment = 'needs_you' | 'waiting' | 'done';
+export interface ApiReviewItem {
+    review_item_id: string;
+    account_id: string;
+    project_id: string;
+    origin_session_id: string | null;
+    kind: ReviewItemKind;
+    status: ReviewItemStatus;
+    risk: ReviewItemRisk;
+    source: ReviewItemSource;
+    title: string;
+    summary: string;
+    detail: Record<string, unknown>;
+    agent: string;
+    created_by: string;
+    acted_by: string | null;
+    acted_at: string | null;
+    feedback: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export declare function listReviewItems(projectId: string, params?: {
+    segment?: ReviewSegment;
+    kind?: ReviewItemKind;
+}): Promise<{
+    review_items: ApiReviewItem[];
+}>;
+export declare function getReviewItem(projectId: string, reviewItemId: string): Promise<{
+    review_item: ApiReviewItem;
+}>;
+export declare function submitReviewItem(projectId: string, input: {
+    kind: 'output' | 'decision' | 'batch';
+    title: string;
+    summary?: string;
+    risk?: ReviewItemRisk;
+    detail?: Record<string, unknown>;
+    agent?: string;
+    session_id?: string;
+}): Promise<ApiReviewItem>;
+export declare function actReviewItem(projectId: string, reviewItemId: string, input: {
+    verdict: ReviewVerdict;
+    feedback?: string;
+}): Promise<ApiReviewItem>;
+export declare function bulkActReviewItems(projectId: string, input: {
+    ids: string[];
+    verdict: ReviewVerdict;
+}): Promise<{
+    updated: number;
+    review_items: ApiReviewItem[];
+}>;

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

@@ -0,0 +1,23 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listReviewItems(projectId, params) {
+    const q = new URLSearchParams();
+    if (params?.segment)
+        q.set('segment', params.segment);
+    if (params?.kind)
+        q.set('kind', params.kind);
+    const qs = q.toString();
+    return unwrap(await backendApi.get(`/projects/${projectId}/review/items${qs ? `?${qs}` : ''}`, { showErrors: false }));
+}
+export async function getReviewItem(projectId, reviewItemId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/review/items/${reviewItemId}`));
+}
+export async function submitReviewItem(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/review/items`, input));
+}
+export async function actReviewItem(projectId, reviewItemId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/review/items/${reviewItemId}/act`, input));
+}
+export async function bulkActReviewItems(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/review/bulk`, input));
+}

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

@@ -0,0 +1,21 @@
+export interface PublicSandboxShare {
+    url: string;
+    port: number;
+    token: string;
+    expiresAt: string;
+    label?: string;
+}
+export interface CreateSandboxShareInput {
+    sandboxId: string;
+    port: number;
+    ttl?: string;
+    label?: string;
+}
+export interface CreateSandboxShareResponse {
+    url: string;
+    expiresAt?: string;
+    label?: string;
+}
+export declare function listSandboxShares(sandboxId: string): Promise<PublicSandboxShare[]>;
+export declare function createSandboxShare(input: CreateSandboxShareInput): Promise<CreateSandboxShareResponse>;
+export declare function revokeSandboxShare(sandboxId: string, token: string): Promise<void>;

package/dist/core/rest/projects-client/sandbox-shares.js

@@ -0,0 +1,19 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listSandboxShares(sandboxId) {
+    const data = unwrap(await backendApi.get(`/p/share?sandbox_id=${encodeURIComponent(sandboxId)}`), 'Failed to load public links');
+    return data.shares ?? [];
+}
+export async function createSandboxShare(input) {
+    return unwrap(await backendApi.post('/p/share', {
+        sandbox_id: input.sandboxId,
+        port: input.port,
+        ttl: input.ttl,
+        label: input.label,
+    }), 'Failed to generate public URL');
+}
+export async function revokeSandboxShare(sandboxId, token) {
+    const res = await backendApi.delete(`/p/share/${encodeURIComponent(token)}?sandbox_id=${encodeURIComponent(sandboxId)}`);
+    if (!res.success)
+        throw new Error(res.error?.message ?? 'Failed to revoke public link');
+}

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

@@ -0,0 +1,144 @@
+export type ProjectSnapshotStatus = 'building' | 'ready' | 'failed';
+export type SnapshotErrorCategory = 'quota' | 'dockerfile' | 'layer' | 'tunnel' | 'provider' | 'timeout' | 'runtime' | 'git' | 'unknown';
+export interface SandboxTemplate {
+    template_id: string | null;
+    slug: string;
+    name: string;
+    is_default: boolean;
+    source: 'platform' | 'toml' | 'ui';
+    provider: string;
+    has_dockerfile: boolean;
+    has_image: boolean;
+    image: string | null;
+    dockerfile_path: string | null;
+    entrypoint: string | null;
+    cpu: number;
+    memory_gb: number;
+    disk_gb: number;
+    snapshot_name: string;
+    content_hash: string;
+    built_from_commit: string | null;
+    daytona_state: string;
+    provider_state: string;
+    ready: boolean;
+    provider_coverage?: Array<{
+        provider: 'daytona' | 'platinum' | 'e2b';
+        available: boolean;
+        snapshot_name: string;
+        state: 'active' | 'building' | 'build_failed' | 'removing' | 'unknown' | 'missing' | null;
+        status: 'ready' | 'building' | 'failed' | 'not_built' | 'unavailable' | 'unknown';
+        launch_ready: boolean;
+        observed_at: string | null;
+    }>;
+    warm_pool?: {
+        enabled: boolean;
+        size: number;
+        ready: number;
+        warming: number;
+    } | null;
+}
+export interface SandboxTemplatesResponse {
+    items: SandboxTemplate[];
+    default_slug: string | null;
+    provider_mode?: 'automatic' | 'pinned';
+    selected_provider?: 'daytona' | 'platinum' | 'e2b' | null;
+    warm_pool_available?: boolean;
+}
+export interface ProjectSnapshotBuild {
+    build_id: string;
+    slug: string;
+    template_slug: string;
+    snapshot_name: string;
+    content_hash: string;
+    status: ProjectSnapshotStatus;
+    error: string | null;
+    error_category: SnapshotErrorCategory | null;
+    fixable_by_agent: boolean;
+    source: 'session-start' | 'project-create' | 'cr-merge' | 'manual' | 'background' | 'startup' | null;
+    provider?: 'daytona' | 'platinum' | 'e2b' | null;
+    started_at: string;
+    finished_at: string | null;
+}
+export type SandboxRuntimeState = 'ready' | 'building' | 'not_built' | 'degraded' | 'blocked' | 'unknown';
+export type SandboxStaleFailureReason = 'superseded' | 'recovered' | 'retrying';
+export interface SandboxRuntimeStatus {
+    state: SandboxRuntimeState;
+    snapshot_name: string | null;
+    current_failure: ProjectSnapshotBuild | null;
+    stale_failure: ProjectSnapshotBuild | null;
+    stale_reason: SandboxStaleFailureReason | null;
+    ready_providers: string[];
+    building_providers: string[];
+    failed_providers: string[];
+    fix_with_agent_available: boolean;
+}
+export interface ProjectSnapshotsResponse {
+    templates: SandboxTemplate[];
+    templates_error: string | null;
+    builds: ProjectSnapshotBuild[];
+    status?: SandboxRuntimeStatus | null;
+    provider_mode?: 'automatic' | 'pinned';
+    selected_provider?: 'daytona' | 'platinum' | 'e2b' | null;
+    warm_pool_available?: boolean;
+}
+export interface ProjectSandboxHealth {
+    primary_slug: string | null;
+    primary_template: SandboxTemplate | null;
+    ready: boolean;
+    building: boolean;
+    latest_build: ProjectSnapshotBuild | null;
+    latest_failure: ProjectSnapshotBuild | null;
+    status?: SandboxRuntimeStatus | null;
+    provider_mode?: 'automatic' | 'pinned';
+    selected_provider?: 'daytona' | 'platinum' | 'e2b' | null;
+}
+export interface RebuildSnapshotResponse {
+    status: 'started';
+    slug: string;
+    deleted_existing: boolean;
+    snapshot_name: string;
+    providers?: Array<'daytona' | 'platinum' | 'e2b'>;
+    failed_providers?: Array<'daytona' | 'platinum' | 'e2b'>;
+}
+export declare function listProjectSandboxTemplates(projectId: string): Promise<SandboxTemplatesResponse>;
+export declare function listProjectSnapshots(projectId: string): Promise<ProjectSnapshotsResponse>;
+export declare function getProjectSandboxHealth(projectId: string): Promise<ProjectSandboxHealth>;
+export declare function rebuildProjectSnapshot(projectId: string, slug?: string): Promise<RebuildSnapshotResponse>;
+export declare function fixSandboxWithAgent(projectId: string): Promise<{
+    session_id: string;
+}>;
+export interface CreateSandboxTemplateInput {
+    slug: string;
+    name?: string;
+    image?: string;
+    dockerfile_path?: string;
+    entrypoint?: string;
+    cpu?: number;
+    memory_gb?: number;
+    disk_gb?: number;
+}
+export interface UpdateSandboxTemplateInput {
+    name?: string;
+    image?: string | null;
+    dockerfile_path?: string | null;
+    entrypoint?: string | null;
+    cpu?: number | null;
+    memory_gb?: number | null;
+    disk_gb?: number | null;
+}
+export declare function createSandboxTemplate(projectId: string, input: CreateSandboxTemplateInput): Promise<{
+    template_id: string;
+    slug: string;
+}>;
+export declare function updateSandboxTemplate(projectId: string, templateId: string, input: UpdateSandboxTemplateInput): Promise<{
+    template_id: string;
+    slug: string;
+}>;
+export declare function deleteSandboxTemplate(projectId: string, templateId: string): Promise<null>;
+export declare function buildSandboxTemplate(projectId: string, templateId: string): Promise<{
+    status: "started";
+    template_id: string;
+    slug: string;
+    providers?: Array<"daytona" | "platinum" | "e2b">;
+}>;
+export declare function listProjectSandboxes(projectId: string): Promise<SandboxTemplatesResponse>;

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

@@ -0,0 +1,35 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listProjectSandboxTemplates(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sandboxes`));
+}
+export async function listProjectSnapshots(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/snapshots`));
+}
+export async function getProjectSandboxHealth(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sandbox-health`, {
+        showErrors: false,
+        timeout: 15_000,
+    }));
+}
+export async function rebuildProjectSnapshot(projectId, slug) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/snapshots/rebuild`, slug ? { slug } : {}));
+}
+export async function fixSandboxWithAgent(projectId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/snapshots/fix-with-agent`, {}));
+}
+export async function createSandboxTemplate(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sandbox-templates`, input));
+}
+export async function updateSandboxTemplate(projectId, templateId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/sandbox-templates/${templateId}`, input));
+}
+export async function deleteSandboxTemplate(projectId, templateId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/sandbox-templates/${templateId}`));
+}
+export async function buildSandboxTemplate(projectId, templateId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sandbox-templates/${templateId}/build`, {}));
+}
+export async function listProjectSandboxes(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sandboxes`));
+}