eai-cli 0.0.0-bootstrap.0

package/dist/lib/api.js

@@ -0,0 +1,991 @@
+/**
+ * Platform API client for CLI — wraps PublicAPI calls with auth.
+ *
+ * Unlike the Platform SDK (which goes through the BFF proxy),
+ * the CLI calls PublicAPI directly with a Bearer token from browser-based
+ * authorization code flow with PKCE.
+ */
+import { getAccessToken } from './auth.js';
+import { toObjectTypeSlug } from './utils.js';
+const PUBLIC_AI_PATH = '/v4/ai';
+const PUBLIC_DATA_DOCUMENTS_PATH = '/v4/data/documents';
+const PUBLIC_DATA_RESOURCES_PATH = '/v4/data/resources';
+const PUBLIC_GEO_PATH = '/v4/geo';
+const PUBLIC_IDENTITY_PATH = '/v4/identity';
+const PUBLIC_INTEGRATIONS_PATH = '/v4/integrations';
+const PUBLIC_PLATFORM_PATH = '/v4/platform';
+const PUBLIC_REALTIME_PATH = '/v4/realtime';
+const PUBLIC_VERTICALS_DAISY_PATH = '/v4/verticals/daisy';
+const PUBLIC_WEBHOOKS_PATH = '/v4/webhooks';
+const PUBLIC_WORKFLOWS_PATH = '/v4/workflows';
+const PUBLIC_API_V4_PATH_PREFIXES = [
+    PUBLIC_AI_PATH,
+    PUBLIC_DATA_DOCUMENTS_PATH,
+    PUBLIC_DATA_RESOURCES_PATH,
+    PUBLIC_GEO_PATH,
+    PUBLIC_IDENTITY_PATH,
+    PUBLIC_INTEGRATIONS_PATH,
+    PUBLIC_PLATFORM_PATH,
+    PUBLIC_REALTIME_PATH,
+    PUBLIC_VERTICALS_DAISY_PATH,
+    PUBLIC_WEBHOOKS_PATH,
+    PUBLIC_WORKFLOWS_PATH,
+];
+function formatApiRequestErrorMessage(options) {
+    return `${options.operation} failed`;
+}
+export class PlatformAPIRequestError extends Error {
+    operation;
+    status;
+    statusText;
+    serverMessage;
+    serverCode;
+    requestId;
+    rawBody;
+    constructor(options) {
+        super(formatApiRequestErrorMessage(options));
+        this.name = 'PlatformAPIRequestError';
+        this.operation = options.operation;
+        this.status = options.status;
+        this.statusText = options.statusText;
+        this.serverMessage = options.serverMessage;
+        this.serverCode = options.serverCode;
+        this.requestId = options.requestId;
+        this.rawBody = options.rawBody;
+    }
+}
+/**
+ * Best-effort extraction of server-provided diagnostic context from a failed
+ * Response. Tolerates non-JSON bodies and FastAPI/Pydantic error envelopes
+ * (``{detail: "..."}``, ``{detail: {message, code}}``, ``{errors: [...]}``).
+ *
+ * Always returns the raw text so ``--debug`` can show the full body, even
+ * when no message field could be parsed.
+ */
+/**
+ * Coerce a server-provided error field to a string. Platform responses
+ * sometimes nest a structured object in message/error/detail/code despite the
+ * declared string shape; returning a non-string here previously crashed
+ * callers that assume a string (e.g. `.trim()`).
+ */
+function coerceServerMessage(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value == null) {
+        return undefined;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export async function extractServerErrorContext(res) {
+    const requestId = res.headers.get('x-request-id') ?? res.headers.get('x-correlation-id') ?? undefined;
+    const rawBody = await res.text().catch(() => '');
+    if (!rawBody) {
+        return { requestId, rawBody: '' };
+    }
+    try {
+        const parsed = JSON.parse(rawBody);
+        let serverMessage;
+        let serverCode;
+        if (typeof parsed.detail === 'string') {
+            serverMessage = parsed.detail;
+        }
+        else if (parsed.detail && typeof parsed.detail === 'object') {
+            serverMessage = coerceServerMessage(parsed.detail.message ?? parsed.detail.error);
+            serverCode = coerceServerMessage(parsed.detail.code);
+        }
+        if (!serverMessage) {
+            serverMessage = coerceServerMessage(parsed.message ?? parsed.error);
+        }
+        if (!serverMessage && Array.isArray(parsed.errors) && parsed.errors[0]?.message) {
+            serverMessage = coerceServerMessage(parsed.errors[0].message);
+            serverCode = serverCode ?? coerceServerMessage(parsed.errors[0].code);
+        }
+        serverCode = serverCode ?? coerceServerMessage(parsed.code);
+        return { serverMessage, serverCode, requestId, rawBody };
+    }
+    catch {
+        return { requestId, rawBody };
+    }
+}
+export function buildPayloadEqualsParams(filters, extras) {
+    const params = { ...(extras || {}) };
+    for (const [field, value] of Object.entries(filters)) {
+        params[`where[${field}][equals]`] = value;
+    }
+    return params;
+}
+function appendParams(path, params) {
+    if (!params || Object.keys(params).length === 0) {
+        return path;
+    }
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item !== undefined && item !== null) {
+                    searchParams.append(key, String(item));
+                }
+            }
+            continue;
+        }
+        searchParams.set(key, String(value));
+    }
+    const qs = searchParams.toString();
+    return qs ? `${path}?${qs}` : path;
+}
+function normalizePublicApiV4Path(path) {
+    const trimmed = path.trim();
+    if (!trimmed) {
+        throw new Error('PublicAPI path is required.');
+    }
+    const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    if (!normalized.startsWith('/v4/')) {
+        throw new Error('Only PublicAPI V4 paths are supported. Start the path with /v4/.');
+    }
+    const allowed = PUBLIC_API_V4_PATH_PREFIXES.some((prefix) => (normalized === prefix || normalized.startsWith(`${prefix}/`)));
+    if (!allowed) {
+        throw new Error(`Unsupported PublicAPI V4 path: ${normalized}`);
+    }
+    return normalized;
+}
+export async function parseApiError(response) {
+    const bodyText = await response.text();
+    if (!bodyText) {
+        return {
+            status: response.status,
+            message: response.statusText || `HTTP ${response.status}`,
+        };
+    }
+    try {
+        const body = JSON.parse(bodyText);
+        const detail = body.detail;
+        if (detail && typeof detail === 'object') {
+            return {
+                status: response.status,
+                code: detail.error,
+                message: detail.message || response.statusText || `HTTP ${response.status}`,
+                bodyText,
+            };
+        }
+        return {
+            status: response.status,
+            code: typeof body.error === 'string' ? body.error : undefined,
+            message: typeof body.message === 'string'
+                ? body.message
+                : typeof detail === 'string'
+                    ? detail
+                    : response.statusText || `HTTP ${response.status}`,
+            bodyText,
+        };
+    }
+    catch {
+        return {
+            status: response.status,
+            message: bodyText,
+            bodyText,
+        };
+    }
+}
+function readStringField(body, camelKey, snakeKey) {
+    const value = body[camelKey] ?? body[snakeKey];
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function readWorkflowStatus(value) {
+    if (value === 'upgrade-required' || value === 'paid-upgrade-required') {
+        return 'paid_upgrade_required';
+    }
+    if (value === 'available'
+        || value === 'not_ready'
+        || value === 'blocked'
+        || value === 'operator_required'
+        || value === 'paid_upgrade_required'
+        || value === 'rate_limited'
+        || value === 'upgrade_required'
+        || value === 'unsupported') {
+        return value;
+    }
+    return 'operator_required';
+}
+function parseRuntimeWorkflowStatus(body) {
+    return {
+        workflowKey: readStringField(body, 'workflowKey', 'workflow_key') ?? 'unknown',
+        tenantId: readStringField(body, 'tenantId', 'tenant_id'),
+        status: readWorkflowStatus(body.status),
+        reasonCode: readStringField(body, 'reasonCode', 'reason_code') ?? 'runtime_workflow_status_unknown',
+        reasonMessage: readStringField(body, 'reasonMessage', 'reason_message') ?? 'Runtime workflow status is unknown.',
+        runtimeWorkflowRef: readStringField(body, 'runtimeWorkflowRef', 'runtime_workflow_ref'),
+        nextAction: readStringField(body, 'nextAction', 'next_action'),
+        checkedAt: readStringField(body, 'checkedAt', 'checked_at'),
+    };
+}
+function parseRuntimeWorkflowRequest(body) {
+    return {
+        requestId: readStringField(body, 'requestId', 'request_id') ?? 'unknown',
+        workflowKey: readStringField(body, 'workflowKey', 'workflow_key') ?? 'unknown',
+        tenantId: readStringField(body, 'tenantId', 'tenant_id') ?? 'unknown',
+        status: readWorkflowStatus(body.status),
+        reasonCode: readStringField(body, 'reasonCode', 'reason_code') ?? 'runtime_workflow_requested',
+        reasonMessage: readStringField(body, 'reasonMessage', 'reason_message') ?? 'Runtime workflow request submitted.',
+        runtimeWorkflowRef: readStringField(body, 'runtimeWorkflowRef', 'runtime_workflow_ref'),
+        nextAction: readStringField(body, 'nextAction', 'next_action'),
+    };
+}
+function parseBuilderReadiness(body) {
+    const checks = Array.isArray(body.checks)
+        ? body.checks.filter((check) => Boolean(check) && typeof check === 'object')
+        : [];
+    return {
+        tenantId: readStringField(body, 'tenantId', 'tenant_id') ?? 'unknown',
+        status: readWorkflowStatus(body.status),
+        checkedAt: readStringField(body, 'checkedAt', 'checked_at'),
+        checks: checks.map((check) => ({
+            key: readStringField(check, 'key', 'key') ?? 'unknown',
+            status: readWorkflowStatus(check.status),
+            reasonCode: readStringField(check, 'reasonCode', 'reason_code') ?? 'builder_check_unknown',
+            reasonMessage: readStringField(check, 'reasonMessage', 'reason_message') ?? 'Builder check did not return detail.',
+            nextAction: readStringField(check, 'nextAction', 'next_action'),
+        })),
+    };
+}
+export class PlatformAPIClient {
+    baseUrl;
+    tenantId;
+    constructor(baseUrl, tenantId) {
+        this.baseUrl = baseUrl;
+        this.tenantId = tenantId;
+    }
+    async headers() {
+        const token = await getAccessToken();
+        const h = {
+            'Content-Type': 'application/json',
+        };
+        if (token) {
+            h['Authorization'] = `Bearer ${token}`;
+        }
+        if (this.tenantId && this.tenantId !== 'system') {
+            h['X-Tenant-Id'] = this.tenantId;
+        }
+        return h;
+    }
+    // --------------- V4 PublicAPI routing ---------------
+    async publicRequest(path, method = 'GET', body, params) {
+        return fetch(`${this.baseUrl}${appendParams(path, params)}`, {
+            method,
+            headers: await this.headers(),
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+    }
+    async requestPublicApi(path, options) {
+        return this.publicRequest(normalizePublicApiV4Path(path), options?.method ?? 'GET', options?.body, options?.params);
+    }
+    // --------------- Resources ---------------
+    async listResources(objectType, options) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        const params = new URLSearchParams();
+        if (options?.page)
+            params.set('page', String(options.page));
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.sort)
+            params.set('sort', options.sort);
+        if (options?.where)
+            params.set('where', JSON.stringify(options.where));
+        if (options?.cursor)
+            params.set('cursor', options.cursor);
+        const qs = params.toString();
+        const url = `${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}${qs ? `?${qs}` : ''}`;
+        return fetch(url, { headers: await this.headers() });
+    }
+    async streamResources(objectType, options) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.sort)
+            params.set('sort', options.sort);
+        if (options?.where)
+            params.set('where', JSON.stringify(options.where));
+        if (options?.cursor)
+            params.set('cursor', options.cursor);
+        const qs = params.toString();
+        const url = `${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/stream${qs ? `?${qs}` : ''}`;
+        return fetch(url, { headers: await this.headers() });
+    }
+    async getResource(objectType, id) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}`, { headers: await this.headers() });
+    }
+    async createResource(objectType, data) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ data }),
+        });
+    }
+    async updateResource(objectType, id, data, version) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}`, {
+            method: 'PUT',
+            headers: await this.headers(),
+            body: JSON.stringify({ data, version }),
+        });
+    }
+    async deleteResource(objectType, id) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}`, {
+            method: 'DELETE',
+            headers: await this.headers(),
+        });
+    }
+    async batchCreateResources(objectType, items) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/batch/create`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ items }),
+        });
+    }
+    async batchUpdateResources(objectType, items) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/batch/update`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ items }),
+        });
+    }
+    async batchDeleteResources(objectType, ids) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/batch/delete`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ ids }),
+        });
+    }
+    async aggregateResources(objectType, request) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/aggregate`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify(request),
+        });
+    }
+    async executeAction(objectType, id, action, params) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}/actions/${action}`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ params: params || {} }),
+        });
+    }
+    async queryResources(query) {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/query`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                ...query,
+                object_types: query.object_types.map(toObjectTypeSlug),
+            }),
+        });
+    }
+    async getPublishedObjectTypes(options) {
+        const filters = {
+            tenant: this.tenantId,
+        };
+        if (options?.name) {
+            filters.name = options.name;
+        }
+        return this.publicRequest(`${PUBLIC_DATA_RESOURCES_PATH}/object-types`, 'GET', undefined, buildPayloadEqualsParams(filters, {
+            limit: Math.min(options?.limit ?? 100, 100),
+            sort: options?.sort ?? 'name',
+        }));
+    }
+    async createObjectType(data) {
+        return this.publicRequest(`${PUBLIC_DATA_RESOURCES_PATH}/object-types`, 'POST', data);
+    }
+    async updateObjectType(objectTypeId, data) {
+        return this.publicRequest(`${PUBLIC_DATA_RESOURCES_PATH}/object-types/${encodeURIComponent(objectTypeId)}`, 'PATCH', data);
+    }
+    async saveAppObjectTypeManifest(verticalKey, objectTypes) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(this.tenantId)}/apps/${encodeURIComponent(verticalKey)}/object-types/manifest`, 'PUT', { objectTypes });
+    }
+    async publishAppObjectTypes(verticalKey) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(this.tenantId)}/apps/${encodeURIComponent(verticalKey)}/object-types/publish`, 'POST');
+    }
+    async getSchema() {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/schema/${this.tenantId}`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+    }
+    async getStorageStatus() {
+        return this.getResourceStorageStatus();
+    }
+    async getResourceStorageStatus() {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/storage`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+    }
+    async getStorageDoctor() {
+        return this.getResourceStorageDoctor();
+    }
+    async getResourceStorageDoctor() {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/storage/doctor`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+    }
+    async getResourceStorageSchemaStatus() {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/storage/schema-status`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+    }
+    async provisionStorage(options) {
+        const backend = options.backend === 'mongodb' ? 'documentdb' : options.backend;
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/storage/provision`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                backend: backend || 'all',
+                dry_run: Boolean(options.dryRun),
+                rebuild_search: Boolean(options.rebuildSearch),
+                provisioning_mode: options.provisioningMode ?? 'dedicated-tenant-storage',
+            }),
+        });
+    }
+    async syncStorageSchema(options) {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/storage/sync-schema`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                backend: options?.backend,
+                dry_run: options?.dryRun ?? false,
+                objectTypes: options?.objectTypes,
+            }),
+        });
+    }
+    async searchResources(request) {
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/search`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                query: request.query,
+                objectTypes: request.objectTypes?.map(toObjectTypeSlug),
+                mode: request.mode || 'hybrid',
+                limit: request.limit ?? 10,
+                includePayload: request.includePayload ?? true,
+            }),
+        });
+    }
+    async uploadResourceFile(objectType, id, propertyName, filePath) {
+        const { readFile } = await import('node:fs/promises');
+        const { basename } = await import('node:path');
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        const content = await readFile(filePath);
+        const token = await getAccessToken();
+        const h = {
+            'Content-Type': 'application/octet-stream',
+        };
+        if (token) {
+            h.Authorization = `Bearer ${token}`;
+        }
+        const filename = encodeURIComponent(basename(filePath));
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}/files/${propertyName}?filename=${filename}`, {
+            method: 'POST',
+            headers: h,
+            body: content,
+        });
+    }
+    async downloadResourceFile(objectType, id, propertyName) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}/files/${propertyName}`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+    }
+    async deleteResourceFile(objectType, id, propertyName) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}/files/${propertyName}`, {
+            method: 'DELETE',
+            headers: await this.headers(),
+        });
+    }
+    async getHistory(objectType, id) {
+        const normalizedObjectType = toObjectTypeSlug(objectType);
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_RESOURCES_PATH}/${this.tenantId}/${normalizedObjectType}/${id}/history`, { headers: await this.headers() });
+    }
+    // --------------- Chat ---------------
+    async sendChat(workflowId, stage, message, conversationId, params) {
+        return fetch(`${this.baseUrl}${PUBLIC_AI_PATH}/chat/${this.tenantId}/${workflowId}/${stage}`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                message,
+                conversation_id: conversationId,
+                params: params || {},
+            }),
+        });
+    }
+    async streamChat(workflowId, stage, message, conversationId, params) {
+        return fetch(`${this.baseUrl}${PUBLIC_AI_PATH}/chat/stream/${this.tenantId}/${workflowId}/${stage}`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                message,
+                conversation_id: conversationId,
+                params: params || {},
+            }),
+        });
+    }
+    // --------------- Builder / Workflows ---------------
+    async getBuilderReadiness(options) {
+        const params = new URLSearchParams();
+        params.set('tenant_id', options?.tenantId || this.tenantId);
+        for (const workflowKey of options?.workflowKeys || []) {
+            params.append('workflow_keys', workflowKey);
+        }
+        const response = await fetch(`${this.baseUrl}${PUBLIC_INTEGRATIONS_PATH}/builder/readiness?${params.toString()}`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+        if (!response.ok) {
+            const context = await extractServerErrorContext(response);
+            throw new PlatformAPIRequestError({
+                operation: 'Builder readiness check',
+                status: response.status,
+                statusText: response.statusText,
+                ...context,
+            });
+        }
+        return parseBuilderReadiness(await response.json());
+    }
+    async getRuntimeWorkflowStatus(workflowKey, tenantId = this.tenantId) {
+        const params = new URLSearchParams({ tenant_id: tenantId });
+        const response = await fetch(`${this.baseUrl}${PUBLIC_WORKFLOWS_PATH}/runtime/${encodeURIComponent(workflowKey)}/status?${params.toString()}`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+        if (!response.ok) {
+            const context = await extractServerErrorContext(response);
+            throw new PlatformAPIRequestError({
+                operation: `Runtime workflow status (${workflowKey})`,
+                status: response.status,
+                statusText: response.statusText,
+                ...context,
+            });
+        }
+        return parseRuntimeWorkflowStatus(await response.json());
+    }
+    async requestRuntimeWorkflow(request) {
+        const response = await fetch(`${this.baseUrl}${PUBLIC_WORKFLOWS_PATH}/runtime-requests`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                tenant_id: request.tenantId || this.tenantId,
+                workflow_key: request.workflowKey,
+                display_name: request.displayName,
+                reason: request.reason,
+            }),
+        });
+        if (!response.ok) {
+            const context = await extractServerErrorContext(response);
+            throw new PlatformAPIRequestError({
+                operation: `Runtime workflow request (${request.workflowKey})`,
+                status: response.status,
+                statusText: response.statusText,
+                ...context,
+            });
+        }
+        return parseRuntimeWorkflowRequest(await response.json());
+    }
+    // --------------- Documents ---------------
+    async uploadDocumentBatch(filePath, processingMode) {
+        const { readFile } = await import('node:fs/promises');
+        const { basename } = await import('node:path');
+        const content = await readFile(filePath);
+        const form = new FormData();
+        form.append('files', new Blob([content]), basename(filePath));
+        form.append('tenant_id', this.tenantId);
+        form.append('processing_mode', processingMode);
+        const token = await getAccessToken();
+        const h = {};
+        if (token)
+            h['Authorization'] = `Bearer ${token}`;
+        h['X-Tenant-Id'] = this.tenantId;
+        const endpoint = processingMode === 'classification'
+            ? `${PUBLIC_DATA_DOCUMENTS_PATH}/classify`
+            : `${PUBLIC_DATA_DOCUMENTS_PATH}/upload`;
+        return fetch(`${this.baseUrl}${endpoint}`, {
+            method: 'POST',
+            headers: h,
+            body: form,
+        });
+    }
+    async uploadDocument(filePath) {
+        return this.uploadDocumentBatch(filePath, 'full');
+    }
+    async classifyDocument(filePath) {
+        return this.uploadDocumentBatch(filePath, 'classification');
+    }
+    async getDocumentRecord(documentId) {
+        return this.publicRequest(`${PUBLIC_DATA_DOCUMENTS_PATH}/records/${encodeURIComponent(documentId)}`, 'GET');
+    }
+    async indexDocument(documentId) {
+        const lookup = await this.getDocumentRecord(documentId);
+        if (!lookup.ok) {
+            return lookup;
+        }
+        const document = await lookup.json();
+        const storagePath = document.fileInfo?.dataLakeUrl;
+        if (!storagePath) {
+            return new Response(JSON.stringify({
+                error: 'MISSING_STORAGE_PATH',
+                message: 'The document does not have a dataLakeUrl/storage path and cannot be indexed.',
+            }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const tenantId = typeof document.tenant === 'string'
+            ? document.tenant
+            : document.tenant?.id || this.tenantId;
+        const businessRequestId = typeof document.businessRequest === 'string'
+            ? document.businessRequest
+            : document.businessRequest?.id;
+        return fetch(`${this.baseUrl}${PUBLIC_DATA_DOCUMENTS_PATH}/rag-index`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                documentId: document.documentId || document.id || documentId,
+                storagePath,
+                tenantId,
+                businessRequestId,
+                title: document.title,
+            }),
+        });
+    }
+    // --------------- Tenants ---------------
+    async listTenants(parentId) {
+        const params = { limit: 100 };
+        if (parentId) {
+            params['where[parentTenant][equals]'] = parentId;
+        }
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants`, 'GET', undefined, params);
+    }
+    async getTenant(id) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(id)}/management`, 'GET');
+    }
+    async listTenantChildren(tenantId, options) {
+        const params = {};
+        if (options?.includeDescendants !== undefined) {
+            params.include_descendants = options.includeDescendants;
+        }
+        if (options?.limit !== undefined) {
+            params.limit = options.limit;
+        }
+        if (options?.offset !== undefined) {
+            params.offset = options.offset;
+        }
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/children`, 'GET', undefined, params);
+    }
+    async createTenantApp(parentTenantId, data) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(parentTenantId)}/apps`, 'POST', data);
+    }
+    async createAppProvisioningJob(verticalKey) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(this.tenantId)}/apps/${encodeURIComponent(verticalKey)}/provisioning-jobs`, 'POST');
+    }
+    async createTenant(data) {
+        if (data.parent) {
+            return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(data.parent)}/children`, 'POST', {
+                displayName: data.name,
+                slug: data.slug,
+                usecase: data.usecase || 'generic',
+                ...(data.homeRegion ? { homeRegion: data.homeRegion } : {}),
+                ...(data.industry ? { industry: data.industry } : {}),
+                ...(data.starterTemplate ? { starterTemplate: data.starterTemplate } : {}),
+            });
+        }
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants`, 'POST', {
+            displayName: data.name,
+            name: data.name,
+            slug: data.slug,
+            parentTenant: data.parent,
+            domain: data.domain,
+            usecase: data.usecase || 'generic',
+            ...(data.homeRegion ? { homeRegion: data.homeRegion } : {}),
+            ...(data.industry ? { industry: data.industry } : {}),
+            ...(data.starterTemplate ? { starterTemplate: data.starterTemplate } : {}),
+        });
+    }
+    async deleteTenant(tenantId) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/delete`, 'POST');
+    }
+    async bootstrapChildTenantAdmin(parentTenantId, childTenantId, body) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(parentTenantId)}/children/${encodeURIComponent(childTenantId)}/bootstrap-admin`, 'POST', body);
+    }
+    async evaluateCapability(request) {
+        const response = await fetch(`${this.baseUrl}${PUBLIC_PLATFORM_PATH}/capabilities/evaluate`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                tenant_id: request.tenantId,
+                target_capability: request.targetCapability,
+                requested_operation: request.requestedOperation || 'inspect',
+            }),
+        });
+        if (!response.ok) {
+            const context = await extractServerErrorContext(response);
+            throw new PlatformAPIRequestError({
+                operation: `POST ${PUBLIC_PLATFORM_PATH}/capabilities/evaluate (${request.targetCapability})`,
+                status: response.status,
+                statusText: response.statusText,
+                serverMessage: context.serverMessage,
+                serverCode: context.serverCode,
+                requestId: context.requestId,
+                rawBody: context.rawBody,
+            });
+        }
+        return await response.json();
+    }
+    // --------------- Users ---------------
+    async getUserMemberships(oid) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/users/${encodeURIComponent(oid)}/memberships`, 'GET');
+    }
+    async provisionMe() {
+        return fetch(`${this.baseUrl}${PUBLIC_IDENTITY_PATH}/me/provision`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ tenant_id: this.tenantId }),
+        });
+    }
+    async lookupUserByEmail(email) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/users/by-email`, 'GET', undefined, { email });
+    }
+    async listCurrentUserTenants() {
+        return fetch(`${this.baseUrl}${PUBLIC_IDENTITY_PATH}/tenants`, {
+            method: 'GET',
+            headers: await this.headers(),
+        });
+    }
+    async provisionUserToTenant(tenantId, userOid) {
+        if (userOid) {
+            return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/users/${encodeURIComponent(userOid)}/provision`, 'POST', { tenant_id: tenantId });
+        }
+        const body = { tenant_id: tenantId };
+        return fetch(`${this.baseUrl}${PUBLIC_IDENTITY_PATH}/me/provision`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify(body),
+        });
+    }
+    async inviteTenantMember(tenantId, request) {
+        const body = {
+            email: request.email,
+        };
+        if (request.roleDefinitionId) {
+            body.roleDefinitionId = request.roleDefinitionId;
+        }
+        if (request.role || !request.roleDefinitionId) {
+            body.role = request.role || 'tenant-viewer';
+        }
+        if (request.firstName)
+            body.firstName = request.firstName;
+        if (request.lastName)
+            body.lastName = request.lastName;
+        if (request.message)
+            body.message = request.message;
+        if (request.redirectUri)
+            body.redirectUri = request.redirectUri;
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/members/invite`, 'POST', body);
+    }
+    async listTenantMembers(tenantId, options) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/members`, 'GET', undefined, {
+            page: options?.page,
+            limit: options?.limit,
+            sort: options?.sort,
+            search: options?.search,
+        });
+    }
+    async listTenantRoleDefinitions(tenantId) {
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/role-definitions`, 'GET');
+    }
+    async updateTenantMemberRole(tenantId, memberId, request) {
+        const body = {};
+        if (request.roleDefinitionId) {
+            body.roleDefinitionId = request.roleDefinitionId;
+        }
+        if (request.role || !request.roleDefinitionId) {
+            body.role = request.role || 'tenant-viewer';
+        }
+        return this.publicRequest(`${PUBLIC_PLATFORM_PATH}/tenants/${encodeURIComponent(tenantId)}/members/${encodeURIComponent(memberId)}/roles`, 'PATCH', body);
+    }
+    // --------------- Provisioning ---------------
+    async provisionEntraApp(request) {
+        const body = {
+            tenant_id: request.tenantId,
+            app_name: request.appName,
+            redirect_uris: request.redirectUris,
+            idempotent: request.idempotent ?? false,
+        };
+        const endpoint = `${PUBLIC_PLATFORM_PATH}/provisioning/entra-apps`;
+        const url = `${this.baseUrl}${endpoint}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const ctx = await extractServerErrorContext(res);
+            throw new PlatformAPIRequestError({
+                operation: 'Entra app provisioning',
+                status: res.status,
+                statusText: res.statusText,
+                ...ctx,
+            });
+        }
+        const data = await res.json();
+        const clientId = data.clientId ?? data.client_id;
+        if (typeof clientId !== 'string' || clientId.trim() === '') {
+            throw new PlatformAPIRequestError({
+                operation: 'Entra app provisioning',
+                status: res.status,
+                statusText: 'Invalid provisioning response',
+            });
+        }
+        const toStringArray = (value) => Array.isArray(value) ? value.filter((v) => typeof v === 'string' && v.trim() !== '') : [];
+        return {
+            clientId,
+            clientSecret: data.clientSecret ?? data.client_secret ?? null,
+            existing: Boolean(data.existing),
+            scopes: toStringArray(data.scopes),
+            redirectUris: toStringArray(data.redirectUris ?? data.redirect_uris),
+            environment: typeof data.environment === 'string' ? data.environment : null,
+            tenantId: typeof (data.tenantId ?? data.tenant_id) === 'string'
+                ? (data.tenantId ?? data.tenant_id)
+                : null,
+            tenantAuthorization: parseTenantAuthorization(data.tenantAuthorization ?? data.tenant_authorization),
+            signinCompleteness: parseSigninCompleteness(data.signinCompleteness ?? data.signin_completeness),
+        };
+    }
+    async rotateEntraAppSecret(request) {
+        const response = await fetch(`${this.baseUrl}${PUBLIC_PLATFORM_PATH}/provisioning/entra-apps/${encodeURIComponent(request.clientId)}/rotate-secret`, {
+            method: 'POST',
+            headers: await this.headers(),
+            body: JSON.stringify({ tenant_id: request.tenantId }),
+        });
+        if (!response.ok) {
+            const context = await extractServerErrorContext(response);
+            throw new PlatformAPIRequestError({
+                operation: 'Entra app secret rotation',
+                status: response.status,
+                statusText: response.statusText,
+                ...context,
+            });
+        }
+        const data = await response.json();
+        const clientId = readStringField(data, 'clientId', 'client_id');
+        const clientSecret = readStringField(data, 'clientSecret', 'client_secret');
+        if (!clientId || !clientSecret) {
+            throw new PlatformAPIRequestError({
+                operation: 'Entra app secret rotation',
+                status: response.status,
+                statusText: 'Invalid secret rotation response',
+            });
+        }
+        return {
+            clientId,
+            clientSecret,
+            tenantId: readStringField(data, 'tenantId', 'tenant_id') ?? request.tenantId,
+            expiresAt: readStringField(data, 'expiresAt', 'expires_at'),
+        };
+    }
+    async deprovisionEntraApp(request) {
+        const response = await fetch(`${this.baseUrl}${PUBLIC_PLATFORM_PATH}/provisioning/entra-apps/${encodeURIComponent(request.clientId)}`, {
+            method: 'DELETE',
+            headers: await this.headers(),
+            body: JSON.stringify({
+                tenant_id: request.tenantId,
+                delete_registration: request.deleteRegistration ?? true,
+            }),
+        });
+        if (!response.ok) {
+            const context = await extractServerErrorContext(response);
+            throw new PlatformAPIRequestError({
+                operation: 'Entra app deprovisioning',
+                status: response.status,
+                statusText: response.statusText,
+                ...context,
+            });
+        }
+        const data = await response.json();
+        const clientId = readStringField(data, 'clientId', 'client_id');
+        const tenantId = readStringField(data, 'tenantId', 'tenant_id');
+        if (!clientId || !tenantId) {
+            throw new PlatformAPIRequestError({
+                operation: 'Entra app deprovisioning',
+                status: response.status,
+                statusText: 'Invalid deprovision response',
+            });
+        }
+        const tenantDeauthorizationRaw = (data.tenantDeauthorization ?? data.tenant_deauthorization);
+        return {
+            clientId,
+            tenantId,
+            tenantDeauthorization: {
+                removed: Boolean(tenantDeauthorizationRaw?.removed),
+                alreadyAbsent: Boolean(tenantDeauthorizationRaw?.alreadyAbsent ?? tenantDeauthorizationRaw?.already_absent),
+            },
+            appRegistrationFound: Boolean(data.appRegistrationFound ?? data.app_registration_found),
+            appRegistrationDeleted: Boolean(data.appRegistrationDeleted ?? data.app_registration_deleted),
+        };
+    }
+}
+function parseTenantAuthorization(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const v = value;
+    const warning = v.warning;
+    return {
+        added: Boolean(v.added),
+        alreadyAuthorized: Boolean(v.already_authorized ?? v.alreadyAuthorized),
+        warning: typeof warning === 'string' && warning.trim() !== '' ? warning : null,
+    };
+}
+function parseSigninCompleteness(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const v = value;
+    const warnings = Array.isArray(v.warnings)
+        ? v.warnings.filter((w) => typeof w === 'string')
+        : [];
+    return {
+        graphPermsAdded: Boolean(v.graph_perms_added ?? v.graphPermsAdded),
+        publicapiPermsAdded: Boolean(v.publicapi_perms_added ?? v.publicapiPermsAdded),
+        consentGranted: Boolean(v.consent_granted ?? v.consentGranted),
+        publicapiPreauthorized: Boolean(v.publicapi_preauthorized ?? v.publicapiPreauthorized),
+        // Older AdminAPI deployments don't emit `signin_ready`; derive it from
+        // the four boolean steps so the CLI behaves identically once each step
+        // is observably True/False.
+        signinReady: typeof (v.signin_ready ?? v.signinReady) === 'boolean'
+            ? Boolean(v.signin_ready ?? v.signinReady)
+            : Boolean(v.graph_perms_added ?? v.graphPermsAdded)
+                && Boolean(v.publicapi_perms_added ?? v.publicapiPermsAdded)
+                && Boolean(v.consent_granted ?? v.consentGranted)
+                && Boolean(v.publicapi_preauthorized ?? v.publicapiPreauthorized),
+        warnings,
+    };
+}
+//# sourceMappingURL=api.js.map