@revoengine/cli 1.0.9 → 1.0.11

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,7 +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,7 +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.d.ts

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

package/dist/src/commands/metadata.js

@@ -0,0 +1,159 @@
+import { RevoClient } from "../client.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";
+import { normalizeStableKeyName } from "../resource-metadata.js";
+import { normalizeTrackedResources } from "../tracked-resources.js";
+import { readBoolFlag, readFlag, readValues } from "../utils.js";
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    red: '\u001b[31m',
+    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;
+}
+function readEnvName(context) {
+    return readFlag(context.args, ['env']) || DEFAULT_ENV_NAME;
+}
+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 buildEnvClient(envName) {
+    return new RevoClient({ envName });
+}
+async function buildPlan(context) {
+    const envName = readEnvName(context);
+    const client = buildEnvClient(envName);
+    return buildMetadataBackfillPlan({
+        client,
+        envName,
+        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}${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).`);
+    }
+}
+function printResult(context, result) {
+    const { println } = context;
+    if (result.action === 'failed') {
+        println(`${paint('Failed', ANSI.bold + ANSI.red)} ${result.resourceType} ${result.resourceId} (${result.error})`);
+        return;
+    }
+    if (result.action === 'skip') {
+        println(`${paint('Skipped', ANSI.dim + ANSI.yellow)} ${result.resourceType} ${result.resourceId}`);
+        return;
+    }
+    println(`${paint('Updated', ANSI.bold + ANSI.green)} ${result.resourceType} ${result.resourceId} ${result.stableKey}`);
+}
+async function confirmApply(context, plan) {
+    const yes = readBoolFlag(context.args, ['yes']);
+    if (plan.counts.update === 0) {
+        return false;
+    }
+    if (yes) {
+        return true;
+    }
+    if (!isInteractiveTerminal()) {
+        throw new Error('Metadata apply requires confirmation. Re-run with --yes or use an interactive terminal.');
+    }
+    return promptConfirm(`Populate metadata on ${plan.counts.update} resource(s) in "${plan.env}"?`, false);
+}
+async function handleMetadataPlan(context) {
+    const plan = await buildPlan(context);
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(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: [] });
+        }
+        else {
+            context.println('No metadata changes to apply.');
+        }
+        return;
+    }
+    const client = buildEnvClient(plan.env);
+    await client.validateSession();
+    const results = await applyMetadataBackfillPlan({ client, plan });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print({ plan, results });
+    }
+    else {
+        for (const result of results) {
+            printResult(context, result);
+        }
+        const failed = results.filter((result) => result.action === 'failed').length;
+        context.println(`Applied ${results.length - failed}/${results.length}.`);
+    }
+    const failed = results.filter((result) => result.action === 'failed').length;
+    if (failed > 0) {
+        throw new Error(`Metadata apply finished with ${failed} failure(s).`);
+    }
+}
+export async function handleMetadataCommand(context) {
+    const subcommand = context.args._[1] || 'plan';
+    if (subcommand === 'plan') {
+        await handleMetadataPlan(context);
+        return;
+    }
+    if (subcommand === 'apply') {
+        await handleMetadataApply(context);
+        return;
+    }
+    throw new Error('Unknown metadata command. Usage: revo metadata <plan|apply> --project <name>');
+}

package/dist/src/commands/project.js

@@ -1,5 +1,10 @@
 import path from 'node:path';
-import { buildProjectSyncState, buildEditorTypesUrl, extractSandboxEndpoint, extractEditorTypesBundle, resolveProjectInvocation, resolveProjectTarget, syncProjectFiles, } from "../project.js";
+import { readComponentLock } from "../component-lock.js";
+import { applyMetadataBackfillPlan, buildMetadataBackfillPlan, } from "../metadata-backfill.js";
+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, shouldTrackResource, TRACKABLE_RESOURCE_TYPES, } from "../tracked-resources.js";
 function printSyncSummary(println, projectRoot, workspaceRoot, result, prefix) {
     const workspaceDirectory = path.relative(projectRoot, workspaceRoot) || '.';
     println(`${prefix} ${projectRoot}`);
@@ -31,6 +36,71 @@ async function resolveProjectSyncInput(context) {
         bundle,
     });
 }
+async function resolveTrackedResources(invocation, projectRoot) {
+    if (invocation.trackedResources) {
+        return invocation.trackedResources;
+    }
+    if (invocation.action === 'update') {
+        return readProjectTrackedResources(projectRoot);
+    }
+    const existing = readProjectTrackedResources(projectRoot);
+    const answer = await promptText('Resources to track with CLI (all, component; comma-separated)', formatTrackedResources(existing));
+    return normalizeTrackedResources(answer);
+}
+async function resolveComponentIdentity(invocation, projectRoot) {
+    if (invocation.identityMode === 'componentId' && invocation.stableKeyName) {
+        throw new Error('--stable-key-name cannot be used with --identity-mode componentId.');
+    }
+    const existingMetadata = readProjectMetadata(projectRoot);
+    const existingLock = readComponentLock(projectRoot);
+    const hasTrackedIdentity = Object.keys(existingLock.components).length > 0
+        || existingLock.componentIdentity.mode === 'stableKey';
+    const existing = existingMetadata
+        ? readProjectComponentIdentity(projectRoot)
+        : hasTrackedIdentity
+            ? existingLock.componentIdentity
+            : DEFAULT_COMPONENT_IDENTITY;
+    const defaultIdentity = existing;
+    const mode = invocation.identityMode || (invocation.action === 'update'
+        ? existing.mode
+        : normalizeComponentIdentityMode(await promptText('Component identity mode (stableKey or componentId)', defaultIdentity.mode)));
+    if (mode === 'componentId') {
+        return { mode };
+    }
+    const metadataProperty = invocation.stableKeyName || (invocation.action === 'update'
+        ? readProjectStableKeyName(projectRoot)
+        : normalizeStableKeyName(await promptText('Stable key metadata property', defaultIdentity.mode === 'stableKey'
+            ? defaultIdentity.metadataProperty || DEFAULT_STABLE_KEY_NAME
+            : DEFAULT_STABLE_KEY_NAME)));
+    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: context.componentEnvironment || 'default',
+        stableKeyName,
+        trackedResources: automaticResources,
+    });
+    if (plan.counts.update === 0) {
+        return;
+    }
+    const results = await applyMetadataBackfillPlan({
+        client: context.client,
+        plan,
+    });
+    const failed = results.filter((result) => result.action === 'failed');
+    if (failed.length > 0) {
+        const details = failed
+            .map((result) => `${result.resourceId}: ${result.error || 'unknown error'}`)
+            .join('; ');
+        throw new Error(`Project initialized, but stable-key metadata backfill failed for ${failed.length} component(s): ${details}`);
+    }
+    const updated = results.filter((result) => result.action === 'update').length;
+    context.println(`Backfilled stable-key metadata on ${updated} component(s).`);
+}
 export async function handleProjectCommand(context) {
     const { args, client, cwd, println } = context;
     const invocation = resolveProjectInvocation(args);
@@ -39,6 +109,17 @@ 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);
     printSyncSummary(println, layout.projectRoot, layout.workspaceRoot, result, invocation.action === 'update' ? 'Updated Revo project in' : 'Initialized Revo project in');
+    if (invocation.action === 'init'
+        && syncInput.componentIdentity.mode === 'stableKey'
+        && 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>;