@beeuni/sdk 0.1.0

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

@@ -0,0 +1,87 @@
+import { backendApi } from '../../http/api-client.js';
+import { sendChecked } from '../../http/transport.js';
+import { platformConfig } from '../../http/config.js';
+import { unwrap } from './shared.js';
+function appendScopeOptions(query, options) {
+    if (options.accountId)
+        query.set('account_id', options.accountId);
+    if (options.projectId)
+        query.set('project_id', options.projectId);
+}
+function appendWindow(query, options) {
+    if (options.from)
+        query.set('from', options.from);
+    if (options.to)
+        query.set('to', options.to);
+}
+function suffix(query) {
+    return query.size > 0 ? `?${query}` : '';
+}
+export async function listSessionCosts(options = {}) {
+    const query = new URLSearchParams();
+    appendScopeOptions(query, options);
+    if (options.ownerId)
+        query.set('owner_id', options.ownerId);
+    appendWindow(query, options);
+    if (options.sort)
+        query.set('sort', options.sort);
+    if (options.limit != null)
+        query.set('limit', String(options.limit));
+    if (options.offset != null)
+        query.set('offset', String(options.offset));
+    return unwrap(await backendApi.get(`/usage/session-costs${suffix(query)}`));
+}
+export async function getSessionCostRecord(sessionId, options = {}) {
+    const query = new URLSearchParams();
+    appendScopeOptions(query, options);
+    return unwrap(await backendApi.get(`/usage/session-costs/${encodeURIComponent(sessionId)}${suffix(query)}`));
+}
+export async function listCostByProject(options = {}) {
+    const query = new URLSearchParams();
+    if (options.accountId)
+        query.set('account_id', options.accountId);
+    appendWindow(query, options);
+    if (options.sort)
+        query.set('sort', options.sort);
+    if (options.limit != null)
+        query.set('limit', String(options.limit));
+    if (options.offset != null)
+        query.set('offset', String(options.offset));
+    return unwrap(await backendApi.get(`/usage/cost-by-project${suffix(query)}`));
+}
+export async function getCostSummary(options = {}) {
+    const query = new URLSearchParams();
+    appendScopeOptions(query, options);
+    if (options.sessionId)
+        query.set('session_id', options.sessionId);
+    appendWindow(query, options);
+    return unwrap(await backendApi.get(`/usage/cost-summary${suffix(query)}`));
+}
+export function costExportUrl(kind, options = {}) {
+    const query = new URLSearchParams();
+    if (options.accountId)
+        query.set('account_id', options.accountId);
+    if (options.projectId)
+        query.set('project_id', options.projectId);
+    if (kind === 'sessions') {
+        const sessionOptions = options;
+        if (sessionOptions.ownerId)
+            query.set('owner_id', sessionOptions.ownerId);
+    }
+    appendWindow(query, options);
+    if (options.sort)
+        query.set('sort', options.sort);
+    query.set('format', 'csv');
+    const path = kind === 'projects' ? '/usage/cost-by-project' : '/usage/session-costs';
+    return `${platformConfig().backendUrl || ''}${path}?${query}`;
+}
+export async function fetchCostExportCsv(kind, options = {}) {
+    const url = kind === 'projects'
+        ? costExportUrl('projects', options)
+        : costExportUrl('sessions', options);
+    const res = await sendChecked(url, { method: 'GET' }, { timeoutMs: 10 * 60_000 }, 'Failed to export CSV');
+    const rowCapHeader = res.headers.get('x-beeuni-row-cap');
+    const parsedRowCap = rowCapHeader != null ? Number(rowCapHeader) : NaN;
+    const blob = await res.blob();
+    return { blob, rowCap: Number.isFinite(parsedRowCap) ? parsedRowCap : null };
+}

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

@@ -0,0 +1,10 @@
+import type { SessionPrompt } from './sessions.js';
+export interface SessionPromptViewer {
+    userId: string | null | undefined;
+    managesSession?: boolean;
+}
+export interface SessionPromptActions {
+    own: boolean;
+    removable: boolean;
+}
+export declare function sessionPromptActions(prompt: Pick<SessionPrompt, 'author_user_id'>, viewer: SessionPromptViewer): SessionPromptActions;

