@revoengine/cli 1.0.0

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

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

package/dist/src/commands/endpoints.js

@@ -0,0 +1,4 @@
+export async function handleEndpointsCommand(context) {
+    const endpoints = await context.client.listEndpoints();
+    context.print(endpoints);
+}

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

@@ -0,0 +1,7 @@
+export * from './auth.ts';
+export * from './component.ts';
+export * from './endpoints.ts';
+export * from './info.ts';
+export * from './project.ts';
+export * from './request.ts';
+export * from './search.ts';

package/dist/src/commands/index.js

@@ -0,0 +1,7 @@
+export * from "./auth.js";
+export * from "./component.js";
+export * from "./endpoints.js";
+export * from "./info.js";
+export * from "./project.js";
+export * from "./request.js";
+export * from "./search.js";

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

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

package/dist/src/commands/info.js

@@ -0,0 +1,6 @@
+import { buildRuntimeViewModel } from "../runtime-view.js";
+import { renderRuntimeInfo } from "../ui.js";
+export async function handleInfoCommand(context) {
+    const view = await buildRuntimeViewModel(context);
+    context.print(renderRuntimeInfo(view));
+}

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

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

package/dist/src/commands/project.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { isUuid, loadStoredConfigIndex } from "../config.js";
+import { buildProjectSyncState, buildEditorTypesUrl, extractSandboxEndpoint, extractEditorTypesBundle, findProjectMetadataFile, resolveProjectInvocation, resolveProjectRoot, resolveProjectTarget, syncProjectFiles, } from "../project.js";
+function printSyncSummary(println, targetDir, result, prefix) {
+    println(`${prefix} ${targetDir}`);
+    println(`Wrote ${path.relative(targetDir, result.typesFile)}`);
+    println(`Wrote ${path.relative(targetDir, result.metadataFile)}`);
+    println(`${result.configResult.action === 'created' ? 'Created' : 'Patched'} ${path.basename(result.configResult.filePath)}`);
+    if (result.gitignoreResult.action === 'created') {
+        println('Created .gitignore');
+    }
+    else if (result.gitignoreResult.action === 'patched') {
+        println('Patched .gitignore');
+    }
+    println('Restart TypeScript server in VSCode if IntelliSense does not appear');
+}
+async function resolveProjectSyncInput(context) {
+    const { client } = context;
+    client.assertReady();
+    const profile = await client.me();
+    const sandboxEndpoint = extractSandboxEndpoint(profile);
+    if (!sandboxEndpoint) {
+        throw new Error('Authenticated profile did not include `endpoints.sandbox`, so editor types cannot be initialized for this instance.');
+    }
+    const bundle = extractEditorTypesBundle(await client.getEditorTypes(buildEditorTypesUrl(sandboxEndpoint)));
+    return buildProjectSyncState({
+        fallbackEndpoint: sandboxEndpoint,
+        fallbackInstanceId: client.instance,
+        bundle,
+    });
+}
+export async function handleProjectCommand(context) {
+    const { args, client, cwd, println } = context;
+    const invocation = resolveProjectInvocation(args);
+    if (invocation.action === 'update') {
+        throw new Error('`revo project update` is not implemented yet.');
+    }
+    if (invocation.action === 'switch') {
+        if (invocation.extraArgs.length > 0) {
+            throw new Error('Project switch accepts exactly one instance ID.');
+        }
+        const instanceId = invocation.targetArg || '';
+        if (!instanceId) {
+            throw new Error('Missing instance UUID. Usage: `revo project switch <instanceId>`.');
+        }
+        if (!isUuid(instanceId)) {
+            throw new Error('Instance ID must be a UUID.');
+        }
+        const metadataFile = findProjectMetadataFile(cwd);
+        if (!metadataFile) {
+            throw new Error('Current directory is not inside an initialized Revo project.');
+        }
+        const projectRoot = resolveProjectRoot(cwd);
+        if (!projectRoot) {
+            throw new Error('Unable to resolve the current Revo project root.');
+        }
+        const storedConfigs = loadStoredConfigIndex();
+        const selected = storedConfigs.instances[instanceId];
+        if (!selected) {
+            throw new Error(`No stored credentials found for instance ${instanceId}. Run \`revo auth login --instance ${instanceId}\` first.`);
+        }
+        if (!selected.token) {
+            throw new Error(`Stored credentials for instance ${instanceId} are incomplete. Run \`revo auth login --instance ${instanceId}\` again.`);
+        }
+        client.baseUrl = selected.baseUrl;
+        client.instance = instanceId;
+        client.token = selected.token;
+        const syncInput = await resolveProjectSyncInput(context);
+        const result = syncProjectFiles(projectRoot, syncInput);
+        printSyncSummary(println, projectRoot, result, `Switched Revo project to ${instanceId} in`);
+        return;
+    }
+    if (invocation.extraArgs.length > 0) {
+        throw new Error('Project init accepts at most one path argument.');
+    }
+    const targetDir = resolveProjectTarget(cwd, invocation.targetArg);
+    const syncInput = await resolveProjectSyncInput(context);
+    const result = syncProjectFiles(targetDir, syncInput);
+    printSyncSummary(println, targetDir, result, 'Initialized Revo project in');
+}

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

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

