@pixlcore/xycli 1.0.1 → 1.0.3

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,17 +83,41 @@ 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
+		timeout: 10000,
+		windowsHide: true
 	});
 	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 +245,247 @@ 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' };
@@ -391,7 +660,8 @@ test('sync PID lock rejects an overlapping run and cleans up afterward', async t
 	`;
 	const holder = spawn(process.execPath, ['-e', holderScript, lockFile], {
 		cwd: Path.join(__dirname, '..'),
-		stdio: ['ignore', 'pipe', 'pipe']
+		stdio: ['ignore', 'pipe', 'pipe'],
+		windowsHide: true
 	});
 	
 	await new Promise((resolve, reject) => {

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/test/utils-unit.test.js

@@ -0,0 +1,19 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const utils = require('../lib/utils.js');
+
+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.
+	assert.equal(utils.getLangFromBinary('/usr/bin/node --use-strict'), 'javascript');
+	assert.equal(utils.getLangFromBinary('/usr/bin/python3.12 -u'), 'python');
+	assert.equal(utils.getLangFromBinary('/bin/bash'), 'shell');
+	assert.equal(utils.getLangFromBinary('/usr/bin/env -S node --use-strict'), 'javascript');
+	assert.equal(utils.getLangFromBinary('"C:\\Program Files\\nodejs\\node.exe" --use-strict'), 'javascript');
+	assert.equal(utils.getLangFromBinary('C:\\Python312\\python.exe -u'), 'python');
+	assert.equal(utils.getLangFromBinary('pwsh.exe -File'), 'powershell');
+	assert.equal(utils.getLangFromBinary('powershell.exe -File'), 'powershell');
+	assert.equal(utils.getLangFromBinary('cmd.exe /c'), 'dos');
+	assert.equal(utils.getLangFromBinary('unknown-binary.exe'), null);
+	assert.equal(utils.getLangFromBinary(null), null);
+});

package/test.js

@@ -30,7 +30,8 @@ else {
 		// suite does not prevent the remaining suites from running and reporting.
 		const child = spawn(process.execPath, ['--test', '--test-concurrency=1', ...files], {
 			cwd: __dirname,
-			stdio: 'inherit'
+			stdio: 'inherit',
+			windowsHide: true
 		});
 		
 		child.on('error', error => {

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', windowsHide: true }).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', windowsHide: true }).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', windowsHide: true }).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', windowsHide: true }).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', windowsHide: true } );