@ac-codeprod/n8n-nodes-alexa-remote 0.2.3

package/dist/nodes/AlexaRemote/lib/alexa-remote-ext.js

@@ -0,0 +1,667 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlexaRemoteExt = void 0;
+exports.createAlexaFromCredentials = createAlexaFromCredentials;
+const alexa_remote2_1 = __importDefault(require("alexa-remote2"));
+const alexa_cookie2_1 = __importDefault(require("alexa-cookie2"));
+const node_events_1 = require("node:events");
+const cookie_crypto_1 = require("./cookie-crypto");
+const helpers_1 = require("./helpers");
+class AlexaRemoteExt extends node_events_1.EventEmitter {
+    constructor() {
+        super();
+        this.initialized = false;
+        this.alexa = new alexa_remote2_1.default();
+        for (const evt of [
+            'ws-device-activity',
+            'ws-volume-change',
+            'ws-bluetooth-state-change',
+            'ws-device-connection-change',
+            'ws-notification-change',
+            'ws-todo-change',
+            'ws-audio-player-state-change',
+            'ws-media-change',
+            'ws-unknown-message',
+        ]) {
+            this.alexa.on(evt, (payload) => {
+                const event = payload;
+                this.emit(evt, event);
+                this.emit('ws-message', { ...event, eventType: evt });
+            });
+        }
+        this.alexa.on('cookie', (...args) => {
+            this.emit('cookie', ...args);
+        });
+    }
+    async init(options) {
+        return new Promise((resolve, reject) => {
+            this.alexa.init(options, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    this.initialized = true;
+                    resolve();
+                }
+            });
+        });
+    }
+    startProxyAuth(options, loginTimeoutMs, onProxyReady) {
+        let timerHandle;
+        let proxyCallbackFired = false;
+        return new Promise((resolve, reject) => {
+            timerHandle = setTimeout(() => {
+                JSON.parse = _origParse;
+                try {
+                    alexa_cookie2_1.default.stopProxyServer();
+                }
+                catch { }
+                reject(new Error(`Authentication timeout after ${loginTimeoutMs / 60000} minutes.`));
+            }, loginTimeoutMs);
+            const config = {
+                proxyOnly: true,
+                setupProxy: true,
+                proxyOwnIp: options.proxyOwnIp,
+                proxyPort: options.proxyPort,
+                proxyListenBind: '0.0.0.0',
+                alexaServiceHost: 'layla.amazon.fr',
+                amazonPage: 'amazon.fr',
+                acceptLanguage: 'fr-FR',
+                proxyLogLevel: 'info',
+            };
+            const _origParse = JSON.parse;
+            JSON.parse = function (text) {
+                if (text === '' || text == null || (typeof text === 'string' && text.trim() === '')) {
+                    return {};
+                }
+                return _origParse.call(this, text);
+            };
+            alexa_cookie2_1.default.generateAlexaCookie(undefined, undefined, config, (err, result) => {
+                if (err) {
+                    if (!proxyCallbackFired) {
+                        proxyCallbackFired = true;
+                        const match = /http:\/\/[^\s)]+/.exec(err.message);
+                        onProxyReady(match ? match[0] : `http://${options.proxyOwnIp}:${options.proxyPort}/`);
+                        return;
+                    }
+                    clearTimeout(timerHandle);
+                    try {
+                        alexa_cookie2_1.default.stopProxyServer();
+                    }
+                    catch { }
+                    JSON.parse = _origParse;
+                    reject(err);
+                    return;
+                }
+                const r = result;
+                const hasCookie = r.cookie || r.loginCookie;
+                if (hasCookie) {
+                    clearTimeout(timerHandle);
+                    try {
+                        alexa_cookie2_1.default.stopProxyServer();
+                    }
+                    catch { }
+                    JSON.parse = _origParse;
+                    resolve(r);
+                }
+            });
+        });
+    }
+    assertInit() {
+        if (!this.initialized) {
+            throw new Error('AlexaRemoteExt not initialized — call init() first');
+        }
+    }
+    async getDevices() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getDevices((error, result) => {
+                var _a;
+                if (error)
+                    reject(error);
+                else
+                    resolve(((_a = result === null || result === void 0 ? void 0 : result.devices) !== null && _a !== void 0 ? _a : result));
+            });
+        });
+    }
+    async getDeviceInfo(serialNumber) {
+        const devices = await this.getDevices();
+        return devices.find((d) => d.serialNumber === serialNumber);
+    }
+    async sendCommand(device, command, value = null) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.sendCommand(device, command, value, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async setDoNotDisturb(device, enabled) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.setDoNotDisturb(device, enabled, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getAutomationRoutines() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getAutomationRoutines((error, result) => {
+                if (error)
+                    reject(error);
+                else if (Array.isArray(result))
+                    resolve(result);
+                else if (result === null || result === void 0 ? void 0 : result.automations)
+                    resolve(result.automations);
+                else if (result && typeof result === 'object')
+                    resolve(Object.values(result));
+                else
+                    resolve([]);
+            });
+        });
+    }
+    async executeRoutine(routineIdOrUtterance) {
+        this.assertInit();
+        const routines = await this.getAutomationRoutines();
+        const routine = routines.find((r) => {
+            var _a;
+            return r.automationId === routineIdOrUtterance ||
+                ((_a = r.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === routineIdOrUtterance.toLowerCase();
+        });
+        if (!routine) {
+            throw new Error(`Routine not found: "${routineIdOrUtterance}". Use Get Routines to list available routines.`);
+        }
+        return new Promise((resolve, reject) => {
+            var _a, _b;
+            const serialNumbers = (_a = this.alexa.serialNumbers) !== null && _a !== void 0 ? _a : {};
+            const serial = (_b = Object.keys(serialNumbers)[0]) !== null && _b !== void 0 ? _b : null;
+            this.alexa.executeAutomationRoutine(serial, routine, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async sendSequenceCommand(sequence) {
+        var _a, _b, _c;
+        this.assertInit();
+        const serial = (_a = this._extractDeviceSerialFromSequence(sequence)) !== null && _a !== void 0 ? _a : this._getFirstDeviceSerial();
+        const serialNumbers = (_b = this.alexa.serialNumbers) !== null && _b !== void 0 ? _b : {};
+        let devOrSerial = (_c = (serial && serialNumbers[serial])) !== null && _c !== void 0 ? _c : serial;
+        if (!devOrSerial) {
+            await new Promise((res) => this.alexa.initDeviceState(res));
+            devOrSerial = this._getFirstDeviceSerial();
+        }
+        if (!devOrSerial) {
+            throw new Error('No Alexa device found. Ensure your devices are online and your Alexa account is properly initialized.');
+        }
+        return new Promise((resolve, reject) => {
+            this.alexa.sendSequenceCommand(devOrSerial, sequence, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async sendSequenceCommandStr(device, command, value = null) {
+        var _a, _b;
+        this.assertInit();
+        const serialNumbers = (_a = this.alexa.serialNumbers) !== null && _a !== void 0 ? _a : {};
+        const devOrSerial = (_b = (device && serialNumbers[device])) !== null && _b !== void 0 ? _b : device;
+        if (!devOrSerial) {
+            throw new Error(`Device "${device}" not found in your Alexa account.`);
+        }
+        return new Promise((resolve, reject) => {
+            this.alexa.sendSequenceCommand(devOrSerial, command, value, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    _extractDeviceSerialFromSequence(seq) {
+        var _a, _b, _c, _d, _e, _f;
+        const node = ((_a = seq.startNode) !== null && _a !== void 0 ? _a : null);
+        if (!node)
+            return null;
+        if ((_b = node.operationPayload) === null || _b === void 0 ? void 0 : _b.deviceSerialNumber) {
+            const s = (_c = node.operationPayload) === null || _c === void 0 ? void 0 : _c.deviceSerialNumber;
+            if (s && s !== 'ALEXA_CURRENT_DSN')
+                return s;
+        }
+        const first = (_d = node.nodesToExecute) === null || _d === void 0 ? void 0 : _d[0];
+        if ((_e = first === null || first === void 0 ? void 0 : first.operationPayload) === null || _e === void 0 ? void 0 : _e.deviceSerialNumber) {
+            const s = (_f = first.operationPayload) === null || _f === void 0 ? void 0 : _f.deviceSerialNumber;
+            if (s && s !== 'ALEXA_CURRENT_DSN')
+                return s;
+        }
+        return null;
+    }
+    _getFirstDeviceSerial() {
+        var _a;
+        const serials = Object.keys((_a = this.alexa.serialNumbers) !== null && _a !== void 0 ? _a : {});
+        return serials[0];
+    }
+    async speak(device, text, locale, type = 'regular') {
+        if (type === 'announcement') {
+            return this.sendAnnouncement([device], text, locale);
+        }
+        const sequence = (0, helpers_1.buildSingleSequence)((0, helpers_1.buildSpeakNode)(device, text, locale));
+        return this.sendSequenceCommand(sequence);
+    }
+    async setVolume(device, volume) {
+        this.assertInit();
+        await this.sendCommand(device, 'volume', String(volume));
+        return { success: true, device, volume };
+    }
+    async playMusic(device, provider, search) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.playMusicProvider(device, provider, search, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async sendAnnouncement(devices, text, locale) {
+        var _a;
+        this.assertInit();
+        const targetDevices = devices.map((serial) => {
+            const dev = this.alexa.find(serial);
+            if (!dev)
+                throw new Error(`Unknown device serial: "${serial}"`);
+            return { deviceSerialNumber: dev.serialNumber, deviceTypeId: dev.deviceType };
+        });
+        const firstDev = this.alexa.find(devices[0]);
+        const customerId = (_a = firstDev === null || firstDev === void 0 ? void 0 : firstDev.deviceOwnerCustomerId) !== null && _a !== void 0 ? _a : 'ALEXA_CUSTOMER_ID';
+        const sequence = {
+            '@type': 'com.amazon.alexa.behaviors.model.Sequence',
+            startNode: {
+                '@type': 'com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode',
+                type: 'AlexaAnnouncement',
+                operationPayload: {
+                    expireAfter: 'PT5S',
+                    content: [
+                        {
+                            locale,
+                            display: { title: '', body: text },
+                            speak: { type: 'text', value: text },
+                        },
+                    ],
+                    target: {
+                        customerId,
+                        devices: targetDevices,
+                    },
+                },
+            },
+        };
+        return new Promise((resolve, reject) => {
+            this.alexa.sendSequenceCommand(devices[0], sequence, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getSmarthomeDevices() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getSmarthomeDevicesV2((error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve((Array.isArray(result) ? result : []));
+            });
+        });
+    }
+    async controlSmarthomeDevice(entity, action, value) {
+        this.assertInit();
+        const parameters = { action };
+        if (value !== undefined && value !== null && value !== '') {
+            parameters.value = value;
+        }
+        return new Promise((resolve, reject) => {
+            this.alexa.executeSmarthomeDeviceAction(entity, parameters, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getNotifications() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getNotifications((error, result) => {
+                var _a;
+                if (error)
+                    reject(error);
+                else
+                    resolve(((_a = result === null || result === void 0 ? void 0 : result.notifications) !== null && _a !== void 0 ? _a : result));
+            });
+        });
+    }
+    async createNotification(device, type, label, alarmTime) {
+        this.assertInit();
+        const date = new Date(alarmTime);
+        if (isNaN(date.getTime())) {
+            throw new Error(`Invalid date format: "${alarmTime}". Use ISO 8601 (e.g. 2026-03-21T17:05:00)`);
+        }
+        const notification = this.alexa.createNotificationObject(device, type, label, date, 'ON', null, null);
+        if (!notification) {
+            throw new Error(`Device "${device}" not found. Ensure the device is online and your Alexa account is initialized.`);
+        }
+        return new Promise((resolve, reject) => {
+            this.alexa.createNotification(notification, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async deleteNotification(notificationId) {
+        this.assertInit();
+        const notifications = await this.getNotifications();
+        const notification = notifications.find((n) => n.id === notificationId);
+        if (!notification) {
+            throw new Error(`Notification "${notificationId}" not found.`);
+        }
+        return new Promise((resolve, reject) => {
+            this.alexa.deleteNotification(notification, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async createList(name) {
+        var _a, _b;
+        this.assertInit();
+        const amazonPage = (_b = (_a = this.alexa._options) === null || _a === void 0 ? void 0 : _a.amazonPage) !== null && _b !== void 0 ? _b : 'amazon.com';
+        return new Promise((resolve, reject) => {
+            this.alexa.httpsGet(`https://www.${amazonPage}/alexashoppinglists/api/v2/lists`, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            }, { method: 'POST', data: JSON.stringify({ listName: name, listType: 'CUSTOM' }) });
+        });
+    }
+    async deleteList(listId, version) {
+        var _a, _b;
+        this.assertInit();
+        const amazonPage = (_b = (_a = this.alexa._options) === null || _a === void 0 ? void 0 : _a.amazonPage) !== null && _b !== void 0 ? _b : 'amazon.com';
+        return new Promise((resolve, reject) => {
+            this.alexa.httpsGet(`https://www.${amazonPage}/alexashoppinglists/api/v2/lists/${listId}?version=${version}`, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            }, { method: 'DELETE' });
+        });
+    }
+    async getLists() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getListsV2((error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async addListItem(listType, text) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.addListItem(listType, text, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getListItems(listId) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getListItems(listId, {}, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async removeListItem(listId, itemId, version) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.deleteListItem(listId, itemId, { version }, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getAccount() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getAccount((error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getContacts() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getContacts((error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getMusicProviders() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getMusicProviders((error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getBluetooth(cached = true) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getBluetooth(cached, (error, result) => {
+                var _a;
+                if (error)
+                    reject(error);
+                else
+                    resolve(((_a = result === null || result === void 0 ? void 0 : result.bluetoothStates) !== null && _a !== void 0 ? _a : result));
+            });
+        });
+    }
+    async connectBluetooth(device, mac) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.connectBluetooth(device, mac, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async disconnectBluetooth(device) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.disconnectBluetooth(device, '', (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async unpairBluetooth(device, mac) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.unpaireBluetooth(device, mac, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getPlayerInfo(device) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getPlayerInfo(device, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getPlayerQueue(device, size = 50) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getPlayerQueue(device, size, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    async getConversations(options = {}) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getConversations(options, (error, result) => {
+                var _a;
+                if (error)
+                    reject(error);
+                else
+                    resolve(((_a = result === null || result === void 0 ? void 0 : result.conversations) !== null && _a !== void 0 ? _a : result));
+            });
+        });
+    }
+    async sendTextMessage(conversationId, text) {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.sendTextMessage(conversationId, text, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    getInternalCookieData() {
+        const opts = this.alexa._options;
+        if (opts === null || opts === void 0 ? void 0 : opts.formerRegistrationData)
+            return opts.formerRegistrationData;
+        if (opts === null || opts === void 0 ? void 0 : opts.cookie)
+            return opts.cookie;
+        return null;
+    }
+    async getMultiRoomGroups() {
+        this.assertInit();
+        return new Promise((resolve, reject) => {
+            this.alexa.getWholeHomeAudioGroups((error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve((result !== null && result !== void 0 ? result : []));
+            });
+        });
+    }
+    onPushEvent(eventType, handler) {
+        return this.on(eventType, handler);
+    }
+    offPushEvent(eventType, handler) {
+        return this.off(eventType, handler);
+    }
+    disconnect() {
+        var _a, _b;
+        try {
+            (_b = (_a = this.alexa).stop) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
+        catch { }
+        this.removeAllListeners();
+    }
+}
+exports.AlexaRemoteExt = AlexaRemoteExt;
+async function createAlexaFromCredentials(credentials, useWsMqtt = false) {
+    var _a;
+    const alexa = new AlexaRemoteExt();
+    const refreshIntervalDays = typeof credentials.refreshInterval === 'number' ? credentials.refreshInterval : 3;
+    const cookieRefreshIntervalMs = refreshIntervalDays > 0 ? refreshIntervalDays * 24 * 60 * 60 * 1000 : 0;
+    const initOptions = {
+        alexaServiceHost: credentials.alexaServiceHost,
+        amazonPage: credentials.amazonPage,
+        acceptLanguage: credentials.acceptLanguage,
+        useWsMqtt,
+        cookieRefreshInterval: cookieRefreshIntervalMs,
+    };
+    const cookiePath = credentials.cookieFile;
+    const raw = (0, cookie_crypto_1.readCookieFile)(cookiePath);
+    let cookieData;
+    try {
+        cookieData = JSON.parse(raw);
+    }
+    catch {
+        cookieData = raw;
+    }
+    initOptions.cookie = typeof cookieData === 'string' ? cookieData : ((_a = cookieData === null || cookieData === void 0 ? void 0 : cookieData.cookie) !== null && _a !== void 0 ? _a : cookieData);
+    await alexa.init(initOptions);
+    if (cookiePath) {
+        const freshData = alexa.getInternalCookieData();
+        if (freshData) {
+            try {
+                (0, cookie_crypto_1.writeCookieFile)(cookiePath, JSON.stringify(freshData, null, 2));
+            }
+            catch { }
+        }
+        const savedCookiePath = cookiePath;
+        alexa.on('cookie', () => {
+            const updatedData = alexa.getInternalCookieData();
+            if (updatedData) {
+                try {
+                    (0, cookie_crypto_1.writeCookieFile)(savedCookiePath, JSON.stringify(updatedData, null, 2));
+                }
+                catch { }
+            }
+        });
+    }
+    return alexa;
+}
+//# sourceMappingURL=alexa-remote-ext.js.map