@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/cjs/methods/ESPDevice/StartAssistedClaiming.js

@@ -0,0 +1,260 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+var provision = require('../../types/provision.js');
+var constants = require('../../utils/constants.js');
+var ESPClaimError = require('../../utils/error/ESPClaimError.js');
+var ClaimingHelper = require('../../services/ESPRMNeoHelpers/ClaimingHelper.js');
+var esp_rmaker_claim = require('../../proto/esp_rmaker_claim.js');
+var TransformEncoding = require('../../services/ESPRMNeoHelpers/TransformEncoding.js');
+var logger$1 = require('../../utils/logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("StartAssistedClaiming");
+function reportProgress(onProgress, status, message, error) {
+    onProgress?.({ status, message, ...(error !== undefined ? { error } : {}) });
+}
+/** Correlation id so a single claim attempt can be stitched together in logs. */
+function buildClaimId(deviceName) {
+    return `${deviceName}-${Date.now()}`;
+}
+/** Parses a device payload as JSON, or null when it is not a JSON object. */
+function parseDevicePayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object"
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Reads the first of `keys` present in `payload` as a non-empty string. */
+function readFirstString(payload, keys) {
+    if (!payload) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = payload[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Reads the device's claim-start payload. The MAC is returned separately because
+ * the claiming service keys its reservation on it; the payload is returned whole
+ * so every field the firmware sent is forwarded rather than cherry-picked.
+ */
+function readDeviceStartPayload(deviceInfo, claimId) {
+    const payload = parseDevicePayload(deviceInfo);
+    const macAddress = readFirstString(payload, constants.CLAIM_DEVICE_MAC_KEYS);
+    if (!macAddress) {
+        logger.error("no MAC in device claim start response", {
+            claimId,
+            payloadKeys: payload ? Object.keys(payload) : null,
+        });
+        throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.DEVICE_MAC_UNAVAILABLE);
+    }
+    return { macAddress, payload: payload ?? {} };
+}
+/**
+ * Reads the device's claim payload for verify, accepting either a JSON wrapper
+ * or a bare PEM block. Returned whole: the firmware sends request flags of its
+ * own alongside the CSR, and extracting only `csr` would drop them.
+ */
+function readDeviceCsrPayload(csrData, claimId) {
+    const parsed = parseDevicePayload(csrData);
+    const payload = parsed ?? { csr: csrData.trim() };
+    const csr = readFirstString(payload, constants.CLAIM_DEVICE_CSR_KEYS);
+    if (!csr) {
+        logger.error("no CSR in device claim payload", {
+            claimId,
+            payloadKeys: Object.keys(payload),
+        });
+        throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CSR_RETRIEVAL_FAILED);
+    }
+    // `csr` is set explicitly so a spelling variant still satisfies the contract,
+    // while every other field the firmware sent is preserved.
+    return { ...payload, csr };
+}
+/** Step 1 — ask the device to start claiming and return its device-info payload. */
+async function requestDeviceInfo(device, claimId) {
+    const request = esp_rmaker_claim.ClaimingProtoHelper.createClaimStartRequest();
+    const response = await device.sendData(constants.Endpoint.RM_CLAIM, TransformEncoding.uint8ArrayToBase64(request));
+    const parsed = esp_rmaker_claim.ClaimingProtoHelper.parseClaimResponse(TransformEncoding.base64ToUint8Array(response));
+    if (!esp_rmaker_claim.ClaimingProtoHelper.isSuccess(parsed)) {
+        logger.error("ClaimStart rejected by device", {
+            claimId,
+            status: esp_rmaker_claim.ClaimingProtoHelper.getStatus(parsed),
+        });
+        throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CLAIM_START_FAILED);
+    }
+    const deviceInfo = esp_rmaker_claim.ClaimingProtoHelper.extractPayloadString(parsed);
+    if (!deviceInfo) {
+        logger.error("ClaimStart returned empty device info", { claimId });
+        throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CLAIM_START_FAILED);
+    }
+    return deviceInfo;
+}
+/**
+ * Steps 3–4 — push the cloud init payload and reassemble the chunked CSR.
+ *
+ * The device owns `totalLen`; an empty ClaimInit means "send the next chunk".
+ * Bounded by {@link CLAIM_CSR_MAX_CHUNKS} and a no-progress check so firmware
+ * that reports Success without advancing cannot spin forever.
+ */
+async function retrieveCsr(device, cloudInitResponse, claimId) {
+    const initRequest = esp_rmaker_claim.ClaimingProtoHelper.createClaimInitRequest(cloudInitResponse);
+    let currentResponse = await device.sendData(constants.Endpoint.RM_CLAIM, TransformEncoding.uint8ArrayToBase64(initRequest));
+    let csrData = "";
+    let deviceChunkSize = 0;
+    let iterations = 0;
+    for (;;) {
+        iterations += 1;
+        if (iterations > constants.CLAIM_CSR_MAX_CHUNKS) {
+            logger.error("CSR retrieval exceeded chunk budget", {
+                claimId,
+                iterations,
+                received: csrData.length,
+            });
+            throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CSR_STALLED);
+        }
+        const parsed = esp_rmaker_claim.ClaimingProtoHelper.parseClaimResponse(TransformEncoding.base64ToUint8Array(currentResponse));
+        if (!esp_rmaker_claim.ClaimingProtoHelper.isSuccess(parsed)) {
+            logger.error("device rejected CSR request", {
+                claimId,
+                iterations,
+                status: esp_rmaker_claim.ClaimingProtoHelper.getStatus(parsed),
+            });
+            throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CSR_RETRIEVAL_FAILED);
+        }
+        const chunk = esp_rmaker_claim.ClaimingProtoHelper.extractPayloadString(parsed);
+        const offset = esp_rmaker_claim.ClaimingProtoHelper.getOffset(parsed);
+        const totalLen = esp_rmaker_claim.ClaimingProtoHelper.getTotalLen(parsed);
+        if (offset === 0) {
+            csrData = chunk;
+            deviceChunkSize = chunk.length;
+        }
+        else {
+            csrData += chunk;
+        }
+        // `totalLen` 0 with a non-empty chunk is the legitimate single-fragment case,
+        // so completion is checked first and an actually-empty CSR is rejected rather
+        // than POSTed to the cloud.
+        if (csrData.length >= totalLen) {
+            if (!csrData) {
+                logger.error("device reported CSR complete but sent no data", {
+                    claimId,
+                    totalLen,
+                });
+                throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CSR_RETRIEVAL_FAILED);
+            }
+            return { csrData, deviceChunkSize };
+        }
+        // No forward progress means the device will never complete the transfer.
+        if (!chunk.length) {
+            logger.error("device returned an empty CSR chunk before completion", {
+                claimId,
+                accumulated: csrData.length,
+                totalLen,
+            });
+            throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CSR_STALLED);
+        }
+        currentResponse = await device.sendData(constants.Endpoint.RM_CLAIM, TransformEncoding.uint8ArrayToBase64(esp_rmaker_claim.ClaimingProtoHelper.createClaimInitContinueRequest()));
+    }
+}
+/** Step 6 — stream the certificate response back to the device in fragments. */
+async function sendCertificate(device, certificateData, deviceChunkSize, claimId) {
+    if (!certificateData) {
+        logger.error("no certificate data to send", { claimId });
+        throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CERTIFICATE_SEND_FAILED);
+    }
+    // 200 bytes is the protocol's fragment ceiling, not a hint: the device answers
+    // an oversized fragment with NoMemory. A smaller device fragment size wins.
+    const chunkSize = deviceChunkSize > 0
+        ? Math.min(deviceChunkSize, constants.CLAIM_MAX_FRAGMENT_SIZE)
+        : constants.CLAIM_MAX_FRAGMENT_SIZE;
+    for (let offset = 0; offset < certificateData.length; offset += chunkSize) {
+        const request = esp_rmaker_claim.ClaimingProtoHelper.createClaimVerifyRequest(certificateData, offset, chunkSize);
+        const response = await device.sendData(constants.Endpoint.RM_CLAIM, TransformEncoding.uint8ArrayToBase64(request));
+        const parsed = esp_rmaker_claim.ClaimingProtoHelper.parseClaimResponse(TransformEncoding.base64ToUint8Array(response));
+        if (!esp_rmaker_claim.ClaimingProtoHelper.isSuccess(parsed)) {
+            // The device validates the reassembled payload only on the final fragment,
+            // so a rejection here can mean the payload was bad rather than the transfer.
+            logger.error("device rejected certificate fragment", {
+                claimId,
+                status: esp_rmaker_claim.ClaimingProtoHelper.getStatus(parsed),
+                offset,
+                chunkSize,
+                totalBytes: certificateData.length,
+            });
+            throw new ESPClaimError.ESPClaimError(constants.ClaimErrorCodes.CERTIFICATE_SEND_FAILED);
+        }
+    }
+}
+/** Best-effort abort so the device does not stay parked in a claiming session. */
+async function abortClaiming(device, claimId) {
+    try {
+        await device.sendData(constants.Endpoint.RM_CLAIM, TransformEncoding.uint8ArrayToBase64(esp_rmaker_claim.ClaimingProtoHelper.createClaimAbortRequest()));
+    }
+    catch (error) {
+        logger.warn("claim abort failed", {
+            claimId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+ESPDevice.ESPDevice.prototype.startAssistedClaiming = async function (onProgress, claimCapability) {
+    const claimId = buildClaimId(this.name);
+    const startedAt = Date.now();
+    try {
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CLAIM_STARTING);
+        const deviceInfo = await requestDeviceInfo(this, claimId);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.DEVICE_INFO_RECEIVED);
+        // Reserve a node ID for this device's MAC. Idempotent, so a retry or a
+        // factory-erased device resolves to the same node.
+        const { macAddress, payload: startPayload } = readDeviceStartPayload(deviceInfo, claimId);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CLAIM_INIT_API);
+        const initiateResponse = await ClaimingHelper.ClaimingHelper.initiateClaim(macAddress, startPayload, claimId);
+        // Forwarded whole; the device reads `node_id` from it.
+        const cloudInitResponse = JSON.stringify(initiateResponse);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CSR_RETRIEVING);
+        const { csrData, deviceChunkSize } = await retrieveCsr(this, cloudInitResponse, claimId);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CSR_RECEIVED);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CLAIM_VERIFY_API);
+        const verifyResponse = await ClaimingHelper.ClaimingHelper.verifyClaim(macAddress, readDeviceCsrPayload(csrData, claimId), claimCapability, claimId);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CERTIFICATE_RECEIVED);
+        // Forwarded whole, so the device also gets `mqtt_host` and `ca_certificate`
+        // alongside its leaf certificate.
+        const certificateData = JSON.stringify(verifyResponse);
+        reportProgress(onProgress, provision.ESPClaimStatus.inProgress, constants.ClaimProgressMessages.CERTIFICATE_SENDING);
+        await sendCertificate(this, certificateData, deviceChunkSize, claimId);
+        logger.info("assisted claiming succeeded", {
+            claimId,
+            nodeId: verifyResponse.node_id,
+            mqttHost: verifyResponse.mqtt_host,
+            elapsedMs: Date.now() - startedAt,
+        });
+        reportProgress(onProgress, provision.ESPClaimStatus.success, constants.ClaimProgressMessages.CLAIM_SUCCESS);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error("assisted claiming failed", {
+            claimId,
+            code: error instanceof ESPClaimError.ESPClaimError ? error.code : undefined,
+            elapsedMs: Date.now() - startedAt,
+            error: message,
+        });
+        await abortClaiming(this, claimId);
+        reportProgress(onProgress, provision.ESPClaimStatus.failed, constants.ClaimProgressMessages.CLAIM_FAILED, message);
+        throw error;
+    }
+};
+//# sourceMappingURL=StartAssistedClaiming.js.map