package/dist/core/rest/projects-client/session-prompt-actions.js

@@ -0,0 +1,4 @@
+export function sessionPromptActions(prompt, viewer) {
+    const own = prompt.author_user_id === undefined || !viewer.userId || prompt.author_user_id === viewer.userId;
+    return { own, removable: own || viewer.managesSession === true };
+}

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

@@ -0,0 +1,58 @@
+export type SessionReminderState = 'active' | 'paused' | 'done';
+export interface SessionReminder {
+    id: string;
+    session_id: string | null;
+    name: string | null;
+    prompt: string;
+    every: string | null;
+    every_seconds: number | null;
+    cron: string | null;
+    timezone: string;
+    at: string | null;
+    state: SessionReminderState;
+    next_fire_at: string | null;
+    last_fired_at: string | null;
+    last_status: string | null;
+    last_error: string | null;
+    created_by: string | null;
+    created_at: string | null;
+}
+export interface CreateSessionReminderInput {
+    prompt: string;
+    name?: string;
+    every?: string | number;
+    cron?: string;
+    timezone?: string;
+    at?: string;
+    in?: string | number;
+}
+export interface UpdateSessionReminderInput {
+    enabled: boolean;
+}
+export declare function listSessionReminders(projectId: string, sessionId: string): Promise<{
+    reminders: SessionReminder[];
+}>;
+export declare function createSessionReminder(projectId: string, sessionId: string, input: CreateSessionReminderInput): Promise<SessionReminder>;
+export declare function updateSessionReminder(projectId: string, sessionId: string, reminderId: string, input: UpdateSessionReminderInput): Promise<SessionReminder>;
+export declare function deleteSessionReminder(projectId: string, sessionId: string, reminderId: string): Promise<{
+    ok: boolean;
+}>;
+export interface SessionReminderRef {
+    sessionId: string;
+    reminderId: string;
+}
+export interface SessionReminderBatchResult {
+    done: SessionReminderRef[];
+    failed: {
+        reminder: SessionReminderRef;
+        error: unknown;
+    }[];
+}
+export declare function updateSessionReminders(projectId: string, reminders: readonly SessionReminderRef[], input: UpdateSessionReminderInput): Promise<SessionReminderBatchResult>;
+export declare function deleteSessionReminders(projectId: string, reminders: readonly SessionReminderRef[]): Promise<SessionReminderBatchResult>;
+export interface ProjectReminder extends SessionReminder {
+    session_name: string | null;
+}
+export declare function listProjectReminders(projectId: string): Promise<{
+    reminders: ProjectReminder[];
+}>;

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

