@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/commands/auth.js

@@ -1,12 +1,13 @@
 import path from 'node:path';
 import { clearAuthValidationState, clearStoredConfig, getConfigDir, loadStoredConfig, resolveRuntimeConfig, saveStoredConfig, } from "../config.js";
 import { readLegacyImportFromFile } from "../legacy.js";
-import { promptText } from "../prompt.js";
+import { promptSecret } from "../prompt.js";
 import { buildRuntimeViewModel } from "../runtime-view.js";
 import { renderAuthStatus } from "../ui.js";
 import { readBoolFlag, readFlag } from "../utils.js";
 function getConfigInput(args) {
     return resolveRuntimeConfig({
+        envName: 'default',
         baseUrl: readFlag(args, ['url', 'baseUrl']) || '',
         token: readFlag(args, ['token', 't']) || '',
     });
@@ -14,7 +15,7 @@ function getConfigInput(args) {
 async function promptMissingConfig(runtime) {
     let token = runtime.token;
     if (!token) {
-        token = (await promptText('Paste API key (input is visible)')).trim();
+        token = (await promptSecret('Paste API key')).trim();
     }
     if (!token) {
         throw new Error('API key is required.');
@@ -89,6 +90,7 @@ export async function handleAuthCommand(context) {
     const next = runtime.token ? runtime : await promptMissingConfig(runtime);
     client.token = next.token;
     client.baseUrl = next.baseUrl;
+    client.instance = runtime.instance;
     try {
         await client.validateSession({ force: true });
     }

package/dist/src/commands/component.js

@@ -1,50 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { ApiError, COMPONENT_LIST_PAGE_SIZE, PermissionDeniedError } from "../client.js";
-import { REVO_LOCK_FILE, componentLockMatchesIdentity, getComponentLockEntry, hashComponentSource, hashPortableComponentSource, hashStable, readComponentLock, sanitizeComponentSource, upsertComponentLockEntry, writeComponentLock, } from "../component-lock.js";
+import { getConfigDir } from "../config.js";
+import { REVO_LOCK_FILE, buildPortableComponentUpdatePayload, componentLockMatchesIdentity, diffPortableComponentSource, getComponentLockEntry, getComponentLockEntries, hashComponentSource, hashPortableComponentSource, hashStable, readComponentLock, sanitizeComponentSource, upsertComponentLockEntry, writeComponentLock, } from "../component-lock.js";
 import { buildSandboxDebugStreamUrl, buildSandboxDebugUrl, extractSandboxEndpoint, readProjectComponentIdentity, readProjectMetadata, resolveProjectRoot, resolveProjectWorkspace, } from "../project.js";
 import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
-import { readComponentIdentityValue, } from "../resource-metadata.js";
+import { readComponentIdentityValue, sanitizeUserMetadata, } from "../resource-metadata.js";
+import { printSyncPlan, printSyncNotice, printSyncStatus, printSyncSummary, } from "../sync-output.js";
 import { deepClone, readBoolFlag, readFlag, readValues, sanitizeSegment, writeJsonFile } from "../utils.js";
+import { hydrateWorkspaceComponentElementDetails } from "../workspace-component.js";
+import { replaceWorkspaceResourceDirectory } from "../workspace-resource.js";
 const NULL_CATEGORY_FOLDER = '__no_category__';
-const ANSI = {
-    reset: '\u001b[0m',
-    bold: '\u001b[1m',
-    dim: '\u001b[2m',
-    green: '\u001b[32m',
-    yellow: '\u001b[33m',
-    cyan: '\u001b[36m',
-    blue: '\u001b[34m',
-    magenta: '\u001b[35m',
-};
-function supportsColor() {
-    return Boolean(process.stdout.isTTY || process.env.FORCE_COLOR);
-}
-function paint(text, code) {
-    return supportsColor() ? `${code}${text}${ANSI.reset}` : text;
-}
-function paintStatus(status) {
-    if (status === 'Skipped') {
-        return paint(status.padEnd(9), ANSI.bold + ANSI.yellow);
-    }
-    if (status === 'Notice') {
-        return paint(status.padEnd(9), ANSI.bold + ANSI.magenta);
-    }
-    return paint(status.padEnd(9), ANSI.bold + ANSI.green);
-}
-function paintPath(targetPath) {
-    return paint(targetPath, ANSI.cyan);
-}
-function paintEngine() {
-    return paint('RevoEngine', ANSI.bold + ANSI.blue);
-}
-function paintArrow(direction) {
-    return paint(direction === 'pull' ? '->' : '<-', ANSI.bold + ANSI.magenta);
-}
-function paintReason(reason) {
-    return paint(`(${reason})`, ANSI.dim + ANSI.yellow);
-}
 function rethrowComponentAccessError(error, action) {
     if (error instanceof PermissionDeniedError) {
         throw new Error(`Access denied (403). You are authenticated, but you do not have permission to ${action} components.`);
@@ -54,32 +22,6 @@ function rethrowComponentAccessError(error, action) {
 function componentWorkspacePath(cwd, manifestPath) {
     return path.relative(cwd, path.dirname(manifestPath)) || '.';
 }
-function printSyncStatus(println, input) {
-    const suffix = input.reason ? ` ${paintReason(input.reason)}` : '';
-    println(`${paintStatus(input.status)} ${paintEngine()} ${paintArrow(input.direction)} ${paintPath(input.targetPath)}${suffix}`);
-}
-function printNotice(println, message) {
-    println(`${paintStatus('Notice')} ${message}`);
-}
-function formatDuration(durationMs) {
-    if (durationMs < 1_000) {
-        return `${durationMs}ms`;
-    }
-    const seconds = durationMs / 1_000;
-    if (seconds < 10) {
-        return `${seconds.toFixed(1)}s`;
-    }
-    return `${Math.round(seconds)}s`;
-}
-function printSummary(println, label, results, durationMs) {
-    const primary = results.filter((result) => result.status === label.toLowerCase()).length;
-    const skipped = results.filter((result) => result.status === 'skipped').length;
-    const total = results.length;
-    const summary = skipped > 0
-        ? `${label} ${primary}/${total}, Skipped ${skipped}/${total} in ${formatDuration(durationMs)}`
-        : `${label} ${primary}/${total} in ${formatDuration(durationMs)}`;
-    println(summary);
-}
 function formatBulkCount(direction, count) {
     if (typeof count === 'number') {
         return direction === 'pull'
@@ -99,7 +41,7 @@ async function confirmBulkAction(context, direction, count, force) {
     if (!isInteractiveTerminal()) {
         throw new Error(`Bulk ${action} requires confirmation. Re-run with --force or use an interactive terminal.`);
     }
-    printNotice(context.println, `About to ${action} ${subject}.`);
+    printSyncNotice(context.println, `About to ${action} ${subject}.`);
     const confirmed = await promptConfirm('Continue?', false);
     if (!confirmed) {
         throw new Error('Cancelled.');
@@ -243,36 +185,9 @@ function getComponentManifestPaths(root) {
     return walkFiles(root).filter((filePath) => filePath.endsWith('component.json'));
 }
 function readWorkspaceComponent(manifestPath) {
-    const componentDir = path.dirname(manifestPath);
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    const detailDirs = [
-        path.join(componentDir, 'elements'),
-        path.join(componentDir, 'details'),
-    ].filter((dir, index, list) => list.indexOf(dir) === index);
     const extension = componentTypeToExtension(normalizeComponentType(manifest));
-    manifest.elements = (manifest.elements || []).map((element) => {
-        const fileName = `${element.order}_${element.key}.${extension}`;
-        let details = '';
-        for (const detailDir of detailDirs) {
-            const preferredPath = path.join(detailDir, fileName);
-            if (fs.existsSync(preferredPath)) {
-                details = fs.readFileSync(preferredPath, 'utf8');
-                break;
-            }
-            if (fs.existsSync(detailDir)) {
-                const match = fs.readdirSync(detailDir).find((entry) => entry.startsWith(`${element.order}_${element.key}.`));
-                if (match) {
-                    details = fs.readFileSync(path.join(detailDir, match), 'utf8');
-                    break;
-                }
-            }
-        }
-        return {
-            ...element,
-            details,
-        };
-    });
-    return manifest;
+    return hydrateWorkspaceComponentElementDetails(manifestPath, manifest, extension);
 }
 function getComponentIdFromPath(componentPath) {
     const basename = path.basename(componentPath);
@@ -449,6 +364,50 @@ function componentSourceHash(component, identity) {
         ? hashPortableComponentSource(component)
         : hashComponentSource(component);
 }
+function writeComponentPushVerificationLog(input) {
+    const outputDir = path.join(input.cwd, '.revoengine', 'logs', 'component-push');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const identityKey = readComponentIdentityValue(input.desired, input.identity) || componentIdOf(input.desired);
+    const outputFile = path.join(outputDir, `${timestamp}-${sanitizeSegment(identityKey)}.json`);
+    const desiredHash = componentSourceHash(input.desired, input.identity);
+    const actualHash = componentSourceHash(input.actual, input.identity);
+    const portableDiff = diffPortableComponentSource(input.desired, input.actual);
+    writeJsonFile(outputFile, {
+        schemaVersion: 1,
+        kind: 'component-push-verification-failure',
+        generatedAt: new Date().toISOString(),
+        targetPath: input.targetPath,
+        ...(input.environment ? { environment: input.environment } : {}),
+        identity: input.identity,
+        hashes: { desired: desiredHash, actual: actualHash },
+        difference: portableDiff,
+        ...(input.operations ? { operations: input.operations } : {}),
+        ...(input.errorOperationId ? { errorOperationId: input.errorOperationId } : {}),
+        desired: input.desired,
+        actual: input.actual,
+    });
+    return path.relative(input.cwd, outputFile);
+}
+function describeComponentPushOperationError(error) {
+    if (error instanceof ApiError) {
+        return {
+            outcome: 'rejected',
+            name: error.name,
+            message: error.message,
+            status: error.status,
+            response: error.data,
+        };
+    }
+    return {
+        outcome: 'failed',
+        name: error instanceof Error ? error.name : 'Error',
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+function readRevoOperationId(headers) {
+    const value = headers?.get('x-revo-oid')?.trim();
+    return value || undefined;
+}
 function identityDescription(identity) {
     return identity.mode === 'stableKey'
         ? `metadata.${identity.metadataProperty}`
@@ -573,6 +532,14 @@ function migrateComponentLockIdentity(cwd, identity, localCatalog, remoteCatalog
         schemaVersion: 2,
         componentIdentity: identity,
         components: migratedComponents,
+        groups: lock.groups,
+        roleGroups: lock.roleGroups,
+        jobTemplates: lock.jobTemplates,
+        schedules: lock.schedules,
+        events: lock.events,
+        endpoints: lock.endpoints,
+        databaseSchemas: lock.databaseSchemas,
+        databaseViews: lock.databaseViews,
     };
     writeComponentLock(projectRoot, migrated);
     return migrated;
@@ -602,7 +569,7 @@ function findLocalEntryForRemote(remote, localCatalog) {
     }
     return idMatch;
 }
-function upsertLockFromRemote(cwd, remote, targetPath, local) {
+function upsertLockFromRemote(cwd, remote, targetPath, local, environmentName) {
     const identity = resolveComponentIdentity(cwd);
     const remoteComponentId = componentIdOf(remote);
     const localComponentId = componentIdOf(local || remote);
@@ -628,9 +595,9 @@ function upsertLockFromRemote(cwd, remote, targetPath, local) {
         remoteHash,
         sourceHash: local ? componentSourceHash(local, identity) : remoteHash,
         pulledAt: new Date().toISOString(),
-    }, identity);
+    }, identity, environmentName);
 }
-function buildPullDecision(cwd, remote, localCatalog = buildLocalComponentCatalog(cwd, resolveComponentIdentity(cwd))) {
+function buildPullDecision(cwd, remote, localCatalog = buildLocalComponentCatalog(cwd, resolveComponentIdentity(cwd)), environmentName) {
     const identity = localCatalog.identity;
     const remoteTargetPath = componentTargetPath(cwd, remote);
     const identityKey = readComponentIdentityValue(remote, identity);
@@ -649,7 +616,7 @@ function buildPullDecision(cwd, remote, localCatalog = buildLocalComponentCatalo
         };
     }
     const targetPath = componentWorkspacePath(cwd, local.manifestPath);
-    const lockEntry = getComponentLockEntry(readComponentLock(getProjectRoot(cwd)), identity, remote);
+    const lockEntry = getComponentLockEntry(readComponentLock(getProjectRoot(cwd)), identity, remote, environmentName);
     const localHash = local.hash;
     const remoteHash = componentSourceHash(remote, identity);
     const base = {
@@ -759,7 +726,7 @@ async function confirmSingleStalePull(context, targetPath) {
     if (!isInteractiveTerminal()) {
         throw new Error(`Local component is stale at ${targetPath}. Re-run with --stale or --force, or use an interactive terminal to confirm overwrite.`);
     }
-    printNotice(context.println, `Local component is stale at ${targetPath}.`);
+    printSyncNotice(context.println, `Local component is stale at ${targetPath}.`);
     return promptConfirm('Overwrite local component with the remote version?', false);
 }
 async function resolveRemoteComponentForTarget(context, target, identity, remoteCatalog) {
@@ -810,7 +777,7 @@ async function pullResolvedComponent(context, component, mode, localCatalog) {
     const { cwd, println } = context;
     const identity = resolveComponentIdentity(cwd);
     const componentId = componentIdOf(component);
-    const decision = buildPullDecision(cwd, component, localCatalog || buildLocalComponentCatalog(cwd, identity));
+    const decision = buildPullDecision(cwd, component, localCatalog || buildLocalComponentCatalog(cwd, identity), context.componentEnvironment);
     if (decision.kind === 'skip' && decision.reason.includes('; unmanaged')) {
         const result = {
             status: 'skipped',
@@ -872,7 +839,7 @@ async function pullResolvedComponent(context, component, mode, localCatalog) {
                 const localComponent = decision.manifestPath
                     ? readWorkspaceComponentSafe(decision.manifestPath) || decision.localComponent
                     : decision.localComponent;
-                upsertLockFromRemote(cwd, component, decision.targetPath, localComponent);
+                upsertLockFromRemote(cwd, component, decision.targetPath, localComponent, context.componentEnvironment);
             }
             const result = {
                 status: metadataUpdated ? 'pulled' : 'skipped',
@@ -893,18 +860,26 @@ async function pullResolvedComponent(context, component, mode, localCatalog) {
         ? path.dirname(decision.manifestPath)
         : path.join(root, getComponentFolder(component));
     const targetPath = path.relative(cwd, folder);
-    const elementsDir = path.join(folder, 'elements');
-    fs.mkdirSync(elementsDir, { recursive: true });
-    const extension = getDetailsExtension(component);
-    for (const element of component.elements || []) {
-        const content = element.details ?? element.logic ?? '';
-        const filePath = path.join(elementsDir, `${element.order}_${element.key}.${extension}`);
-        fs.writeFileSync(filePath, content);
+    const populate = (directory) => {
+        const elementsDir = path.join(directory, 'elements');
+        fs.mkdirSync(elementsDir, { recursive: true });
+        const extension = getDetailsExtension(component);
+        for (const element of component.elements || []) {
+            const content = element.details ?? element.logic ?? '';
+            const filePath = path.join(elementsDir, `${element.order}_${element.key}.${extension}`);
+            fs.writeFileSync(filePath, content);
+        }
+        writeJsonFile(path.join(directory, 'component.json'), buildPulledManifest(component, decision.localComponent, identity));
+    };
+    if (mode.force) {
+        replaceWorkspaceResourceDirectory(root, folder, populate);
+    }
+    else {
+        populate(folder);
     }
     const manifestPath = path.join(folder, 'component.json');
-    writeJsonFile(manifestPath, buildPulledManifest(component, decision.localComponent, identity));
     const localComponent = readWorkspaceComponentSafe(manifestPath) || decision.localComponent;
-    upsertLockFromRemote(cwd, component, targetPath, localComponent);
+    upsertLockFromRemote(cwd, component, targetPath, localComponent, context.componentEnvironment);
     const result = {
         status: 'pulled',
         targetPath,
@@ -985,7 +960,7 @@ async function pullAllComponents(context, options) {
             results.push(result);
         }
     }
-    printSummary(context.println, 'Pulled', results, Date.now() - startedAt);
+    printSyncSummary(context.println, 'Pulled', results, Date.now() - startedAt);
     return results;
 }
 async function resolveRemoteComponentForLocal(context, component, identity, remoteCatalog) {
@@ -1032,6 +1007,19 @@ function buildPushElements(component, remote, identity) {
         };
     });
 }
+function buildComponentCreatePayload(component, identity) {
+    return {
+        name: component.name || '',
+        category: component.category ?? null,
+        desc: component.desc ?? null,
+        type: normalizeComponentType(component),
+        compiler: compilerFromType(component.type, component.compiler),
+        active: component.active ?? true,
+        async: Boolean(component.async),
+        metadata: sanitizeUserMetadata(component.metadata),
+        elements: buildPushElements(component, { elements: [] }, identity),
+    };
+}
 async function pushSingleComponent(context, manifestPath, remoteCatalog) {
     const { client, println } = context;
     const component = readWorkspaceComponent(manifestPath);
@@ -1068,6 +1056,30 @@ async function pushSingleComponent(context, manifestPath, remoteCatalog) {
     try {
         const remote = await resolveRemoteComponentForLocal(context, component, identity, resolvedRemoteCatalog);
         if (!remote) {
+            if (context.componentEnvironment) {
+                const created = unwrapComponent(await client.createComponent(buildComponentCreatePayload(component, identity)));
+                const createdComponentId = componentIdOf(created);
+                if (!createdComponentId) {
+                    throw new Error(`Cannot push ${targetPath}: create response did not include componentId.`);
+                }
+                await client.saveComponentElements(createdComponentId, buildPushElements(component, { elements: [] }, identity));
+                const refreshedRemote = unwrapComponent(await client.getComponent(createdComponentId));
+                if (componentSourceHash(refreshedRemote, identity) !== componentSourceHash(component, identity)) {
+                    const logPath = writeComponentPushVerificationLog({
+                        cwd: context.cwd,
+                        targetPath,
+                        environment: context.componentEnvironment,
+                        identity,
+                        desired: component,
+                        actual: refreshedRemote,
+                    });
+                    throw new Error(`Cannot push ${targetPath}: created component did not verify against local source. Diagnostic: ${logPath}`);
+                }
+                upsertLockFromRemote(context.cwd, refreshedRemote, targetPath, component, context.componentEnvironment);
+                const result = { status: 'deployed', targetPath };
+                printSyncStatus(println, { status: 'Deployed', direction: 'push', targetPath });
+                return result;
+            }
             const result = {
                 status: 'skipped',
                 targetPath,
@@ -1086,8 +1098,25 @@ async function pushSingleComponent(context, manifestPath, remoteCatalog) {
             throw new Error(`Remote component matched by ${identityDescription(identity)} "${identityKey}" has no componentId.`);
         }
         if (!readBoolFlag(context.args, ['force', 'f'])) {
-            const lockEntry = getComponentLockEntry(readComponentLock(getProjectRoot(context.cwd)), identity, component);
+            const lockEntry = getComponentLockEntry(readComponentLock(getProjectRoot(context.cwd)), identity, component, context.componentEnvironment);
             if (!lockEntry) {
+                const remoteHash = componentSourceHash(remote, identity);
+                const localHash = componentSourceHash(component, identity);
+                if (context.componentEnvironment && localHash === remoteHash) {
+                    upsertLockFromRemote(context.cwd, remote, targetPath, component, context.componentEnvironment);
+                    const result = {
+                        status: 'skipped',
+                        targetPath,
+                        reason: 'local matches remote; target baseline adopted',
+                    };
+                    printSyncStatus(println, {
+                        status: 'Skipped',
+                        direction: 'push',
+                        targetPath: result.targetPath,
+                        reason: result.reason,
+                    });
+                    return result;
+                }
                 throw new Error(`Cannot push ${targetPath}: missing lock entry. Run \`revo component pull ${identityKey} --force\` to establish a remote baseline.`);
             }
             if (lockEntry.remoteComponentId !== remoteComponentId) {
@@ -1097,7 +1126,7 @@ async function pushSingleComponent(context, manifestPath, remoteCatalog) {
             const localHash = componentSourceHash(component, identity);
             if (remoteHash !== lockEntry.remoteHash) {
                 if (localHash === remoteHash) {
-                    upsertLockFromRemote(context.cwd, remote, targetPath, component);
+                    upsertLockFromRemote(context.cwd, remote, targetPath, component, context.componentEnvironment);
                     const result = {
                         status: 'skipped',
                         targetPath,
@@ -1128,21 +1157,98 @@ async function pushSingleComponent(context, manifestPath, remoteCatalog) {
                 return result;
             }
         }
-        const elements = buildPushElements(component, remote, identity);
-        const response = await client.saveComponentElements(remoteComponentId, elements);
-        if (response.status === 304) {
+        const hasLiveRemote = typeof client.getComponent === 'function';
+        const portableDiff = hasLiveRemote
+            ? diffPortableComponentSource(component, remote)
+            : { configurationFields: [], elementsChanged: true, changedFields: ['elements'] };
+        if (portableDiff.changedFields.length === 0) {
             const result = {
                 status: 'skipped',
                 targetPath,
                 reason: 'no changes',
             };
+            upsertLockFromRemote(context.cwd, remote, targetPath, component, context.componentEnvironment);
+            printSyncStatus(println, {
+                status: 'Skipped',
+                direction: 'push',
+                targetPath,
+                reason: result.reason,
+            });
+            return result;
+        }
+        let configurationChanged = false;
+        const operations = {};
+        let errorOperationId;
+        if (portableDiff.configurationFields.length > 0) {
+            try {
+                await client.updateComponent(remoteComponentId, buildPortableComponentUpdatePayload(component, remote, portableDiff.configurationFields));
+                configurationChanged = true;
+                operations.configurationUpdate = { outcome: 'accepted' };
+            }
+            catch (error) {
+                operations.configurationUpdate = describeComponentPushOperationError(error);
+                if (error instanceof ApiError) {
+                    errorOperationId = readRevoOperationId(error.headers) || errorOperationId;
+                }
+                if (!isNotModifiedError(error)) {
+                    throw error;
+                }
+            }
+        }
+        let elementsChanged = false;
+        if (portableDiff.elementsChanged) {
             try {
-                const refreshedRemote = unwrapComponent(await client.getComponent(remoteComponentId));
-                upsertLockFromRemote(context.cwd, refreshedRemote, targetPath, component);
+                const elements = buildPushElements(component, remote, identity);
+                const response = await client.saveComponentElements(remoteComponentId, elements);
+                elementsChanged = response.status !== 304;
+                const operationId = readRevoOperationId(response.headers);
+                errorOperationId = operationId || errorOperationId;
+                operations.elementsSave = {
+                    outcome: 'accepted',
+                    status: response.status,
+                    ok: response.ok,
+                    response: response.data,
+                    ...(operationId ? { errorOperationId: operationId } : {}),
+                };
             }
-            catch {
-                upsertLockFromRemote(context.cwd, remote, targetPath, component);
+            catch (error) {
+                operations.elementsSave = describeComponentPushOperationError(error);
+                if (error instanceof ApiError) {
+                    errorOperationId = readRevoOperationId(error.headers) || errorOperationId;
+                }
+                if (!isNotModifiedError(error)) {
+                    throw error;
+                }
             }
+        }
+        const refreshedRemote = hasLiveRemote
+            ? unwrapComponent(await client.getComponent(remoteComponentId))
+            : {
+                ...component,
+                componentId: remoteComponentId,
+                ...(componentVersion(remote) != null ? { version: componentVersion(remote) } : {}),
+            };
+        if (hasLiveRemote
+            && componentSourceHash(refreshedRemote, identity) !== componentSourceHash(component, identity)) {
+            const logPath = writeComponentPushVerificationLog({
+                cwd: context.cwd,
+                targetPath,
+                environment: context.componentEnvironment,
+                identity,
+                desired: component,
+                actual: refreshedRemote,
+                operations,
+                errorOperationId,
+            });
+            throw new Error(`Cannot push ${targetPath}: updated component did not verify against local source. Diagnostic: ${logPath}`);
+        }
+        upsertLockFromRemote(context.cwd, refreshedRemote, targetPath, component, context.componentEnvironment);
+        if (!configurationChanged && !elementsChanged) {
+            const result = {
+                status: 'skipped',
+                targetPath,
+                reason: 'no changes',
+            };
             printSyncStatus(println, {
                 status: 'Skipped',
                 direction: 'push',
@@ -1155,17 +1261,6 @@ async function pushSingleComponent(context, manifestPath, remoteCatalog) {
             status: 'deployed',
             targetPath,
         };
-        try {
-            const refreshedRemote = unwrapComponent(await client.getComponent(remoteComponentId));
-            upsertLockFromRemote(context.cwd, refreshedRemote, targetPath, component);
-        }
-        catch {
-            upsertLockFromRemote(context.cwd, {
-                ...component,
-                componentId: remoteComponentId,
-                ...(componentVersion(remote) != null ? { version: componentVersion(remote) } : {}),
-            }, targetPath, component);
-        }
         printSyncStatus(println, {
             status: 'Deployed',
             direction: 'push',
@@ -1243,7 +1338,7 @@ async function pushAllComponents(context, options) {
             results.push(result);
         }
     }
-    printSummary(context.println, 'Deployed', results, Date.now() - startedAt);
+    printSyncSummary(context.println, 'Deployed', results, Date.now() - startedAt);
     return results;
 }
 async function buildComponentPlan(context, scope = { enabled: false, base: '', componentIds: new Set() }) {
@@ -1254,7 +1349,7 @@ async function buildComponentPlan(context, scope = { enabled: false, base: '', c
     const localCatalog = buildLocalComponentCatalog(context.cwd, identity);
     const { components } = await fetchAllComponentSummaries(context);
     const remoteCatalog = await buildRemoteComponentCatalog(context, identity, components);
-    const lockEntries = componentLockMatchesIdentity(lock, identity) ? lock.components : {};
+    const lockEntries = getComponentLockEntries(lock, identity, context.componentEnvironment);
     const allIdentityKeys = [...new Set([
             ...localCatalog.byIdentity.keys(),
             ...remoteCatalog.byIdentity.keys(),
@@ -1278,6 +1373,9 @@ async function buildComponentPlan(context, scope = { enabled: false, base: '', c
         const localHash = local?.hash || null;
         const remoteHash = remote?.hash || null;
         const lockHash = lockEntry?.remoteHash || null;
+        const changedFields = local && remote
+            ? diffPortableComponentSource(local.component, remote.component).changedFields
+            : [];
         let status = 'clean';
         let reason = 'local, lock, and remote match';
         if (!local && !remote) {
@@ -1331,6 +1429,7 @@ async function buildComponentPlan(context, scope = { enabled: false, base: '', c
             remoteHash,
             remoteVersion: remote ? componentVersion(remote.component) : lockEntry?.remoteVersion ?? null,
             reason,
+            ...(changedFields.length > 0 ? { changedFields } : {}),
             ...(scope.enabled ? { inScope } : {}),
         };
     });
@@ -1366,12 +1465,6 @@ async function buildComponentPlan(context, scope = { enabled: false, base: '', c
         items: scopedItems,
     };
 }
-function printPlan(context, plan) {
-    for (const item of plan.items) {
-        context.println(`${item.status.padEnd(14)} ${item.path} ${item.reason ? `(${item.reason})` : ''}`.trimEnd());
-    }
-    context.println(`Plan: ${plan.items.length} components, ${plan.counts.conflict} conflicts, ${plan.counts['local-changed']} local changes, ${plan.counts['remote-changed']} remote changes.`);
-}
 function parseTargets(args, names) {
     const values = readValues(args, names);
     if (values.length > 0) {
@@ -1562,7 +1655,17 @@ function collectDebugExtraLibs(cwd, currentComponentId) {
     }));
 }
 function writeRawDebugRequestDump(options) {
-    process.stderr.write(`[debug-request] ${JSON.stringify(options, null, 2)}\n`);
+    const directory = path.join(getConfigDir(), 'debug-requests');
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    try {
+        fs.chmodSync(directory, 0o700);
+    }
+    catch {
+        // Some platforms do not support Unix-style permissions.
+    }
+    const filePath = path.join(directory, `debug-request-${randomUUID()}.json`);
+    writeJsonFile(filePath, options);
+    process.stderr.write(`[debug-request] Saved private payload to ${filePath}\n`);
 }
 function formatProcessLog(log) {
     if (!log || typeof log !== 'object' || Array.isArray(log)) {
@@ -1687,6 +1790,12 @@ export async function handleComponentCommand(context) {
     const json = readBoolFlag(args, ['json']);
     const strict = readBoolFlag(args, ['strict']);
     const changedScope = resolveChangedComponentScope(context);
+    if (context.componentEnvironment && ['pull', 'plan', 'push'].includes(subcommand)) {
+        const identity = resolveComponentIdentity(context.cwd);
+        if (identity.mode !== 'stableKey') {
+            throw new Error('Component sync with a named project requires componentIdentity.mode "stableKey". Configure it in .revoengine/revo.json before pulling from a named project.');
+        }
+    }
     if (subcommand === 'pull-all') {
         await pullAllComponents(context, { force, stale, yes });
         return;
@@ -1701,7 +1810,17 @@ export async function handleComponentCommand(context) {
             context.print(plan);
         }
         else {
-            printPlan(context, plan);
+            printSyncPlan(context.println, {
+                title: 'Component',
+                environment: context.componentEnvironment || 'default',
+                counts: plan.counts,
+                items: plan.items.map((item) => ({
+                    status: item.status,
+                    target: item.path,
+                    reason: item.reason,
+                    changedFields: item.changedFields,
+                })),
+            });
         }
         if (strict) {
             const blocking = plan.items.filter((item) => ((!changedScope.enabled || item.inScope)

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

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