@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/commands/env.js

@@ -0,0 +1,380 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_BASE_URL, DEFAULT_ENV_NAME, getActiveEnvironmentName, getConfigDir, getEnvironmentProfile, listEnvironmentProfiles, removeEnvironmentProfile, resolveRuntimeConfig, saveEnvironmentProfile, setActiveEnvironmentName, } from "../config.js";
+import { applyEnvSyncPlan, buildEnvSyncPlan, captureEnvSnapshot, } from "../env-sync.js";
+import { isInteractiveTerminal, promptConfirm, promptSecret, promptText } from "../prompt.js";
+import { readProjectStableKeyName, readProjectTrackedResources } from "../project.js";
+import { normalizeStableKeyName } from "../resource-metadata.js";
+import { normalizeTrackedResources, shouldTrackResource } from "../tracked-resources.js";
+import { readBoolFlag, readFlag, readValues } from "../utils.js";
+const ENV_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const RESERVED_ENV_NAMES = new Set(['add', 'list', 'set', 'remove', 'diff', 'apply', DEFAULT_ENV_NAME]);
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    red: '\u001b[31m',
+    magenta: '\u001b[35m',
+    cyan: '\u001b[36m',
+};
+function supportsColor() {
+    return Boolean(process.stdout.isTTY || process.env.FORCE_COLOR);
+}
+function paint(text, code) {
+    return supportsColor() ? `${code}${text}${ANSI.reset}` : text;
+}
+const ACTION_MARKS = {
+    create: { symbol: '+', code: ANSI.bold + ANSI.green },
+    update: { symbol: '~', code: ANSI.bold + ANSI.yellow },
+    delete: { symbol: '-', code: ANSI.bold + ANSI.red },
+    collision: { symbol: '!', code: ANSI.bold + ANSI.magenta },
+    orphan: { symbol: ' ', code: ANSI.dim },
+    noop: { symbol: ' ', code: ANSI.dim },
+};
+function formatUpdateDetail(item) {
+    const parts = [];
+    if (item.changedFields && item.changedFields.length > 0) {
+        parts.push(`fields: ${item.changedFields.join(', ')}`);
+    }
+    const elementParts = [
+        ...(item.changedElementKeys || []).map((key) => `~${key}`),
+        ...(item.addedElementKeys || []).map((key) => `+${key}`),
+        ...(item.removedElementKeys || []).map((key) => `-${key}`),
+    ];
+    if (elementParts.length > 0) {
+        parts.push(`elements ${elementParts.join(' ')}`);
+    }
+    return parts.length > 0 ? ` (${parts.join('; ')})` : '';
+}
+function printPlanText(context, plan) {
+    const { println } = context;
+    println(`Comparing ${paint(plan.from.env, ANSI.bold + ANSI.cyan)} -> ${paint(plan.to.env, ANSI.bold + ANSI.cyan)}`);
+    for (const item of plan.items) {
+        if (item.action === 'noop') {
+            continue;
+        }
+        const mark = ACTION_MARKS[item.action];
+        const detail = item.action === 'update'
+            ? formatUpdateDetail(item)
+            : item.reason
+                ? ` (${item.reason})`
+                : '';
+        const line = `${mark.symbol} ${item.action.padEnd(9)} ${item.resourceType}  ${item.stableKey}${detail}`;
+        println(paint(line, mark.code));
+    }
+    const { counts } = plan;
+    println(`Plan: ${counts.create} to create, ${counts.update} to update, ${counts.delete} to delete, `
+        + `${counts.noop} unchanged, ${counts.orphan} orphaned, ${counts.collision} collisions.`);
+}
+function hasBlockingDrift(plan) {
+    return plan.items.some((item) => item.action !== 'noop');
+}
+function readScope(args) {
+    const keys = readValues(args, ['key']);
+    const categories = readValues(args, ['category']);
+    return keys.length > 0 || categories.length > 0 ? { keys, categories } : undefined;
+}
+function readStableKeyName(context) {
+    return normalizeStableKeyName(readFlag(context.args, ['stable-key-name', 'stableKeyName'])
+        || readProjectStableKeyName(context.cwd));
+}
+function readTrackedResources(context) {
+    const values = readValues(context.args, ['resources', 'resource', 'tracked-resources', 'trackedResources']);
+    return values.length > 0
+        ? normalizeTrackedResources(values)
+        : readProjectTrackedResources(context.cwd);
+}
+function requireEnvName(args, flag) {
+    const value = readFlag(args, [flag]) || '';
+    if (!value) {
+        throw new Error(`Missing --${flag} <env>. Use a saved environment name or "${DEFAULT_ENV_NAME}".`);
+    }
+    return value;
+}
+function buildEnvClient(envName) {
+    return new RevoClient({ envName });
+}
+function assertDifferentEnvironments(fromName, toName, from, to) {
+    if (from.baseUrl === to.baseUrl && from.token === to.token) {
+        throw new Error(`--from ${fromName} and --to ${toName} resolve to the same environment.`);
+    }
+}
+async function captureSnapshots(fromName, toName, stableKeyName) {
+    const fromClient = buildEnvClient(fromName);
+    const toClient = buildEnvClient(toName);
+    assertDifferentEnvironments(fromName, toName, fromClient, toClient);
+    const [source, target] = await Promise.all([
+        captureEnvSnapshot(fromClient, fromName, { stableKeyName }),
+        captureEnvSnapshot(toClient, toName, { stableKeyName }),
+    ]);
+    return { source, target, toClient };
+}
+function emptySnapshot(client, envName) {
+    return {
+        ref: {
+            env: envName,
+            baseUrl: client.baseUrl,
+            instance: client.instance,
+        },
+        components: new Map(),
+        collisions: [],
+    };
+}
+function buildEmptySnapshots(fromName, toName) {
+    const fromClient = buildEnvClient(fromName);
+    const toClient = buildEnvClient(toName);
+    assertDifferentEnvironments(fromName, toName, fromClient, toClient);
+    return {
+        source: emptySnapshot(fromClient, fromName),
+        target: emptySnapshot(toClient, toName),
+        toClient,
+    };
+}
+function validateProfileName(name) {
+    if (!name) {
+        throw new Error('Missing project name. Usage: revo projects add <name>');
+    }
+    if (!ENV_NAME_PATTERN.test(name)) {
+        throw new Error('Project names may only contain letters, digits, dots, underscores, and dashes.');
+    }
+    if (RESERVED_ENV_NAMES.has(name)) {
+        throw new Error(`"${name}" is a reserved name and cannot be used for a project.`);
+    }
+}
+async function handleEnvAdd(context) {
+    const { args, println } = context;
+    const name = args._[2] || '';
+    validateProfileName(name);
+    const offline = readBoolFlag(args, ['offline']);
+    const existing = getEnvironmentProfile(name);
+    const baseUrl = readFlag(args, ['url', 'baseUrl'])
+        || await promptText('RevoEngine API URL', DEFAULT_BASE_URL);
+    const token = (readFlag(args, ['token']) || await promptSecret('Paste API key')).trim();
+    if (!token) {
+        throw new Error('API key is required.');
+    }
+    let instance = '';
+    if (!offline) {
+        const probe = new RevoClient({ baseUrl, token, instance: '', envName: DEFAULT_ENV_NAME });
+        await probe.validateSession({ force: true });
+        instance = probe.instance;
+    }
+    const production = await promptConfirm('Is this a production project?', existing?.production === true);
+    const existed = Boolean(existing);
+    saveEnvironmentProfile(name, {
+        baseUrl,
+        token,
+        ...(instance ? { instance } : {}),
+        ...(production ? { production: true } : {}),
+    }, { activate: true });
+    println(`${existed ? 'Updated' : 'Saved'} project "${name}" in ${getConfigDir()}.`);
+    println(`Active project: ${name}.`);
+}
+function handleEnvList(context) {
+    const { args, print, println } = context;
+    const profiles = listEnvironmentProfiles();
+    const names = [DEFAULT_ENV_NAME, ...Object.keys(profiles).sort()];
+    const active = getActiveEnvironmentName();
+    if (readBoolFlag(args, ['json'])) {
+        print(Object.fromEntries(Object.keys(profiles).sort().map((name) => [name, {
+                baseUrl: profiles[name].baseUrl,
+                instance: profiles[name].instance || null,
+                ...(profiles[name].production ? { production: true } : {}),
+                tokenConfigured: Boolean(profiles[name].token),
+            }])));
+        return;
+    }
+    const defaultRuntime = resolveRuntimeConfig({ envName: DEFAULT_ENV_NAME });
+    for (const name of names) {
+        const profile = name === DEFAULT_ENV_NAME ? defaultRuntime : profiles[name];
+        const instanceSuffix = profile.instance ? ` (instance ${profile.instance})` : '';
+        const productionSuffix = profile.production ? ' [PRODUCTION]' : '';
+        println(`${name === active ? '*' : ' '} ${paint(name.padEnd(16), ANSI.bold + ANSI.cyan)} ${profile.baseUrl}${instanceSuffix}${productionSuffix}`);
+    }
+}
+function handleEnvSet(context) {
+    const name = context.args._[2] || '';
+    if (!name) {
+        throw new Error('Missing project name. Usage: revo projects set <name>');
+    }
+    setActiveEnvironmentName(name);
+    context.println(`Active project: ${name}.`);
+}
+function handleEnvRemove(context) {
+    const { args, println } = context;
+    const name = args._[2] || '';
+    if (!name) {
+        throw new Error('Missing project name. Usage: revo projects remove <name>');
+    }
+    const wasActive = getActiveEnvironmentName() === name;
+    if (!removeEnvironmentProfile(name)) {
+        throw new Error(`Unknown project "${name}". Run 'revo projects list' to see saved projects.`);
+    }
+    println(`Removed project "${name}".`);
+    if (wasActive) {
+        println('Active project: default.');
+    }
+}
+async function handleEnvDiff(context) {
+    const { args, print } = context;
+    const fromName = requireEnvName(args, 'from');
+    const toName = requireEnvName(args, 'to');
+    const prune = readBoolFlag(args, ['prune']);
+    const stableKeyName = readStableKeyName(context);
+    const trackedResources = readTrackedResources(context);
+    const { source, target } = shouldTrackResource(trackedResources, 'component')
+        ? await captureSnapshots(fromName, toName, stableKeyName)
+        : buildEmptySnapshots(fromName, toName);
+    const plan = buildEnvSyncPlan(source, target, { prune, scope: readScope(args) });
+    if (readBoolFlag(args, ['json'])) {
+        print(plan);
+    }
+    else {
+        printPlanText(context, plan);
+    }
+    if (readBoolFlag(args, ['strict']) && hasBlockingDrift(plan)) {
+        throw new Error('Strict mode: environments differ.');
+    }
+}
+async function confirmApply(context, plan, toName) {
+    const { args, println } = context;
+    const yes = readBoolFlag(args, ['yes']);
+    const force = readBoolFlag(args, ['force']);
+    const changeCount = plan.counts.create + plan.counts.update + plan.counts.delete;
+    const deleteCount = plan.counts.delete;
+    if (!isInteractiveTerminal()) {
+        if (!yes) {
+            throw new Error('Apply requires confirmation. Re-run with --yes or use an interactive terminal.');
+        }
+        if (deleteCount > 0 && !force) {
+            throw new Error(`Apply would delete ${deleteCount} component(s) from "${toName}". Re-run with --force to confirm deletes.`);
+        }
+        return true;
+    }
+    if (!yes) {
+        const confirmed = await promptConfirm(`Apply ${changeCount} change(s) to "${toName}"?`, false);
+        if (!confirmed) {
+            println('Apply cancelled.');
+            return false;
+        }
+    }
+    if (deleteCount > 0 && !force) {
+        const confirmed = await promptConfirm(`Also delete ${deleteCount} component(s) from "${toName}"?`, false);
+        if (!confirmed) {
+            println('Apply cancelled: deletes were not confirmed. Re-run without --prune to apply without deletes.');
+            return false;
+        }
+    }
+    return true;
+}
+function formatDuration(durationMs) {
+    if (durationMs < 1_000) {
+        return `${durationMs}ms`;
+    }
+    const seconds = durationMs / 1_000;
+    return seconds < 10 ? `${seconds.toFixed(1)}s` : `${Math.round(seconds)}s`;
+}
+function printApplyResult(context, result) {
+    const { println } = context;
+    const mark = ACTION_MARKS[result.action];
+    if (result.status === 'failed') {
+        println(`${paint('Failed', ANSI.bold + ANSI.red)}    ${result.action.padEnd(9)} ${result.stableKey} (${result.error})`);
+        return;
+    }
+    const verifiedSuffix = result.verified === false ? paint(' (verification mismatch)', ANSI.bold + ANSI.red) : '';
+    println(`${paint('Applied', mark.code)}   ${result.action.padEnd(9)} ${result.stableKey}${verifiedSuffix}`);
+}
+async function handleEnvApply(context) {
+    const { args, print, println } = context;
+    const fromName = requireEnvName(args, 'from');
+    const toName = requireEnvName(args, 'to');
+    const prune = readBoolFlag(args, ['prune']);
+    const dryRun = readBoolFlag(args, ['dry-run', 'dryRun']);
+    const json = readBoolFlag(args, ['json']);
+    const stableKeyName = readStableKeyName(context);
+    const trackedResources = readTrackedResources(context);
+    const { source, target, toClient } = shouldTrackResource(trackedResources, 'component')
+        ? await captureSnapshots(fromName, toName, stableKeyName)
+        : buildEmptySnapshots(fromName, toName);
+    const plan = buildEnvSyncPlan(source, target, { prune, scope: readScope(args) });
+    if (!json) {
+        printPlanText(context, plan);
+    }
+    const changeCount = plan.counts.create + plan.counts.update + plan.counts.delete;
+    if (plan.counts.collision > 0) {
+        throw new Error(`Cannot apply: ${plan.counts.collision} stable-key collision(s) in scope. Resolve duplicates or narrow the scope with --key/--category.`);
+    }
+    if (changeCount === 0) {
+        if (json) {
+            print({ plan, results: [] });
+        }
+        else {
+            println('No changes to apply.');
+        }
+        return;
+    }
+    if (dryRun) {
+        if (json) {
+            print({ plan, results: [] });
+        }
+        else {
+            println('Dry run: no changes applied.');
+        }
+        return;
+    }
+    if (!await confirmApply(context, plan, toName)) {
+        return;
+    }
+    const startedAt = Date.now();
+    const results = await applyEnvSyncPlan({
+        targetClient: toClient,
+        plan,
+        source,
+        target,
+        stableKeyName,
+        onItem: json ? undefined : (result) => printApplyResult(context, result),
+    });
+    const failed = results.filter((result) => result.status === 'failed');
+    const unverified = results.filter((result) => result.verified === false);
+    if (json) {
+        print({ plan, results });
+    }
+    else {
+        println(`Applied ${results.length - failed.length}/${results.length} in ${formatDuration(Date.now() - startedAt)}.`);
+        if (unverified.length > 0) {
+            println(paint(`Warning: ${unverified.length} component(s) did not verify against the source after apply.`, ANSI.bold + ANSI.yellow));
+        }
+    }
+    if (failed.length > 0) {
+        throw new Error(`Apply finished with ${failed.length} failure(s).`);
+    }
+}
+export async function handleEnvCommand(context) {
+    const subcommand = context.args._[1] || 'list';
+    if (subcommand === 'add') {
+        await handleEnvAdd(context);
+        return;
+    }
+    if (subcommand === 'list') {
+        handleEnvList(context);
+        return;
+    }
+    if (subcommand === 'set') {
+        handleEnvSet(context);
+        return;
+    }
+    if (subcommand === 'remove') {
+        handleEnvRemove(context);
+        return;
+    }
+    if (subcommand === 'diff') {
+        await handleEnvDiff(context);
+        return;
+    }
+    if (subcommand === 'apply') {
+        await handleEnvApply(context);
+        return;
+    }
+    throw new Error(`Unknown projects command: ${subcommand}. Available: add, list, set, remove, diff, apply.`);
+}

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

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

