@nordicsemiconductor/pc-nrfconnect-shared 127.0.0 → 129.0.0

package/nrfutil/device/batch.ts

@@ -93,12 +93,17 @@ export class Batch {
         this.enqueueBatchOperationObject('fw-read', core, {
             ...callbacks,
             onTaskEnd: (taskEnd: TaskEnd<DeviceBuffer>) => {
-                if (taskEnd.result === 'success' && taskEnd.data)
+                if (taskEnd.result === 'success' && taskEnd.data) {
+                    const data = Buffer.from(taskEnd.data.buffer, 'base64');
                     callbacks?.onTaskEnd?.({
                         ...taskEnd,
-                        data: Buffer.from(taskEnd.data.buffer, 'base64'),
+                        task: {
+                            ...taskEnd.task,
+                            data,
+                        },
+                        data,
                     });
-                else {
+                } else {
                     callbacks?.onException?.(new Error('Read failed'));
                 }
             },
@@ -263,7 +268,7 @@ export class Batch {
 
         const sandbox = await getDeviceSandbox();
         try {
-            await sandbox.execSubcommand<unknown>(
+            await sandbox.spawnNrfutilSubcommand<unknown>(
                 'x-execute-batch',
                 [
                     '--serial-number',

package/nrfutil/device/common.ts

@@ -12,6 +12,7 @@ import {
 import { getNrfutilLogger } from '../nrfutilLogger';
 import sandbox, { type NrfutilSandbox } from '../sandbox';
 import { Progress } from '../sandboxTypes';
+import logLibVersions from './logLibVersions';
 
 export const deviceTraitsToArgs = (traits: DeviceTraits) => {
     const args: string[] = [];
@@ -171,6 +172,7 @@ export const getDeviceSandbox = async () => {
             undefined
         );
         deviceSandbox = await promiseDeviceSandbox;
+        deviceSandbox.getModuleVersion().then(logLibVersions);
 
         deviceSandbox.onLogging((evt, pid) => {
             const deviceLogger = getNrfutilLogger();

package/nrfutil/device/list.ts

@@ -68,7 +68,7 @@ export default async (
     };
 
     const sandbox = await getDeviceSandbox();
-    return sandbox.execBackgroundSubcommand<HotplugEvent>('list', args, {
+    return sandbox.spawnBackgroundSubcommand<HotplugEvent>('list', args, {
         onData,
         onError,
     });

package/{src/utils → nrfutil/device}/logLibVersions.ts

@@ -7,13 +7,13 @@
 import { spawn } from 'child_process';
 import os from 'os';
 
-import NrfutilDeviceLib from '../../nrfutil/device/device';
+import logger from '../../src/logging';
 import {
     describeVersion,
+    getExpectedVersion,
     resolveModuleVersion,
-} from '../../nrfutil/moduleVersion';
-import { SubDependency } from '../../nrfutil/sandboxTypes';
-import logger from '../logging';
+} from '../moduleVersion';
+import { ModuleVersion, SubDependency } from '../sandboxTypes';
 
 const log = (description: string, moduleVersion?: SubDependency | string) => {
     if (moduleVersion == null) {
@@ -67,15 +67,29 @@ const checkJLinkArchitectureOnDarwin = async () => {
     return 'arm';
 };
 
-export default async () => {
+export default async (moduleVersion: ModuleVersion) => {
     try {
-        const moduleVersion = await NrfutilDeviceLib.getModuleVersion();
         const dependencies = moduleVersion.dependencies;
 
         log('nrfutil-device', moduleVersion.version);
         log('nrf-device-lib', resolveModuleVersion('nrfdl', dependencies));
         log('nrfjprog DLL', resolveModuleVersion('jprog', dependencies));
         log('JLink', resolveModuleVersion('JlinkARM', dependencies));
+
+        const jlinkVersion = resolveModuleVersion('JlinkARM', dependencies);
+
+        if (jlinkVersion) {
+            const result = getExpectedVersion(jlinkVersion);
+            if (!result.isExpectedVersion) {
+                logger.warn(
+                    `Installed JLink version does not match the expected version (${result.expectedVersion})`
+                );
+            }
+        } else {
+            logger.warn(
+                `JLink is not installed. Please install JLink from: https://www.segger.com/downloads/jlink`
+            );
+        }
         if (
             process.platform === 'darwin' &&
             os.cpus()[0].model.includes('Apple')

package/nrfutil/sandbox.ts

@@ -4,10 +4,11 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { spawn } from 'child_process';
+import { exec, spawn } from 'child_process';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import treeKill from 'tree-kill';
 
 import describeError from '../src/logging/describeError';
 import usageData from '../src/utils/usageData';
@@ -136,7 +137,7 @@ export class NrfutilSandbox {
     };
 
     public getModuleVersion = async () => {
-        const results = await this.execNrfutil<ModuleVersion>(this.module, [
+        const results = await this.spawnNrfutil<ModuleVersion>(this.module, [
             '--version',
         ]);
 
@@ -175,7 +176,7 @@ export class NrfutilSandbox {
             getNrfutilLogger()?.info(
                 `Preparing nrfutil-${this.module} version: ${this.version}`
             );
-            await this.execNrfutil(
+            await this.spawnNrfutil(
                 'install',
                 [`${this.module}=${this.version}`, '--force'],
                 onProgress
@@ -193,13 +194,59 @@ export class NrfutilSandbox {
         }
     };
 
-    private execNrfutil = async <Result>(
+    public getNrfutilExePath = () => path.join(this.baseDir, 'nrfutil');
+
+    public spawnNrfutilSubcommand = <Result>(
+        command: string,
+        args: string[],
+        onProgress?: (progress: Progress, task?: Task) => void,
+        onTaskBegin?: (taskBegin: TaskBegin) => void,
+        onTaskEnd?: (taskEnd: TaskEnd<Result>) => void,
+        controller?: AbortController,
+        editEnv?: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
+    ) =>
+        this.spawnNrfutil<Result>(
+            this.module,
+            [command, ...args],
+            onProgress,
+            onTaskBegin,
+            onTaskEnd,
+            controller,
+            editEnv
+        );
+
+    private spawnNrfutilCommand = (
+        command: string,
+        args: string[],
+        parser: (data: Buffer, pid?: number) => Buffer | undefined,
+        onStdError: (data: Buffer, pid?: number) => void,
+        controller?: AbortController,
+        editEnv?: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
+    ) =>
+        this.spawnCommand(
+            this.getNrfutilExePath(),
+            [
+                command,
+                ...args,
+                '--json',
+                '--log-output=stdout',
+                '--log-level',
+                this.logLevel,
+            ],
+            parser,
+            onStdError,
+            controller,
+            editEnv
+        );
+
+    private spawnNrfutil = async <Result>(
         command: string,
         args: string[],
         onProgress?: (progress: Progress, task?: Task) => void,
         onTaskBegin?: (taskBegin: TaskBegin) => void,
         onTaskEnd?: (taskEnd: TaskEnd<Result>) => void,
-        controller?: AbortController
+        controller?: AbortController,
+        editEnv?: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
     ) => {
         const info: Result[] = [];
         const taskEnd: TaskEnd<Result>[] = [];
@@ -207,7 +254,7 @@ export class NrfutilSandbox {
         let pid: number | undefined;
 
         try {
-            await this.execCommand(
+            await this.spawnNrfutilCommand(
                 command,
                 args,
                 (data, processId) =>
@@ -235,7 +282,8 @@ export class NrfutilSandbox {
                     pid = processId;
                     stdErr = (stdErr ?? '') + data.toString();
                 },
-                controller
+                controller,
+                editEnv
             );
 
             if (
@@ -276,47 +324,201 @@ export class NrfutilSandbox {
         }
     };
 
-    public execSubcommand = <Result>(
+    public spawnCommand = (
+        command: string,
+        args: string[],
+        parser: (data: Buffer, pid?: number) => Buffer | undefined,
+        onStdError: (data: Buffer, pid?: number) => void,
+        controller?: AbortController,
+        editEnv: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv = env => env
+    ) =>
+        new Promise<void>((resolve, reject) => {
+            let aborting = false;
+            usageData.sendUsageData(`running nrfutil ${this.module}`, {
+                args,
+                exec: command,
+            });
+            const nrfutil = spawn(command, args, {
+                env: editEnv(this.env),
+            });
+
+            const listener = () => {
+                getNrfutilLogger()?.info(
+                    `Aborting ongoing nrfutil ${
+                        this.module
+                    } ${command} ${JSON.stringify(args)}`
+                );
+                aborting = true;
+                if (nrfutil.pid) {
+                    treeKill(nrfutil.pid);
+                } else {
+                    nrfutil.kill('SIGINT');
+                }
+            };
+
+            controller?.signal.addEventListener('abort', listener);
+
+            let buffer = Buffer.from('');
+
+            nrfutil.stdout.on('data', (data: Buffer) => {
+                if (controller?.signal.aborted) return;
+
+                buffer = Buffer.concat([buffer, data]);
+                const remainingBytes = parser(buffer, nrfutil.pid);
+                if (remainingBytes) {
+                    buffer = remainingBytes;
+                } else {
+                    buffer = Buffer.from('');
+                }
+            });
+
+            nrfutil.stderr.on('data', (data: Buffer) => {
+                onStdError(data, nrfutil.pid);
+            });
+
+            nrfutil.on('close', code => {
+                controller?.signal.removeEventListener('abort', listener);
+                if (aborting) {
+                    reject(
+                        new Error(
+                            `Aborted ongoing nrfutil ${command} ${
+                                args[0] ?? ''
+                            }`
+                        )
+                    );
+                    return;
+                }
+
+                if (code === 0) {
+                    resolve();
+                } else {
+                    reject(new Error(`Failed with exit code ${code}.`));
+                }
+            });
+        });
+
+    public execNrfutilSubcommand = <Result>(
         command: string,
         args: string[],
         onProgress?: (progress: Progress, task?: Task) => void,
         onTaskBegin?: (taskBegin: TaskBegin) => void,
         onTaskEnd?: (taskEnd: TaskEnd<Result>) => void,
-        controller?: AbortController
+        controller?: AbortController,
+        editEnv?: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
     ) =>
-        this.execNrfutil<Result>(
+        this.execNrfutilCommand<Result>(
             this.module,
             [command, ...args],
             onProgress,
             onTaskBegin,
             onTaskEnd,
-            controller
+            controller,
+            editEnv
         );
 
-    private execCommand = (
+    private execNrfutilCommand = async <Result>(
         command: string,
         args: string[],
-        parser: (data: Buffer, pid?: number) => Buffer | undefined,
+        onProgress?: (progress: Progress, task?: Task) => void,
+        onTaskBegin?: (taskBegin: TaskBegin) => void,
+        onTaskEnd?: (taskEnd: TaskEnd<Result>) => void,
+        controller?: AbortController,
+        editEnv?: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
+    ) => {
+        const info: Result[] = [];
+        const taskEnd: TaskEnd<Result>[] = [];
+        let stdErr: string | undefined;
+        let pid: number | undefined;
+
+        try {
+            await this.execCommand(
+                command,
+                args,
+                (data, processId) =>
+                    commonParser<Result>(
+                        data,
+                        {
+                            onProgress,
+                            onTaskBegin,
+                            onTaskEnd: end => {
+                                taskEnd.push(end);
+                                onTaskEnd?.(end);
+                            },
+                            onInfo: i => {
+                                info.push(i);
+                            },
+                            onLogging: logging => {
+                                this.onLoggingHandlers.forEach(onLogging => {
+                                    onLogging(logging, processId);
+                                });
+                            },
+                        },
+                        processId
+                    ),
+                (data, processId) => {
+                    pid = processId;
+                    stdErr = (stdErr ?? '') + data.toString();
+                },
+                controller,
+                editEnv
+            );
+
+            if (
+                stdErr ||
+                taskEnd.filter(end => end.result === 'fail').length > 0
+            )
+                throw new Error('Task failed.');
+
+            return { taskEnd, info };
+        } catch (e) {
+            const error = e as Error;
+
+            const addPunctuation = (str: string) =>
+                str.endsWith('.') ? str.trim() : `${str.trim()}.`;
+
+            if (stdErr) {
+                error.message += `\n${addPunctuation(stdErr)}`;
+            }
+
+            const taskEndErrorMsg = taskEnd
+                .filter(end => end.result === 'fail' && !!end.message)
+                .map(end =>
+                    end.message ? `Message: ${addPunctuation(end.message)}` : ''
+                )
+                .join('\n');
+
+            if (taskEndErrorMsg) {
+                error.message += `\n${taskEndErrorMsg}`;
+            }
+
+            error.message = error.message.replaceAll('Error: ', '');
+            usageData.sendErrorReport(
+                `${
+                    pid && this.logLevel === 'trace' ? `[PID:${pid}] ` : ''
+                }${describeError(error)}`
+            );
+            throw error;
+        }
+    };
+
+    public execCommand = (
+        command: string,
+        args: string[],
+        onData: (data: Buffer, pid?: number) => void,
         onStdError: (data: Buffer, pid?: number) => void,
-        controller?: AbortController
+        controller?: AbortController,
+        editEnv: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv = env => env
     ) =>
         new Promise<void>((resolve, reject) => {
             let aborting = false;
-            usageData.sendUsageData(`running nrfutil ${command}`, { args });
-            const nrfutil = spawn(
-                path.join(this.baseDir, 'nrfutil'),
-                [
-                    command,
-                    ...args,
-                    '--json',
-                    '--log-output=stdout',
-                    '--log-level',
-                    this.logLevel,
-                ],
-                {
-                    env: this.env,
-                }
-            );
+            usageData.sendUsageData(`running nrfutil ${this.module}`, {
+                args,
+                exec: command,
+            });
+
+            const nrfutil = exec(`${command} ${args.join(' ')}`, {
+                env: editEnv(this.env),
+            });
 
             const listener = () => {
                 getNrfutilLogger()?.info(
@@ -325,26 +527,22 @@ export class NrfutilSandbox {
                     } ${command} ${JSON.stringify(args)}`
                 );
                 aborting = true;
-                nrfutil.kill('SIGINT');
+                if (nrfutil.pid) {
+                    treeKill(nrfutil.pid);
+                } else {
+                    nrfutil.kill('SIGINT');
+                }
             };
 
             controller?.signal.addEventListener('abort', listener);
 
-            let buffer = Buffer.from('');
-
-            nrfutil.stdout.on('data', (data: Buffer) => {
+            nrfutil.stdout?.on('data', (data: Buffer) => {
                 if (controller?.signal.aborted) return;
 
-                buffer = Buffer.concat([buffer, data]);
-                const remainingBytes = parser(buffer, nrfutil.pid);
-                if (remainingBytes) {
-                    buffer = remainingBytes;
-                } else {
-                    buffer = Buffer.from('');
-                }
+                onData(data, nrfutil.pid);
             });
 
-            nrfutil.stderr.on('data', (data: Buffer) => {
+            nrfutil.stderr?.on('data', (data: Buffer) => {
                 onStdError(data, nrfutil.pid);
             });
 
@@ -369,16 +567,17 @@ export class NrfutilSandbox {
             });
         });
 
-    public execBackgroundSubcommand = <Result>(
+    public spawnBackgroundSubcommand = <Result>(
         command: string,
         args: string[],
-        processors: BackgroundTask<Result>
+        processors: BackgroundTask<Result>,
+        editEnv?: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
     ) => {
         const controller = new AbortController();
         let running = true;
         const closedHandlers: ((error?: Error) => void)[] = [];
 
-        const operation = this.execCommand(
+        const operation = this.spawnNrfutilCommand(
             this.module,
             [command, ...args],
             (data, pid) => {
@@ -400,7 +599,8 @@ export class NrfutilSandbox {
             (data, pid) => {
                 processors.onError(new Error(data.toString()), pid);
             },
-            controller
+            controller,
+            editEnv
         );
 
         operation
@@ -454,7 +654,7 @@ export class NrfutilSandbox {
         controller?: AbortController,
         args: string[] = []
     ) => {
-        const results = await this.execSubcommand<T>(
+        const results = await this.spawnNrfutilSubcommand<T>(
             command,
             args,
             onProgress,
@@ -464,7 +664,7 @@ export class NrfutilSandbox {
         );
 
         if (results.taskEnd.length === 1) {
-            return results.taskEnd[0].data;
+            return results.taskEnd[0].data ?? results.taskEnd[0].task.data;
         }
         throw new Error('Unexpected result');
     };
@@ -474,7 +674,7 @@ export class NrfutilSandbox {
         controller?: AbortController,
         args: string[] = []
     ) => {
-        const results = await this.execSubcommand<T>(
+        const results = await this.spawnNrfutilSubcommand<T>(
             command,
             args,
             undefined,

package/nrfutil/sandboxTypes.ts

@@ -17,13 +17,11 @@ export type FeatureClassification =
     | 'nrf-external-confidential'
     | 'nrf-external';
 
-export type Task = {
+export type Task<T = undefined | null> = {
     id: string;
     description: string;
     name: string;
-    data: {
-        serialNumber: string;
-    };
+    data: T;
 };
 
 export type TaskError = {
@@ -35,12 +33,11 @@ export type TaskBegin = {
     task: Task;
 };
 
-export type TaskEnd<T = void> = {
-    task: Task;
+export type TaskEnd<T = undefined | null> = {
+    task: Task<T>;
     message?: string;
     result?: 'success' | 'fail';
     error?: TaskError;
-    name: string;
     data?: T;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nordicsemiconductor/pc-nrfconnect-shared",
-    "version": "127.0.0",
+    "version": "129.0.0",
     "description": "Shared commodities for developing pc-nrfconnect-* packages",
     "repository": {
         "type": "git",
@@ -115,6 +115,7 @@
         "shasum": "1.0.2",
         "systeminformation": "5.17.12",
         "tailwindcss": "3.3.2",
+        "tree-kill-promise": "^3.0.14",
         "ts-node": "10.9.1",
         "typescript": "4.9.5",
         "util": "0.12.5",

package/src/InlineInput/InlineInput.tsx

@@ -34,9 +34,9 @@ useSynchronisationIfChangedFromOutside does take care of this by remembering the
 external value and comparing with it to determine whether it has changed.
 */
 
-const useSynchronisationIfChangedFromOutside = (
-    externalValue: string,
-    setInternalValue: (value: string) => void
+export const useSynchronisationIfChangedFromOutside = <T,>(
+    externalValue: T,
+    setInternalValue: (value: T) => void
 ) => {
     const previousExternalValue = useRef(externalValue);
     useEffect(() => {

package/src/InlineInput/NumberInputWithDropdown.tsx

@@ -9,6 +9,7 @@ import React, { useState } from 'react';
 import { DropdownItem } from '../Dropdown/Dropdown';
 import { RangeOrValues } from '../Slider/range';
 import classNames from '../utils/classNames';
+import { useSynchronisationIfChangedFromOutside } from './InlineInput';
 import NumberInlineInput from './NumberInlineInput';
 
 import styles from '../Dropdown/Dropdown.module.scss';
@@ -55,6 +56,8 @@ export default ({
         }
     };
 
+    useSynchronisationIfChangedFromOutside(value, setInlineValue);
+
     return (
         <div
             className={`tw-preflight tw-relative tw-w-full ${className}`}
@@ -78,6 +81,7 @@ export default ({
                     textAlignLeft
                     onValidityChanged={setIsValid}
                     preventDefaultInvalidStyle
+                    disabled={disabled}
                 />
                 <button
                     id={id}

package/src/logging/sendInitialLogMessages.ts

@@ -4,14 +4,8 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import NrfutilDeviceLib from '../../nrfutil/device/device';
-import {
-    getExpectedVersion,
-    resolveModuleVersion,
-} from '../../nrfutil/moduleVersion';
 import appDetails from '../utils/appDetails';
 import { getAppDataDir } from '../utils/appDirs';
-import logLibVersions from '../utils/logLibVersions';
 import udevInstalled from '../utils/udevInstalled';
 import logger from '.';
 
@@ -20,7 +14,6 @@ export default async () => {
     if (initialMessagesSent) return;
     initialMessagesSent = true;
 
-    logLibVersions();
     logger.debug(`Application data folder: ${getAppDataDir()}`);
 
     const {
@@ -44,23 +37,6 @@ export default async () => {
     logger.debug(`HomeDir: ${homeDir}`);
     logger.debug(`TmpDir: ${tmpDir}`);
 
-    const dependencies = (await NrfutilDeviceLib.getModuleVersion())
-        .dependencies;
-    const jlinkVersion = resolveModuleVersion('JlinkARM', dependencies);
-
-    if (jlinkVersion) {
-        const result = getExpectedVersion(jlinkVersion);
-        if (!result.isExpectedVersion) {
-            logger.warn(
-                `Installed JLink version does not match the expected version (${result.expectedVersion})`
-            );
-        }
-    } else {
-        logger.warn(
-            `JLink is not installed. Please install JLink from: https://www.segger.com/downloads/jlink`
-        );
-    }
-
     if (!udevInstalled()) {
         logger.warn(
             'Required component nrf-udev is not detected. Install it from https://github.com/NordicSemiconductor/nrf-udev and restart the application'