@pixlcore/xycli 1.0.0 → 1.0.2

package/test/jobs.test.js

@@ -0,0 +1,205 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const sdk = require('@pixlcore/xyops-sdk');
+const { loadTestConfig, createCheck, xy, json, call: apiCall, cleanupFixtures } = require('./helpers/common.js');
+
+test('jobs', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	
+	// This suite launches short-lived Shell Plugin Jobs, waits for each one to
+	// become final, and records every Job ID immediately for exact cleanup.
+	const stamp = Date.now();
+	const eventID = 'cli_job_test_' + stamp;
+	const eventTitle = 'CLI Job Test ' + stamp;
+	const marker = 'XYCLI_JOB_TEST_' + stamp;
+	const script = 'echo "' + marker + '"';
+	const jobIDs = new Set();
+	let eventCreated = false;
+	
+	async function loadJob(id) {
+		const result = await sdk.api.getJob({ id: id, remove: 'timelines' });
+		if (result.err || !result.data || !result.data.job) return null;
+		return result.data.job;
+	}
+	
+	async function waitForFinalJob(id, timeout = 20000) {
+		const expires = Date.now() + timeout;
+		while (Date.now() < expires) {
+			const job = await loadJob(id);
+			if (job && job.final) return job;
+			await new Promise(resolve => setTimeout(resolve, 200));
+		}
+		throw new Error('Timed out waiting for Job to complete: ' + id);
+	}
+	
+	function launchedJobID(output) {
+		const match = output.match(/Successfully launched job: #(\w+)/i);
+		assert.ok(match, 'CLI printed the launched Job ID');
+		jobIDs.add(match[1]);
+		return match[1];
+	}
+	
+	async function cleanupJobs() {
+		const errors = [];
+		for (const id of jobIDs) {
+			try {
+				let job = await loadJob(id);
+				if (!job) continue;
+				if (!job.final) {
+					await sdk.api.abortJob({ id: id });
+					job = await waitForFinalJob(id, 10000);
+				}
+				const result = await sdk.api.deleteJob({ id: id });
+				if (result.err) throw result.err;
+			}
+			catch (error) { errors.push(error); }
+		}
+		if (errors.length) throw new AggregateError(errors, 'Disposable Job cleanup failed.');
+	}
+	
+	try {
+		let category;
+		let plugin;
+		let serverID;
+		
+		await check('local server can run a Shell Plugin Job', async () => {
+			const data = await apiCall('getMultiple', { lists: 'categories,plugins', servers: 1 });
+			category = data.categories.find(item => item.enabled) || data.categories[0];
+			plugin = data.plugins.find(item => item.id == 'shellplug' && item.enabled);
+			serverID = Object.keys(data.servers || {})[0];
+			assert.ok(category && category.enabled, 'An enabled Category is required');
+			assert.ok(plugin, 'The enabled stock shellplug Event Plugin is required');
+			assert.ok(serverID, 'A connected Server is required');
+		});
+		
+		// Mark cleanup eligibility before creation.  This also covers the rare case
+		// where the server commits the Event but the client loses the response.
+		eventCreated = true;
+		await apiCall('createEvent', {
+			id: eventID,
+			title: eventTitle,
+			enabled: true,
+			category: category.id,
+			plugin: plugin.id,
+			params: { script: script },
+			fields: [],
+			tags: [],
+			targets: [serverID],
+			algo: 'random',
+			notes: 'Disposable CLI Job test Event',
+			actions: [],
+			limits: [],
+			triggers: [{ type: 'manual', enabled: true }]
+		});
+		
+		await check('dry run previews overrides without launching a Job', () => {
+			const req = json(['run', eventID, '--params.script', script, '--input.data.marker', marker, '--dry']);
+			assert.equal(req.id, eventID);
+			assert.equal(req.params.script, script);
+			assert.equal(req.input.data.marker, marker);
+		});
+		
+		const launchOutput = xy(['run', eventID, '--params.script', script, '--input.data.marker', marker]);
+		const firstJobID = launchedJobID(launchOutput);
+		let firstJob = await waitForFinalJob(firstJobID);
+		
+		await check('run launches a successful Event-backed Job', () => {
+			assert.match(launchOutput, /Watch job live:/);
+			assert.equal(firstJob.id, firstJobID);
+			assert.equal(firstJob.event, eventID);
+			assert.equal(firstJob.plugin, plugin.id);
+			assert.equal(firstJob.server, serverID);
+			assert.equal(firstJob.final, true);
+			assert.equal(firstJob.code || 0, 0);
+			assert.equal(firstJob.params.script, script);
+			assert.equal(firstJob.input.data.marker, marker);
+			assert.match(firstJob.output || '', new RegExp(marker));
+		});
+		
+		await check('Job get supports JSON and human reports', () => {
+			assert.deepEqual(json(['job', firstJobID]), firstJob);
+			const out = xy(['job', firstJobID]);
+			assert.match(out, /JOB SUMMARY/);
+			assert.match(out, new RegExp(firstJobID));
+			assert.match(out, /Job completed successfully/i);
+			assert.match(out, /Other Commands:/);
+		});
+		
+		await check('verbose Job detail and Job log include process output', () => {
+			assert.match(xy(['job', firstJobID, '--verbose']), new RegExp(marker));
+			assert.match(xy(['job', 'log', firstJobID]), new RegExp(marker));
+		});
+		
+		await check('completed Job search finds the launched Job', () => {
+			const out = xy(['jobs', '--event', eventID]);
+			assert.match(out, /JOB SEARCH RESULTS/);
+			assert.match(out, new RegExp(firstJobID));
+			assert.match(out, new RegExp(eventTitle));
+		});
+		
+		await check('dry rerun previews the original Job settings', () => {
+			const req = json(['job', 'run', firstJobID, '--dry']);
+			assert.equal(req.id, eventID);
+			assert.equal(req.event, eventID);
+			assert.equal(req.params.script, script);
+			assert.equal(req.input.data.marker, marker);
+		});
+		
+		const rerunOutput = xy(['job', 'run', firstJobID]);
+		const secondJobID = launchedJobID(rerunOutput);
+		const secondJob = await waitForFinalJob(secondJobID);
+		
+		await check('Job rerun launches a distinct successful Job', () => {
+			assert.notEqual(secondJob.id, firstJobID);
+			assert.equal(secondJob.event, eventID);
+			assert.equal(secondJob.code || 0, 0);
+			assert.equal(secondJob.params.script, script);
+			assert.equal(secondJob.input.data.marker, marker);
+			assert.match(secondJob.output || '', new RegExp(marker));
+		});
+		
+		await check('completed Job refuses active-only operations', () => {
+			assert.match(xy(['job', 'abort', firstJobID], { fail: true }), /already completed/i);
+			assert.match(xy(['job', 'resume', firstJobID], { fail: true }), /already completed/i);
+		});
+		
+		await check('unconfirmed Job delete shows its target and warning', () => {
+			const out = xy(['job', 'delete', firstJobID]);
+			assert.match(out, /DELETE JOB/);
+			assert.match(out, new RegExp(firstJobID));
+			assert.match(out, /Please confirm the delete/);
+		});
+		
+		await check('dry Job delete leaves the completed Job intact', async () => {
+			assert.deepEqual(json(['job', 'delete', firstJobID, '--confirm', '--dry']), { id: firstJobID });
+			assert.ok(await loadJob(firstJobID));
+		});
+		
+		for (const id of [firstJobID, secondJobID]) {
+			xy(['job', 'delete', id, '--confirm']);
+		}
+		
+		await check('confirmed Job delete removes both completed Jobs', async () => {
+			assert.equal(await loadJob(firstJobID), null);
+			assert.equal(await loadJob(secondJobID), null);
+			jobIDs.delete(firstJobID);
+			jobIDs.delete(secondJobID);
+		});
+		
+		await apiCall('deleteEvent', { id: eventID });
+		eventCreated = false;
+		
+		for (const topic of ['jobs', 'job', 'job get', 'job log', 'job run', 'job resume', 'job abort', 'job delete']) {
+			await check('help ' + topic, () => assert.ok(xy(['help', ...topic.split(' ')]).length > 100));
+		}
+	}
+	finally {
+		await cleanupJobs();
+		if (eventCreated) {
+			await cleanupFixtures([
+				{ list: 'events', method: 'deleteEvent', match: item => item.id == eventID || (item.title || '').startsWith(eventTitle) }
+			]);
+		}
+	}
+});

