@pixlcore/xycli 1.0.7 → 1.0.9

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

@@ -0,0 +1,188 @@
+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 bucketSync = require('../lib/sync-buckets.js');
+const sync = require('../lib/sync.js');
+const utils = require('../lib/utils.js');
+
+// The bucket pass uses the ordinary sync logging functions, whose output is
+// provided by pixl-cli in production. Keep the test output quiet and local.
+global.println = () => {};
+
+function fixture(t, options = {}) {
+	const dir = fs.mkdtempSync(Path.join(os.tmpdir(), 'xycli-bucket-sync-unit-'));
+	t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+	const item = { type: 'bucket', data: { id: 'bucket_unit', title: 'Changed Title' }, file: Path.join(dir, 'custom', 'Original-Name.json') };
+	const paths = bucketSync.getSyncBucketPaths(item);
+	fs.mkdirSync(paths.files, { recursive: true });
+	fs.writeFileSync(item.file, '{}');
+	fs.writeFileSync(paths.data, JSON.stringify(options.localData || { keep: true, removed: true }));
+	fs.utimesSync(paths.data, 100, options.localDataTime || 100);
+	
+	const remote = {
+		bucket: { id: item.data.id, title: item.data.title },
+		data: options.remoteData || { keep: false, server: true },
+		meta: { mod: options.remoteDataTime || 90 },
+		files: options.remoteFiles || []
+	};
+	const bytes = options.remoteBytes || {};
+	const calls = [];
+	const app = {
+		...bucketSync,
+		...sync,
+		compareVersions: utils.compareVersions,
+		xyopsVersion: options.version || '1.1.2',
+		dry: !!options.dry,
+		errors: [],
+		warnings: [],
+		api: {
+			async getBucket() { return { data: structuredClone(remote) }; },
+			async file(request, settings) {
+				const path = 'files/' + request.path;
+				if (!Object.hasOwn(bytes, path)) return { err: new Error('Missing remote bytes') };
+				fs.writeFileSync(settings.download, bytes[path]);
+				return { data: {} };
+			}
+		},
+		async callStandardAPI(method, request, settings = {}) {
+			calls.push({ method, request, settings });
+			if (method == 'writeBucketData') {
+				remote.data = structuredClone(request.data);
+				remote.meta.mod = 120;
+				return {};
+			}
+			if (method == 'uploadBucketFiles') {
+				settings.files.forEach(path => {
+					const name = app.cleanSyncBucketFilename(Path.basename(path));
+					let file = remote.files.find(entry => entry.filename == name);
+					if (!file) {
+						file = { filename: name, path: 'files/bucket/bucket_unit/new/' + name };
+						remote.files.push(file);
+					}
+					file.size = fs.statSync(path).size;
+					file.date = 130;
+				});
+				return { files: structuredClone(remote.files) };
+			}
+			if (method == 'deleteBucketFile') {
+				remote.files = remote.files.filter(file => file.path != request.path);
+				return {};
+			}
+			throw new Error('Unexpected API: ' + method);
+		},
+		logSyncError(message) { this.errors.push(message); },
+		logSyncWarning(message) { this.warnings.push(message); },
+		markdown(text) { return text; },
+		die(message) { throw new Error(message); }
+	};
+	return { dir, item, paths, remote, calls, app };
+}
+
+test('bucket sync rejects xyOps versions older than 1.1.2', t => {
+	const current = fixture(t);
+	assert.doesNotThrow(() => current.app.requireBucketSyncVersion());
+	current.app.xyopsVersion = '1.1.1';
+	assert.throws(() => current.app.requireBucketSyncVersion(), /v1\.1\.2 or later/);
+});
+
+test('bucket setup writes data and binary files with server mtimes beside the XYPDF source', async t => {
+	const file = { filename: 'Sample.JSON', path: 'files/bucket/bucket_unit/key/Sample.JSON', size: 8, date: 80 };
+	const env = fixture(t, { remoteFiles: [file], remoteBytes: { [file.path]: 'not json' } });
+	fs.rmSync(env.paths.dir, { recursive: true, force: true });
+	await env.app.setupBucketContents([{ id: env.item.data.id, file: env.item.file }], { dry: false, force: false });
+	assert.deepEqual(JSON.parse(fs.readFileSync(env.paths.data, 'utf8')), env.remote.data);
+	assert.equal(fs.readFileSync(Path.join(env.paths.files, 'Sample.JSON'), 'utf8'), 'not json');
+	assert.equal(fs.statSync(env.paths.data).mtimeMs / 1000, 90);
+	assert.equal(fs.statSync(Path.join(env.paths.files, 'Sample.JSON')).mtimeMs / 1000, 80);
+});
+
+test('upsync replaces data, normalizes manifest names, batches uploads, and deletes missing files last', async t => {
+	const removed = { filename: 'old.txt', path: 'files/bucket/bucket_unit/old/old.txt', size: 3, date: 60 };
+	const env = fixture(t, { remoteFiles: [removed] });
+	// Semicolon needs server filename normalization but remains a regular file on Windows.
+	const upload = Path.join(env.paths.files, 'New; File.txt');
+	fs.writeFileSync(upload, 'new');
+	fs.utimesSync(upload, 110, 110);
+	await env.app.syncBucketContents([env.item], { up: ['buckets'], delete: ['buckets'] });
+	assert.deepEqual(env.calls.map(call => call.method), ['writeBucketData', 'uploadBucketFiles', 'deleteBucketFile']);
+	assert.equal(env.calls[0].request.replace, true);
+	assert.deepEqual(env.remote.data, { keep: true, removed: true });
+	assert.equal(env.remote.files[0].filename, 'New_ File.txt');
+	assert.equal(fs.statSync(upload).mtimeMs / 1000, 130);
+	assert.equal(fs.statSync(env.paths.data).mtimeMs / 1000, 120);
+});
+
+test('downsync replaces changed files and preserves the server timestamp', async t => {
+	const file = { filename: 'same.txt', path: 'files/bucket/bucket_unit/key/same.txt', size: 6, date: 140 };
+	const env = fixture(t, { remoteFiles: [file], remoteBytes: { [file.path]: 'remote' }, remoteDataTime: 150 });
+	const localFile = Path.join(env.paths.files, file.filename);
+	fs.writeFileSync(localFile, 'old');
+	fs.utimesSync(localFile, 100, 100);
+	await env.app.syncBucketContents([env.item], { down: ['buckets'] });
+	assert.equal(fs.readFileSync(localFile, 'utf8'), 'remote');
+	assert.equal(fs.statSync(localFile).mtimeMs / 1000, 140);
+	assert.deepEqual(JSON.parse(fs.readFileSync(env.paths.data, 'utf8')), env.remote.data);
+	assert.equal(fs.statSync(env.paths.data).mtimeMs / 1000, 150);
+});
+
+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, {
+		localDataTime: 160,
+		remoteDataTime: 150,
+		remoteFiles: [old],
+		remoteBytes: { [old.path]: 'remote'
+		}
+	});
+	const localFile = Path.join(env.paths.files, old.filename);
+	fs.writeFileSync(localFile, 'stale');
+	fs.utimesSync(localFile, 100, 100);
+	await env.app.syncBucketContents([env.item], { up: ['buckets'], down: ['buckets'] });
+	assert.deepEqual(env.calls.map(call => call.method), ['writeBucketData']);
+	assert.equal(fs.readFileSync(localFile, 'utf8'), 'remote');
+	assert.equal(fs.statSync(localFile).mtimeMs / 1000, 140);
+	assert.deepEqual(env.remote.data, env.app.readSyncBucketLocal(env.item).data);
+});
+
+test('two-way sync reports equal-time content conflicts instead of guessing', async t => {
+	const env = fixture(t, { remoteDataTime: 100 });
+	await env.app.syncBucketContents([env.item], { up: ['buckets'], down: ['buckets'] });
+	assert.equal(env.app.errors.length, 1);
+	assert.match(env.app.errors[0], /equal timestamps/);
+	assert.deepEqual(env.calls, []);
+});
+
+test('invalid local data blocks every bucket mutation including file deletion', async t => {
+	const removed = { filename: 'old.txt', path: 'files/bucket/bucket_unit/old/old.txt', size: 3, date: 60 };
+	const env = fixture(t, { remoteFiles: [removed] });
+	fs.writeFileSync(env.paths.data, '{invalid');
+	await env.app.syncBucketContents([env.item], { up: ['buckets'], delete: ['buckets'] });
+	assert.equal(env.app.errors.length, 1);
+	assert.deepEqual(env.calls, []);
+});
+
+test('bucket dry runs leave data, files, and server records unchanged', async t => {
+	const removed = { filename: 'old.txt', path: 'files/bucket/bucket_unit/old/old.txt', size: 3, date: 60 };
+	const env = fixture(t, { remoteFiles: [removed], dry: true });
+	const added = Path.join(env.paths.files, 'new.txt');
+	fs.writeFileSync(added, 'new');
+	const originalTime = fs.statSync(env.paths.data).mtimeMs;
+	await env.app.syncBucketContents([env.item], { up: ['buckets'], delete: ['buckets'] });
+	assert.deepEqual(env.calls, []);
+	assert.equal(env.remote.files.length, 1);
+	assert.deepEqual(env.remote.data, { keep: false, server: true });
+	assert.equal(fs.statSync(env.paths.data).mtimeMs, originalTime);
+});
+
+test('a failed download keeps the previous local file intact', async t => {
+	const file = { filename: 'same.txt', path: 'files/bucket/bucket_unit/key/same.txt', size: 6, date: 140 };
+	const env = fixture(t, { remoteFiles: [file] });
+	const localFile = Path.join(env.paths.files, file.filename);
+	fs.writeFileSync(localFile, 'before');
+	fs.utimesSync(localFile, 100, 100);
+	await env.app.syncBucketContents([env.item], { down: ['buckets'] });
+	assert.equal(env.app.errors.length, 1);
+	assert.equal(fs.readFileSync(localFile, 'utf8'), 'before');
+});