package/dist/src/commands/events.js

@@ -0,0 +1,146 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { readProjectStableKeyName } from "../project.js";
+import { activateVerifiedEvents, buildEventsPlan, pullEventsToWorkspace, pushEvents } from "../resource-syncs/event-sync.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { printSyncNotice, printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+export async function handleEventsCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (!['pull', 'plan', 'push'].includes(subcommand)) {
+        throw new Error('Unknown events command. Usage: revo events <pull|plan|push> --all --project <name>');
+    }
+    if (!readBoolFlag(context.args, ['all', 'a'])) {
+        throw new Error('Event sync currently requires --all.');
+    }
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    if (envName === DEFAULT_ENV_NAME) {
+        throw new Error('Event sync requires a named environment profile; "default" is not supported.');
+    }
+    const activate = readBoolFlag(context.args, ['activate']);
+    if (activate && subcommand !== 'push') {
+        throw new Error('--activate is available only with events push.');
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildEventsPlan({
+            client: new RevoClient({ envName }),
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(plan);
+        }
+        else {
+            printSyncPlan(context.println, {
+                title: 'Event',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items,
+                warnings: plan.exclusions,
+                blockers: plan.blockers,
+            });
+        }
+        if (readBoolFlag(context.args, ['strict'])) {
+            const drift = plan.items.filter((item) => !['clean', 'orphan', 'skipped'].includes(item.status));
+            if (plan.blockers.length > 0 || drift.length > 0) {
+                throw new Error(`Event strict plan is not converged: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s).`);
+            }
+        }
+        return;
+    }
+    if (subcommand === 'push') {
+        if (!readBoolFlag(context.args, ['yes', 'y'])) {
+            if (activate && !isInteractiveTerminal()) {
+                throw new Error('Event activation in non-interactive mode requires --yes --activate.');
+            }
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push Events to "${envName}"?`, false)) {
+                throw new Error('Event push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const client = new RevoClient({ envName });
+        const pushed = await pushEvents({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            force: readBoolFlag(context.args, ['force', 'f']),
+        });
+        const results = [...pushed.results];
+        let activation;
+        if (activate) {
+            const candidateCount = pushed.verifiedActivationCandidates.length;
+            const configurationFailures = pushed.results.filter((item) => item.status === 'failed');
+            if (configurationFailures.length > 0) {
+                activation = { candidateCount, results: [], skipped: 'configuration phase has failures' };
+            }
+            else {
+                const confirmed = !isInteractiveTerminal() || await promptConfirm(`Align activation for ${candidateCount} verified Event(s) on "${envName}"?`, false);
+                if (confirmed) {
+                    const activationResults = await activateVerifiedEvents({ client, candidates: pushed.verifiedActivationCandidates });
+                    results.push(...activationResults);
+                    activation = { candidateCount, results: activationResults };
+                }
+                else {
+                    activation = { candidateCount, results: [], skipped: 'activation not confirmed' };
+                }
+            }
+        }
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print({ plan: pushed.plan, results, ...(activation ? { activation } : {}) });
+        }
+        else {
+            for (const item of results) {
+                const label = item.action === 'activate'
+                    ? 'Activated'
+                    : item.action === 'disable'
+                        ? 'Deactivated'
+                        : item.status === 'deployed'
+                            ? 'Deployed'
+                            : item.status === 'failed'
+                                ? 'Failed'
+                                : 'Skipped';
+                printSyncStatus(context.println, {
+                    status: label,
+                    direction: 'push',
+                    targetPath: item.targetPath,
+                    reason: item.error || item.reason,
+                });
+            }
+            if (activation?.skipped) {
+                printSyncNotice(context.println, `${activation.candidateCount} verified Event activation candidate(s): ${activation.skipped}`);
+            }
+            printSyncSummary(context.println, 'Deployed', results, Date.now() - startedAt);
+        }
+        const failed = results.filter((item) => item.status === 'failed');
+        if (failed.length > 0) {
+            throw new Error(`Event push finished with ${failed.length} failure(s).`);
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullEventsToWorkspace({
+        client: new RevoClient({ envName }),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(result);
+        return;
+    }
+    const output = [];
+    for (const pulled of result.pulled) {
+        printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+        output.push({ status: 'pulled', targetPath: pulled.targetPath });
+    }
+    for (const warning of result.warnings) {
+        printSyncNotice(context.println, `${warning.stableKey}: ${warning.reason}`);
+    }
+    printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+}

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

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