@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/component-lock.js

@@ -22,6 +22,9 @@ const VOLATILE_COMPONENT_FIELDS = new Set([
     'hash',
     'remoteHash',
 ]);
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 function normalizeValue(value, fallback = null) {
     return value ?? fallback;
 }
@@ -86,6 +89,41 @@ export function normalizePortableComponentSource(component) {
 export function hashPortableComponentSource(component) {
     return hashStable(normalizePortableComponentSource(component));
 }
+export const PORTABLE_COMPONENT_CONFIG_FIELDS = [
+    'name',
+    'category',
+    'desc',
+    'active',
+    'type',
+    'async',
+];
+export function diffPortableComponentSource(source, target) {
+    const sourcePortable = normalizePortableComponentSource(source);
+    const targetPortable = normalizePortableComponentSource(target);
+    const configurationFields = PORTABLE_COMPONENT_CONFIG_FIELDS.filter((field) => sourcePortable[field] !== targetPortable[field]);
+    const elementsChanged = hashStable(sourcePortable.elements) !== hashStable(targetPortable.elements);
+    return {
+        configurationFields,
+        elementsChanged,
+        changedFields: [
+            ...configurationFields,
+            ...(elementsChanged ? ['elements'] : []),
+        ],
+    };
+}
+export function buildPortableComponentUpdatePayload(source, target, changedFields) {
+    if (!Number.isInteger(target.version)) {
+        throw new Error('target component version is required to update component configuration');
+    }
+    const sourcePortable = normalizePortableComponentSource(source);
+    const payload = { version: target.version };
+    for (const field of PORTABLE_COMPONENT_CONFIG_FIELDS) {
+        if (changedFields.includes(field)) {
+            payload[field] = sourcePortable[field];
+        }
+    }
+    return payload;
+}
 export function getLockPath(projectRoot) {
     return path.join(projectRoot, REVO_LOCK_FILE);
 }
@@ -96,6 +134,14 @@ export function readComponentLock(projectRoot) {
             schemaVersion: 2,
             componentIdentity: COMPONENT_IDENTITY_BY_ID,
             components: {},
+            groups: {},
+            roleGroups: {},
+            jobTemplates: {},
+            schedules: {},
+            events: {},
+            endpoints: {},
+            databaseSchemas: {},
+            databaseViews: {},
         };
     }
     const raw = readJsonFile(lockPath);
@@ -115,20 +161,207 @@ export function readComponentLock(projectRoot) {
                     : {}),
                 componentId: String(entry.componentId || remoteComponentId),
                 remoteComponentId,
