@pixlcore/xycli 1.0.1 → 1.0.3

package/lib/sync.js

@@ -30,6 +30,11 @@ module.exports = {
 		// xy sync --up "events,plugins" --delete plugins
 		await this.getMultiple();
 		
+		// Both ordinary sync and setup completion commands report failures through
+		// the shared warning and error collectors.
+		this.warnings = [];
+		this.errors = [];
+		
 		// optionally setup local filesystem for sync
 		if (this.args.other && (this.args.other[0] === 'setup')) {
 			this.args.other.shift();
@@ -72,9 +77,6 @@ module.exports = {
 			this.die("Delete mode requires up-only sync. Enable --up and disable --down.");
 		}
 		
-		this.warnings = [];
-		this.errors = [];
-		
 		// scan all base directories, default to cwd
 		var files = [];
 		if (!this.args.other || !this.args.other.length) {
@@ -635,19 +637,22 @@ module.exports = {
 		} // run_event
 	},
 	
-	syncFinishCmd(cmd) {
+	syncFinishCmd(cmd, opts) {
 		// spawn command and log output
-		var sconfig = this.sconfig;
-		var cwd = this.args.other[0]; // use first base dir as cwd for shell commands
+		opts = opts || {};
+		var sconfig = this.sconfig || {};
+		var cwd = opts.cwd || this.args.other[0]; // default to first normal sync base dir
+		var cmd_timeout = opts.cmd_timeout || sconfig.cmd_timeout || 30;
 		
 		println( "\n " + green.bold("Running completion command: ") + cyan.bold(cmd) );
 		
 		try {
 			const output = cp.execSync(cmd, {
 				cwd: cwd,
-				timeout: (sconfig.cmd_timeout || 30) * 1000,
+				timeout: cmd_timeout * 1000,
 				encoding: 'utf8',
-				stdio: ['ignore', 'pipe', 'pipe']
+				stdio: ['ignore', 'pipe', 'pipe'],
+				windowsHide: true
 			});
 			
 			if (output.match(/\S/)) {
@@ -732,12 +737,8 @@ module.exports = {
 	async setupSync() {
 		// export select resources to local XYPDF files in suggested layout
 		// xy sync --setup all --file_props "script,params.script"
+		// xy sync --setup events --new
 		// xy sync --setup all --marketplace --stock --force
-		var data_types = this.config.ui.data_types;
-		var list_data_types = Object.keys(data_types).map( key => {
-			return { ...data_types[key], id: key };
-		} );
-		
 		if ((this.args.setup === 'all') || (this.args.setup[0] === 'all')) {
 			this.args.setup = this.config.ui.list_list.map( list => list.id ).filter( id => !id.match(/^(buckets|secrets|users|roles)$/) );
 		}
@@ -760,87 +761,279 @@ module.exports = {
 			if (!Array.isArray(this.args.file_props)) this.dieUsage('sync setup');
 		}
 		
+		// New-only setup is intentionally an additive operation.  It must never be
+		// combined with the overwrite behavior of --force.
+		var new_only = false;
+		if (this.args.new !== undefined) {
+			if ((this.args.new !== true) && (this.args.new !== false)) {
+				this.die("Invalid --new value (use --new or --new false).");
+			}
+			new_only = this.args.new;
+		}
+		if (new_only && this.args.force) this.die("Sync setup --new cannot be combined with --force.");
+		
+		var default_ext = this.normalizeSyncDefaultExt(this.args.default_ext);
+		var existing_keys = new_only ? this.scanSyncSourceIndex(['.']) : {};
+		
 		this.printBoxList({
 			title: 'Sync Setup',
 			rows: [
 				['Item Types', this.args.setup.join(', ')],
 				['File Props', this.args.file_props ? this.args.file_props.join(', ') : '(None)'],
+				['Default Ext', '.' + default_ext],
+				new_only ? ['New Only', 'Yes'] : null,
 				this.dry ? ['Dry Run', 'No changes will be made.'] : null
 			]
 		});
 		
 		println( "\n " + this.color('theme').bold("WRITING FILES:") );
 		
-		// split up workflows into their own folder
-		if (this.args.setup.includes('events')) {
-			this.workflows = this.events.filter( event => event.type == 'workflow' );
-			this.events = this.events.filter( event => event.type != 'workflow' );
-			this.args.setup.push('workflows');
-			list_data_types.push( { id: "event", "list": "workflows" } );
+		var result = this.writeSyncSetupFiles(this.args.setup, {
+			base_dir: '.',
+			existing_keys: existing_keys,
+			new_only: new_only,
+			file_props: this.args.file_props || [],
+			default_ext: default_ext,
+			stock: !!this.args.stock,
+			marketplace: !!this.args.marketplace,
+			force: !!this.args.force,
+			dry: !!this.dry
+		});
+		
+		if (new_only && !result.written) println( "\n " + gray("No new definitions found.") );
+		
+		println( "\n " + this.color('theme').bold("Setup complete!") );
+		
+		// Setup writes into the current directory, not a positional base directory.
+		// Only run an explicitly supplied down command after real files were written.
+		if (!this.dry && result.written && this.args.down_cmd) {
+			this.syncFinishCmd(this.args.down_cmd, {
+				cwd: '.',
+				cmd_timeout: this.args.cmd_timeout
+			});
+		}
+	},
+	
+	normalizeSyncDefaultExt(value) {
+		// Allow users to choose the fallback extension for extracted properties whose
+		// language cannot be detected.  A leading dot is accepted for convenience,
+		// but paths and compound values are rejected before any files are written.
+		if (value === undefined) return 'txt';
+		if (typeof(value) != 'string') {
+			this.die("Invalid --default_ext value (use a filename extension such as ps1 or .ps1).");
 		}
 		
-		this.args.setup.forEach( (list_name) => {
-			var list = this[list_name];
-			if (!list || !list.length) return;
+		var ext = value.trim().replace(/^\./, '');
+		if (!ext.match(/^[A-Za-z0-9][A-Za-z0-9_]*$/)) {
+			this.die("Invalid --default_ext value (use a filename extension such as ps1 or .ps1).");
+		}
+		return ext;
+	},
+	
+	scanSyncSourceIndex(base_dirs) {
+		// Build an identity index from an existing sync tree.  Filenames and folders
+		// are deliberately ignored, because sync sources may be freely reorganized.
+		var files = [];
+		base_dirs.forEach( dir => {
+			dir = Path.normalize(dir).replace(/[\\/]+$/, '') || '.';
+			if (!fs.existsSync(dir)) this.die("Sync base dir does not exist: " + dir);
+			files = files.concat( Tools.findFilesSync(dir, { stats: true }) );
+		});
+		
+		var index = {};
+		files.filter( file => !!file.path.match(/\.json$/i) ).forEach( file => {
+			var xypdf = null;
+			try { xypdf = Tools.parseJSON( fs.readFileSync(file.path, 'utf8') ); }
+			catch (err) { this.die("Failed to parse JSON file: " + file.path + ": " + err); }
 			
-			var type_def = Tools.findObject( list_data_types, { list: list_name } );
-			if (!type_def) return; // sanity
+			// Ordinary JSON files are unrelated and may coexist in the tree.
+			if (!xypdf || !Tools.isaHash(xypdf) || (xypdf.type !== 'xypdf')) return;
+			if (xypdf.version !== '1.0') this.die("File is not a compatible version of XYPDF: " + file.path);
+			if (xypdf.xyops !== undefined && this.compareVersions(xypdf.xyops, this.xyopsVersion) > 0) {
+				this.die("Item requires xyOps v" + xypdf.xyops + " or higher: " + file.path);
+			}
+			if (!Array.isArray(xypdf.items) || (xypdf.items.length !== 1)) {
+				this.die("Sync source must contain exactly one item: " + file.path);
+			}
 			
-			if (!this.dry) Tools.mkdirp.sync( list_name );
-			println( "\n " + cli.emoji('📂') + " " + bold.cyan(list_name + '/') );
+			var item = xypdf.items[0];
+			if (!item || !Tools.isaHash(item) || !item.type || (typeof(item.type) != 'string')) {
+				this.die("Malformed item type in file: " + file.path);
+			}
+			if (item.type.match(/^(bucket|secret|user|role)$/)) {
+				this.die("Unsupported item type: " + item.type + " in file: " + file.path);
+			}
+			if (!item.data || !Tools.isaHash(item.data) || !item.data.id || (typeof(item.data.id) != 'string')) {
+				this.die("Malformed or missing item data or ID in file: " + file.path);
+			}
 			
-			list.forEach( (item) => {
-				// exclude marketplace and stock items
-				if (item.marketplace && !this.args.marketplace) return;
-				if (item.stock && !this.args.stock) return;
+			var type_def = this.config.ui.data_types[item.type];
+			if (!type_def) this.die("Cannot locate internal type definition: " + item.type);
+			var list = this[type_def.list];
+			if (!list) this.die("Cannot locate internal list: " + type_def.list);
+			if (!Tools.findObject(list, { id: item.data.id })) {
+				this.die("Cannot find " + item.type + " in xyOps: " + (item.data.title || item.data.id) + " (" + item.data.id + ")");
+			}
+			
+			var key = item.type + '-' + item.data.id;
+			if (index[key]) {
+				this.die("Duplicate source item found: " + file.path + " (already found in " + index[key].file + ")");
+			}
+			index[key] = { file: file.path, item: item };
+		});
+		
+		return index;
+	},
+	
+	writeSyncSetupFiles(list_names, opts = {}) {
+		// Write selected remote definitions using setup's suggested layout.  Keeping
+		// this operation separate allows a future downsync to append newly discovered
+		// remote definitions after it finishes updating existing local sources.
+		var data_types = this.config.ui.data_types;
+		var list_data_types = Object.keys(data_types).map( key => {
+			return { ...data_types[key], id: key };
+		});
+		var targets = [];
+		
+		list_names.forEach( list_name => {
+			if (list_name == 'events') {
+				targets.push({ name: 'events', type: 'event', items: this.events.filter( event => event.type != 'workflow' ) });
+				targets.push({ name: 'workflows', type: 'event', items: this.events.filter( event => event.type == 'workflow' ) });
+				return;
+			}
+			
+			var type_def = Tools.findObject( list_data_types, { list: list_name } );
+			if (type_def) targets.push({ name: list_name, type: type_def.id, items: this[list_name] || [] });
+		});
+		
+		var result = { written: 0, skipped: 0 };
+		var existing_keys = opts.existing_keys || {};
+		var base_dir = opts.base_dir || '.';
+		var default_ext = this.normalizeSyncDefaultExt(opts.default_ext);
+		
+		// Build and validate the complete write plan before creating any directories.
+		// Events and workflows are grouped under their xyOps Category titles.  A
+		// missing Category indicates inconsistent remote data, so setup must stop
+		// without leaving behind a partially generated tree.
+		targets.forEach( target => {
+			var items = target.items.filter( item => {
+				if (item.marketplace && !opts.marketplace) return false;
+				if (item.stock && !opts.stock) return false;
+				if (opts.new_only && existing_keys[target.type + '-' + item.id]) {
+					result.skipped++;
+					return false;
+				}
+				return true;
+			});
+			
+			target.plans = items.map( source_item => {
+				var dir = Path.join(base_dir, target.name);
+				var display_dir = target.name + '/';
+				
+				if (target.type == 'event') {
+					var category = Tools.findObject( this.categories, { id: source_item.category } );
+					if (!category) {
+						this.die("Cannot find Category for " + (source_item.type == 'workflow' ? 'workflow' : 'Event') + ": " + (source_item.title || source_item.id) + " (" + (source_item.category || 'missing ID') + ")");
+					}
+					
+					var category_slug = this.getSyncSetupTitleSlug(category.title, 'Category', category.id);
+					dir = Path.join(dir, category_slug);
+					display_dir += category_slug + '/';
+				}
 				
-				// extract extras first
+				var title = this.getSyncSetupTitleSlug(source_item.title, (source_item.type == 'workflow' ? 'workflow' : target.type), source_item.id);
+				return { source_item, title, dir, display_dir };
+			});
+			
+			// Remote Event order is not guaranteed to keep Categories together. Group
+			// plans explicitly so each printed folder heading owns every file shown
+			// beneath it, while preserving the first-seen order of folders and items.
+			var groups_by_dir = new Map();
+			var plan_groups = [];
+			target.plans.forEach( plan => {
+				var group = groups_by_dir.get(plan.dir);
+				if (!group) {
+					group = [];
+					groups_by_dir.set(plan.dir, group);
+					plan_groups.push(group);
+				}
+				group.push(plan);
+			});
+			target.plans = [].concat(...plan_groups);
+		});
+		
+		// All Categories are now known to be valid, so it is safe to start writing.
+		targets.forEach( target => {
+			var active_dir = '';
+			target.plans.forEach( plan => {
+				var dir = plan.dir;
+				if (dir != active_dir) {
+					if (!opts.dry) Tools.mkdirp.sync(dir);
+					println( "\n " + cli.emoji('📂') + " " + bold.cyan(plan.display_dir) );
+					active_dir = dir;
+				}
+			
+				// Work on a deep copy so setup never changes the cached remote definition.
+				var item = Tools.copyHash(plan.source_item, true);
 				var extras = [];
-				(this.args.file_props || []).forEach( (path) => {
+				(opts.file_props || []).forEach( path => {
 					var extra = Tools.getPath(item, path);
 					if ((typeof(extra) == 'string') && extra.match(/\S/)) {
 						extras.push({ path, content: extra });
-						
-						// we do not need to check the return value of setPath here,
-						// because this path is guaranteed to exist at this point
 						Tools.setPath( item, path, "(External)" );
 					}
-				} );
+				});
 				
-				var data = this.getItemExportData(type_def.id, item);
-				var title = item.title.replace(/\W+/g, '-').replace(/\-+$/, '').replace(/^\-+/, '');
+				var data = this.getItemExportData(target.type, item);
+				var title = plan.title;
 				var filename = title + '.json';
-				var file = Path.join(list_name, filename);
+				var file = Path.join(dir, filename);
 				
-				if (!this.dry) {
-					if (!this.args.force && fs.existsSync(file)) this.die("File exists, add '--force' to overwrite all: " + file);
+				if (!opts.dry) {
+					if (!opts.force && fs.existsSync(file)) this.die("File exists, add '--force' to overwrite all: " + file);
 					Tools.writeFileAtomicSync( file, JSON.stringify(data, null, "\t") + "\n" );
 				}
 				println( "    " + cli.emoji('📄') + " " + bold.green(filename) );
+				result.written++;
 				
-				// now handle extras
-				extras.forEach( (extra) => {
+				extras.forEach( extra => {
 					var command = item.command;
 					if (!command && extra.content.match(/^\s*\#\!(.+?)\n/)) command = RegExp.$1;
 					
-					var ext = 'txt';
-					if (command) ext = this.getExtFromBinary(command);
+					var ext = default_ext;
+					if (command) {
+						var detected_ext = this.getExtFromBinary(command);
+						if (detected_ext != 'txt') ext = detected_ext;
+					}
 					else if (extra.content.trim().match(/^\{[\S\s]*\}$/) || extra.content.trim().match(/^\[[\S\s]*\]$/)) ext = 'json';
 					
 					var extra_filename = title + '-' + extra.path + '.' + ext;
-					var extra_file = Path.join(list_name, extra_filename);
-					
-					if (!this.dry) {
-						if (!this.args.force && fs.existsSync(extra_file)) this.die("File exists, add '--force' to overwrite all: " + extra_file);
+					var extra_file = Path.join(dir, extra_filename);
+					if (!opts.dry) {
+						if (!opts.force && fs.existsSync(extra_file)) this.die("File exists, add '--force' to overwrite all: " + extra_file);
 						Tools.writeFileAtomicSync( extra_file, extra.content );
 					}
-					
 					println( "    " + cli.emoji('📜') + " " + bold.yellow(extra_filename) );
-				} );
-			} ); // foreach item
-		} ); // foreach list
+				});
+			});
+		});
 		
-		println( "\n " + this.color('theme').bold("Setup complete!") );
+		return result;
+	},
+	
+	getSyncSetupTitleSlug(title, item_type, item_id) {
+		// Use one filename-safe transformation for definitions and Category folders.
+		// Reject unusable titles explicitly instead of silently producing `.json` or
+		// collapsing an Event back into the top-level resource directory.
+		if (typeof(title) != 'string') {
+			this.die("Cannot create sync setup path for " + item_type + ": Missing title (" + item_id + ")");
+		}
+		
+		var slug = title.replace(/\W+/g, '-').replace(/\-+$/, '').replace(/^\-+/, '');
+		if (!slug) {
+			this.die("Cannot create sync setup path for " + item_type + ": Title has no usable filename characters (" + item_id + ")");
+		}
+		return slug;
 	},
 	
 	getItemExportData(type, item) {

package/lib/utils.js

@@ -254,7 +254,21 @@ module.exports = {
 		// This mirrors the xyOps UI helper, while avoiding slow source auto-detection
 		// for common interpreters.
 		if ((typeof(bin) != 'string') || !bin.trim()) return null;
-		var cmd = Path.basename( bin.trim() ).replace(/\s+.+$/, '').replace(/\d+$/, '').toLowerCase();
+		
+		// Normalize both path styles because Plugin definitions may come from a
+		// different operating system than the CLI displaying them.  Remove command
+		// arguments before taking the basename, including quoted paths with spaces.
+		var cmdline = bin.trim().replace(/\\/g, '/');
+		var cmd = cmdline;
+		if (cmd.match(/^(?:.*\/)?env(?:\.exe)?\s+(?:\-S\s+)?(\S+)/i)) cmd = RegExp.$1;
+		else if (cmd.match(/^"([^"]+)"/)) cmd = RegExp.$1;
+		else if (cmd.match(/^'([^']+)'/)) cmd = RegExp.$1;
+		else cmd = cmd.replace(/\s+.+$/, '');
+		cmd = Path.posix.basename(cmd);
+		
+		// Windows executables conventionally include .exe.  Version suffixes are
+		// also common for interpreters such as python3.12 and node24.
+		cmd = cmd.replace(/\.exe$/i, '').replace(/\d+(?:\.\d+)*$/, '').toLowerCase();
 		
 		switch (cmd) {
 			case 'sh':
@@ -268,14 +282,26 @@ module.exports = {
 			break;
 			
 			case 'node':
+			case 'nodejs':
 			case 'deno':
 			case 'bun':
 				cmd = 'javascript';
 			break;
 			
 			case 'pwsh':
+			case 'powershell':
 				cmd = 'powershell';
 			break;
+			
+			case 'cmd':
+				cmd = 'dos';
+			break;
+			
+			case 'py':
+			case 'pythonw':
+			case 'pypy':
+				cmd = 'python';
+			break;
 		}
 		
 		return HIGHLIGHT_LANGUAGES.includes(cmd) ? cmd : null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pixlcore/xycli",
-	"version": "1.0.1",
+	"version": "1.0.3",
 	"description": "A complete command-line interface for the xyOps workflow automation system.",
 	"author": "Joseph Huckaby <jhuckaby@pixlcore.com>",
 	"homepage": "https://github.com/pixlcore/xycli",
@@ -20,7 +20,9 @@
 		"xyops", "cli"
 	],
 	"scripts": {
-		"test": "node test.js"
+		"test": "node test.js",
+		"test:offline": "node --test test/config.test.js test/help.test.js test/markdown.test.js test/sync-unit.test.js test/toast.test.js test/utils-unit.test.js",
+		"changelog": "node tools/changelog.js"
 	},
 	"dependencies": {
 		"@pixlcore/xyops-sdk": "^1.0.7",

package/test/README.md

@@ -67,7 +67,7 @@ node --test test/config.test.js test/sync-unit.test.js
 | `servers` | Active and recently offline lists, local filters, installer generation, historical search, live and historical Server details, charts, processes, connections, pagination, validation, help |
 | `system` | Admin dashboard, conductors, connected users, export, maintenance, optimization, rate resets, diagnostics, broadcasts, help |
 | `sync` | Setup export, isolated filesystem discovery, external property files, dry-run, upsync, downsync, composite global-state governance, no-op detection, and guarded delete mode |
-| `sync-unit` | Offline PID locking and stale recovery, up-only deletion guards, pre-delete failure blocking, stock/Marketplace deletion protection, inherited settings and CLI overrides, warning/error exit status, duplicates, quiet/dry runs, completion failures, and notification delivery after warnings or errors |
+| `sync-unit` | Offline setup extension fallbacks, new-only exports and setup completion commands, PID locking and stale recovery, up-only deletion guards, pre-delete failure blocking, stock/Marketplace deletion protection, inherited settings and CLI overrides, warning/error exit status, duplicates, quiet/dry runs, completion failures, and notification delivery after warnings or errors |
 | `tags` | CRUD, metadata search, sparse future-proof updates, JSON input, validation, pagination, help |
 | `tickets` | Search, CRUD, number resolution, comments, attachment uploads/downloads, Events, related Job lookup, sparse updates, validation, help |
 | `toast` | Warning-box word wrapping and terminal-width limits |

package/test/config.test.js

@@ -4,12 +4,25 @@ const fs = require('node:fs');
 const os = require('node:os');
 const Path = require('node:path');
 const { spawnSync } = require('node:child_process');
+const config = require('../lib/config.js');
+
+function assertPrivateMode(file) {
+	// Windows permissions are represented by ACLs, not Unix owner/group/other
+	// mode bits.  The file still has to exist, but an exact 0600 assertion only
+	// describes the Unix behavior that fs.chmodSync can enforce.
+	assert.equal(fs.existsSync(file), true);
+	if (process.platform != 'win32') assert.equal(fs.statSync(file).mode & 0o777, 0o600);
+}
 
 function createConfigFixture(t, initial) {
 	// Give each CLI process a disposable home directory.  Config commands exit
 	// before contacting xyOps, so these checks need no development server.
 	const home_dir = fs.mkdtempSync(Path.join(os.tmpdir(), 'xycli-config-'));
-	t.after(() => fs.rmSync(home_dir, { recursive: true, force: true }));
+	const program_data = fs.mkdtempSync(Path.join(os.tmpdir(), 'xycli-program-data-'));
+	t.after(() => {
+		fs.rmSync(home_dir, { recursive: true, force: true });
+		fs.rmSync(program_data, { recursive: true, force: true });
+	});
 	const file = Path.join(home_dir, '.config', 'xyops', 'cli.json');
 	
 	if (initial) {
@@ -20,17 +33,26 @@ function createConfigFixture(t, initial) {
 	return {
 		file,
 		run(args) {
+			const env = {
+				...process.env,
+				HOME: home_dir,
+				USERPROFILE: home_dir,
+				ProgramData: program_data,
+				XYOPS_API_KEY: 'fixture-key',
+				XYOPS_BASE_URL: 'https://fixture.invalid',
+				XYOPS_ITEMS_PER_PAGE: '99',
+				XYOPS_COLOR: 'false'
+			};
+			
+			// Prove the Windows code path does not receive a compatibility HOME
+			// variable from Git Bash, WSL, or the parent test environment.
+			if (process.platform == 'win32') delete env.HOME;
+			
 			const result = spawnSync(process.execPath, [Path.join(__dirname, '..', 'index.js'), 'config', ...args], {
 				encoding: 'utf8',
 				timeout: 10000,
-				env: {
-					...process.env,
-					HOME: home_dir,
-					XYOPS_API_KEY: 'fixture-key',
-					XYOPS_BASE_URL: 'https://fixture.invalid',
-					XYOPS_ITEMS_PER_PAGE: '99',
-					XYOPS_COLOR: 'false'
-				}
+				windowsHide: true,
+				env
 			});
 			
 			// Keep captured CLI output out of assertion messages, since a config
@@ -43,6 +65,24 @@ function createConfigFixture(t, initial) {
 	};
 }
 
+test('config resolves native Unix and Windows source paths', () => {
+	assert.deepEqual(config.getConfigFiles('linux', {}, '/home/nick'), [
+		'/etc/xyops/cli.json',
+		'/home/nick/.config/xyops/cli.json'
+	]);
+	assert.deepEqual(config.getConfigFiles('win32', { ProgramData: 'C:\\ProgramData' }, 'C:\\Users\\Nick'), [
+		'C:\\ProgramData\\xyops\\cli.json',
+		'C:\\Users\\Nick\\.config\\xyops\\cli.json'
+	]);
+	assert.deepEqual(config.getConfigFiles('win32', { ALLUSERSPROFILE: 'D:\\SharedData' }, 'C:\\Users\\Nick'), [
+		'D:\\SharedData\\xyops\\cli.json',
+		'C:\\Users\\Nick\\.config\\xyops\\cli.json'
+	]);
+	assert.deepEqual(config.getConfigFiles('win32', {}, 'C:\\Users\\Nick'), [
+		'C:\\Users\\Nick\\.config\\xyops\\cli.json'
+	]);
+});
+
 test('config updates only requested user settings without saving inherited overrides', t => {
 	const fixture = createConfigFixture(t, {
 		items_per_page: 10,
@@ -61,7 +101,7 @@ test('config updates only requested user settings without saving inherited overr
 		suggest: true,
 		sync: { up: ['events'], down: false }
 	});
-	assert.equal(fs.statSync(fixture.file).mode & 0o777, 0o600);
+	assertPrivateMode(fixture.file);
 });
 
 test('config creates a missing user file with only supplied settings', t => {
@@ -69,7 +109,7 @@ test('config creates a missing user file with only supplied settings', t => {
 	fixture.run(['--items_per_page', '25']);
 	
 	assert.deepEqual(fixture.read(), { items_per_page: 25 });
-	assert.equal(fs.statSync(fixture.file).mode & 0o777, 0o600);
+	assertPrivateMode(fixture.file);
 });
 
 test('config dotted updates preserve sibling user settings and explicit false or zero values', t => {

package/test/helpers/common.js

@@ -59,6 +59,7 @@ function runCLI(args, options = {}) {
 		timeout: 30000,
 		maxBuffer: 16 * 1024 * 1024,
 		input: options.input,
+		windowsHide: true,
 		env: {
 			...process.env,
 			XYOPS_COLOR: 'false',