@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/commands/database-schemas.js

@@ -0,0 +1,188 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { buildDatabaseSchemasPlan, pullDatabaseSchemasToWorkspace, pushDatabaseSchemas } from "../resource-syncs/database-schema-sync.js";
+import { printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+function formatPlanChangeValue(value) {
+    if (value === undefined) {
+        return '(absent)';
+    }
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? String(value) : serialized;
+}
+export async function handleDatabaseSchemasCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (subcommand !== 'pull' && subcommand !== 'plan' && subcommand !== 'push') {
+        throw new Error('Unknown database-schemas command. Usage: revo database-schemas <pull|plan|push> --all --project <name>');
+    }
+    const selectedStableKey = context.args._[2];
+    const all = readBoolFlag(context.args, ['all', 'a']);
+    const skipPartitions = readBoolFlag(context.args, ['skip-partitions']);
+    const pruneOrphans = readBoolFlag(context.args, ['prune-orphans']);
+    if (subcommand !== 'push' && !all) {
+        throw new Error(`Database Schema ${subcommand} currently requires --all.`);
+    }
+    if (subcommand === 'push' && all === Boolean(selectedStableKey)) {
+        throw new Error('Database Schema push requires exactly one selector: <stableKey> or --all.');
+    }
+    if (skipPartitions && subcommand !== 'plan') {
+        throw new Error('Database Schema --skip-partitions is supported only by plan.');
+    }
+    if (pruneOrphans && subcommand === 'plan') {
+        throw new Error('Database Schema --prune-orphans is supported only by pull or push.');
+    }
+    if (pruneOrphans && (!readBoolFlag(context.args, ['yes', 'y']) || !readBoolFlag(context.args, ['force', 'f']))) {
+        throw new Error(`Database Schema ${subcommand} --prune-orphans requires --yes --force.`);
+    }
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    if (envName === DEFAULT_ENV_NAME) {
+        throw new Error(`Database Schema ${subcommand} requires a named environment profile; "default" is not supported.`);
+    }
+    const client = new RevoClient({ envName });
+    if (subcommand === 'push') {
+        const confirmed = readBoolFlag(context.args, ['yes', 'y']);
+        if (!confirmed) {
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push Database Schemas to "${envName}"?`, false)) {
+                throw new Error('Database Schema push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const result = await pushDatabaseSchemas({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            ...(selectedStableKey ? { stableKey: selectedStableKey } : {}),
+            force: readBoolFlag(context.args, ['force', 'f']),
+            prunePartitions: readBoolFlag(context.args, ['prune-partitions']),
+            prunePartitionsConfirmed: confirmed,
+            pruneOrphans,
+            pruneOrphansConfirmed: confirmed,
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(result);
+        }
+        else {
+            for (const item of result.results) {
+                const label = item.status === 'deployed'
+                    ? 'Deployed'
+                    : item.status === 'failed'
+                        ? 'Failed'
+                        : item.status === 'write-unverified'
+                            ? 'Unverified'
+                            : 'Skipped';
+                printSyncStatus(context.println, {
+                    status: label,
+                    direction: 'push',
+                    targetPath: item.targetPath,
+                    reason: item.error || item.reason,
+                });
+            }
+            printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+        }
+        const failed = result.results.filter((item) => item.status === 'failed');
+        const unverifiedWrites = result.results.filter((item) => item.status === 'write-unverified');
+        if (failed.length > 0 || unverifiedWrites.length > 0) {
+            const outcomes = [
+                ...(failed.length > 0 ? [`${failed.length} failure(s)`] : []),
+                ...(unverifiedWrites.length > 0 ? [`${unverifiedWrites.length} unverified write(s)`] : []),
+            ];
+            throw new Error(`Database Schema push finished with ${outcomes.join(', ')}.`);
+        }
+        return;
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildDatabaseSchemasPlan({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            withStats: readBoolFlag(context.args, ['with-stats']),
+            skipPartitions,
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(plan);
+        }
+        else {
+            printSyncPlan(context.println, {
+                title: 'Database Schema',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items.map((item) => ({
+                    ...item,
+                    details: [
+                        ...(item.changes?.length
+                            ? [{
+                                    label: 'changes',
+                                    values: item.changes.map((change) => (`${change.field} (${change.risk}): ${formatPlanChangeValue(change.before)} -> ${formatPlanChangeValue(change.after)}`)),
+                                }]
+                            : []),
+                        ...(item.hints.length ? [{ label: 'hints', values: item.hints }] : []),
+                        ...(item.stats
+                            ? [{
+                                    label: 'size',
+                                    values: `total=${item.stats.total}B table=${item.stats.table}B indexes=${item.stats.indexes}B audit=${item.stats.audit}B`,
+                                }]
+                            : []),
+                    ],
+                })),
+                warnings: plan.warnings,
+                blockers: plan.blockers,
+            });
+        }
+        if (readBoolFlag(context.args, ['strict'])) {
+            const converged = new Set(['clean', 'reconciled', 'orphan-root', 'orphan-partition']);
+            const drift = plan.items.filter((item) => !converged.has(item.status));
+            if (plan.blockers.length > 0 || drift.length > 0) {
+                throw new Error(`Database Schema strict plan is not converged: ${drift.length} drift or incomplete item(s), ${plan.blockers.length} blocker(s).`);
+            }
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullDatabaseSchemasToWorkspace({
+        client,
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+        strict: readBoolFlag(context.args, ['strict']),
+        pruneOrphans,
+    });
+    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 pruned of result.pruned) {
+        printSyncStatus(context.println, {
+            status: 'Pruned',
+            direction: 'pull',
+            targetPath: pruned.targetPath,
+            reason: `source resource ${pruned.stableKey} is absent`,
+        });
+        output.push({ status: 'pruned', targetPath: pruned.targetPath });
+    }
+    for (const skipped of result.skipped) {
+        printSyncStatus(context.println, {
+            status: 'Skipped', direction: 'pull', targetPath: skipped.targetPath, reason: skipped.reason,
+        });
+        output.push({ status: 'skipped', targetPath: skipped.targetPath, reason: skipped.reason });
+    }
+    const auditEnabled = result.diagnostics.filter((item) => item.audit === true).length;
+    const restricted = result.diagnostics.filter((item) => (item.acl && typeof item.acl === 'object' && item.acl.restricted === true)).length;
+    const tagged = result.diagnostics.filter((item) => Array.isArray(item.tags) && item.tags.length > 0).length;
+    if (auditEnabled > 0 || restricted > 0 || tagged > 0) {
+        context.println(`Diagnostics (target-local, excluded from portable hash): ${auditEnabled} audit-enabled, ${restricted} restricted, ${tagged} tagged.`);
+    }
+    printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+}

package/dist/src/commands/database-views.d.ts

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

package/dist/src/commands/database-views.js

@@ -0,0 +1,123 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { buildDatabaseViewsPlan, pullDatabaseViewsToWorkspace, pushDatabaseViews } from "../resource-syncs/database-view-sync.js";
+import { printSyncNotice, printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+export async function handleDatabaseViewsCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (subcommand !== 'pull' && subcommand !== 'plan' && subcommand !== 'push') {
+        throw new Error('Unknown database-views command. Usage: revo database-views <pull|plan|push> --all --project <name>');
+    }
+    const selectedStableKey = context.args._[2];
+    const all = readBoolFlag(context.args, ['all', 'a']);
+    if (subcommand !== 'push' && !all) {
+        throw new Error(`Database View ${subcommand} currently requires --all.`);
+    }
+    if (subcommand === 'push' && all === Boolean(selectedStableKey)) {
+        throw new Error('Database View push requires exactly one selector: <stableKey> or --all.');
+    }
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    if (envName === DEFAULT_ENV_NAME) {
+        throw new Error(`Database View ${subcommand} requires a named environment profile; "default" is not supported.`);
+    }
+    const client = new RevoClient({ envName });
+    if (subcommand === 'push') {
+        const confirmed = readBoolFlag(context.args, ['yes', 'y']);
+        if (!confirmed) {
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push Database Views to "${envName}"?`, false)) {
+                throw new Error('Database View push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const result = await pushDatabaseViews({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            ...(selectedStableKey ? { stableKey: selectedStableKey } : {}),
+            force: readBoolFlag(context.args, ['force', 'f']),
+            allowMaterializedWrites: readBoolFlag(context.args, ['allow-materialized']),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(result);
+        }
+        else {
+            for (const item of result.results) {
+                printSyncStatus(context.println, {
+                    status: item.status === 'deployed' ? 'Deployed' : item.status === 'write-unverified' ? 'Unverified' : item.status === 'failed' ? 'Failed' : 'Skipped',
+                    direction: 'push',
+                    targetPath: item.targetPath,
+                    reason: item.error || item.reason,
+                });
+            }
+            printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+            const skipped = result.results.filter((item) => item.status === 'skipped');
+            if (skipped.length > 0) {
+                printSyncNotice(context.println, `${skipped.length} Database View resource(s) were skipped; review plan warnings before retrying.`);
+            }
+        }
+        const failed = result.results.filter((item) => item.status === 'failed' || item.status === 'write-unverified');
+        if (failed.length > 0 || result.plan.globalBlockers.length > 0) {
+            const reasons = failed.map((item) => item.error || item.reason || item.stableKey).join('; ');
+            const blockers = result.plan.globalBlockers.join('; ');
+            throw new Error(`Database View push finished with ${failed.length} failed or unverified write(s) and ${result.plan.globalBlockers.length} global blocker(s): ${[reasons, blockers].filter(Boolean).join('; ')}`);
+        }
+        return;
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildDatabaseViewsPlan({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(plan);
+        }
+        else {
+            printSyncPlan(context.println, {
+                title: 'Database View',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items,
+                warnings: [...plan.exclusions, ...plan.warnings],
+                blockers: plan.blockers,
+            });
+        }
+        if (readBoolFlag(context.args, ['strict'])) {
+            const drift = plan.items.filter((item) => item.status !== 'clean' && item.status !== 'orphan');
+            if (plan.blockers.length > 0 || plan.exclusions.length > 0 || plan.warnings.length > 0 || drift.length > 0) {
+                throw new Error(`Database View strict plan is not converged: ${drift.length} drift or incomplete item(s), ${plan.blockers.length} blocker(s), ${plan.warnings.length} warning(s), ${plan.exclusions.length} exclusion(s).`);
+            }
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullDatabaseViewsToWorkspace({
+        client,
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+        strict: readBoolFlag(context.args, ['strict']),
+    });
+    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 skipped of result.skipped) {
+        printSyncNotice(context.println, `${skipped.stableKey || skipped.name}: ${skipped.reason}`);
+        output.push({ status: 'skipped', targetPath: skipped.name, reason: skipped.reason });
+    }
+    printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+}

package/dist/src/commands/endpoints.js

@@ -1,4 +1,118 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { buildEndpointsPlan, pullEndpointsToWorkspace, pushEndpoints } from "../resource-syncs/endpoint-sync.js";
+import { printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
 export async function handleEndpointsCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (subcommand === 'pull' || subcommand === 'plan' || subcommand === 'push') {
+        if (!readBoolFlag(context.args, ['all', 'a'])) {
+            throw new Error('Endpoint 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('Endpoint sync requires a named environment profile; "default" is not supported.');
+        }
+        const client = new RevoClient({ envName });
+        const stableKeyName = readProjectStableKeyName(context.cwd);
+        if (subcommand === 'push') {
+            if (readBoolFlag(context.args, ['prune'])) {
+                throw new Error('Endpoint prune is disabled until a reviewed deletion contract is introduced.');
+            }
+            if (!readBoolFlag(context.args, ['yes', 'y'])) {
+                if (!isInteractiveTerminal() || !await promptConfirm(`Push Endpoints to "${envName}"?`, false)) {
+                    throw new Error('Endpoint push requires confirmation. Re-run with --yes or use an interactive terminal.');
+                }
+            }
+            const startedAt = Date.now();
+            const result = await pushEndpoints({
+                client,
+                cwd: context.cwd,
+                envName,
+                stableKeyName,
+                force: readBoolFlag(context.args, ['force', 'f']),
+            });
+            if (readBoolFlag(context.args, ['json'])) {
+                context.print(result);
+            }
+            else {
+                for (const item of result.results) {
+                    const label = item.status === 'deployed' ? 'Deployed' : item.status === 'failed' ? 'Failed' : 'Skipped';
+                    printSyncStatus(context.println, {
+                        status: label,
+                        direction: 'push',
+                        targetPath: item.targetPath,
+                        reason: item.error || item.reason,
+                    });
+                }
+                printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+            }
+            const failed = result.results.filter((item) => item.status === 'failed');
+            if (failed.length > 0) {
+                throw new Error(`Endpoint push finished with ${failed.length} failure(s).`);
+            }
+            return;
+        }
+        if (subcommand === 'plan') {
+            const plan = await buildEndpointsPlan({ client, cwd: context.cwd, envName, stableKeyName });
+            if (readBoolFlag(context.args, ['json'])) {
+                context.print(plan);
+            }
+            else {
+                printSyncPlan(context.println, {
+                    title: 'Endpoint',
+                    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(`Endpoint strict plan is not converged: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s).`);
+                }
+            }
+            return;
+        }
+        const startedAt = Date.now();
+        const result = await pullEndpointsToWorkspace({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName,
+            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 skipped of result.skipped) {
+            printSyncStatus(context.println, {
+                status: 'Skipped',
+                direction: 'pull',
+                targetPath: skipped.targetPath,
+                reason: skipped.reason,
+            });
+            output.push({ status: 'skipped', targetPath: skipped.targetPath, reason: skipped.reason });
+        }
+        printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+        return;
+    }
+    if (subcommand) {
+        throw new Error('Unknown endpoints command. Usage: revo endpoints [pull|plan|push] --all --project <name>');
+    }
     const endpoints = await context.client.listEndpoints();
     context.print(endpoints);
 }

package/dist/src/commands/env.js

@@ -1,13 +1,13 @@
 import { RevoClient } from "../client.js";
-import { DEFAULT_BASE_URL, DEFAULT_ENV_NAME, getConfigDir, getEnvironmentProfile, listEnvironmentProfiles, removeEnvironmentProfile, resolveRuntimeConfig, saveEnvironmentProfile, } from "../config.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, promptText } from "../prompt.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', 'remove', 'diff', 'apply', DEFAULT_ENV_NAME]);
+const RESERVED_ENV_NAMES = new Set(['add', 'list', 'set', 'remove', 'diff', 'apply', DEFAULT_ENV_NAME]);
 const ANSI = {
     reset: '\u001b[0m',
     bold: '\u001b[1m',
@@ -93,7 +93,7 @@ function requireEnvName(args, flag) {
     return value;
 }
 function buildEnvClient(envName) {
-    return new RevoClient(resolveRuntimeConfig({ envName }));
+    return new RevoClient({ envName });
 }
 function assertDifferentEnvironments(fromName, toName, from, to) {
     if (from.baseUrl === to.baseUrl && from.token === to.token) {
@@ -133,13 +133,13 @@ function buildEmptySnapshots(fromName, toName) {
 }
 function validateProfileName(name) {
     if (!name) {
-        throw new Error('Missing environment name. Usage: revo env add <name>');
+        throw new Error('Missing project name. Usage: revo projects add <name>');
     }
     if (!ENV_NAME_PATTERN.test(name)) {
-        throw new Error('Environment names may only contain letters, digits, dots, underscores, and dashes.');
+        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 an environment.`);
+        throw new Error(`"${name}" is a reserved name and cannot be used for a project.`);
     }
 }
 async function handleEnvAdd(context) {
@@ -147,58 +147,74 @@ async function handleEnvAdd(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 promptText('Paste API key (input is visible)')).trim();
+    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 });
+        const probe = new RevoClient({ baseUrl, token, instance: '', envName: DEFAULT_ENV_NAME });
         await probe.validateSession({ force: true });
         instance = probe.instance;
     }
-    const existed = Boolean(getEnvironmentProfile(name));
+    const production = await promptConfirm('Is this a production project?', existing?.production === true);
+    const existed = Boolean(existing);
     saveEnvironmentProfile(name, {
         baseUrl,
         token,
         ...(instance ? { instance } : {}),
-    });
-    println(`${existed ? 'Updated' : 'Saved'} environment "${name}" in ${getConfigDir()}.`);
+        ...(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 = Object.keys(profiles).sort();
+    const names = [DEFAULT_ENV_NAME, ...Object.keys(profiles).sort()];
+    const active = getActiveEnvironmentName();
     if (readBoolFlag(args, ['json'])) {
-        print(Object.fromEntries(names.map((name) => [name, {
+        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;
     }
-    if (names.length === 0) {
-        println('No environments saved. Run `revo env add <name>` to add one.');
-        return;
-    }
+    const defaultRuntime = resolveRuntimeConfig({ envName: DEFAULT_ENV_NAME });
     for (const name of names) {
-        const profile = profiles[name];
+        const profile = name === DEFAULT_ENV_NAME ? defaultRuntime : profiles[name];
         const instanceSuffix = profile.instance ? ` (instance ${profile.instance})` : '';
-        println(`${paint(name.padEnd(16), ANSI.bold + ANSI.cyan)} ${profile.baseUrl}${instanceSuffix}`);
+        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 environment name. Usage: revo env remove <name>');
+        throw new Error('Missing project name. Usage: revo projects remove <name>');
     }
+    const wasActive = getActiveEnvironmentName() === name;
     if (!removeEnvironmentProfile(name)) {
-        throw new Error(`Unknown environment "${name}". Run 'revo env list' to see saved environments.`);
+        throw new Error(`Unknown project "${name}". Run 'revo projects list' to see saved projects.`);
+    }
+    println(`Removed project "${name}".`);
+    if (wasActive) {
+        println('Active project: default.');
     }
-    println(`Removed environment "${name}".`);
 }
 async function handleEnvDiff(context) {
     const { args, print } = context;
@@ -344,6 +360,10 @@ export async function handleEnvCommand(context) {
         handleEnvList(context);
         return;
     }
+    if (subcommand === 'set') {
+        handleEnvSet(context);
+        return;
+    }
     if (subcommand === 'remove') {
         handleEnvRemove(context);
         return;
@@ -356,5 +376,5 @@ export async function handleEnvCommand(context) {
         await handleEnvApply(context);
         return;
     }
-    throw new Error(`Unknown env command: ${subcommand}. Available: add, list, remove, diff, apply.`);
+    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>;