@beeuni/sdk 0.1.0

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

@@ -0,0 +1,421 @@
+import { backendApi } from '../../http/api-client.js';
+import { ApiError } from '../../http/api/errors.js';
+import { authenticatedFetch } from '../../http/auth.js';
+import { platformConfig } from '../../http/config.js';
+import { unwrap } from './shared.js';
+function connectorGatewayPath(projectId, suffix) {
+    return projectId
+        ? `/connectors/projects/${encodeURIComponent(projectId)}/${suffix}`
+        : `/connectors/${suffix}`;
+}
+export async function getConnectorCatalog(projectId, options) {
+    const params = new URLSearchParams();
+    if (options?.slug)
+        params.set('slug', options.slug);
+    if (options?.includeSchemas !== undefined) {
+        params.set('include_schemas', String(options.includeSchemas));
+    }
+    if (options?.includeOutputSchemas)
+        params.set('include_output_schemas', 'true');
+    const query = params.toString() ? `?${params.toString()}` : '';
+    const result = unwrap(await backendApi.get(`${connectorGatewayPath(projectId, 'catalog')}${query}`));
+    return result.connectors ?? [];
+}
+export async function listConnectorTools(projectId) {
+    const tools = [];
+    for (const connector of await getConnectorCatalog(projectId, { includeSchemas: false })) {
+        for (const action of connector.actions) {
+            tools.push({
+                tool: `${connector.slug}.${action.path}`,
+                connector: connector.slug,
+                action: action.path,
+                risk: action.risk,
+                description: action.description || action.name,
+                inputSchema: action.inputSchema,
+            });
+        }
+    }
+    return tools;
+}
+export async function searchConnectorTools(projectId, query = '', options = {}) {
+    const normalized = query.trim().toLowerCase();
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    const exact = [];
+    const tokenMatches = [];
+    for (const tool of await listConnectorTools(projectId)) {
+        const haystack = `${tool.tool} ${tool.description}`.toLowerCase();
+        if (!normalized || haystack.includes(normalized))
+            exact.push(tool);
+        else if (tokens.every((token) => haystack.includes(token)))
+            tokenMatches.push(tool);
+    }
+    return [...exact, ...tokenMatches].slice(0, options.limit ?? 20);
+}
+export async function describeConnectorTool(projectId, tool) {
+    const separator = tool.indexOf('.');
+    if (separator < 0)
+        return null;
+    const connectorSlug = tool.slice(0, separator).trim();
+    if (!connectorSlug)
+        return null;
+    const connector = (await getConnectorCatalog(projectId, {
+        slug: connectorSlug,
+        includeSchemas: true,
+        includeOutputSchemas: true,
+    })).find((entry) => entry.slug === connectorSlug);
+    if (!connector)
+        return null;
+    for (const action of connector.actions) {
+        const candidateTool = `${connector.slug}.${action.path}`;
+        if (candidateTool === tool) {
+            return {
+                tool: candidateTool,
+                connector: connector.slug,
+                action: action.path,
+                risk: action.risk,
+                description: action.description || action.name,
+                inputSchema: action.inputSchema,
+                outputSchema: action.outputSchema ?? null,
+            };
+        }
+    }
+    return null;
+}
+function parseConnectorTool(tool) {
+    const separator = tool.indexOf('.');
+    const connector = separator < 0 ? '' : tool.slice(0, separator).trim();
+    const action = separator < 0 ? '' : tool.slice(separator + 1).trim();
+    if (!connector || !action) {
+        throw new Error('tool must use the connector.action format');
+    }
+    return { connector, action };
+}
+const CONNECTOR_CALL_TIMEOUT_MS = 90_000;
+export async function callConnector(projectId, tool, args = {}, options = {}) {
+    const { connector, action } = parseConnectorTool(tool);
+    const account = options.account?.trim();
+    const approvalContext = options.approvalContext?.trim();
+    const result = unwrap(await backendApi.post(connectorGatewayPath(projectId, 'call'), {
+        connector,
+        action,
+        args,
+        ...(account ? { account } : {}),
+        ...(approvalContext ? { approval_context: approvalContext } : {}),
+    }, { timeout: options.timeoutMs ?? CONNECTOR_CALL_TIMEOUT_MS, signal: options.signal }));
+    if (result.ok && result.binding !== undefined && !('output' in result))
+        result.output = result.data;
+    return result;
+}
+export async function listConnectorAccounts(projectId, slug) {
+    const response = await backendApi.get(connectorGatewayPath(projectId, `connectors/${encodeURIComponent(slug)}/accounts`));
+    return unwrap(response).accounts ?? [];
+}
+function connectorResponseMessage(body, status) {
+    if (body && typeof body === 'object') {
+        const value = body;
+        for (const key of ['reason', 'error', 'message', 'detail']) {
+            if (typeof value[key] === 'string' && value[key])
+                return value[key];
+        }
+    }
+    return `HTTP ${status}`;
+}
+function trimTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value.charCodeAt(end - 1) === 47)
+        end -= 1;
+    return end === value.length ? value : value.slice(0, end);
+}
+export async function uploadConnectorAttachment(projectId, content, input) {
+    const filename = input.filename.trim();
+    const contentType = input.contentType.trim();
+    if (!filename)
+        throw new Error('filename is required');
+    if (!contentType)
+        throw new Error('contentType is required');
+    const headers = {
+        'Content-Type': contentType,
+        'X-Beeuni-Attachment-Filename': encodeURIComponent(filename),
+        'X-Beeuni-Attachment-Disposition': input.contentDisposition ?? 'attachment',
+    };
+    if (input.contentId?.trim()) {
+        headers['X-Beeuni-Attachment-Content-Id'] = encodeURIComponent(input.contentId.trim());
+    }
+    if (input.connector?.trim()) {
+        headers['X-Beeuni-Attachment-Connector'] = encodeURIComponent(input.connector.trim());
+    }
+    const backendUrl = trimTrailingSlashes(platformConfig().backendUrl);
+    const endpoint = connectorGatewayPath(projectId, 'attachments');
+    const response = await authenticatedFetch(`${backendUrl}${endpoint}`, { method: 'POST', headers, body: content }, { timeoutMs: 60_000 });
+    const raw = await response.text();
+    let body = null;
+    if (raw) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = raw;
+        }
+    }
+    if (!response.ok) {
+        throw new ApiError(connectorResponseMessage(body, response.status), {
+            status: response.status,
+            code: body && typeof body === 'object'
+                ? String(body.code ?? response.status)
+                : String(response.status),
+            details: body,
+            response,
+            endpoint,
+        });
+    }
+    return body;
+}
+export function connectionSharedWithEveryone(connection) {
+    if (connection.owner_type !== 'project')
+        return false;
+    const shares = connection.shared_with ?? [];
+    return shares.length === 0 || shares.some((share) => share.principal_type === 'project');
+}
+export async function listConnections(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/connections`));
+}
+export async function listAllConnections(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/connections/all`));
+}
+export async function reconcileConnection(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connections`, input));
+}
+export async function reconcileMemberConnection(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connections/me`, input));
+}
+export async function updateConnectionCredential(projectId, connectionId, input) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/connections/${connectionId}/credential`, input));
+}
+function connectionOAuth2Path(projectId, connectionId, suffix) {
+    return `/projects/${projectId}/connections/${connectionId}/oauth2/${suffix}`;
+}
+export async function ensureProjectConnectorConnection(projectId, slug) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connectors/${encodeURIComponent(slug)}/oauth2/connection`, {}));
+}
+export async function putConnectionOAuth2Application(projectId, connectionId, input) {
+    return unwrap(await backendApi.put(connectionOAuth2Path(projectId, connectionId, 'application'), input));
+}
+export async function getConnectionOAuth2Application(projectId, connectionId) {
+    return unwrap(await backendApi.get(connectionOAuth2Path(projectId, connectionId, 'application')));
+}
+export async function discoverConnectionOAuth2(projectId, connectionId, input) {
+    return unwrap(await backendApi.post(connectionOAuth2Path(projectId, connectionId, 'discover'), input));
+}
+export async function discoverConnectionOAuth2Resource(projectId, connectionId, input = {}) {
+    return unwrap(await backendApi.post(connectionOAuth2Path(projectId, connectionId, 'discover-resource'), input));
+}
+export async function registerConnectionOAuth2Client(projectId, connectionId, input) {
+    return unwrap(await backendApi.post(connectionOAuth2Path(projectId, connectionId, 'register'), input));
+}
+export async function startConnectionOAuth2Authorization(projectId, connectionId, input) {
+    return unwrap(await backendApi.post(connectionOAuth2Path(projectId, connectionId, 'authorize'), input));
+}
+export async function startConnectionOAuth2DeviceAuthorization(projectId, connectionId, input) {
+    return unwrap(await backendApi.post(connectionOAuth2Path(projectId, connectionId, 'device'), input));
+}
+export async function pollConnectionOAuth2DeviceAuthorization(projectId, connectionId, sessionId) {
+    return unwrap(await backendApi.post(connectionOAuth2Path(projectId, connectionId, `device/${encodeURIComponent(sessionId)}`), {}));
+}
+export async function getConnectionOAuth2Status(projectId, connectionId) {
+    return unwrap(await backendApi.get(connectionOAuth2Path(projectId, connectionId, 'status')));
+}
+export async function revokeConnection(projectId, connectionId) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/connections/${connectionId}/revoke`, {}));
+}
+export async function activateConnection(projectId, connectionId) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/connections/${connectionId}/activate`, {}));
+}
+export async function setDefaultConnection(projectId, connectionId) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/connections/${connectionId}/default`, {}));
+}
+export async function renameConnection(projectId, connectionId, label) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/connections/${connectionId}/label`, {
+        label,
+    }));
+}
+export async function addComputerToProject(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/computers`, {
+        tunnel_id: input.tunnelId,
+        ...(input.share ? { share: input.share } : {}),
+    }));
+}
+export async function shareConnection(projectId, connectionId, principals = []) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connections/${connectionId}/share`, {
+        principals,
+    }));
+}
+export async function pipedreamConnectConnection(projectId, connectionId, input = {}) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connections/${connectionId}/connect`, input));
+}
+export async function pipedreamFinalizeConnection(projectId, connectionId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connections/${connectionId}/connect/finalize`, {}));
+}
+export async function listConnectors(projectId, options) {
+    const query = options?.includeSchemas === undefined ? '' : `?include_schemas=${options.includeSchemas}`;
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/connectors${query}`, { showErrors: false }));
+}
+export async function syncConnectors(projectId) {
+    return unwrap(await backendApi.post(`/connectors/projects/${projectId}/connectors/sync`, {}));
+}
+export async function setConnectorCredentialMode(projectId, slug, mode) {
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/credential-mode`, { mode }));
+}
+export async function setConnectorAuthorizationStrategy(projectId, slug, authorizationStrategy) {
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/authorization-strategy`, { authorization_strategy: authorizationStrategy }));
+}
+export async function setConnectorSensitive(projectId, slug, sensitive) {
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/sensitive`, { sensitive }));
+}
+export async function getConnectorPolicies(projectId, slug) {
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/policies`));
+}
+export async function setConnectorPolicies(projectId, slug, policies) {
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/policies`, { policies }));
+}
+export async function getConnectionPolicies(_projectId, _connectionId) {
+    throw new Error('Connection-specific policies were removed. Use getConnectorPolicies(projectId, slug).');
+}
+export async function setConnectionPolicies(_projectId, _connectionId, _policies) {
+    throw new Error('Connection-specific policies were removed. Use setConnectorPolicies(projectId, slug, policies).');
+}
+export async function getConnectorConfig(projectId, slug) {
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/config`));
+}
+export async function setConnectorName(projectId, slug, name) {
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/name`, { name }));
+}
+export async function connectorConnect(projectId, slug, options = {}) {
+    return unwrap(await backendApi.post(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/connect`, {
+        ...(options.owner ? { owner: options.owner } : {}),
+        ...(options.successRedirectUri ? { success_redirect_uri: options.successRedirectUri } : {}),
+        ...(options.errorRedirectUri ? { error_redirect_uri: options.errorRedirectUri } : {}),
+    }));
+}
+export const pipedreamConnect = connectorConnect;
+export async function listSessionConnectRequests(projectId, sessionId) {
+    const result = unwrap(await backendApi.get(`/connectors/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/connect-requests`));
+    return result.connectors ?? [];
+}
+export async function createConnector(projectId, draft) {
+    return unwrap(await backendApi.post(`/connectors/projects/${projectId}/connectors`, draft));
+}
+export async function discoverConnectorAuth(projectId, draft) {
+    return unwrap(await backendApi.post(`/connectors/projects/${projectId}/connectors/auth-discovery`, draft));
+}
+export async function deleteConnector(projectId, slug) {
+    return unwrap(await backendApi.delete(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}`));
+}
+export async function listPipedreamApps(projectId, qOrQuery, cursor) {
+    const query = typeof qOrQuery === 'string' || qOrQuery === undefined
+        ? { ...(qOrQuery ? { q: qOrQuery } : {}), ...(cursor ? { cursor } : {}) }
+        : qOrQuery;
+    const params = new URLSearchParams();
+    if (query.q)
+        params.set('q', query.q);
+    if (query.category)
+        params.set('category', query.category);
+    if (query.cursor)
+        params.set('cursor', query.cursor);
+    if (query.limit)
+        params.set('limit', String(query.limit));
+    const qs = params.toString();
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/pipedream/apps${qs ? `?${qs}` : ''}`));
+}
+export async function listPipedreamSections(projectId, opts) {
+    const params = new URLSearchParams();
+    if (opts?.perCategory)
+        params.set('perCategory', String(opts.perCategory));
+    if (opts?.maxCategories)
+        params.set('maxCategories', String(opts.maxCategories));
+    const qs = params.toString();
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/pipedream/sections${qs ? `?${qs}` : ''}`));
+}
+export async function listConnectToolkits(projectId, query = {}) {
+    const params = new URLSearchParams();
+    if (query.q)
+        params.set('q', query.q);
+    if (query.category)
+        params.set('category', query.category);
+    if (query.cursor)
+        params.set('cursor', query.cursor);
+    if (query.limit)
+        params.set('limit', String(query.limit));
+    const qs = params.toString();
+    const page = unwrap(await backendApi.get(`/connectors/projects/${projectId}/connect/toolkits${qs ? `?${qs}` : ''}`));
+    if ('toolkits' in page)
+        return page;
+    const nextCursor = page.cursor?.trim() || undefined;
+    return {
+        provider: 'composio',
+        toolkits: page.items,
+        nextCursor,
+        hasMore: Boolean(nextCursor),
+    };
+}
+export async function listConnectSections(projectId, opts) {
+    const params = new URLSearchParams();
+    if (opts?.perCategory)
+        params.set('perCategory', String(opts.perCategory));
+    if (opts?.maxCategories)
+        params.set('maxCategories', String(opts.maxCategories));
+    const qs = params.toString();
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/connect/sections${qs ? `?${qs}` : ''}`));
+}
+export async function listDiscoverConnectors(projectId, qOrQuery, cursor) {
+    const query = typeof qOrQuery === 'string' || qOrQuery === undefined
+        ? { ...(qOrQuery ? { q: qOrQuery } : {}), ...(cursor ? { cursor } : {}) }
+        : qOrQuery;
+    const params = new URLSearchParams();
+    if (query.q)
+        params.set('q', query.q);
+    if (query.category)
+        params.set('category', query.category);
+    if (query.cursor)
+        params.set('cursor', query.cursor);
+    if (query.limit)
+        params.set('limit', String(query.limit));
+    const qs = params.toString();
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/discover/connectors${qs ? `?${qs}` : ''}`));
+}
+export async function listDiscoverSections(projectId, opts) {
+    const params = new URLSearchParams();
+    if (opts?.perCategory)
+        params.set('perCategory', String(opts.perCategory));
+    if (opts?.maxCategories)
+        params.set('maxCategories', String(opts.maxCategories));
+    const qs = params.toString();
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/discover/sections${qs ? `?${qs}` : ''}`));
+}
+export async function getDiscoverConnector(projectId, id) {
+    const params = new URLSearchParams({ id });
+    return unwrap(await backendApi.get(`/connectors/projects/${projectId}/discover/connectors/detail?${params.toString()}`));
+}
+export const listDiscoverIntegrations = listDiscoverConnectors;
+export const getDiscoverIntegration = getDiscoverConnector;
+export async function getConnectStatus() {
+    return unwrap(await backendApi.get('/connectors/connect-status'));
+}
+export async function setConnectorCredential(projectId, slug, credential) {
+    const input = typeof credential === 'string' ? { value: credential } : credential;
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/credential`, input));
+}
+export async function deleteConnectorCredential(projectId, slug) {
+    return unwrap(await backendApi.delete(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/credential`));
+}
+export async function setConnectorSecretBinding(projectId, slug, secretIdentifier) {
+    return unwrap(await backendApi.put(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/secret-binding`, { secret_identifier: secretIdentifier }));
+}
+export async function connectorFinalize(projectId, slug, options = {}) {
+    const body = {};
+    if (options.owner)
+        body.owner = options.owner;
+    if (options.connectionId)
+        body.connection_id = options.connectionId;
+    return unwrap(await backendApi.post(`/connectors/projects/${projectId}/connectors/${encodeURIComponent(slug)}/connect/finalize`, body));
+}
+export const pipedreamFinalize = connectorFinalize;

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