package/dist/src/commands/request.js

@@ -0,0 +1,59 @@
+import { readFlag, readValues } from "../utils.js";
+function parseJsonMaybe(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parsePositionalJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error('Positional request body must be valid JSON.');
+    }
+}
+function parseQueryValue(value) {
+    const query = {};
+    const parts = value.split(/[,&]/).map((part) => part.trim()).filter(Boolean);
+    for (const part of parts) {
+        const [key, raw] = part.split('=');
+        if (!key) {
+            continue;
+        }
+        query[key] = raw ?? '';
+    }
+    return query;
+}
+export async function handleRequestCommand(context) {
+    const { args, client } = context;
+    const method = (args._[1] || readFlag(args, ['method', 'm']) || 'GET').toUpperCase();
+    const requestPath = args._[2] || readFlag(args, ['path', 'p']) || '';
+    const bodyFlag = readFlag(args, ['body', 'd']);
+    const positionalBody = args._[3] || '';
+    const body = positionalBody ? parsePositionalJson(positionalBody) : parseJsonMaybe(bodyFlag);
+    const queryValues = readValues(args, ['query', 'q']);
+    if (!requestPath) {
+        throw new Error('Missing request path.');
+    }
+    const query = queryValues.reduce((acc, entry) => {
+        return {
+            ...acc,
+            ...parseQueryValue(entry),
+        };
+    }, {});
+    const response = await client.request(method, requestPath, {
+        query: Object.keys(query).length > 0 ? query : undefined,
+        body,
+    });
+    context.print({
+        status: response.status,
+        ok: response.ok,
+        data: response.data,
+    });
+}

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

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

package/dist/src/commands/search.js

@@ -0,0 +1,22 @@
+import { readFlag } from "../utils.js";
+const SEARCH_TYPES = new Set(['CODE', 'SIMPLE']);
+export async function handleSearchCommand(context) {
+    const { args, client } = context;
+    const type = (readFlag(args, ['type', 't']) || args._[1] || '').toUpperCase();
+    const term = readFlag(args, ['term']) || args._[2] || '';
+    if (!type || !term) {
+        throw new Error('Search requires a type and a term.');
+    }
+    if (!SEARCH_TYPES.has(type)) {
+        throw new Error('Search type must be CODE or SIMPLE.');
+    }
+    const result = await client.search({
+        type,
+        term,
+        componentType: readFlag(args, ['componentType']),
+        caseSensitive: readFlag(args, ['caseSensitive']),
+        take: readFlag(args, ['take']),
+        skip: readFlag(args, ['skip']),
+    });
+    context.print(result);
+}

package/dist/src/config.d.ts

