@revoengine/cli 1.0.10 → 1.0.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (104) hide show
  1. package/README.md +314 -239
  2. package/dist/src/cli.js +126 -9
  3. package/dist/src/client.d.ts +373 -6
  4. package/dist/src/client.js +1005 -53
  5. package/dist/src/commands/auth.js +4 -2
  6. package/dist/src/commands/component.d.ts +67 -0
  7. package/dist/src/commands/component.js +555 -164
  8. package/dist/src/commands/database-tables.d.ts +2 -0
  9. package/dist/src/commands/database-tables.js +169 -0
  10. package/dist/src/commands/database-views.d.ts +2 -0
  11. package/dist/src/commands/database-views.js +126 -0
  12. package/dist/src/commands/endpoints.js +124 -0
  13. package/dist/src/commands/env.js +44 -24
  14. package/dist/src/commands/events.d.ts +2 -0
  15. package/dist/src/commands/events.js +144 -0
  16. package/dist/src/commands/groups.d.ts +2 -0
  17. package/dist/src/commands/groups.js +160 -0
  18. package/dist/src/commands/index.d.ts +9 -0
  19. package/dist/src/commands/index.js +9 -0
  20. package/dist/src/commands/job-templates.d.ts +2 -0
  21. package/dist/src/commands/job-templates.js +107 -0
  22. package/dist/src/commands/metadata.js +75 -10
  23. package/dist/src/commands/migrate.d.ts +6 -0
  24. package/dist/src/commands/migrate.js +658 -0
  25. package/dist/src/commands/project.js +10 -3
  26. package/dist/src/commands/role-groups.d.ts +2 -0
  27. package/dist/src/commands/role-groups.js +141 -0
  28. package/dist/src/commands/schedules.d.ts +2 -0
  29. package/dist/src/commands/schedules.js +140 -0
  30. package/dist/src/commands/terminal-browser.d.ts +16 -0
  31. package/dist/src/commands/terminal-browser.js +92 -0
  32. package/dist/src/commands/terminal-image.d.ts +7 -0
  33. package/dist/src/commands/terminal-image.js +40 -0
  34. package/dist/src/commands/terminal-patch-worker.d.ts +1 -0
  35. package/dist/src/commands/terminal-patch-worker.js +24 -0
  36. package/dist/src/commands/terminal-patch.d.ts +2 -0
  37. package/dist/src/commands/terminal-patch.js +156 -0
  38. package/dist/src/commands/terminal-sandbox.d.ts +8 -0
  39. package/dist/src/commands/terminal-sandbox.js +87 -0
  40. package/dist/src/commands/terminal-service.d.ts +38 -0
  41. package/dist/src/commands/terminal-service.js +210 -0
  42. package/dist/src/commands/terminal.d.ts +49 -0
  43. package/dist/src/commands/terminal.js +826 -0
  44. package/dist/src/component-lock.d.ts +111 -3
  45. package/dist/src/component-lock.js +363 -15
  46. package/dist/src/config.d.ts +10 -2
  47. package/dist/src/config.js +49 -14
  48. package/dist/src/database-table-artifacts.d.ts +7 -0
  49. package/dist/src/database-table-artifacts.js +8 -0
  50. package/dist/src/diff-details.d.ts +8 -0
  51. package/dist/src/diff-details.js +152 -0
  52. package/dist/src/env-sync.d.ts +0 -3
  53. package/dist/src/env-sync.js +11 -25
  54. package/dist/src/http-trace.d.ts +94 -0
  55. package/dist/src/http-trace.js +226 -0
  56. package/dist/src/metadata-backfill.d.ts +18 -7
  57. package/dist/src/metadata-backfill.js +1002 -27
  58. package/dist/src/migration.d.ts +141 -0
  59. package/dist/src/migration.js +1632 -0
  60. package/dist/src/project.d.ts +2 -0
  61. package/dist/src/project.js +4 -17
  62. package/dist/src/prompt.js +10 -18
  63. package/dist/src/resource-inventory.d.ts +28 -0
  64. package/dist/src/resource-inventory.js +85 -0
  65. package/dist/src/resource-metadata.d.ts +1 -0
  66. package/dist/src/resource-metadata.js +3 -0
  67. package/dist/src/resource-syncs/database-table-sync.d.ts +127 -0
  68. package/dist/src/resource-syncs/database-table-sync.js +2374 -0
  69. package/dist/src/resource-syncs/database-view-sync.d.ts +146 -0
  70. package/dist/src/resource-syncs/database-view-sync.js +1405 -0
  71. package/dist/src/resource-syncs/endpoint-sync.d.ts +123 -0
  72. package/dist/src/resource-syncs/endpoint-sync.js +1563 -0
  73. package/dist/src/resource-syncs/event-sync.d.ts +126 -0
  74. package/dist/src/resource-syncs/event-sync.js +1046 -0
  75. package/dist/src/resource-syncs/group-sync.d.ts +93 -0
  76. package/dist/src/resource-syncs/group-sync.js +928 -0
  77. package/dist/src/resource-syncs/job-template-sync.d.ts +106 -0
  78. package/dist/src/resource-syncs/job-template-sync.js +843 -0
  79. package/dist/src/resource-syncs/role-group-sync.d.ts +90 -0
  80. package/dist/src/resource-syncs/role-group-sync.js +635 -0
  81. package/dist/src/resource-syncs/schedule-sync.d.ts +140 -0
  82. package/dist/src/resource-syncs/schedule-sync.js +1396 -0
  83. package/dist/src/resource-syncs/util.d.ts +22 -0
  84. package/dist/src/resource-syncs/util.js +118 -0
  85. package/dist/src/resource-target.d.ts +11 -0
  86. package/dist/src/resource-target.js +48 -0
  87. package/dist/src/runtime-view.d.ts +1 -0
  88. package/dist/src/runtime-view.js +6 -1
  89. package/dist/src/sync-output.d.ts +66 -0
  90. package/dist/src/sync-output.js +268 -0
  91. package/dist/src/tracked-resources.d.ts +1 -1
  92. package/dist/src/tracked-resources.js +28 -2
  93. package/dist/src/types.d.ts +227 -0
  94. package/dist/src/ui.d.ts +3 -0
  95. package/dist/src/ui.js +76 -18
  96. package/dist/src/utils.d.ts +4 -0
  97. package/dist/src/utils.js +81 -0
  98. package/dist/src/workspace-component.d.ts +2 -0
  99. package/dist/src/workspace-component.js +34 -0
  100. package/dist/src/workspace-diff.d.ts +25 -0
  101. package/dist/src/workspace-diff.js +75 -0
  102. package/dist/src/workspace-resource.d.ts +2 -0
  103. package/dist/src/workspace-resource.js +52 -0
  104. package/package.json +12 -4