+                ...(entry.environments && typeof entry.environments === 'object'
+                    ? {
+                        environments: Object.fromEntries(Object.entries(entry.environments)
+                            .filter(([, baseline]) => (typeof baseline.remoteComponentId === 'string'
+                            && typeof baseline.remoteHash === 'string'
+                            && typeof baseline.syncedAt === 'string'))
+                            .map(([envName, baseline]) => [envName, {
+                                remoteComponentId: String(baseline.remoteComponentId),
+                                remoteVersion: typeof baseline.remoteVersion === 'number' ? baseline.remoteVersion : null,
+                                remoteHash: String(baseline.remoteHash),
+                                syncedAt: String(baseline.syncedAt),
+                            }])),
+                    }
+                    : {}),
             }];
     }));
     return {
         schemaVersion: 2,
         componentIdentity,
         components,
+        groups: Object.fromEntries(Object.entries(raw.groups && typeof raw.groups === 'object' ? raw.groups : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                ...((isRecord(entry.owner) && entry.owner.type === 'group' && typeof entry.owner.stableKey === 'string')
+                    ? { owner: { type: 'group', stableKey: entry.owner.stableKey } }
+                    : (isRecord(entry.owner) && entry.owner.type === 'manual-user')
+                        ? { owner: { type: 'manual-user' } }
+                        : (isRecord(entry.owner) && entry.owner.type === 'unresolved' && typeof entry.owner.reason === 'string')
+                            ? { owner: { type: 'unresolved', reason: entry.owner.reason } }
+                            : {}),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        roleGroups: Object.fromEntries(Object.entries(raw.roleGroups && typeof raw.roleGroups === 'object' ? raw.roleGroups : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        jobTemplates: Object.fromEntries(Object.entries(raw.jobTemplates && typeof raw.jobTemplates === 'object' ? raw.jobTemplates : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                ...((isRecord(entry.migration) && (entry.migration.componentBinding === 'pinned-unsupported'
+                    || entry.migration.executionPrincipal === 'excluded')) ? {
+                    migration: {
+                        ...(entry.migration.componentBinding === 'pinned-unsupported' ? { componentBinding: 'pinned-unsupported' } : {}),
+                        ...(entry.migration.executionPrincipal === 'excluded' ? { executionPrincipal: 'excluded' } : {}),
+                    },
+                } : {}),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        schedules: Object.fromEntries(Object.entries(raw.schedules && typeof raw.schedules === 'object' ? raw.schedules : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        events: Object.fromEntries(Object.entries(raw.events && typeof raw.events === 'object' ? raw.events : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        endpoints: Object.fromEntries(Object.entries(raw.endpoints && typeof raw.endpoints === 'object' ? raw.endpoints : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
+        databaseSchemas: Object.fromEntries(Object.entries(raw.databaseSchemas && typeof raw.databaseSchemas === 'object' ? raw.databaseSchemas : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                ...(typeof entry.sourceRestricted === 'boolean' ? { sourceRestricted: entry.sourceRestricted } : {}),
+                ...(typeof entry.parentStableKey === 'string' ? { parentStableKey: entry.parentStableKey } : {}),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        ...(typeof baseline.tombstone?.deletedAt === 'string' && typeof baseline.tombstone.parentStableKey === 'string'
+                            ? { tombstone: {
+                                    deletedAt: baseline.tombstone.deletedAt,
+                                    parentStableKey: baseline.tombstone.parentStableKey,
+                                } }
+                            : {}),
+                    }])),
+            }])),
+        databaseViews: Object.fromEntries(Object.entries(raw.databaseViews && typeof raw.databaseViews === 'object' ? raw.databaseViews : {})
+            .filter(([, entry]) => (typeof entry.stableKey === 'string'
+            && typeof entry.path === 'string'
+            && typeof entry.sourceHash === 'string'
+            && entry.environments
+            && typeof entry.environments === 'object'))
+            .map(([key, entry]) => [key, {
+                stableKey: String(entry.stableKey),
+                path: String(entry.path),
+                sourceHash: String(entry.sourceHash),
+                environments: Object.fromEntries(Object.entries(entry.environments)
+                    .filter(([, baseline]) => typeof baseline.remoteHash === 'string' && typeof baseline.syncedAt === 'string')
+                    .map(([envName, baseline]) => [envName, {
+                        remoteHash: String(baseline.remoteHash),
+                        syncedAt: String(baseline.syncedAt),
+                    }])),
+            }])),
     };
 }
 export function writeComponentLock(projectRoot, lock) {
     const sortedComponents = Object.fromEntries(Object.entries(lock.components).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedRoleGroups = Object.fromEntries(Object.entries(lock.roleGroups).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedGroups = Object.fromEntries(Object.entries(lock.groups || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedJobTemplates = Object.fromEntries(Object.entries(lock.jobTemplates || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedSchedules = Object.fromEntries(Object.entries(lock.schedules || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedEvents = Object.fromEntries(Object.entries(lock.events || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedEndpoints = Object.fromEntries(Object.entries(lock.endpoints || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedDatabaseSchemas = Object.fromEntries(Object.entries(lock.databaseSchemas || {}).sort(([left], [right]) => left.localeCompare(right)));
+    const sortedDatabaseViews = Object.fromEntries(Object.entries(lock.databaseViews || {}).sort(([left], [right]) => left.localeCompare(right)));
     writeJsonFile(getLockPath(projectRoot), {
         schemaVersion: 2,
         componentIdentity: normalizeComponentIdentityConfig(lock.componentIdentity),
         components: sortedComponents,
+        ...(Object.keys(sortedGroups).length > 0 ? { groups: sortedGroups } : {}),
+        roleGroups: sortedRoleGroups,
+        jobTemplates: sortedJobTemplates,
+        ...(Object.keys(sortedSchedules).length > 0 ? { schedules: sortedSchedules } : {}),
+        ...(Object.keys(sortedEvents).length > 0 ? { events: sortedEvents } : {}),
+        ...(Object.keys(sortedEndpoints).length > 0 ? { endpoints: sortedEndpoints } : {}),
+        ...(Object.keys(sortedDatabaseSchemas).length > 0 ? { databaseSchemas: sortedDatabaseSchemas } : {}),
+        ...(Object.keys(sortedDatabaseViews).length > 0 ? { databaseViews: sortedDatabaseViews } : {}),
     });
 }
 export function componentLockKey(identity, component) {
@@ -137,14 +370,49 @@ export function componentLockKey(identity, component) {
 export function componentLockMatchesIdentity(lock, identity) {
     return sameComponentIdentityConfig(lock.componentIdentity, identity);
 }
-export function getComponentLockEntry(lock, identity, component) {
+export function getComponentLockEntry(lock, identity, component, environmentName) {
     if (!componentLockMatchesIdentity(lock, identity)) {
         return null;
     }
     const key = componentLockKey(identity, component);
-    return key ? lock.components[key] || null : null;
+    const entry = key ? lock.components[key] || null : null;
+    if (!entry || !environmentName) {
+        return entry;
+    }
+    const baseline = entry.environments?.[environmentName];
+    if (!baseline) {
+        return null;
+    }
+    return {
+        ...entry,
+        remoteComponentId: baseline.remoteComponentId,
+        remoteVersion: baseline.remoteVersion,
+        remoteHash: baseline.remoteHash,
+        pulledAt: baseline.syncedAt,
+    };
 }
-export function upsertComponentLockEntry(projectRoot, entry, identity = COMPONENT_IDENTITY_BY_ID) {
+export function getComponentLockEntries(lock, identity, environmentName) {
+    if (!componentLockMatchesIdentity(lock, identity)) {
+        return {};
+    }
+    if (!environmentName) {
+        return lock.components;
+    }
+    return Object.fromEntries(Object.entries(lock.components).flatMap(([key, entry]) => {
+        const baseline = entry.environments?.[environmentName];
+        if (!baseline) {
+            return [];
+        }
+        return [[key, {
+                    ...entry,
+                    remoteComponentId: baseline.remoteComponentId,
+                    remoteVersion: baseline.remoteVersion,
+                    remoteHash: baseline.remoteHash,
+                    pulledAt: baseline.syncedAt,
+                }]];
+    }));
+}
+export function upsertComponentLockEntry(projectRoot, entry, identity = COMPONENT_IDENTITY_BY_ID, environmentName) {
     const normalizedIdentity = normalizeComponentIdentityConfig(identity);
     const lock = readComponentLock(projectRoot);
     if (!componentLockMatchesIdentity(lock, normalizedIdentity)) {
@@ -170,21 +438,42 @@ export function upsertComponentLockEntry(projectRoot, entry, identity = COMPONEN
             : {}),
     };
     const existing = lock.components[key];
+    const storedEntry = environmentName
+        ? {
+            ...normalizedEntry,
+            remoteComponentId: existing?.remoteComponentId || normalizedEntry.remoteComponentId,
+            remoteVersion: existing?.remoteVersion ?? normalizedEntry.remoteVersion,
+            remoteHash: existing?.remoteHash || normalizedEntry.remoteHash,
+            environments: {
+                ...existing?.environments,
+                [environmentName]: {
+                    remoteComponentId: normalizedEntry.remoteComponentId,
+                    remoteVersion: normalizedEntry.remoteVersion,
+                    remoteHash: normalizedEntry.remoteHash,
+                    syncedAt: normalizedEntry.pulledAt,
+                },
+            },
+        }
+        : {
+            ...normalizedEntry,
+            ...(existing?.environments ? { environments: existing.environments } : {}),
+        };
     if (existing
-        && existing.identityMode === normalizedEntry.identityMode
-        && existing.metadataProperty === normalizedEntry.metadataProperty
-        && existing.stableKey === normalizedEntry.stableKey
-        && existing.componentId === normalizedEntry.componentId
-        && existing.remoteComponentId === normalizedEntry.remoteComponentId
-        && existing.componentName === normalizedEntry.componentName
-        && existing.category === normalizedEntry.category
-        && existing.path === normalizedEntry.path
-        && existing.remoteVersion === normalizedEntry.remoteVersion
-        && existing.remoteHash === normalizedEntry.remoteHash
-        && existing.sourceHash === normalizedEntry.sourceHash) {
+        && existing.identityMode === storedEntry.identityMode
+        && existing.metadataProperty === storedEntry.metadataProperty
+        && existing.stableKey === storedEntry.stableKey
+        && existing.componentId === storedEntry.componentId
+        && existing.remoteComponentId === storedEntry.remoteComponentId
+        && existing.componentName === storedEntry.componentName
+        && existing.category === storedEntry.category
+        && existing.path === storedEntry.path
+        && existing.remoteVersion === storedEntry.remoteVersion
+        && existing.remoteHash === storedEntry.remoteHash
+        && existing.sourceHash === storedEntry.sourceHash
+        && JSON.stringify(existing.environments || {}) === JSON.stringify(storedEntry.environments || {})) {
         return;
     }
     lock.componentIdentity = normalizedIdentity;
-    lock.components[key] = normalizedEntry;
+    lock.components[key] = storedEntry;
     writeComponentLock(projectRoot, lock);
 }

package/dist/src/config.d.ts

@@ -4,6 +4,7 @@ export type RuntimeConfig = {
     baseUrl: string;
     instance: string;
     token: string;
+    production?: true;
 };
 export type RuntimeConfigOptions = {
     baseUrl?: string;
@@ -15,10 +16,12 @@ export type StoredEnvironmentProfile = {
     baseUrl: string;
     token: string;
     instance?: string;
+    production?: true;
 };
 type StoredConfig = Omit<RuntimeConfig, 'instance'> & {
     instance?: string;
     environments?: Record<string, StoredEnvironmentProfile>;
+    activeEnvironment?: string;
 };
 export type AuthValidationState = {
     key: string;
@@ -54,14 +57,19 @@ export declare function loadStoredConfig(options?: {
 }): StoredConfig;
 export declare function listEnvironmentProfiles(): Record<string, StoredEnvironmentProfile>;
 export declare function getEnvironmentProfile(name: string): StoredEnvironmentProfile | null;
-export declare function saveEnvironmentProfile(name: string, profile: StoredEnvironmentProfile): void;
+export declare const DEFAULT_ENV_NAME = "default";
+export declare function getActiveEnvironmentName(): string;
+export declare function setActiveEnvironmentName(name: string): void;
+export declare function saveEnvironmentProfile(name: string, profile: StoredEnvironmentProfile, options?: {
+    activate?: boolean;
+}): void;
 export declare function removeEnvironmentProfile(name: string): boolean;
 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 const DEFAULT_ENV_NAME = "default";
 export declare function resolveRuntimeConfig(options?: RuntimeConfigOptions): {
+    production?: true | undefined;
     baseUrl: string;
     instance: string;
     token: string;

package/dist/src/config.js

@@ -75,11 +75,13 @@ export function saveStoredConfig(nextConfig) {
     const current = readStoredConfigFile();
     const instance = nextConfig.instance || current.instance || '';
     const environments = nextConfig.environments ?? current.environments;
+    const activeEnvironment = nextConfig.activeEnvironment ?? current.activeEnvironment;
     const config = {
         baseUrl: nextConfig.baseUrl || current.baseUrl || DEFAULT_BASE_URL,
         token: nextConfig.token || current.token || '',
         ...(instance ? { instance } : {}),
         ...(environments && Object.keys(environments).length > 0 ? { environments } : {}),
+        ...(activeEnvironment && activeEnvironment !== DEFAULT_ENV_NAME ? { activeEnvironment } : {}),
     };
     writeJsonFile(configFile, config);
     removeFileIfExists(credentialsFile);
@@ -88,13 +90,15 @@ export function clearStoredConfig() {
     const { dir, configFile, credentialsFile, authStateFile } = getConfigPaths();
     // Logout clears the default login but must not destroy named environment
     // profiles stored alongside it.
-    const environments = readStoredConfigFile().environments;
+    const stored = readStoredConfigFile();
+    const environments = stored.environments;
     if (environments && Object.keys(environments).length > 0) {
         ensureDirectory(dir);
         writeJsonFile(configFile, {
             baseUrl: DEFAULT_BASE_URL,
             token: '',
             environments,
+            ...(stored.activeEnvironment ? { activeEnvironment: stored.activeEnvironment } : {}),
         });
         for (const filePath of [credentialsFile, authStateFile]) {
             try {
@@ -181,6 +185,7 @@ function parseEnvironmentProfiles(value) {
             baseUrl: entry.baseUrl,
             token: entry.token,
             ...(typeof entry.instance === 'string' && isUuid(entry.instance) ? { instance: entry.instance } : {}),
+            ...(entry.production === true ? { production: true } : {}),
         };
     }
     return Object.keys(environments).length > 0 ? environments : null;
@@ -195,6 +200,11 @@ function parseFlatConfig(raw, credentials) {
             ? credentials.token
             : '';
     const environments = parseEnvironmentProfiles(raw.environments);
+    const activeEnvironment = typeof raw.activeEnvironment === 'string'
+        && raw.activeEnvironment !== DEFAULT_ENV_NAME
+        && environments?.[raw.activeEnvironment]
+        ? raw.activeEnvironment
+        : undefined;
     return {
         baseUrl: typeof raw.baseUrl === 'string'
             ? raw.baseUrl
@@ -203,6 +213,7 @@ function parseFlatConfig(raw, credentials) {
                 : DEFAULT_BASE_URL,
         ...(typeof raw.instance === 'string' && isUuid(raw.instance) ? { instance: raw.instance } : {}),
         ...(environments ? { environments } : {}),
+        ...(activeEnvironment ? { activeEnvironment } : {}),
         token,
     };
 }
@@ -225,6 +236,11 @@ function parseMappedConfig(raw) {
         ? configuredDefault
         : Object.keys(instances)[0] || '';
     const environments = parseEnvironmentProfiles(raw.environments);
+    const activeEnvironment = typeof raw.activeEnvironment === 'string'
+        && raw.activeEnvironment !== DEFAULT_ENV_NAME
+        && environments?.[raw.activeEnvironment]
+        ? raw.activeEnvironment
+        : undefined;
     const selected = defaultInstance ? instances[defaultInstance] : undefined;
     const base = selected
         ? {
@@ -233,7 +249,11 @@ function parseMappedConfig(raw) {
             token: selected.token,
         }
         : emptyStoredConfigFile();
-    return environments ? { ...base, environments } : base;
+    return {
+        ...base,
+        ...(environments ? { environments } : {}),
+        ...(activeEnvironment ? { activeEnvironment } : {}),
+    };
 }
 function parseLegacyConfig(config, credentials) {
     const baseUrl = isRecord(config) && typeof config.baseUrl === 'string'
@@ -319,9 +339,19 @@ export function listEnvironmentProfiles() {
 export function getEnvironmentProfile(name) {
     return listEnvironmentProfiles()[name] || null;
 }
-export function saveEnvironmentProfile(name, profile) {
+export const DEFAULT_ENV_NAME = 'default';
+export function getActiveEnvironmentName() {
+    return readStoredConfigFile().activeEnvironment || DEFAULT_ENV_NAME;
+}
+export function setActiveEnvironmentName(name) {
+    if (name !== DEFAULT_ENV_NAME && !getEnvironmentProfile(name)) {
+        throw new Error(`Unknown project "${name}". Run 'revo projects list' to see saved projects.`);
+    }
+    saveStoredConfig({ activeEnvironment: name });
+}
+export function saveEnvironmentProfile(name, profile, options = {}) {
     const environments = { ...listEnvironmentProfiles(), [name]: profile };
-    saveStoredConfig({ environments });
+    saveStoredConfig({ environments, ...(options.activate ? { activeEnvironment: name } : {}) });
 }
 export function removeEnvironmentProfile(name) {
     const environments = listEnvironmentProfiles();
@@ -329,7 +359,10 @@ export function removeEnvironmentProfile(name) {
         return false;
     }
     delete environments[name];
-    saveStoredConfig({ environments });
+    saveStoredConfig({
+        environments,
+        ...(getActiveEnvironmentName() === name ? { activeEnvironment: DEFAULT_ENV_NAME } : {}),
+    });
     return true;
 }
 export function buildAuthValidationKey(runtime) {
@@ -422,31 +455,33 @@ export function clearAuthValidationState(key) {
         }
     }
 }
-export const DEFAULT_ENV_NAME = 'default';
 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 stored = loadStoredConfig();
+    const stored = readStoredConfigFile();
     // A named profile is an explicit selection and resolves exclusively: no
     // fallback to env vars or the stored default, or --from/--to could silently
     // mix one environment's URL with another environment's token or instance.
-    if (options.envName && options.envName !== DEFAULT_ENV_NAME) {
-        const profile = getEnvironmentProfile(options.envName);
+    const envName = options.envName || stored.activeEnvironment || DEFAULT_ENV_NAME;
+    if (envName !== DEFAULT_ENV_NAME) {
+        const profile = stored.environments?.[envName];
         if (!profile) {
-            throw new Error(`Unknown environment "${options.envName}". Run 'revo env list' to see saved environments.`);
+            throw new Error(`Unknown project "${envName}". Run 'revo projects list' to see saved projects.`);
         }
         return {
             baseUrl: options.baseUrl || profile.baseUrl || DEFAULT_BASE_URL,
-            instance: options.instance || profile.instance || '',
+            instance: options.instance ?? (profile.instance || ''),
             token: options.token || profile.token || '',
+            ...(profile.production ? { production: true } : {}),
         };
     }
+    const defaultStored = mergeWithLegacy(stored);
     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 || '',
+        baseUrl: options.baseUrl || env.baseUrl || defaultStored.baseUrl || DEFAULT_BASE_URL,
+        instance: options.instance ?? (env.instance || defaultStored.instance || ''),
+        token: options.token || env.token || defaultStored.token || '',
     };
 }

package/dist/src/database-schema-artifacts.d.ts

@@ -0,0 +1,7 @@
+export declare const DATABASE_BACKUP_CATEGORY = "Database Backup";
+export declare function isDatabaseBackupArtifact(value: {
+    category?: unknown;
+}): boolean;
+export declare function excludeDatabaseBackupArtifacts<T extends {
+    category?: unknown;
+}>(records: readonly T[]): T[];

package/dist/src/database-schema-artifacts.js

@@ -0,0 +1,8 @@
+export const DATABASE_BACKUP_CATEGORY = 'Database Backup';
+export function isDatabaseBackupArtifact(value) {
+    return typeof value.category === 'string'
+        && value.category.trim() === DATABASE_BACKUP_CATEGORY;
+}
+export function excludeDatabaseBackupArtifacts(records) {
+    return records.filter((record) => !isDatabaseBackupArtifact(record));
+}

package/dist/src/env-sync.d.ts

@@ -69,8 +69,6 @@ export declare function buildStableKey(component: ComponentRecord, stableKeyName
 export declare function captureEnvSnapshot(client: RevoClient, envName: string, options?: {
     stableKeyName?: string;
 }): Promise<EnvSnapshot>;
-declare const PORTABLE_METADATA_FIELDS: readonly ["name", "category", "desc", "active", "type", "async"];
-export type PortableMetadataField = (typeof PORTABLE_METADATA_FIELDS)[number];
 export declare function buildEnvSyncPlan(source: EnvSnapshot, target: EnvSnapshot, options: {
     prune: boolean;
     scope?: EnvSyncScope;
@@ -83,4 +81,3 @@ export declare function applyEnvSyncPlan(input: {
     stableKeyName?: string;
     onItem?: (result: EnvApplyItemResult) => void;
 }): Promise<EnvApplyItemResult[]>;
-export {};