@cbnventures/nova 0.12.0 → 0.13.0

package/build/src/tests/lib/utility.test.js

@@ -1,47 +1,43 @@
-import * as assert from 'node:assert/strict';
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { before, after, describe, it, } from 'node:test';
-import { discoverPathsWithFile } from '../../lib/utility.js';
+import { deepStrictEqual, fail, match, notStrictEqual, ok, strictEqual, } from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, sep, } from 'node:path';
+import { test } from 'node:test';
+import { currentTimestamp, detectShell, discoverPathsWithFile, executeShell, isCommandExists, isExecuteShellError, isFileIdentical, isPlainObject, isProjectRoot, loadWorkspaceManifests, parseLinuxOsReleaseText, parseWindowsRegistryText, pathExists, renameFileWithDate, saveWorkspaceManifest, } from '../../lib/utility.js';
 import { Logger } from '../../toolkit/index.js';
-describe('discoverPathsWithFile', (context) => {
-    let originalCwd;
-    let sandboxRoot;
-    before(async () => {
-        originalCwd = process.cwd();
-        sandboxRoot = await fs.mkdtemp(path.join(os.tmpdir(), `nova-${context.name}-`));
-    });
-    after(async () => {
+test('discoverPathsWithFile', async (context) => {
+    const originalCwd = process.cwd();
+    const sandboxRoot = await mkdtemp(join(tmpdir(), `nova-${context.name}-`));
+    context.after(async () => {
         process.chdir(originalCwd);
-        await fs.rm(sandboxRoot, {
+        await rm(sandboxRoot, {
             recursive: true,
             force: true,
         });
     });
-    it('finds every package.json when traversing forward', async () => {
-        const projectRoot = path.join(sandboxRoot, 'forward');
-        const appRoot = path.join(projectRoot, 'apps', 'some-app');
-        const packageRoot = path.join(projectRoot, 'packages', 'some-package');
-        const nodeRoot = path.join(projectRoot, 'node_modules', 'ignore-me');
-        const dotHiddenRoot = path.join(projectRoot, '.hidden', 'ignore-me');
+    await context.test('finds every package.json when traversing forward', async () => {
+        const projectRoot = join(sandboxRoot, 'forward');
+        const appRoot = join(projectRoot, 'apps', 'some-app');
+        const packageRoot = join(projectRoot, 'packages', 'some-package');
+        const nodeRoot = join(projectRoot, 'node_modules', 'ignore-me');
+        const dotHiddenRoot = join(projectRoot, '.hidden', 'ignore-me');
         await Promise.all([
-            fs.mkdir(appRoot, { recursive: true }),
-            fs.mkdir(packageRoot, { recursive: true }),
-            fs.mkdir(nodeRoot, { recursive: true }),
-            fs.mkdir(dotHiddenRoot, { recursive: true }),
+            mkdir(appRoot, { recursive: true }),
+            mkdir(packageRoot, { recursive: true }),
+            mkdir(nodeRoot, { recursive: true }),
+            mkdir(dotHiddenRoot, { recursive: true }),
         ]);
         await Promise.all([
-            fs.writeFile(path.join(projectRoot, 'package.json'), '{}\n'),
-            fs.writeFile(path.join(appRoot, 'package.json'), '{}\n'),
-            fs.writeFile(path.join(packageRoot, 'package.json'), '{}\n'),
-            fs.writeFile(path.join(nodeRoot, 'package.json'), '{}\n'),
-            fs.writeFile(path.join(dotHiddenRoot, 'package.json'), '{}\n'),
+            writeFile(join(projectRoot, 'package.json'), '{}\n'),
+            writeFile(join(appRoot, 'package.json'), '{}\n'),
+            writeFile(join(packageRoot, 'package.json'), '{}\n'),
+            writeFile(join(nodeRoot, 'package.json'), '{}\n'),
+            writeFile(join(dotHiddenRoot, 'package.json'), '{}\n'),
         ]);
-        const realProjectRoot = await fs.realpath(projectRoot);
+        const realProjectRoot = await realpath(projectRoot);
         process.chdir(realProjectRoot);
         const absolutePaths = await discoverPathsWithFile('package.json', 'forward');
-        const relativePaths = absolutePaths.map((absolutePath) => path.relative(realProjectRoot, absolutePath).split(path.sep).join('/'));
+        const relativePaths = absolutePaths.map((absolutePath) => relative(realProjectRoot, absolutePath).split(sep).join('/'));
         Logger.customize({
             name: 'discoverPathsWithFile',
             type: 'test',
@@ -52,22 +48,22 @@ describe('discoverPathsWithFile', (context) => {
             type: 'test',
             purpose: 'forward-relativePaths',
         }).debug(relativePaths);
-        assert.deepStrictEqual(relativePaths, ['', 'apps/some-app', 'packages/some-package']);
+        deepStrictEqual(relativePaths, ['', 'apps/some-app', 'packages/some-package']);
     });
-    it('climbs to parent package.json files when traversing backward', async () => {
-        const projectRoot = path.join(sandboxRoot, 'backward');
-        const appRoot = path.join(projectRoot, 'apps', 'some-app');
-        const appStuffRoot = path.join(appRoot, 'stuff');
-        await fs.mkdir(appStuffRoot, { recursive: true });
+    await context.test('climbs to parent package.json files when traversing backward', async () => {
+        const projectRoot = join(sandboxRoot, 'backward');
+        const appRoot = join(projectRoot, 'apps', 'some-app');
+        const appStuffRoot = join(appRoot, 'stuff');
+        await mkdir(appStuffRoot, { recursive: true });
         await Promise.all([
-            fs.writeFile(path.join(projectRoot, 'package.json'), '{}\n'),
-            fs.writeFile(path.join(appRoot, 'package.json'), '{}\n'),
+            writeFile(join(projectRoot, 'package.json'), '{}\n'),
+            writeFile(join(appRoot, 'package.json'), '{}\n'),
         ]);
-        const realProjectRoot = await fs.realpath(projectRoot);
-        const realAppStuffRoot = await fs.realpath(appStuffRoot);
+        const realProjectRoot = await realpath(projectRoot);
+        const realAppStuffRoot = await realpath(appStuffRoot);
         process.chdir(realAppStuffRoot);
         const absolutePaths = await discoverPathsWithFile('package.json', 'backward');
-        const relativePaths = absolutePaths.map((absolutePath) => path.relative(realProjectRoot, absolutePath).split(path.sep).join('/'));
+        const relativePaths = absolutePaths.map((absolutePath) => relative(realProjectRoot, absolutePath).split(sep).join('/'));
         Logger.customize({
             name: 'discoverPathsWithFile',
             type: 'test',
@@ -78,7 +74,671 @@ describe('discoverPathsWithFile', (context) => {
             type: 'test',
             purpose: 'backward-relativePaths',
         }).debug(relativePaths);
-        assert.deepStrictEqual(relativePaths, ['apps/some-app', '']);
+        deepStrictEqual(relativePaths, ['apps/some-app', '']);
+    });
+});
+test('isPlainObject', async (context) => {
+    await context.test('returns true for empty object literal', () => {
+        strictEqual(isPlainObject({}), true);
+    });
+    await context.test('returns true for object with properties', () => {
+        const obj = {
+            a: 1,
+            b: 2,
+        };
+        strictEqual(isPlainObject(obj), true);
+    });
+    await context.test('returns true for Object.create(null)', () => {
+        strictEqual(isPlainObject(Object.create(null)), true);
+    });
+    await context.test('returns false for null', () => {
+        strictEqual(isPlainObject(null), false);
+    });
+    await context.test('returns false for undefined', () => {
+        strictEqual(isPlainObject(undefined), false);
+    });
+    await context.test('returns false for string', () => {
+        strictEqual(isPlainObject('hello'), false);
+    });
+    await context.test('returns false for number', () => {
+        strictEqual(isPlainObject(42), false);
+    });
+    await context.test('returns false for boolean', () => {
+        strictEqual(isPlainObject(true), false);
+    });
+    await context.test('returns false for array', () => {
+        strictEqual(isPlainObject([1, 2, 3]), false);
+    });
+    await context.test('returns false for Date instance', () => {
+        strictEqual(isPlainObject(new Date()), false);
+    });
+    await context.test('returns false for RegExp instance', () => {
+        strictEqual(isPlainObject(new RegExp('test')), false);
+    });
+    await context.test('returns false for Map instance', () => {
+        strictEqual(isPlainObject(new Map()), false);
+    });
+    await context.test('returns false for Set instance', () => {
+        strictEqual(isPlainObject(new Set()), false);
+    });
+    await context.test('returns false for class instance', () => {
+        class Foo {
+        }
+        strictEqual(isPlainObject(new Foo()), false);
+    });
+});
+test('isExecuteShellError', async (context) => {
+    await context.test('returns true for object with cmd property', () => {
+        strictEqual(isExecuteShellError({ cmd: 'echo hello' }), true);
+    });
+    await context.test('returns true for object with killed property', () => {
+        strictEqual(isExecuteShellError({ killed: false }), true);
+    });
+    await context.test('returns true for object with code property', () => {
+        strictEqual(isExecuteShellError({ code: 1 }), true);
+    });
+    await context.test('returns true for object with signal property', () => {
+        strictEqual(isExecuteShellError({ signal: 'SIGTERM' }), true);
+    });
+    await context.test('returns true for object with stdout property', () => {
+        strictEqual(isExecuteShellError({ stdout: 'output' }), true);
+    });
+    await context.test('returns true for object with stderr property', () => {
+        strictEqual(isExecuteShellError({ stderr: 'error' }), true);
+    });
+    await context.test('returns true for object with multiple exec properties', () => {
+        const error = {
+            cmd: 'test',
+            killed: false,
+            code: 1,
+            signal: 'SIGTERM',
+            stdout: '',
+            stderr: 'failed',
+        };
+        strictEqual(isExecuteShellError(error), true);
+    });
+    await context.test('returns false for null', () => {
+        strictEqual(isExecuteShellError(null), false);
+    });
+    await context.test('returns false for undefined', () => {
+        strictEqual(isExecuteShellError(undefined), false);
+    });
+    await context.test('returns false for string', () => {
+        strictEqual(isExecuteShellError('error'), false);
+    });
+    await context.test('returns false for number', () => {
+        strictEqual(isExecuteShellError(42), false);
+    });
+    await context.test('returns false for empty object', () => {
+        strictEqual(isExecuteShellError({}), false);
+    });
+    await context.test('returns false for object with wrong property types', () => {
+        strictEqual(isExecuteShellError({ cmd: 123 }), false);
+    });
+});
+test('currentTimestamp', async (context) => {
+    await context.test('returns a bracketed timestamp string', () => {
+        const result = currentTimestamp();
+        ok(result.startsWith('['));
+        ok(result.endsWith(']'));
+    });
+    await context.test('matches expected timestamp format', () => {
+        const result = currentTimestamp();
+        const pattern = new RegExp('^\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3} [+-]\\d{2}\\d{2}]$');
+        match(result, pattern);
+    });
+    await context.test('produces different milliseconds on consecutive calls', () => {
+        const results = new Set();
+        for (let i = 0; i < 10; i += 1) {
+            results.add(currentTimestamp());
+        }
+        ok(results.size >= 1);
+    });
+});
+test('detectShell', async (context) => {
+    await context.test('returns a non-empty string', () => {
+        const result = detectShell();
+        strictEqual(typeof result, 'string');
+        ok(result.length > 0);
+    });
+    await context.test('returns a known shell path', () => {
+        const result = detectShell();
+        const knownShells = [
+            'cmd.exe',
+            '/bin/zsh',
+            '/bin/bash',
+            '/bin/ksh',
+            '/bin/sh',
+        ];
+        ok(knownShells.includes(result), `Unexpected shell: "${result}"`);
+    });
+});
+test('pathExists', async (context) => {
+    await context.test('returns true for existing file', async () => {
+        const tempDir = await mkdtemp(join(tmpdir(), 'nova-pathExists-'));
+        const tempFile = join(tempDir, 'test.txt');
+        await writeFile(tempFile, 'test');
+        const result = await pathExists(tempFile);
+        strictEqual(result, true);
+        await rm(tempDir, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('returns true for existing directory', async () => {
+        const tempDir = await mkdtemp(join(tmpdir(), 'nova-pathExists-'));
+        const result = await pathExists(tempDir);
+        strictEqual(result, true);
+        await rm(tempDir, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('returns false for non-existent path', async () => {
+        const result = await pathExists(join(tmpdir(), 'nova-does-not-exist-xyz'));
+        strictEqual(result, false);
+    });
+});
+test('executeShell', async (context) => {
+    await context.test('runs a simple echo command', async () => {
+        const result = await executeShell('echo hello');
+        strictEqual(result.code, 0);
+        ok(result.textOut.includes('hello'));
+    });
+    await context.test('returns non-zero code for failing command', async () => {
+        const result = await executeShell('nova-nonexistent-command-xyz-12345');
+        notStrictEqual(result.code, 0);
+    });
+});
+test('isCommandExists', async (context) => {
+    await context.test('returns true for an existing command', async () => {
+        const result = await isCommandExists('node');
+        strictEqual(result, true);
+    });
+    await context.test('returns false for a non-existent command', async () => {
+        const result = await isCommandExists('nova-nonexistent-command-xyz-12345');
+        strictEqual(result, false);
+    });
+});
+test('isFileIdentical', async (context) => {
+    const sandboxRoot = await mkdtemp(join(tmpdir(), `nova-${context.name}-`));
+    context.after(async () => {
+        await rm(sandboxRoot, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('returns true when string content matches file', async () => {
+        const filePath = join(sandboxRoot, 'string-match.txt');
+        await writeFile(filePath, 'hello world');
+        const result = await isFileIdentical(filePath, 'hello world');
+        strictEqual(result, true);
+    });
+    await context.test('returns false when string content differs from file', async () => {
+        const filePath = join(sandboxRoot, 'string-differ.txt');
+        await writeFile(filePath, 'hello world');
+        const result = await isFileIdentical(filePath, 'goodbye world');
+        strictEqual(result, false);
+    });
+    await context.test('returns true when object content matches JSON file', async () => {
+        const filePath = join(sandboxRoot, 'object-match.json');
+        const contents = {
+            name: 'nova',
+            version: '1.0.0',
+        };
+        const contentsJson = JSON.stringify(contents, null, 2);
+        await writeFile(filePath, `${contentsJson}\n`);
+        const result = await isFileIdentical(filePath, contents);
+        strictEqual(result, true);
+    });
+    await context.test('returns false when object content differs from JSON file', async () => {
+        const filePath = join(sandboxRoot, 'object-differ.json');
+        const existingContents = {
+            name: 'nova',
+            version: '1.0.0',
+        };
+        const proposedContents = {
+            name: 'nova',
+            version: '2.0.0',
+        };
+        const existingJson = JSON.stringify(existingContents, null, 2);
+        await writeFile(filePath, `${existingJson}\n`);
+        const result = await isFileIdentical(filePath, proposedContents);
+        strictEqual(result, false);
+    });
+    await context.test('returns false when file does not exist', async () => {
+        const filePath = join(sandboxRoot, 'does-not-exist.txt');
+        const result = await isFileIdentical(filePath, 'content');
+        strictEqual(result, false);
+    });
+});
+test('renameFileWithDate', async (context) => {
+    const sandboxRoot = await mkdtemp(join(tmpdir(), `nova-${context.name}-`));
+    context.after(async () => {
+        await rm(sandboxRoot, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('renames a file with a date-stamped name', async () => {
+        const filePath = join(sandboxRoot, 'rename-test.txt');
+        await writeFile(filePath, 'test content');
+        const result = await renameFileWithDate(filePath, 'backup', 'txt');
+        strictEqual(result, true);
+        const originalExists = await pathExists(filePath);
+        strictEqual(originalExists, false);
+        const files = await readdir(sandboxRoot);
+        const renamedFile = files.find((file) => file.startsWith('backup.'));
+        ok(renamedFile !== undefined, 'Renamed file should exist');
+        ok(new RegExp('^backup\\.\\d{4}-\\d{2}-\\d{2}_\\d{4}\\.txt$').test(renamedFile));
+    });
+    await context.test('returns false when source file does not exist', async () => {
+        const filePath = join(sandboxRoot, 'does-not-exist.txt');
+        const result = await renameFileWithDate(filePath, 'backup', 'txt');
+        strictEqual(result, false);
+    });
+    await context.test('increments counter when target file already exists', async () => {
+        const subDir = join(sandboxRoot, 'counter-test');
+        await mkdir(subDir);
+        const filePath = join(subDir, 'original.txt');
+        await writeFile(filePath, 'content');
+        const now = new Date();
+        const timestamp = [
+            now.getUTCFullYear(),
+            (now.getUTCMonth() + 1).toString().padStart(2, '0'),
+            now.getUTCDate().toString().padStart(2, '0'),
+        ].join('-');
+        const existingName = `backup.${timestamp}_0001.txt`;
+        await writeFile(join(subDir, existingName), 'existing');
+        const result = await renameFileWithDate(filePath, 'backup', 'txt');
+        strictEqual(result, true);
+        const files = await readdir(subDir);
+        const secondFile = files.find((file) => file.includes('_0002'));
+        ok(secondFile !== undefined, 'File with incremented counter should exist');
+    });
+});
+test('isProjectRoot', async (context) => {
+    const originalCwd = process.cwd();
+    const sandboxRoot = await mkdtemp(join(tmpdir(), `nova-${context.name}-`));
+    context.after(async () => {
+        process.chdir(originalCwd);
+        await rm(sandboxRoot, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('returns true when cwd is project root with single package.json', async () => {
+        const projectRoot = join(sandboxRoot, 'single');
+        await mkdir(projectRoot, { recursive: true });
+        await writeFile(join(projectRoot, 'package.json'), '{}\n');
+        const realProjectRoot = await realpath(projectRoot);
+        process.chdir(realProjectRoot);
+        const result = await isProjectRoot(realProjectRoot);
+        strictEqual(result, true);
+    });
+    await context.test('returns false when cwd has no package.json above', async () => {
+        const emptyDir = join(sandboxRoot, 'empty');
+        await mkdir(emptyDir, { recursive: true });
+        const realEmptyDir = await realpath(emptyDir);
+        process.chdir(realEmptyDir);
+        const result = await isProjectRoot(realEmptyDir);
+        strictEqual(result, false);
+    });
+    await context.test('returns false when multiple package.json files found above', async () => {
+        const projectRoot = join(sandboxRoot, 'multi');
+        const appRoot = join(projectRoot, 'apps', 'my-app');
+        await mkdir(appRoot, { recursive: true });
+        await Promise.all([
+            writeFile(join(projectRoot, 'package.json'), '{}\n'),
+            writeFile(join(appRoot, 'package.json'), '{}\n'),
+        ]);
+        const realAppRoot = await realpath(appRoot);
+        process.chdir(realAppRoot);
+        const result = await isProjectRoot(realAppRoot);
+        strictEqual(result, false);
+    });
+});
+test('loadWorkspaceManifests', async (context) => {
+    const sandboxRoot = await mkdtemp(join(tmpdir(), `nova-${context.name}-`));
+    context.after(async () => {
+        await rm(sandboxRoot, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('loads package.json for configured workspaces', async () => {
+        const projectRoot = join(sandboxRoot, 'valid');
+        const pkgDir = join(projectRoot, 'packages', 'core');
+        await mkdir(pkgDir, { recursive: true });
+        const rootPackageJson = JSON.stringify({ name: 'root' }, null, 2);
+        const corePackageJson = JSON.stringify({ name: '@test/core' }, null, 2);
+        await Promise.all([
+            writeFile(join(projectRoot, 'package.json'), rootPackageJson),
+            writeFile(join(pkgDir, 'package.json'), corePackageJson),
+        ]);
+        const result = await loadWorkspaceManifests({
+            projectRoot,
+            workspaces: [
+                ['./', {
+                        name: 'root',
+                        role: 'project',
+                        policy: 'freezable',
+                    }],
+                ['./packages/core', {
+                        name: '@test/core',
+                        role: 'package',
+                        policy: 'distributable',
+                    }],
+            ],
+        });
+        strictEqual(result.length, 2);
+        const firstWorkspace = result[0];
+        const secondWorkspace = result[1];
+        ok(firstWorkspace !== undefined);
+        ok(secondWorkspace !== undefined);
+        strictEqual(firstWorkspace.manifest.name, 'root');
+        strictEqual(firstWorkspace.fileContents['name'], 'root');
+        strictEqual(secondWorkspace.manifest.name, '@test/core');
+        strictEqual(secondWorkspace.fileContents['name'], '@test/core');
+    });
+    await context.test('skips workspace with missing package.json', async () => {
+        const projectRoot = join(sandboxRoot, 'missing');
+        await mkdir(projectRoot, { recursive: true });
+        const rootPackageJson = JSON.stringify({ name: 'root' }, null, 2);
+        await writeFile(join(projectRoot, 'package.json'), rootPackageJson);
+        const result = await loadWorkspaceManifests({
+            projectRoot,
+            workspaces: [
+                ['./', {
+                        name: 'root',
+                        role: 'project',
+                        policy: 'freezable',
+                    }],
+                ['./packages/missing', {
+                        name: '@test/missing',
+                        role: 'package',
+                        policy: 'distributable',
+                    }],
+            ],
+        });
+        strictEqual(result.length, 1);
+        const onlyWorkspace = result[0];
+        ok(onlyWorkspace !== undefined);
+        strictEqual(onlyWorkspace.manifest.name, 'root');
+    });
+    await context.test('returns empty array when no workspaces provided', async () => {
+        const result = await loadWorkspaceManifests({
+            projectRoot: sandboxRoot,
+            workspaces: [],
+        });
+        strictEqual(result.length, 0);
+    });
+});
+test('saveWorkspaceManifest', async (context) => {
+    const sandboxRoot = await mkdtemp(join(tmpdir(), `nova-${context.name}-`));
+    context.after(async () => {
+        await rm(sandboxRoot, {
+            recursive: true,
+            force: true,
+        });
+    });
+    await context.test('writes changed file contents', async () => {
+        const filePath = join(sandboxRoot, 'write-test', 'package.json');
+        await mkdir(dirname(filePath), { recursive: true });
+        const original = {
+            name: 'test',
+            version: '1.0.0',
+        };
+        const originalJson = JSON.stringify(original, null, 2);
+        await writeFile(filePath, `${originalJson}\n`, 'utf-8');
+        const modified = {
+            name: 'test',
+            version: '2.0.0',
+        };
+        await saveWorkspaceManifest({
+            manifest: {
+                name: 'test',
+                role: 'package',
+                policy: 'distributable',
+            },
+            filePath,
+            fileContents: modified,
+        }, true);
+        const written = JSON.parse(await readFile(filePath, 'utf-8'));
+        strictEqual(written.version, '2.0.0');
+    });
+    await context.test('skips writing when file contents are identical', async () => {
+        const filePath = join(sandboxRoot, 'skip-test', 'package.json');
+        await mkdir(dirname(filePath), { recursive: true });
+        const contents = {
+            name: 'test',
+            version: '1.0.0',
+        };
+        const contentsJson = JSON.stringify(contents, null, 2);
+        await writeFile(filePath, `${contentsJson}\n`, 'utf-8');
+        const statBefore = await stat(filePath);
+        await saveWorkspaceManifest({
+            manifest: {
+                name: 'test',
+                role: 'package',
+                policy: 'distributable',
+            },
+            filePath,
+            fileContents: contents,
+        }, true);
+        const statAfter = await stat(filePath);
+        strictEqual(statBefore.mtimeMs, statAfter.mtimeMs);
+    });
+    await context.test('creates backup when replaceFile is false', async () => {
+        const subDir = join(sandboxRoot, 'backup-test');
+        await mkdir(subDir, { recursive: true });
+        const filePath = join(subDir, 'package.json');
+        const original = {
+            name: 'test',
+            version: '1.0.0',
+        };
+        const originalJson = JSON.stringify(original, null, 2);
+        await writeFile(filePath, `${originalJson}\n`, 'utf-8');
+        const modified = {
+            name: 'test',
+            version: '2.0.0',
+        };
+        await saveWorkspaceManifest({
+            manifest: {
+                name: 'test',
+                role: 'package',
+                policy: 'distributable',
+            },
+            filePath,
+            fileContents: modified,
+        }, false);
+        const files = await readdir(subDir);
+        const backupFile = files.find((file) => file.startsWith('package.') && file !== 'package.json');
+        ok(backupFile !== undefined, 'Backup file should exist');
+        const written = JSON.parse(await readFile(filePath, 'utf-8'));
+        strictEqual(written.version, '2.0.0');
+    });
+});
+test('parseLinuxOsReleaseText', async (context) => {
+    await context.test('parses Ubuntu os-release text', () => {
+        const text = [
+            'NAME="Ubuntu"',
+            'VERSION="22.04.3 LTS (Jammy Jellyfish)"',
+            'ID=ubuntu',
+            'ID_LIKE=debian',
+            'PRETTY_NAME="Ubuntu 22.04.3 LTS"',
+            'VERSION_ID="22.04"',
+        ].join('\n');
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(result['NAME'], 'Ubuntu');
+        strictEqual(result['VERSION'], '22.04.3 LTS (Jammy Jellyfish)');
+        strictEqual(result['ID'], 'ubuntu');
+        strictEqual(result['ID_LIKE'], 'debian');
+        strictEqual(result['VERSION_ID'], '22.04');
+    });
+    await context.test('parses Alpine os-release text', () => {
+        const text = [
+            'NAME="Alpine Linux"',
+            'ID=alpine',
+            'VERSION_ID=3.19.0',
+            'PRETTY_NAME="Alpine Linux v3.19"',
+        ].join('\n');
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(result['NAME'], 'Alpine Linux');
+        strictEqual(result['ID'], 'alpine');
+        strictEqual(result['VERSION_ID'], '3.19.0');
+    });
+    await context.test('parses Debian os-release text', () => {
+        const text = [
+            'PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"',
+            'NAME="Debian GNU/Linux"',
+            'VERSION_ID="12"',
+            'ID=debian',
+        ].join('\n');
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(result['NAME'], 'Debian GNU/Linux');
+        strictEqual(result['ID'], 'debian');
+        strictEqual(result['VERSION_ID'], '12');
+    });
+    await context.test('skips comment lines', () => {
+        const text = [
+            '# This is a comment',
+            'NAME="Test"',
+            '# Another comment',
+            'ID=test',
+        ].join('\n');
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(Object.keys(result).length, 2);
+        strictEqual(result['NAME'], 'Test');
+        strictEqual(result['ID'], 'test');
+    });
+    await context.test('skips empty lines', () => {
+        const text = [
+            '',
+            'NAME="Test"',
+            '',
+            '',
+            'ID=test',
+            '',
+        ].join('\n');
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(Object.keys(result).length, 2);
+    });
+    await context.test('strips double-quoted values', () => {
+        const text = 'NAME="Ubuntu"';
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(result['NAME'], 'Ubuntu');
+    });
+    await context.test('preserves unquoted values', () => {
+        const text = 'ID=ubuntu';
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(result['ID'], 'ubuntu');
+    });
+    await context.test('handles values containing equals sign', () => {
+        const text = 'BUG_REPORT_URL="https://example.com?a=1&b=2"';
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(result['BUG_REPORT_URL'], 'https://example.com?a=1&b=2');
+    });
+    await context.test('returns empty object for empty string', () => {
+        const result = parseLinuxOsReleaseText('');
+        deepStrictEqual(result, {});
+    });
+    await context.test('handles CRLF line endings', () => {
+        const text = 'NAME="Test"\r\nID=test\r\nVERSION_ID="1.0"';
+        const result = parseLinuxOsReleaseText(text);
+        strictEqual(Object.keys(result).length, 3);
+        strictEqual(result['NAME'], 'Test');
+        strictEqual(result['ID'], 'test');
+        strictEqual(result['VERSION_ID'], '1.0');
+    });
+});
+test('parseWindowsRegistryText', async (context) => {
+    await context.test('parses REG_SZ values', () => {
+        const text = '    ProductName    REG_SZ    Windows 11 Pro';
+        const result = parseWindowsRegistryText(text);
+        const productName = result['ProductName'];
+        if (productName === undefined) {
+            fail('Expected ProductName to be defined');
+        }
+        strictEqual(productName.type, 'REG_SZ');
+        strictEqual(productName.data, 'Windows 11 Pro');
+    });
+    await context.test('parses REG_DWORD values', () => {
+        const text = '    CurrentMajorVersionNumber    REG_DWORD    0xa';
+        const result = parseWindowsRegistryText(text);
+        const currentMajorVersionNumber = result['CurrentMajorVersionNumber'];
+        if (currentMajorVersionNumber === undefined) {
+            fail('Expected CurrentMajorVersionNumber to be defined');
+        }
+        strictEqual(currentMajorVersionNumber.type, 'REG_DWORD');
+        strictEqual(currentMajorVersionNumber.data, '0xa');
+    });
+    await context.test('parses mixed registry types', () => {
+        const text = [
+            'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion',
+            '    ProductName    REG_SZ    Windows 11 Pro',
+            '    CurrentBuild    REG_SZ    22631',
+            '    CurrentMajorVersionNumber    REG_DWORD    0xa',
+        ].join('\n');
+        const result = parseWindowsRegistryText(text);
+        strictEqual(Object.keys(result).length, 3);
+        const productName = result['ProductName'];
+        const currentBuild = result['CurrentBuild'];
+        const currentMajorVersionNumber = result['CurrentMajorVersionNumber'];
+        if (productName === undefined) {
+            fail('Expected ProductName to be defined');
+        }
+        if (currentBuild === undefined) {
+            fail('Expected CurrentBuild to be defined');
+        }
+        if (currentMajorVersionNumber === undefined) {
+            fail('Expected CurrentMajorVersionNumber to be defined');
+        }
+        strictEqual(productName.type, 'REG_SZ');
+        strictEqual(currentBuild.type, 'REG_SZ');
+        strictEqual(currentMajorVersionNumber.type, 'REG_DWORD');
+    });
+    await context.test('returns empty object for empty string', () => {
+        const result = parseWindowsRegistryText('');
+        deepStrictEqual(result, {});
+    });
+    await context.test('skips non-matching lines', () => {
+        const text = [
+            'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion',
+            '',
+            '    ProductName    REG_SZ    Windows 11 Pro',
+        ].join('\n');
+        const result = parseWindowsRegistryText(text);
+        strictEqual(Object.keys(result).length, 1);
+        const productName = result['ProductName'];
+        if (productName === undefined) {
+            fail('Expected ProductName to be defined');
+        }
+        strictEqual(productName.data, 'Windows 11 Pro');
+    });
+    await context.test('trims trailing whitespace from data', () => {
+        const text = '    ProductName    REG_SZ    Windows 11 Pro   ';
+        const result = parseWindowsRegistryText(text);
+        const productName = result['ProductName'];
+        if (productName === undefined) {
+            fail('Expected ProductName to be defined');
+        }
+        strictEqual(productName.data, 'Windows 11 Pro');
+    });
+    await context.test('handles LF line endings', () => {
+        const text = '    ProductName    REG_SZ    Windows 11\n    CurrentBuild    REG_SZ    22631';
+        const result = parseWindowsRegistryText(text);
+        strictEqual(Object.keys(result).length, 2);
+        const productName = result['ProductName'];
+        const currentBuild = result['CurrentBuild'];
+        if (productName === undefined) {
+            fail('Expected ProductName to be defined');
+        }
+        if (currentBuild === undefined) {
+            fail('Expected CurrentBuild to be defined');
+        }
+        strictEqual(productName.data, 'Windows 11');
+        strictEqual(currentBuild.data, '22631');
     });
 });
 //# sourceMappingURL=utility.test.js.map