@@ -0,0 +1,149 @@
+export type FolderLevel = 'read' | 'write' | 'manage';
+export type FolderAccess = 'none' | FolderLevel;
+export type FolderPrincipalType = 'user' | 'group' | 'agent' | 'project';
+export interface Drive {
+    driveId: string;
+    accountId: string;
+    projectId: string;
+    kind: 'project';
+    name: string;
+    sizeBytes: number | null;
+    sizeLimitBytes: number | null;
+    fileCount: number | null;
+    lastChangeAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    access: FolderAccess;
+    personalFolder: string | null;
+    openConflicts?: number;
+    sharedWithMe?: Array<{
+        path: string;
+        access: FolderAccess;
+    }>;
+}
+export interface DriveEntry {
+    path: string;
+    name: string;
+    type: 'file' | 'dir' | 'symlink';
+    size: number;
+    mtime: number;
+    access: FolderAccess;
+    shared?: boolean;
+}
+export interface DriveVersion {
+    id: string;
+    createdAt: string;
+    kind: 'created' | 'edit' | 'sync' | 'restore';
+    author: 'drive' | 'session' | 'system';
+    changes: {
+        changed: number;
+        deleted: number;
+    };
+}
+export interface FolderGrant {
+    grantId: string;
+    path: string;
+    inherited: boolean;
+    system: boolean;
+    principalType: FolderPrincipalType;
+    principalId: string;
+    label: string;
+    level: FolderLevel;
+}
+export interface FolderAccessView {
+    path: string;
+    access: FolderAccess;
+    grantable: boolean;
+    grants: FolderGrant[];
+}
+export interface FolderPrincipals {
+    people: Array<{
+        id: string;
+        label: string;
+    }>;
+    teams: Array<{
+        id: string;
+        label: string;
+    }>;
+    agents: Array<{
+        id: string;
+        label: string;
+    }>;
+}
+export interface DriveConflict {
+    conflictId: string;
+    path: string;
+    originalPath: string;
+    detectedAt: string;
+}
+export interface SessionDrive {
+    driveId: string;
+    name: string;
+    kind: 'project';
+    mountPath: string;
+    readOnly: boolean;
+    subdir: string;
+    role?: 'me' | 'drive';
+    openConflicts?: number;
+}
+export interface SessionDrives {
+    drives: SessionDrive[];
+    personal: boolean;
+    skipped?: Array<{
+        driveId: string;
+        name: string;
+    }>;
+    skippedMessage?: string | null;
+}
+export declare function getProjectDrive(projectId: string): Promise<Drive>;
+export declare function getFolderAccess(driveId: string, path: string): Promise<FolderAccessView>;
+export declare function shareFolder(driveId: string, input: {
+    path: string;
+    principalType: FolderPrincipalType;
+    principalId?: string;
+    level: FolderLevel;
+}): Promise<{
+    grantId: string;
+    pendingSessions?: number;
+}>;
+export declare function unshareFolder(driveId: string, grantId: string): Promise<{
+    pendingSessions: number;
+}>;
+export declare function listFolderPrincipals(driveId: string): Promise<FolderPrincipals>;
+export declare function listDriveConflicts(driveId: string): Promise<DriveConflict[]>;
+export declare function dismissDriveConflict(driveId: string, conflictId: string): Promise<void>;
+export declare function listDriveFiles(driveId: string, path?: string): Promise<DriveEntry[]>;
+export declare function listDriveFolder(driveId: string, path?: string): Promise<{
+    entries: DriveEntry[];
+    access: FolderAccess;
+}>;
+export declare function getDriveFileUrl(driveId: string, path: string, options?: {
+    download?: boolean;
+}): string;
+export declare function downloadDriveFile(driveId: string, path: string, signal?: AbortSignal): Promise<Blob>;
+export declare function readDriveFile(driveId: string, path: string, signal?: AbortSignal): Promise<{
+    blob: Blob;
+    version: string | null;
+}>;
+export declare function uploadDriveFile(driveId: string, path: string, body: Blob | ArrayBuffer | Uint8Array<ArrayBuffer>, options?: {
+    signal?: AbortSignal;
+    ifMatch?: string | null;
+}): Promise<{
+    path: string;
+    size: number;
+    version?: string;
+}>;
+export declare function makeDriveFolder(driveId: string, path: string): Promise<{
+    path: string;
+}>;
+export declare function moveDriveFile(driveId: string, from: string, to: string): Promise<{
+    from: string;
+    to: string;
+}>;
+export declare function deleteDriveFile(driveId: string, path: string, options?: {
+    recursive?: boolean;
+}): Promise<void>;
+export declare function listDriveVersions(driveId: string): Promise<DriveVersion[]>;
+export declare function restoreDriveVersion(driveId: string, versionId: string): Promise<void>;
+export declare function listSessionDrives(projectId: string, sessionId: string): Promise<SessionDrive[]>;
+export declare function getSessionDrives(projectId: string, sessionId: string): Promise<SessionDrives>;

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

