@pixlcore/xycli 1.0.8 → 1.1.0

package/test/sync-buckets-unit.test.js

@@ -127,6 +127,37 @@ test('downsync replaces changed files and preserves the server timestamp', async
 	assert.equal(fs.statSync(env.paths.data).mtimeMs / 1000, 150);
 });
 
+test('down-only bucket deletion removes local files absent from the remote manifest', async t => {
+	const keep = { filename: 'keep.txt', path: 'files/bucket/bucket_unit/key/keep.txt', size: 4, date: 80 };
+	const env = fixture(t, { localData: { keep: true }, remoteData: { keep: true }, remoteFiles: [keep] });
+	const keep_path = Path.join(env.paths.files, 'keep.txt');
+	const stale_path = Path.join(env.paths.files, 'stale.txt');
+	fs.writeFileSync(keep_path, 'keep');
+	fs.utimesSync(keep_path, 80, 80);
+	fs.writeFileSync(stale_path, 'stale');
+	
+	await env.app.syncBucketContents([env.item], { down: ['buckets'], delete: ['buckets'] });
+	assert.equal(env.app.errors.length, 0);
+	assert.equal(fs.existsSync(keep_path), true);
+	assert.equal(fs.existsSync(stale_path), false);
+	assert.equal(env.app.downSynced, true);
+	assert.deepEqual(env.calls, []);
+});
+
+test('down-only bucket deletion previews files and skips them after a failed download', async t => {
+	const remote_file = { filename: 'remote.txt', path: 'files/bucket/bucket_unit/key/remote.txt', size: 6, date: 80 };
+	for (const dry of [true, false]) {
+		const env = fixture(t, { localData: { keep: true }, remoteData: { keep: true },
+			remoteFiles: [remote_file], dry });
+		const stale_path = Path.join(env.paths.files, 'stale.txt');
+		fs.writeFileSync(stale_path, 'stale');
+		await env.app.syncBucketContents([env.item], { down: ['buckets'], delete: ['buckets'] });
+		assert.equal(fs.existsSync(stale_path), true);
+		if (dry) assert.equal(env.app.errors.length, 0);
+		else assert.match(env.app.errors[0], /Missing remote bytes/);
+	}
+});
+
 test('two-way sync chooses the newer data and file copies independently', async t => {
 	const old = { filename: 'remote.txt', path: 'files/bucket/bucket_unit/key/remote.txt', size: 6, date: 140 };
 	const env = fixture(t, {

package/test/sync-buckets.test.js

@@ -115,6 +115,42 @@ test('bucket filesystem sync', async t => {
 			assert.equal(Math.floor(fs.statSync(file).mtimeMs / 1000), remoteFile.date);
 			assert.equal(Math.floor(fs.statSync(dataFile).mtimeMs / 1000), bucket.meta.mod);
 		});
+		
+		await check('down-only delete removes a local Bucket file absent from xyOps', async () => {
+			const content = Path.join(activeRoot, 'buckets', slug);
+			const extra = Path.join(content, 'files', 'LocalOnly.txt');
+			fs.writeFileSync(extra, 'only in the local sync tree');
+			const before = await call('getBucket', { id });
+			
+			const preview = xy(['sync', activeRoot, '--up', 'false', '--down', 'buckets', '--delete', 'buckets', '--dry']);
+			assert.match(preview, /Would delete local bucket file/);
+			assert.ok(fs.existsSync(extra), 'Dry run preserves the local file');
+			
+			const output = xy(['sync', activeRoot, '--up', 'false', '--down', 'buckets', '--delete', 'buckets']);
+			assert.match(output, /Deleting local bucket file/);
+			assert.ok(!fs.existsSync(extra), 'Missing remote file was removed locally');
+			assert.ok(fs.existsSync(Path.join(content, 'files', 'seed.json')), 'Existing remote file remains');
+			assert.deepEqual((await call('getBucket', { id })).files, before.files, 'Remote Bucket files are unchanged');
+		});
+		
+		await check('down-only delete removes a deleted Bucket and its local content', async () => {
+			const source = Path.join(activeRoot, 'buckets', slug + '.json');
+			const content = Path.join(activeRoot, 'buckets', slug);
+			await call('deleteBucket', { id });
+			created = false;
+			assert.ok(fs.existsSync(source), 'Local source remains before down-delete');
+			assert.ok(fs.existsSync(content), 'Local content remains before down-delete');
+			
+			const preview = xy(['sync', activeRoot, '--up', 'false', '--down', 'buckets', '--delete', 'buckets', '--dry']);
+			assert.match(preview, /Would delete local bucket/);
+			assert.ok(fs.existsSync(source), 'Dry run preserves the Bucket source');
+			assert.ok(fs.existsSync(content), 'Dry run preserves Bucket content');
+			
+			const output = xy(['sync', activeRoot, '--up', 'false', '--down', 'buckets', '--delete', 'buckets']);
+			assert.match(output, /Deleting local bucket/);
+			assert.ok(!fs.existsSync(source), 'Deleted Bucket source was removed');
+			assert.ok(!fs.existsSync(content), 'Deleted Bucket content was removed');
+		});
 	}
 	finally {
 		// Ordinary sync writes a shared management map. Restore it exactly, then

package/test/sync-syshook-unit.test.js

@@ -0,0 +1,231 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const Path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+function makeTree(t) {
+	var dir = fs.mkdtempSync(Path.join(os.tmpdir(), 'xycli-syshook-test-'));
+	t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+	return dir;
+}
+
+function writeSource(dir, name, type, data) {
+	var file = Path.join(dir, name);
+	fs.mkdirSync(Path.dirname(file), { recursive: true });
+	fs.writeFileSync(file, JSON.stringify({
+		type: 'xypdf', version: '1.0', items: [{ type, data }]
+	}));
+	return file;
+}
+
+function runHook(dir, action, payload, extra = [], use_default_lock = false) {
+	// Strip xyOps connection variables to match the conductor's shell-hook
+	// environment.  The hook must complete without credentials or API access.
+	var env = { ...process.env, HOME: dir };
+	for (const key of Object.keys(env)) {
+		if (key.startsWith('XYOPS_')) delete env[key];
+	}
+	
+	var args = [Path.join(__dirname, '..', 'index.js'), 'sync', dir, '--syshook', action];
+	if (!use_default_lock) args.push('--lock_file', Path.join(dir, '.sync-lock'));
+	args.push(...extra);
+	
+	return spawnSync(process.execPath, args, {
+		input: payload === null ? '' : JSON.stringify(payload) + '\n',
+		encoding: 'utf8',
+		timeout: 10000,
+		env
+	});
+}
+
+function markerCommand(name) {
+	var code = `require('node:fs').writeFileSync(${JSON.stringify(name)}, process.cwd())`;
+	return `${JSON.stringify(process.execPath)} -e ${JSON.stringify(code)}`;
+}
+
+test('syshook deletes only the exact Event and its owned neighbors', t => {
+	var dir = makeTree(t);
+	var event = writeSource(dir, 'events/Ops/Nightly.json', 'event', {
+		id: 'evt_one', title: 'Nightly', params: { script: '(External)' }
+	});
+	var neighbor = Path.join(dir, 'events/Ops/Nightly-params.script.sh');
+	fs.writeFileSync(neighbor, 'echo one\n');
+	var other = writeSource(dir, 'events/Ops/Nightly-V2.json', 'event', {
+		id: 'evt_two', title: 'Nightly V2', params: { script: '(External)' }
+	});
+	var other_neighbor = Path.join(dir, 'events/Ops/Nightly-V2-params.script.sh');
+	fs.writeFileSync(other_neighbor, 'echo two\n');
+	var new_event = writeSource(dir, 'events/Ops/New.json', 'event', { id: 'evt_new', title: 'New' });
+	var same_id_plugin = writeSource(dir, 'plugins/Shared.json', 'plugin', { id: 'evt_one', title: 'Shared' });
+	var marker = Path.join(dir, 'completed.txt');
+	
+	var result = runHook(dir, 'event_delete', {
+		xy: 1, action: 'event_delete', event: { id: 'evt_one', title: 'Nightly' }
+	}, ['--down_cmd', markerCommand('completed.txt')]);
+	
+	assert.ifError(result.error);
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(fs.existsSync(event), false);
+	assert.equal(fs.existsSync(neighbor), false);
+	assert.equal(fs.existsSync(other), true);
+	assert.equal(fs.existsSync(other_neighbor), true);
+	assert.equal(fs.existsSync(new_event), true);
+	assert.equal(fs.existsSync(same_id_plugin), true);
+	assert.equal(fs.readFileSync(marker, 'utf8'), fs.realpathSync(dir));
+});
+
+test('syshook uses its default lock without a configured xyOps URL or API Key', t => {
+	var dir = makeTree(t);
+	var event = writeSource(dir, 'events/Delete-Me.json', 'event', { id: 'evt_no_config' });
+	var result = runHook(dir, 'event_delete', {
+		xy: 1, action: 'event_delete', event: { id: 'evt_no_config' }
+	}, [], true);
+	
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(fs.existsSync(event), false);
+});
+
+test('syshook rejects a mismatched action without deleting files', t => {
+	var dir = makeTree(t);
+	var file = writeSource(dir, 'plugins/Shared.json', 'plugin', { id: 'plugin_one', title: 'Shared' });
+	var result = runHook(dir, 'plugin_delete', {
+		xy: 1, action: 'event_delete', plugin: { id: 'plugin_one' }
+	}, ['--down_cmd', markerCommand('completed.txt')]);
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /does not match --syshook plugin_delete/);
+	assert.equal(fs.existsSync(file), true);
+	assert.equal(fs.existsSync(Path.join(dir, 'completed.txt')), false);
+});
+
+test('syshook deletes a matching Plugin without changing another Plugin', t => {
+	var dir = makeTree(t);
+	var target = writeSource(dir, 'plugins/Shared.json', 'plugin', { id: 'plugin_one', title: 'Shared' });
+	var other = writeSource(dir, 'plugins/Other.json', 'plugin', { id: 'plugin_two', title: 'Other' });
+	var result = runHook(dir, 'plugin_delete', {
+		xy: 1, action: 'plugin_delete', plugin: { id: 'plugin_one' }
+	});
+	
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(fs.existsSync(target), false);
+	assert.equal(fs.existsSync(other), true);
+});
+
+// Each remaining standard sync type uses the same exact type-and-ID lookup.
+// Include another Event with the target ID to catch an accidental ID-only
+// match, especially for the API Key action's different spelling.
+for (const [action, type] of [
+	['alert_delete', 'alert'],
+	['apikey_delete', 'api_key'],
+	['category_delete', 'category'],
+	['channel_delete', 'channel'],
+	['group_delete', 'group'],
+	['monitor_delete', 'monitor'],
+	['tag_delete', 'tag'],
+	['web_hook_delete', 'web_hook']
+]) {
+	test('syshook deletes one ' + type + ' for ' + action, t => {
+		var dir = makeTree(t);
+		var target = writeSource(dir, type + '/Target.json', type, { id: 'shared_id' });
+		var other = writeSource(dir, type + '/Other.json', type, { id: 'other_id' });
+		var event = writeSource(dir, 'events/Shared.json', 'event', { id: 'shared_id' });
+		var result = runHook(dir, action, {
+			xy: 1, action, [type]: { id: 'shared_id' }
+		});
+		
+		assert.equal(result.status, 0, result.stderr);
+		assert.equal(fs.existsSync(target), false);
+		assert.equal(fs.existsSync(other), true);
+		assert.equal(fs.existsSync(event), true);
+	});
+}
+
+test('syshook rejects bucket deletion and preserves its source', t => {
+	var dir = makeTree(t);
+	var bucket = writeSource(dir, 'buckets/Shared.json', 'bucket', { id: 'bucket_one' });
+	var result = runHook(dir, 'bucket_delete', {
+		xy: 1, action: 'bucket_delete', bucket: { id: 'bucket_one' }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Invalid --syshook action/);
+	assert.equal(fs.existsSync(bucket), true);
+});
+
+test('syshook checks neighboring files before deleting the source', t => {
+	var dir = makeTree(t);
+	var target = writeSource(dir, 'events/Ops/Nightly.json', 'event', { id: 'evt_one', title: 'Nightly' });
+	var unrelated = Path.join(dir, 'events/Ops/Nightly-other.txt');
+	fs.writeFileSync(unrelated, 'keep me\n');
+	var result = runHook(dir, 'event_delete', {
+		xy: 1, action: 'event_delete', event: { id: 'evt_one' }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Neighbor file does not match a string property/);
+	assert.equal(fs.existsSync(target), true);
+	assert.equal(fs.existsSync(unrelated), true);
+});
+
+test('syshook stops on malformed JSON before deleting a matching source', t => {
+	var dir = makeTree(t);
+	var target = writeSource(dir, 'events/Ops/Nightly.json', 'event', { id: 'evt_one', title: 'Nightly' });
+	fs.writeFileSync(Path.join(dir, 'events/Ops/Broken.json'), '{bad json');
+	var result = runHook(dir, 'event_delete', {
+		xy: 1, action: 'event_delete', event: { id: 'evt_one' }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Failed to parse JSON file/);
+	assert.equal(fs.existsSync(target), true);
+});
+
+test('syshook refuses duplicate XYPDF sources before changing either file', t => {
+	var dir = makeTree(t);
+	var data = { id: 'plugin_one', title: 'Shared', script: '(External)' };
+	var first = writeSource(dir, 'plugins/First.json', 'plugin', data);
+	var second = writeSource(dir, 'plugins/Second.json', 'plugin', data);
+	var result = runHook(dir, 'plugin_delete', {
+		xy: 1, action: 'plugin_delete', plugin: { id: 'plugin_one' }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Duplicate XYPDF sources/);
+	assert.equal(fs.existsSync(first), true);
+	assert.equal(fs.existsSync(second), true);
+});
+
+test('syshook dry run and absent source never run down_cmd', t => {
+	var dir = makeTree(t);
+	var file = writeSource(dir, 'plugins/Shared.json', 'plugin', { id: 'plugin_one', title: 'Shared' });
+	var command = markerCommand('completed.txt');
+	var payload = { xy: 1, action: 'plugin_delete', plugin: { id: 'plugin_one' } };
+	var preview = runHook(dir, 'plugin_delete', payload, ['--dry', '--down_cmd', command]);
+	
+	assert.equal(preview.status, 0, preview.stderr);
+	assert.match(preview.stdout, /Would delete:/);
+	assert.equal(fs.existsSync(file), true);
+	assert.equal(fs.existsSync(Path.join(dir, 'completed.txt')), false);
+	
+	var absent = runHook(dir, 'plugin_delete', {
+		xy: 1, action: 'plugin_delete', plugin: { id: 'other' }
+	}, ['--down_cmd', command]);
+	assert.equal(absent.status, 0, absent.stderr);
+	assert.equal(fs.existsSync(file), true);
+	assert.equal(fs.existsSync(Path.join(dir, 'completed.txt')), false);
+});
+
+test('syshook reports a failed down_cmd after deleting the matched source', t => {
+	var dir = makeTree(t);
+	var file = writeSource(dir, 'plugins/Shared.json', 'plugin', { id: 'plugin_one', title: 'Shared' });
+	var command = `${JSON.stringify(process.execPath)} -e "process.exit(2)"`;
+	var result = runHook(dir, 'plugin_delete', {
+		xy: 1, action: 'plugin_delete', plugin: { id: 'plugin_one' }
+	}, ['--down_cmd', command]);
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Command failed/);
+	assert.equal(fs.existsSync(file), false);
+});

package/test/sync-unit.test.js

@@ -15,26 +15,30 @@ const script = `
 	const options = JSON.parse(process.argv[1]);
 	cli.args.quiet = options.quiet !== false;
 	const sync = require('./lib/sync.js');
+	const bucketSync = require('./lib/sync-buckets.js');
 	if (options.setupCwd) process.chdir(options.setupCwd);
 	const calls = [];
 	const requests = [];
 	const apiOptions = [];
 	const app = {
 		...sync,
+		...bucketSync,
 		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' }, event: { list: 'events' }, plugin: { list: 'plugins' } }
+				list_list: (options.includeBuckets ? ['buckets', 'categories', 'events', 'plugins'] : ['categories', 'events', 'plugins']).map(id => ({ id })),
+				data_types: { bucket: { list: 'buckets' }, category: { list: 'categories' }, event: { list: 'events' }, plugin: { list: 'plugins' } }
 			}
 		},
-		state: {},
+		state: options.state || {},
+		buckets: options.buckets || [],
 		categories: options.categories || [],
 		events: options.events || [],
 		plugins: options.plugins || [],
 		version: 'test',
+		xyopsVersion: '1.1.2',
 		dry: !!options.args.dry,
 		color() { return cli.chalk.white; },
 		markdown(text) { return text; },
@@ -95,6 +99,15 @@ function runSync(t, options) {
 				items: [{ type: source.type, data: source.data }]
 			});
 			fs.writeFileSync(file, contents);
+			if (source.bucketFiles) {
+				var bucket_dir = file.replace(/\.json$/i, '');
+				fs.mkdirSync(Path.join(bucket_dir, 'files'), { recursive: true });
+				fs.writeFileSync(Path.join(bucket_dir, 'data.json'), JSON.stringify(source.bucketData || {}));
+				for (const [name, contents] of Object.entries(source.bucketFiles)) {
+					fs.writeFileSync(Path.join(bucket_dir, 'files', name), contents);
+				}
+				if (source.bucketExtra) fs.writeFileSync(Path.join(bucket_dir, source.bucketExtra), 'keep');
+			}
 		});
 	}
 	if (options.missingDir) args.other = [Path.join(dir, 'missing')];
@@ -189,16 +202,16 @@ test('sync update guard rejects malformed confirmation values', async () => {
 	);
 });
 
-test('sync rejects deletion with down-only, two-way, or mixed directions before writes', t => {
+test('sync rejects deletion without exactly one direction before writes', t => {
 	for (const args of [
-		{ down: 'categories', delete: 'categories' },
 		{ up: 'categories', down: 'categories', delete: 'categories', dry: true },
 		{ up: 'categories', down: 'events', delete: 'categories' },
-		{ up: [], delete: 'categories' }
+		{ up: [], delete: 'categories' },
+		{ down: [], delete: 'categories' }
 	]) {
 		const result = runSync(t, { args });
 		assert.equal(result.status, 1);
-		assert.match(result.stderr, /Delete mode requires up-only sync/);
+		assert.match(result.stderr, /Delete mode requires exactly one sync direction/);
 		assert.deepEqual(result.report.calls, []);
 	}
 });
@@ -218,6 +231,101 @@ test('sync validates inherited deletion and direction settings after CLI overrid
 	assert.equal(emptyDown.status, 0);
 });
 
+test('down-only delete removes one missing local source and its neighbors', t => {
+	const result = runSync(t, {
+		categories: [{ id: 'keep', title: 'Keep', notes: 'Same' }],
+		events: [{ id: 'missing', title: 'Same ID on another type' }],
+		existingSources: [
+			{ path: 'categories/Stale.json', type: 'category', data: { id: 'missing', title: 'Stale', notes: '(External)' } },
+			{ path: 'categories/Stale-notes.txt', contents: 'Old note\n' },
+			{ path: 'categories/Keep.json', type: 'category', data: { id: 'keep', title: 'Keep', notes: 'Same' } },
+			{ path: 'events/Other.json', type: 'event', data: { id: 'missing', title: 'Same ID on another type' } }
+		],
+		args: { down: 'categories', delete: 'categories', down_cmd: getSetupMarkerCommand('completed.txt') }
+	});
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Stale.json')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Stale-notes.txt')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Keep.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'events/Other.json')), true);
+	assert.equal(fs.readFileSync(Path.join(result.dir, 'completed.txt'), 'utf8'), fs.realpathSync(result.dir));
+	assert.deepEqual(result.report.requests.filter(req => req.method.startsWith('delete_')), []);
+});
+
+test('down-only delete previews local files without changing them or running down_cmd', t => {
+	const result = runSync(t, {
+		quiet: false,
+		existingSources: [
+			{ path: 'categories/Stale.json', type: 'category', data: { id: 'missing', title: 'Stale' } }
+		],
+		args: { down: 'categories', delete: 'categories', dry: true, down_cmd: getSetupMarkerCommand('completed.txt') }
+	});
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(result.stdout, /Would delete local/);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Stale.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'completed.txt')), false);
+});
+
+test('down-only delete removes an orphan Bucket and all its local content', t => {
+	const result = runSync(t, {
+		includeBuckets: true,
+		existingSources: [
+			{ path: 'buckets/Stale.json', type: 'bucket', data: { id: 'missing', title: 'Stale' },
+				bucketData: { old: true }, bucketFiles: { 'old.txt': 'contents' } }
+		],
+		args: { down: 'buckets', delete: 'buckets' }
+	});
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'buckets/Stale.json')), false);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'buckets/Stale')), false);
+});
+
+test('down-only delete preflights all Bucket content before removing any source', t => {
+	const result = runSync(t, {
+		includeBuckets: true,
+		existingSources: [
+			{ path: 'buckets/First.json', type: 'bucket', data: { id: 'first', title: 'First' }, bucketFiles: {} },
+			{ path: 'buckets/Second.json', type: 'bucket', data: { id: 'second', title: 'Second' },
+				bucketFiles: {}, bucketExtra: 'untracked.txt' }
+		],
+		args: { down: 'buckets', delete: 'buckets' }
+	});
+	assert.equal(result.status, 1);
+	assert.match(result.report.errors[0], /Local delete preflight failed/);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'buckets/First.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'buckets/First')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'buckets/Second.json')), true);
+});
+
+test('down-only delete protects local stock and Marketplace definitions', t => {
+	const result = runSync(t, {
+		existingSources: [
+			{ path: 'categories/Stock.json', type: 'category', data: { id: 'stock', title: 'Stock', stock: false } },
+			{ path: 'categories/Marketplace.json', type: 'category', data: { id: 'marketplace', title: 'Marketplace', marketplace: null } },
+			{ path: 'categories/Custom.json', type: 'category', data: { id: 'custom', title: 'Custom' } }
+		],
+		args: { down: 'categories', delete: 'categories' }
+	});
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Stock.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Marketplace.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Custom.json')), false);
+});
+
+test('down-only delete skips local removals after a sync-state error', t => {
+	const result = runSync(t, {
+		state: { sync: { 'category-old': true } },
+		failAPI: 'update_global_state',
+		existingSources: [
+			{ path: 'categories/Stale.json', type: 'category', data: { id: 'stale', title: 'Stale' } }
+		],
+		args: { down: 'categories', delete: 'categories' }
+	});
+	assert.equal(result.status, 1);
+	assert.match(result.report.warnings[0], /Delete pass skipped/);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'categories/Stale.json')), true);
+});
+
 test('sync errors exit nonzero even in quiet mode or a dry run', t => {
 	for (const dry of [false, true]) {
 		const result = runSync(t, { missingDir: true, args: { up: 'categories', dry, quiet: true } });
@@ -227,6 +335,73 @@ test('sync errors exit nonzero even in quiet mode or a dry run', t => {
 	}
 });
 
+test('sync ignore-missing skips only absent remote IDs and continues updates', t => {
+	const remote = { id: 'present', title: 'Present', notes: 'Remote' };
+	const local = { ...remote, notes: 'Local' };
+	const missing = { id: 'gone', title: 'Gone', notes: 'Keep this file' };
+	const result = runSync(t, {
+		categories: [remote],
+		existingSources: [
+			{ path: 'Gone.json', type: 'category', data: missing },
+			{ path: 'Present.json', type: 'category', data: local }
+		],
+		args: { up: 'categories', down: 'categories', delete: false, ignore_missing: true }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.deepEqual(result.report.warnings, []);
+	assert.equal(result.report.calls.includes('update_category'), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'Gone.json')), true);
+	assert.equal(JSON.parse(fs.readFileSync(Path.join(result.dir, 'Gone.json'), 'utf8')).items[0].data.notes, 'Keep this file');
+});
+
+test('sync ignore-missing does not suppress malformed source warnings', t => {
+	const result = runSync(t, {
+		source: { id: 'missing', title: 'Missing' },
+		emptyItems: true,
+		args: { up: 'categories', ignore_missing: true }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.report.warnings[0], /empty, malformed or missing items array/);
+	assert.deepEqual(result.report.calls, []);
+});
+
+test('sync ignore-missing still validates neighbors of missing sources', t => {
+	const result = runSync(t, {
+		source: { id: 'missing', title: 'Missing' },
+		invalidNeighbor: true,
+		args: { up: 'categories', ignore_missing: true }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.report.warnings[0], /Neighbor file does not match/);
+	assert.deepEqual(result.report.calls, []);
+});
+
+test('sync ignore-missing still rejects duplicate missing sources', t => {
+	const result = runSync(t, {
+		source: { id: 'missing', title: 'Missing' },
+		duplicateSource: true,
+		args: { up: 'categories', ignore_missing: true }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.report.warnings[0], /Duplicate source item found/);
+	assert.deepEqual(result.report.calls, []);
+});
+
+test('sync ignore-missing can be disabled over a saved setting', t => {
+	const result = runSync(t, {
+		source: { id: 'missing', title: 'Missing' },
+		config: { up: 'categories', ignore_missing: true },
+		args: { ignore_missing: false }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.report.warnings[0], /Cannot find category in xyOps/);
+});
+
 test('sync sends existing Plugin properties through the sync API path', t => {
 	const remote = { id: 'legacy', title: 'Legacy', type: 'event', command: 'node', cwd: '/opt/legacy', custom_field: { keep: true }, notes: 'Remote' };
 	const local = { ...remote, notes: 'Local' };
@@ -313,6 +488,39 @@ test('sync setup new exports only remote definitions missing from the local tree
 	assert.equal(fs.existsSync(Path.join(result.dir, 'custom', 'layout', 'Renamed-Existing.json')), true);
 });
 
+test('sync setup new ignore-missing leaves stale files and exports new definitions', t => {
+	const missing = { id: 'gone', title: 'Gone' };
+	const added = { id: 'added', title: 'Added Plugin', command: 'node' };
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [added],
+		existingSources: [{ path: 'old/Gone.json', type: 'plugin', data: missing }],
+		args: { new: true, ignore_missing: true }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.deepEqual(result.report.warnings, []);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'old', 'Gone.json')), true);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Added-Plugin.json')), true);
+});
+
+test('sync setup new ignore-missing still rejects duplicate missing sources', t => {
+	const missing = { id: 'gone', title: 'Gone' };
+	const result = runSync(t, {
+		setup: ['plugins'],
+		plugins: [{ id: 'added', title: 'Added Plugin', command: 'node' }],
+		existingSources: [
+			{ path: 'old/Gone.json', type: 'plugin', data: missing },
+			{ path: 'other/Gone.json', type: 'plugin', data: missing }
+		],
+		args: { new: true, ignore_missing: true }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /Duplicate source item found/);
+	assert.equal(fs.existsSync(Path.join(result.dir, 'plugins', 'Added-Plugin.json')), false);
+});
+
 test('sync setup runs down_cmd after writing files from the setup directory', t => {
 	const marker = 'setup-complete.txt';
 	const result = runSync(t, {

package/test/sync.test.js

@@ -510,6 +510,48 @@ test('sync', async t => {
 			assert.ok(fixtures.category && fixtures.plugin && fixtures.event, 'Resources outside the missing fixture remain');
 			assert.deepEqual(fixtures.syncState, deleteSyncState, 'Up-only delete mode tracks the remaining Category sources');
 		});
+		
+		await check('remove disposable remote Event and Plugin for down-only deletion', async () => {
+			// The local sources and external property files remain in the isolated
+			// sync tree. Delete only these two server fixtures so down-delete has
+			// exactly two local candidates and no unrelated remote mutations.
+			await call('deleteEvent', { id: eventID });
+			await call('deletePlugin', { id: pluginID });
+			const fixtures = await getFixtures();
+			assert.equal(fixtures.event, undefined);
+			assert.equal(fixtures.plugin, undefined);
+			assert.ok(fixtures.category, 'Unrelated Category remains in xyOps');
+			for (const file of [eventFile, eventScriptFile, pluginFile, pluginScriptFile, categoryFile]) {
+				assert.ok(fs.existsSync(file), 'Local fixture remains before down-delete: ' + file);
+			}
+		});
+		
+		await check('dry down-only delete preserves local Event and Plugin files', () => {
+			const output = xy([
+				'sync', syncRoot, '--up', 'false', '--down', 'events,plugins', '--delete', 'events,plugins', '--dry'
+			], { cwd: temp });
+			assert.match(output, /Would delete local event/);
+			assert.match(output, /Would delete local plugin/);
+			for (const file of [eventFile, eventScriptFile, pluginFile, pluginScriptFile, categoryFile]) {
+				assert.ok(fs.existsSync(file), 'Dry run preserves local fixture: ' + file);
+			}
+		});
+		
+		await check('down-only delete removes only missing Event and Plugin files', async () => {
+			const output = xy([
+				'sync', syncRoot, '--up', 'false', '--down', 'events,plugins', '--delete', 'events,plugins'
+			], { cwd: temp });
+			assert.match(output, /Deleting local event/);
+			assert.match(output, /Deleting local plugin/);
+			for (const file of [eventFile, eventScriptFile, pluginFile, pluginScriptFile]) {
+				assert.ok(!fs.existsSync(file), 'Down-delete removes local fixture: ' + file);
+			}
+			assert.ok(fs.existsSync(categoryFile), 'Unrelated local Category remains');
+			const fixtures = await getFixtures();
+			assert.ok(fixtures.category, 'Down-delete preserves unrelated remote Category');
+			assert.equal(fixtures.event, undefined);
+			assert.equal(fixtures.plugin, undefined);
+		});
 	}
 	finally {
 		const cleanupErrors = [];

package/test/tickets.test.js

@@ -23,6 +23,7 @@ test('tickets', async t => {
 	const body = '# Test Ticket\n\n- **Bold item** with `code`\n';
 	let ticketCreated = false;
 	let tagCreated = false;
+	let commentAuthor = '';
 
 	fs.writeFileSync(bodyFile, body);
 	fs.writeFileSync(firstFile, 'First Ticket attachment.\n');
@@ -110,6 +111,8 @@ test('tickets', async t => {
 			const saved = row.changes.filter( change => change.type == 'comment' );
 			assert.equal(saved.length, 1);
 			assert.equal(saved[0].body, comment);
+			// The API key can belong to any user, so use the author saved by xyOps.
+			commentAuthor = saved[0].username || '(Unknown)';
 			assert.equal(row.status, 'draft');
 		});
 
@@ -159,7 +162,7 @@ test('tickets', async t => {
 				'TICKET #' + num, 'Number', '#' + num, 'Ticket ID', id, subject,
 				'TICKET BODY', 'Test Ticket', '• Bold item with code',
 				'TICKET FILES', Path.basename(firstFile), Path.basename(secondFile), 'Download a file',
-				'Comment by admin', 'Investigation update', '• Checked the logs'
+				'Comment by ' + commentAuthor, 'Investigation update', '• Checked the logs'
 			]) assert.ok(out.includes(text), text);
 			if (event) {
 				assert.match(out, /TICKET EVENTS/);