@@ -0,0 +1,54 @@
+export declare const APP_NAME = "revoengine";
+export declare const DEFAULT_BASE_URL = "https://api.revoengine.com";
+export type RuntimeConfig = {
+    baseUrl: string;
+    instance: string;
+    token: string;
+};
+export type RuntimeConfigOptions = {
+    baseUrl?: string;
+    instance?: string;
+    token?: string;
+};
+type StoredConfig = RuntimeConfig;
+type StoredInstanceConfig = {
+    baseUrl: string;
+    token: string;
+};
+type StoredConfigFile = {
+    defaultInstance: string;
+    instances: Record<string, StoredInstanceConfig>;
+};
+export type AuthValidationState = {
+    key: string;
+    status: 'authenticated' | 'not_authenticated';
+    checkedAt: number;
+    profile?: unknown;
+};
+export declare const AUTH_VALIDATION_TTL_MS = 60000;
+export declare function getConfigDir(): string;
+export declare function getConfigPaths(): {
+    dir: string;
+    configFile: string;
+    credentialsFile: string;
+    authStateFile: string;
+};
+export declare function readProjectInstanceId(startDir?: string): string;
+export declare function isUuid(value: unknown): value is string;
+export declare function saveStoredConfig(nextConfig: Partial<StoredConfig>): void;
+export declare function clearStoredConfig(): void;
+export declare function loadStoredConfigIndex(): StoredConfigFile;
+export declare function loadStoredConfig(options?: {
+    instance?: string;
+    allowLegacy?: boolean;
+}): RuntimeConfig;
+export declare function buildAuthValidationKey(runtime: RuntimeConfigOptions): string;
+export declare function readAuthValidationState(key?: string): AuthValidationState;
+export declare function saveAuthValidationState(state: AuthValidationState): void;
+export declare function clearAuthValidationState(key?: string): void;
+export declare function resolveRuntimeConfig(options?: RuntimeConfigOptions): {
+    baseUrl: string;
+    instance: string;
+    token: string;
+};
+export {};

package/dist/src/config.js

