@nordicsemiconductor/pc-nrfconnect-shared 213.0.0 → 214.0.0

package/nrfutil/device/logLibVersions.ts

@@ -4,14 +4,15 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { spawn } from 'child_process';
-import os from 'os';
-
 import describeError from '../../src/logging/describeError';
-import { getJlinkCompatibility } from '../jlinkVersion';
-import { describeVersion, findDependency } from '../moduleVersion';
 import { getNrfutilLogger } from '../nrfutilLogger';
-import type { Dependency, ModuleVersion } from '../sandboxTypes';
+import { getJlinkCompatibility } from '../version/jlinkVersion';
+import {
+    type Dependency,
+    describeVersion,
+    findDependency,
+    type ModuleVersion,
+} from '../version/moduleVersion';
 
 const log = (
     description: string,
@@ -29,49 +30,7 @@ const log = (
     }
 };
 
-const pathEnvVariable = () => {
-    if (process.platform !== 'darwin') return process.env;
-
-    return {
-        ...process.env,
-        PATH: `/bin:/usr/bin:/usr/local/bin:${process.env.PATH}`,
-    };
-};
-
-const spawnAsync = (cmd: string, params?: string[]) =>
-    new Promise<string>((resolve, reject) => {
-        const codeProcess = spawn(cmd, params, {
-            shell: true,
-            env: pathEnvVariable(),
-        });
-        let stdout = '';
-        let stderr = '';
-        codeProcess.stdout.on('data', data => {
-            stdout += data;
-        });
-        codeProcess.stderr.on('data', data => {
-            stderr += data;
-        });
-
-        codeProcess.on('close', (code, signal) => {
-            if (stderr) console.log(stderr);
-            if (code === 0 && signal === null) {
-                return resolve(stdout);
-            }
-            return reject();
-        });
-    });
-
-const checkJLinkArchitectureOnDarwin = async () => {
-    const stdout = await spawnAsync('file $(which JLinkExe)');
-    const universalMatch = 'Mach-O universal binary with 2 architectures';
-    const intelMatch = 'Mach-O 64-bit executable x86_64';
-    if (stdout.includes(universalMatch)) return 'universal';
-    if (stdout.includes(intelMatch)) return 'x86_64';
-    return 'arm';
-};
-
-export default async (moduleVersion: ModuleVersion) => {
+export default (moduleVersion: ModuleVersion) => {
     const logger = getNrfutilLogger();
     try {
         const dependencies = moduleVersion.dependencies;
@@ -107,26 +66,6 @@ export default async (moduleVersion: ModuleVersion) => {
                 );
                 break;
         }
-
-        if (
-            process.platform === 'darwin' &&
-            os.cpus()[0].model.includes('Apple')
-        ) {
-            const JLinkArchOnDarwin = await checkJLinkArchitectureOnDarwin();
-
-            if (JLinkArchOnDarwin && JLinkArchOnDarwin !== 'universal') {
-                const JLinkInstallerVersion =
-                    JLinkArchOnDarwin === 'arm'
-                        ? '64-bit Apple M1 Installer'
-                        : '64-bit Intel Installer';
-                logger?.warn(
-                    `It looks like you have installed JLink using ${JLinkInstallerVersion}, but currently we only support their Universal Installer for your system.`
-                );
-                logger?.warn(
-                    `Please install JLink: https://www.segger.com/downloads/jlink/JLink_MacOSX_V818_universal.pkg`
-                );
-            }
-        }
     } catch (error) {
         logger?.error(
             `Failed to get the library versions${

package/nrfutil/device/program.ts

@@ -9,45 +9,48 @@ import os from 'os';
 import path from 'path';
 import { v4 as uuid } from 'uuid';
 
-import { Progress } from '../sandboxTypes';
+import { type OnProgress } from '../sandboxTypes';
 import {
+    coreArg,
     DeviceCore,
     deviceSingleTaskEndOperationVoid,
-    DeviceTraits,
+    deviceTraitsToArgs,
     NrfutilDevice,
     ResetKind,
 } from './common';
 
-export type FileExtensions = 'zip' | 'hex';
-export type FirmwareType = { buffer: Buffer; type: FileExtensions } | string;
+export type FileExtension = 'zip' | 'hex';
+
+type FirmwareBuffer = { buffer: Buffer; type: FileExtension };
+export type Firmware = FirmwareBuffer | string;
 
 export type ProgrammingOptions =
     | JLinkProgrammingOptions
     | McuBootProgrammingOptions
     | NordicDfuProgrammingOptions;
 
-export interface JLinkProgrammingOptions {
-    chipEraseMode?: 'ERASE_ALL' | 'ERASE_NONE';
+interface JLinkProgrammingOptions {
+    chipEraseMode: 'ERASE_ALL' | 'ERASE_NONE';
     reset?: ResetKind;
     verify?: 'VERIFY_HASH' | 'VERIFY_NONE' | 'VERIFY_READ';
 }
 
-export interface McuBootProgrammingOptions {
+interface McuBootProgrammingOptions {
     mcuEndState?: 'NRFDL_MCU_STATE_APPLICATION' | 'NRFDL_MCU_STATE_PROGRAMMING';
     netCoreUploadDelay?: number;
     target?: string;
 }
 
-export interface NordicDfuProgrammingOptions {
-    mcuEndState?: 'NRFDL_MCU_STATE_APPLICATION' | 'NRFDL_MCU_STATE_PROGRAMMING';
+interface NordicDfuProgrammingOptions {
+    mcuEndState: 'NRFDL_MCU_STATE_APPLICATION' | 'NRFDL_MCU_STATE_PROGRAMMING';
 }
 
-export const isJLinkProgrammingOptions = (
+const isJLinkProgrammingOptions = (
     options: ProgrammingOptions
 ): options is JLinkProgrammingOptions =>
     (options as JLinkProgrammingOptions).chipEraseMode !== undefined;
 
-export const isMcuBootProgrammingOptions = (
+const isMcuBootProgrammingOptions = (
     options: ProgrammingOptions
 ): options is McuBootProgrammingOptions =>
     (options as McuBootProgrammingOptions).netCoreUploadDelay !== undefined ||
@@ -59,52 +62,45 @@ export const isNordicDfuProgrammingOptions = (
     !isMcuBootProgrammingOptions(options) &&
     (options as NordicDfuProgrammingOptions).mcuEndState !== undefined;
 
-const deviceTraitsToArgs = (traits: DeviceTraits) => {
-    const args: string[] = [];
-    const traitsString = Object.keys(traits)
-        .map(trait => (traits[trait as keyof DeviceTraits] ? trait : null))
-        .filter(t => t !== null)
-        .join(',');
-
-    if (traitsString.length > 0) {
-        args.push('--traits');
-        args.push(traitsString);
-    }
-
-    return args;
-};
-
-export const programmingOptionsToArgs = (options?: ProgrammingOptions) => {
+const programmingOptionsToStrings = (options?: ProgrammingOptions) => {
     if (!options) return [];
 
-    const args: string[] = [];
-
     if (isJLinkProgrammingOptions(options)) {
-        if (options.chipEraseMode)
-            args.push(`chip_erase_mode=${options.chipEraseMode}`);
-        if (options.reset) args.push(`reset=${options.reset}`);
-        if (options.verify) args.push(`verify=${options.verify}`);
-    } else if (isMcuBootProgrammingOptions(options)) {
-        if (options.mcuEndState)
-            args.push(`mcu_end_state=${options.mcuEndState}`);
-        if (options.netCoreUploadDelay)
-            args.push(
+        return [
+            `chip_erase_mode=${options.chipEraseMode}`,
+            options.reset && `reset=${options.reset}`,
+            options.verify && `verify=${options.verify}`,
+        ].filter(Boolean);
+    }
+
+    if (isMcuBootProgrammingOptions(options)) {
+        return [
+            options.mcuEndState && `mcu_end_state=${options.mcuEndState}`,
+            options.target && `target=${options.target}`,
+            options.netCoreUploadDelay &&
                 `net_core_upload_delay=${Math.round(
                     options.netCoreUploadDelay
-                )}`
-            );
-        if (options.target) args.push(`target=${options.target}`);
-    } else if (isNordicDfuProgrammingOptions(options)) {
-        if (options.mcuEndState)
-            args.push(`mcu_end_state=${options.mcuEndState}`);
+                )}`,
+        ].filter(Boolean);
+    }
+
+    if (isNordicDfuProgrammingOptions(options)) {
+        return [`mcu_end_state=${options.mcuEndState}`];
     }
 
-    return args.length > 0 ? ['--options', `${args.join(',')}`] : [];
+    throw new Error(`Unhandled ProgrammingOptions: ${options}`);
 };
