xs-dev 0.38.1 → 1.0.0

package/build/src/toolbox/system/__tests__/errors.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+describe('Error Handling Utilities', () => {
+    describe('success', () => {
+        it('should create a successful result with data', () => {
+            const result = (0, errors_1.success)('test data');
+            expect(result).toEqual({ success: true, data: 'test data' });
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect((0, errors_1.isFailure)(result)).toBe(false);
+        });
+        it('should work with different data types', () => {
+            const numberResult = (0, errors_1.success)(42);
+            if ((0, errors_1.isSuccess)(numberResult)) {
+                expect(numberResult.data).toBe(42);
+            }
+            const objectResult = (0, errors_1.success)({ key: 'value' });
+            if ((0, errors_1.isSuccess)(objectResult)) {
+                expect(objectResult.data).toEqual({ key: 'value' });
+            }
+        });
+    });
+    describe('successVoid', () => {
+        it('should create a successful result with void data', () => {
+            const result = (0, errors_1.successVoid)();
+            expect(result).toEqual({ success: true, data: undefined });
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+        });
+    });
+    describe('failure', () => {
+        it('should create a failed result with error message', () => {
+            const result = (0, errors_1.failure)('error message');
+            expect(result).toEqual({ success: false, error: 'error message' });
+            expect((0, errors_1.isSuccess)(result)).toBe(false);
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+        });
+    });
+    describe('wrapAsync', () => {
+        it('should wrap successful async operations', async () => {
+            const asyncFn = async () => 'success';
+            const result = await (0, errors_1.wrapAsync)(asyncFn);
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            if ((0, errors_1.isSuccess)(result)) {
+                expect(result.data).toBe('success');
+            }
+        });
+        it('should wrap failed async operations', async () => {
+            const asyncFn = async () => {
+                throw new Error('async error');
+            };
+            const result = await (0, errors_1.wrapAsync)(asyncFn);
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+            if ((0, errors_1.isFailure)(result)) {
+                expect(result.error).toBe('async error');
+            }
+        });
+        it('should handle non-Error thrown values', async () => {
+            const asyncFn = async () => {
+                throw 'string error';
+            };
+            const result = await (0, errors_1.wrapAsync)(asyncFn);
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+            if ((0, errors_1.isFailure)(result)) {
+                expect(result.error).toBe('string error');
+            }
+        });
+    });
+    describe('wrapSync', () => {
+        it('should wrap successful sync operations', () => {
+            const syncFn = () => 'success';
+            const result = (0, errors_1.wrapSync)(syncFn);
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            if ((0, errors_1.isSuccess)(result)) {
+                expect(result.data).toBe('success');
+            }
+        });
+        it('should wrap failed sync operations', () => {
+            const syncFn = () => {
+                throw new Error('sync error');
+            };
+            const result = (0, errors_1.wrapSync)(syncFn);
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+            if ((0, errors_1.isFailure)(result)) {
+                expect(result.error).toBe('sync error');
+            }
+        });
+    });
+    describe('unwrap', () => {
+        it('should extract data from successful results', () => {
+            const result = (0, errors_1.success)('test data');
+            expect((0, errors_1.unwrap)(result)).toBe('test data');
+        });
+        it('should throw for failed results', () => {
+            const result = (0, errors_1.failure)('error message');
+            expect(() => (0, errors_1.unwrap)(result)).toThrow('error message');
+        });
+    });
+    describe('unwrapOr', () => {
+        it('should extract data from successful results', () => {
+            const result = (0, errors_1.success)('test data');
+            expect((0, errors_1.unwrapOr)(result, 'default')).toBe('test data');
+        });
+        it('should return default value for failed results', () => {
+            const result = (0, errors_1.failure)('error message');
+            expect((0, errors_1.unwrapOr)(result, 'default')).toBe('default');
+        });
+    });
+    describe('mapResult', () => {
+        it('should transform successful results', () => {
+            const result = (0, errors_1.success)('test');
+            const mapped = (0, errors_1.mapResult)(result, (data) => data.toUpperCase());
+            expect((0, errors_1.isSuccess)(mapped)).toBe(true);
+            if ((0, errors_1.isSuccess)(mapped)) {
+                expect(mapped.data).toBe('TEST');
+            }
+        });
+        it('should pass through failed results', () => {
+            const result = (0, errors_1.failure)('error message');
+            const mapped = (0, errors_1.mapResult)(result, (data) => data.toUpperCase());
+            expect((0, errors_1.isFailure)(mapped)).toBe(true);
+            if ((0, errors_1.isFailure)(mapped)) {
+                expect(mapped.error).toBe('error message');
+            }
+        });
+    });
+    describe('flatMapResult', () => {
+        it('should chain successful results', () => {
+            const result = (0, errors_1.success)('test');
+            const chained = (0, errors_1.flatMapResult)(result, (data) => (0, errors_1.success)(data.length));
+            expect((0, errors_1.isSuccess)(chained)).toBe(true);
+            if ((0, errors_1.isSuccess)(chained)) {
+                expect(chained.data).toBe(4);
+            }
+        });
+        it('should chain to failed results', () => {
+            const result = (0, errors_1.success)('test');
+            const chained = (0, errors_1.flatMapResult)(result, (_data) => (0, errors_1.failure)('chained error'));
+            expect((0, errors_1.isFailure)(chained)).toBe(true);
+            if ((0, errors_1.isFailure)(chained)) {
+                expect(chained.error).toBe('chained error');
+            }
+        });
+        it('should pass through failed results', () => {
+            const result = (0, errors_1.failure)('original error');
+            const chained = (0, errors_1.flatMapResult)(result, (data) => (0, errors_1.success)(data.length));
+            expect((0, errors_1.isFailure)(chained)).toBe(true);
+            if ((0, errors_1.isFailure)(chained)) {
+                expect(chained.error).toBe('original error');
+            }
+        });
+    });
+    describe('type guards', () => {
+        it('should correctly identify success results', () => {
+            const successResult = (0, errors_1.success)('data');
+            const failureResult = (0, errors_1.failure)('error');
+            expect((0, errors_1.isSuccess)(successResult)).toBe(true);
+            expect((0, errors_1.isFailure)(successResult)).toBe(false);
+            expect((0, errors_1.isSuccess)(failureResult)).toBe(false);
+            expect((0, errors_1.isFailure)(failureResult)).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.test.js","sourceRoot":"","sources":["../../../../../src/toolbox/system/__tests__/errors.test.ts"],"names":[],"mappings":"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"}

package/build/src/toolbox/system/__tests__/exec.test.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gluegun_1 = require("gluegun");
+const exec_1 = require("../exec");
+const errors_1 = require("../errors");
+// Mock gluegun system
+jest.mock('gluegun', () => ({
+    system: {
+        which: jest.fn(),
+        exec: jest.fn(),
+        spawn: jest.fn(),
+    },
+    filesystem: {
+        homedir: jest.fn(() => '/home/user'),
+        resolve: jest.fn((...paths) => paths.join('/')),
+    },
+}));
+// Mock the constants file to avoid filesystem dependency issues
+jest.mock('../../setup/constants', () => ({
+    EXPORTS_FILE_PATH: '/home/user/.local/share/xs-dev-exports.sh',
+}));
+const mockSystem = gluegun_1.system;
+describe('Exec Utilities', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset environment
+        delete process.env.SUDO_ASKPASS;
+    });
+    describe('execWithSudo', () => {
+        it('should succeed with non-interactive sudo', async () => {
+            mockSystem.exec.mockResolvedValueOnce('success');
+            const result = await (0, exec_1.execWithSudo)('test command');
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect(mockSystem.exec).toHaveBeenCalledWith('sudo --non-interactive --preserve-env test command', {});
+        });
+        it('should fall back to askpass when password is required', async () => {
+            // First call fails with password error
+            mockSystem.exec
+                .mockRejectedValueOnce(new Error('password required'))
+                .mockResolvedValueOnce('success with askpass');
+            // Mock ssh-askpass being available
+            mockSystem.which.mockReturnValue('/usr/bin/ssh-askpass');
+            const result = await (0, exec_1.execWithSudo)('test command');
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect(mockSystem.exec).toHaveBeenCalledTimes(2);
+            expect(mockSystem.exec).toHaveBeenNthCalledWith(1, 'sudo --non-interactive --preserve-env test command', {});
+            expect(mockSystem.exec).toHaveBeenNthCalledWith(2, 'sudo --askpass --preserve-env test command', {});
+            expect(process.env.SUDO_ASKPASS).toBe('/usr/bin/ssh-askpass');
+        });
+        it('should fail when ssh-askpass is not available', async () => {
+            mockSystem.exec.mockRejectedValueOnce(new Error('password required'));
+            mockSystem.which.mockReturnValue(undefined);
+            const result = await (0, exec_1.execWithSudo)('test command');
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+            if ((0, errors_1.isFailure)(result)) {
+                expect(result.error).toBe('ssh-askpass required to prompt for password');
+            }
+        });
+        it('should fail with non-password errors', async () => {
+            mockSystem.exec.mockRejectedValueOnce(new Error('permission denied'));
+            const result = await (0, exec_1.execWithSudo)('test command');
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+            if ((0, errors_1.isFailure)(result)) {
+                expect(result.error).toContain('Failed to execute sudo command');
+            }
+        });
+        it('should pass through options', async () => {
+            mockSystem.exec.mockResolvedValueOnce('success');
+            const options = { stdout: 'pipe' };
+            await (0, exec_1.execWithSudo)('test command', options);
+            expect(mockSystem.exec).toHaveBeenCalledWith('sudo --non-interactive --preserve-env test command', options);
+        });
+    });
+    describe('pkexec', () => {
+        it('should execute command with pkexec', async () => {
+            mockSystem.exec.mockResolvedValueOnce('success');
+            const result = await (0, exec_1.pkexec)('test command');
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect(mockSystem.exec).toHaveBeenCalledWith('pkexec test command', {});
+        });
+        it('should handle pkexec failures', async () => {
+            mockSystem.exec.mockRejectedValueOnce(new Error('pkexec failed'));
+            const result = await (0, exec_1.pkexec)('test command');
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+        });
+        it('should pass through options', async () => {
+            mockSystem.exec.mockResolvedValueOnce('success');
+            const options = { cwd: '/tmp' };
+            await (0, exec_1.pkexec)('test command', options);
+            expect(mockSystem.exec).toHaveBeenCalledWith('pkexec test command', options);
+        });
+    });
+    describe('sourceEnvironment', () => {
+        it('should call system.spawn with correct command', async () => {
+            mockSystem.spawn.mockResolvedValueOnce({
+                stdout: 'PATH=/usr/bin:/bin\nHOME=/home/user\n',
+            });
+            const result = await (0, exec_1.sourceEnvironment)();
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect(mockSystem.spawn).toHaveBeenCalled();
+        });
+        it('should handle spawn errors', async () => {
+            mockSystem.spawn.mockRejectedValueOnce(new Error('spawn failed'));
+            const result = await (0, exec_1.sourceEnvironment)();
+            expect((0, errors_1.isFailure)(result)).toBe(true);
+        });
+    });
+    describe('sourceIdf', () => {
+        it('should call system.spawn with IDF export command', async () => {
+            mockSystem.spawn.mockResolvedValueOnce({
+                stdout: 'PATH=/esp/bin:/usr/bin\nIDF_PATH=/esp/esp-idf\n',
+            });
+            const result = await (0, exec_1.sourceIdf)();
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect(mockSystem.spawn).toHaveBeenCalledWith('source $IDF_PATH/export.sh 1> /dev/null && env', { shell: process.env.SHELL });
+        });
+    });
+    describe('sourceIdfPythonEnv', () => {
+        it('should call system.spawn with Python environment activation', async () => {
+            process.env.IDF_PYTHON_ENV_PATH = '/path/to/python/env';
+            mockSystem.spawn.mockResolvedValueOnce({
+                stdout: 'PATH=/python/env/bin:/usr/bin\nVIRTUAL_ENV=/python/env\n',
+            });
+            const result = await (0, exec_1.sourceIdfPythonEnv)();
+            expect((0, errors_1.isSuccess)(result)).toBe(true);
+            expect(mockSystem.spawn).toHaveBeenCalledWith('source /path/to/python/env/bin/activate && env', { shell: process.env.SHELL });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlYy50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3Rvb2xib3gvc3lzdGVtL19fdGVzdHNfXy9leGVjLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxxQ0FBZ0M7QUFDaEMsa0NBTWdCO0FBQ2hCLHNDQUFnRDtBQUVoRCxzQkFBc0I7QUFDdEIsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUMxQixNQUFNLEVBQUU7UUFDTixLQUFLLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRTtRQUNoQixJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRTtRQUNmLEtBQUssRUFBRSxJQUFJLENBQUMsRUFBRSxFQUFFO0tBQ2pCO0lBQ0QsVUFBVSxFQUFFO1FBQ1YsT0FBTyxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsWUFBWSxDQUFDO1FBQ3BDLE9BQU8sRUFBRSxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxLQUFlLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7S0FDMUQ7Q0FDRixDQUFDLENBQUMsQ0FBQTtBQUVILGdFQUFnRTtBQUNoRSxJQUFJLENBQUMsSUFBSSxDQUFDLHVCQUF1QixFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUM7SUFDeEMsaUJBQWlCLEVBQUUsMkNBQTJDO0NBQy9ELENBQUMsQ0FBQyxDQUFBO0FBRUgsTUFBTSxVQUFVLEdBQUcsZ0JBQW9DLENBQUE7QUFFdkQsUUFBUSxDQUFDLGdCQUFnQixFQUFFLEdBQUcsRUFBRTtJQUM5QixVQUFVLENBQUMsR0FBRyxFQUFFO1FBQ2QsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFBO1FBQ3BCLG9CQUFvQjtRQUNwQixPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFBO0lBQ2pDLENBQUMsQ0FBQyxDQUFBO0lBRUYsUUFBUSxDQUFDLGNBQWMsRUFBRSxHQUFHLEVBQUU7UUFDNUIsRUFBRSxDQUFDLDBDQUEwQyxFQUFFLEtBQUssSUFBSSxFQUFFO1lBQ3hELFVBQVUsQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsU0FBUyxDQUFDLENBQUE7WUFFaEQsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFBLG1CQUFZLEVBQUMsY0FBYyxDQUFDLENBQUE7WUFFakQsTUFBTSxDQUFDLElBQUEsa0JBQVMsRUFBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtZQUNwQyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLG9CQUFvQixDQUMxQyxvREFBb0QsRUFDcEQsRUFBRSxDQUNILENBQUE7UUFDSCxDQUFDLENBQUMsQ0FBQTtRQUVGLEVBQUUsQ0FBQyx1REFBdUQsRUFBRSxLQUFLLElBQUksRUFBRTtZQUNyRSx1Q0FBdUM7WUFDdkMsVUFBVSxDQUFDLElBQUk7aUJBQ1oscUJBQXFCLENBQUMsSUFBSSxLQUFLLENBQUMsbUJBQW1CLENBQUMsQ0FBQztpQkFDckQscUJBQXFCLENBQUMsc0JBQXNCLENBQUMsQ0FBQTtZQUVoRCxtQ0FBbUM7WUFDbkMsVUFBVSxDQUFDLEtBQUssQ0FBQyxlQUFlLENBQUMsc0JBQXNCLENBQUMsQ0FBQTtZQUV4RCxNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUEsbUJBQVksRUFBQyxjQUFjLENBQUMsQ0FBQTtZQUVqRCxNQUFNLENBQUMsSUFBQSxrQkFBUyxFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1lBQ3BDLE1BQU0sQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMscUJBQXFCLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDaEQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyx1QkFBdUIsQ0FDN0MsQ0FBQyxFQUNELG9EQUFvRCxFQUNwRCxFQUFFLENBQ0gsQ0FBQTtZQUNELE1BQU0sQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsdUJBQXVCLENBQzdDLENBQUMsRUFDRCw0Q0FBNEMsRUFDNUMsRUFBRSxDQUNILENBQUE7WUFDRCxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQUMsc0JBQXNCLENBQUMsQ0FBQTtRQUMvRCxDQUFDLENBQUMsQ0FBQTtRQUVGLEVBQUUsQ0FBQywrQ0FBK0MsRUFBRSxLQUFLLElBQUksRUFBRTtZQUM3RCxVQUFVLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLElBQUksS0FBSyxDQUFDLG1CQUFtQixDQUFDLENBQUMsQ0FBQTtZQUNyRSxVQUFVLENBQUMsS0FBSyxDQUFDLGVBQWUsQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUUzQyxNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUEsbUJBQVksRUFBQyxjQUFjLENBQUMsQ0FBQTtZQUVqRCxNQUFNLENBQUMsSUFBQSxrQkFBUyxFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1lBQ3BDLElBQUksSUFBQSxrQkFBUyxFQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7Z0JBQ3RCLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLDZDQUE2QyxDQUFDLENBQUE7WUFDMUUsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUFBO1FBRUYsRUFBRSxDQUFDLHNDQUFzQyxFQUFFLEtBQUssSUFBSSxFQUFFO1lBQ3BELFVBQVUsQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsSUFBSSxLQUFLLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFBO1lBRXJFLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBQSxtQkFBWSxFQUFDLGNBQWMsQ0FBQyxDQUFBO1lBRWpELE1BQU0sQ0FBQyxJQUFBLGtCQUFTLEVBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7WUFDcEMsSUFBSSxJQUFBLGtCQUFTLEVBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztnQkFDdEIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxTQUFTLENBQUMsZ0NBQWdDLENBQUMsQ0FBQTtZQUNsRSxDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUE7UUFFRixFQUFFLENBQUMsNkJBQTZCLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDM0MsVUFBVSxDQUFDLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUVoRCxNQUFNLE9BQU8sR0FBRyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQTtZQUNsQyxNQUFNLElBQUEsbUJBQVksRUFBQyxjQUFjLEVBQUUsT0FBTyxDQUFDLENBQUE7WUFFM0MsTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxvQkFBb0IsQ0FDMUMsb0RBQW9ELEVBQ3BELE9BQU8sQ0FDUixDQUFBO1FBQ0gsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtJQUVGLFFBQVEsQ0FBQyxRQUFRLEVBQUUsR0FBRyxFQUFFO1FBQ3RCLEVBQUUsQ0FBQyxvQ0FBb0MsRUFBRSxLQUFLLElBQUksRUFBRTtZQUNsRCxVQUFVLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLFNBQVMsQ0FBQyxDQUFBO1lBRWhELE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBQSxhQUFNLEVBQUMsY0FBYyxDQUFDLENBQUE7WUFFM0MsTUFBTSxDQUFDLElBQUEsa0JBQVMsRUFBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtZQUNwQyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLG9CQUFvQixDQUFDLHFCQUFxQixFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQ3pFLENBQUMsQ0FBQyxDQUFBO1FBRUYsRUFBRSxDQUFDLCtCQUErQixFQUFFLEtBQUssSUFBSSxFQUFFO1lBQzdDLFVBQVUsQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsSUFBSSxLQUFLLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQTtZQUVqRSxNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUEsYUFBTSxFQUFDLGNBQWMsQ0FBQyxDQUFBO1lBRTNDLE1BQU0sQ0FBQyxJQUFBLGtCQUFTLEVBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDdEMsQ0FBQyxDQUFDLENBQUE7UUFFRixFQUFFLENBQUMsNkJBQTZCLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDM0MsVUFBVSxDQUFDLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUVoRCxNQUFNLE9BQU8sR0FBRyxFQUFFLEdBQUcsRUFBRSxNQUFNLEVBQUUsQ0FBQTtZQUMvQixNQUFNLElBQUEsYUFBTSxFQUFDLGNBQWMsRUFBRSxPQUFPLENBQUMsQ0FBQTtZQUVyQyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLG9CQUFvQixDQUMxQyxxQkFBcUIsRUFDckIsT0FBTyxDQUNSLENBQUE7UUFDSCxDQUFDLENBQUMsQ0FBQTtJQUNKLENBQUMsQ0FBQyxDQUFBO0lBRUYsUUFBUSxDQUFDLG1CQUFtQixFQUFFLEdBQUcsRUFBRTtRQUNqQyxFQUFFLENBQUMsK0NBQStDLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDN0QsVUFBVSxDQUFDLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQztnQkFDckMsTUFBTSxFQUFFLHVDQUF1QzthQUNoRCxDQUFDLENBQUE7WUFFRixNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUEsd0JBQWlCLEdBQUUsQ0FBQTtZQUV4QyxNQUFNLENBQUMsSUFBQSxrQkFBUyxFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1lBQ3BDLE1BQU0sQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQTtRQUM3QyxDQUFDLENBQUMsQ0FBQTtRQUVGLEVBQUUsQ0FBQyw0QkFBNEIsRUFBRSxLQUFLLElBQUksRUFBRTtZQUMxQyxVQUFVLENBQUMsS0FBSyxDQUFDLHFCQUFxQixDQUFDLElBQUksS0FBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUE7WUFFakUsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFBLHdCQUFpQixHQUFFLENBQUE7WUFFeEMsTUFBTSxDQUFDLElBQUEsa0JBQVMsRUFBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUN0QyxDQUFDLENBQUMsQ0FBQTtJQUNKLENBQUMsQ0FBQyxDQUFBO0lBRUYsUUFBUSxDQUFDLFdBQVcsRUFBRSxHQUFHLEVBQUU7UUFDekIsRUFBRSxDQUFDLGtEQUFrRCxFQUFFLEtBQUssSUFBSSxFQUFFO1lBQ2hFLFVBQVUsQ0FBQyxLQUFLLENBQUMscUJBQXFCLENBQUM7Z0JBQ3JDLE1BQU0sRUFBRSxpREFBaUQ7YUFDMUQsQ0FBQyxDQUFBO1lBRUYsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFBLGdCQUFTLEdBQUUsQ0FBQTtZQUVoQyxNQUFNLENBQUMsSUFBQSxrQkFBUyxFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1lBQ3BDLE1BQU0sQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUMsb0JBQW9CLENBQzNDLGdEQUFnRCxFQUNoRCxFQUFFLEtBQUssRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxDQUM3QixDQUFBO1FBQ0gsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtJQUVGLFFBQVEsQ0FBQyxvQkFBb0IsRUFBRSxHQUFHLEVBQUU7UUFDbEMsRUFBRSxDQUFDLDZEQUE2RCxFQUFFLEtBQUssSUFBSSxFQUFFO1lBQzNFLE9BQU8sQ0FBQyxHQUFHLENBQUMsbUJBQW1CLEdBQUcscUJBQXFCLENBQUE7WUFFdkQsVUFBVSxDQUFDLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQztnQkFDckMsTUFBTSxFQUFFLDBEQUEwRDthQUNuRSxDQUFDLENBQUE7WUFFRixNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUEseUJBQWtCLEdBQUUsQ0FBQTtZQUV6QyxNQUFNLENBQUMsSUFBQSxrQkFBUyxFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1lBQ3BDLE1BQU0sQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUMsb0JBQW9CLENBQzNDLGdEQUFnRCxFQUNoRCxFQUFFLEtBQUssRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxDQUM3QixDQUFBO1FBQ0gsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMsQ0FBQyxDQUFBIn0=

package/build/src/toolbox/system/errors.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.successVoid = successVoid;
+exports.failure = failure;
+exports.wrapAsync = wrapAsync;
+exports.wrapSync = wrapSync;
+exports.isSuccess = isSuccess;
+exports.isFailure = isFailure;
+exports.unwrap = unwrap;
+exports.unwrapOr = unwrapOr;
+exports.mapResult = mapResult;
+exports.flatMapResult = flatMapResult;
+/**
+ * Creates a successful result
+ */
+function success(data) {
+    return { success: true, data };
+}
+/**
+ * Creates a successful result with no data (void)
+ */
+function successVoid() {
+    return { success: true, data: undefined };
+}
+/**
+ * Creates a failed result with error message
+ */
+function failure(error) {
+    return { success: false, error };
+}
+/**
+ * Wraps a function that might throw in a Result type
+ */
+async function wrapAsync(fn) {
+    try {
+        const result = await fn();
+        return success(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return failure(message);
+    }
+}
+/**
+ * Wraps a synchronous function that might throw in a Result type
+ */
+function wrapSync(fn) {
+    try {
+        const result = fn();
+        return success(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return failure(message);
+    }
+}
+/**
+ * Checks if a Result is successful
+ */
+function isSuccess(result) {
+    return result.success;
+}
+/**
+ * Checks if a Result is a failure
+ */
+function isFailure(result) {
+    return !result.success;
+}
+/**
+ * Gets data from a successful result or throws if failed
+ */
+function unwrap(result) {
+    if (isSuccess(result)) {
+        return result.data;
+    }
+    throw new Error(result.error);
+}
+/**
+ * Gets data from a successful result or returns default value if failed
+ */
+function unwrapOr(result, defaultValue) {
+    if (isSuccess(result)) {
+        return result.data;
+    }
+    return defaultValue;
+}
+/**
+ * Maps the data of a successful result, or passes through the error
+ */
+function mapResult(result, fn) {
+    if (isSuccess(result)) {
+        return success(fn(result.data));
+    }
+    return result;
+}
+/**
+ * Chains Result operations together
+ */
+function flatMapResult(result, fn) {
+    if (isSuccess(result)) {
+        return fn(result.data);
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/toolbox/system/exec.js

@@ -8,13 +8,14 @@ exports.sourceIdfPythonEnv = sourceIdfPythonEnv;
 const node_os_1 = require("node:os");
 const gluegun_1 = require("gluegun");
 const constants_1 = require("../setup/constants");
+const errors_1 = require("./errors");
 function ensureAskPass() {
     const SUDO_ASKPASS = gluegun_1.system.which('ssh-askpass');
     if (SUDO_ASKPASS === null || SUDO_ASKPASS === undefined) {
-        gluegun_1.print.warning('ssh-askpass required to prompt for password');
-        process.exit(1);
+        return (0, errors_1.failure)('ssh-askpass required to prompt for password');
     }
     process.env.SUDO_ASKPASS = SUDO_ASKPASS;
+    return (0, errors_1.success)(undefined);
 }
 /**
  * Ensure command can be run with sudo,
@@ -23,64 +24,69 @@ function ensureAskPass() {
 async function execWithSudo(command, options = {}) {
     try {
         await gluegun_1.system.exec(`sudo --non-interactive --preserve-env ${command}`, options);
-        return;
+        return (0, errors_1.success)(undefined);
     }
     catch (error) {
         if (error.toString().includes('password') === true) {
-            ensureAskPass();
+            const askPassResult = ensureAskPass();
+            if (!askPassResult.success) {
+                return askPassResult;
+            }
         }
         else {
-            throw error;
+            return (0, errors_1.failure)(`Failed to execute sudo command: ${error}`);
         }
     }
-    await gluegun_1.system.exec(`sudo --askpass --preserve-env ${command}`, options);
+    return await (0, errors_1.wrapAsync)(async () => {
+        await gluegun_1.system.exec(`sudo --askpass --preserve-env ${command}`, options);
+    });
 }
 /**
  * Use Policykit pkexec to run the command as an admin user
  */
 async function pkexec(command, options = {}) {
-    await gluegun_1.system.exec(`pkexec ${command}`, options);
+    return await (0, errors_1.wrapAsync)(async () => {
+        await gluegun_1.system.exec(`pkexec ${command}`, options);
+    });
 }
 /**
  * Utility for updating in-memory process.env after running a command
  */
 async function updateProcessEnv(command) {
     const OS = (0, node_os_1.type)().toLowerCase();
-    if (OS !== 'windows_nt') {
-        try {
-            const result = await gluegun_1.system.spawn(`${command} && env`, {
-                shell: process.env.SHELL,
-            });
-            if (typeof result.stdout === 'string' ||
-                result.stdout instanceof Buffer) {
-                const localEnv = Object.fromEntries(result.stdout.toString()
-                    .split('\n')
-                    .map((field) => field?.split('=')));
-                if ('PATH' in localEnv)
-                    process.env = localEnv;
-            }
-        }
-        catch (error) {
-            console.warn('Unable to update environment:', error);
-        }
+    if (OS === 'windows_nt') {
+        return (0, errors_1.success)(undefined); // No-op on Windows
     }
+    return await (0, errors_1.wrapAsync)(async () => {
+        const result = await gluegun_1.system.spawn(`${command} && env`, {
+            shell: process.env.SHELL,
+        });
+        if (typeof result.stdout === 'string' || result.stdout instanceof Buffer) {
+            const localEnv = Object.fromEntries(result.stdout.toString()
+                .split('\n')
+                .map((field) => field?.split('='))
+                .filter((pair) => pair.length === 2));
+            if ('PATH' in localEnv)
+                process.env = localEnv;
+        }
+    });
 }
 /**
  * Set updated env from user shell as process.env
  */
 async function sourceEnvironment() {
-    await updateProcessEnv(`source ${constants_1.EXPORTS_FILE_PATH}`);
+    return await updateProcessEnv(`source ${constants_1.EXPORTS_FILE_PATH}`);
 }
 /**
  * Set updated env from IDF_PATH/export.sh as process.env
  */
 async function sourceIdf() {
-    await updateProcessEnv(`source $IDF_PATH/export.sh 1> /dev/null`);
+    return await updateProcessEnv(`source $IDF_PATH/export.sh 1> /dev/null`);
 }
 /**
  * Set updated env from IDF_PYTHON_ENV_PATH as process.env
  */
 async function sourceIdfPythonEnv() {
-    await updateProcessEnv(`source ${process.env.IDF_PYTHON_ENV_PATH ?? ''}/bin/activate`);
+    return await updateProcessEnv(`source ${process.env.IDF_PYTHON_ENV_PATH ?? ''}/bin/activate`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/toolbox/system/packages.js

@@ -4,35 +4,38 @@ exports.findMissingDependencies = findMissingDependencies;
 exports.installPackages = installPackages;
 const exec_1 = require("../system/exec");
 const gluegun_1 = require("gluegun");
+const errors_1 = require("./errors");
 /**
  * Check if the list of dependencies are installed on the system.
  **/
 async function findMissingDependencies(dependencies) {
-    const missingDependencies = [];
-    for (const dep of dependencies) {
-        if (dep.type === 'binary') {
-            if (gluegun_1.system.which(dep.name) === null) {
-                missingDependencies.push(dep);
+    return await (0, errors_1.wrapAsync)(async () => {
+        const missingDependencies = [];
+        for (const dep of dependencies) {
+            if (dep.type === 'binary') {
+                if (gluegun_1.system.which(dep.name) === null) {
+                    missingDependencies.push(dep);
+                }
             }
-        }
-        if (dep.type === 'library') {
-            try {
-                await gluegun_1.system.run(`pkg-config --exists ${dep.name}`);
+            if (dep.type === 'library') {
+                try {
+                    await gluegun_1.system.run(`pkg-config --exists ${dep.name}`);
+                }
+                catch (error) {
+                    missingDependencies.push(dep);
+                }
             }
-            catch (error) {
-                missingDependencies.push(dep);
+            if (dep.type === 'pylib') {
+                try {
+                    await gluegun_1.system.run(`pip3 show ${dep.name}`);
+                }
+                catch (error) {
+                    missingDependencies.push(dep);
+                }
             }
         }
-        if (dep.type === 'pylib') {
-            try {
-                await gluegun_1.system.run(`pip3 show ${dep.name}`);
-            }
-            catch (error) {
-                missingDependencies.push(dep);
-            }
-        }
-    }
-    return missingDependencies;
+        return missingDependencies;
+    });
 }
 /**
  * Attempt to install packages on the linux platform.
@@ -40,12 +43,12 @@ async function findMissingDependencies(dependencies) {
 async function installPackages(packages) {
     const packageManager = gluegun_1.system.which('apt');
     if (packageManager !== null && packageManager !== undefined) {
-        await (0, exec_1.pkexec)(`${packageManager} install --yes ${packages.map((p) => p.packageName).join(' ')}`, { stdout: process.stdout });
+        const result = await (0, exec_1.pkexec)(`${packageManager} install --yes ${packages.map((p) => p.packageName).join(' ')}`, { stdout: process.stdout });
+        return result;
     }
     else {
-        gluegun_1.print.warning('xs-dev attempted to install dependencies, but does not yet support your package manager');
-        gluegun_1.print.warning(`Please install these dependencies before running this command again: ${packages.map((p) => p.packageName).join(', ')}`);
-        process.exit(1);
+        return (0, errors_1.failure)(`xs-dev attempted to install dependencies, but does not yet support your package manager. ` +
+            `Please install these dependencies before running this command again: ${packages.map((p) => p.packageName).join(', ')}`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdG9vbGJveC9zeXN0ZW0vcGFja2FnZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFTQSwwREE4QkM7QUFLRCwwQ0FpQkM7QUE1REQseUNBQXVDO0FBQ3ZDLHFDQUFnQztBQUVoQyxxQ0FBNkM7QUFFN0M7O0lBRUk7QUFDRyxLQUFLLFVBQVUsdUJBQXVCLENBQzNDLFlBQTBCO0lBRTFCLE9BQU8sTUFBTSxJQUFBLGtCQUFTLEVBQUMsS0FBSyxJQUFJLEVBQUU7UUFDaEMsTUFBTSxtQkFBbUIsR0FBaUIsRUFBRSxDQUFBO1FBRTVDLEtBQUssTUFBTSxHQUFHLElBQUksWUFBWSxFQUFFLENBQUM7WUFDL0IsSUFBSSxHQUFHLENBQUMsSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO2dCQUMxQixJQUFJLGdCQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQztvQkFDcEMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO2dCQUMvQixDQUFDO1lBQ0gsQ0FBQztZQUNELElBQUksR0FBRyxDQUFDLElBQUksS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDM0IsSUFBSSxDQUFDO29CQUNILE1BQU0sZ0JBQU0sQ0FBQyxHQUFHLENBQUMsdUJBQXVCLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO2dCQUNyRCxDQUFDO2dCQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7b0JBQ2YsbUJBQW1CLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO2dCQUMvQixDQUFDO1lBQ0gsQ0FBQztZQUNELElBQUksR0FBRyxDQUFDLElBQUksS0FBSyxPQUFPLEVBQUUsQ0FBQztnQkFDekIsSUFBSSxDQUFDO29CQUNILE1BQU0sZ0JBQU0sQ0FBQyxHQUFHLENBQUMsYUFBYSxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQTtnQkFDM0MsQ0FBQztnQkFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO29CQUNmLG1CQUFtQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtnQkFDL0IsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBRUQsT0FBTyxtQkFBbUIsQ0FBQTtJQUM1QixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUM7QUFFRDs7SUFFSTtBQUNHLEtBQUssVUFBVSxlQUFlLENBQ25DLFFBQXNCO0lBRXRCLE1BQU0sY0FBYyxHQUFHLGdCQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRTFDLElBQUksY0FBYyxLQUFLLElBQUksSUFBSSxjQUFjLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDNUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFBLGFBQU0sRUFDekIsR0FBRyxjQUFjLGtCQUFrQixRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQ2pGLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FDM0IsQ0FBQTtRQUNELE9BQU8sTUFBTSxDQUFBO0lBQ2YsQ0FBQztTQUFNLENBQUM7UUFDTixPQUFPLElBQUEsZ0JBQU8sRUFDWiwyRkFBMkY7WUFDekYsd0VBQXdFLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDMUgsQ0FBQTtJQUNILENBQUM7QUFDSCxDQUFDIn0=