@revoengine/cli 1.0.0

package/dist/src/prompt.js

@@ -0,0 +1,64 @@
+import readline from 'node:readline/promises';
+export function isInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export async function promptText(message, defaultValue = '') {
+    if (!isInteractiveTerminal()) {
+        return defaultValue;
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultValue ? ` [${defaultValue}]` : '';
+    try {
+        const answer = await rl.question(`${message}${suffix}: `);
+        return answer.trim() || defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptSecret(message) {
+    if (!isInteractiveTerminal()) {
+        return '';
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    let muted = true;
+    const originalWriteToOutput = rl._writeToOutput.bind(rl);
+    rl._writeToOutput = (value) => {
+        if (!muted) {
+            originalWriteToOutput(value);
+            return;
+        }
+        if (value.startsWith(`${message}: `)) {
+            originalWriteToOutput(value);
+            return;
+        }
+        // Preserve terminal editing/paste behavior while masking visible content.
+        originalWriteToOutput('*');
+    };
+    try {
+        const answer = await rl.question(`${message}: `);
+        return answer;
+    }
+    finally {
+        muted = false;
+        rl.close();
+    }
+}
+export async function promptConfirm(message, defaultValue = false) {
+    if (!isInteractiveTerminal()) {
+        return defaultValue;
+    }
+    const hint = defaultValue ? 'Y/n' : 'y/N';
+    const answer = (await promptText(`${message} (${hint})`)).trim().toLowerCase();
+    if (!answer) {
+        return defaultValue;
+    }
+    return answer === 'y' || answer === 'yes';
+}

package/dist/src/runtime-view.d.ts

@@ -0,0 +1,17 @@
+import { resolveRuntimeConfig } from './config.ts';
+import type { CommandContext } from './types.ts';
+export type AuthViewState = {
+    status: 'authenticated' | 'not_authenticated' | 'unable_to_validate';
+    validation: string | null;
+    email: string | null;
+};
+export type RuntimeViewModel = {
+    packageVersion: string;
+    nodeVersion: string;
+    configDir: string;
+    runtime: ReturnType<typeof resolveRuntimeConfig>;
+    auth: AuthViewState;
+};
+export declare function buildRuntimeViewModel(context: CommandContext, options?: {
+    forceValidation?: boolean;
+}): Promise<RuntimeViewModel>;

package/dist/src/runtime-view.js

@@ -0,0 +1,80 @@
+import { getConfigDir, resolveRuntimeConfig } from "./config.js";
+import { AuthenticationError } from "./client.js";
+function resolveArgsRuntime(context) {
+    return resolveRuntimeConfig({
+        baseUrl: typeof context.args.url === 'string'
+            ? context.args.url
+            : typeof context.args.baseUrl === 'string'
+                ? context.args.baseUrl
+                : undefined,
+        instance: typeof context.args.instance === 'string'
+            ? context.args.instance
+            : typeof context.args.i === 'string'
+                ? context.args.i
+                : undefined,
+        token: typeof context.args.token === 'string'
+            ? context.args.token
+            : typeof context.args.t === 'string'
+                ? context.args.t
+                : undefined,
+    });
+}
+function extractEmail(profile) {
+    if (!profile || typeof profile !== 'object') {
+        return null;
+    }
+    const candidate = profile;
+    const direct = ['email', 'mail', 'userEmail', 'login'];
+    for (const key of direct) {
+        if (typeof candidate[key] === 'string' && candidate[key]) {
+            return candidate[key];
+        }
+    }
+    const nestedKeys = ['user', 'data', 'profile'];
+    for (const key of nestedKeys) {
+        const nested = candidate[key];
+        if (nested && typeof nested === 'object') {
+            const nestedEmail = extractEmail(nested);
+            if (nestedEmail) {
+                return nestedEmail;
+            }
+        }
+    }
+    return null;
+}
+export async function buildRuntimeViewModel(context, options = {}) {
+    const runtime = resolveArgsRuntime(context);
+    const auth = {
+        status: 'not_authenticated',
+        validation: null,
+        email: null,
+    };
+    if (runtime.token && runtime.instance) {
+        context.client.baseUrl = runtime.baseUrl;
+        context.client.instance = runtime.instance;
+        context.client.token = runtime.token;
+        try {
+            const profile = await context.client.me({ force: options.forceValidation });
+            auth.status = 'authenticated';
+            auth.validation = null;
+            auth.email = extractEmail(profile);
+        }
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                auth.status = 'not_authenticated';
+                auth.validation = error.message;
+            }
+            else {
+                auth.status = 'unable_to_validate';
+                auth.validation = error instanceof Error ? error.message : String(error);
+            }
+        }
+    }
+    return {
+        packageVersion: context.packageVersion,
+        nodeVersion: process.version,
+        configDir: getConfigDir(),
+        runtime,
+        auth,
+    };
+}

package/dist/src/spinner.d.ts

@@ -0,0 +1,14 @@
+type SpinnerStream = {
+    isTTY?: boolean;
+    write: (chunk: string) => boolean;
+};
+type SpinnerOptions = {
+    text: string;
+    stream?: SpinnerStream;
+    intervalMs?: number;
+};
+export declare function createSpinner(options: SpinnerOptions): {
+    start(): void;
+    stop(): void;
+};
+export {};

package/dist/src/spinner.js

@@ -0,0 +1,46 @@
+const FRAMES = ['|', '/', '-', '\\'];
+const ANSI = {
+    reset: '\u001b[0m',
+    cyan: '\u001b[36m',
+    dim: '\u001b[2m',
+};
+function supportsSpinner(stream) {
+    return Boolean(stream.isTTY || process.env.FORCE_COLOR);
+}
+function paint(text, code, stream) {
+    return supportsSpinner(stream) ? `${code}${text}${ANSI.reset}` : text;
+}
+export function createSpinner(options) {
+    const stream = options.stream || process.stderr;
+    if (!supportsSpinner(stream)) {
+        return {
+            start() { },
+            stop() { },
+        };
+    }
+    let index = 0;
+    let timer = null;
+    const render = () => {
+        const frame = paint(FRAMES[index % FRAMES.length], ANSI.cyan, stream);
+        const text = paint(options.text, ANSI.dim, stream);
+        stream.write(`\r${frame} ${text}`);
+        index += 1;
+    };
+    return {
+        start() {
+            if (timer) {
+                return;
+            }
+            render();
+            timer = setInterval(render, options.intervalMs || 90);
+            timer.unref?.();
+        },
+        stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            stream.write('\r\u001b[2K');
+        },
+    };
+}

package/dist/src/types.d.ts

@@ -0,0 +1,36 @@
+import type { RevoClient } from './client.ts';
+export type ParsedArgs = {
+    _: string[];
+    [key: string]: string | boolean | string[] | undefined;
+};
+export type CommandContext = {
+    args: ParsedArgs;
+    client: RevoClient;
+    cwd: string;
+    packageVersion: string;
+    print: (value: unknown) => void;
+    println: (message: string) => void;
+    error: (message: string) => void;
+};
+export type ComponentElementRecord = {
+    key: string;
+    desc?: string;
+    details?: string;
+    hidden?: boolean;
+    order: number;
+    [key: string]: unknown;
+};
+export type ComponentRecord = {
+    componentId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    type?: string;
+    compiler?: string;
+    active?: boolean;
+    async?: boolean;
+    version?: number;
+    elements?: ComponentElementRecord[];
+    [key: string]: unknown;
+};

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/ui.d.ts

@@ -0,0 +1,26 @@
+import type { RuntimeConfig } from './config.ts';
+import type { AuthViewState } from './runtime-view.ts';
+export declare const CLI_NAME = "revo";
+export declare const CLI_ALIAS = "revoengine";
+export declare const CLI_PACKAGE = "@revoengine/cli";
+export declare function renderBanner(version: string): string;
+export declare function renderHelp(version: string): string;
+export declare function renderRuntimeInfo(input: {
+    packageVersion: string;
+    nodeVersion: string;
+    configDir: string;
+    runtime: RuntimeConfig;
+    auth: AuthViewState;
+}): string;
+export declare function renderAuthStatus(input: {
+    configDir: string;
+    runtime: RuntimeConfig;
+    auth: AuthViewState;
+}): string;
+export declare function renderOverview(input: {
+    packageVersion: string;
+    nodeVersion: string;
+    configDir: string;
+    runtime: RuntimeConfig;
+    auth: AuthViewState;
+}): string;

package/dist/src/ui.js

@@ -0,0 +1,182 @@
+export const CLI_NAME = 'revo';
+export const CLI_ALIAS = 'revoengine';
+export const CLI_PACKAGE = '@revoengine/cli';
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    red: '\u001b[31m',
+    green: '\u001b[32m',
+    blue: '\u001b[34m',
+    cyan: '\u001b[36m',
+    magenta: '\u001b[35m',
+    yellow: '\u001b[33m',
+};
+function supportsColor() {
+    return Boolean(process.stdout.isTTY || process.env.FORCE_COLOR);
+}
+function paint(text, code) {
+    return supportsColor() ? `${code}${text}${ANSI.reset}` : text;
+}
+function paintHeader(text) {
+    return paint(text, ANSI.bold + ANSI.magenta);
+}
+function paintMuted(text) {
+    return paint(text, ANSI.dim + ANSI.yellow);
+}
+function paintWarning(text) {
+    return paint(text, ANSI.bold + ANSI.red);
+}
+function paintStatus(status) {
+    if (status === 'authenticated') {
+        return paint('Authenticated', ANSI.bold + ANSI.green);
+    }
+    if (status === 'not_authenticated') {
+        return paint('Not authenticated', ANSI.bold + ANSI.red);
+    }
+    return paint('Unable to validate', ANSI.bold + ANSI.yellow);
+}
+function abbreviateEmail(email) {
+    const match = email.match(/^([^@]+)@([0-9a-f]{4})[0-9a-f-]*([0-9a-f]{3})(\.sa\.revoengine\.com)$/i);
+    if (!match) {
+        return email;
+    }
+    return `${match[1]}@${match[2]}...${match[3]}${match[4]}`;
+}
+function formatStatusValue(auth) {
+    if (auth.status === 'authenticated' && auth.email) {
+        return `${paintStatus(auth.status)}. ${paintMuted(`(${abbreviateEmail(auth.email)})`)}`;
+    }
+    if (auth.status !== 'authenticated' && auth.validation && auth.validation !== 'skipped') {
+        return `${paintStatus(auth.status)}. ${paintMuted(`(${auth.validation})`)}`;
+    }
+    return paintStatus(auth.status);
+}
+function shouldRenderValidationRow(auth) {
+    return false;
+}
+function row(label, value) {
+    return `  ${paint(label.padEnd(14), ANSI.bold + ANSI.blue)} ${value}`;
+}
+function formatCommand(command) {
+    return command
+        .split(/(\s+)/)
+        .map((part) => {
+        if (!part.trim()) {
+            return part;
+        }
+        if (part === CLI_NAME || part === CLI_ALIAS) {
+            return paint(part, ANSI.bold + ANSI.cyan);
+        }
+        if (part.startsWith('<') && part.endsWith('>')) {
+            return paint(part, ANSI.yellow);
+        }
+        if (part.startsWith('--') || /^-\w/.test(part)) {
+            return paint(part, ANSI.magenta);
+        }
+        if (part.startsWith('[') && part.endsWith(']')) {
+            return paint(part, ANSI.dim + ANSI.yellow);
+        }
+        return paint(part, ANSI.blue);
+    })
+        .join('');
+}
+function commandRow(command, description) {
+    const padding = ' '.repeat(Math.max(2, 34 - command.length));
+    return `  ${formatCommand(command)}${padding}${paintMuted(description)}`;
+}
+function noteRow(text) {
+    return `  ${paintMuted(text)}`;
+}
+function renderCommandCatalog() {
+    return [
+        paintHeader('Usage'),
+        `  ${formatCommand(`${CLI_NAME} <command> [arguments] [options]`)}`,
+        '',
+        paintHeader('Global Options'),
+        commandRow('--url <url>', 'Override API base URL for TEST, prod, local, or dedicated tenants'),
+        commandRow('--instance <uuid>', 'Override instance ID'),
+        commandRow('--token <apiKey>', 'Override API key for non-interactive runs'),
+        '',
+        paintHeader('Core'),
+        commandRow('revo -i', 'Show runtime info, config path, and auth state'),
+        commandRow('revo auth login', 'Paste API key and instance ID in the terminal'),
+        commandRow('revo auth status', 'Show the current authentication status'),
+        commandRow('revo auth logout', 'Remove stored credentials'),
+        commandRow('revo project [path]', 'Initialize ambient editor types for JS and TS'),
+        commandRow('revo project switch <instanceId>', 'Switch the current project to another stored instance'),
+        commandRow('revo endpoints', 'List available API endpoints'),
+        '',
+        paintHeader('Components'),
+        commandRow('revo component pull <componentId...> [--force] [--stale]', 'Pull one or more components safely'),
+        commandRow('revo component pull --all [--force] [--stale]', 'Pull every available component with confirmation'),
+        commandRow('revo component push <componentId...>', 'Push one or more local components'),
+        commandRow('revo component push --all [--force]', 'Push every local component.json with confirmation'),
+        commandRow('revo component debug <componentId> [BODY]', 'Debug one local component against sandbox'),
+        '',
+        paintHeader('Low-Level'),
+        commandRow('revo search <CODE|SIMPLE> <term>', 'Search code references or all platform content'),
+        commandRow('revo request <METHOD> <PATH> [BODY]', 'Make a raw API request with optional JSON body'),
+    ].join('\n');
+}
+export function renderBanner(version) {
+    const revo = paint('revo', ANSI.dim + ANSI.cyan);
+    const engine = paint('engine', ANSI.bold + ANSI.blue);
+    const accent = paint('CLI for the RevoEngine Platform', ANSI.dim + ANSI.magenta);
+    return [
+        `      ${revo} ${engine}`,
+        `  ${accent}`,
+        `${paint(CLI_PACKAGE, ANSI.bold)} ${paint(`v${version}`, ANSI.yellow)}`,
+        row('Primary', CLI_NAME),
+        row('Alias', CLI_ALIAS),
+        row('Website', 'https://revoengine.com'),
+    ].join('\n');
+}
+export function renderHelp(version) {
+    return [
+        renderBanner(version),
+        '',
+        renderCommandCatalog(),
+    ].join('\n');
+}
+export function renderRuntimeInfo(input) {
+    const { auth, configDir, nodeVersion, packageVersion, runtime } = input;
+    const onboardingWarning = auth.status === 'not_authenticated'
+        ? paintWarning(`Warning: Start onboarding with ${CLI_ALIAS} auth login`)
+        : '';
+    return [
+        renderBanner(packageVersion),
+        ...(onboardingWarning ? ['', onboardingWarning] : []),
+        '',
+        paintHeader('Runtime'),
+        row('Node', nodeVersion),
+        row('Config', configDir),
+        row('Base URL', runtime.baseUrl),
+        row('Status', formatStatusValue(auth)),
+        row('Instance', runtime.instance || 'missing'),
+        ...(shouldRenderValidationRow(auth) ? [row('Validation', auth.validation || 'skipped')] : []),
+        '',
+        paintHeader('Tips'),
+        commandRow('revo auth login', 'Save credentials interactively'),
+        commandRow('revo --help', 'Show the command reference'),
+    ].join('\n');
+}
+export function renderAuthStatus(input) {
+    const { auth, configDir, runtime } = input;
+    return [
+        paintHeader('Auth Status'),
+        row('Status', formatStatusValue(auth)),
+        row('Config', configDir),
+        row('Base URL', runtime.baseUrl),
+        row('Instance', runtime.instance || 'missing'),
+        row('API key', runtime.token ? 'configured' : 'missing'),
+        ...(shouldRenderValidationRow(auth) ? [row('Validation', auth.validation || 'skipped')] : []),
+    ].join('\n');
+}
+export function renderOverview(input) {
+    return [
+        renderRuntimeInfo(input),
+        '',
+        renderCommandCatalog(),
+    ].join('\n');
+}