+
+export const programmingOptionsToArgs = (options?: ProgrammingOptions) => {
+    const optionsString = programmingOptionsToStrings(options).join(',');
+
+    return optionsString.length > 0 ? ['--options', optionsString] : [];
+};
+
 const program = (
     device: NrfutilDevice,
     firmwarePath: string,
-    onProgress?: (progress: Progress) => void,
+    onProgress?: OnProgress,
     core?: DeviceCore,
     programmingOptions?: ProgrammingOptions,
     controller?: AbortController
@@ -118,32 +114,31 @@ const program = (
             '--firmware',
             firmwarePath,
             ...deviceTraitsToArgs(device.traits),
-            ...(core ? ['--core', core] : []),
+            ...coreArg(core),
             ...programmingOptionsToArgs(programmingOptions),
         ]
     );
 
+export const createTempFile = (firmware: FirmwareBuffer): string => {
+    let tempFilePath;
+    do {
+        tempFilePath = path.join(os.tmpdir(), `${uuid()}.${firmware.type}`);
+    } while (fs.existsSync(tempFilePath));
+
+    fs.writeFileSync(tempFilePath, firmware.buffer);
+
+    return tempFilePath;
+};
+
 const programBuffer = async (
     device: NrfutilDevice,
-    firmware: Buffer,
-    type: FileExtensions,
-    onProgress?: (progress: Progress) => void,
+    firmware: FirmwareBuffer,
+    onProgress?: OnProgress,
     core?: DeviceCore,
     programmingOptions?: ProgrammingOptions,
     controller?: AbortController
 ) => {
-    const saveTemp = (): string => {
-        let tempFilePath;
-        do {
-            tempFilePath = path.join(os.tmpdir(), `${uuid()}.${type}`);
-        } while (fs.existsSync(tempFilePath));
-
-        fs.writeFileSync(tempFilePath, firmware);
-
-        return tempFilePath;
-    };
-
-    const tempFilePath = saveTemp();
+    const tempFilePath = createTempFile(firmware);
     try {
         await program(
             device,
@@ -161,8 +156,8 @@ const programBuffer = async (
 
 export default async (
     device: NrfutilDevice,
-    firmware: FirmwareType,
-    onProgress?: (progress: Progress) => void,
+    firmware: Firmware,
+    onProgress?: OnProgress,
     core?: DeviceCore,
     programmingOptions?: ProgrammingOptions,
     controller?: AbortController
@@ -179,8 +174,7 @@ export default async (
     } else {
         await programBuffer(
             device,
-            firmware.buffer,
-            firmware.type,
+            firmware,
             onProgress,
             core,
             programmingOptions,

package/nrfutil/device/recover.ts

@@ -4,8 +4,9 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { Progress } from '../sandboxTypes';
+import { type OnProgress } from '../sandboxTypes';
 import {
+    coreArg,
     DeviceCore,
     deviceSingleTaskEndOperationVoid,
     NrfutilDevice,
@@ -14,7 +15,7 @@ import {
 export default (
     device: NrfutilDevice,
     core?: DeviceCore,
-    onProgress?: (progress: Progress) => void,
+    onProgress?: OnProgress,
     controller?: AbortController
 ) =>
     deviceSingleTaskEndOperationVoid(
@@ -22,5 +23,5 @@ export default (
         'recover',
         onProgress,
         controller,
-        core ? ['--core', core] : []
+        coreArg(core)
     );

package/nrfutil/device/reset.ts

@@ -4,8 +4,9 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { Progress } from '../sandboxTypes';
+import { type OnProgress } from '../sandboxTypes';
 import {
+    coreArg,
     DeviceCore,
     deviceSingleTaskEndOperationVoid,
     NrfutilDevice,
@@ -16,20 +17,13 @@ export default async (
     device: NrfutilDevice,
     core?: DeviceCore,
     resetKind?: ResetKind,
-    onProgress?: (progress: Progress) => void,
+    onProgress?: OnProgress,
     controller?: AbortController
 ) => {
-    const args: string[] = [];
-
-    if (resetKind) {
-        args.push('--reset-kind');
-        args.push(resetKind);
-    }
-
-    if (core) {
-        args.push('--core');
-        args.push(core);
-    }
+    const args = [
+        ...(resetKind ? ['--reset-kind', resetKind] : []),
+        ...coreArg(core),
+    ];
 
     await deviceSingleTaskEndOperationVoid(
         device,

package/nrfutil/device/setMcuState.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { Progress } from '../sandboxTypes';
+import { type OnProgress } from '../sandboxTypes';
 import { deviceSingleTaskEndOperationVoid, NrfutilDevice } from './common';
 
 export type McuState = 'Application' | 'Programming';
@@ -12,7 +12,7 @@ export type McuState = 'Application' | 'Programming';
 export default (
     device: NrfutilDevice,
     state: McuState,
-    onProgress?: (progress: Progress) => void,
+    onProgress?: OnProgress,
     controller?: AbortController,
     target?: string
 ) =>

package/nrfutil/device/setProtectionStatus.ts

@@ -4,8 +4,9 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { Progress } from '../sandboxTypes';
+import { type OnProgress } from '../sandboxTypes';
 import {
+    coreArg,
     DeviceCore,
     deviceSingleTaskEndOperationVoid,
     NrfutilDevice,
@@ -15,7 +16,7 @@ export default (
     device: NrfutilDevice,
     region: 'All' | 'SecureRegions' | 'Region0' | 'Region0Region1',
     core?: DeviceCore,
-    onProgress?: (progress: Progress) => void,
+    onProgress?: OnProgress,
     controller?: AbortController
 ) =>
     deviceSingleTaskEndOperationVoid(
@@ -23,5 +24,5 @@ export default (
         'protection-set',
         onProgress,
         controller,
-        [region, ...(core ? ['--core', core] : [])]
+        [region, ...coreArg(core)]
     );

package/nrfutil/device/xRead.ts

@@ -5,8 +5,9 @@
  */
 
 /* eslint-disable no-bitwise */
-import { Progress } from '../sandboxTypes';
+import { type OnProgress } from '../sandboxTypes';
 import {
+    coreArg,
     DeviceCore,
     deviceSingleTaskEndOperation,
     NrfutilDevice,
@@ -88,43 +89,40 @@ export function toIntelHex(memoryData: MemoryData[]) {
     return { intelHex: records.join('\n') };
 }
 
+export type XReadOptions = {
+    address: number;
+    bytes: number;
+    width?: 8 | 15 | 32; // defaults to 32
+    direct?: boolean;
+};
+
+export const xReadOptionsToArgs = ({
+    address,
+    bytes,
+    width,
+    direct,
+}: XReadOptions) => [
+    '--address',
+    address.toString(),
+    '--bytes',
+    bytes.toString(),
+    ...(direct ? ['--direct'] : []),
+    ...(width ? ['--width', width.toString()] : []),
+];
+
 const xRead = async (
     device: NrfutilDevice,
-    address: number,
-    bytes: number,
+    options: XReadOptions,
     core?: DeviceCore,
-    width?: 8 | 15 | 32, // defaults to 32
-    direct?: boolean,
-    onProgress?: (progress: Progress) => void,
+    onProgress?: OnProgress,
     controller?: AbortController
 ) => {
-    const args: string[] = [
-        '--address',
-        address.toString(),
-        '--bytes',
-        bytes.toString(),
-    ];
-
-    if (direct) {
-        args.push('--direct');
-    }
-
-    if (width) {
-        args.push('--width');
-        args.push(width.toString());
-    }
-
-    if (core) {
-        args.push('--core');
-        args.push(core);
-    }
-
     const result = await deviceSingleTaskEndOperation<MemoryReadRaw>(
         device,
         'x-read',
         onProgress,
         controller,
-        args
+        [...xReadOptionsToArgs(options), ...coreArg(core)]
     );
 
     return toIntelHex(result.memoryData);

package/nrfutil/index.ts

@@ -4,8 +4,7 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-export { default as prepareSandbox } from './sandbox';
-export type { NrfutilSandbox } from './sandbox';
+export { NrfutilSandbox } from './sandbox';
 export type { Progress } from './sandboxTypes';
 export { getNrfutilLogger, setNrfutilLogger } from './nrfutilLogger';
 export {
@@ -14,4 +13,4 @@ export {
     setVerboseLogging,
     getAllModuleVersions,
 } from './modules';
-export { getJlinkCompatibility } from './jlinkVersion';
+export { getJlinkCompatibility } from './version/jlinkVersion';

package/nrfutil/modules.ts

@@ -8,10 +8,10 @@ import { getUserDataDir } from '../src/utils/appDirs';
 import { isLauncher, packageJsonApp } from '../src/utils/packageJson';
 import { getIsLoggingVerbose } from '../src/utils/persistentStore';
 import logLibVersions from './device/logLibVersions';
-import { describeVersion } from './moduleVersion';
 import { getNrfutilLogger } from './nrfutilLogger';
-import sandbox, { NrfutilSandbox } from './sandbox';
+import { NrfutilSandbox } from './sandbox';
 import { LogLevel } from './sandboxTypes';
+import { describeVersion } from './version/moduleVersion';
 
 const fallbackLevel = process.env.NODE_ENV === 'production' ? 'off' : 'error';
 
@@ -40,31 +40,26 @@ const logModuleVersions = (module: string, moduleSandbox: NrfutilSandbox) => {
 const forwardLogging = (moduleSandbox: NrfutilSandbox) => {
     moduleSandbox.onLogging((evt, pid) => {
         const logger = getNrfutilLogger();
-        const formatMsg = (msg: string) =>
-            `${
-                pid && moduleSandbox?.logLevel === 'trace'
-                    ? `[PID:${pid}] `
-                    : ''
-            }${msg}`;
+        const msg = `${moduleSandbox.pidIfTraceLogging(pid)}${evt.message}`;
 
         switch (evt.level) {
             case 'TRACE':
-                logger?.verbose(formatMsg(evt.message));
+                logger?.verbose(msg);
                 break;
             case 'DEBUG':
-                logger?.debug(formatMsg(evt.message));
+                logger?.debug(msg);
                 break;
             case 'INFO':
-                logger?.info(formatMsg(evt.message));
+                logger?.info(msg);
                 break;
             case 'WARN':
-                logger?.warn(formatMsg(evt.message));
+                logger?.warn(msg);
                 break;
             case 'ERROR':
-                logger?.error(formatMsg(evt.message));
+                logger?.error(msg);
                 break;
             case 'CRITICAL':
-                logger?.error(formatMsg(evt.message));
+                logger?.error(msg);
                 break;
             case 'OFF':
             default:
@@ -79,7 +74,7 @@ const getModuleSandbox = (module: string) => {
 
     const createModuleSandbox = async () => {
         getNrfutilLogger()?.info(`Initialising the bundled nrfutil ${module}`);
-        promiseModuleSandbox = sandbox(getUserDataDir(), module);
+        promiseModuleSandbox = NrfutilSandbox.create(getUserDataDir(), module);
         moduleSandbox = await promiseModuleSandbox;
 
         logModuleVersions(module, moduleSandbox);