@revoengine/cli 1.0.10 → 1.0.11

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>;

package/dist/src/commands/groups.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { RevoClient } from "../client.js";
+import { resolveProjectRoot, readProjectStableKeyName } from "../project.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { buildGroupsPlan, pullGroupsToWorkspace, pushGroups } from "../resource-syncs/group-sync.js";
+import { printSyncNotice, printSyncPlan, printSyncStatus, printSyncSummary, } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+function requireEnvName(context) {
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    return envName;
+}
+function environmentClient(envName) {
+    return new RevoClient({ envName });
+}
+function warnAboutExperimentalState(context) {
+    const projectRoot = resolveProjectRoot(context.cwd) || path.resolve(context.cwd);
+    const legacyPaths = [
+        path.join(projectRoot, '.revoengine', 'resources'),
+        path.join(projectRoot, '.revoengine', 'resources.lock.json'),
+        path.join(projectRoot, '.revoengine', 'plans'),
+    ].filter((candidate) => fs.existsSync(candidate));
+    if (legacyPaths.length === 0) {
+        return;
+    }
+    const warning = `Ignoring experimental ${legacyPaths.map((candidate) => path.relative(projectRoot, candidate)).join(', ')}; groups use workspace/Groups and .revoengine/revo.lock.json.`;
+    if (readBoolFlag(context.args, ['json'])) {
+        (context.warn || context.error)(warning);
+    }
+    else {
+        context.println(warning);
+    }
+}
+async function handlePull(context) {
+    if (!readBoolFlag(context.args, ['all', 'a'])) {
+        throw new Error('Group pull currently requires --all.');
+    }
+    const envName = requireEnvName(context);
+    const startedAt = Date.now();
+    const result = await pullGroupsToWorkspace({
+        client: environmentClient(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 outputResults = [];
+    for (const pulled of result.pulled) {
+        printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+        outputResults.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,
+        });
+        outputResults.push({ status: 'skipped', targetPath: skipped.targetPath, reason: skipped.reason });
+    }
+    for (const notice of result.notices) {
+        printSyncNotice(context.println, `${notice.stableKey}: ${notice.reason}`);
+    }
+    printSyncSummary(context.println, 'Pulled', outputResults, Date.now() - startedAt);
+}
+async function handlePlan(context) {
+    if (!readBoolFlag(context.args, ['all', 'a'])) {
+        throw new Error('Group plan currently requires --all.');
+    }
+    if (readBoolFlag(context.args, ['prune'])) {
+        throw new Error('Group prune is disabled until a reviewed deletion contract is introduced.');
+    }
+    const envName = requireEnvName(context);
+    const plan = await buildGroupsPlan({
+        client: environmentClient(envName),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(plan);
+    }
+    else {
+        printSyncPlan(context.println, {
+            title: 'Group',
+            environment: plan.env,
+            counts: plan.counts,
+            items: plan.items.map((item) => ({
+                ...item,
+                details: item.ownerStableKey
+                    ? [{ label: 'owner', values: item.ownerStableKey }]
+                    : [],
+            })),
+            warnings: plan.warnings,
+            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(`Group plan is not clean: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s).`);
+        }
+    }
+}
+async function handlePush(context) {
+    if (!readBoolFlag(context.args, ['all', 'a'])) {
+        throw new Error('Group push currently requires --all.');
+    }
+    if (readBoolFlag(context.args, ['prune'])) {
+        throw new Error('Group prune is disabled until a reviewed deletion contract is introduced.');
+    }
+    const envName = requireEnvName(context);
+    if (!readBoolFlag(context.args, ['yes', 'y'])) {
+        if (!isInteractiveTerminal() || !await promptConfirm(`Push Groups to "${envName}"?`, false)) {
+            throw new Error('Group push requires confirmation. Re-run with --yes or use an interactive terminal.');
+        }
+    }
+    const startedAt = Date.now();
+    const result = await pushGroups({
+        client: environmentClient(envName),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        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(`Group push finished with ${failed.length} failure(s).`);
+    }
+}
+export async function handleGroupsCommand(context) {
+    warnAboutExperimentalState(context);
+    const subcommand = context.args._[1] || '';
+    if (subcommand === 'pull') {
+        await handlePull(context);
+        return;
+    }
+    if (subcommand === 'plan') {
+        await handlePlan(context);
+        return;
+    }
+    if (subcommand === 'push') {
+        await handlePush(context);
+        return;
+    }
+    throw new Error('Unknown groups command. Usage: revo groups <pull|plan|push> --all --project <name>');
+}

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

@@ -1,9 +1,17 @@
 export * from './auth.ts';
 export * from './component.ts';
+export * from './database-schemas.ts';
+export * from './database-views.ts';
 export * from './endpoints.ts';
 export * from './env.ts';
+export * from './events.ts';
+export * from './groups.ts';
 export * from './info.ts';
+export * from './job-templates.ts';
 export * from './metadata.ts';
 export * from './project.ts';
 export * from './request.ts';
+export * from './role-groups.ts';
 export * from './search.ts';
+export * from './terminal.ts';
+export * from './schedules.ts';

package/dist/src/commands/index.js

@@ -1,9 +1,17 @@
 export * from "./auth.js";
 export * from "./component.js";
+export * from "./database-schemas.js";
+export * from "./database-views.js";
 export * from "./endpoints.js";
 export * from "./env.js";
+export * from "./events.js";
+export * from "./groups.js";
 export * from "./info.js";
+export * from "./job-templates.js";
 export * from "./metadata.js";
 export * from "./project.js";
 export * from "./request.js";
+export * from "./role-groups.js";
 export * from "./search.js";
+export * from "./terminal.js";
+export * from "./schedules.js";

package/dist/src/commands/job-templates.d.ts

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

package/dist/src/commands/job-templates.js

@@ -0,0 +1,101 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { buildJobTemplatesPlan, pullJobTemplatesToWorkspace, pushJobTemplates } from "../resource-syncs/job-template-sync.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { printSyncNotice, printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+export async function handleJobTemplatesCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (!['pull', 'plan', 'push'].includes(subcommand))
+        throw new Error('Unknown job-templates command. Usage: revo job-templates <pull|plan|push> --all --project <name>');
+    if (!readBoolFlag(context.args, ['all', 'a']))
+        throw new Error('Job-template 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('Job-template sync requires a named environment profile; "default" is not supported.');
+    if (subcommand === 'push') {
+        if (!readBoolFlag(context.args, ['yes', 'y'])) {
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push job templates to "${envName}"?`, false)) {
+                throw new Error('Job-template push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const result = await pushJobTemplates({
+            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);
+        }
+        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(`Job-template push finished with ${failed.length} failure(s).`);
+        return;
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildJobTemplatesPlan({
+            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: 'Job-template',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items,
+                warnings: plan.warnings,
+                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(`Job-template strict plan is not converged: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s).`);
+            }
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullJobTemplatesToWorkspace({
+        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/metadata.js

@@ -1,5 +1,5 @@
 import { RevoClient } from "../client.js";
-import { DEFAULT_ENV_NAME, resolveRuntimeConfig } from "../config.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
 import { applyMetadataBackfillPlan, buildMetadataBackfillPlan, } from "../metadata-backfill.js";
 import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
 import { readProjectStableKeyName, readProjectTrackedResources } from "../project.js";
@@ -35,7 +35,7 @@ function readTrackedResources(context) {
         : readProjectTrackedResources(context.cwd);
 }
 function buildEnvClient(envName) {
-    return new RevoClient(resolveRuntimeConfig({ envName }));
+    return new RevoClient({ envName });
 }
 async function buildPlan(context) {
     const envName = readEnvName(context);
@@ -46,18 +46,36 @@ async function buildPlan(context) {
         stableKeyName: readStableKeyName(context),
         trackedResources: readTrackedResources(context),
         force: readBoolFlag(context.args, ['force']),
+        skipPartitions: readBoolFlag(context.args, ['skip-partitions', 'skipPartitions']),
     });
 }
 function printPlanText(context, plan) {
     const { println } = context;
     println(`Metadata backfill ${paint(plan.env, ANSI.bold + ANSI.cyan)} (${plan.stableKeyName})`);
+    if (plan.skipPartitions) {
+        println('Scope: root database schemas only (partitions skipped).');
+    }
     for (const item of plan.items) {
+        const reservedMetadataNotice = item.resourceType === 'group'
+            && item.reason.includes('backend-reserved metadata keys excluded')
+            ? ` (${item.reason})`
+            : '';
         if (item.action === 'skip') {
+            println(`${paint('= assigned', ANSI.dim + ANSI.yellow)} ${item.resourceType} ${item.name} -> ${item.metadataField}.${item.stableKeyName}=${item.stableKey}${reservedMetadataNotice}`);
+            continue;
+        }
+        if (item.action === 'blocked') {
+            println(`${paint('! blocked', ANSI.bold + ANSI.red)} ${item.resourceType} ${item.name} -> ${item.metadataField}.${item.stableKeyName}=${item.stableKey} (${item.reason})`);
             continue;
         }
-        println(`${paint('+ update', ANSI.bold + ANSI.green)} ${item.resourceType} ${item.name} -> ${item.metadataField}.${item.stableKeyName}=${item.stableKey}`);
+        println(`${paint('+ update', ANSI.bold + ANSI.green)} ${item.resourceType} ${item.name} -> ${item.metadataField}.${item.stableKeyName}=${item.stableKey}${reservedMetadataNotice}`);
+    }
+    println(`Plan: ${plan.counts.update} to update, ${plan.counts.skip} already populated, ${plan.counts.blocked} blocked.`);
+}
+function assertNoPlanBlockers(plan) {
+    if (plan.blockers.length > 0) {
+        throw new Error(`Metadata plan has ${plan.blockers.length} blocking validation error(s).`);
     }
-    println(`Plan: ${plan.counts.update} to update, ${plan.counts.skip} already populated.`);
 }
 function printResult(context, result) {
     const { println } = context;
@@ -88,15 +106,18 @@ async function handleMetadataPlan(context) {
     const plan = await buildPlan(context);
     if (readBoolFlag(context.args, ['json'])) {
         context.print(plan);
-        return;
     }
-    printPlanText(context, plan);
+    else {
+        printPlanText(context, plan);
+    }
+    assertNoPlanBlockers(plan);
 }
 async function handleMetadataApply(context) {
     const plan = await buildPlan(context);
     if (!readBoolFlag(context.args, ['json'])) {
         printPlanText(context, plan);
     }
+    assertNoPlanBlockers(plan);
     if (!await confirmApply(context, plan)) {
         if (readBoolFlag(context.args, ['json'])) {
             context.print({ plan, results: [] });
@@ -107,6 +128,7 @@ async function handleMetadataApply(context) {
         return;
     }
     const client = buildEnvClient(plan.env);
+    await client.validateSession();
     const results = await applyMetadataBackfillPlan({ client, plan });
     if (readBoolFlag(context.args, ['json'])) {
         context.print({ plan, results });
@@ -133,5 +155,5 @@ export async function handleMetadataCommand(context) {
         await handleMetadataApply(context);
         return;
     }
-    throw new Error('Unknown metadata command. Usage: revo metadata <plan|apply> --env <name>');
+    throw new Error('Unknown metadata command. Usage: revo metadata <plan|apply> --project <name>');
 }

package/dist/src/commands/project.js

@@ -4,7 +4,7 @@ import { applyMetadataBackfillPlan, buildMetadataBackfillPlan, } from "../metada
 import { buildProjectSyncState, buildEditorTypesUrl, extractSandboxEndpoint, extractEditorTypesBundle, readProjectComponentIdentity, readProjectMetadata, readProjectStableKeyName, readProjectTrackedResources, resolveProjectInvocation, resolveProjectTarget, syncProjectFiles, } from "../project.js";
 import { promptText } from "../prompt.js";
 import { DEFAULT_COMPONENT_IDENTITY, DEFAULT_STABLE_KEY_NAME, normalizeComponentIdentityConfig, normalizeComponentIdentityMode, normalizeStableKeyName, } from "../resource-metadata.js";
-import { formatTrackedResources, normalizeTrackedResources, } from "../tracked-resources.js";
+import { formatTrackedResources, normalizeTrackedResources, shouldTrackResource, TRACKABLE_RESOURCE_TYPES, } from "../tracked-resources.js";
 function printSyncSummary(println, projectRoot, workspaceRoot, result, prefix) {
     const workspaceDirectory = path.relative(projectRoot, workspaceRoot) || '.';
     println(`${prefix} ${projectRoot}`);
@@ -75,11 +75,14 @@ async function resolveComponentIdentity(invocation, projectRoot) {
     return normalizeComponentIdentityConfig({ mode, metadataProperty }, DEFAULT_COMPONENT_IDENTITY);
 }
 async function backfillStableKeyMetadata(context, stableKeyName, trackedResources) {
+    const automaticResources = trackedResources.includes('all')
+        ? TRACKABLE_RESOURCE_TYPES.filter((resource) => resource !== 'database-schema')
+        : trackedResources.filter((resource) => resource !== 'database-schema');
     const plan = await buildMetadataBackfillPlan({
         client: context.client,
-        envName: 'default',
+        envName: context.componentEnvironment || 'default',
         stableKeyName,
-        trackedResources,
+        trackedResources: automaticResources,
     });
     if (plan.counts.update === 0) {
         return;
@@ -106,6 +109,7 @@ export async function handleProjectCommand(context) {
     }
     const layout = resolveProjectTarget(cwd, invocation.targetArg);
     const syncInput = await resolveProjectSyncInput(context);
+    syncInput.authProfile = context.componentEnvironment || 'default';
     syncInput.componentIdentity = await resolveComponentIdentity(invocation, layout.projectRoot);
     syncInput.trackedResources = await resolveTrackedResources(invocation, layout.projectRoot);
     const result = syncProjectFiles(layout, syncInput);
@@ -115,4 +119,7 @@ export async function handleProjectCommand(context) {
         && context.args['metadata-backfill'] !== false) {
         await backfillStableKeyMetadata(context, syncInput.componentIdentity.metadataProperty || DEFAULT_STABLE_KEY_NAME, syncInput.trackedResources);
     }
+    if (invocation.action === 'init' && shouldTrackResource(syncInput.trackedResources, 'database-schema')) {
+        context.println('Database Schema Stable Keys require an explicit review: revo metadata plan --resources database-schema --project <source>');
+    }
 }

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

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