@pixlcore/xycli 1.0.7 → 1.0.9

package/test/sync-unit.test.js

@@ -18,6 +18,7 @@ const script = `
 	if (options.setupCwd) process.chdir(options.setupCwd);
 	const calls = [];
 	const requests = [];
+	const apiOptions = [];
 	const app = {
 		...sync,
 		args: options.args,
@@ -41,9 +42,10 @@ const script = `
 		compareVersions() { return 0; },
 		async getMultiple() {},
 		die(message) { throw new Error(message); },
-		async callStandardAPI(method, data) {
+		async callStandardAPI(method, data, opts) {
 			calls.push(method);
 			requests.push({ method, data });
+			apiOptions.push({ method, opts });
 			if (options.failAPI === method) throw new Error('Fixture API failure');
 		}
 	};
@@ -51,7 +53,7 @@ const script = `
 		console.error(err.message);
 		process.exitCode = 1;
 	}).finally(() => {
-		console.log(JSON.stringify({ calls, requests, errors: app.errors || [], warnings: app.warnings || [] }));
+		console.log(JSON.stringify({ calls, requests, apiOptions, errors: app.errors || [], warnings: app.warnings || [] }));
 	});
 `;
 
@@ -225,6 +227,87 @@ 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' };
+	const result = runSync(t, {
+		plugins: [remote],
+		existingSources: [{ path: 'Legacy.json', type: 'plugin', data: local }],
+		args: { up: 'plugins' }
+	});
+	
+	assert.equal(result.status, 0);
+	assert.deepEqual(result.report.requests.find(request => request.method === 'update_plugin').data, local);
+	assert.equal(result.report.apiOptions.find(call => call.method === 'update_plugin').opts.sync, true);
+});
+
 test('sync API errors preserve failure status while still sending both notifications', t => {
 	const category = { id: 'fixture', title: 'Fixture', notes: 'Remote' };
 	for (const failAPI of ['update_category', 'update_global_state', 'delete_category']) {
@@ -297,6 +380,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/toast.test.js

@@ -7,14 +7,14 @@ cli.global();
 
 test('toast wraps within the terminal width without ellipsis', () => {
 	const originalWidth = cli.width;
-	const originalWrite = process.stdout.write;
+	const originalWrite = process.stderr.write;
 	const originalColor = cli.chalk.enabled;
 	let output = '';
 	
 	try {
 		cli.width = function() { return 40; };
 		cli.chalk.enabled = false;
-		process.stdout.write = function(chunk) {
+		process.stderr.write = function(chunk) {
 			output += chunk;
 			return true;
 		};
@@ -27,7 +27,7 @@ test('toast wraps within the terminal width without ellipsis', () => {
 	finally {
 		cli.width = originalWidth;
 		cli.chalk.enabled = originalColor;
-		process.stdout.write = originalWrite;
+		process.stderr.write = originalWrite;
 	}
 	
 	const box_lines = output.split('\n').filter( line => line.match(/[┌│└]/) );

package/test/utils-unit.test.js

@@ -1,7 +1,10 @@
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
+const cli = require('pixl-cli');
 const utils = require('../lib/utils.js');
 
+cli.global();
+
 test('executable language detection accepts Unix and Windows command forms', () => {
 	// Plugin definitions are portable, so exercise both path styles regardless of
 	// the operating system running this test.
@@ -17,3 +20,50 @@ test('executable language detection accepts Unix and Windows command forms', ()
 	assert.equal(utils.getLangFromBinary('unknown-binary.exe'), null);
 	assert.equal(utils.getLangFromBinary(null), null);
 });
+
+test('sync API updates preserve stored properties while manual updates retain typo checks', async () => {
+	const calls = [];
+	const context = {
+		...utils,
+		dry: false,
+		verbose: false,
+		api: {
+			async update_plugin(request, opts) {
+				calls.push({ method: 'update_plugin', request, opts });
+				return { err: null, data: { code: 0 } };
+			},
+			async update_event(request, opts) {
+				calls.push({ method: 'update_event', request, opts });
+				return { err: null, data: { code: 0 } };
+			}
+		},
+		die(message) { throw new Error(message); }
+	};
+	
+	for (const [method, request] of [
+		['update_plugin', { id: 'legacy_plugin', cwd: '/tmp/legacy' }],
+		['update_event', { id: 'legacy_event', custom_field: { enabled: true } }]
+	]) {
+		// A hand-typed update still rejects an unknown top-level property.
+		const prior_calls = calls.length;
+		await assert.rejects(context.callStandardAPI(method, request), /Unsupported property/);
+		assert.equal(calls.length, prior_calls);
+		
+		// Sync forwards the complete stored object to xyOps for its own validation.
+		await context.callStandardAPI(method, request, { sync: true });
+		assert.equal(calls.length, prior_calls + 1);
+		assert.deepEqual(calls.at(-1), { method, request, opts: {} });
+	}
+	
+	// The original report failed during dry sync, before any xyOps request.
+	// Preview the same Plugin payload and verify that it makes no SDK call.
+	const plugin_request = { id: 'legacy_plugin', cwd: '/tmp/legacy' };
+	const previews = [];
+	const prior_calls = calls.length;
+	context.dry = true;
+	context.color = () => cli.chalk.white;
+	context.jsonOutput = request => { previews.push(request); };
+	await context.callStandardAPI('update_plugin', plugin_request, { sync: true });
+	assert.deepEqual(previews, [plugin_request]);
+	assert.equal(calls.length, prior_calls);
+});