package/dist/cjs/methods/ESPDevice/StartAssistedClaiming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StartAssistedClaiming.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPDevice/VerifyUserNodeMapping.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var ESPDevice = require('../../ESPDevice.js');
+var NodeMappingHelper = require('../../services/ESPRMNeoHelpers/NodeMappingHelper.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPDevice.ESPDevice.prototype.verifyUserNodeMapping = async function (groupId, requestId, requestBody = {}) {
+    return NodeMappingHelper.NodeMappingHelper.verifyUserNodeMapping(groupId, requestId, requestBody);
+};
+//# sourceMappingURL=VerifyUserNodeMapping.js.map

package/dist/cjs/methods/ESPDevice/VerifyUserNodeMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VerifyUserNodeMapping.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/ChangePassword.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var constants = require('../../utils/constants.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var ESPRMNeoAPIManager = require('../../services/ESPRMNeoAPIManager.js');
+var ESPRMNeoStorage = require('../../services/ESPRMNeoStorage/ESPRMNeoStorage.js');
+var logger$1 = require('../../utils/logger.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("ChangePassword");
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.changePassword = async function (oldPassword, newPassword) {
+    try {
+        const accessToken = await ESPRMNeoStorage.ESPRMNeoStorage.getItem(constants.StorageKeys.ACCESSTOKEN);
+        if (!accessToken) {
+            throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.NOT_LOGGED_IN, errorMessages.authErrorMessages.NOT_LOGGED_IN);
+        }
+        const api = ESPRMNeoAPIManager.ESPRMNeoAPIManager.getInstance();
+        logger.debug(`changePassword → POST ${constants.APIPathV1.USER_AUTH_PASSWORD} (Cognito Bearer)`);
+        const requestBody = {
+            access_token: accessToken,
+            old_password: oldPassword,
+            new_password: newPassword,
+        };
+        const apiResponse = await api.postUserApiWithBearer(constants.APIPathV1.USER_AUTH_PASSWORD, requestBody, accessToken);
+        return normalizeApiResponse.normalizeApiResponse(apiResponse, {
+            message: constants.AuthSuccessMessages.PASSWORD_CHANGED,
+        });
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError.ESPAuthError)
+            throw err;
+        const message = err instanceof Error
+            ? err.message
+            : errorMessages.authErrorMessages.CHANGE_PASSWORD_FAILED;
+        logger.debug("changePassword → Error:", message);
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.CHANGE_PASSWORD_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=ChangePassword.js.map

package/dist/cjs/methods/ESPRMNeoAuth/ChangePassword.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChangePassword.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/ConfirmSignUp.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var constants = require('../../utils/constants.js');
+var ESPRMNeoAPIManager = require('../../services/ESPRMNeoAPIManager.js');
+var logger$1 = require('../../utils/logger.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var authUtils = require('../../utils/authUtils.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("ConfirmSignUp");
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.confirmSignUp = async function (username, verificationCode) {
+    try {
+        const requestBody = {
+            code: verificationCode,
+            ...authUtils.signupIdentityFromUsername(username),
+        };
+        const api = ESPRMNeoAPIManager.ESPRMNeoAPIManager.getInstance();
+        logger.debug(`confirmSignUp → POST ${constants.APIPathV1.USER_AUTH_SIGNUP_VERIFY}`);
+        const apiResponse = await api.postUserApi(constants.APIPathV1.USER_AUTH_SIGNUP_VERIFY, requestBody);
+        return normalizeApiResponse.normalizeApiResponse(apiResponse, {
+            message: constants.AuthSuccessMessages.USER_CONFIRMED,
+        });
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError.ESPAuthError)
+            throw err;
+        const message = err instanceof Error
+            ? err.message
+            : errorMessages.authErrorMessages.CONFIRM_SIGNUP_FAILED;
+        logger.debug("confirmSignUp → Error:", message);
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.CONFIRM_SIGNUP_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=ConfirmSignUp.js.map

package/dist/cjs/methods/ESPRMNeoAuth/ConfirmSignUp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmSignUp.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/ForgotPassword.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var constants = require('../../utils/constants.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var ESPRMNeoAPIManager = require('../../services/ESPRMNeoAPIManager.js');
+var logger$1 = require('../../utils/logger.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("ForgotPassword");
+function toForgotPasswordResponse(apiResponse) {
+    return {
+        message: apiResponse?.message,
+    };
+}
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.forgotPassword = async function (username) {
+    try {
+        const requestBody = { username };
+        const api = ESPRMNeoAPIManager.ESPRMNeoAPIManager.getInstance();
+        logger.debug(`forgotPassword → POST ${constants.APIPathV1.USER_AUTH_PASSWORD_RECOVERY}`);
+        const apiResponse = await api.postUserApi(constants.APIPathV1.USER_AUTH_PASSWORD_RECOVERY, requestBody);
+        return toForgotPasswordResponse(apiResponse);
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError.ESPAuthError)
+            throw err;
+        const message = err instanceof Error
+            ? err.message
+            : errorMessages.authErrorMessages.FORGOT_PASSWORD_FAILED;
+        logger.debug("forgotPassword → Error:", message);
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.FORGOT_PASSWORD_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=ForgotPassword.js.map

package/dist/cjs/methods/ESPRMNeoAuth/ForgotPassword.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgotPassword.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/GetLoggedInUser.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var ESPRMNeoUser = require('../../ESPRMNeoUser.js');
+var ESPRMNeoStorage = require('../../services/ESPRMNeoStorage/ESPRMNeoStorage.js');
+var CheckTokenExpiry = require('../../services/ESPRMNeoHelpers/CheckTokenExpiry.js');
+var constants = require('../../utils/constants.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var logger$1 = require('../../utils/logger.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("GetLoggedInUser");
+/**
+ * Loads access, id, and refresh tokens from storage in one round-trip.
+ * @returns Tokens if all three exist, otherwise null.
+ */
+async function getStoredTokens() {
+    const [accessToken, idToken, refreshToken] = await Promise.all([
+        ESPRMNeoStorage.ESPRMNeoStorage.getItem(constants.StorageKeys.ACCESSTOKEN),
+        ESPRMNeoStorage.ESPRMNeoStorage.getItem(constants.StorageKeys.IDTOKEN),
+        ESPRMNeoStorage.ESPRMNeoStorage.getItem(constants.StorageKeys.REFRESHTOKEN),
+    ]);
+    if (!accessToken || !idToken || !refreshToken)
+        return null;
+    return { accessToken, idToken, refreshToken };
+}
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.getLoggedInUser =
+    async function () {
+        try {
+            let tokens = await getStoredTokens();
+            if (!tokens)
+                return null;
+            if (CheckTokenExpiry.isTokenExpired(tokens.accessToken)) {
+                await ESPRMNeoUser.ESPRMNeoUser.extendSession(tokens.refreshToken);
+                tokens = await getStoredTokens();
+                if (!tokens)
+                    return null;
+            }
+            return new ESPRMNeoUser.ESPRMNeoUser(tokens);
+        }
+        catch (err) {
+            if (err instanceof ESPAuthError.ESPAuthError)
+                throw err;
+            const message = err instanceof Error
+                ? err.message
+                : errorMessages.authErrorMessages.GET_LOGGED_IN_USER_FAILED;
+            logger.debug("getLoggedInUser → Error:", message);
+            throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.GET_LOGGED_IN_USER_FAILED, message, err);
+        }
+    };
+//# sourceMappingURL=GetLoggedInUser.js.map

package/dist/cjs/methods/ESPRMNeoAuth/GetLoggedInUser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetLoggedInUser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/Login.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var ESPRMNeoUser = require('../../ESPRMNeoUser.js');
+var ESPRMNeoAPIManager = require('../../services/ESPRMNeoAPIManager.js');
+var logger$1 = require('../../utils/logger.js');
+var constants = require('../../utils/constants.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("Login");
+/**
+ * Maps a sign-in API response to SDK token fields, or throws when any token is missing.
+ */
+function toUserTokens(apiResponse) {
+    if (!apiResponse?.access_token ||
+        !apiResponse?.id_token ||
+        !apiResponse?.refresh_token) {
+        logger.debug("login → Missing required tokens in response");
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.LOGIN_FAILED_MISSING_TOKENS, errorMessages.authErrorMessages.LOGIN_FAILED_MISSING_TOKENS, apiResponse);
+    }
+    return {
+        accessToken: apiResponse.access_token,
+        idToken: apiResponse.id_token,
+        refreshToken: apiResponse.refresh_token,
+    };
+}
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.login = async function (username, password) {
+    try {
+        const api = ESPRMNeoAPIManager.ESPRMNeoAPIManager.getInstance();
+        logger.debug(`login → POST ${constants.APIPathV1.USER_AUTH_TOKEN}`);
+        const requestBody = { username, password };
+        const apiResponse = await api.postUserApi(constants.APIPathV1.USER_AUTH_TOKEN, requestBody);
+        return new ESPRMNeoUser.ESPRMNeoUser(toUserTokens(apiResponse));
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError.ESPAuthError)
+            throw err;
+        const message = err instanceof Error ? err.message : errorMessages.authErrorMessages.LOGIN_FAILED;
+        logger.debug("login → Error:", message);
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.LOGIN_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=Login.js.map

package/dist/cjs/methods/ESPRMNeoAuth/Login.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Login.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/SendSignUpCode.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var ESPRMNeoAPIManager = require('../../services/ESPRMNeoAPIManager.js');
+var logger$1 = require('../../utils/logger.js');
+var constants = require('../../utils/constants.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var authUtils = require('../../utils/authUtils.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("SendSignUpCode");
+/**
+ * Builds the signup request body from username, password, and optional attributes.
+ * Explicit `userAttributes` override the username-derived email / phone fields.
+ */
+function toSignupRequest(username, password, userAttributes) {
+    const attrs = userAttributes ?? {};
+    const identity = authUtils.signupIdentityFromUsername(username);
+    return {
+        password,
+        email: attrs.email ?? identity.email,
+        phone_number: attrs.phone_number ?? identity.phone_number,
+    };
+}
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.sendSignUpCode = async function (username, password, userAttributes) {
+    try {
+        const requestBody = toSignupRequest(username, password, userAttributes);
+        const api = ESPRMNeoAPIManager.ESPRMNeoAPIManager.getInstance();
+        logger.debug(`sendSignUpCode → POST ${constants.APIPathV1.USER_AUTH_SIGNUP}`);
+        const apiResponse = await api.postUserApi(constants.APIPathV1.USER_AUTH_SIGNUP, requestBody);
+        return normalizeApiResponse.normalizeApiResponse(apiResponse);
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError.ESPAuthError)
+            throw err;
+        const message = err instanceof Error ? err.message : errorMessages.authErrorMessages.SIGNUP_FAILED;
+        logger.debug("sendSignUpCode → Error:", message);
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.SIGNUP_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=SendSignUpCode.js.map

package/dist/cjs/methods/ESPRMNeoAuth/SendSignUpCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SendSignUpCode.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAuth/SetNewPassword.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var ESPRMNeoAuth = require('../../ESPRMNeoAuth.js');
+var ESPRMNeoAPIManager = require('../../services/ESPRMNeoAPIManager.js');
+var constants = require('../../utils/constants.js');
+var logger$1 = require('../../utils/logger.js');
+var normalizeApiResponse = require('../../utils/normalizeApiResponse.js');
+var errorMessages = require('../../utils/error/errorMessages.js');
+var ESPAuthError = require('../../utils/error/ESPAuthError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("SetNewPassword");
+ESPRMNeoAuth.ESPRMNeoAuth.prototype.setNewPassword = async function (username, newPassword, verificationCode) {
+    try {
+        const requestBody = {
+            username,
+            code: verificationCode,
+            new_password: newPassword,
+        };
+        const api = ESPRMNeoAPIManager.ESPRMNeoAPIManager.getInstance();
+        logger.debug(`setNewPassword → POST ${constants.APIPathV1.USER_AUTH_PASSWORD_RECOVERY_CONFIRMATION}`);
+        const apiResponse = await api.postUserApi(constants.APIPathV1.USER_AUTH_PASSWORD_RECOVERY_CONFIRMATION, requestBody);
+        return normalizeApiResponse.normalizeApiResponse(apiResponse, {
+            message: constants.AuthSuccessMessages.PASSWORD_RESET,
+        });
+    }
+    catch (err) {
+        if (err instanceof ESPAuthError.ESPAuthError)
+            throw err;
+        const message = err instanceof Error
+            ? err.message
+            : errorMessages.authErrorMessages.PASSWORD_RESET_FAILED;
+        logger.debug("setNewPassword → Error:", message);
+        throw new ESPAuthError.ESPAuthError(constants.AuthErrorCodes.PASSWORD_RESET_FAILED, message, err);
+    }
+};
+//# sourceMappingURL=SetNewPassword.js.map

package/dist/cjs/methods/ESPRMNeoAuth/SetNewPassword.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SetNewPassword.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/ESPRMNeoAutomation/AddAction.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var ESPRMNeoAutomation = require('../../ESPRMNeoAutomation.js');
+var constants = require('../../utils/constants.js');
+var ESPAPICallValidationError = require('../../utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ESPRMNeoAutomation.ESPRMNeoAutomation.prototype.addAction = async function (target) {
+    if (!target ||
+        !String(target.node ?? "").trim() ||
+        !String(target.path ?? "").trim()) {
+        throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.INVALID_ACTION_TARGET);
+    }
+    const nextActions = { targets: [...this.actions.targets, target] };
+    const response = await this.update({ actions: nextActions });
+    this.actions = nextActions;
+    return response;
+};
+//# sourceMappingURL=AddAction.js.map

package/dist/cjs/methods/ESPRMNeoAutomation/AddAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AddAction.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}