@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/client.js

@@ -1,30 +1,152 @@
 import { AUTH_VALIDATION_TTL_MS, buildAuthValidationKey, DEFAULT_BASE_URL, readAuthValidationState, resolveRuntimeConfig, saveAuthValidationState, } from "./config.js";
+import { isInteractiveTerminal, promptConfirm } from "./prompt.js";
 import { createSpinner } from "./spinner.js";
 export class ApiError extends Error {
     status;
     data;
-    constructor(status, message, data) {
+    headers;
+    constructor(status, message, data, headers) {
         super(message);
         this.name = 'ApiError';
         this.status = status;
         this.data = data;
+        this.headers = headers;
     }
 }
 export class AuthenticationError extends ApiError {
-    constructor(status, message, data) {
-        super(status, message, data);
+    constructor(status, message, data, headers) {
+        super(status, message, data, headers);
         this.name = 'AuthenticationError';
     }
 }
 export class PermissionDeniedError extends ApiError {
     path;
-    constructor(path, message, data) {
-        super(403, message, data);
+    constructor(path, message, data, headers) {
+        super(403, message, data, headers);
         this.name = 'PermissionDeniedError';
         this.path = path;
     }
 }
 const REQUEST_DELAY_MS = 50;
+const COMPONENT_LIST_PAGE_SIZE = 200;
+const DATABASE_SCHEMA_LIST_PAGE_SIZE = 200;
+const DATABASE_SCHEMA_THIN_FIELDS = [
+    'databaseId', 'name', 'category', 'metadata', 'type', 'parent', 'master', 'version',
+    'deletedAt', 'deletedBy',
+].join(',');
+const DATABASE_SCHEMA_PULL_FIELDS = [
+    'databaseId', 'name', 'category', 'desc', 'metadata', 'type', 'definition', 'partition',
+    'parent', 'master', 'version', 'audit', 'restricted', 'tags',
+    'deletedAt', 'deletedBy',
+].join(',');
+const ACTIVE_COMPONENT_LIST_FILTER = {
+    'filter[and][0][field]': 'deletedAt',
+    'filter[and][0][op]': 'isNull',
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function hasDatabaseSchemaParent(database) {
+    if (typeof database.parent === 'string') {
+        return database.parent.trim().length > 0;
+    }
+    if (!isRecord(database.parent)) {
+        return false;
+    }
+    return [database.parent.databaseId, database.parent.id, database.parent.name]
+        .some((value) => typeof value === 'string' && value.trim().length > 0);
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function unwrapList(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const candidate = value;
+        if (Array.isArray(candidate.data)) {
+            return candidate.data;
+        }
+        if (Array.isArray(candidate.items)) {
+            return candidate.items;
+        }
+        if (Array.isArray(candidate.results)) {
+            return candidate.results;
+        }
+    }
+    return [];
+}
+function resolveNextListRequest(value) {
+    if (typeof value === 'string' && value) {
+        return {
+            path: value,
+        };
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    for (const key of ['path', 'url', 'href']) {
+        if (typeof value[key] === 'string' && value[key]) {
+            return {
+                path: value[key],
+            };
+        }
+    }
+    const query = {};
+    for (const key of ['cursor', 'page', 'skip', 'take', 'limit', 'offset']) {
+        const candidate = value[key];
+        if (typeof candidate === 'string' || typeof candidate === 'number') {
+            query[key] = candidate;
+        }
+    }
+    return Object.keys(query).length > 0 ? { query } : null;
+}
+function buildActiveComponentListQuery(skip, take = COMPONENT_LIST_PAGE_SIZE) {
+    return {
+        take,
+        skip,
+        count: true,
+        ...ACTIVE_COMPONENT_LIST_FILTER,
+    };
+}
+function withActiveComponentListFilter(request) {
+    if (!request.query) {
+        return request;
+    }
+    return {
+        ...request,
+        query: {
+            ...request.query,
+            count: request.query.count ?? true,
+            ...ACTIVE_COMPONENT_LIST_FILTER,
+        },
+    };
+}
+function unwrapListPage(value) {
+    const items = unwrapList(value);
+    if (!isRecord(value)) {
+        return {
+            items,
+            total: null,
+            nextRequest: null,
+        };
+    }
+    const meta = isRecord(value.meta) ? value.meta : null;
+    const pagination = isRecord(value.pagination) ? value.pagination : null;
+    const total = readNumber(value.total)
+        ?? readNumber(value.count)
+        ?? (meta ? readNumber(meta.total) ?? readNumber(meta.count) : null)
+        ?? (pagination ? readNumber(pagination.total) ?? readNumber(pagination.count) : null);
+    const nextRequest = resolveNextListRequest(value.next)
+        ?? (meta ? resolveNextListRequest(meta.next) : null)
+        ?? (pagination ? resolveNextListRequest(pagination.next) : null);
+    return {
+        items,
+        total,
+        nextRequest,
+    };
+}
 function normalizeBaseUrl(baseUrl) {
     const url = new URL(baseUrl || DEFAULT_BASE_URL);
     url.pathname = url.pathname.replace(/\/+$/, '');
@@ -71,12 +193,68 @@ function buildUrl(baseUrl, requestPath, query) {
     }
     return url;
 }
+function isLocalhost(hostname) {
+    return hostname === 'localhost';
+}
+function isMatchingFirstPartySandbox(base, target) {
+    if (base.hostname === 'app.revo.com' && target.hostname === 'sbx.revoengine.com') {
+        return true;
+    }
+    if (!base.hostname.startsWith('api.')) {
+        return false;
+    }
+    const serviceDomain = base.hostname.slice('api.'.length);
+    return (serviceDomain === 'revoengine.com' || serviceDomain.endsWith('.revong.com'))
+        && target.hostname === `sbx.${serviceDomain}`;
+}
+function resolveTrustedServiceOrigins(configured) {
+    const values = configured ?? (process.env.REVO_TRUSTED_SERVICE_ORIGINS || '').split(',').filter(Boolean);
+    return new Set(values.map((value) => {
+        const url = new URL(value.trim());
+        if (url.username || url.password || url.protocol !== 'https:' || url.pathname !== '/' || url.search || url.hash) {
+            throw new Error('REVO_TRUSTED_SERVICE_ORIGINS contains an invalid origin.');
+        }
+        return url.origin;
+    }));
+}
+function assertCredentialDestination(baseUrl, url, allowExternalOrigin = false, trustedServiceOrigins = new Set()) {
+    const base = new URL(baseUrl);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+        throw new Error('Refusing to send API credentials to an invalid URL.');
+    }
+    if (url.origin === base.origin) {
+        return;
+    }
+    if (!allowExternalOrigin) {
+        throw new Error('Refusing to send API credentials to an external origin.');
+    }
+    if (url.protocol !== 'https:' && !(isLocalhost(base.hostname) && isLocalhost(url.hostname))) {
+        throw new Error('External service endpoints must use HTTPS.');
+    }
+    if (isLocalhost(base.hostname) && isLocalhost(url.hostname)) {
+        return;
+    }
+    if (!isMatchingFirstPartySandbox(base, url) && !trustedServiceOrigins.has(url.origin)) {
+        throw new Error('External service origin is not trusted. Set REVO_TRUSTED_SERVICE_ORIGINS explicitly.');
+    }
+}
+function assertNoAuthenticatedRedirect(response) {
+    if (response.status >= 300 && response.status < 400 && response.status !== 304) {
+        throw new Error('Authenticated request was redirected; refusing to forward API credentials.');
+    }
+}
 function normalizeToken(token) {
     if (!token) {
         return '';
     }
     return token.startsWith('Bearer ') ? token : `Bearer ${token}`;
 }
+async function confirmProductionWriteInTerminal(details) {
+    if (!isInteractiveTerminal()) {
+        return false;
+    }
+    return promptConfirm(`PRODUCTION: send ${details.method} ${details.path} to ${details.baseUrl}?`, false);
+}
 function defaultSpinnerLabel(method, path) {
     const upperMethod = method.toUpperCase();
     if (path === '/api/v1/me') {
@@ -220,13 +398,20 @@ export class RevoClient {
     baseUrl;
     instance;
     token;
+    production;
     fetchImpl;
+    productionWriteConfirmed = false;
+    confirmProductionWrite;
+    trustedServiceOrigins;
     constructor(options = {}) {
         const config = resolveRuntimeConfig(options);
         this.baseUrl = config.baseUrl;
         this.instance = config.instance || '';
         this.token = config.token;
+        this.production = options.production === true || config.production === true;
         this.fetchImpl = options.fetch || globalThis.fetch;
+        this.confirmProductionWrite = options.confirmProductionWrite || confirmProductionWriteInTerminal;
+        this.trustedServiceOrigins = resolveTrustedServiceOrigins(options.trustedServiceOrigins);
     }
     get authHeader() {
         return normalizeToken(this.token);
@@ -295,10 +480,14 @@ export class RevoClient {
     }
     async request(method, path, options = {}) {
         this.assertReady();
+        if (options.productionWrite !== false) {
+            await this.assertProductionWriteConfirmed(method, path);
+        }
         if (options.authGuard !== false && path !== '/api/v1/me') {
             await this.validateSession();
         }
         const url = buildUrl(this.baseUrl, path, options.query);
+        assertCredentialDestination(this.baseUrl, url, options.allowExternalOrigin, this.trustedServiceOrigins);
         const headers = new Headers(options.headers || {});
         headers.set('Authorization', this.authHeader);
         headers.set('x-api-key', this.token);
@@ -317,6 +506,10 @@ export class RevoClient {
         const spinner = createSpinner({
             text: options.spinnerLabel || defaultSpinnerLabel(method, path),
         });
+        const abortController = options.timeoutMs === undefined ? undefined : new AbortController();
+        const timeout = abortController
+            ? setTimeout(() => abortController.abort(), options.timeoutMs)
+            : undefined;
         spinner.start();
         try {
             await delay(REQUEST_DELAY_MS);
@@ -324,7 +517,10 @@ export class RevoClient {
                 method: method.toUpperCase(),
                 headers,
                 body: body,
+                redirect: 'manual',
+                ...(abortController ? { signal: abortController.signal } : {}),
             });
+            assertNoAuthenticatedRedirect(response);
             const data = await readResponseData(response);
             if (!response.ok && response.status !== 304) {
                 if (response.status === 401) {
@@ -333,12 +529,12 @@ export class RevoClient {
                         status: 'not_authenticated',
                         checkedAt: Date.now(),
                     });
-                    throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', data);
+                    throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', data, response.headers);
                 }
                 if (response.status === 403 && path !== '/api/v1/me') {
-                    throw new PermissionDeniedError(path, `Access denied for ${path}.`, data);
+                    throw new PermissionDeniedError(path, `Access denied for ${path}.`, data, response.headers);
                 }
-                throw new ApiError(response.status, toErrorMessage(typeof data === 'string' ? data : JSON.stringify(data), response.status), data);
+                throw new ApiError(response.status, toErrorMessage(typeof data === 'string' ? data : JSON.stringify(data), response.status), data, response.headers);
             }
             const previous = readAuthValidationState(this.authValidationKey);
             saveAuthValidationState({
@@ -355,9 +551,27 @@ export class RevoClient {
             };
         }
         finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             spinner.stop();
         }
     }
+    async assertProductionWriteConfirmed(method, path) {
+        const normalizedMethod = method.toUpperCase();
+        if (!this.production || this.productionWriteConfirmed || !['POST', 'PUT', 'PATCH', 'DELETE'].includes(normalizedMethod)) {
+            return;
+        }
+        const confirmed = await this.confirmProductionWrite({
+            baseUrl: this.baseUrl,
+            method: normalizedMethod,
+            path,
+        });
+        if (!confirmed) {
+            throw new Error('Production write cancelled. Confirm the operation in an interactive terminal.');
+        }
+        this.productionWriteConfirmed = true;
+    }
     async requestData(method, path, options = {}) {
         const response = await this.request(method, path, options);
         return response.data;
@@ -369,24 +583,356 @@ export class RevoClient {
         }
         return this.requestData('GET', '/api/v1/me', { authGuard: false });
     }
-    async listEndpoints() {
-        return this.requestData('GET', '/api/v1/endpoints');
+    async listEndpoints(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/endpoints', {
+            query: options.query,
+        });
+    }
+    async listDatabaseSchemas(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/databases', {
+            query: options.query,
+        });
+    }
+    async listAllDatabaseSchemas(options = {}) {
+        const databases = [];
+        const databaseIds = new Set();
+        const seenRequests = new Set();
+        const fields = options.projection === 'pull'
+            ? DATABASE_SCHEMA_PULL_FIELDS
+            : DATABASE_SCHEMA_THIN_FIELDS;
+        const filter = JSON.stringify({
+            and: [
+                { field: 'deletedAt', op: 'isNull' },
+                ...(options.skipPartitions ? [{ field: 'parent', op: 'isNull' }] : []),
+            ],
+        });
+        let nextRequest = {
+            query: {
+                take: DATABASE_SCHEMA_LIST_PAGE_SIZE,
+                skip: 0,
+                count: true,
+                fields,
+                sort: JSON.stringify({ databaseId: 'ASC' }),
+                filter,
+            },
+        };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Database-schema list pagination loop detected while listing all databases.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listDatabaseSchemas(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null && !options.skipPartitions) {
+                if (discoveredTotal !== null && discoveredTotal !== page.total) {
+                    throw new Error('Database-schema inventory changed during offset pagination; retry the command from a stable snapshot.');
+                }
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    const database = item;
+                    if (!database.deletedAt && !database.deletedBy && !(options.skipPartitions && hasDatabaseSchemaParent(database))) {
+                        const databaseId = String(database.databaseId || database.id || '');
+                        if (!databaseId || databaseIds.has(databaseId)) {
+                            continue;
+                        }
+                        databaseIds.add(databaseId);
+                        databases.push(database);
+                    }
+                }
+            }
+            if (page.total !== null && (Number(nextRequest.query?.skip || 0) + page.items.length) >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = {
+                    ...page.nextRequest,
+                    query: { ...page.nextRequest.query, fields, sort: JSON.stringify({ databaseId: 'ASC' }), filter },
+                };
+            }
+            else if (nextRequest.query && page.items.length === DATABASE_SCHEMA_LIST_PAGE_SIZE) {
+                nextRequest = {
+                    query: {
+                        ...nextRequest.query,
+                        skip: Number(nextRequest.query.skip || 0) + page.items.length,
+                        count: false,
+                    },
+                };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        if (!options.skipPartitions && discoveredTotal !== null && databases.length !== discoveredTotal) {
+            throw new Error('Database-schema inventory changed during offset pagination; retry the command from a stable snapshot.');
+        }
+        return { databases, discoveredTotal };
+    }
+    async findActiveDatabaseSchemasByField(field, value, path) {
+        const databases = [];
+        const databaseIds = new Set();
+        const filter = JSON.stringify({
+            and: [
+                { field: 'deletedAt', op: 'isNull' },
+                { field, op: 'eq', value, ...(path ? { path } : {}) },
+            ],
+        });
+        let skip = 0;
+        let discoveredTotal = null;
+        do {
+            const page = unwrapListPage(await this.listDatabaseSchemas({
+                query: {
+                    take: DATABASE_SCHEMA_LIST_PAGE_SIZE,
+                    skip,
+                    count: true,
+                    fields: DATABASE_SCHEMA_PULL_FIELDS,
+                    sort: JSON.stringify({ databaseId: 'ASC' }),
+                    filter,
+                },
+            }));
+            if (page.total !== null) {
+                if (discoveredTotal !== null && discoveredTotal !== page.total) {
+                    throw new Error('Database-schema filtered inventory changed during offset pagination; retry the command from a stable snapshot.');
+                }
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (!isRecord(item) || item.deletedAt || item.deletedBy) {
+                    continue;
+                }
+                const database = item;
+                const databaseId = String(database.databaseId || database.id || '');
+                if (!databaseId || databaseIds.has(databaseId)) {
+                    continue;
+                }
+                databaseIds.add(databaseId);
+                databases.push(database);
+            }
+            skip += page.items.length;
+            if (page.items.length === 0) {
+                break;
+            }
+            if (discoveredTotal !== null && skip >= discoveredTotal) {
+                break;
+            }
+            if (discoveredTotal === null && page.items.length < DATABASE_SCHEMA_LIST_PAGE_SIZE) {
+                break;
+            }
+        } while (true);
+        if (discoveredTotal !== null && databases.length !== discoveredTotal) {
+            throw new Error('Database-schema filtered inventory changed during offset pagination; retry the command from a stable snapshot.');
+        }
+        return databases;
+    }
+    async getDatabaseSchemaStats() {
+        return this.requestData('GET', '/api/v1/databases/stats');
+    }
+    async getDatabaseSchema(databaseId) {
+        return this.requestData('GET', `/api/v1/databases/${encodeURIComponent(databaseId)}`);
+    }
+    async createDatabaseSchema(body) {
+        return this.requestData('POST', '/api/v1/databases', {
+            body,
+            spinnerLabel: 'Creating database schema',
+        });
+    }
+    async updateDatabaseSchemaMetadata(databaseId, body) {
+        return this.requestData('PUT', `/api/v1/databases/${encodeURIComponent(databaseId)}`, {
+            body,
+            spinnerLabel: 'Updating database schema metadata',
+        });
+    }
+    async updateDatabaseSchema(databaseId, body) {
+        return this.requestData('PUT', `/api/v1/databases/${encodeURIComponent(databaseId)}`, {
+            body,
+            spinnerLabel: 'Updating database schema',
+        });
+    }
+    async deleteDatabaseSchema(databaseId) {
+        return this.requestData('DELETE', `/api/v1/databases/${encodeURIComponent(databaseId)}`, {
+            spinnerLabel: 'Deleting database schema',
+        });
+    }
+    async listAllDatabaseViews() {
+        const views = [];
+        const databaseViewIds = new Set();
+        let discoveredTotal = null;
+        for (let skip = 0;; skip += DATABASE_SCHEMA_LIST_PAGE_SIZE) {
+            const page = await this.requestData('GET', '/api/v1/databases/views', {
+                query: {
+                    take: DATABASE_SCHEMA_LIST_PAGE_SIZE,
+                    skip,
+                    fields: JSON.stringify(['databaseViewId', 'deletedAt', 'sourceDatabaseIds']),
+                    sort: JSON.stringify({ databaseViewId: 'ASC' }),
+                },
+            });
+            const items = Array.isArray(page) ? page : Array.isArray(page.data) ? page.data : [];
+            for (const item of items) {
+                const databaseViewId = String(item.databaseViewId || item.id || '');
+                if (!databaseViewId || databaseViewIds.has(databaseViewId)) {
+                    throw new Error('Database View inventory changed during offset pagination; retry the command from a stable snapshot.');
+                }
+                databaseViewIds.add(databaseViewId);
+                views.push(item);
+            }
+            const hasExplicitNext = !Array.isArray(page) && typeof page.next === 'boolean';
+            const pageTotal = !Array.isArray(page)
+                ? typeof page.results === 'number' ? page.results : page.total
+                : undefined;
+            if (typeof pageTotal === 'number') {
+                if (discoveredTotal !== null && discoveredTotal !== pageTotal) {
+                    throw new Error('Database View inventory changed during offset pagination; retry the command from a stable snapshot.');
+                }
+                discoveredTotal = pageTotal;
+            }
+            if (items.length === 0
+                || (hasExplicitNext ? page.next !== true : items.length < DATABASE_SCHEMA_LIST_PAGE_SIZE)
+                || (typeof pageTotal === 'number' && views.length >= pageTotal)) {
+                if (discoveredTotal !== null && views.length !== discoveredTotal) {
+                    throw new Error('Database View inventory changed during offset pagination; retry the command from a stable snapshot.');
+                }
+                return views;
+            }
+        }
+    }
+    async getDatabaseView(databaseViewId) {
+        return this.requestData('GET', `/api/v1/databases/views/${encodeURIComponent(databaseViewId)}`);
+    }
+    async listAllDatabaseViewsForSync() {
+        const summaries = await this.listAllDatabaseViews();
+        const activeSummaries = summaries.filter((view) => !view.deletedAt && !view.deletedBy);
+        const seenIds = new Set();
+        const records = await Promise.all(activeSummaries.map(async (summary) => {
+            const databaseViewId = String(summary.databaseViewId || summary.id || '');
+            if (!databaseViewId || seenIds.has(databaseViewId)) {
+                return undefined;
+            }
+            seenIds.add(databaseViewId);
+            const response = await this.getDatabaseView(databaseViewId);
+            if (isRecord(response) && isRecord(response.data)) {
+                return response.data;
+            }
+            return response;
+        }));
+        return records
+            .filter((record) => record !== undefined && !record.deletedAt && !record.deletedBy)
+            .sort((left, right) => String(left.databaseViewId || left.id || '').localeCompare(String(right.databaseViewId || right.id || '')));
+    }
+    async previewDatabaseView(body) {
+        return this.requestData('POST', '/api/v1/databases/views/preview', {
+            body,
+            productionWrite: false,
+            spinnerLabel: 'Previewing Database View',
+            timeoutMs: 30_000,
+        });
+    }
+    async createDatabaseView(body) {
+        return this.requestData('POST', '/api/v1/databases/views', {
+            body,
+            spinnerLabel: 'Creating Database View',
+        });
+    }
+    async updateDatabaseView(databaseViewId, body) {
+        return this.requestData('PUT', `/api/v1/databases/views/${encodeURIComponent(databaseViewId)}`, {
+            body,
+            spinnerLabel: 'Updating Database View',
+        });
+    }
+    async listAllEndpoints() {
+        const endpoints = [];
+        const seenRequests = new Set();
+        let nextRequest = {
+            query: { take: COMPONENT_LIST_PAGE_SIZE, skip: 0, count: true },
+        };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Endpoint list pagination loop detected while listing all endpoints.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listEndpoints(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    endpoints.push(item);
+                }
+            }
+            if (page.total !== null && endpoints.length >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = page.nextRequest;
+            }
+            else if (nextRequest.query && typeof nextRequest.query.take === 'number' && page.items.length === nextRequest.query.take) {
+                nextRequest = {
+                    query: { take: nextRequest.query.take, skip: endpoints.length, count: true },
+                };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        return { endpoints, discoveredTotal };
+    }
+    async getEndpoint(endpointId) {
+        return this.requestData('GET', `/api/v1/endpoints/${encodeURIComponent(endpointId)}`);
+    }
+    async createEndpoint(body) {
+        return this.requestData('POST', '/api/v1/endpoints', {
+            body,
+            spinnerLabel: 'Creating endpoint',
+        });
+    }
+    async updateEndpoint(endpointId, body) {
+        return this.requestData('PUT', `/api/v1/endpoints/${encodeURIComponent(endpointId)}`, {
+            body,
+            spinnerLabel: 'Updating endpoint',
+        });
+    }
+    async activateEndpoint(endpointId) {
+        await this.requestData('POST', `/api/v1/endpoints/${encodeURIComponent(endpointId)}/activate`, {
+            spinnerLabel: 'Activating endpoint',
+        });
+    }
+    async disableEndpoint(endpointId) {
+        await this.requestData('POST', `/api/v1/endpoints/${encodeURIComponent(endpointId)}/disable`, {
+            spinnerLabel: 'Disabling endpoint',
+        });
+    }
+    async restoreEndpoint(endpointId) {
+        await this.requestData('POST', `/api/v1/endpoints/${encodeURIComponent(endpointId)}/restore`, {
+            spinnerLabel: 'Restoring endpoint',
+        });
+    }
+    async getComponentSnapshotVersion(componentId, version) {
+        return this.requestData('GET', `/api/v1/activity/${encodeURIComponent(componentId)}/${encodeURIComponent(String(version))}`, { query: { refType: 'COMPONENTS' } });
     }
     async getEditorTypes(requestPath = '/v1/editor/types') {
         return this.requestData('GET', requestPath, {
             spinnerLabel: 'Loading editor types',
+            allowExternalOrigin: true,
         });
     }
     async debugComponent(requestPath, body) {
         return this.requestData('POST', requestPath, {
             body,
             spinnerLabel: 'Debugging component',
+            allowExternalOrigin: true,
         });
     }
     async *debugComponentStream(requestPath, body) {
         this.assertReady();
+        await this.assertProductionWriteConfirmed('POST', requestPath);
         await this.validateSession();
         const url = buildUrl(this.baseUrl, requestPath);
+        assertCredentialDestination(this.baseUrl, url, true, this.trustedServiceOrigins);
         const headers = new Headers();
         headers.set('Accept', 'text/event-stream');
         headers.set('Content-Type', 'application/json');
@@ -400,7 +946,9 @@ export class RevoClient {
             method: 'POST',
             headers,
             body: JSON.stringify(body),
+            redirect: 'manual',
         });
+        assertNoAuthenticatedRedirect(response);
         if (!response.ok) {
             const data = await readResponseData(response);
             if (response.status === 401) {
@@ -409,12 +957,12 @@ export class RevoClient {
                     status: 'not_authenticated',
                     checkedAt: Date.now(),
                 });
-                throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', data);
+                throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', data, response.headers);
             }
             if (response.status === 403) {
-                throw new PermissionDeniedError(requestPath, `Access denied for ${requestPath}.`, data);
+                throw new PermissionDeniedError(requestPath, `Access denied for ${requestPath}.`, data, response.headers);
             }
-            throw new ApiError(response.status, toErrorMessage(typeof data === 'string' ? data : JSON.stringify(data), response.status), data);
+            throw new ApiError(response.status, toErrorMessage(typeof data === 'string' ? data : JSON.stringify(data), response.status), data, response.headers);
         }
         for await (const event of readSseEvents(response)) {
             yield event;
@@ -428,11 +976,404 @@ export class RevoClient {
             query: options.query,
         });
     }
+    async listAllComponents() {
+        const components = [];
+        const seenRequests = new Set();
+        let nextRequest = {
+            query: buildActiveComponentListQuery(0),
+        };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Component list pagination loop detected while listing all components.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listComponents(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    components.push(item);
+                }
+            }
+            if (page.total !== null && components.length >= page.total) {
+                nextRequest = null;
+                continue;
+            }
+            if (page.nextRequest) {
+                nextRequest = withActiveComponentListFilter(page.nextRequest);
+                continue;
+            }
+            if (nextRequest.query
+                && typeof nextRequest.query.take === 'number'
+                && page.items.length === nextRequest.query.take) {
+                nextRequest = {
+                    query: buildActiveComponentListQuery(components.length, nextRequest.query.take),
+                };
+                continue;
+            }
+            nextRequest = null;
+        }
+        return { components, discoveredTotal };
+    }
     async getComponent(componentId) {
         return this.requestData('GET', `/api/v1/component/${componentId}`);
     }
+    async createComponent(body) {
+        return this.requestData('POST', '/api/v1/component', {
+            body,
+            spinnerLabel: 'Creating component',
+        });
+    }
+    async updateComponent(componentId, body) {
+        return this.requestData('PUT', `/api/v1/component/${componentId}`, {
+            body,
+            spinnerLabel: 'Updating component',
+        });
+    }
+    async deleteComponent(componentId) {
+        return this.request('DELETE', `/api/v1/component/${componentId}`, {
+            spinnerLabel: 'Deleting component',
+        });
+    }
+    async listRoleGroups(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/role-groups', {
+            query: options.query,
+        });
+    }
+    async listAllRoleGroups() {
+        const roleGroups = [];
+        const seenRequests = new Set();
+        let nextRequest = {
+            query: { take: COMPONENT_LIST_PAGE_SIZE, skip: 0, count: true },
+        };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Role-group list pagination loop detected while listing all role groups.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listRoleGroups(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    roleGroups.push(item);
+                }
+            }
+            if (page.total !== null && roleGroups.length >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = page.nextRequest;
+            }
+            else if (nextRequest.query && typeof nextRequest.query.take === 'number' && page.items.length === nextRequest.query.take) {
+                nextRequest = { query: { ...nextRequest.query, skip: roleGroups.length } };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        return { roleGroups, discoveredTotal };
+    }
+    async getRoleGroup(roleGroupId) {
+        return this.requestData('GET', `/api/v1/role-groups/${roleGroupId}`);
+    }
+    async listGroups(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/groups', {
+            query: options.query,
+        });
+    }
+    async listAllGroups() {
+        const groups = [];
+        const seenRequests = new Set();
+        let nextRequest = {
+            query: { take: COMPONENT_LIST_PAGE_SIZE, skip: 0, count: true },
+        };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Group list pagination loop detected while listing all groups.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listGroups(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    groups.push(item);
+                }
+            }
+            if (page.total !== null && groups.length >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = page.nextRequest;
+            }
+            else if (nextRequest.query && typeof nextRequest.query.take === 'number' && page.items.length === nextRequest.query.take) {
+                nextRequest = { query: { ...nextRequest.query, skip: groups.length } };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        return { groups, discoveredTotal };
+    }
+    async getGroup(groupId) {
+        return this.requestData('GET', `/api/v1/groups/${groupId}`);
+    }
+    async listJobTemplates(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/automation/template', {
+            query: options.query,
+        });
+    }
+    async listAllJobTemplates() {
+        const jobTemplates = [];
+        const seenRequests = new Set();
+        let nextRequest = { query: buildActiveComponentListQuery(0) };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Job-template list pagination loop detected while listing all job templates.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listJobTemplates(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    jobTemplates.push(item);
+                }
+            }
+            if (page.total !== null && jobTemplates.length >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = withActiveComponentListFilter(page.nextRequest);
+            }
+            else if (nextRequest.query && typeof nextRequest.query.take === 'number' && page.items.length === nextRequest.query.take) {
+                nextRequest = { query: buildActiveComponentListQuery(jobTemplates.length, nextRequest.query.take) };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        return { jobTemplates, discoveredTotal };
+    }
+    async getJobTemplate(jobTemplateId) {
+        return this.requestData('GET', `/api/v1/automation/template/${jobTemplateId}`);
+    }
+    async createJobTemplate(body) {
+        return this.requestData('POST', '/api/v1/automation/template', {
+            body,
+            spinnerLabel: 'Creating job template',
+        });
+    }
+    async updateJobTemplate(jobTemplateId, body) {
+        return this.requestData('PUT', `/api/v1/automation/template/${jobTemplateId}`, {
+            body,
+            spinnerLabel: 'Updating job template',
+        });
+    }
+    async listSchedules(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/automation/schedule', {
+            query: options.query,
+        });
+    }
+    async listAllSchedules() {
+        const schedules = [];
+        const seenRequests = new Set();
+        let nextRequest = { query: buildActiveComponentListQuery(0) };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Schedule list pagination loop detected while listing all schedules.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listSchedules(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    schedules.push(item);
+                }
+            }
+            if (page.total !== null && schedules.length >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = withActiveComponentListFilter(page.nextRequest);
+            }
+            else if (nextRequest.query && typeof nextRequest.query.take === 'number' && page.items.length === nextRequest.query.take) {
+                nextRequest = { query: buildActiveComponentListQuery(schedules.length, nextRequest.query.take) };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        return { schedules, discoveredTotal };
+    }
+    async getSchedule(scheduleId) {
+        return this.requestData('GET', `/api/v1/automation/schedule/${scheduleId}`);
+    }
+    async createSchedule(body) {
+        return this.requestData('POST', '/api/v1/automation/schedule', {
+            body,
+            spinnerLabel: 'Creating schedule',
+        });
+    }
+    async updateSchedule(scheduleId, body) {
+        return this.requestData('PUT', `/api/v1/automation/schedule/${scheduleId}`, {
+            body,
+            spinnerLabel: 'Updating schedule',
+        });
+    }
+    async activateSchedule(scheduleId) {
+        return this.requestData('POST', `/api/v1/automation/schedule/${scheduleId}/activate`, {
+            spinnerLabel: 'Activating schedule',
+        });
+    }
+    async listEvents(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/automation/event', {
+            query: options.query,
+        });
+    }
+    async listAllEvents({ includeDeleted = false } = {}) {
+        const events = [];
+        const seenRequests = new Set();
+        let nextRequest = {
+            query: includeDeleted
+                ? { take: COMPONENT_LIST_PAGE_SIZE, skip: 0, count: true }
+                : buildActiveComponentListQuery(0),
+        };
+        let discoveredTotal = null;
+        while (nextRequest) {
+            const requestKey = JSON.stringify(nextRequest);
+            if (seenRequests.has(requestKey)) {
+                throw new Error('Event list pagination loop detected while listing all events.');
+            }
+            seenRequests.add(requestKey);
+            const pageValue = await this.listEvents(nextRequest);
+            const page = unwrapListPage(pageValue);
+            if (page.total !== null) {
+                discoveredTotal = page.total;
+            }
+            for (const item of page.items) {
+                if (isRecord(item)) {
+                    events.push(item);
+                }
+            }
+            if (page.total !== null && events.length >= page.total) {
+                nextRequest = null;
+            }
+            else if (page.nextRequest) {
+                nextRequest = includeDeleted
+                    ? page.nextRequest
+                    : withActiveComponentListFilter(page.nextRequest);
+            }
+            else if (nextRequest.query && typeof nextRequest.query.take === 'number' && page.items.length === nextRequest.query.take) {
+                nextRequest = {
+                    query: includeDeleted
+                        ? { take: nextRequest.query.take, skip: events.length, count: true }
+                        : buildActiveComponentListQuery(events.length, nextRequest.query.take),
+                };
+            }
+            else {
+                nextRequest = null;
+            }
+        }
+        return { events, discoveredTotal };
+    }
+    async getEvent(eventId) {
+        return this.requestData('GET', `/api/v1/automation/event/${eventId}`);
+    }
+    async createEvent(body) {
+        return this.requestData('POST', '/api/v1/automation/event', {
+            body,
+            spinnerLabel: 'Creating event',
+        });
+    }
+    async updateEvent(eventId, body) {
+        return this.requestData('PUT', `/api/v1/automation/event/${eventId}`, {
+            body,
+            spinnerLabel: 'Updating event',
+        });
+    }
+    async activateEvent(eventId) {
+        return this.requestData('POST', `/api/v1/automation/event/${eventId}/activate`, {
+            spinnerLabel: 'Activating event',
+        });
+    }
+    async disableEvent(eventId) {
+        return this.requestData('POST', `/api/v1/automation/event/${eventId}/disable`, {
+            spinnerLabel: 'Disabling event',
+        });
+    }
+    async createRoleGroup(body) {
+        return this.requestData('POST', '/api/v1/role-groups', {
+            body,
+            spinnerLabel: 'Creating role group',
+        });
+    }
+    async updateRoleGroup(roleGroupId, body) {
+        return this.requestData('PUT', `/api/v1/role-groups/${roleGroupId}`, {
+            body,
+            spinnerLabel: 'Updating role group',
+        });
+    }
+    async updateGroup(groupId, body) {
+        return this.requestData('PUT', `/api/v1/groups/${groupId}`, {
+            body,
+            spinnerLabel: 'Updating group',
+        });
+    }
+    async createGroup(body) {
+        return this.requestData('POST', '/api/v1/groups', {
+            body,
+            spinnerLabel: 'Creating group',
+        });
+    }
+    async addRoleGroupRole(roleGroupId, roleKey) {
+        return this.requestData('POST', `/api/v1/role-groups/${roleGroupId}/roleAdd`, {
+            body: { key: roleKey },
+            spinnerLabel: 'Adding role-group role',
+        });
+    }
+    async removeRoleGroupRole(roleGroupId, roleKey) {
+        return this.requestData('POST', `/api/v1/role-groups/${roleGroupId}/roleDelete`, {
+            body: { key: roleKey },
+            spinnerLabel: 'Removing role-group role',
+        });
+    }
+    async deleteRoleGroup(roleGroupId) {
+        return this.request('DELETE', `/api/v1/role-groups/${roleGroupId}`, {
+            spinnerLabel: 'Deleting role group',
+        });
+    }
+    async listSystemRoles() {
+        return this.requestData('GET', '/api/v1/roles');
+    }
+    async listAllSystemRoles() {
+        return unwrapList(await this.listSystemRoles()).filter(isRecord);
+    }
     async saveComponentElements(componentId, body) {
         return this.request('POST', `/api/v1/component/${componentId}/save`, { body });
     }
 }
+export { COMPONENT_LIST_PAGE_SIZE };
 export { buildUrl, normalizeToken };