@@ -0,0 +1,1046 @@
1
+ import path from 'node:path';
2
+ import { describeFieldChanges } from "../diff-details.js";
3
+ import { hashStable, readComponentLock, writeComponentLock } from "../component-lock.js";
4
+ import { NULL_CATEGORY_KEY, normalizeStableKeyValue, readConfiguredResourceMetadataStableKey, sanitizeUserMetadata } from "../resource-metadata.js";
5
+ import { readJsonFile, sanitizeSegment } from "../utils.js";
6
+ import { findManifestFiles, isRecord, localTargetPath, mapWithConcurrency, removeRelocatedManifest, requireProjectLayout, stableKeySuffix, toPortableRelativePath, unwrapData, writePulledManifest, } from "./util.js";
7
+ export const EVENTS_DIRECTORY = 'Events';
8
+ export const EVENT_MANIFEST_FILE = 'event.json';
9
+ const EVENT_TRANSPORT_FIELDS = new Set([
10
+ 'jobEventId', 'eventId', 'id', 'name', 'category', 'desc', 'description', 'active', 'type',
11
+ 'targetType', 'targetId', 'targetVersion', 'targetConfig', 'filter', 'version', 'metadata',
12
+ 'metaData', 'resourceMetadata', 'topic', 'custom', 'deletedAt', 'deletedBy', 'createdAt', 'createdBy',
13
+ 'lastUpdateAt', 'lastUpdateBy', 'updatedAt', 'updatedBy', 'history', 'jobEventHistory',
14
+ ]);
15
+ function eventIdOf(record) {
16
+ return String(record.jobEventId || record.eventId || record.id || '');
17
+ }
18
+ function jobTemplateIdOf(record) {
19
+ return String(record.jobTemplateId || record.id || '');
20
+ }
21
+ function canonicalValue(value) {
22
+ if (Array.isArray(value)) {
23
+ return value.map((item) => canonicalValue(item));
24
+ }
25
+ if (!isRecord(value)) {
26
+ return value;
27
+ }
28
+ return Object.fromEntries(Object.keys(value).sort((left, right) => left.localeCompare(right))
29
+ .map((key) => [key, canonicalValue(value[key])]));
30
+ }
31
+ function canonicalMetadata(record, stableKeyName, stableKey) {
32
+ return canonicalValue({
33
+ ...sanitizeUserMetadata(record.resourceMetadata),
34
+ ...sanitizeUserMetadata(record.metaData),
35
+ ...sanitizeUserMetadata(record.metadata),
36
+ [stableKeyName]: stableKey,
37
+ });
38
+ }
39
+ function extensionFields(record) {
40
+ return canonicalValue(Object.fromEntries(Object.entries(record)
41
+ .filter(([key, value]) => !EVENT_TRANSPORT_FIELDS.has(key) && value !== undefined)));
42
+ }
43
+ function eventExclusionReason(record) {
44
+ if (record.deletedAt || record.deletedBy) {
45
+ return 'deleted event is excluded';
46
+ }
47
+ if (record.targetType !== 'JOB_TEMPLATE') {
48
+ return `target type ${String(record.targetType || 'unknown')} is unsupported; only JOB_TEMPLATE is migrated`;
49
+ }
50
+ return undefined;
51
+ }
52
+ function eventPresentationKey(value) {
53
+ const category = typeof value.category === 'string' && value.category.trim()
54
+ ? value.category
55
+ : NULL_CATEGORY_KEY;
56
+ return normalizeStableKeyValue(`${category}/${String(value.name || '')}`);
57
+ }
58
+ export function eventManifestPath(workspaceRoot, manifest) {
59
+ const category = typeof manifest.category === 'string' && manifest.category.trim()
60
+ ? sanitizeSegment(manifest.category)
61
+ : 'Uncategorized';
62
+ return path.join(workspaceRoot, EVENTS_DIRECTORY, category, `${sanitizeSegment(manifest.name)}-${stableKeySuffix(manifest.stableKey)}`, EVENT_MANIFEST_FILE);
63
+ }
64
+ function portablePathIdentity(filePath) {
65
+ return path.resolve(filePath)
66
+ .normalize('NFC')
67
+ .split(path.sep)
68
+ .map((segment) => segment.replace(/[. ]+$/g, '').toLowerCase())
69
+ .join(path.sep);
70
+ }
71
+ function disambiguateManifestPath(filePath, stableKey) {
72
+ const directory = path.dirname(filePath);
73
+ return path.join(path.dirname(directory), `${path.basename(directory)}-${hashStable(stableKey).slice(0, 8)}`, path.basename(filePath));
74
+ }
75
+ function readWorkspaceEvents(cwd) {
76
+ const { workspaceRoot } = requireProjectLayout(cwd, 'Event');
77
+ return findManifestFiles(path.join(workspaceRoot, EVENTS_DIRECTORY), EVENT_MANIFEST_FILE).map((manifestPath) => ({
78
+ manifestPath,
79
+ manifest: readJsonFile(manifestPath),
80
+ }));
81
+ }
82
+ function nonEmptyString(value) {
83
+ return typeof value === 'string' && value.trim().length > 0;
84
+ }
85
+ function validManifest(value, stableKeyName) {
86
+ if (!isRecord(value) || value.kind !== 'event' || !nonEmptyString(value.stableKey) || !nonEmptyString(value.name)
87
+ || !nonEmptyString(value.type) || typeof value.custom !== 'boolean' || !isRecord(value.metadata) || !isRecord(value.target)) {
88
+ return false;
89
+ }
90
+ if (value.category !== undefined && value.category !== null && typeof value.category !== 'string') {
91
+ return false;
92
+ }
93
+ if (value.description !== undefined && typeof value.description !== 'string') {
94
+ return false;
95
+ }
96
+ if (typeof value.active !== 'boolean' || value.target.type !== 'JOB_TEMPLATE' || !nonEmptyString(value.target.jobTemplateStableKey)) {
97
+ return false;
98
+ }
99
+ if (value.filter !== undefined && value.filter !== null && !isRecord(value.filter)) {
100
+ return false;
101
+ }
102
+ if (value.extensions !== undefined && !isRecord(value.extensions)) {
103
+ return false;
104
+ }
105
+ if (value.extensions !== undefined && Object.keys(value.extensions).length > 0) {
106
+ return false;
107
+ }
108
+ return readConfiguredResourceMetadataStableKey(value, stableKeyName) === value.stableKey;
109
+ }
110
+ function manifestFromRecord(input) {
111
+ const { record, stableKey, jobTemplateStableKey, stableKeyName } = input;
112
+ if (typeof record.custom !== 'boolean') {
113
+ throw new Error(`Event "${stableKey}" is missing the custom classifier in the API response.`);
114
+ }
115
+ const extensions = extensionFields(record);
116
+ return {
117
+ kind: 'event',
118
+ stableKey,
119
+ name: String(record.name || ''),
120
+ ...(record.category === undefined ? {} : { category: record.category }),
121
+ ...(typeof record.desc === 'string' ? { description: record.desc } : typeof record.description === 'string' ? { description: record.description } : {}),
122
+ metadata: canonicalMetadata(record, stableKeyName, stableKey),
123
+ active: record.active === true,
124
+ custom: record.custom,
125
+ type: String(record.type || ''),
126
+ ...(record.filter === undefined ? {} : { filter: canonicalValue(record.filter) }),
127
+ target: { type: 'JOB_TEMPLATE', jobTemplateStableKey },
128
+ ...(Object.keys(extensions).length > 0 ? { extensions } : {}),
129
+ };
130
+ }
131
+ export function hashEventContent(manifest) {
132
+ return hashStable({
133
+ kind: 'event', stableKey: manifest.stableKey, name: manifest.name, category: manifest.category ?? null,
134
+ description: manifest.description ?? '', metadata: canonicalValue(manifest.metadata), custom: manifest.custom, type: manifest.type,
135
+ filter: canonicalValue(manifest.filter ?? null), target: manifest.target, extensions: canonicalValue(manifest.extensions || {}),
136
+ });
137
+ }
138
+ export function hashPortableEvent(manifest) {
139
+ return hashStable({ content: hashEventContent(manifest), active: manifest.active });
140
+ }
141
+ export function hashEventManifest(manifest) {
142
+ return hashStable(canonicalValue(manifest));
143
+ }
144
+ async function hydrate(records, idOf, get) {
145
+ return mapWithConcurrency(records, async (record) => {
146
+ const id = idOf(record);
147
+ return id ? unwrapData(await get(id)) : record;
148
+ });
149
+ }
150
+ async function loadRemoteEventInventory(client, stableKeyName) {
151
+ const [{ events: eventSummaries }, { jobTemplates: templateSummaries }] = await Promise.all([
152
+ client.listAllEvents({ includeDeleted: true }), client.listAllJobTemplates(),
153
+ ]);
154
+ const [events, jobTemplates] = await Promise.all([
155
+ hydrate(eventSummaries, eventIdOf, (id) => client.getEvent(id)),
156
+ hydrate(templateSummaries, jobTemplateIdOf, (id) => client.getJobTemplate(id)),
157
+ ]);
158
+ const eventsByStableKey = new Map();
159
+ const jobTemplatesByStableKey = new Map();
160
+ const jobTemplatesById = new Map();
161
+ for (const event of events) {
162
+ const stableKey = readConfiguredResourceMetadataStableKey(event, stableKeyName);
163
+ if (stableKey) {
164
+ eventsByStableKey.set(stableKey, [...(eventsByStableKey.get(stableKey) || []), event]);
165
+ }
166
+ }
167
+ for (const jobTemplate of jobTemplates) {
168
+ const id = jobTemplateIdOf(jobTemplate);
169
+ const stableKey = readConfiguredResourceMetadataStableKey(jobTemplate, stableKeyName);
170
+ if (id) {
171
+ jobTemplatesById.set(id, jobTemplate);
172
+ }
173
+ if (stableKey) {
174
+ jobTemplatesByStableKey.set(stableKey, [...(jobTemplatesByStableKey.get(stableKey) || []), jobTemplate]);
175
+ }
176
+ }
177
+ return { events, eventsByStableKey, jobTemplatesById, jobTemplatesByStableKey };
178
+ }
179
+ function emptyPlanCounts() {
180
+ return {
181
+ clean: 0,
182
+ create: 0,
183
+ 'safe-update': 0,
184
+ 'remote-changed': 0,
185
+ conflict: 0,
186
+ 'missing-lock': 0,
187
+ 'activation-drift': 0,
188
+ orphan: 0,
189
+ collision: 0,
190
+ skipped: 0,
191
+ };
192
+ }
193
+ function diffEvents(desired, current) {
194
+ const fields = [
195
+ ['name', desired.name, current.name],
196
+ ['category', desired.category ?? null, current.category ?? null],
197
+ ['description', desired.description ?? '', current.description ?? ''],
198
+ ['metadata', desired.metadata, current.metadata],
199
+ ['custom', desired.custom, current.custom],
200
+ ['type', desired.type, current.type],
201
+ ['filter', desired.filter ?? null, current.filter ?? null],
202
+ ['target.jobTemplateStableKey', desired.target.jobTemplateStableKey, current.target.jobTemplateStableKey],
203
+ ['extensions', desired.extensions || {}, current.extensions || {}],
204
+ ];
205
+ return fields
206
+ .filter(([, left, right]) => hashStable(left) !== hashStable(right))
207
+ .map(([field]) => field)
208
+ .sort();
209
+ }
210
+ function eventManifestFromTarget(record, templatesById, templatesByStableKey, stableKeyName) {
211
+ const stableKey = readConfiguredResourceMetadataStableKey(record, stableKeyName);
212
+ if (!stableKey) {
213
+ return { reason: `missing ${stableKeyName}; unmanaged` };
214
+ }
215
+ const exclusion = eventExclusionReason(record);
216
+ if (exclusion) {
217
+ return { stableKey, reason: exclusion };
218
+ }
219
+ const template = record.targetId ? templatesById.get(record.targetId) : undefined;
220
+ const jobTemplateStableKey = template
221
+ ? readConfiguredResourceMetadataStableKey(template, stableKeyName)
222
+ : undefined;
223
+ if (!jobTemplateStableKey) {
224
+ return { stableKey, reason: 'target Job Template dependency is missing stableKey or unavailable', dependencyBlocked: true };
225
+ }
226
+ const matchingTemplates = templatesByStableKey.get(jobTemplateStableKey) || [];
227
+ if (matchingTemplates.length !== 1) {
228
+ return {
229
+ stableKey,
230
+ reason: `target Job Template dependency "${jobTemplateStableKey}" is ambiguous`,
231
+ dependencyBlocked: true,
232
+ };
233
+ }
234
+ return { stableKey, manifest: manifestFromRecord({ record, stableKey, jobTemplateStableKey, stableKeyName }) };
235
+ }
236
+ export async function buildEventsPlan(input) {
237
+ const { projectRoot } = requireProjectLayout(input.cwd, 'Event');
238
+ const remote = await loadRemoteEventInventory(input.client, input.stableKeyName);
239
+ const targetEvents = remote.events;
240
+ const templatesById = remote.jobTemplatesById;
241
+ const templatesByStableKey = remote.jobTemplatesByStableKey;
242
+ const blockers = [];
243
+ const warnings = [];
244
+ const exclusions = [];
245
+ const items = [];
246
+ const projectedJobTemplatesByKey = input.projectedJobTemplates === undefined
247
+ ? undefined
248
+ : new Map();
249
+ for (const dependency of input.projectedJobTemplates || []) {
250
+ projectedJobTemplatesByKey?.set(dependency.stableKey, [
251
+ ...(projectedJobTemplatesByKey.get(dependency.stableKey) || []),
252
+ dependency,
253
+ ]);
254
+ }
255
+ const localByStableKey = new Map();
256
+ for (const entry of readWorkspaceEvents(input.cwd)) {
257
+ const manifest = entry.manifest;
258
+ if (!validManifest(manifest, input.stableKeyName)) {
259
+ const unsupportedExtensions = isRecord(manifest) && isRecord(manifest.extensions)
260
+ ? Object.keys(manifest.extensions).sort()
261
+ : [];
262
+ const reason = unsupportedExtensions.length > 0
263
+ ? `unsupported extension fields: ${unsupportedExtensions.join(', ')}`
264
+ : isRecord(manifest) && manifest.custom === undefined
265
+ ? 'missing custom classifier; re-pull the Event from its source or add custom: true/false explicitly'
266
+ : 'invalid manifest';
267
+ blockers.push(`Invalid Event manifest ${path.relative(projectRoot, entry.manifestPath)}: ${reason}.`);
268
+ items.push({ status: 'conflict', name: isRecord(manifest) && nonEmptyString(manifest.name) ? manifest.name : path.basename(entry.manifestPath), reason, blocked: true });
269
+ continue;
270
+ }
271
+ localByStableKey.set(manifest.stableKey, [...(localByStableKey.get(manifest.stableKey) || []), { manifest }]);
272
+ }
273
+ for (const [stableKey, localEvents] of localByStableKey) {
274
+ if (localEvents.length > 1) {
275
+ blockers.push(`Duplicate local Event stableKey "${stableKey}".`);
276
+ for (const local of localEvents) {
277
+ items.push({ status: 'collision', stableKey, name: local.manifest.name, reason: 'duplicate workspace stableKey', blocked: true });
278
+ }
279
+ }
280
+ }
281
+ const targetsByStableKey = new Map();
282
+ const targetIssuesByStableKey = new Map();
283
+ for (const record of targetEvents) {
284
+ const target = eventManifestFromTarget(record, templatesById, templatesByStableKey, input.stableKeyName);
285
+ if ('manifest' in target) {
286
+ const targetEvent = {
287
+ manifest: target.manifest,
288
+ hash: hashPortableEvent(target.manifest),
289
+ contentHash: hashEventContent(target.manifest),
290
+ };
291
+ targetsByStableKey.set(target.stableKey, [...(targetsByStableKey.get(target.stableKey) || []), targetEvent]);
292
+ continue;
293
+ }
294
+ const label = target.stableKey || String(record.name || eventIdOf(record) || 'unknown event');
295
+ if (target.dependencyBlocked) {
296
+ blockers.push(`Cannot plan Event "${label}": ${target.reason}.`);
297
+ items.push({ status: 'conflict', ...(target.stableKey ? { stableKey: target.stableKey } : {}), name: String(record.name || label), reason: target.reason, blocked: true });
298
+ }
299
+ else {
300
+ exclusions.push(`${label}: ${target.reason}`);
301
+ items.push({ status: 'skipped', ...(target.stableKey ? { stableKey: target.stableKey } : {}), name: String(record.name || label), reason: target.reason });
302
+ }
303
+ if (target.stableKey) {
304
+ targetIssuesByStableKey.set(target.stableKey, target.reason);
305
+ }
306
+ }
307
+ for (const [stableKey, targets] of targetsByStableKey) {
308
+ if (targets.length <= 1) {
309
+ continue;
310
+ }
311
+ blockers.push(`Duplicate target Event stableKey "${stableKey}".`);
312
+ for (const target of targets) {
313
+ items.push({
314
+ status: 'collision',
315
+ stableKey,
316
+ name: target.manifest.name,
317
+ currentHash: target.hash,
318
+ reason: 'duplicate target stableKey',
319
+ blocked: true,
320
+ });
321
+ }
322
+ }
323
+ const lock = readComponentLock(projectRoot);
324
+ const consumedTargets = new Set();
325
+ for (const [stableKey, localEvents] of localByStableKey) {
326
+ if (localEvents.length !== 1) {
327
+ continue;
328
+ }
329
+ const desired = localEvents[0].manifest;
330
+ const dependencyStableKey = desired.target.jobTemplateStableKey;
331
+ const liveTemplates = templatesByStableKey.get(dependencyStableKey) || [];
332
+ const usesProjection = projectedJobTemplatesByKey !== undefined;
333
+ const projectedTemplates = projectedJobTemplatesByKey?.get(dependencyStableKey) || [];
334
+ const templates = usesProjection ? projectedTemplates : liveTemplates;
335
+ if (templates.length !== 1) {
336
+ const reason = templates.length === 0
337
+ ? (usesProjection ? 'Job Template is missing from the projected source migration' : 'target Job Template is missing')
338
+ : (usesProjection ? 'Job Template dependency stableKey is ambiguous in the projected source migration' : 'target Job Template dependency stableKey is ambiguous');
339
+ blockers.push(`Cannot plan Event "${stableKey}": ${reason}.`);
340
+ items.push({
341
+ status: 'conflict',
342
+ stableKey,
343
+ name: desired.name,
344
+ reason,
345
+ jobTemplateStableKey: dependencyStableKey,
346
+ dependency: {
347
+ resource: 'job-template',
348
+ stableKey: dependencyStableKey,
349
+ expectedHash: null,
350
+ projectedHash: null,
351
+ actualHash: null,
352
+ readiness: 'blocked',
353
+ },
354
+ blocked: true,
355
+ });
356
+ continue;
357
+ }
358
+ const projectedDependency = usesProjection ? projectedTemplates[0] : undefined;
359
+ const dependencyReadiness = projectedDependency?.state === 'pending-create'
360
+ ? 'pending-job-template-create'
361
+ : projectedDependency?.state === 'pending-update'
362
+ ? 'pending-job-template-update'
363
+ : projectedDependency?.state === 'pending-adopt'
364
+ ? 'pending-job-template-adopt'
365
+ : 'ready';
366
+ const dependency = {
367
+ resource: 'job-template',
368
+ stableKey: dependencyStableKey,
369
+ expectedHash: projectedDependency?.desiredHash || null,
370
+ projectedHash: projectedDependency?.desiredHash || null,
371
+ actualHash: projectedDependency?.actualHash || null,
372
+ readiness: dependencyReadiness,
373
+ };
374
+ if (dependencyReadiness !== 'ready') {
375
+ warnings.push(`Event "${stableKey}" dependency "${dependencyStableKey}" is ${dependencyReadiness}; migration will resolve its verified target UUID after the Job Template phase.`);
376
+ }
377
+ const targets = targetsByStableKey.get(stableKey) || [];
378
+ const common = {
379
+ stableKey,
380
+ name: desired.name,
381
+ desiredHash: hashPortableEvent(desired),
382
+ jobTemplateStableKey: desired.target.jobTemplateStableKey,
383
+ dependency,
384
+ };
385
+ if (targets.length > 1) {
386
+ consumedTargets.add(stableKey);
387
+ continue;
388
+ }
389
+ if (targets.length === 0) {
390
+ const targetIssue = targetIssuesByStableKey.get(stableKey);
391
+ if (targetIssue) {
392
+ blockers.push(`Cannot plan Event "${stableKey}": ${targetIssue}.`);
393
+ items.push({ status: 'conflict', ...common, reason: targetIssue, blocked: true });
394
+ }
395
+ else if (targetEvents.some((record) => !record.deletedAt
396
+ && !record.deletedBy
397
+ && !readConfiguredResourceMetadataStableKey(record, input.stableKeyName)
398
+ && eventPresentationKey(record) === eventPresentationKey(desired))) {
399
+ const reason = `target Event matching category/name is missing ${input.stableKeyName}`;
400
+ blockers.push(`Cannot plan Event "${stableKey}": ${reason}.`);
401
+ items.push({ status: 'conflict', ...common, reason, blocked: true });
402
+ }
403
+ else {
404
+ items.push({ status: 'create', ...common });
405
+ }
406
+ continue;
407
+ }
408
+ consumedTargets.add(stableKey);
409
+ const current = targets[0];
410
+ const fieldChanges = describeFieldChanges(desired, current.manifest, diffEvents(desired, current.manifest));
411
+ const currentHash = current.hash;
412
+ const baselineHash = lock.events[stableKey]?.environments[input.envName]?.remoteHash;
413
+ const currentContentHash = current.contentHash;
414
+ const desiredContentHash = hashEventContent(desired);
415
+ if (desiredContentHash === currentContentHash && desired.active !== current.manifest.active) {
416
+ items.push({
417
+ status: 'activation-drift',
418
+ ...common,
419
+ changedFields: ['active'],
420
+ fieldChanges: describeFieldChanges(desired, current.manifest, ['active']),
421
+ currentHash,
422
+ baselineHash,
423
+ reason: `source active=${desired.active}; target active=${current.manifest.active}`,
424
+ });
425
+ }
426
+ else if (common.desiredHash === currentHash) {
427
+ items.push({ status: 'clean', ...common, currentHash, ...(baselineHash ? { baselineHash } : {}) });
428
+ }
429
+ else if (!baselineHash) {
430
+ items.push({ status: 'missing-lock', ...common, fieldChanges, currentHash, changedFields: diffEvents(desired, current.manifest), reason: `missing ${input.envName} lock baseline` });
431
+ }
432
+ else if (currentHash === baselineHash) {
433
+ items.push({ status: 'safe-update', ...common, fieldChanges, currentHash, baselineHash, changedFields: diffEvents(desired, current.manifest), reason: 'local manifest changed; target matches lock baseline' });
434
+ }
435
+ else if (common.desiredHash === baselineHash) {
436
+ items.push({ status: 'remote-changed', ...common, fieldChanges, currentHash, baselineHash, changedFields: diffEvents(desired, current.manifest), reason: 'target changed; local manifest matches lock baseline' });
437
+ }
438
+ else {
439
+ items.push({ status: 'conflict', ...common, fieldChanges, currentHash, baselineHash, changedFields: diffEvents(desired, current.manifest), reason: 'local manifest and target both changed since lock baseline' });
440
+ }
441
+ }
442
+ for (const [stableKey, targets] of targetsByStableKey) {
443
+ if (consumedTargets.has(stableKey) || localByStableKey.has(stableKey)) {
444
+ continue;
445
+ }
446
+ if (targets.length === 1) {
447
+ items.push({ status: 'orphan', stableKey, name: targets[0].manifest.name, currentHash: targets[0].hash, reason: 'target-only Event' });
448
+ }
449
+ }
450
+ const rank = {
451
+ create: 0,
452
+ 'safe-update': 1,
453
+ 'remote-changed': 2,
454
+ conflict: 3,
455
+ 'missing-lock': 4,
456
+ 'activation-drift': 5,
457
+ clean: 6,
458
+ orphan: 7,
459
+ collision: 8,
460
+ skipped: 9,
461
+ };
462
+ items.sort((left, right) => rank[left.status] - rank[right.status] || (left.stableKey || left.name).localeCompare(right.stableKey || right.name));
463
+ const counts = emptyPlanCounts();
464
+ for (const item of items) {
465
+ counts[item.status] += 1;
466
+ }
467
+ return {
468
+ resourceType: 'event',
469
+ env: input.envName,
470
+ counts,
471
+ blockers: [...new Set(blockers)].sort(),
472
+ warnings: [...new Set(warnings)].sort(),
473
+ items,
474
+ exclusions: [...new Set(exclusions)].sort(),
475
+ };
476
+ }
477
+ function buildEventCreatePayload(manifest, targetId) {
478
+ const extensions = writableEventExtensions(manifest.extensions);
479
+ return {
480
+ ...extensions,
481
+ name: manifest.name,
482
+ ...(manifest.category === undefined || manifest.category === null ? {} : { category: manifest.category }),
483
+ active: false,
484
+ ...(manifest.description === undefined ? {} : { desc: manifest.description }),
485
+ metadata: canonicalValue(manifest.metadata),
486
+ custom: manifest.custom,
487
+ type: manifest.type,
488
+ ...(manifest.filter === undefined ? {} : { filter: canonicalValue(manifest.filter) }),
489
+ targetType: 'JOB_TEMPLATE',
490
+ targetId,
491
+ };
492
+ }
493
+ function buildEventUpdatePayload(manifest, targetId, version) {
494
+ const extensions = writableEventExtensions(manifest.extensions);
495
+ return {
496
+ ...extensions,
497
+ name: manifest.name,
498
+ category: manifest.category ?? null,
499
+ desc: manifest.description ?? '',
500
+ metadata: canonicalValue(manifest.metadata),
501
+ custom: manifest.custom,
502
+ type: manifest.type,
503
+ filter: canonicalValue(manifest.filter ?? null),
504
+ targetType: 'JOB_TEMPLATE',
505
+ targetId,
506
+ version,
507
+ };
508
+ }
509
+ function writableEventExtensions(extensions) {
510
+ return canonicalValue(Object.fromEntries(Object.entries(extensions || {})
511
+ .filter(([key]) => !EVENT_TRANSPORT_FIELDS.has(key))));
512
+ }
513
+ function workspaceEventsByStableKey(cwd, stableKeyName) {
514
+ const events = new Map();
515
+ for (const entry of readWorkspaceEvents(cwd)) {
516
+ if (!validManifest(entry.manifest, stableKeyName)) {
517
+ continue;
518
+ }
519
+ events.set(entry.manifest.stableKey, { manifestPath: entry.manifestPath, manifest: entry.manifest });
520
+ }
521
+ return events;
522
+ }
523
+ function updateEventEnvironmentBaseline(input) {
524
+ const { projectRoot } = requireProjectLayout(input.cwd, 'Event');
525
+ const lock = readComponentLock(projectRoot);
526
+ const stableKey = input.manifest.stableKey;
527
+ const existingPair = Object.entries(lock.events).find(([, entry]) => entry.stableKey === stableKey);
528
+ const existing = existingPair?.[1];
529
+ if (existingPair && existingPair[0] !== stableKey) {
530
+ delete lock.events[existingPair[0]];
531
+ }
532
+ const previousBaseline = existing?.environments[input.envName];
533
+ lock.events[stableKey] = {
534
+ stableKey,
535
+ path: toPortableRelativePath(projectRoot, input.manifestPath),
536
+ sourceHash: hashEventManifest(input.manifest),
537
+ environments: {
538
+ ...(existing?.environments || {}),
539
+ [input.envName]: previousBaseline?.remoteHash === input.remoteHash
540
+ ? previousBaseline
541
+ : { remoteHash: input.remoteHash, syncedAt: new Date().toISOString() },
542
+ },
543
+ };
544
+ writeComponentLock(projectRoot, lock);
545
+ }
546
+ function eventPushError(error) {
547
+ return error instanceof Error ? error.message : String(error);
548
+ }
549
+ function assertEventsPushable(plan, force) {
550
+ if (plan.blockers.length > 0) {
551
+ throw new Error(`Event push blocked: ${plan.blockers.join(' ')}`);
552
+ }
553
+ const contentBlockers = plan.items.filter((item) => ['missing-lock', 'remote-changed', 'conflict'].includes(item.status));
554
+ if (contentBlockers.length > 0 && !force) {
555
+ const statuses = [...new Set(contentBlockers.map((item) => item.status))].sort().join(', ');
556
+ throw new Error(`Event push blocked by ${statuses}; review the plan and re-run with --force only to adopt or overwrite reviewed content drift.`);
557
+ }
558
+ }
559
+ async function resolveLiveEventWriteTarget(input) {
560
+ const remote = input.inventory || await loadRemoteEventInventory(input.client, input.stableKeyName);
561
+ const dependencies = remote.jobTemplatesByStableKey.get(input.manifest.target.jobTemplateStableKey) || [];
562
+ if (dependencies.length !== 1) {
563
+ const reason = dependencies.length === 0 ? 'is missing' : 'is ambiguous';
564
+ throw new Error(`target Job Template dependency "${input.manifest.target.jobTemplateStableKey}" ${reason}`);
565
+ }
566
+ const jobTemplateId = jobTemplateIdOf(dependencies[0]);
567
+ if (!jobTemplateId) {
568
+ throw new Error(`target Job Template dependency "${input.manifest.target.jobTemplateStableKey}" has no jobTemplateId`);
569
+ }
570
+ const matches = remote.eventsByStableKey.get(input.manifest.stableKey) || [];
571
+ if (input.action === 'create') {
572
+ if (matches.length > 0) {
573
+ throw new Error(`target Event "${input.manifest.stableKey}" appeared after planning`);
574
+ }
575
+ const nameMatches = remote.events.filter((event) => !event.deletedAt
576
+ && !event.deletedBy
577
+ && eventPresentationKey(event) === eventPresentationKey(input.manifest));
578
+ if (nameMatches.length > 0) {
579
+ throw new Error(`target Event matching category/name for "${input.manifest.stableKey}" appeared after planning`);
580
+ }
581
+ return { jobTemplateId };
582
+ }
583
+ if (matches.length !== 1) {
584
+ throw new Error(`expected one live target Event match, found ${matches.length}`);
585
+ }
586
+ const event = matches[0];
587
+ const exclusion = eventExclusionReason(event);
588
+ if (exclusion) {
589
+ throw new Error(`live target Event is excluded: ${exclusion}`);
590
+ }
591
+ const eventId = eventIdOf(event);
592
+ if (!eventId || typeof event.version !== 'number') {
593
+ throw new Error('live target Event did not include id and version');
594
+ }
595
+ const currentTemplate = event.targetId ? remote.jobTemplatesById.get(event.targetId) : undefined;
596
+ const currentTemplateStableKey = currentTemplate
597
+ ? readConfiguredResourceMetadataStableKey(currentTemplate, input.stableKeyName)
598
+ : undefined;
599
+ if (!currentTemplateStableKey) {
600
+ throw new Error('live target Event dependency is missing or unmanaged');
601
+ }
602
+ const currentManifest = manifestFromRecord({
603
+ record: event,
604
+ stableKey: input.manifest.stableKey,
605
+ jobTemplateStableKey: currentTemplateStableKey,
606
+ stableKeyName: input.stableKeyName,
607
+ });
608
+ return {
609
+ jobTemplateId,
610
+ event,
611
+ eventId,
612
+ currentHash: hashPortableEvent(currentManifest),
613
+ active: currentManifest.active,
614
+ };
615
+ }
616
+ async function verifyEventWrite(input) {
617
+ const event = unwrapData(await input.client.getEvent(input.eventId));
618
+ if (readConfiguredResourceMetadataStableKey(event, input.stableKeyName) !== input.manifest.stableKey) {
619
+ throw new Error(`verified Event is missing or changed ${input.stableKeyName}`);
620
+ }
621
+ if (event.targetType !== 'JOB_TEMPLATE' || event.targetId !== input.jobTemplateId) {
622
+ throw new Error('verified Event target does not match the live Job Template dependency');
623
+ }
624
+ let jobTemplate = input.jobTemplatesById?.get(input.jobTemplateId);
625
+ if (!jobTemplate) {
626
+ jobTemplate = unwrapData(await input.client.getJobTemplate(input.jobTemplateId));
627
+ input.jobTemplatesById?.set(input.jobTemplateId, jobTemplate);
628
+ }
629
+ if (readConfiguredResourceMetadataStableKey(jobTemplate, input.stableKeyName) !== input.manifest.target.jobTemplateStableKey) {
630
+ throw new Error('verified Event target Job Template does not match the desired stable key');
631
+ }
632
+ const verifiedManifest = manifestFromRecord({
633
+ record: event,
634
+ stableKey: input.manifest.stableKey,
635
+ jobTemplateStableKey: input.manifest.target.jobTemplateStableKey,
636
+ stableKeyName: input.stableKeyName,
637
+ });
638
+ if (hashEventContent(verifiedManifest) !== hashEventContent(input.manifest)) {
639
+ throw new Error('written Event did not match desired portable configuration');
640
+ }
641
+ if (verifiedManifest.active !== input.expectedActive) {
642
+ throw new Error('written Event did not preserve the expected target activation state');
643
+ }
644
+ return hashPortableEvent(verifiedManifest);
645
+ }
646
+ export async function pushEvents(input) {
647
+ const plan = await buildEventsPlan(input);
648
+ assertEventsPushable(plan, input.force === true);
649
+ const localByKey = workspaceEventsByStableKey(input.cwd, input.stableKeyName);
650
+ const results = [];
651
+ const verifiedActivationCandidates = [];
652
+ const writeCandidates = plan.items.filter((item) => (item.status === 'create'
653
+ || item.status === 'safe-update'
654
+ || item.status === 'activation-drift'
655
+ || (input.force === true && ['missing-lock', 'remote-changed', 'conflict'].includes(item.status))));
656
+ const liveInventory = writeCandidates.length > 0
657
+ ? await loadRemoteEventInventory(input.client, input.stableKeyName)
658
+ : undefined;
659
+ const processWrite = async (item, action) => {
660
+ const stableKey = item.stableKey || '';
661
+ const local = localByKey.get(stableKey);
662
+ const targetPath = local ? localTargetPath(input.cwd, local.manifestPath) : stableKey;
663
+ try {
664
+ if (!local) {
665
+ throw new Error('desired manifest disappeared after planning');
666
+ }
667
+ if (hashPortableEvent(local.manifest) !== item.desiredHash) {
668
+ throw new Error('desired manifest changed after planning');
669
+ }
670
+ const live = await resolveLiveEventWriteTarget({
671
+ client: input.client,
672
+ stableKeyName: input.stableKeyName,
673
+ manifest: local.manifest,
674
+ action,
675
+ inventory: liveInventory,
676
+ });
677
+ let eventId;
678
+ let expectedActive;
679
+ if (action === 'create') {
680
+ const created = unwrapData(await input.client.createEvent(buildEventCreatePayload(local.manifest, live.jobTemplateId)));
681
+ eventId = eventIdOf(created);
682
+ if (!eventId) {
683
+ const freshInventory = await loadRemoteEventInventory(input.client, input.stableKeyName);
684
+ const resolvedCreated = await resolveLiveEventWriteTarget({
685
+ client: input.client,
686
+ stableKeyName: input.stableKeyName,
687
+ manifest: local.manifest,
688
+ action: 'update',
689
+ inventory: freshInventory,
690
+ });
691
+ if (!resolvedCreated.eventId) {
692
+ throw new Error('created Event could not be resolved by stableKey');
693
+ }
694
+ eventId = resolvedCreated.eventId;
695
+ }
696
+ else if (liveInventory) {
697
+ liveInventory.events.push(created);
698
+ liveInventory.eventsByStableKey.set(local.manifest.stableKey, [created]);
699
+ }
700
+ expectedActive = false;
701
+ }
702
+ else {
703
+ if (!live.eventId || !live.event || typeof live.event.version !== 'number' || live.active === undefined) {
704
+ throw new Error('live target Event did not include id, version, and activation state');
705
+ }
706
+ if (live.currentHash !== item.currentHash) {
707
+ throw new Error('target Event changed after planning');
708
+ }
709
+ await input.client.updateEvent(live.eventId, buildEventUpdatePayload(local.manifest, live.jobTemplateId, live.event.version));
710
+ eventId = live.eventId;
711
+ expectedActive = live.active;
712
+ }
713
+ const remoteHash = await verifyEventWrite({
714
+ client: input.client,
715
+ stableKeyName: input.stableKeyName,
716
+ manifest: local.manifest,
717
+ eventId,
718
+ jobTemplateId: live.jobTemplateId,
719
+ expectedActive,
720
+ jobTemplatesById: liveInventory?.jobTemplatesById,
721
+ });
722
+ updateEventEnvironmentBaseline({
723
+ cwd: input.cwd,
724
+ envName: input.envName,
725
+ manifest: local.manifest,
726
+ manifestPath: local.manifestPath,
727
+ remoteHash,
728
+ });
729
+ results.push({ stableKey, action, status: 'deployed', targetPath });
730
+ if (local.manifest.active !== expectedActive) {
731
+ verifiedActivationCandidates.push({
732
+ stableKey,
733
+ eventId,
734
+ targetPath,
735
+ manifestPath: local.manifestPath,
736
+ manifest: local.manifest,
737
+ stableKeyName: input.stableKeyName,
738
+ cwd: input.cwd,
739
+ envName: input.envName,
740
+ });
741
+ }
742
+ }
743
+ catch (error) {
744
+ results.push({ stableKey, action, status: 'failed', targetPath, error: eventPushError(error) });
745
+ }
746
+ };
747
+ for (const item of plan.items.filter((candidate) => candidate.status === 'create')) {
748
+ await processWrite(item, 'create');
749
+ }
750
+ for (const item of plan.items.filter((candidate) => (candidate.status === 'safe-update'
751
+ || (input.force === true && ['missing-lock', 'remote-changed', 'conflict'].includes(candidate.status))))) {
752
+ await processWrite(item, 'update');
753
+ }
754
+ for (const item of plan.items.filter((candidate) => candidate.status === 'clean')) {
755
+ const local = item.stableKey ? localByKey.get(item.stableKey) : undefined;
756
+ if (local && item.currentHash) {
757
+ updateEventEnvironmentBaseline({
758
+ cwd: input.cwd,
759
+ envName: input.envName,
760
+ manifest: local.manifest,
761
+ manifestPath: local.manifestPath,
762
+ remoteHash: item.currentHash,
763
+ });
764
+ }
765
+ results.push({
766
+ stableKey: item.stableKey || item.name,
767
+ action: 'noop',
768
+ status: 'skipped',
769
+ targetPath: local ? localTargetPath(input.cwd, local.manifestPath) : item.stableKey || item.name,
770
+ reason: 'no local changes',
771
+ });
772
+ }
773
+ for (const item of plan.items.filter((candidate) => candidate.status === 'activation-drift')) {
774
+ const local = item.stableKey ? localByKey.get(item.stableKey) : undefined;
775
+ if (local) {
776
+ try {
777
+ const live = await resolveLiveEventWriteTarget({
778
+ client: input.client,
779
+ stableKeyName: input.stableKeyName,
780
+ manifest: local.manifest,
781
+ action: 'update',
782
+ inventory: liveInventory,
783
+ });
784
+ if (!live.eventId || live.active === undefined) {
785
+ throw new Error('live target Event did not include id and activation state');
786
+ }
787
+ if (live.currentHash !== item.currentHash) {
788
+ throw new Error('target Event changed after planning');
789
+ }
790
+ if (live.active !== local.manifest.active) {
791
+ verifiedActivationCandidates.push({
792
+ stableKey: local.manifest.stableKey,
793
+ eventId: live.eventId,
794
+ targetPath: localTargetPath(input.cwd, local.manifestPath),
795
+ manifestPath: local.manifestPath,
796
+ manifest: local.manifest,
797
+ stableKeyName: input.stableKeyName,
798
+ cwd: input.cwd,
799
+ envName: input.envName,
800
+ });
801
+ }
802
+ }
803
+ catch (error) {
804
+ results.push({
805
+ stableKey: item.stableKey || item.name,
806
+ action: 'noop',
807
+ status: 'failed',
808
+ targetPath: localTargetPath(input.cwd, local.manifestPath),
809
+ error: eventPushError(error),
810
+ });
811
+ continue;
812
+ }
813
+ }
814
+ results.push({
815
+ stableKey: item.stableKey || item.name,
816
+ action: 'noop',
817
+ status: 'skipped',
818
+ targetPath: local ? localTargetPath(input.cwd, local.manifestPath) : item.stableKey || item.name,
819
+ reason: 'activation differs; re-run with --activate to align it with source',
820
+ });
821
+ }
822
+ for (const item of plan.items.filter((candidate) => candidate.status === 'orphan')) {
823
+ results.push({ stableKey: item.stableKey || item.name, action: 'orphan', status: 'skipped', targetPath: item.stableKey || item.name, reason: 'target-only orphan' });
824
+ }
825
+ for (const item of plan.items.filter((candidate) => candidate.status === 'skipped')) {
826
+ results.push({ stableKey: item.stableKey || item.name, action: 'skipped', status: 'skipped', targetPath: item.stableKey || item.name, reason: item.reason || 'unmanaged' });
827
+ }
828
+ return { plan, results, verifiedActivationCandidates };
829
+ }
830
+ export async function activateVerifiedEvents(input) {
831
+ const results = [];
832
+ const jobTemplatesCache = new Map();
833
+ for (const candidate of input.candidates) {
834
+ const action = candidate.manifest.active ? 'activate' : 'disable';
835
+ try {
836
+ const current = unwrapData(await input.client.getEvent(candidate.eventId));
837
+ if (readConfiguredResourceMetadataStableKey(current, candidate.stableKeyName) !== candidate.stableKey) {
838
+ throw new Error('target Event stable key changed after activation preflight');
839
+ }
840
+ if (current.active === candidate.manifest.active) {
841
+ results.push({
842
+ stableKey: candidate.stableKey,
843
+ action,
844
+ status: 'skipped',
845
+ targetPath: candidate.targetPath,
846
+ reason: 'already aligned',
847
+ });
848
+ continue;
849
+ }
850
+ if (candidate.manifest.active) {
851
+ await input.client.activateEvent(candidate.eventId);
852
+ }
853
+ else {
854
+ await input.client.disableEvent(candidate.eventId);
855
+ }
856
+ const remoteHash = await verifyEventWrite({
857
+ client: input.client,
858
+ stableKeyName: candidate.stableKeyName,
859
+ manifest: candidate.manifest,
860
+ eventId: candidate.eventId,
861
+ jobTemplateId: String(current.targetId || ''),
862
+ expectedActive: candidate.manifest.active,
863
+ jobTemplatesById: jobTemplatesCache,
864
+ });
865
+ updateEventEnvironmentBaseline({
866
+ cwd: candidate.cwd,
867
+ envName: candidate.envName,
868
+ manifest: candidate.manifest,
869
+ manifestPath: candidate.manifestPath,
870
+ remoteHash,
871
+ });
872
+ results.push({
873
+ stableKey: candidate.stableKey,
874
+ action,
875
+ status: 'deployed',
876
+ targetPath: candidate.targetPath,
877
+ });
878
+ }
879
+ catch (error) {
880
+ results.push({
881
+ stableKey: candidate.stableKey,
882
+ action,
883
+ status: 'failed',
884
+ targetPath: candidate.targetPath,
885
+ error: eventPushError(error),
886
+ });
887
+ }
888
+ }
889
+ return results;
890
+ }
891
+ export async function pullEventsToWorkspace(input) {
892
+ const { projectRoot, workspaceRoot } = requireProjectLayout(input.cwd, 'Event');
893
+ const [{ events: summaries }, { jobTemplates: templateSummaries }] = await Promise.all([
894
+ input.client.listAllEvents({ includeDeleted: true }), input.client.listAllJobTemplates(),
895
+ ]);
896
+ const [events, templates] = await Promise.all([
897
+ hydrate(summaries, eventIdOf, (id) => input.client.getEvent(id)),
898
+ hydrate(templateSummaries, jobTemplateIdOf, (id) => input.client.getJobTemplate(id)),
899
+ ]);
900
+ const templatesById = new Map(templates.map((template) => [jobTemplateIdOf(template), template]));
901
+ const manifests = [];
902
+ const warnings = [];
903
+ const seen = new Set();
904
+ for (const record of events) {
905
+ const stableKey = readConfiguredResourceMetadataStableKey(record, input.stableKeyName);
906
+ const label = stableKey || String(record.name || eventIdOf(record) || 'unknown event');
907
+ const exclusion = eventExclusionReason(record);
908
+ if (exclusion) {
909
+ warnings.push({ stableKey: label, reason: exclusion });
910
+ continue;
911
+ }
912
+ if (!stableKey) {
913
+ warnings.push({ stableKey: label, reason: `missing ${input.stableKeyName}; unmanaged` });
914
+ continue;
915
+ }
916
+ const target = record.targetId ? templatesById.get(record.targetId) : undefined;
917
+ const jobTemplateStableKey = target ? readConfiguredResourceMetadataStableKey(target, input.stableKeyName) : undefined;
918
+ if (!jobTemplateStableKey) {
919
+ warnings.push({ stableKey, reason: 'target Job Template dependency is missing stableKey' });
920
+ continue;
921
+ }
922
+ if (seen.has(stableKey)) {
923
+ throw new Error(`Duplicate Event stableKey "${stableKey}" on source; no files were changed.`);
924
+ }
925
+ seen.add(stableKey);
926
+ const manifest = manifestFromRecord({ record, stableKey, jobTemplateStableKey, stableKeyName: input.stableKeyName });
927
+ manifests.push(manifest);
928
+ }
929
+ manifests.sort((left, right) => left.stableKey.localeCompare(right.stableKey));
930
+ warnings.sort((left, right) => left.stableKey.localeCompare(right.stableKey) || left.reason.localeCompare(right.reason));
931
+ const lock = readComponentLock(projectRoot);
932
+ const existingByKey = new Map();
933
+ const existingByPath = new Map();
934
+ for (const entry of readWorkspaceEvents(input.cwd)) {
935
+ const manifest = entry.manifest;
936
+ const legacyWithoutCustom = isRecord(manifest) && manifest.custom === undefined
937
+ && validManifest({ ...manifest, custom: false }, input.stableKeyName);
938
+ if (!validManifest(manifest, input.stableKeyName) && !legacyWithoutCustom) {
939
+ throw new Error(`Cannot pull over invalid Event manifest ${path.relative(projectRoot, entry.manifestPath)}.`);
940
+ }
941
+ const existingManifest = manifest;
942
+ if (existingByKey.has(existingManifest.stableKey)) {
943
+ throw new Error(`Duplicate local Event stableKey "${existingManifest.stableKey}"; no files were changed.`);
944
+ }
945
+ const localEntry = { manifestPath: entry.manifestPath, manifest: existingManifest };
946
+ existingByKey.set(existingManifest.stableKey, localEntry);
947
+ const pathIdentity = portablePathIdentity(entry.manifestPath);
948
+ existingByPath.set(pathIdentity, [...(existingByPath.get(pathIdentity) || []), localEntry]);
949
+ }
950
+ const writes = manifests.map((manifest) => {
951
+ const sourceHash = hashEventManifest(manifest);
952
+ const remoteHash = hashPortableEvent(manifest);
953
+ const existing = existingByKey.get(manifest.stableKey);
954
+ if (existing && !input.force) {
955
+ const localHash = hashEventManifest(existing.manifest);
956
+ const baseline = lock.events[manifest.stableKey];
957
+ if (localHash !== sourceHash && (!baseline || localHash !== baseline.sourceHash)) {
958
+ throw new Error(`Cannot pull Event "${manifest.stableKey}": local manifest changed since the lock baseline. Re-run with --force to overwrite.`);
959
+ }
960
+ }
961
+ return {
962
+ manifest,
963
+ sourceHash,
964
+ remoteHash,
965
+ targetPath: eventManifestPath(workspaceRoot, manifest),
966
+ previousPath: existing?.manifestPath,
967
+ };
968
+ });
969
+ const sourceStableKeys = new Set(manifests.map((manifest) => manifest.stableKey));
970
+ const pruned = input.pruneOrphans === true
971
+ ? [...existingByKey.values()]
972
+ .filter((entry) => !sourceStableKeys.has(entry.manifest.stableKey))
973
+ .map((entry) => ({
974
+ stableKey: entry.manifest.stableKey,
975
+ targetPath: localTargetPath(input.cwd, entry.manifestPath),
976
+ manifestPath: entry.manifestPath,
977
+ }))
978
+ .sort((left, right) => right.manifestPath.length - left.manifestPath.length || left.stableKey.localeCompare(right.stableKey))
979
+ : [];
980
+ const candidatePathCounts = new Map();
981
+ for (const write of writes) {
982
+ const pathIdentity = portablePathIdentity(write.targetPath);
983
+ candidatePathCounts.set(pathIdentity, (candidatePathCounts.get(pathIdentity) || 0) + 1);
984
+ }
985
+ for (const write of writes) {
986
+ if ((candidatePathCounts.get(portablePathIdentity(write.targetPath)) || 0) > 1) {
987
+ write.targetPath = disambiguateManifestPath(write.targetPath, write.manifest.stableKey);
988
+ }
989
+ }
990
+ const paths = new Set();
991
+ for (const write of writes) {
992
+ const pathIdentity = portablePathIdentity(write.targetPath);
993
+ if (paths.has(pathIdentity)) {
994
+ throw new Error('Multiple Events resolve to the same workspace path; no files were changed.');
995
+ }
996
+ paths.add(pathIdentity);
997
+ const pathOwner = (existingByPath.get(pathIdentity) || [])
998
+ .find((entry) => entry.manifest.stableKey !== write.manifest.stableKey);
999
+ if (pathOwner) {
1000
+ throw new Error(`Event workspace path "${path.relative(projectRoot, write.targetPath)}" is occupied by different stableKey "${pathOwner.manifest.stableKey}"; no files were changed.`);
1001
+ }
1002
+ }
1003
+ const root = path.join(workspaceRoot, EVENTS_DIRECTORY);
1004
+ let lockChanged = false;
1005
+ for (const item of pruned) {
1006
+ removeRelocatedManifest(item.manifestPath, root);
1007
+ if (lock.events[item.stableKey]) {
1008
+ delete lock.events[item.stableKey];
1009
+ lockChanged = true;
1010
+ }
1011
+ }
1012
+ for (const write of writes) {
1013
+ writePulledManifest({
1014
+ filePath: write.targetPath,
1015
+ manifest: write.manifest,
1016
+ previousPath: write.previousPath,
1017
+ root: root,
1018
+ force: input.force,
1019
+ });
1020
+ const previous = lock.events[write.manifest.stableKey];
1021
+ const previousBaseline = previous?.environments[input.envName];
1022
+ const entry = {
1023
+ stableKey: write.manifest.stableKey,
1024
+ path: toPortableRelativePath(projectRoot, write.targetPath),
1025
+ sourceHash: write.sourceHash,
1026
+ environments: {
1027
+ ...(previous?.environments || {}),
1028
+ [input.envName]: previousBaseline?.remoteHash === write.remoteHash
1029
+ ? previousBaseline
1030
+ : { remoteHash: write.remoteHash, syncedAt: new Date().toISOString() },
1031
+ },
1032
+ };
1033
+ if (!previous || hashStable(previous) !== hashStable(entry)) {
1034
+ lockChanged = true;
1035
+ }
1036
+ lock.events[write.manifest.stableKey] = entry;
1037
+ }
1038
+ if (lockChanged) {
1039
+ writeComponentLock(projectRoot, lock);
1040
+ }
1041
+ return {
1042
+ pulled: writes.map((write) => ({ manifest: write.manifest, targetPath: localTargetPath(input.cwd, write.targetPath) })),
1043
+ pruned: pruned.map(({ stableKey, targetPath }) => ({ stableKey, targetPath })),
1044
+ warnings,
1045
+ };
1046
+ }