package/test/sync-unit.test.js

@@ -13,28 +13,31 @@ const script = `
 	const cli = require('pixl-cli');
 	cli.global();
 	const options = JSON.parse(process.argv[1]);
-	cli.args.quiet = true;
+	cli.args.quiet = options.quiet !== false;
+	const sync = require('./lib/sync.js');
+	if (options.setupCwd) process.chdir(options.setupCwd);
 	const calls = [];
 	const requests = [];
 	const app = {
-		...require('./lib/sync.js'),
+		...sync,
 		args: options.args,
 		config: {
 			base_url: 'https://fixture.invalid',
 			sync: options.config || {},
 			ui: {
 				list_list: ['categories', 'events', 'plugins'].map(id => ({ id })),
-				data_types: { category: { list: 'categories' }, plugin: { list: 'plugins' } }
+				data_types: { category: { list: 'categories' }, event: { list: 'events' }, plugin: { list: 'plugins' } }
 			}
 		},
 		state: {},
 		categories: options.categories || [],
-		events: [],
+		events: options.events || [],
 		plugins: options.plugins || [],
 		version: 'test',
 		dry: !!options.args.dry,
 		color() { return cli.chalk.white; },
 		markdown(text) { return text; },
+		printBoxList() {},
 		compareVersions() { return 0; },
 		async getMultiple() {},
 		die(message) { throw new Error(message); },
@@ -58,6 +61,7 @@ function runSync(t, options) {
 	const dir = fs.mkdtempSync(Path.join(os.tmpdir(), 'xycli-sync-unit-'));
 	t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
 	const args = { other: [dir], ...options.args };
+	if (options.setup) args.other = ['setup', ...options.setup];
 	
 	if (options.source) {
 		fs.writeFileSync(Path.join(dir, 'Category.json'), JSON.stringify({
@@ -79,9 +83,25 @@ function runSync(t, options) {
 			fs.copyFileSync(Path.join(dir, 'Category.json'), Path.join(dir, 'Duplicate.json'));
 		}
 	}
+	if (options.existingSources) {
+		options.existingSources.forEach(source => {
+			const file = Path.join(dir, source.path);
+			fs.mkdirSync(Path.dirname(file), { recursive: true });
+			const contents = source.contents !== undefined ? source.contents : JSON.stringify({
+				type: 'xypdf',
+				version: '1.0',
+				items: [{ type: source.type, data: source.data }]
+			});
+			fs.writeFileSync(file, contents);
+		});
+	}
 	if (options.missingDir) args.other = [Path.join(dir, 'missing')];
 	
-	const result = spawnSync(process.execPath, ['-e', script, JSON.stringify({ ...options, args })], {
+	const result = spawnSync(process.execPath, ['-e', script, JSON.stringify({
+		...options,
+		args,
+		setupCwd: options.setup ? dir : undefined
+	})], {
 		cwd: Path.join(__dirname, '..'),
 		encoding: 'utf8',
 		timeout: 10000
@@ -89,7 +109,14 @@ function runSync(t, options) {
 	assert.ifError(result.error);
 	assert.equal(result.signal, null);
 	const report = JSON.parse(result.stdout.trim().split('\n').pop());
-	return { ...result, report };
+	return { ...result, report, dir };
+}
+
+function getSetupMarkerCommand(filename) {
+	// Use the current Node.js binary so the completion-command fixture is
+	// portable and does not depend on a separate shell utility being installed.
+	const code = `require('node:fs').writeFileSync(${JSON.stringify(filename)}, process.cwd())`;
+	return `${JSON.stringify(process.execPath)} -e ${JSON.stringify(code)}`;
 }
 
 test('sync update guard requires confirmation only for the exact managed object', async () => {
@@ -217,6 +244,267 @@ test('sync API errors preserve failure status while still sending both notificat
 	}
 });
 
+test('sync setup uses a custom extension only when detection falls back to txt', t => {
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [
+			{ id: 'fallback', title: 'Fallback', command: 'custom-runner', script: 'Write-Host "Hello"\n' },
+			{ id: 'detected', title: 'Detected', command: 'pwsh -File', script: 'Write-Host "Hello"\n' },
+			{ id: 'json', title: 'JSON Data', command: '', script: '{ "hello": true }\n' }
+		],
+		args: { file_props: 'script', default_ext: '.code' }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Fallback-script.code')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Detected-script.ps1')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'JSON-Data-script.json')), true);
+});
+
+test('sync setup rejects unsafe or malformed default extensions before writing', t => {
+	for (const defaultExt of [true, '', '.', '../ps1', 'ps/1', 'ps-1', 'tar.gz']) {
+		const result = runSync(t, {
+			setup: ['plugins'],
+			plugins: [{ id: 'fixture', title: 'Fixture', command: 'custom-runner', script: 'Example\n' }],
+			args: { file_props: 'script', default_ext: defaultExt }
+		});
+		
+		assert.equal(result.status, 1);
+		assert.match(result.stderr, /Invalid --default_ext value/);
+		assert.equal(fs.existsSync(Path.join(result.dir, 'plugins')), false);
+	}
+});
+
+test('sync setup new exports only remote definitions missing from the local tree', t => {
+	const existing = { id: 'existing', title: 'Existing', command: 'node', script: 'console.log("Existing");\n' };
+	const added = { id: 'added', title: 'Added Plugin', command: 'custom-runner', script: 'Write-Host "Added"\n' };
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [existing, added],
+		existingSources: [{
+			path: 'custom/layout/Renamed-Existing.json',
+			type: 'plugin',
+			data: existing
+		}],
+		args: { new: true, file_props: 'script', default_ext: 'ps1' }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Added-Plugin.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Added-Plugin-script.ps1')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Existing.json')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'custom', 'layout', 'Renamed-Existing.json')), true);
+});
+
+test('sync setup runs down_cmd after writing files from the setup directory', t => {
+	const marker = 'setup-complete.txt';
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [{ id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+		args: {
+			file_props: 'script',
+			down_cmd: getSetupMarkerCommand(marker)
+		}
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.readFileSync(Path.join(result.dir, marker), 'utf8'), fs.realpathSync(result.dir));
+});
+
+test('sync setup new runs down_cmd only when it writes new files', t => {
+	const existing = { id: 'existing', title: 'Existing', command: 'node', script: 'Existing\n' };
+	const marker = 'setup-new-complete.txt';
+	const command = getSetupMarkerCommand(marker);
+	const added = runSync(t, {
+		setup: ['plugins'],
+		plugins: [existing, { id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+		existingSources: [{ path: 'Existing.json', type: 'plugin', data: existing }],
+		args: { new: true, down_cmd: command }
+	});
+	
+	assert.equal(added.status, 0);
+	assert.equal(fs.existsSync(Path.join(added.dir, marker)), true);
+	
+	const unchanged = runSync(t, {
+		setup: ['plugins'],
+		plugins: [existing],
+		existingSources: [{ path: 'Existing.json', type: 'plugin', data: existing }],
+		args: { new: true, down_cmd: command }
+	});
+	
+	assert.equal(unchanged.status, 0);
+	assert.equal(fs.existsSync(Path.join(unchanged.dir, marker)), false);
+});
+
+test('sync setup does not run down_cmd during a dry run', t => {
+	const marker = 'setup-dry-complete.txt';
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [{ id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+		args: { dry: true, down_cmd: getSetupMarkerCommand(marker) }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.existsSync(Path.join(result.dir, marker)), false);
+});
+
+test('sync setup completion-command errors exit nonzero', t => {
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [{ id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+		args: { down_cmd: `${JSON.stringify(process.execPath)} -e "process.exit(2)"` }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.report.errors[0], /Command failed/);
+});
+
+test('sync setup new dry run discovers additions without writing them', t => {
+	const existing = { id: 'existing', title: 'Existing', command: 'node', script: 'Existing\n' };
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [existing, { id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+		existingSources: [{ path: 'Existing-Renamed.json', type: 'plugin', data: existing }],
+		args: { new: true, dry: true, file_props: 'script' }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins')), false);
+});
+
+test('sync setup new preserves existing Events and writes new workflows separately', t => {
+	const category = { id: 'operations', title: 'Operations Team' };
+	const existing = { id: 'existing-event', title: 'Existing Event', type: 'event', category: category.id };
+	const workflow = { id: 'new-workflow', title: 'New Workflow', type: 'workflow', category: category.id };
+	const result = runSync(t, {
+		setup: ['events'],
+		categories: [category],
+		events: [existing, workflow],
+		existingSources: [{ path: 'custom/Event.json', type: 'event', data: existing }],
+		args: { new: true }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'workflows', 'Operations-Team', 'New-Workflow.json')), true);
+});
+
+test('sync setup groups Events and workflows into Category folders', t => {
+	const operations = { id: 'operations', title: 'Operations Team' };
+	const limited = { id: 'limited', title: 'Limited Run' };
+	const engineering = { id: 'engineering', title: 'Engineering & QA' };
+	const result = runSync(t, {
+		setup: ['events'],
+		categories: [operations, limited, engineering],
+		events: [
+			{ id: 'nightly', title: 'Nightly Backup', type: 'event', category: operations.id, params: { script: '#!/bin/sh\necho backup\n' } },
+			{ id: 'limited', title: 'Limited Event', type: 'event', category: limited.id },
+			{ id: 'release', title: 'Release Pipeline', type: 'workflow', category: engineering.id },
+			{ id: 'ondemand', title: 'On Demand Backup', type: 'event', category: operations.id }
+		],
+		args: { file_props: 'params.script' },
+		quiet: false
+	});
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events', 'Operations-Team', 'Nightly-Backup.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events', 'Operations-Team', 'Nightly-Backup-params.script.sh')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events', 'Operations-Team', 'On-Demand-Backup.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events', 'Limited-Run', 'Limited-Event.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'workflows', 'Engineering-QA', 'Release-Pipeline.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events', 'Nightly-Backup.json')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'workflows', 'Release-Pipeline.json')), false);
+	
+	// The source order deliberately returns to Operations after Limited Run.
+	// Its two Events must still print beneath one folder heading.
+	const operationsHeader = result.stdout.indexOf('events/Operations-Team/');
+	const nightlyFile = result.stdout.indexOf('Nightly-Backup.json');
+	const onDemandFile = result.stdout.indexOf('On-Demand-Backup.json');
+	const limitedHeader = result.stdout.indexOf('events/Limited-Run/');
+	const limitedFile = result.stdout.indexOf('Limited-Event.json');
+	const workflowHeader = result.stdout.indexOf('workflows/Engineering-QA/');
+	assert.ok(operationsHeader < nightlyFile);
+	assert.ok(nightlyFile < onDemandFile);
+	assert.ok(onDemandFile < limitedHeader);
+	assert.ok(limitedHeader < limitedFile);
+	assert.ok(limitedFile < workflowHeader);
+	assert.equal(result.stdout.indexOf('events/Operations-Team/', operationsHeader + 1), -1);
+});
+
+test('sync setup validates all Event Categories before writing any files', t => {
+	const result = runSync(t, {
+		setup: ['plugins', 'events'],
+		plugins: [{ id: 'plugin', title: 'Plugin', script: 'Hello\n' }],
+		events: [{ id: 'orphan', title: 'Orphan Event', type: 'event', category: 'missing' }],
+		args: {}
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Cannot find Category for Event: Orphan Event \(missing\)/);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events')), false);
+});
+
+test('sync setup new rejects overwrite mode and malformed values before writing', t => {
+	for (const args of [
+		{ new: true, force: true },
+		{ new: 'yes' }
+	]) {
+		const result = runSync(t, {
+			setup: ['plugins'],
+			plugins: [{ id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+			args
+		});
+		
+		assert.equal(result.status, 1);
+		assert.match(result.stderr, /--new/);
+		assert.equal(fs.existsSync(Path.join(result.dir, 'plugins')), false);
+	}
+});
+
+test('sync setup new aborts on duplicate or malformed existing sources before writing', t => {
+	const existing = { id: 'existing', title: 'Existing', command: 'node', script: 'Existing\n' };
+	for (const existingSources of [
+		[
+			{ path: 'one.json', type: 'plugin', data: existing },
+			{ path: 'nested/two.json', type: 'plugin', data: existing }
+		],
+		[{ path: 'broken.json', contents: '{ nope' }],
+		[{ path: 'orphan.json', type: 'plugin', data: { id: 'missing', title: 'Missing' } }]
+	]) {
+		const result = runSync(t, {
+			setup: ['plugins'],
+			plugins: [existing, { id: 'added', title: 'Added', command: 'node', script: 'Added\n' }],
+			existingSources,
+			args: { new: true }
+		});
+		
+		assert.equal(result.status, 1);
+		assert.match(result.stderr, /Duplicate source item|Failed to parse JSON file|Cannot find plugin in xyOps/);
+		assert.equal(fs.existsSync(Path.join(result.dir, 'plugins')), false);
+	}
+});
+
+test('sync skips the entire delete pass after an update or state API failure', t => {
+	const category = { id: 'fixture', title: 'Fixture', notes: 'Remote' };
+	const orphan = { id: 'orphan', title: 'Orphan', notes: 'Delete candidate' };
+	
+	for (const failAPI of ['update_category', 'update_global_state']) {
+		const result = runSync(t, {
+			categories: [category, orphan],
+			source: { ...category, notes: 'Local' },
+			failAPI,
+			args: { up: 'categories', delete: 'categories' }
+		});
+		
+		assert.equal(result.status, 1);
+		assert.equal(result.report.errors.length, 1);
+		assert.match(result.report.warnings[0], /Delete pass skipped/);
+		assert.equal(result.report.calls.includes('update_global_state'), true);
+		assert.deepEqual(result.report.requests.filter(req => req.method.startsWith('delete_')), []);
+	}
+});
+
 test('sync completion-command errors also exit nonzero and notify', t => {
 	const category = { id: 'fixture', title: 'Fixture', notes: 'Remote' };
 	const result = runSync(t, {

package/test/sync.test.js

@@ -171,8 +171,9 @@ test('sync', async t => {
 		const categoryExport = Path.join(temp, 'categories', slugify(categoryTitle) + '.json');
 		const pluginExport = Path.join(temp, 'plugins', slugify(pluginTitle) + '.json');
 		const pluginScriptExport = Path.join(temp, 'plugins', slugify(pluginTitle) + '-script.js');
-		const eventExport = Path.join(temp, 'events', slugify(eventTitle) + '.json');
-		const eventScriptExport = Path.join(temp, 'events', slugify(eventTitle) + '-params.script.sh');
+		const eventDir = Path.join(temp, 'events', slugify(categoryTitle));
+		const eventExport = Path.join(eventDir, slugify(eventTitle) + '.json');
+		const eventScriptExport = Path.join(eventDir, slugify(eventTitle) + '-params.script.sh');
 		
 		await check('setup writes valid XYPDF and external property files', () => {
 			const category = readXYPDF(categoryExport);

package/tools/changelog.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+// Build xyCLI CHANGELOG.md file
+
+var fs = require('fs');
+var Path = require('path');
+var cp = require('child_process');
+var Tools = require('pixl-tools');
+
+var debug = (process.argv[2] == 'debug');
+
+// make sure we're in the correct dir
+process.chdir( Path.dirname( __dirname ) );
+
+// make sure git sandbox is clean
+var porcelain = cp.execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+if (!debug && porcelain.length) {
+	console.error("\nERROR: Git sandbox has local changes.  Please commit these before updating the changelog.\n");
+	process.exit(1);
+}
+
+// get list of tags
+var tags = cp.execSync('git tag --list --sort=version:refname', { encoding: 'utf8' }).trim().split(/\n/).reverse();
+
+var md = '';
+md += "# xyCLI Changelog\n";
+
+var last_tag = tags.pop();
+if (!tags.length) {
+	console.error("\nERROR: No tags found after popping first one.  Please push another tag before running changelog.\n");
+	process.exit(1);
+}
+
+tags.forEach( function(tag, idx) {
+	var prev_tag = tags[idx + 1] || last_tag;
+	md += `\n## Version ${tag}\n\n`;
+	
+	var cmd = `git log ${prev_tag}..${tag} --no-merges --pretty=format:'%h %H %ad %s%n%n%b%n----PX----' --date=short`;
+	var output = cp.execSync(cmd, { encoding: 'utf8' }).trim();
+	var commits = output.split('----PX----');
+	var first = true;
+	
+	// 029a96a 029a96aebd721fe565b1b5c8f2b661564c9017f3 2025-12-30 Version 0.9.2
+	commits.forEach( function(chunk) {
+		var lines = chunk.trim().split(/\n/);
+		var line = lines.shift();
+		
+		var matches = line.trim().match(/^(\w+)\s+(\w+)\s+([\d\-]+)\s+(.+)$/);
+		if (!matches) return;
+		if (matches[4].match(/\b(CHANGELOG)\b/)) return;
+		
+		var url = 'https://github.com/pixlcore/xycli/commit/' + matches[2];
+		
+		if (first) {
+			md += `> ` + Tools.formatDate( matches[3] + ' 00:00:00', '[mmmm] [mday], [yyyy]' ) + "\n\n";
+			first = false;
+		}
+		
+		md += `- [\`${matches[1]}\`](${url}): ` + matches[4] + "\n";
+		
+		if (matches[4].match(/^Version/)) lines.forEach( function(extra) {
+			if (!extra.match(/\S/)) return;
+			extra = extra.trim();
+			if (!extra.match(/^\-/)) extra = '- ' + extra;
+			md += "\t" + extra + "\n";
+		} );
+	} );
+} );
+
+md += `\n## Version ${last_tag}\n\n> September 20, 2026\n\n- Initial release!\n`;
+
+if (debug) {
+	console.log(md);
+	process.exit(0);
+}
+
+fs.writeFileSync( 'CHANGELOG.md', md );
+
+// make sure log has actually changed
+porcelain = cp.execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+if (!porcelain.length) {
+	console.error("\nWarning: Changelog has not changed since last run.  Skipping actions.\n");
+	process.exit(1);
+}
+
+cp.execSync('git add CHANGELOG.md && git commit -m "Update CHANGELOG" && git push', { stdio: 'inherit' } );