@nordicsemiconductor/pc-nrfconnect-shared 89.0.0 → 91.0.0

package/ipc/MetaFiles.ts

@@ -14,10 +14,13 @@ export interface SourceJson {
 export type WithdrawnJson = UrlString[];
 
 export type AppVersions = {
-    [version: string]: {
-        shasum?: string;
-        tarballUrl: UrlString;
-    };
+    [version: string]: AppVersion;
+};
+
+export type AppVersion = {
+    shasum?: string;
+    tarballUrl: UrlString;
+    nrfutilModules?: NrfutilModules;
 };
 
 export interface AppInfo {
@@ -39,9 +42,26 @@ interface ObjectContainingOptionalStrings {
     [index: string]: string | undefined;
 }
 
+interface NrfConnectForDesktop {
+    nrfutil?: NrfutilModules;
+    html?: string;
+}
+
+type SemverString = string;
+
+export type NrfutilModuleName = string;
+export type NrfutilModuleVersion = SemverString;
+
+export interface NrfutilModules {
+    [name: NrfutilModuleName]: [
+        NrfutilModuleVersion,
+        ...NrfutilModuleVersion[]
+    ];
+}
+
 export interface PackageJson {
     name: string;
-    version: string;
+    version: SemverString;
 
     // Several optional properties
     author?: string;
@@ -52,6 +72,7 @@ export interface PackageJson {
     devDependencies?: ObjectContainingOptionalStrings;
     displayName?: string;
     engines?: ObjectContainingOptionalStrings;
+    nrfConnectForDesktop?: NrfConnectForDesktop;
     files?: readonly string[];
     license?: string;
     main?: string;
@@ -61,7 +82,4 @@ export interface PackageJson {
         url: UrlString;
     };
     scripts?: ObjectContainingOptionalStrings;
-    nrfConnectForDesktop?: {
-        html?: string;
-    };
 }

package/nrfutil/device/__mocks__/device.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const program = jest.fn();
+const programBuffer = jest.fn();
+const erase = jest.fn();
+const recover = jest.fn();
+const reset = jest.fn();
+const getProtectionStatus = jest.fn();
+const setProtectionStatus = jest.fn();
+const getFwInfo = jest.fn();
+const setMcuState = jest.fn();
+const getCoreInfo = jest.fn();
+const list = jest.fn(() => ({
+    stop: jest.fn(),
+}));
+const firmwareRead = jest.fn();
+const onLogging = jest.fn();
+const setLogLevel = jest.fn();
+const setVerboseLogging = jest.fn();
+const getModuleVersion = jest.fn();
+
+export default {
+    program,
+    programBuffer,
+    erase,
+    recover,
+    reset,
+    getProtectionStatus,
+    setProtectionStatus,
+    getFwInfo,
+    setMcuState,
+    getCoreInfo,
+    list,
+    firmwareRead,
+    onLogging,
+    setLogLevel,
+    setVerboseLogging,
+    getModuleVersion,
+};

package/nrfutil/device/batch.ts

@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { TaskEnd } from '../sandboxTypes';
+import { BatchOperationWrapper, Callbacks } from './batchTypes';
+import {
+    DeviceCore,
+    getDeviceSandbox,
+    NrfutilDeviceWithSerialnumber,
+    ResetKind,
+} from './common';
+import eraseBatch from './eraseBatch';
+import firmwareReadBatch from './firmwareReadBatch';
+import { DeviceCoreInfo } from './getCoreInfo';
+import getCoreInfoBatch from './getCoreInfoBatch';
+import { FWInfo } from './getFwInfo';
+import getFwInfoBatch from './getFwInfoBatch';
+import { GetProtectionStatusResult } from './getProtectionStatus';
+import getProtectionStatusBatch from './getProtectionStatusBatch';
+import { FirmwareType, ProgrammingOptions } from './program';
+import programBatch from './programBatch';
+import recoverBatch from './recoverBatch';
+import resetBatch from './resetBatch';
+
+type BatchOperationWrapperUnknown = BatchOperationWrapper<unknown, unknown>;
+
+export class Batch {
+    private operations: BatchOperationWrapperUnknown[];
+
+    private collectOperations: {
+        callback: (completedTasks: TaskEnd<unknown>[]) => void;
+        operationId: number;
+        count: number;
+    }[] = [];
+
+    constructor(operations?: BatchOperationWrapperUnknown[]) {
+        this.operations = operations ?? [];
+    }
+
+    public erase(core: DeviceCore, callbacks?: Callbacks) {
+        this.operations.push(
+            eraseBatch(core, { callbacks }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public firmwareRead(core: DeviceCore, callbacks?: Callbacks<Buffer>) {
+        this.operations.push(
+            firmwareReadBatch(core, {
+                callbacks,
+            }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public getCoreInfo(
+        core: DeviceCore,
+        callbacks?: Callbacks<DeviceCoreInfo>
+    ) {
+        this.operations.push(
+            getCoreInfoBatch(core, {
+                callbacks,
+            }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public getFwInfo(core: DeviceCore, callbacks?: Callbacks<FWInfo>) {
+        this.operations.push(
+            getFwInfoBatch(core, {
+                callbacks,
+            }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public getProtectionStatus(
+        core: DeviceCore,
+        callbacks?: Callbacks<GetProtectionStatusResult>
+    ) {
+        this.operations.push(
+            getProtectionStatusBatch(core, {
+                callbacks,
+            }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public program(
+        firmware: FirmwareType,
+        core: DeviceCore,
+        programmingOptions?: ProgrammingOptions,
+        callbacks?: Callbacks
+    ) {
+        this.operations.push(
+            programBatch(firmware, core, {
+                programmingOptions,
+                callbacks,
+            }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public recover(core: DeviceCore, callbacks?: Callbacks) {
+        this.operations.push(
+            recoverBatch(core, { callbacks }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public reset(core: DeviceCore, reset?: ResetKind, callbacks?: Callbacks) {
+        this.operations.push(
+            resetBatch(core, {
+                reset,
+                callbacks,
+            }) as BatchOperationWrapperUnknown
+        );
+
+        return this;
+    }
+
+    public collect(
+        count: number,
+        callback: (completedTasks: TaskEnd<unknown>[]) => void
+    ) {
+        this.collectOperations.push({
+            callback,
+            operationId: this.operations.length - 1,
+            count,
+        });
+
+        return this;
+    }
+
+    public async run(
+        device: NrfutilDeviceWithSerialnumber,
+        controller?: AbortController | undefined
+    ): Promise<unknown[]> {
+        let beginId = 0;
+        let endId = 0;
+        const results: TaskEnd<unknown>[] = [];
+
+        const operations = {
+            operations: this.operations.map((operation, index) => ({
+                operationId: index.toString(),
+                ...operation.operation,
+            })),
+        };
+
+        const sandbox = await getDeviceSandbox();
+        try {
+            await sandbox.execSubcommand<unknown>(
+                'execute-batch',
+                [
+                    '--serial-number',
+                    device.serialNumber,
+                    '--batch-json',
+                    JSON.stringify(operations),
+                ],
+                (progress, task) => {
+                    if (task) {
+                        this.operations[endId].onProgress?.(progress, task);
+                    }
+                },
+                onTaskBegin => {
+                    beginId += 1;
+                    this.operations[endId].onTaskBegin?.(onTaskBegin);
+                },
+                taskEnd => {
+                    results.push(taskEnd);
+
+                    this.operations[endId].onTaskEnd?.(taskEnd);
+
+                    this.collectOperations
+                        .filter(operation => operation.operationId === endId)
+                        .forEach(operation => {
+                            operation.callback(
+                                results.slice(
+                                    results.length - operation.count,
+                                    results.length
+                                )
+                            );
+                        });
+
+                    endId += 1;
+                },
+                controller
+            );
+
+            const errors = results.filter(result => result.result === 'fail');
+            if (errors.length > 0) {
+                const error = new Error(
+                    `Batch failed: ${errors
+                        .map(e => `error: ${e.error}, message: ${e.message}`)
+                        .join('\n')}`
+                );
+                this.operations[endId].onException?.(error);
+                throw error;
+            }
+        } catch (error) {
+            if (beginId !== endId) {
+                this.operations[beginId].onException?.(error as Error);
+            }
+            throw error;
+        }
+
+        return results.map(result => result.data);
+    }
+}

package/nrfutil/device/batchTypes.ts

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { Progress, Task, TaskBegin, TaskEnd } from '../sandboxTypes';
+import { DeviceCore, ResetKind } from './common';
+import {
+    isJLinkProgrammingOptions,
+    isMcuBootProgrammingOptions,
+    isNordicDfuProgrammingOptions,
+    ProgrammingOptions,
+} from './program';
+
+export interface BatchOperationWrapper<OperationType, T = void> {
+    operation: GenericOperation<OperationType>;
+    onProgress?: (progress: Progress, task?: Task) => void;
+    onTaskBegin?: TaskBeginCallback;
+    onTaskEnd?: TaskEndCallback<T>;
+    onException?: (error: Error) => void;
+}
+
+export type Callbacks<T = void> = {
+    onTaskBegin?: TaskBeginCallback;
+    onTaskEnd?: TaskEndCallback<T>;
+    onProgress?: (progress: Progress, task?: Task) => void;
+    onException?: (error: Error) => void;
+};
+
+export type DeviceCoreBatch =
+    | 'NRFDL_DEVICE_CORE_APPLICATION'
+    | 'NRFDL_DEVICE_CORE_NETWORK'
+    | 'NRFDL_DEVICE_CORE_MODEM';
+
+export const convertDeviceCoreType = (core?: DeviceCore) => {
+    switch (core) {
+        case 'Application':
+            return 'NRFDL_DEVICE_CORE_APPLICATION';
+        case 'Network':
+            return 'NRFDL_DEVICE_CORE_NETWORK';
+        case 'Modem':
+            return 'NRFDL_DEVICE_CORE_MODEM';
+    }
+};
+
+export const convertProgrammingOptionsType = (
+    programmingOptions?: ProgrammingOptions
+) => {
+    if (!programmingOptions) {
+        return undefined;
+    }
+
+    if (isJLinkProgrammingOptions(programmingOptions)) {
+        return {
+            qspi_erase_mode: programmingOptions.chipEraseMode,
+            reset: programmingOptions.reset,
+            verify: programmingOptions.verify,
+        };
+    }
+
+    if (isMcuBootProgrammingOptions(programmingOptions)) {
+        return {
+            mcu_end_state: programmingOptions.mcuEndState,
+            net_core_upload_delay: programmingOptions.netCoreUploadDelay,
+        };
+    }
+
+    if (isNordicDfuProgrammingOptions(programmingOptions)) {
+        return {
+            mcu_end_state: programmingOptions.mcuEndState,
+        };
+    }
+};
+
+export interface ProgrammingOperation {
+    type: 'program';
+    firmware: {
+        file: string;
+    };
+    reset?: ResetKind;
+}
+
+export interface ResetOperation {
+    type: 'reset';
+    option?: ResetKind;
+}
+
+export interface RecoverOperation {
+    type: 'recover';
+}
+
+export interface ProtectionGetOperation {
+    type: 'protection-get';
+}
+
+export interface FirmwareReadOperation {
+    type: 'fw-read';
+    firmware: {
+        buffer: string;
+    };
+}
+
+export interface EraseOperation {
+    type: 'erase';
+}
+
+export interface GetCoreInfoOperation {
+    type: 'core-info';
+}
+
+export interface GetFwInfoOperation {
+    type: 'fw-info';
+}
+
+export interface GenericOperation<T> {
+    core?: DeviceCoreBatch;
+    operationId?: string;
+    operation: T;
+}
+
+export type BatchOperation =
+    | ProgrammingOperation
+    | ResetOperation
+    | RecoverOperation
+    | ProtectionGetOperation
+    | FirmwareReadOperation
+    | EraseOperation
+    | GetCoreInfoOperation
+    | GetFwInfoOperation;
+
+export type TaskEndCallback<T = void> = (end: TaskEnd<T>) => void;
+export type TaskBeginCallback = (begin: TaskBegin) => void;