@@ -0,0 +1,50 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listSessionReminders(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/reminders`));
+}
+export async function createSessionReminder(projectId, sessionId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/reminders`, input));
+}
+export async function updateSessionReminder(projectId, sessionId, reminderId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/sessions/${sessionId}/reminders/${reminderId}`, input));
+}
+export async function deleteSessionReminder(projectId, sessionId, reminderId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/sessions/${sessionId}/reminders/${reminderId}`));
+}
+const BATCH_CONCURRENCY = 4;
+async function runBatch(reminders, run) {
+    const outcomes = new Array(reminders.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < reminders.length) {
+            const index = next++;
+            try {
+                await run(reminders[index]);
+                outcomes[index] = { ok: true };
+            }
+            catch (error) {
+                outcomes[index] = { ok: false, error };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(BATCH_CONCURRENCY, reminders.length) }, worker));
+    const result = { done: [], failed: [] };
+    reminders.forEach((reminder, index) => {
+        const outcome = outcomes[index];
+        if (outcome.ok)
+            result.done.push(reminder);
+        else
+            result.failed.push({ reminder, error: outcome.error });
+    });
+    return result;
+}
+export function updateSessionReminders(projectId, reminders, input) {
+    return runBatch(reminders, (r) => updateSessionReminder(projectId, r.sessionId, r.reminderId, input));
+}
+export function deleteSessionReminders(projectId, reminders) {
+    return runBatch(reminders, (r) => deleteSessionReminder(projectId, r.sessionId, r.reminderId));
+}
+export async function listProjectReminders(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/reminders`));
+}

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

@@ -0,0 +1,85 @@
+import type { ProjectSession } from "./sessions.js";
+export type ProjectSessionSandboxStatus = "provisioning" | "active" | "stopped" | "error" | "archived";
+export interface ProjectSessionSandbox {
+    sandbox_id: string;
+    session_id: string;
+    project_id: string;
+    account_id: string;
+    provider: "daytona" | "platinum" | "e2b";
+    external_id: string | null;
+    base_url: string | null;
+    status: ProjectSessionSandboxStatus;
+    config: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    last_used_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export type SessionStartStage = "provisioning" | "starting" | "ready" | "stopped" | "failed";
+export interface SessionStartFailure {
+    category: 'provider-capacity' | 'git-auth' | 'sandbox-provider' | 'unsupported-secret-delivery' | 'invalid-secret-boundary-policy' | 'snapshot-too-large' | 'drives-unavailable';
+    message: string;
+    retryable: boolean;
+    evidence?: {
+        check: string;
+        observed_at: string | null;
+        error: string | null;
+        attempts: number;
+        next_retry_at: string | null;
+    };
+}
+export interface SessionStartResult {
+    stage: SessionStartStage;
+    agent_name: string;
+    retriable: boolean;
+    sandbox: ProjectSessionSandbox | null;
+    runtime_session_id?: string | null;
+    opencode_session_id: string | null;
+    failure?: SessionStartFailure | null;
+    runtime_url?: string | null;
+    reason?: string;
+    capabilities?: string[];
+    observed_at?: string;
+    action?: "inspected" | "checked_provider" | "resumed" | "provisioned" | "restored" | "reconciled" | "awaited_wake" | "cooling_down";
+    boot?: {
+        phase: "provisioning" | "resuming" | "booting" | "ready" | "parked" | "failed";
+        since: string | null;
+        actively_starting: boolean;
+    };
+    observation?: {
+        provider: {
+            known: boolean;
+            status: string | null;
+            checked_at: string | null;
+        };
+        runtime: {
+            known: boolean;
+            state: "ready" | "booting" | "unreachable" | null;
+            boot_phase: string | null;
+            checked_at: string | null;
+        };
+    };
+    runtime_transport?: 'rest';
+}
+export declare function projectSessionStartSeed(session: ProjectSession): SessionStartResult | null;
+export declare class SessionStartError extends Error {
+    status?: number;
+    code?: string;
+    terminal: boolean;
+    constructor(message: string, options: {
+        status?: number;
+        code?: string;
+        terminal: boolean;
+    });
+}
+export declare function isSessionStartError(error: unknown): error is SessionStartError;
+type SessionStartOptions = number | {
+    waitMs?: number;
+    repositoryMode?: "previous";
+    keepStopped?: boolean;
+    intentAgeMs?: number;
+};
+export declare function startProjectSession(projectId: string, sessionId: string, options?: SessionStartOptions): Promise<SessionStartResult | null>;
+export declare function startProjectSessionOrThrow(projectId: string, sessionId: string, options?: SessionStartOptions): Promise<SessionStartResult>;
+export declare function sessionStartKey(projectId: string, sessionId: string): readonly ["session-start", string, string];
+export {};

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

@@ -0,0 +1,113 @@
+import { backendApi } from "../../http/api-client.js";
+import { isSessionFresh } from "../../http/fresh-sessions.js";
+import { setSessionRuntime } from "../../session/session-runtime-registry.js";
+import { getSandboxUrlForExternalId } from "../../session/server-store/url-helpers.js";
+export function projectSessionStartSeed(session) {
+    if (session.status !== "running" ||
+        !session.sandbox_id ||
+        !session.sandbox_provider ||
+        !session.sandbox_url ||
+        !(session.runtime_session_id ?? session.opencode_session_id)) {
+        return null;
+    }
+    const runtimeSessionId = session.runtime_session_id ?? session.opencode_session_id;
+    const externalId = session.sandbox_url.match(/\/p\/([^/]+)\//)?.[1];
+    if (!externalId)
+        return null;
+    return {
+        stage: "ready",
+        agent_name: session.agent_name ?? "default",
+        retriable: true,
+        sandbox: {
+            sandbox_id: session.sandbox_id,
+            session_id: session.session_id,
+            project_id: session.project_id,
+            account_id: session.account_id,
+            provider: session.sandbox_provider,
+            external_id: externalId,
+            base_url: session.sandbox_url,
+            status: "active",
+            config: {},
+            metadata: session.metadata,
+            last_used_at: session.updated_at,
+            created_at: session.created_at,
+            updated_at: session.updated_at,
+        },
+        runtime_session_id: runtimeSessionId,
+        opencode_session_id: runtimeSessionId,
+        runtime_url: session.sandbox_url,
+    };
+}
+export class SessionStartError extends Error {
+    status;
+    code;
+    terminal;
+    constructor(message, options) {
+        super(message);
+        this.name = "SessionStartError";
+        this.status = options.status;
+        this.code = options.code;
+        this.terminal = options.terminal;
+    }
+}
+export function isSessionStartError(error) {
+    return error instanceof Error && error.name === "SessionStartError";
+}
+function classifySessionStartFailure(error) {
+    const apiError = error;
+    const status = apiError?.status;
+    const code = apiError?.code ?? apiError?.details?.code ?? apiError?.details?.error;
+    const message = apiError?.message || "Unable to start this session";
+    if (status && status >= 400 && status < 500 && status !== 408 && status !== 429) {
+        return new SessionStartError(message, { status, code, terminal: true });
+    }
+    return null;
+}
+function postSessionStart(projectId, sessionId, options) {
+    const waitMs = typeof options === "number" ? options : options?.waitMs;
+    const repositoryMode = typeof options === "number" ? undefined : options?.repositoryMode;
+    const search = new URLSearchParams();
+    if (waitMs && waitMs > 0)
+        search.set("wait_ms", String(Math.floor(waitMs)));
+    if (repositoryMode)
+        search.set("repository_mode", repositoryMode);
+    if (typeof options === "object" && options?.keepStopped)
+        search.set("keep_stopped", "1");
+    if (typeof options === "object" && options?.intentAgeMs && options.intentAgeMs > 0) {
+        search.set("intent_age_ms", String(Math.floor(options.intentAgeMs)));
+    }
+    const qs = search.size > 0 ? `?${search.toString()}` : "";
+    return backendApi.post(`/projects/${projectId}/sessions/${sessionId}/start${qs}`, {}, { showErrors: false });
+}
+export async function startProjectSession(projectId, sessionId, options) {
+    const response = await postSessionStart(projectId, sessionId, options);
+    if (!response.success || !response.data) {
+        const terminal = classifySessionStartFailure(response.error);
+        if (terminal && !(terminal.status === 404 && isSessionFresh(sessionId)))
+            throw terminal;
+        return null;
+    }
+    return recordReadyRuntime(projectId, sessionId, response.data);
+}
+export async function startProjectSessionOrThrow(projectId, sessionId, options) {
+    const response = await postSessionStart(projectId, sessionId, options);
+    if (!response.success || !response.data)
+        throw response.error ?? new Error("Unable to start this session");
+    return recordReadyRuntime(projectId, sessionId, response.data);
+}
+function recordReadyRuntime(projectId, sessionId, result) {
+    const externalId = result.sandbox?.external_id;
+    const runtimeSessionId = result.runtime_session_id ?? result.opencode_session_id;
+    if (result.stage === "ready" && externalId && runtimeSessionId) {
+        setSessionRuntime(projectId, sessionId, {
+            runtimeSessionId,
+            opencodeSessionId: runtimeSessionId,
+            runtimeUrl: getSandboxUrlForExternalId(externalId),
+            sandboxId: externalId,
+        });
+    }
+    return result;
+}
+export function sessionStartKey(projectId, sessionId) {
+    return ["session-start", projectId, sessionId];
+}