@revoengine/cli 1.0.0

package/dist/src/client.js

@@ -0,0 +1,315 @@
+import { AUTH_VALIDATION_TTL_MS, buildAuthValidationKey, DEFAULT_BASE_URL, isUuid, readAuthValidationState, resolveRuntimeConfig, saveAuthValidationState, } from "./config.js";
+import { createSpinner } from "./spinner.js";
+export class ApiError extends Error {
+    status;
+    data;
+    constructor(status, message, data) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.data = data;
+    }
+}
+export class AuthenticationError extends ApiError {
+    constructor(status, message, data) {
+        super(status, message, data);
+        this.name = 'AuthenticationError';
+    }
+}
+export class PermissionDeniedError extends ApiError {
+    path;
+    constructor(path, message, data) {
+        super(403, message, data);
+        this.name = 'PermissionDeniedError';
+        this.path = path;
+    }
+}
+const REQUEST_DELAY_MS = 50;
+function normalizeBaseUrl(baseUrl) {
+    const url = new URL(baseUrl || DEFAULT_BASE_URL);
+    url.pathname = url.pathname.replace(/\/+$/, '');
+    return url;
+}
+function buildUrl(baseUrl, requestPath, query) {
+    if (/^https?:\/\//i.test(requestPath)) {
+        const absolute = new URL(requestPath);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined || value === null || value === '') {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        absolute.searchParams.append(key, String(item));
+                    }
+                }
+                else {
+                    absolute.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return absolute;
+    }
+    const url = normalizeBaseUrl(baseUrl);
+    const pathname = requestPath.startsWith('/') ? requestPath : `/${requestPath}`;
+    const basePath = url.pathname === '/' ? '' : url.pathname;
+    url.pathname = pathname.startsWith(basePath) ? pathname : `${basePath}${pathname}`;
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null || value === '') {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    url.searchParams.append(key, String(item));
+                }
+            }
+            else {
+                url.searchParams.set(key, String(value));
+            }
+        }
+    }
+    return url;
+}
+function normalizeToken(token) {
+    if (!token) {
+        return '';
+    }
+    return token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+}
+function defaultSpinnerLabel(method, path) {
+    const upperMethod = method.toUpperCase();
+    if (path === '/api/v1/me') {
+        return 'Validating session';
+    }
+    if (path === '/api/v1/endpoints') {
+        return 'Loading endpoints';
+    }
+    if (path === '/api/v1/search') {
+        return 'Searching';
+    }
+    if (path === '/api/v1/component' && upperMethod === 'GET') {
+        return 'Loading components';
+    }
+    if (path === '/api/v1/component' && upperMethod === 'POST') {
+        return 'Creating component';
+    }
+    if (/^\/api\/v1\/component\/[^/]+\/save$/i.test(path)) {
+        return 'Saving component';
+    }
+    if (/^\/api\/v1\/component\/[^/]+$/i.test(path) && upperMethod === 'GET') {
+        return 'Loading component';
+    }
+    return `${upperMethod} ${path}`;
+}
+function toErrorMessage(responseText, status) {
+    const trimmed = responseText.trim();
+    return trimmed ? `${status} ${trimmed}` : `HTTP ${status}`;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readResponseData(response) {
+    const text = await response.text();
+    const contentType = response.headers.get('content-type') || '';
+    if (!text) {
+        return null;
+    }
+    if (contentType.includes('application/json')) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    return text;
+}
+export class RevoClient {
+    baseUrl;
+    instance;
+    token;
+    fetchImpl;
+    constructor(options = {}) {
+        const config = resolveRuntimeConfig(options);
+        this.baseUrl = config.baseUrl;
+        this.instance = config.instance;
+        this.token = config.token;
+        this.fetchImpl = options.fetch || globalThis.fetch;
+    }
+    get authHeader() {
+        return normalizeToken(this.token);
+    }
+    get authValidationKey() {
+        return buildAuthValidationKey({
+            baseUrl: this.baseUrl,
+            instance: this.instance,
+            token: this.token,
+        });
+    }
+    assertReady() {
+        if (!this.fetchImpl) {
+            throw new Error('Fetch is not available in this Node.js runtime.');
+        }
+        if (!this.token) {
+            throw new Error('Missing API token. Run `revo auth login` or set REVO_TOKEN / REVO_API_KEY.');
+        }
+        if (!this.instance) {
+            throw new Error('Missing instance UUID. Run `revo auth login` or set REVO_INSTANCE.');
+        }
+        if (!isUuid(this.instance)) {
+            throw new Error(`Invalid instance UUID: ${this.instance}`);
+        }
+    }
+    async validateSession(options = {}) {
+        this.assertReady();
+        const cached = readAuthValidationState(this.authValidationKey);
+        const now = Date.now();
+        if (!options.force
+            && cached
+            && cached.key === this.authValidationKey
+            && now - cached.checkedAt < AUTH_VALIDATION_TTL_MS) {
+            if (cached.status === 'not_authenticated') {
+                throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', null);
+            }
+            if (cached.profile !== undefined) {
+                return {
+                    authenticated: true,
+                    fromCache: true,
+                    profile: cached.profile,
+                };
+            }
+        }
+        try {
+            const profile = await this.requestData('GET', '/api/v1/me', { authGuard: false });
+            saveAuthValidationState({
+                key: this.authValidationKey,
+                status: 'authenticated',
+                checkedAt: now,
+                profile,
+            });
+            return {
+                authenticated: true,
+                fromCache: false,
+                profile,
+            };
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 401) {
+                saveAuthValidationState({
+                    key: this.authValidationKey,
+                    status: 'not_authenticated',
+                    checkedAt: now,
+                });
+                throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', error.data);
+            }
+            throw error;
+        }
+    }
+    async request(method, path, options = {}) {
+        this.assertReady();
+        if (options.authGuard !== false && path !== '/api/v1/me') {
+            await this.validateSession();
+        }
+        const url = buildUrl(this.baseUrl, path, options.query);
+        const headers = new Headers(options.headers || {});
+        headers.set('Authorization', this.authHeader);
+        headers.set('x-api-key', this.token);
+        headers.set('instance', this.instance);
+        headers.set('x-api-instance', this.instance);
+        let body = options.body;
+        if (body !== undefined && body !== null && method.toUpperCase() !== 'GET') {
+            headers.set('Content-Type', 'application/json');
+            body = JSON.stringify(body);
+        }
+        else if (method.toUpperCase() === 'GET') {
+            body = undefined;
+        }
+        const spinner = createSpinner({
+            text: options.spinnerLabel || defaultSpinnerLabel(method, path),
+        });
+        spinner.start();
+        try {
+            await delay(REQUEST_DELAY_MS);
+            const response = await this.fetchImpl(url, {
+                method: method.toUpperCase(),
+                headers,
+                body: body,
+            });
+            const data = await readResponseData(response);
+            if (!response.ok && response.status !== 304) {
+                if (response.status === 401) {
+                    saveAuthValidationState({
+                        key: this.authValidationKey,
+                        status: 'not_authenticated',
+                        checkedAt: Date.now(),
+                    });
+                    throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', data);
+                }
+                if (response.status === 403 && path !== '/api/v1/me') {
+                    throw new PermissionDeniedError(path, `Access denied for ${path}.`, data);
+                }
+                throw new ApiError(response.status, toErrorMessage(typeof data === 'string' ? data : JSON.stringify(data), response.status), data);
+            }
+            const previous = readAuthValidationState(this.authValidationKey);
+            saveAuthValidationState({
+                key: this.authValidationKey,
+                status: 'authenticated',
+                checkedAt: Date.now(),
+                profile: previous && previous.key === this.authValidationKey ? previous.profile : undefined,
+            });
+            return {
+                status: response.status,
+                ok: response.ok,
+                data,
+                headers: response.headers,
+            };
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+    async requestData(method, path, options = {}) {
+        const response = await this.request(method, path, options);
+        return response.data;
+    }
+    async me(options = {}) {
+        const result = await this.validateSession({ force: options.force });
+        if (result.profile !== undefined) {
+            return result.profile;
+        }
+        return this.requestData('GET', '/api/v1/me', { authGuard: false });
+    }
+    async listEndpoints() {
+        return this.requestData('GET', '/api/v1/endpoints');
+    }
+    async getEditorTypes(requestPath = '/v1/editor/types') {
+        return this.requestData('GET', requestPath, {
+            spinnerLabel: 'Loading editor types',
+        });
+    }
+    async debugComponent(requestPath, body) {
+        return this.requestData('POST', requestPath, {
+            body,
+            spinnerLabel: 'Debugging component',
+        });
+    }
+    async search(params) {
+        return this.requestData('GET', '/api/v1/search', { query: params });
+    }
+    async listComponents(options = {}) {
+        return this.requestData('GET', options.path || '/api/v1/component', {
+            query: options.query,
+        });
+    }
+    async getComponent(componentId) {
+        return this.requestData('GET', `/api/v1/component/${componentId}`);
+    }
+    async createComponent(body) {
+        return this.request('POST', '/api/v1/component', { body });
+    }
+    async saveComponentElements(componentId, body) {
+        return this.request('POST', `/api/v1/component/${componentId}/save`, { body });
+    }
+}
+export { buildUrl, normalizeToken };

package/dist/src/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../types.ts';
+export declare function handleAuthCommand(context: CommandContext): Promise<void>;

package/dist/src/commands/auth.js

@@ -0,0 +1,131 @@
+import path from 'node:path';
+import { clearAuthValidationState, clearStoredConfig, getConfigDir, isUuid, loadStoredConfig, resolveRuntimeConfig, saveStoredConfig, } from "../config.js";
+import { readLegacyImportFromFile } from "../legacy.js";
+import { promptText } from "../prompt.js";
+import { buildRuntimeViewModel } from "../runtime-view.js";
+import { renderAuthStatus } from "../ui.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+function getConfigInput(args) {
+    return resolveRuntimeConfig({
+        baseUrl: readFlag(args, ['url', 'baseUrl']) || '',
+        instance: readFlag(args, ['instance', 'i']) || '',
+        token: readFlag(args, ['token', 't']) || '',
+    });
+}
+async function promptMissingConfig(runtime) {
+    let token = runtime.token;
+    let instance = runtime.instance;
+    if (!token) {
+        token = (await promptText('Paste API key (input is visible)')).trim();
+    }
+    if (!instance) {
+        instance = (await promptText('Paste instance ID')).trim();
+    }
+    if (!token) {
+        throw new Error('API key is required.');
+    }
+    if (!instance || !isUuid(instance)) {
+        throw new Error('Instance ID must be a UUID.');
+    }
+    return {
+        token,
+        instance,
+        baseUrl: runtime.baseUrl,
+    };
+}
+export async function handleAuthCommand(context) {
+    const { args, client, print, println, error } = context;
+    const subcommand = args._[1] || 'login';
+    if (subcommand === 'logout') {
+        clearStoredConfig();
+        println(`Removed stored credentials from ${getConfigDir()}.`);
+        return;
+    }
+    if (subcommand === 'get') {
+        const stored = loadStoredConfig();
+        print({
+            instance: stored.instance || null,
+            baseUrl: stored.baseUrl,
+            tokenConfigured: Boolean(stored.token),
+            configDir: getConfigDir(),
+        });
+        return;
+    }
+    if (subcommand === 'set') {
+        const instance = readFlag(args, ['instance', 'i']);
+        if (!instance) {
+            throw new Error('Missing instance UUID.');
+        }
+        if (!isUuid(instance)) {
+            throw new Error('Instance must be a UUID.');
+        }
+        const stored = loadStoredConfig();
+        saveStoredConfig({
+            baseUrl: stored.baseUrl,
+            token: stored.token,
+            instance,
+        });
+        println(`Saved default instance ${instance}.`);
+        return;
+    }
+    if (subcommand === 'status') {
+        const view = await buildRuntimeViewModel(context, { forceValidation: true });
+        print(renderAuthStatus(view));
+        return;
+    }
+    if (subcommand === 'key') {
+        const filePath = readFlag(args, ['file', 'f']) || path.join(process.cwd(), 'config.json');
+        const selectedInstance = readFlag(args, ['instance', 'i']) || '';
+        const offline = readBoolFlag(args, ['offline', 'o']);
+        const imported = readLegacyImportFromFile(filePath, selectedInstance || undefined);
+        if (!imported) {
+            throw new Error(`Unable to read legacy config from ${filePath}.`);
+        }
+        saveStoredConfig(imported);
+        clearAuthValidationState();
+        println(`Imported legacy config from ${filePath}.`);
+        if (!offline) {
+            client.token = imported.token;
+            client.instance = imported.instance;
+            client.baseUrl = imported.baseUrl;
+            if (imported.token && imported.instance) {
+                try {
+                    await client.validateSession({ force: true });
+                }
+                catch (validationError) {
+                    if (validationError instanceof Error) {
+                        error(`Saved config, but validation failed: ${validationError.message}`);
+                    }
+                }
+            }
+        }
+        return;
+    }
+    if (subcommand !== 'login') {
+        throw new Error('Unknown auth command.');
+    }
+    const stored = loadStoredConfig();
+    if (stored.token && stored.instance) {
+        println(`Warning: already logged in for instance ${stored.instance}. Run \`revo auth logout\` before logging in again.`);
+        return;
+    }
+    const runtime = getConfigInput(args);
+    const next = runtime.token && runtime.instance ? runtime : await promptMissingConfig(runtime);
+    client.token = next.token;
+    client.instance = next.instance;
+    client.baseUrl = next.baseUrl;
+    try {
+        await client.validateSession({ force: true });
+    }
+    catch (validationError) {
+        if (validationError instanceof Error) {
+            error(`Saved credentials, but validation failed: ${validationError.message}`);
+            return;
+        }
+        error(`Saved credentials, but validation failed: ${String(validationError)}`);
+        return;
+    }
+    saveStoredConfig(next);
+    clearAuthValidationState();
+    println(`Logged in and saved credentials to ${getConfigDir()}.`);
+}

package/dist/src/commands/component.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../types.ts';
+export declare function handleComponentCommand(context: CommandContext): Promise<void>;