@pixlcore/xycli 1.0.6 → 1.0.8

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-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,20 @@ test('sync errors exit nonzero even in quiet mode or a dry run', t => {
 	}
 });
 
+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']) {
@@ -432,6 +448,61 @@ test('sync setup groups Events and workflows into Category folders', t => {
 	assert.equal(result.stdout.indexOf('events/Operations-Team/', operationsHeader + 1), -1);
 });
 
+test('sync setup externalizes each matching workflow node parameter', t => {
+	const shellScript = '#!/bin/sh\necho first\n';
+	const nodeScript = '#!/usr/bin/env node\nconsole.log("second");\n';
+	const workflow = {
+		id: 'flow', title: 'Flow', type: 'workflow', category: 'operations',
+		workflow: { nodes: [
+			{ id: 'ntrigger1', type: 'trigger' },
+			{ id: 'nfirst01', type: 'event', data: { params: { script: shellScript } } },
+			{ id: 'nsecond1', type: 'job', data: { params: { script: nodeScript } } },
+			{ id: 'nempty001', type: 'job', data: { params: { script: '' } } }
+		] }
+	};
+	const result = runSync(t, {
+		setup: ['events'],
+		categories: [{ id: 'operations', title: 'Operations' }],
+		events: [workflow],
+		args: { file_props: 'params.script' }
+	});
+	const dir = Path.join(result.dir, 'workflows', 'Operations');
+	const source = JSON.parse(fs.readFileSync(Path.join(dir, 'Flow.json'), 'utf8')).items[0].data;
+	
+	assert.equal(result.status, 0);
+	assert.deepEqual(result.report.errors, []);
+	assert.equal(fs.readFileSync(Path.join(dir, 'Flow-workflow.nfirst01.params.script.sh'), 'utf8'), shellScript);
+	assert.equal(fs.readFileSync(Path.join(dir, 'Flow-workflow.nsecond1.params.script.js'), 'utf8'), nodeScript);
+	assert.equal(source.workflow.nodes[1].data.params.script, '(External)');
+	assert.equal(source.workflow.nodes[2].data.params.script, '(External)');
+	assert.equal(source.workflow.nodes[3].data.params.script, '');
+	assert.equal(fs.readdirSync(dir).length, 3, 'Empty and trigger nodes have no neighbor files');
+});
+
+test('sync setup accepts a shorthand path for one workflow node', t => {
+	const workflow = {
+		id: 'flow', title: 'Flow', type: 'workflow', category: 'operations',
+		workflow: { nodes: [
+			{ id: 'nfirst01', type: 'job', data: { params: { script: 'First\n' } } },
+			{ id: 'nsecond1', type: 'job', data: { params: { script: 'Second\n' } } }
+		] }
+	};
+	const result = runSync(t, {
+		setup: ['events'],
+		categories: [{ id: 'operations', title: 'Operations' }],
+		events: [workflow],
+		args: { file_props: 'workflow.nfirst01.params.script' }
+	});
+	const dir = Path.join(result.dir, 'workflows', 'Operations');
+	const source = JSON.parse(fs.readFileSync(Path.join(dir, 'Flow.json'), 'utf8')).items[0].data;
+	
+	assert.equal(result.status, 0);
+	assert.equal(fs.readFileSync(Path.join(dir, 'Flow-workflow.nfirst01.params.script.txt'), 'utf8'), 'First\n');
+	assert.equal(source.workflow.nodes[0].data.params.script, '(External)');
+	assert.equal(source.workflow.nodes[1].data.params.script, 'Second\n');
+	assert.equal(fs.readdirSync(dir).length, 2);
+});
+
 test('sync setup validates all Event Categories before writing any files', t => {
 	const result = runSync(t, {
 		setup: ['plugins', 'events'],
@@ -655,6 +726,112 @@ test('property neighbor matching requires an exact source basename boundary', t
 	assert.equal(result.report.requests.some(request => request.method === 'update_event'), false);
 });
 
+test('workflow node neighbors replace placeholders before upload', t => {
+	const shellScript = '#!/bin/sh\necho local\n';
+	const nodeScript = '#!/usr/bin/env node\nconsole.log("local");\n';
+	const remote = {
+		id: 'flow', title: 'Flow', type: 'workflow', category: 'operations',
+		workflow: { nodes: [
+			{ id: 'nfirst01', type: 'event', data: { params: { script: 'Remote shell\n' } } },
+			{ id: 'nsecond1', type: 'job', data: { params: { script: 'Remote node\n' } } }
+		] }
+	};
+	const local = JSON.parse(JSON.stringify(remote));
+	local.workflow.nodes.forEach(node => { node.data.params.script = '(External)'; });
+	const result = runSync(t, {
+		events: [remote],
+		existingSources: [
+			{ path: 'Flow.json', type: 'event', data: local },
+			{ path: 'Flow-workflow.nfirst01.params.script.sh', contents: shellScript },
+			{ path: 'Flow-workflow.nsecond1.params.script.js', contents: nodeScript }
+		],
+		args: { up: 'events' }
+	});
+	const updates = result.report.requests.filter(request => request.method === 'update_event');
+	
+	assert.equal(result.status, 0);
+	assert.deepEqual(result.report.warnings, []);
+	assert.deepEqual(result.report.errors, []);
+	assert.equal(updates.length, 1);
+	assert.equal(updates[0].data.workflow.nodes[0].data.params.script, shellScript);
+	assert.equal(updates[0].data.workflow.nodes[1].data.params.script, nodeScript);
+	const source = JSON.parse(fs.readFileSync(Path.join(result.dir, 'Flow.json'), 'utf8')).items[0].data;
+	assert.equal(source.workflow.nodes[0].data.params.script, '(External)');
+	assert.equal(source.workflow.nodes[1].data.params.script, '(External)');
+});
+
+test('workflow node neighbors receive pulled values while JSON keeps placeholders', t => {
+	const shellScript = '#!/bin/sh\necho remote\n';
+	const nodeScript = '#!/usr/bin/env node\nconsole.log("remote");\n';
+	const remote = {
+		id: 'flow', title: 'Flow', type: 'workflow', category: 'operations',
+		workflow: { nodes: [
+			{ id: 'nfirst01', type: 'event', data: { params: { script: shellScript } } },
+			{ id: 'nsecond1', type: 'job', data: { params: { script: nodeScript } } }
+		] }
+	};
+	const local = JSON.parse(JSON.stringify(remote));
+	local.workflow.nodes.forEach(node => { node.data.params.script = '(External)'; });
+	const result = runSync(t, {
+		events: [remote],
+		existingSources: [
+			{ path: 'Flow.json', type: 'event', data: local },
+			{ path: 'Flow-workflow.nfirst01.params.script.sh', contents: 'Old shell\n' },
+			{ path: 'Flow-workflow.nsecond1.params.script.js', contents: 'Old node\n' }
+		],
+		args: { down: 'events' }
+	});
+	const source = JSON.parse(fs.readFileSync(Path.join(result.dir, 'Flow.json'), 'utf8')).items[0].data;
+	
+	assert.equal(result.status, 0);
+	assert.deepEqual(result.report.warnings, []);
+	assert.deepEqual(result.report.errors, []);
+	assert.equal(fs.readFileSync(Path.join(result.dir, 'Flow-workflow.nfirst01.params.script.sh'), 'utf8'), shellScript);
+	assert.equal(fs.readFileSync(Path.join(result.dir, 'Flow-workflow.nsecond1.params.script.js'), 'utf8'), nodeScript);
+	assert.equal(source.workflow.nodes[0].data.params.script, '(External)');
+	assert.equal(source.workflow.nodes[1].data.params.script, '(External)');
+});
+
+test('workflow node shorthand preserves ordinary indexed dot paths', () => {
+	const sync = require('../lib/sync.js');
+	const data = { workflow: { nodes: [
+		{ id: 'nfirst01', data: { params: { script: 'Original\n' } } }
+	] } };
+	
+	// The literal "nodes" segment must not be mistaken for a workflow node ID.
+	assert.equal(sync.getSyncPropByPath(data, 'workflow.nfirst01.params.script'), 'Original\n');
+	assert.equal(sync.getSyncPropByPath(data, 'workflow.nodes.0.data.params.script'), 'Original\n');
+	assert.equal(sync.setSyncPropByPath(data, 'workflow.nodes.0.data.params.script', 'Indexed\n'), true);
+	assert.equal(sync.getSyncPropByPath(data, 'workflow.nfirst01.params.script'), 'Indexed\n');
+	assert.equal(sync.setSyncPropByPath(data, 'workflow.nfirst01.params.script', 'Shorthand\n'), true);
+	assert.equal(sync.getSyncPropByPath(data, 'workflow.nodes.0.data.params.script'), 'Shorthand\n');
+	assert.equal(sync.getSyncPropByPath(data, 'workflow.nmissing1.params.script'), undefined);
+	assert.equal(sync.setSyncPropByPath(data, 'workflow.nmissing1.params.script', 'Missing\n'), undefined);
+	assert.equal(data.workflow.nodes.length, 1);
+});
+
+test('a workflow neighbor for a missing node stops sync before upload', t => {
+	const workflow = {
+		id: 'flow', title: 'Flow', type: 'workflow', category: 'operations',
+		workflow: { nodes: [
+			{ id: 'nfirst01', type: 'job', data: { params: { script: 'Inline\n' } } }
+		] }
+	};
+	const result = runSync(t, {
+		events: [workflow],
+		existingSources: [
+			{ path: 'Flow.json', type: 'event', data: workflow },
+			{ path: 'Flow-workflow.nmissing1.params.script.sh', contents: 'Orphan\n' }
+		],
+		args: { up: 'events' }
+	});
+	
+	assert.equal(result.status, 1);
+	assert.match(result.report.warnings[0], /does not match an existing string property/);
+	assert.deepEqual(result.report.errors, []);
+	assert.equal(result.report.requests.some(request => request.method === 'update_event'), false);
+});
+
 test('a property neighbor must resolve to an existing string property', t => {
 	const category = { id: 'fixture', title: 'Fixture', notes: '' };
 	const result = runSync(t, {

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