@beeuni/sdk 0.1.0

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

@@ -0,0 +1,376 @@
+import type { CatalogModel } from '@beeuni/llm-catalog';
+import { type ApiClientOptions } from '../../http/api-client.js';
+import type { SandboxProviderName } from '../platform-client/types.js';
+import { type ProjectFileEntry, type ProjectGitConnection, type ProjectRole, type ServerTokenOptions } from './shared.js';
+export type FeatureFlagKey = 'agent_tunnel' | 'marketplace' | 'connectors_api_discover' | 'agentmail_email' | 'teams' | 'llm_gateway' | 'review_center' | 'meta_agent' | 'apps' | 'monitors' | 'reminders' | 'warm_sessions' | 'secrets_egress' | 'pi_worker' | 'session_transcript_history' | 'pooled_provider_secrets' | 'pi_harness' | 'config_releases' | 'agent_principal' | 'us_region' | 'event_triggers' | 'notification_center' | 'drives' | 'ephemeral_sandboxes' | 'human_messaging';
+type GraduatedFeatureFlagKey = 'agent_tunnel' | 'teams' | 'review_center' | 'session_transcript_history' | 'agent_principal' | 'human_messaging' | 'pi_worker' | 'config_releases';
+type ServedFeatureFlagKey = Exclude<FeatureFlagKey, GraduatedFeatureFlagKey>;
+export declare const FEATURE_FLAG_KEYS: readonly FeatureFlagKey[];
+export type FeatureFlagStability = 'experimental' | 'beta' | 'stable';
+export interface FeatureFlagView {
+    key: FeatureFlagKey;
+    name: string;
+    description: string;
+    stability: FeatureFlagStability;
+    available: boolean;
+    enabled: boolean;
+    overridden: boolean;
+    operator_only?: boolean;
+}
+export type ExperimentalFeatureKey = FeatureFlagKey;
+export type ExperimentalFeatureView = FeatureFlagView;
+export interface ProjectGlyph {
+    name: string;
+    color: string;
+}
+export interface BeeuniProject {
+    project_id: string;
+    account_id: string;
+    name: string;
+    repo_url: string;
+    git_origin_url?: string;
+    default_branch: string;
+    manifest_path: string;
+    status: 'active' | 'archived';
+    metadata: Record<string, unknown>;
+    last_opened_at: string | null;
+    created_at: string;
+    updated_at: string;
+    project_role?: ProjectRole | null;
+    effective_project_role?: ProjectRole | null;
+    experimental?: Record<ServedFeatureFlagKey, boolean> & Partial<Record<GraduatedFeatureFlagKey, boolean>>;
+    experimental_features?: FeatureFlagView[];
+    warm_pool?: {
+        enabled: boolean;
+        size: number;
+    };
+    warm_pool_available?: boolean;
+    default_sandbox_provider?: SandboxProviderName | null;
+    available_sandbox_providers?: SandboxProviderName[];
+    icon?: string | null;
+    icon_glyph?: ProjectGlyph | null;
+    dashboard_url?: string;
+}
+export interface ProjectConfigSummary {
+    is_beeuni_repo: boolean;
+    signals: Record<string, boolean>;
+    manifest_raw: string | null;
+    open_code_raw: string | null;
+    default_agent?: string | null;
+    open_code_default_agent: string | null;
+    agent_discovery: 'opencode' | 'declarative';
+    agents: Array<{
+        name: string;
+        path: string;
+        description: string | null;
+        mode: string | null;
+        model?: string | null;
+        source?: 'opencode' | 'beeuni.toml';
+        enabled?: boolean;
+        platform?: boolean;
+        sandbox?: string | null;
+        scope?: {
+            env: string[] | 'all';
+            connectors: string[] | 'all';
+            beeuni_permissions?: string[] | 'all';
+            beeuni_cli: string[] | 'all';
+            apps?: string[] | 'all';
+        };
+    }>;
+    skills: Array<{
+        name: string;
+        path: string;
+        description: string | null;
+    }>;
+    commands: Array<{
+        name: string;
+        path: string;
+        description: string | null;
+    }>;
+    env: {
+        required: string[];
+        optional: string[];
+    };
+}
+export interface ProjectDetail {
+    project: BeeuniProject;
+    git_connection?: ProjectGitConnection | null;
+    config: ProjectConfigSummary;
+    file_count: number;
+    files: ProjectFileEntry[];
+}
+export interface GatewayCatalogModel {
+    name: string;
+    free?: boolean;
+    reasoning?: boolean;
+    tool_call?: boolean;
+    attachment?: boolean;
+    temperature?: boolean;
+    limit?: {
+        context?: number;
+        output?: number;
+    };
+    variants?: Record<string, Record<string, unknown>>;
+    provider?: string;
+    provider_name?: string;
+    release_date?: string;
+    released?: string;
+    family?: string;
+    cost?: {
+        input?: number;
+        output?: number;
+    };
+    modalities?: {
+        input?: string[];
+        output?: string[];
+    };
+    reasoning_options?: Array<{
+        type: string;
+        values?: string[];
+        min?: number;
+        max?: number;
+    }>;
+    description?: string;
+    open_weights?: boolean;
+    last_updated?: string;
+    enabled?: boolean;
+}
+export interface ProjectLlmCatalogResponse {
+    models: Record<string, GatewayCatalogModel>;
+    managedPricingRoutes?: Record<string, Array<{
+        route: string;
+        role: 'preferred' | 'eligible';
+        input: number;
+        cacheRead: number;
+        output: number;
+    }>>;
+    modelOverrides?: Record<string, boolean>;
+    usingDefaults?: boolean;
+    defaultModel?: string;
+}
+export interface ProjectInput {
+    account_id?: string;
+    name?: string;
+    repo_url: string;
+    default_branch?: string;
+    manifest_path?: string;
+    icon?: string | null;
+    icon_glyph?: ProjectGlyph | null;
+}
+export interface CreateProjectRepoInput {
+    account_id?: string;
+    name: string;
+    project_name?: string;
+    installation_id?: string;
+    private?: boolean;
+    description?: string;
+    starter_template?: 'general-knowledge-worker' | 'minimal';
+    source_item_id?: string;
+    icon?: string;
+    icon_glyph?: ProjectGlyph;
+}
+export interface ProvisionProjectInput {
+    account_id?: string;
+    name: string;
+    seed_starter?: boolean;
+    default_branch?: string;
+    starter_template?: 'general-knowledge-worker' | 'minimal';
+    marketplace_items?: string[];
+    source_item_id?: string;
+    icon?: string;
+    icon_glyph?: ProjectGlyph;
+    idempotency_key?: string;
+}
+export interface RepoCollaboratorInvite {
+    username: string;
+    permission: string;
+    invitationUrl: string | null;
+    alreadyCollaborator: boolean;
+}
+export declare function listProjects(): Promise<BeeuniProject[]>;
+export declare function listProjectsForAccount(accountId?: string): Promise<BeeuniProject[]>;
+export declare function getProject(projectId: string, options?: ApiClientOptions): Promise<BeeuniProject>;
+export declare function inviteRepoCollaborator(projectId: string, githubUsername: string, permission?: 'read' | 'write'): Promise<RepoCollaboratorInvite>;
+export interface ManifestValidationIssue {
+    [key: string]: unknown;
+}
+export interface ManifestValidationResult {
+    valid: boolean;
+    issues: ManifestValidationIssue[];
+}
+export declare function validateProjectManifest(projectId: string, raw: string): Promise<ManifestValidationResult>;
+export interface ProjectGitToken {
+    push_token: string;
+    git_username: string;
+    repo_id: string | null;
+    repo_url: string | null;
+}
+export declare function getProjectGitToken(projectId: string): Promise<ProjectGitToken>;
+export declare function isManagedGithubProject(project: {
+    metadata?: Record<string, unknown> | null;
+}): boolean;
+export declare function getProjectDetail(projectId: string, options?: ApiClientOptions): Promise<{
+    config: {
+        default_agent: string | null;
+        is_beeuni_repo: boolean;
+        signals: Record<string, boolean>;
+        manifest_raw: string | null;
+        open_code_raw: string | null;
+        open_code_default_agent: string | null;
+        agent_discovery: "opencode" | "declarative";
+        agents: Array<{
+            name: string;
+            path: string;
+            description: string | null;
+            mode: string | null;
+            model?: string | null;
+            source?: "opencode" | "beeuni.toml";
+            enabled?: boolean;
+            platform?: boolean;
+            sandbox?: string | null;
+            scope?: {
+                env: string[] | "all";
+                connectors: string[] | "all";
+                beeuni_permissions?: string[] | "all";
+                beeuni_cli: string[] | "all";
+                apps?: string[] | "all";
+            };
+        }>;
+        skills: Array<{
+            name: string;
+            path: string;
+            description: string | null;
+        }>;
+        commands: Array<{
+            name: string;
+            path: string;
+            description: string | null;
+        }>;
+        env: {
+            required: string[];
+            optional: string[];
+        };
+    };
+    project: BeeuniProject;
+    git_connection?: ProjectGitConnection | null;
+    file_count: number;
+    files: ProjectFileEntry[];
+}>;
+export declare function getProjectLlmCatalog(projectId: string, options?: ApiClientOptions): Promise<ProjectLlmCatalogResponse>;
+export declare function getProjectModelPicker(projectId: string, options?: ApiClientOptions): Promise<ProjectLlmCatalogResponse>;
+export type ProjectLlmCatalogProviderModel = CatalogModel;
+export interface ProjectLlmCatalogProvider {
+    id: string;
+    name: string;
+    env?: string[];
+    doc?: string | null;
+    api?: string | null;
+    npm?: string | null;
+    models: Array<ProjectLlmCatalogProviderModel>;
+}
+export interface ProjectLlmCatalogProvidersResponse {
+    source: string;
+    fetched_at: string;
+    provider_count: number;
+    model_count: number;
+    providers: ProjectLlmCatalogProvider[];
+}
+export declare function getProjectLlmCatalogProviders(projectId: string, options?: ApiClientOptions): Promise<ProjectLlmCatalogProvidersResponse>;
+export declare function createProject(input: ProjectInput): Promise<BeeuniProject>;
+export declare function createProjectRepo(input: CreateProjectRepoInput): Promise<BeeuniProject>;
+export declare function provisionProject(input: ProvisionProjectInput, options?: ApiClientOptions): Promise<BeeuniProject>;
+export type ProvisionPhase = 'validating' | 'creating_repository' | 'registering' | 'seeding';
+export type ProvisionStreamEvent = {
+    type: 'phase';
+    phase: ProvisionPhase;
+} | {
+    type: 'done';
+    project: BeeuniProject;
+} | {
+    type: 'error';
+    error: string;
+    code?: string;
+    status?: number;
+};
+export declare function provisionProjectStream(input: ProvisionProjectInput, onEvent: (event: ProvisionStreamEvent) => void, options?: ApiClientOptions): Promise<BeeuniProject>;
+export interface ManagedGitStatus {
+    configured: boolean;
+    provider: string;
+}
+export declare function getManagedGitStatus(): Promise<ManagedGitStatus>;
+export declare function updateProject(projectId: string, input: Partial<ProjectInput>): Promise<BeeuniProject>;
+export declare function updateFeatureFlag(projectId: string, feature: FeatureFlagKey, enabled: boolean | null): Promise<BeeuniProject>;
+export declare function updateExperimentalFeature(projectId: string, feature: FeatureFlagKey, enabled: boolean | null): Promise<BeeuniProject>;
+export interface PreparationView {
+    kind: 'preparation';
+    transition_id: string | null;
+    project_id: string;
+    status: string;
+    source_provider: string | null;
+    target_provider: string | null;
+    active_provider: string | null;
+    label: string;
+    generation: number | null;
+    snapshot_name: string | null;
+    external_template_id: string | null;
+    commit_sha: string | null;
+    attempts: number;
+    last_error: string | null;
+    error_class: string | null;
+    requested_at: string | null;
+    ready_at: string | null;
+    activated_at: string | null;
+    immediate: boolean;
+}
+export type UpdateProjectSandboxProviderResult = ({
+    kind: 'project';
+} & BeeuniProject) | PreparationView;
+export declare function updateProjectSandboxProvider(projectId: string, provider: SandboxProviderName | null): Promise<UpdateProjectSandboxProviderResult>;
+export interface SandboxProviderTransitionView {
+    transition_id: string | null;
+    project_id: string;
+    status: string;
+    source_provider: string | null;
+    target_provider: string | null;
+    generation: number | null;
+    label: string;
+    error_class: string | null;
+    requested_at: string | null;
+    ready_at: string | null;
+    activated_at: string | null;
+    immediate: boolean;
+}
+export interface SandboxProviderTransitionState {
+    active_provider: string | null;
+    latest: SandboxProviderTransitionView | null;
+    history: SandboxProviderTransitionView[];
+}
+export declare function getProjectSandboxProviderTransition(projectId: string, options?: ApiClientOptions): Promise<SandboxProviderTransitionState>;
+export declare function updateTemplateWarmPool(_projectId: string, _input: {
+    slug: string;
+    enabled?: boolean;
+    size?: number;
+}): Promise<BeeuniProject>;
+export declare function setProjectOnboardingComplete(projectId: string, completed: boolean): Promise<BeeuniProject>;
+export type OnboardingUseCase = 'founder' | 'product_design' | 'sales' | 'support' | 'marketing' | 'engineering' | 'finance_ops' | 'hr_recruiting' | 'other';
+export type OnboardingCompanySize = '1-10' | '11-50' | '51-200' | '201-1000' | '1000+';
+export interface OnboardingProfile {
+    use_case?: OnboardingUseCase;
+    use_case_note?: string;
+    company_domain?: string;
+    company_size?: OnboardingCompanySize;
+}
+export declare function setProjectOnboardingProfile(projectId: string, profile: OnboardingProfile): Promise<BeeuniProject>;
+export declare function archiveProject(projectId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function fetchProjectsForAccountWithToken(opts: ServerTokenOptions, accountId: string): Promise<BeeuniProject[] | null>;
+export type ProvisionProjectWithTokenResult = {
+    ok: true;
+    project: BeeuniProject;
+} | {
+    ok: false;
+    limitReached: boolean;
+};
+export declare function provisionProjectWithToken(opts: ServerTokenOptions, input: ProvisionProjectInput): Promise<ProvisionProjectWithTokenResult>;
+export {};

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

@@ -0,0 +1,237 @@
+import { ApiError, backendApi } from '../../http/api-client.js';
+import { retiredEndpointError } from '../../http/api/errors.js';
+import { normalizeServerBackendBase, serverTokenGet, unwrap, } from './shared.js';
+export const FEATURE_FLAG_KEYS = [
+    'marketplace',
+    'connectors_api_discover',
+    'agentmail_email',
+    'llm_gateway',
+    'meta_agent',
+    'apps',
+    'monitors',
+    'reminders',
+    'warm_sessions',
+    'secrets_egress',
+    'pooled_provider_secrets',
+    'pi_harness',
+    'us_region',
+    'event_triggers',
+    'notification_center',
+    'drives',
+    'ephemeral_sandboxes',
+];
+export async function listProjects() {
+    return unwrap(await backendApi.get('/projects'));
+}
+export async function listProjectsForAccount(accountId) {
+    const query = accountId ? `?account_id=${encodeURIComponent(accountId)}` : '';
+    return unwrap(await backendApi.get(`/projects${query}`));
+}
+export async function getProject(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}`, options));
+}
+export async function inviteRepoCollaborator(projectId, githubUsername, permission = 'write') {
+    return unwrap(await backendApi.post(`/projects/${projectId}/git/collaborators`, {
+        github_username: githubUsername,
+        permission,
+    }));
+}
+export async function validateProjectManifest(projectId, raw) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/manifest/validate`, {
+        raw,
+    }), 'Failed to validate manifest');
+}
+export async function getProjectGitToken(projectId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/git-token`, {}), 'Failed to mint git token');
+}
+export function isManagedGithubProject(project) {
+    const git = project.metadata
+        ?.git;
+    return git?.provider === 'github' && git?.managed === true;
+}
+export async function getProjectDetail(projectId, options) {
+    const detail = unwrap(await backendApi.get(`/projects/${projectId}/detail`, {
+        showErrors: false,
+        ...options,
+    }));
+    return {
+        ...detail,
+        config: {
+            ...detail.config,
+            default_agent: detail.config.default_agent ?? detail.config.open_code_default_agent ?? null,
+        },
+    };
+}
+export async function getProjectLlmCatalog(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/llm-catalog`, {
+        showErrors: false,
+        ...options,
+    }));
+}
+export async function getProjectModelPicker(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/model-picker`, {
+        showErrors: false,
+        ...options,
+    }));
+}
+export async function getProjectLlmCatalogProviders(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/llm-catalog/providers`, { showErrors: false, ...options }));
+}
+export async function createProject(input) {
+    return unwrap(await backendApi.post('/projects', input));
+}
+export async function createProjectRepo(input) {
+    return unwrap(await backendApi.post('/projects/create-repo', input, { showErrors: false }));
+}
+export async function provisionProject(input, options = {}) {
+    return unwrap(await backendApi.post('/projects/provision', {
+        seed_starter: true,
+        ...input,
+    }, {
+        timeout: 120_000,
+        ...options,
+    }));
+}
+const FRAME_PARSE_ERROR_EXCERPT_LENGTH = 200;
+function parseProvisionStreamFrame(frame) {
+    const dataLines = frame
+        .split('\n')
+        .filter((line) => line.startsWith('data:'))
+        .map((line) => line.slice(5).replace(/^ /, ''));
+    if (dataLines.length === 0)
+        return null;
+    const payload = dataLines.join('\n');
+    try {
+        return JSON.parse(payload);
+    }
+    catch (cause) {
+        const excerpt = payload.length > FRAME_PARSE_ERROR_EXCERPT_LENGTH
+            ? `${payload.slice(0, FRAME_PARSE_ERROR_EXCERPT_LENGTH)}…`
+            : payload;
+        throw new Error(`provisionProjectStream: received an unparseable SSE frame (${excerpt})`, {
+            cause,
+        });
+    }
+}
+export async function provisionProjectStream(input, onEvent, options = {}) {
+    const response = await backendApi.postStream('/projects/provision-stream', { seed_starter: true, ...input }, options);
+    if (!response.ok) {
+        const body = (await response.json().catch(() => null));
+        throw new ApiError(body?.error || `Provision failed: HTTP ${response.status}`, {
+            status: response.status,
+            code: body?.code,
+        });
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error('Provision stream is unavailable on this runtime (no response body)');
+    }
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let settled = null;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let boundary = buffer.indexOf('\n\n');
+            while (boundary !== -1) {
+                const frame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                boundary = buffer.indexOf('\n\n');
+                const event = parseProvisionStreamFrame(frame);
+                if (!event)
+                    continue;
+                onEvent(event);
+                if (event.type === 'error') {
+                    throw new ApiError(event.error, { status: event.status, code: event.code });
+                }
+                if (event.type === 'done')
+                    settled = event.project;
+            }
+        }
+    }
+    finally {
+        reader.cancel().catch(() => { });
+    }
+    if (!settled)
+        throw new Error('Provision stream ended without a result');
+    return settled;
+}
+export async function getManagedGitStatus() {
+    try {
+        return unwrap(await backendApi.get('/projects/managed-git/status', {
+            showErrors: false,
+        }));
+    }
+    catch {
+        return { configured: false, provider: 'github' };
+    }
+}
+export async function updateProject(projectId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}`, input));
+}
+export async function updateFeatureFlag(projectId, feature, enabled) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/features`, {
+        feature,
+        enabled,
+    }));
+}
+export async function updateExperimentalFeature(projectId, feature, enabled) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/experimental`, {
+        feature,
+        enabled,
+    }));
+}
+export async function updateProjectSandboxProvider(projectId, provider) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/sandbox-provider`, { provider }));
+}
+export async function getProjectSandboxProviderTransition(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sandbox-provider/transition`, { showErrors: false, ...options }));
+}
+export async function updateTemplateWarmPool(_projectId, _input) {
+    throw retiredEndpointError('updateTemplateWarmPool');
+}
+export async function setProjectOnboardingComplete(projectId, completed) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/onboarding`, { completed }));
+}
+export async function setProjectOnboardingProfile(projectId, profile) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/onboarding`, { profile }));
+}
+export async function archiveProject(projectId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}`));
+}
+export async function fetchProjectsForAccountWithToken(opts, accountId) {
+    return serverTokenGet(opts, `/v1/projects?account_id=${encodeURIComponent(accountId)}`);
+}
+export async function provisionProjectWithToken(opts, input) {
+    if (!opts.backendUrl || !opts.accessToken)
+        return { ok: false, limitReached: false };
+    const base = normalizeServerBackendBase(opts.backendUrl);
+    try {
+        const res = await fetch(`${base}/v1/projects/provision`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${opts.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ seed_starter: true, ...input }),
+            signal: AbortSignal.timeout(opts.timeoutMs ?? 90_000),
+        });
+        if (res.ok) {
+            const project = (await res.json().catch(() => null));
+            if (!project?.project_id)
+                return { ok: false, limitReached: false };
+            return { ok: true, project };
+        }
+        if (res.status === 403) {
+            const body = (await res.json().catch(() => null));
+            return { ok: false, limitReached: body?.code === 'project_limit_reached' };
+        }
+        return { ok: false, limitReached: false };
+    }
+    catch {
+        return { ok: false, limitReached: false };
+    }
+}

package/dist/core/rest/projects-client/prompt-attachments.d.ts

@@ -0,0 +1,31 @@
+export interface PromptAttachment {
+    attachment_id: string;
+    filename: string;
+    mime: string;
+    size: number;
+    expires_at: string;
+}
+export interface PromptAttachmentUpload extends PromptAttachment {
+    upload: {
+        kind: 'direct';
+        url: string;
+        method: 'PUT';
+        headers: Record<string, string>;
+        expires_at: string;
+    } | {
+        kind: 'chunked';
+        chunk_size: number;
+    };
+    received_bytes: number;
+}
+export interface PromptAttachmentUploadOptions {
+    signal?: AbortSignal;
+    resume?: PromptAttachmentUpload;
+    onUpload?: (upload: PromptAttachmentUpload) => void;
+    onProgress?: (receivedBytes: number, totalBytes: number) => void;
+    onProcessing?: () => void;
+}
+export declare function uploadPromptAttachment(projectId: string, file: File, options?: PromptAttachmentUploadOptions): Promise<PromptAttachment>;
+export declare function deletePromptAttachment(projectId: string, attachmentId: string, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;