@@ -0,0 +1,88 @@
+import { ApiError, backendApi } from '../../http/api-client.js';
+import { authenticatedFetch } from '../../http/auth.js';
+import { platformConfig } from '../../http/config.js';
+import { unwrap } from './shared.js';
+import { stripTrailingSlashes } from '../../../platform/strings.js';
+const drivePath = (driveId) => `/drives/${encodeURIComponent(driveId)}`;
+export async function getProjectDrive(projectId) {
+    const drives = unwrap(await backendApi.get(`/drives?${new URLSearchParams({ projectId })}`), 'Failed to load files').drives;
+    if (!drives[0])
+        throw new ApiError('Files not found', { status: 404 });
+    return drives[0];
+}
+export async function getFolderAccess(driveId, path) {
+    return unwrap(await backendApi.get(`${drivePath(driveId)}/access?${new URLSearchParams({ path })}`), 'Failed to load sharing');
+}
+export async function shareFolder(driveId, input) {
+    return unwrap(await backendApi.put(`${drivePath(driveId)}/access`, input), 'Failed to share folder');
+}
+export async function unshareFolder(driveId, grantId) {
+    const res = unwrap(await backendApi.delete(`${drivePath(driveId)}/access/${encodeURIComponent(grantId)}`), 'Failed to stop sharing');
+    return { pendingSessions: typeof res?.pendingSessions === 'number' ? res.pendingSessions : 0 };
+}
+export async function listFolderPrincipals(driveId) {
+    return unwrap(await backendApi.get(`${drivePath(driveId)}/principals`), 'Failed to load people');
+}
+export async function listDriveConflicts(driveId) {
+    return unwrap(await backendApi.get(`${drivePath(driveId)}/conflicts`), 'Failed to load conflicts').conflicts;
+}
+export async function dismissDriveConflict(driveId, conflictId) {
+    unwrap(await backendApi.post(`${drivePath(driveId)}/conflicts/${encodeURIComponent(conflictId)}/dismiss`, {}), 'Failed to dismiss conflict');
+}
+export async function listDriveFiles(driveId, path = '/') {
+    return (await listDriveFolder(driveId, path)).entries;
+}
+export async function listDriveFolder(driveId, path = '/') {
+    return unwrap(await backendApi.get(`${drivePath(driveId)}/files?${new URLSearchParams({ path })}`), 'Failed to load files');
+}
+export function getDriveFileUrl(driveId, path, options) {
+    const base = stripTrailingSlashes(platformConfig().backendUrl);
+    const query = { path };
+    if (options?.download)
+        query.download = '1';
+    return `${base}${drivePath(driveId)}/files/content?${new URLSearchParams(query)}`;
+}
+export async function downloadDriveFile(driveId, path, signal) {
+    const response = await authenticatedFetch(getDriveFileUrl(driveId, path), { signal });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => null));
+        throw new ApiError(body?.message || 'Could not download file', { status: response.status });
+    }
+    return response.blob();
+}
+export async function readDriveFile(driveId, path, signal) {
+    const response = await authenticatedFetch(getDriveFileUrl(driveId, path), { signal });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => null));
+        throw new ApiError(body?.message || 'Could not download file', { status: response.status });
+    }
+    return { blob: await response.blob(), version: response.headers.get('etag') };
+}
+export async function uploadDriveFile(driveId, path, body, options) {
+    return unwrap(await backendApi.putRaw(`${drivePath(driveId)}/files/content?${new URLSearchParams({ path })}`, body, { signal: options?.signal, ...(options?.ifMatch ? { headers: { 'If-Match': options.ifMatch } } : {}) }), 'Failed to upload file');
+}
+export async function makeDriveFolder(driveId, path) {
+    return unwrap(await backendApi.post(`${drivePath(driveId)}/files/mkdir`, { path }), 'Failed to create folder');
+}
+export async function moveDriveFile(driveId, from, to) {
+    return unwrap(await backendApi.post(`${drivePath(driveId)}/files/move`, { from, to }), 'Failed to move');
+}
+export async function deleteDriveFile(driveId, path, options) {
+    const query = { path };
+    if (options?.recursive)
+        query.recursive = 'true';
+    unwrap(await backendApi.delete(`${drivePath(driveId)}/files?${new URLSearchParams(query)}`), 'Failed to delete');
+}
+export async function listDriveVersions(driveId) {
+    return unwrap(await backendApi.get(`${drivePath(driveId)}/versions`), 'Failed to load versions').versions;
+}
+export async function restoreDriveVersion(driveId, versionId) {
+    unwrap(await backendApi.post(`${drivePath(driveId)}/restore`, { versionId }), 'Failed to restore version');
+}
+const sessionDrivesPath = (projectId, sessionId) => `/projects/${encodeURIComponent(projectId)}/sessions/${encodeURIComponent(sessionId)}/drives`;
+export async function listSessionDrives(projectId, sessionId) {
+    return (await getSessionDrives(projectId, sessionId)).drives;
+}
+export async function getSessionDrives(projectId, sessionId) {
+    return unwrap(await backendApi.get(sessionDrivesPath(projectId, sessionId)), 'Failed to load session files');
+}