package/test/sync-buckets.test.js

@@ -0,0 +1,133 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const Path = require('node:path');
+const { api } = require('@pixlcore/xyops-sdk');
+const { loadTestConfig, createCheck, createTempDir, xy, call } = require('./helpers/common.js');
+
+test('bucket filesystem sync', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	const temp = createTempDir(t, 'xycli-bucket-sync-live-');
+	const setupRoot = Path.join(temp, 'setup');
+	const activeRoot = Path.join(temp, 'active');
+	const stamp = Date.now();
+	const id = 'cli_bucket_sync_test_' + stamp;
+	const title = 'CLI Bucket Sync Test ' + stamp;
+	const slug = title.replace(/\W+/g, '-').replace(/^-|-$/g, '');
+	const seed = Path.join(temp, 'seed.json');
+	let originalState = null;
+	let created = false;
+	
+	fs.mkdirSync(setupRoot, { recursive: true });
+	fs.mkdirSync(activeRoot, { recursive: true });
+	fs.writeFileSync(seed, 'seed');
+	
+	try {
+		await check('create an isolated Bucket fixture', async () => {
+			const before = await call('getMultiple', { lists: 'buckets', state: 1 });
+			originalState = structuredClone((before.state && before.state.sync) || {});
+			
+			// --new will skip existing Buckets without downloading their content.
+			for (const bucket of before.buckets) {
+				fs.writeFileSync(Path.join(setupRoot, 'skip-' + bucket.id + '.json'), JSON.stringify({
+					type: 'xypdf', version: '1.0', items: [{ type: 'bucket', data: bucket }]
+				}));
+			}
+			await call('createBucket', { id, title, enabled: false, data: { keep: true, remove: true } });
+			created = true;
+			const uploaded = await api.uploadBucketFiles({ id }, { files: [seed] });
+			assert.ok(!uploaded.err && uploaded.data && uploaded.data.code === 0, 'Seed upload succeeded');
+		});
+		
+		await check('setup exports Bucket data and files', async () => {
+			const output = xy(['sync', 'setup', 'buckets', '--new'], { cwd: setupRoot });
+			assert.match(output, /🪣.*\/\s*\n/);
+			assert.match(output, /📄.*data\.json/);
+			assert.match(output, /📂.*files\//);
+			assert.match(output, /📎.*seed\.json/);
+			assert.doesNotMatch(output, /Bucket content:/);
+			const source = Path.join(setupRoot, 'buckets', slug);
+			assert.deepEqual(JSON.parse(fs.readFileSync(Path.join(source, 'data.json'), 'utf8')), { keep: true, remove: true });
+			assert.equal(fs.readFileSync(Path.join(source, 'files', 'seed.json'), 'utf8'), 'seed');
+			fs.mkdirSync(Path.join(activeRoot, 'buckets'), { recursive: true });
+			fs.cpSync(source + '.json', Path.join(activeRoot, 'buckets', slug + '.json'));
+			fs.cpSync(source, Path.join(activeRoot, 'buckets', slug), { recursive: true });
+		});
+		
+		await check('upsync replaces data and uploads a new file', async () => {
+			const content = Path.join(activeRoot, 'buckets', slug);
+			// Semicolon exercises filename normalization on Unix and Windows alike.
+			const added = Path.join(content, 'files', 'New; File.txt');
+			const source = Path.join(activeRoot, 'buckets', slug + '.json');
+			const xypdf = JSON.parse(fs.readFileSync(source, 'utf8'));
+			xypdf.items[0].data.notes = 'Local Bucket notes';
+			fs.writeFileSync(source, JSON.stringify(xypdf));
+			fs.writeFileSync(Path.join(content, 'data.json'), JSON.stringify({ keep: 'local' }));
+			fs.writeFileSync(added, 'new content');
+			const output = xy(['sync', activeRoot, '--up', 'buckets', '--down', 'false', '--delete', 'false']);
+			assert.match(output, new RegExp('Updating bucket: ' + title + ' \\(' + id + '\\)'));
+			assert.match(output, new RegExp('\\n\\n ⬆️ Updating bucket data: ' + title + ' \\(' + id + '\\)'));
+			assert.match(output, /-.*"keep": true/);
+			assert.match(output, /\+.*"keep": "local"/);
+			assert.match(output, new RegExp('\\n\\n ⬆️ Uploading \\d+ bucket files?: ' + title + ' \\(' + id + '\\)'));
+			assert.match(output, /📎.*New; File\.txt/);
+			assert.ok(output.indexOf('Updating bucket data:') > output.indexOf('Updating bucket:'), 'Bucket data has its own section after the definition');
+			const bucket = await call('getBucket', { id });
+			assert.equal(bucket.bucket.notes, 'Local Bucket notes');
+			assert.deepEqual(bucket.data, { keep: 'local' });
+			const file = bucket.files.find(entry => entry.filename === 'New_ File.txt');
+			assert.ok(file, 'Normalized upload is in the manifest');
+			assert.equal(Math.floor(fs.statSync(added).mtimeMs / 1000), file.date);
+		});
+		
+		await check('downsync pulls remote data and file changes', async () => {
+			await call('updateBucket', { id, notes: 'Remote Bucket notes' });
+			await call('writeBucketData', { id, replace: true, data: { keep: 'remote' } });
+			fs.writeFileSync(seed, 'remote replacement');
+			const uploaded = await api.uploadBucketFiles({ id }, { files: [seed] });
+			assert.ok(!uploaded.err && uploaded.data && uploaded.data.code === 0, 'Replacement upload succeeded');
+			xy(['sync', activeRoot, '--up', 'false', '--down', 'buckets', '--delete', 'false']);
+			const content = Path.join(activeRoot, 'buckets', slug);
+			const xypdf = JSON.parse(fs.readFileSync(content + '.json', 'utf8'));
+			assert.equal(xypdf.items[0].data.notes, 'Remote Bucket notes');
+			assert.deepEqual(JSON.parse(fs.readFileSync(Path.join(content, 'data.json'), 'utf8')), { keep: 'remote' });
+			assert.equal(fs.readFileSync(Path.join(content, 'files', 'seed.json'), 'utf8'), 'remote replacement');
+		});
+		
+		await check('two-way sync pushes newer local content and aligns timestamps', async () => {
+			const content = Path.join(activeRoot, 'buckets', slug);
+			const dataFile = Path.join(content, 'data.json');
+			const file = Path.join(content, 'files', 'seed.json');
+			const newer = Math.ceil(Date.now() / 1000) + 5;
+			fs.writeFileSync(dataFile, JSON.stringify({ keep: 'two-way' }));
+			fs.writeFileSync(file, 'two-way file');
+			fs.utimesSync(dataFile, newer, newer);
+			fs.utimesSync(file, newer, newer);
+			const output = xy(['sync', activeRoot, '--up', 'buckets', '--down', 'buckets', '--delete', 'false']);
+			assert.match(output, new RegExp('\\n\\n ⬆️ Updating bucket data: ' + title + ' \\(' + id + '\\)'));
+			assert.match(output, /-.*"keep": "remote"/);
+			assert.match(output, /\+.*"keep": "two-way"/);
+			const bucket = await call('getBucket', { id });
+			assert.deepEqual(bucket.data, { keep: 'two-way' });
+			const remoteFile = bucket.files.find(entry => entry.filename === 'seed.json');
+			assert.equal(remoteFile.size, Buffer.byteLength('two-way file'));
+			assert.equal(Math.floor(fs.statSync(file).mtimeMs / 1000), remoteFile.date);
+			assert.equal(Math.floor(fs.statSync(dataFile).mtimeMs / 1000), bucket.meta.mod);
+		});
+	}
+	finally {
+		// Ordinary sync writes a shared management map. Restore it exactly, then
+		// delete only this uniquely named Bucket and its content.
+		const cleanupErrors = [];
+		if (originalState !== null) {
+			try { await call('update_global_state', { sync: originalState }); }
+			catch (error) { cleanupErrors.push(error); }
+		}
+		if (created) {
+			try { await call('deleteBucket', { id }); }
+			catch (error) { cleanupErrors.push(error); }
+		}
+		if (cleanupErrors.length) throw new AggregateError(cleanupErrors, 'Bucket sync fixture cleanup failed');
+	}
+});

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);
+});