@pixlcore/xycli 1.0.0 → 1.0.2

package/lib/sync.js

@@ -30,6 +30,11 @@ module.exports = {
 		// xy sync --up "events,plugins" --delete plugins
 		await this.getMultiple();
 		
+		// Both ordinary sync and setup completion commands report failures through
+		// the shared warning and error collectors.
+		this.warnings = [];
+		this.errors = [];
+		
 		// optionally setup local filesystem for sync
 		if (this.args.other && (this.args.other[0] === 'setup')) {
 			this.args.other.shift();
@@ -72,9 +77,6 @@ module.exports = {
 			this.die("Delete mode requires up-only sync. Enable --up and disable --down.");
 		}
 		
-		this.warnings = [];
-		this.errors = [];
-		
 		// scan all base directories, default to cwd
 		var files = [];
 		if (!this.args.other || !this.args.other.length) {
@@ -353,6 +355,14 @@ module.exports = {
 		// update state db
 		await this.syncState(state);
 		
+		// Deletion is the destructive final phase, so only begin it after every
+		// update and the sync-state write completed cleanly.  Earlier successful
+		// updates are intentionally left in place and will compare equal on retry.
+		if (sconfig.delete && (this.errors.length || this.warnings.length)) {
+			this.logSyncWarning("Delete pass skipped because the sync encountered earlier warnings or errors.");
+			return await this.completeSync();
+		}
+		
 		// now handle deletes
 		if (!sconfig.delete) return await this.completeSync();
 		
@@ -627,17 +637,19 @@ module.exports = {
 		} // run_event
 	},
 	
-	syncFinishCmd(cmd) {
+	syncFinishCmd(cmd, opts) {
 		// spawn command and log output
-		var sconfig = this.sconfig;
-		var cwd = this.args.other[0]; // use first base dir as cwd for shell commands
+		opts = opts || {};
+		var sconfig = this.sconfig || {};
+		var cwd = opts.cwd || this.args.other[0]; // default to first normal sync base dir
+		var cmd_timeout = opts.cmd_timeout || sconfig.cmd_timeout || 30;
 		
 		println( "\n " + green.bold("Running completion command: ") + cyan.bold(cmd) );
 		
 		try {
 			const output = cp.execSync(cmd, {
 				cwd: cwd,
-				timeout: (sconfig.cmd_timeout || 30) * 1000,
+				timeout: cmd_timeout * 1000,
 				encoding: 'utf8',
 				stdio: ['ignore', 'pipe', 'pipe']
 			});
@@ -724,12 +736,8 @@ module.exports = {
 	async setupSync() {
 		// export select resources to local XYPDF files in suggested layout
 		// xy sync --setup all --file_props "script,params.script"
+		// xy sync --setup events --new
 		// xy sync --setup all --marketplace --stock --force
-		var data_types = this.config.ui.data_types;
-		var list_data_types = Object.keys(data_types).map( key => {
-			return { ...data_types[key], id: key };
-		} );
-		
 		if ((this.args.setup === 'all') || (this.args.setup[0] === 'all')) {
 			this.args.setup = this.config.ui.list_list.map( list => list.id ).filter( id => !id.match(/^(buckets|secrets|users|roles)$/) );
 		}
@@ -752,87 +760,279 @@ module.exports = {
 			if (!Array.isArray(this.args.file_props)) this.dieUsage('sync setup');
 		}
 		
+		// New-only setup is intentionally an additive operation.  It must never be
+		// combined with the overwrite behavior of --force.
+		var new_only = false;
+		if (this.args.new !== undefined) {
+			if ((this.args.new !== true) && (this.args.new !== false)) {
+				this.die("Invalid --new value (use --new or --new false).");
+			}
+			new_only = this.args.new;
+		}
+		if (new_only && this.args.force) this.die("Sync setup --new cannot be combined with --force.");
+		
+		var default_ext = this.normalizeSyncDefaultExt(this.args.default_ext);
+		var existing_keys = new_only ? this.scanSyncSourceIndex(['.']) : {};
+		
 		this.printBoxList({
 			title: 'Sync Setup',
 			rows: [
 				['Item Types', this.args.setup.join(', ')],
 				['File Props', this.args.file_props ? this.args.file_props.join(', ') : '(None)'],
+				['Default Ext', '.' + default_ext],
+				new_only ? ['New Only', 'Yes'] : null,
 				this.dry ? ['Dry Run', 'No changes will be made.'] : null
 			]
 		});
 		
 		println( "\n " + this.color('theme').bold("WRITING FILES:") );
 		
-		// split up workflows into their own folder
-		if (this.args.setup.includes('events')) {
-			this.workflows = this.events.filter( event => event.type == 'workflow' );
-			this.events = this.events.filter( event => event.type != 'workflow' );
-			this.args.setup.push('workflows');
-			list_data_types.push( { id: "event", "list": "workflows" } );
+		var result = this.writeSyncSetupFiles(this.args.setup, {
+			base_dir: '.',
+			existing_keys: existing_keys,
+			new_only: new_only,
+			file_props: this.args.file_props || [],
+			default_ext: default_ext,
+			stock: !!this.args.stock,
+			marketplace: !!this.args.marketplace,
+			force: !!this.args.force,
+			dry: !!this.dry
+		});
+		
+		if (new_only && !result.written) println( "\n " + gray("No new definitions found.") );
+		
+		println( "\n " + this.color('theme').bold("Setup complete!") );
+		
+		// Setup writes into the current directory, not a positional base directory.
+		// Only run an explicitly supplied down command after real files were written.
+		if (!this.dry && result.written && this.args.down_cmd) {
+			this.syncFinishCmd(this.args.down_cmd, {
+				cwd: '.',
+				cmd_timeout: this.args.cmd_timeout
+			});
+		}
+	},
+	
+	normalizeSyncDefaultExt(value) {
+		// Allow users to choose the fallback extension for extracted properties whose
+		// language cannot be detected.  A leading dot is accepted for convenience,
+		// but paths and compound values are rejected before any files are written.
+		if (value === undefined) return 'txt';
+		if (typeof(value) != 'string') {
+			this.die("Invalid --default_ext value (use a filename extension such as ps1 or .ps1).");
+		}
+		
+		var ext = value.trim().replace(/^\./, '');
+		if (!ext.match(/^[A-Za-z0-9][A-Za-z0-9_]*$/)) {
+			this.die("Invalid --default_ext value (use a filename extension such as ps1 or .ps1).");
 		}
+		return ext;
+	},
+	
+	scanSyncSourceIndex(base_dirs) {
+		// Build an identity index from an existing sync tree.  Filenames and folders
+		// are deliberately ignored, because sync sources may be freely reorganized.
+		var files = [];
+		base_dirs.forEach( dir => {
+			dir = Path.normalize(dir).replace(/[\\/]+$/, '') || '.';
+			if (!fs.existsSync(dir)) this.die("Sync base dir does not exist: " + dir);
+			files = files.concat( Tools.findFilesSync(dir, { stats: true }) );
+		});
 		
-		this.args.setup.forEach( (list_name) => {
-			var list = this[list_name];
-			if (!list || !list.length) return;
+		var index = {};
+		files.filter( file => !!file.path.match(/\.json$/i) ).forEach( file => {
+			var xypdf = null;
+			try { xypdf = Tools.parseJSON( fs.readFileSync(file.path, 'utf8') ); }
+			catch (err) { this.die("Failed to parse JSON file: " + file.path + ": " + err); }
 			
-			var type_def = Tools.findObject( list_data_types, { list: list_name } );
-			if (!type_def) return; // sanity
+			// Ordinary JSON files are unrelated and may coexist in the tree.
+			if (!xypdf || !Tools.isaHash(xypdf) || (xypdf.type !== 'xypdf')) return;
+			if (xypdf.version !== '1.0') this.die("File is not a compatible version of XYPDF: " + file.path);
+			if (xypdf.xyops !== undefined && this.compareVersions(xypdf.xyops, this.xyopsVersion) > 0) {
+				this.die("Item requires xyOps v" + xypdf.xyops + " or higher: " + file.path);
+			}
+			if (!Array.isArray(xypdf.items) || (xypdf.items.length !== 1)) {
+				this.die("Sync source must contain exactly one item: " + file.path);
+			}
 			
-			if (!this.dry) Tools.mkdirp.sync( list_name );
-			println( "\n " + cli.emoji('📂') + " " + bold.cyan(list_name + '/') );
+			var item = xypdf.items[0];
+			if (!item || !Tools.isaHash(item) || !item.type || (typeof(item.type) != 'string')) {
+				this.die("Malformed item type in file: " + file.path);
+			}
+			if (item.type.match(/^(bucket|secret|user|role)$/)) {
+				this.die("Unsupported item type: " + item.type + " in file: " + file.path);
+			}
+			if (!item.data || !Tools.isaHash(item.data) || !item.data.id || (typeof(item.data.id) != 'string')) {
+				this.die("Malformed or missing item data or ID in file: " + file.path);
+			}
 			
-			list.forEach( (item) => {
-				// exclude marketplace and stock items
-				if (item.marketplace && !this.args.marketplace) return;
-				if (item.stock && !this.args.stock) return;
+			var type_def = this.config.ui.data_types[item.type];
+			if (!type_def) this.die("Cannot locate internal type definition: " + item.type);
+			var list = this[type_def.list];
+			if (!list) this.die("Cannot locate internal list: " + type_def.list);
+			if (!Tools.findObject(list, { id: item.data.id })) {
+				this.die("Cannot find " + item.type + " in xyOps: " + (item.data.title || item.data.id) + " (" + item.data.id + ")");
+			}
+			
+			var key = item.type + '-' + item.data.id;
+			if (index[key]) {
+				this.die("Duplicate source item found: " + file.path + " (already found in " + index[key].file + ")");
+			}
+			index[key] = { file: file.path, item: item };
+		});
+		
+		return index;
+	},
+	
+	writeSyncSetupFiles(list_names, opts = {}) {
+		// Write selected remote definitions using setup's suggested layout.  Keeping
+		// this operation separate allows a future downsync to append newly discovered
+		// remote definitions after it finishes updating existing local sources.
+		var data_types = this.config.ui.data_types;
+		var list_data_types = Object.keys(data_types).map( key => {
+			return { ...data_types[key], id: key };
+		});
+		var targets = [];
+		
+		list_names.forEach( list_name => {
+			if (list_name == 'events') {
+				targets.push({ name: 'events', type: 'event', items: this.events.filter( event => event.type != 'workflow' ) });
+				targets.push({ name: 'workflows', type: 'event', items: this.events.filter( event => event.type == 'workflow' ) });
+				return;
+			}
+			
+			var type_def = Tools.findObject( list_data_types, { list: list_name } );
+			if (type_def) targets.push({ name: list_name, type: type_def.id, items: this[list_name] || [] });
+		});
+		
+		var result = { written: 0, skipped: 0 };
+		var existing_keys = opts.existing_keys || {};
+		var base_dir = opts.base_dir || '.';
+		var default_ext = this.normalizeSyncDefaultExt(opts.default_ext);
+		
+		// Build and validate the complete write plan before creating any directories.
+		// Events and workflows are grouped under their xyOps Category titles.  A
+		// missing Category indicates inconsistent remote data, so setup must stop
+		// without leaving behind a partially generated tree.
+		targets.forEach( target => {
+			var items = target.items.filter( item => {
+				if (item.marketplace && !opts.marketplace) return false;
+				if (item.stock && !opts.stock) return false;
+				if (opts.new_only && existing_keys[target.type + '-' + item.id]) {
+					result.skipped++;
+					return false;
+				}
+				return true;
+			});
+			
+			target.plans = items.map( source_item => {
+				var dir = Path.join(base_dir, target.name);
+				var display_dir = target.name + '/';
 				
-				// extract extras first
+				if (target.type == 'event') {
+					var category = Tools.findObject( this.categories, { id: source_item.category } );
+					if (!category) {
+						this.die("Cannot find Category for " + (source_item.type == 'workflow' ? 'workflow' : 'Event') + ": " + (source_item.title || source_item.id) + " (" + (source_item.category || 'missing ID') + ")");
+					}
+					
+					var category_slug = this.getSyncSetupTitleSlug(category.title, 'Category', category.id);
+					dir = Path.join(dir, category_slug);
+					display_dir += category_slug + '/';
+				}
+				
+				var title = this.getSyncSetupTitleSlug(source_item.title, (source_item.type == 'workflow' ? 'workflow' : target.type), source_item.id);
+				return { source_item, title, dir, display_dir };
+			});
+			
+			// Remote Event order is not guaranteed to keep Categories together. Group
+			// plans explicitly so each printed folder heading owns every file shown
+			// beneath it, while preserving the first-seen order of folders and items.
+			var groups_by_dir = new Map();
+			var plan_groups = [];
+			target.plans.forEach( plan => {
+				var group = groups_by_dir.get(plan.dir);
+				if (!group) {
+					group = [];
+					groups_by_dir.set(plan.dir, group);
+					plan_groups.push(group);
+				}
+				group.push(plan);
+			});
+			target.plans = [].concat(...plan_groups);
+		});
+		
+		// All Categories are now known to be valid, so it is safe to start writing.
+		targets.forEach( target => {
+			var active_dir = '';
+			target.plans.forEach( plan => {
+				var dir = plan.dir;
+				if (dir != active_dir) {
+					if (!opts.dry) Tools.mkdirp.sync(dir);
+					println( "\n " + cli.emoji('📂') + " " + bold.cyan(plan.display_dir) );
+					active_dir = dir;
+				}
+			
+				// Work on a deep copy so setup never changes the cached remote definition.
+				var item = Tools.copyHash(plan.source_item, true);
 				var extras = [];
-				(this.args.file_props || []).forEach( (path) => {
+				(opts.file_props || []).forEach( path => {
 					var extra = Tools.getPath(item, path);
 					if ((typeof(extra) == 'string') && extra.match(/\S/)) {
 						extras.push({ path, content: extra });
-						
-						// we do not need to check the return value of setPath here,
-						// because this path is guaranteed to exist at this point
 						Tools.setPath( item, path, "(External)" );
 					}
-				} );
+				});
 				
-				var data = this.getItemExportData(type_def.id, item);
-				var title = item.title.replace(/\W+/g, '-').replace(/\-+$/, '').replace(/^\-+/, '');
+				var data = this.getItemExportData(target.type, item);
+				var title = plan.title;
 				var filename = title + '.json';
-				var file = Path.join(list_name, filename);
+				var file = Path.join(dir, filename);
 				
-				if (!this.dry) {
-					if (!this.args.force && fs.existsSync(file)) this.die("File exists, add '--force' to overwrite all: " + file);
+				if (!opts.dry) {
+					if (!opts.force && fs.existsSync(file)) this.die("File exists, add '--force' to overwrite all: " + file);
 					Tools.writeFileAtomicSync( file, JSON.stringify(data, null, "\t") + "\n" );
 				}
 				println( "    " + cli.emoji('📄') + " " + bold.green(filename) );
+				result.written++;
 				
-				// now handle extras
-				extras.forEach( (extra) => {
+				extras.forEach( extra => {
 					var command = item.command;
 					if (!command && extra.content.match(/^\s*\#\!(.+?)\n/)) command = RegExp.$1;
 					
-					var ext = 'txt';
-					if (command) ext = this.getExtFromBinary(command);
+					var ext = default_ext;
+					if (command) {
+						var detected_ext = this.getExtFromBinary(command);
+						if (detected_ext != 'txt') ext = detected_ext;
+					}
 					else if (extra.content.trim().match(/^\{[\S\s]*\}$/) || extra.content.trim().match(/^\[[\S\s]*\]$/)) ext = 'json';
 					
 					var extra_filename = title + '-' + extra.path + '.' + ext;
-					var extra_file = Path.join(list_name, extra_filename);
-					
-					if (!this.dry) {
-						if (!this.args.force && fs.existsSync(extra_file)) this.die("File exists, add '--force' to overwrite all: " + extra_file);
+					var extra_file = Path.join(dir, extra_filename);
+					if (!opts.dry) {
+						if (!opts.force && fs.existsSync(extra_file)) this.die("File exists, add '--force' to overwrite all: " + extra_file);
 						Tools.writeFileAtomicSync( extra_file, extra.content );
 					}
-					
 					println( "    " + cli.emoji('📜') + " " + bold.yellow(extra_filename) );
-				} );
-			} ); // foreach item
-		} ); // foreach list
+				});
+			});
+		});
 		
-		println( "\n " + this.color('theme').bold("Setup complete!") );
+		return result;
+	},
+	
+	getSyncSetupTitleSlug(title, item_type, item_id) {
+		// Use one filename-safe transformation for definitions and Category folders.
+		// Reject unusable titles explicitly instead of silently producing `.json` or
+		// collapsing an Event back into the top-level resource directory.
+		if (typeof(title) != 'string') {
+			this.die("Cannot create sync setup path for " + item_type + ": Missing title (" + item_id + ")");
+		}
+		
+		var slug = title.replace(/\W+/g, '-').replace(/\-+$/, '').replace(/^\-+/, '');
+		if (!slug) {
+			this.die("Cannot create sync setup path for " + item_type + ": Title has no usable filename characters (" + item_id + ")");
+		}
+		return slug;
 	},
 	
 	getItemExportData(type, item) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pixlcore/xycli",
-	"version": "1.0.0",
+	"version": "1.0.2",
 	"description": "A complete command-line interface for the xyOps workflow automation system.",
 	"author": "Joseph Huckaby <jhuckaby@pixlcore.com>",
 	"homepage": "https://github.com/pixlcore/xycli",
@@ -20,7 +20,8 @@
 		"xyops", "cli"
 	],
 	"scripts": {
-		"test": "node test.js"
+		"test": "node test.js",
+		"changelog": "node tools/changelog.js"
 	},
 	"dependencies": {
 		"@pixlcore/xyops-sdk": "^1.0.7",

package/test/README.md

@@ -8,7 +8,7 @@ Use Node.js 22 or newer and install the CLI dependencies with `npm install`.
 
 Start xyOps at `http://localhost:5522` and configure an administrator API key using your normal CLI config file or the `XYOPS_API_KEY` environment variable. The tests read the same configuration as `xy`, including `XYOPS_BASE_URL` overrides. They refuse to run against a different server address.
 
-Use an xyOps version that supports restoring API key IDs, hashes, and masks through `create_api_key`. The Server tests need a connected server, and the Monitor tests also need a server group. The log tests expect the standard log columns and debug entries in the current xyOps log.
+Use an xyOps version that supports restoring API key IDs, hashes, and masks through `create_api_key`. The Server and Job tests need a connected server, the Job tests need the enabled stock Shell Plugin, and the Monitor tests also need a server group. The log tests expect the standard log columns and debug entries in the current xyOps log.
 
 ## Running Tests
 
@@ -55,6 +55,8 @@ node --test test/config.test.js test/sync-unit.test.js
 | `categories` | CRUD, actions and limits, JSON input, validation, pagination, help |
 | `channels` | CRUD, recipients, indexed edits, filters, validation, help |
 | `config` | Offline user-file updates, inherited-setting isolation, missing-file creation, dotted edits, permissions, and read-only display |
+| `events` | CRUD, dependency filters, nested edits, triggers, actions, limits, fields, validation, and help |
+| `jobs` | Event launch, parameter and input overrides, completed reports, output logs, search, rerun, deletion, validation, and help |
 | `log` | Log searches, latest rows, matching, column selection, native output |
 | `markdown` | Terminal rendering, inline formatting inside list items, typographic bullets, and output margins |
 | `monitors` | CRUD, groups, evaluator requests, type conversions, validation, help |
@@ -65,7 +67,7 @@ node --test test/config.test.js test/sync-unit.test.js
 | `servers` | Active and recently offline lists, local filters, installer generation, historical search, live and historical Server details, charts, processes, connections, pagination, validation, help |
 | `system` | Admin dashboard, conductors, connected users, export, maintenance, optimization, rate resets, diagnostics, broadcasts, help |
 | `sync` | Setup export, isolated filesystem discovery, external property files, dry-run, upsync, downsync, composite global-state governance, no-op detection, and guarded delete mode |
-| `sync-unit` | Offline PID locking and stale recovery, up-only deletion guards, stock/Marketplace deletion protection, inherited settings and CLI overrides, warning/error exit status, duplicates, quiet/dry runs, completion failures, and notification delivery after warnings or errors |
+| `sync-unit` | Offline setup extension fallbacks, new-only exports and setup completion commands, PID locking and stale recovery, up-only deletion guards, pre-delete failure blocking, stock/Marketplace deletion protection, inherited settings and CLI overrides, warning/error exit status, duplicates, quiet/dry runs, completion failures, and notification delivery after warnings or errors |
 | `tags` | CRUD, metadata search, sparse future-proof updates, JSON input, validation, pagination, help |
 | `tickets` | Search, CRUD, number resolution, comments, attachment uploads/downloads, Events, related Job lookup, sparse updates, validation, help |
 | `toast` | Warning-box word wrapping and terminal-width limits |
@@ -80,7 +82,7 @@ Pagination checks that require saved events, completed jobs, or alert history re
 
 The mutating suites create uniquely named disposable objects and remove them in cleanup blocks, including after assertion failures. Test events have no active triggers, channels are never invoked, monitor sources use constants, and Plugin definitions are never executed or attached to other objects. Temporary files live in private operating-system temp directories and are removed by native test hooks.
 
-The Marketplace suite installs and upgrades `pixlcore/xyplug-ai`, then deletes it without executing or attaching it to an Event. The suite requires this product to be uninstalled when the test begins and removes its own installation during cleanup. Ticket fixtures remain in `draft` for their entire lifecycle so assigned test users never receive email notifications.
+The Job suite creates one enabled Event with no triggers, launches short-lived Shell Plugin Jobs only through explicit test commands, and deletes the completed Jobs and Event. The Marketplace suite installs and upgrades `pixlcore/xyplug-ai`, then deletes it without executing or attaching it to an Event. The suite requires this product to be uninstalled when the test begins and removes its own installation during cleanup. Ticket fixtures remain in `draft` for their entire lifecycle so assigned test users never receive email notifications.
 
 API key tests keep plaintext secrets in memory. Export files contain the stored hash and mask, and are deleted after the test. Captured CLI output is omitted from process failure messages because it can contain credentials.
 

package/test/events.test.js

@@ -0,0 +1,187 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { loadTestConfig, createCheck, xy, json, call: apiCall, cleanupFixtures } = require('./helpers/common.js');
+
+test('events', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	
+	// Keep the Event disabled for its entire lifecycle.  Its schedule, actions,
+	// limits, and source are saved definitions only and can never launch a Job.
+	const stamp = Date.now();
+	const id = 'cli_event_test_' + stamp;
+	const title = 'CLI Event Test ' + stamp;
+	const action = { type: 'email', enabled: true, condition: 'success', users: ['admin'] };
+	const limit = { type: 'time', enabled: true, duration: 300, abort: true };
+	const field = { id: 'message', title: 'Message', type: 'text', value: 'Hello' };
+	const script = 'echo "Event fixture ' + stamp + '"';
+	let category;
+	let plugin;
+	let group;
+	
+	try {
+		await check('local server has Event dependencies', async () => {
+			const data = await apiCall('getMultiple', { lists: 'categories,plugins,groups' });
+			category = data.categories.find(item => item.enabled) || data.categories[0];
+			plugin = data.plugins.find(item => item.id == 'shellplug') || data.plugins.find(item => item.type == 'event');
+			group = data.groups[0];
+			assert.ok(category, 'At least one Category is required');
+			assert.ok(plugin, 'At least one Event Plugin is required');
+			assert.ok(group, 'At least one Server Group is required');
+		});
+		
+		await check('dry creation builds a complete Event request', () => {
+			const req = json([
+				'event', 'create', '--id', id, '--title', title,
+				'--enabled', 'false', '--category', category.id, '--plugin', plugin.id,
+				'--targets', JSON.stringify([group.id]), '--algo', 'random',
+				'--notes', 'Original notes', '--params.script', script,
+				'--cron', '15 4 * * *', '--action', JSON.stringify(action),
+				'--limit', JSON.stringify(limit), '--field', JSON.stringify(field), '--dry'
+			]);
+			assert.equal(req.id, id);
+			assert.equal(req.enabled, false);
+			assert.equal(req.category, category.id);
+			assert.equal(req.plugin, plugin.id);
+			assert.deepEqual(req.targets, [group.id]);
+			assert.equal(req.params.script, script);
+			assert.ok(req.triggers.some(trigger => trigger.type == 'manual' && trigger.enabled));
+			assert.ok(req.triggers.some(trigger => trigger.type == 'schedule' && trigger.enabled));
+			assert.deepEqual(req.actions.at(-1), action);
+			assert.deepEqual(req.limits.at(-1), limit);
+			assert.deepEqual(req.fields.at(-1), field);
+		});
+		
+		await check('dry creation does not persist', () => assert.deepEqual(json(['events', '--id', id]), []));
+		
+		xy([
+			'event', 'create', '--id', id, '--title', title,
+			'--enabled', 'false', '--category', category.id, '--plugin', plugin.id,
+			'--targets', JSON.stringify([group.id]), '--algo', 'random',
+			'--notes', 'Original notes', '--params.script', script,
+			'--cron', '15 4 * * *', '--action', JSON.stringify(action),
+			'--limit', JSON.stringify(limit), '--field', JSON.stringify(field)
+		]);
+		const created = json(['event', id]);
+		
+		await check('create persists the complete Event definition', () => {
+			assert.equal(created.id, id);
+			assert.equal(created.title, title);
+			assert.equal(created.enabled, false);
+			assert.equal(created.category, category.id);
+			assert.equal(created.plugin, plugin.id);
+			assert.deepEqual(created.targets, [group.id]);
+			assert.equal(created.params.script, script);
+			assert.equal(created.notes, 'Original notes');
+			assert.equal(created.revision, 1);
+			assert.deepEqual(created.actions.at(-1), action);
+			assert.deepEqual(created.limits.at(-1), limit);
+			assert.deepEqual(created.fields.at(-1), field);
+		});
+		
+		await check('exact ID, named ID, and fuzzy title get the Event', () => {
+			assert.deepEqual(json(['event', id]), created);
+			assert.equal(json(['event', 'get', '--id', id]).id, id);
+			assert.equal(json(['event', 'get', '--title', title.toLowerCase()]).id, id);
+		});
+		
+		await check('search and dependency filters find only the fixture', () => {
+			assert.deepEqual(json(['events', title, '--category', category.id, '--plugin', plugin.id, '--target', group.id]), [created]);
+			assert.deepEqual(json(['event', 'list', id, '--enabled', 'true']), []);
+		});
+		
+		await check('human list and detail render Event configuration', () => {
+			const list = xy(['events', title]);
+			const detail = xy(['event', id]);
+			assert.match(list, /FILTERED EVENTS/);
+			assert.match(list, /Other Commands:/);
+			for (const label of ['Event Summary', 'Event ID', 'Event Notes', 'Original notes', 'Triggers', 'Actions', 'Limits', 'User Parameters']) {
+				assert.ok(detail.toLowerCase().includes(label.toLowerCase()), label);
+			}
+		});
+		
+		await check('dry update is sparse and preserves the saved revision', () => {
+			assert.deepEqual(json(['event', 'update', id, '--notes', 'Preview', '--dry']), { notes: 'Preview', id: id });
+			assert.equal(json(['event', id]).revision, 1);
+		});
+		
+		const actionIndex = created.actions.length - 1;
+		const limitIndex = created.limits.length - 1;
+		const fieldIndex = created.fields.length - 1;
+		const updatedScript = 'echo "Updated Event fixture ' + stamp + '"';
+		xy([
+			'event', 'update', id, '--title', title + ' Updated',
+			'--notes', 'Updated notes', '--params.script', updatedScript,
+			'--actions.' + actionIndex + '.condition', 'complete',
+			'--limits.' + limitIndex + '.duration', '600',
+			'--fields.' + fieldIndex + '.value', 'Updated'
+		]);
+		let updated = json(['event', id]);
+		
+		await check('dotted update preserves untouched Event settings', () => {
+			assert.equal(updated.title, title + ' Updated');
+			assert.equal(updated.notes, 'Updated notes');
+			assert.equal(updated.params.script, updatedScript);
+			assert.equal(updated.actions[actionIndex].condition, 'complete');
+			assert.equal(updated.actions[actionIndex].users[0], 'admin');
+			assert.equal(updated.limits[limitIndex].duration, 600);
+			assert.equal(updated.fields[fieldIndex].value, 'Updated');
+			assert.equal(updated.enabled, false);
+			assert.equal(updated.revision, 2);
+		});
+		
+		const originalTriggerCount = updated.triggers.length;
+		const delay = { type: 'delay', enabled: true, duration: 60 };
+		xy(['event', 'update', id, '--trigger', JSON.stringify(delay)]);
+		updated = json(['event', id]);
+		
+		await check('singular trigger appends to the saved trigger list', () => {
+			assert.equal(updated.triggers.length, originalTriggerCount + 1);
+			assert.deepEqual(updated.triggers.at(-1), delay);
+		});
+		
+		const revision = updated.revision;
+		for (const args of [
+			['update', id],
+			['update', id, '--actions.99.enabled', 'true'],
+			['update', id, '--actions.0.__proto__.polluted', 'true'],
+			['update', id, '--unknown', 'value'],
+			['delete', title + ' Updated', '--confirm']
+		]) {
+			await check('reject Event ' + args.slice(0, 4).join(' '), () => xy(['event', ...args], { fail: true }));
+		}
+		
+		await check('rejected requests leave the Event unchanged', () => assert.equal(json(['event', id]).revision, revision));
+		
+		await check('duplicate Event ID error is surfaced', () => {
+			assert.match(xy(['event', 'create', '--id', id, '--title', title, '--enabled', 'false', '--params.script', script], { fail: true }), /already exists/i);
+		});
+		
+		await check('unconfirmed delete shows the Event and warning toast', () => {
+			for (const args of [['delete', id], ['delete', id, '--confirm', 'maybe']]) {
+				const out = xy(['event', ...args]);
+				assert.match(out, /DELETE EVENT/);
+				assert.match(out, new RegExp(id));
+				assert.match(out, /Please confirm the delete/);
+			}
+		});
+		
+		await check('dry delete sends only the Event ID', () => {
+			assert.deepEqual(json(['event', 'delete', id, '--confirm', '--dry']), { id: id });
+			assert.equal(json(['event', id]).id, id);
+		});
+		
+		xy(['event', 'delete', id, '--confirm']);
+		await check('confirmed delete removes the Event', () => assert.deepEqual(json(['events', '--id', id]), []));
+		await check('get after deletion fails', () => xy(['event', id], { fail: true }));
+		
+		for (const topic of ['events', 'event', 'event get', 'event create', 'event update', 'event delete', 'event run', 'run']) {
+			await check('help ' + topic, () => assert.ok(xy(['help', ...topic.split(' ')]).length > 100));
+		}
+	}
+	finally {
+		await cleanupFixtures([
+			{ list: 'events', method: 'deleteEvent', match: item => item.id == id || (item.title || '').startsWith(title) }
+		]);
+	}
+});