@beeuni/sdk 0.1.0

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

@@ -0,0 +1,240 @@
+import type { ApiError } from '../../http/api/errors.js';
+import { type AccountRole, type ProjectRole, type ServerTokenOptions } from './shared.js';
+export interface AccountBranding {
+    app_name: string | null;
+    logo_url: string | null;
+    icon_url: string | null;
+    favicon_url: string | null;
+    logo_dark_url: string | null;
+    icon_dark_url: string | null;
+    favicon_dark_url: string | null;
+}
+export type AccountBrandingAssetKind = 'logo' | 'icon' | 'favicon' | 'logo_dark' | 'icon_dark' | 'favicon_dark';
+export interface AccountBrandingState {
+    branding: AccountBranding;
+    entitled: boolean;
+}
+export interface BeeuniAccount {
+    account_id: string;
+    name: string;
+    slug?: string;
+    created_at?: string;
+    updated_at?: string;
+    account_role?: string;
+    is_primary_owner?: boolean;
+    branding?: AccountBranding | null;
+}
+export interface AccountDetail {
+    account_id: string;
+    name: string;
+    member_count: number;
+    project_count: number;
+    role: AccountRole;
+    mfa_required?: boolean;
+    branding?: AccountBranding | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface AccountMemberGroup {
+    group_id: string;
+    name: string;
+}
+export interface AccountMemberProject {
+    project_id: string;
+    name: string;
+    role: ProjectRole;
+}
+export interface AccountMember {
+    user_id: string;
+    email: string | null;
+    account_role: AccountRole;
+    is_super_admin?: boolean;
+    explicit_project_count?: number;
+    projects?: AccountMemberProject[];
+    groups?: AccountMemberGroup[];
+    active_pat_count?: number;
+    has_verified_mfa?: boolean;
+    joined_at: string;
+}
+export interface InviteProjectGrant {
+    project_id: string;
+    role?: ProjectRole;
+}
+export type InviteMemberResult = {
+    status: 'added';
+    user_id: string;
+    email: string;
+    account_role: AccountRole;
+    project_grants: Array<{
+        project_id: string;
+        role: ProjectRole;
+    }>;
+} | {
+    status: 'pending';
+    invite_id: string;
+    email: string;
+    account_role: AccountRole;
+    project_grants: Array<{
+        project_id: string;
+        role: ProjectRole;
+    }>;
+    expires_at: string;
+    invite_url: string;
+    email_sent: boolean;
+    email_skip_reason: string | null;
+};
+export interface AccountInvitation {
+    invite_id: string;
+    email: string;
+    initial_role: AccountRole;
+    invited_by: string;
+    created_at: string;
+    expires_at: string;
+    invite_url: string;
+}
+export interface ResendInviteResult {
+    ok: boolean;
+    expires_at: string;
+    invite_url: string;
+    email_sent: boolean;
+    email_skip_reason: string | null;
+}
+export interface AccountInviteDescribeFull {
+    invite_id: string;
+    account_id: string;
+    account_name: string | null;
+    email: string;
+    initial_role: AccountRole;
+    inviter_email: string | null;
+    created_at: string;
+    expires_at: string;
+    expired: boolean;
+    accepted_at: string | null;
+    email_matches_caller: true;
+    projects?: Array<{
+        project_id: string;
+        name: string;
+        role: string;
+    }>;
+}
+export interface AccountInviteDescribeRedacted {
+    invite_id: string;
+    expired: boolean;
+    accepted_at: string | null;
+    email_matches_caller: false;
+    account_id?: null;
+    account_name?: null;
+    email?: null;
+    initial_role?: null;
+    inviter_email?: null;
+    created_at?: null;
+    expires_at?: null;
+}
+export type AccountInviteDescribe = AccountInviteDescribeFull | AccountInviteDescribeRedacted;
+export interface MyAccountInvite {
+    invite_id: string;
+    account_id: string;
+    account_name: string | null;
+    initial_role: AccountRole;
+    inviter_email: string | null;
+    created_at: string;
+    expires_at: string;
+    projects: Array<{
+        project_id: string;
+        name: string;
+        role: string;
+    }>;
+}
+export declare function listAccounts(): Promise<BeeuniAccount[]>;
+export declare function createAccount(input: {
+    name: string;
+}): Promise<BeeuniAccount>;
+export declare function getAccount(accountId: string): Promise<AccountDetail>;
+export declare function updateAccountName(accountId: string, name: string): Promise<AccountDetail>;
+export declare function getAccountBranding(accountId: string): Promise<AccountBrandingState>;
+export declare function updateAccountBranding(accountId: string, input: {
+    app_name: string | null;
+}): Promise<AccountBrandingState>;
+export declare function uploadAccountBrandingAsset(accountId: string, kind: AccountBrandingAssetKind, file: Blob, filename?: string): Promise<AccountBrandingState>;
+export declare function removeAccountBrandingAsset(accountId: string, kind: AccountBrandingAssetKind): Promise<AccountBrandingState>;
+export declare function resetAccountBranding(accountId: string): Promise<AccountBrandingState>;
+export declare function listAccountMembers(accountId: string): Promise<AccountMember[]>;
+export declare function inviteAccountMember(accountId: string, input: {
+    email: string;
+    role?: AccountRole;
+    project_grants?: InviteProjectGrant[];
+}): Promise<{
+    status: "added";
+    user_id: string;
+    email: string;
+    account_role: AccountRole;
+    project_grants: Array<{
+        project_id: string;
+        role: ProjectRole;
+    }>;
+} | {
+    status: "pending";
+    invite_id: string;
+    email: string;
+    account_role: AccountRole;
+    project_grants: Array<{
+        project_id: string;
+        role: ProjectRole;
+    }>;
+    expires_at: string;
+    invite_url: string;
+    email_sent: boolean;
+    email_skip_reason: string | null;
+}>;
+export declare function listAccountInvites(accountId: string): Promise<AccountInvitation[]>;
+export declare function cancelAccountInvite(accountId: string, inviteId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function resendAccountInvite(accountId: string, inviteId: string): Promise<ResendInviteResult>;
+export declare function listMyAccountInvites(): Promise<MyAccountInvite[]>;
+export declare function describeAccountInvite(inviteId: string): Promise<AccountInviteDescribeFull | AccountInviteDescribeRedacted>;
+export declare function acceptAccountInvite(inviteId: string): Promise<{
+    account_id: string;
+    account_role: AccountRole;
+    already_accepted?: boolean;
+    bootstrap_grants_applied?: Array<{
+        project_id: string;
+        role: string;
+    }>;
+}>;
+export declare function declineAccountInvite(inviteId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function removeAccountMember(accountId: string, userId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function updateAccountMemberRole(accountId: string, userId: string, role: AccountRole): Promise<AccountMember>;
+export declare function leaveAccount(accountId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function fetchAccountsWithToken(opts: ServerTokenOptions): Promise<BeeuniAccount[] | null>;
+export interface AccountIdentity {
+    user_id: string;
+    email: string;
+    token_context?: {
+        auth_type: string | null;
+        project_id: string | null;
+        session_id: string | null;
+        agent: string | null;
+        connectors: 'all' | string[] | null;
+        beeuni_permissions?: 'all' | string[] | null;
+        beeuni_cli: 'all' | string[] | null;
+    };
+    accounts: Array<{
+        account_id: string;
+        slug: string;
+        name: string;
+        role: string;
+    }>;
+}
+export interface ValidateTokenResult {
+    valid: boolean;
+    identity?: AccountIdentity;
+    error?: ApiError;
+}
+export declare function validateToken(): Promise<ValidateTokenResult>;

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

@@ -0,0 +1,82 @@
+import { backendApi } from '../../http/api-client.js';
+import { serverTokenGet, unwrap, } from './shared.js';
+export async function listAccounts() {
+    return unwrap(await backendApi.get('/accounts'));
+}
+export async function createAccount(input) {
+    return unwrap(await backendApi.post('/accounts', input));
+}
+export async function getAccount(accountId) {
+    return unwrap(await backendApi.get(`/accounts/${accountId}`));
+}
+export async function updateAccountName(accountId, name) {
+    return unwrap(await backendApi.patch(`/accounts/${accountId}`, { name }));
+}
+export async function getAccountBranding(accountId) {
+    return unwrap(await backendApi.get(`/accounts/${accountId}/branding`));
+}
+export async function updateAccountBranding(accountId, input) {
+    return unwrap(await backendApi.put(`/accounts/${accountId}/branding`, input));
+}
+export async function uploadAccountBrandingAsset(accountId, kind, file, filename) {
+    const form = new FormData();
+    form.append('file', file, filename ?? (file instanceof File ? file.name : kind));
+    return unwrap(await backendApi.upload(`/accounts/${accountId}/branding/assets/${kind}`, form));
+}
+export async function removeAccountBrandingAsset(accountId, kind) {
+    return unwrap(await backendApi.delete(`/accounts/${accountId}/branding/assets/${kind}`));
+}
+export async function resetAccountBranding(accountId) {
+    return unwrap(await backendApi.delete(`/accounts/${accountId}/branding`));
+}
+export async function listAccountMembers(accountId) {
+    return unwrap(await backendApi.get(`/accounts/${accountId}/members`));
+}
+export async function inviteAccountMember(accountId, input) {
+    return unwrap(await backendApi.post(`/accounts/${accountId}/members`, input, {
+        showErrors: false,
+    }));
+}
+export async function listAccountInvites(accountId) {
+    return unwrap(await backendApi.get(`/accounts/${accountId}/invites`));
+}
+export async function cancelAccountInvite(accountId, inviteId) {
+    return unwrap(await backendApi.delete(`/accounts/${accountId}/invites/${inviteId}`));
+}
+export async function resendAccountInvite(accountId, inviteId) {
+    return unwrap(await backendApi.post(`/accounts/${accountId}/invites/${inviteId}/resend`, {}));
+}
+export async function listMyAccountInvites() {
+    const res = unwrap(await backendApi.get('/account-invites', { showErrors: false }));
+    return res.invites;
+}
+export async function describeAccountInvite(inviteId) {
+    return unwrap(await backendApi.get(`/account-invites/${inviteId}`, {
+        showErrors: false,
+    }));
+}
+export async function acceptAccountInvite(inviteId) {
+    return unwrap(await backendApi.post(`/account-invites/${inviteId}/accept`, {}));
+}
+export async function declineAccountInvite(inviteId) {
+    return unwrap(await backendApi.post(`/account-invites/${inviteId}/decline`, {}));
+}
+export async function removeAccountMember(accountId, userId) {
+    return unwrap(await backendApi.delete(`/accounts/${accountId}/members/${userId}`));
+}
+export async function updateAccountMemberRole(accountId, userId, role) {
+    return unwrap(await backendApi.patch(`/accounts/${accountId}/members/${userId}`, { role }));
+}
+export async function leaveAccount(accountId) {
+    return unwrap(await backendApi.post(`/accounts/${accountId}/leave`, {}));
+}
+export async function fetchAccountsWithToken(opts) {
+    return serverTokenGet(opts, '/v1/accounts');
+}
+export async function validateToken() {
+    const res = await backendApi.get('/accounts/me', { showErrors: false });
+    if (!res.success || !res.data) {
+        return { valid: false, error: res.error };
+    }
+    return { valid: true, identity: res.data };
+}

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

@@ -0,0 +1,131 @@
+export interface AdminProviderDistribution {
+    allowed: string[];
+    default: string;
+    weights: Record<string, number>;
+}
+export interface AdminProviderSandbox {
+    sandboxId: string;
+    sessionId: string;
+    accountId: string;
+    projectId: string;
+    provider: string;
+    externalId: string | null;
+    status: string;
+    lastUsedAt: string | null;
+}
+export interface AdminProviderSandboxesResponse {
+    sandboxes: AdminProviderSandbox[];
+    byProvider: {
+        provider: string;
+        count: number;
+    }[];
+}
+export interface AdminProviderStat {
+    provider: string;
+    provisions: number;
+    ok: number;
+    error: number;
+    stopped: number;
+    successRate: number | null;
+    p50Ms: number;
+    p95Ms: number;
+    avgMs: number;
+    phases: {
+        label: string;
+        avgMs: number;
+    }[];
+}
+export interface AdminProviderAnalytics {
+    days: number;
+    totals: {
+        provisions: number;
+        ok: number;
+        error: number;
+        stopped: number;
+        migrations: number;
+        successRate: number | null;
+    };
+    providers: AdminProviderStat[];
+    latencyByDay: Record<string, unknown>[];
+    volumeByDay: Record<string, unknown>[];
+    migrations: {
+        flow: string;
+        count: number;
+    }[];
+    recentErrors: {
+        provider: string;
+        errorClass: string | null;
+        error: string | null;
+        createdAt: string;
+    }[];
+}
+export declare function getAdminProviderDistribution<T = AdminProviderDistribution>(): Promise<T>;
+export declare function listAdminSandboxes<T = AdminProviderSandboxesResponse>(limit?: number): Promise<T>;
+export declare function setAdminProviderDistribution<T = unknown>(weights: Record<string, number>): Promise<T>;
+export declare function getAdminProviderAnalytics<T = AdminProviderAnalytics>(days: number): Promise<T>;
+export declare function migrateAdminSandboxProvider<T = unknown>(sessionId: string, targetProvider: string): Promise<T>;
+export declare function getAdminProviderFallback(): Promise<{
+    enabled: boolean;
+}>;
+export declare function setAdminProviderFallback<T = unknown>(enabled: boolean): Promise<T>;
+export type AdminBootMode = 'standard' | 'artifacts' | 'volume';
+export interface AdminBootModeRule {
+    mode: AdminBootMode;
+    standardFallback: boolean;
+}
+export interface AdminVolumesPolicy {
+    enabled: boolean;
+    percent: number;
+    orgs: Record<string, boolean>;
+}
+export interface AdminBootModePolicy {
+    volumes: AdminVolumesPolicy;
+    killSwitch: boolean;
+    default: AdminBootModeRule;
+    orgs: Record<string, AdminBootModeRule>;
+    fallback: {
+        volumeAttempts: number;
+        artifactsAttempts: number;
+    };
+    artifacts: string | null;
+}
+export interface AdminBootModes {
+    stored: boolean;
+    policy: AdminBootModePolicy;
+    orgs: Array<{
+        accountId: string;
+        name: string | null;
+        volumes: boolean | null;
+        rule: AdminBootModeRule | null;
+    }>;
+    env: {
+        bootArtifacts: string | null;
+        volumeOff: boolean;
+        driveSync: boolean;
+    };
+    providers: {
+        allowed: string[];
+        default: string;
+        volumeProvider: string;
+        volumeProviderConfigured: boolean;
+    };
+    stats: {
+        since: string;
+        modes: {
+            mode: AdminBootMode;
+            requested: number;
+            booted: number;
+        }[];
+        fallbacks: {
+            from: AdminBootMode;
+            to: AdminBootMode;
+            reason: string;
+            count: number;
+            sample: string | null;
+        }[];
+    } | {
+        error: string;
+    };
+}
+export declare function getAdminBootModes(): Promise<AdminBootModes>;
+export declare function setAdminBootModes(policy: AdminBootModePolicy): Promise<AdminBootModes>;

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

@@ -0,0 +1,39 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export function getAdminProviderDistribution() {
+    return backendApi.get('/admin/api/provider-distribution').then((response) => unwrap(response));
+}
+export function listAdminSandboxes(limit = 300) {
+    return backendApi
+        .get(`/admin/api/sandboxes?limit=${limit}`)
+        .then((response) => unwrap(response));
+}
+export function setAdminProviderDistribution(weights) {
+    return backendApi.put('/admin/api/provider-distribution', weights).then((response) => unwrap(response));
+}
+export function getAdminProviderAnalytics(days) {
+    return backendApi
+        .get(`/admin/api/provider-analytics?days=${days}`)
+        .then((response) => unwrap(response));
+}
+export function migrateAdminSandboxProvider(sessionId, targetProvider) {
+    return backendApi
+        .post(`/admin/api/sandboxes/${encodeURIComponent(sessionId)}/migrate`, { targetProvider })
+        .then((response) => unwrap(response));
+}
+export function getAdminProviderFallback() {
+    return backendApi
+        .get('/admin/api/provider-fallback')
+        .then((response) => unwrap(response));
+}
+export function setAdminProviderFallback(enabled) {
+    return backendApi
+        .put('/admin/api/provider-fallback', { enabled })
+        .then((response) => unwrap(response));
+}
+export function getAdminBootModes() {
+    return backendApi.get('/admin/api/boot-modes').then((response) => unwrap(response));
+}
+export function setAdminBootModes(policy) {
+    return backendApi.put('/admin/api/boot-modes', policy).then((response) => unwrap(response));
+}

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

@@ -0,0 +1,72 @@
+export type AgentGrantSetV2 = 'all' | 'none' | string[];
+export type PermissionAction = 'ask' | 'allow' | 'deny';
+export type PermissionRule = PermissionAction | Record<string, PermissionAction>;
+export type PermissionConfig = PermissionAction | Record<string, PermissionRule | PermissionAction>;
+export interface RuntimeAgentConfig {
+    description?: string;
+    mode?: 'primary' | 'subagent' | 'all';
+    model?: string;
+    variant?: string;
+    temperature?: number;
+    top_p?: number;
+    prompt?: string;
+    hidden?: boolean;
+    options?: Record<string, unknown>;
+    color?: string;
+    steps?: number;
+    permission?: PermissionConfig;
+}
+export type OpencodeAgentConfig = RuntimeAgentConfig;
+export interface AgentConfigBlock {
+    file?: string;
+    enabled?: boolean;
+    sandbox?: string;
+    connectors?: AgentGrantSetV2;
+    connectors_required?: string[];
+    connectors_personal?: string[];
+    secrets?: AgentGrantSetV2;
+    skills?: AgentGrantSetV2;
+    apps?: AgentGrantSetV2;
+    beeuni_permissions?: AgentGrantSetV2;
+    beeuni_cli?: AgentGrantSetV2;
+    repository_access?: boolean;
+    workspace?: 'runtime' | 'read' | 'branch';
+    behavior?: RuntimeAgentConfig;
+    opencode?: RuntimeAgentConfig;
+}
+export interface AgentConfigResponse {
+    agent: string;
+    schema_version: number;
+    editable: boolean;
+    default_agent: string | null;
+    block: AgentConfigBlock | null;
+    harness?: string;
+    ignored_settings?: string[];
+}
+export declare function getAgentConfig(projectId: string, agentName: string): Promise<{
+    block: AgentConfigBlock | null;
+    agent: string;
+    schema_version: number;
+    editable: boolean;
+    default_agent: string | null;
+    harness?: string;
+    ignored_settings?: string[];
+}>;
+export declare function updateAgentConfig(projectId: string, agentName: string, block: AgentConfigBlock): Promise<{
+    block: AgentConfigBlock | null;
+    ok: boolean;
+    agent: string;
+    schema_version: number;
+}>;
+export interface GrantSecretToAgentResponse {
+    identifier: string;
+    agent: string;
+    already_granted: boolean;
+    adopted_governance: boolean;
+}
+export declare function grantSecretToAgent(projectId: string, identifier: string, agentName: string): Promise<GrantSecretToAgentResponse>;
+export interface UpdateProjectDefaultAgentResponse {
+    ok: boolean;
+    default_agent: string;
+}
+export declare function updateProjectDefaultAgent(projectId: string, agentName: string): Promise<UpdateProjectDefaultAgentResponse>;

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

@@ -0,0 +1,39 @@
+import { backendApi } from '../../http/api-client.js';
+import { canonicalizeRequiredConnectors } from './agent-connectors.js';
+import { unwrap } from './shared.js';
+export async function getAgentConfig(projectId, agentName) {
+    const response = unwrap(await backendApi.get(`/projects/${projectId}/agents/${encodeURIComponent(agentName)}/config`));
+    return {
+        ...response,
+        block: response.block ? canonicalizeAgentBlock(response.block) : null,
+    };
+}
+export async function updateAgentConfig(projectId, agentName, block) {
+    const canonicalBlock = canonicalizeAgentBlock(block, true);
+    const response = unwrap(await backendApi.put(`/projects/${projectId}/agents/${encodeURIComponent(agentName)}/config`, canonicalBlock));
+    return {
+        ...response,
+        block: response.block ? canonicalizeAgentBlock(response.block) : null,
+    };
+}
+function canonicalizeAgentBlock(block, writing = false) {
+    const next = canonicalizeRequiredConnectors(block);
+    if (next.workspace === undefined)
+        return next;
+    const legacyAccess = next.workspace === 'branch';
+    if (next.repository_access !== undefined && next.repository_access !== legacyAccess) {
+        throw new Error('repository_access conflicts with workspace');
+    }
+    if (writing && next.workspace === 'read' && next.repository_access === undefined) {
+        throw new Error('Legacy read is unavailable. Set repository_access explicitly.');
+    }
+    next.repository_access ??= legacyAccess;
+    delete next.workspace;
+    return next;
+}
+export async function grantSecretToAgent(projectId, identifier, agentName) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/secrets/${encodeURIComponent(identifier)}/grant`, { agent: agentName }));
+}
+export async function updateProjectDefaultAgent(projectId, agentName) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/default-agent`, { agent: agentName }));
+}

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

@@ -0,0 +1,6 @@
+type ConnectorGrantBlock = {
+    connectors_required?: string[];
+    connectors_personal?: string[];
+};
+export declare function canonicalizeRequiredConnectors<T extends ConnectorGrantBlock>(block: T): T;
+export {};

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

@@ -0,0 +1,32 @@
+function normalizeConnectorList(values) {
+    const normalized = [];
+    for (const value of values) {
+        const slug = value.trim();
+        if (slug && !normalized.includes(slug))
+            normalized.push(slug);
+    }
+    return normalized;
+}
+function equalConnectorSets(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const rightSet = new Set(right);
+    return left.every((slug) => rightSet.has(slug));
+}
+export function canonicalizeRequiredConnectors(block) {
+    const canonical = block.connectors_required
+        ? normalizeConnectorList(block.connectors_required)
+        : undefined;
+    const legacy = block.connectors_personal
+        ? normalizeConnectorList(block.connectors_personal)
+        : undefined;
+    if (canonical && legacy && !equalConnectorSets(canonical, legacy)) {
+        throw new Error('connectors_personal must match connectors_required when both fields are present');
+    }
+    const next = { ...block };
+    delete next.connectors_personal;
+    if (canonical !== undefined || legacy !== undefined) {
+        next.connectors_required = canonical ?? legacy;
+    }
+    return next;
+}

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

@@ -0,0 +1,13 @@
+export type AgentGrantSet = string[] | 'all';
+export declare function setAgentScope(projectId: string, agentName: string, scope: {
+    env?: AgentGrantSet;
+    connectors?: AgentGrantSet;
+    connectors_required?: string[];
+    connectors_personal?: string[];
+}): Promise<{
+    ok: boolean;
+    agent: string;
+    env: AgentGrantSet;
+    connectors: AgentGrantSet;
+    connectors_required: string[];
+}>;

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

@@ -0,0 +1,7 @@
+import { backendApi } from '../../http/api-client.js';
+import { canonicalizeRequiredConnectors } from './agent-connectors.js';
+import { unwrap } from './shared.js';
+export async function setAgentScope(projectId, agentName, scope) {
+    const canonicalScope = canonicalizeRequiredConnectors(scope);
+    return unwrap(await backendApi.put(`/projects/${projectId}/agents/${encodeURIComponent(agentName)}/scope`, canonicalScope));
+}