package/dist/src/utils.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedArgs } from './types.ts';
+export declare function readFlag(args: ParsedArgs, names: string[]): string;
+export declare function readBoolFlag(args: ParsedArgs, names: string[]): boolean;
+export declare function readValues(args: ParsedArgs, names: string[]): string[];
+export declare function toArray(value: string | string[] | undefined): string[];
+export declare function sanitizeSegment(value: string): string;
+export declare function readJsonFile(filePath: string): any;
+export declare function writeJsonFile(filePath: string, data: unknown): void;
+export declare function deepClone<T>(value: T): T;
+export declare function readPackageVersion(): string;

package/dist/src/utils.js

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function readFlag(args, names) {
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (Array.isArray(value) && value.length > 0) {
+            return value[0];
+        }
+    }
+    return '';
+}
+export function readBoolFlag(args, names) {
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'string') {
+            return value !== 'false';
+        }
+    }
+    return false;
+}
+export function readValues(args, names) {
+    const values = [];
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === 'string') {
+            values.push(value);
+        }
+        else if (Array.isArray(value)) {
+            values.push(...value);
+        }
+    }
+    return values;
+}
+export function toArray(value) {
+    if (!value) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+export function sanitizeSegment(value) {
+    const normalized = value
+        .trim()
+        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_')
+        .replace(/\s+/g, '_');
+    return normalized.length > 0 ? normalized : 'untitled';
+}
+export function readJsonFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw.trim() ? JSON.parse(raw) : {};
+}
+export function writeJsonFile(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch {
+        // Best effort on platforms with limited chmod support.
+    }
+}
+export function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function readPackageVersion() {
+    let currentDir = path.dirname(fileURLToPath(import.meta.url));
+    while (currentDir !== path.dirname(currentDir)) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const raw = fs.readFileSync(packageJsonPath, 'utf8');
+            return JSON.parse(raw).version;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    const raw = fs.readFileSync(packageJsonPath, 'utf8');
+    return JSON.parse(raw).version;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@revoengine/cli",
+  "version": "1.0.0",
+  "description": "CLI package for the RevoEngine Platform API",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "bin": {
+    "revo": "dist/bin/revo.js",
+    "revoengine": "dist/bin/revo.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "node --input-type=module -e \"await import('./src/config.ts'); await import('./src/legacy.ts'); await import('./src/client.ts'); await import('./src/ui.ts'); await import('./src/commands/auth.ts'); await import('./src/commands/component.ts'); await import('./src/commands/endpoints.ts'); await import('./src/commands/info.ts'); await import('./src/commands/request.ts'); await import('./src/commands/search.ts'); await import('./src/cli.ts'); await import('./src/index.ts'); await import('./bin/revo.ts'); await import('./scripts/dev.ts')\"",
+    "dev": "node ./scripts/dev.ts",
+    "prepack": "npm run build",
+    "test": "node --test ./test/*.test.ts"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "tsconfig.json",
+    "tsconfig.build.json"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.3"
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "declaration": true,
+    "noEmit": false,
+    "outDir": "dist",
+    "rootDir": ".",
+    "rewriteRelativeImportExtensions": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "bin/**/*.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": [
+      "node"
+    ],
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "bin/**/*.ts",
+    "scripts/**/*.ts"
+  ]
+}