@@ -0,0 +1,356 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { readLegacyImportFromProject } from "./legacy.js";
+import { readJsonFile, writeJsonFile } from "./utils.js";
+export const APP_NAME = 'revoengine';
+export const DEFAULT_BASE_URL = 'https://api.revoengine.com';
+export const AUTH_VALIDATION_TTL_MS = 60_000;
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function getConfigDir() {
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        return path.join(process.env.APPDATA, APP_NAME);
+    }
+    const homeConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    return path.join(homeConfig, APP_NAME);
+}
+export function getConfigPaths() {
+    const dir = getConfigDir();
+    return {
+        dir,
+        configFile: path.join(dir, 'config.json'),
+        credentialsFile: path.join(dir, 'credentials.json'),
+        authStateFile: path.join(dir, 'auth-state.json'),
+    };
+}
+function findProjectMetadataFile(startDir = process.cwd()) {
+    if (!startDir) {
+        return '';
+    }
+    let currentDir = path.resolve(startDir);
+    const { root } = path.parse(currentDir);
+    while (true) {
+        const candidate = path.join(currentDir, '.revoengine', 'revo.json');
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        if (currentDir === root) {
+            return '';
+        }
+        currentDir = path.dirname(currentDir);
+    }
+}
+export function readProjectInstanceId(startDir = process.cwd()) {
+    const metadataFile = findProjectMetadataFile(startDir);
+    if (!metadataFile) {
+        return '';
+    }
+    try {
+        const metadata = readJsonFile(metadataFile);
+        return typeof metadata.instanceId === 'string' ? metadata.instanceId : '';
+    }
+    catch {
+        return '';
+    }
+}
+function resolveEnvValue(keys) {
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value) {
+            return value;
+        }
+    }
+    return '';
+}
+export function isUuid(value) {
+    return typeof value === 'string'
+        && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+export function saveStoredConfig(nextConfig) {
+    const { dir, configFile, credentialsFile } = getConfigPaths();
+    ensureDirectory(dir);
+    const current = readStoredConfigFile();
+    const fallback = current.defaultInstance ? current.instances[current.defaultInstance] : undefined;
+    const instance = nextConfig.instance || current.defaultInstance || '';
+    if (!instance) {
+        writeJsonFile(configFile, current);
+        removeFileIfExists(credentialsFile);
+        return;
+    }
+    const currentEntry = current.instances[instance];
+    current.instances[instance] = {
+        baseUrl: nextConfig.baseUrl || currentEntry?.baseUrl || fallback?.baseUrl || DEFAULT_BASE_URL,
+        token: nextConfig.token || currentEntry?.token || fallback?.token || '',
+    };
+    current.defaultInstance = instance;
+    writeJsonFile(configFile, current);
+    removeFileIfExists(credentialsFile);
+}
+export function clearStoredConfig() {
+    const { configFile, credentialsFile, authStateFile } = getConfigPaths();
+    for (const filePath of [configFile, credentialsFile, authStateFile]) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch (error) {
+            if (!error || error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+}
+function removeFileIfExists(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch (error) {
+        if (!error || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+function canIgnoreWriteError(error) {
+    return error !== null
+        && typeof error === 'object'
+        && 'code' in error
+        && ['EACCES', 'EPERM', 'EROFS'].includes(String(error.code));
+}
+function migrateStoredConfigBestEffort(configFile, credentialsFile, nextConfig) {
+    try {
+        writeJsonFile(configFile, nextConfig);
+        removeFileIfExists(credentialsFile);
+    }
+    catch (error) {
+        if (!canIgnoreWriteError(error)) {
+            throw error;
+        }
+    }
+}
+function emptyStoredConfigFile() {
+    return {
+        defaultInstance: '',
+        instances: {},
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeInstanceConfig(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    return {
+        baseUrl: typeof value.baseUrl === 'string'
+            ? value.baseUrl
+            : typeof value.url === 'string'
+                ? value.url
+                : DEFAULT_BASE_URL,
+        token: typeof value.token === 'string' ? value.token : '',
+    };
+}
+function parseMappedConfig(raw) {
+    if (!isRecord(raw) || !isRecord(raw.instances)) {
+        return null;
+    }
+    const instances = {};
+    for (const [instanceId, value] of Object.entries(raw.instances)) {
+        if (!isUuid(instanceId)) {
+            continue;
+        }
+        const normalized = normalizeInstanceConfig(value);
+        if (normalized) {
+            instances[instanceId] = normalized;
+        }
+    }
+    const configuredDefault = typeof raw.defaultInstance === 'string' ? raw.defaultInstance : '';
+    const defaultInstance = isUuid(configuredDefault) && instances[configuredDefault]
+        ? configuredDefault
+        : Object.keys(instances)[0] || '';
+    return {
+        defaultInstance,
+        instances,
+    };
+}
+function parseLegacyConfig(config, credentials) {
+    const baseUrl = isRecord(config) && typeof config.baseUrl === 'string'
+        ? config.baseUrl
+        : isRecord(config) && typeof config.url === 'string'
+            ? config.url
+            : DEFAULT_BASE_URL;
+    const instance = isRecord(config) && typeof config.instance === 'string' ? config.instance : '';
+    const token = isRecord(credentials) && typeof credentials.token === 'string' ? credentials.token : '';
+    if (!instance) {
+        return emptyStoredConfigFile();
+    }
+    return {
+        defaultInstance: instance,
+        instances: {
+            [instance]: {
+                baseUrl,
+                token,
+            },
+        },
+    };
+}
+function readStoredConfigFile() {
+    const { configFile, credentialsFile } = getConfigPaths();
+    const config = fs.existsSync(configFile) ? readJsonFile(configFile) : {};
+    const credentials = fs.existsSync(credentialsFile) ? readJsonFile(credentialsFile) : {};
+    const mapped = parseMappedConfig(config);
+    if (mapped) {
+        if (fs.existsSync(credentialsFile)) {
+            migrateStoredConfigBestEffort(configFile, credentialsFile, mapped);
+        }
+        return mapped;
+    }
+    const legacy = parseLegacyConfig(config, credentials);
+    if (legacy.defaultInstance) {
+        migrateStoredConfigBestEffort(configFile, credentialsFile, legacy);
+    }
+    return legacy;
+}
+export function loadStoredConfigIndex() {
+    return readStoredConfigFile();
+}
+function readStoredConfig(options = {}) {
+    const stored = readStoredConfigFile();
+    const selectedInstance = options.instance && stored.instances[options.instance]
+        ? options.instance
+        : stored.defaultInstance;
+    const selected = selectedInstance ? stored.instances[selectedInstance] : undefined;
+    return {
+        baseUrl: selected?.baseUrl || DEFAULT_BASE_URL,
+        instance: selectedInstance || '',
+        token: selected?.token || '',
+    };
+}
+function mergeWithLegacy(stored, options = {}) {
+    if (options.allowLegacy === false) {
+        return stored;
+    }
+    if ((stored.token && stored.instance) || !process.cwd()) {
+        return stored;
+    }
+    const legacy = readLegacyImportFromProject(process.cwd());
+    if (!legacy) {
+        return stored;
+    }
+    const merged = {
+        baseUrl: stored.baseUrl || legacy.baseUrl || DEFAULT_BASE_URL,
+        instance: stored.instance || options.instance || legacy.instance || '',
+        token: stored.token || legacy.token || '',
+    };
+    if (merged.token || merged.instance || merged.baseUrl !== DEFAULT_BASE_URL) {
+        saveStoredConfig(merged);
+    }
+    return merged;
+}
+export function loadStoredConfig(options = {}) {
+    return mergeWithLegacy(readStoredConfig(options), options);
+}
+export function buildAuthValidationKey(runtime) {
+    return createHash('sha256')
+        .update(JSON.stringify({
+        baseUrl: runtime.baseUrl || DEFAULT_BASE_URL,
+        instance: runtime.instance || '',
+        token: runtime.token || '',
+    }))
+        .digest('hex');
+}
+function emptyAuthValidationStateStore() {
+    return {
+        entries: {},
+    };
+}
+function parseAuthValidationStateStore(raw) {
+    if (isRecord(raw) && isRecord(raw.entries)) {
+        const entries = {};
+        for (const [key, value] of Object.entries(raw.entries)) {
+            if (!isRecord(value)) {
+                continue;
+            }
+            const candidate = value;
+            if (candidate.key === key
+                && (candidate.status === 'authenticated' || candidate.status === 'not_authenticated')
+                && typeof candidate.checkedAt === 'number') {
+                entries[key] = candidate;
+            }
+        }
+        return { entries };
+    }
+    if (isRecord(raw)) {
+        const candidate = raw;
+        if (typeof candidate.key === 'string'
+            && (candidate.status === 'authenticated' || candidate.status === 'not_authenticated')
+            && typeof candidate.checkedAt === 'number') {
+            return {
+                entries: {
+                    [candidate.key]: candidate,
+                },
+            };
+        }
+    }
+    return emptyAuthValidationStateStore();
+}
+function readAuthValidationStateStore() {
+    const { authStateFile } = getConfigPaths();
+    if (!fs.existsSync(authStateFile)) {
+        return emptyAuthValidationStateStore();
+    }
+    const raw = readJsonFile(authStateFile);
+    return parseAuthValidationStateStore(raw);
+}
+export function readAuthValidationState(key) {
+    const store = readAuthValidationStateStore();
+    if (key) {
+        return store.entries[key] || null;
+    }
+    return Object.values(store.entries)[0] || null;
+}
+export function saveAuthValidationState(state) {
+    const { dir, authStateFile } = getConfigPaths();
+    ensureDirectory(dir);
+    const store = readAuthValidationStateStore();
+    store.entries[state.key] = state;
+    writeJsonFile(authStateFile, store);
+}
+export function clearAuthValidationState(key) {
+    const { authStateFile } = getConfigPaths();
+    if (key) {
+        const store = readAuthValidationStateStore();
+        delete store.entries[key];
+        if (Object.keys(store.entries).length > 0) {
+            writeJsonFile(authStateFile, store);
+            return;
+        }
+    }
+    try {
+        fs.unlinkSync(authStateFile);
+    }
+    catch (error) {
+        if (!error || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+export function resolveRuntimeConfig(options = {}) {
+    const env = {
+        baseUrl: resolveEnvValue(['REVO_URL', 'REVO_BASE_URL', 'REVOENGINE_URL', 'REVOENGINE_BASE_URL']),
+        instance: resolveEnvValue(['REVO_INSTANCE', 'REVOENGINE_INSTANCE']),
+        token: resolveEnvValue(['REVO_TOKEN', 'REVO_API_KEY', 'REVOENGINE_TOKEN', 'REVOENGINE_API_KEY']),
+    };
+    const projectInstance = !options.instance && !env.instance ? readProjectInstanceId() : '';
+    const requestedInstance = options.instance || env.instance || projectInstance || undefined;
+    const stored = loadStoredConfig({
+        instance: requestedInstance,
+        allowLegacy: !requestedInstance,
+    });
+    return {
+        baseUrl: options.baseUrl || env.baseUrl || stored.baseUrl || DEFAULT_BASE_URL,
+        instance: options.instance || env.instance || stored.instance || '',
+        token: options.token || env.token || stored.token || '',
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './config.ts';
+export * from './client.ts';
+export * from './cli.ts';
+export * from './commands/index.ts';

package/dist/src/index.js

@@ -0,0 +1,4 @@
+export * from "./config.js";
+export * from "./client.js";
+export * from "./cli.js";
+export * from "./commands/index.js";

package/dist/src/legacy.d.ts

@@ -0,0 +1,8 @@
+export type LegacyRuntimeImport = {
+    baseUrl: string;
+    instance: string;
+    token: string;
+    source: string;
+};
+export declare function readLegacyImportFromFile(filePath: string, preferredInstance?: string | null): LegacyRuntimeImport | null;
+export declare function readLegacyImportFromProject(cwd?: string): LegacyRuntimeImport | null;