alexa-cookie2 5.0.4 → 5.0.5

package/README.md

@@ -55,6 +55,9 @@ Partly based on [Amazon Alexa Remote Control](http://blog.loetzimmer.de/2017/10/
 Thank you for that work.
 
 ## Changelog:
+### 5.0.5 (2026-07-06)
+* (@Apollon77) Fix Proxy URL when no static port is provided
+
 ### 5.0.4 (2026-07-05)
 * (@fkhr79, @blabond) Fix Amazon login proxy auth flow
 

package/lib/proxy.js

@@ -72,7 +72,7 @@ function customStringify(v, func, intent) {
 
 function initAmazonProxy(_options, callbackCookie, callbackListening) {
     const initialCookies = {};
-    const proxyBase = `http://${_options.proxyOwnIp}:${_options.proxyPort}/`;
+    const proxyBase = () => `http://${_options.proxyOwnIp}:${_options.proxyPort}/`;
     const defaultAmazonHost = `www.${_options.baseAmazonPage}`;
     const amazonProxyHosts = [];
 
@@ -106,7 +106,7 @@ function initAmazonProxy(_options, callbackCookie, callbackListening) {
     function amazonHostFromProxyUrl(url) {
         if (!url) return null;
         for (const host of amazonProxyHosts) {
-            if (url === `${proxyBase}${host}` || url.startsWith(`${proxyBase}${host}/`)) {
+            if (url === `${proxyBase()}${host}` || url.startsWith(`${proxyBase()}${host}/`)) {
                 return host;
             }
         }
@@ -286,22 +286,23 @@ function initAmazonProxy(_options, callbackCookie, callbackListening) {
         data = data.replace(///g, '/');
         for (const host of amazonProxyHosts) {
             const hostRegex = new RegExp(`https?://${escapeRegex(host)}:?[0-9]*/`, 'g');
-            data = data.replace(hostRegex, `${proxyBase}${host}/`);
+            data = data.replace(hostRegex, `${proxyBase()}${host}/`);
         }
         //_options.logger && _options.logger('REPLACEHOSTS: ' + dataOrig + ' --> ' + data);
         return data;
     }
 
     function replaceHostsBack(data) {
+        const base = proxyBase();
         for (const host of amazonProxyHosts) {
-            const hostRegex = new RegExp(`${escapeRegex(proxyBase)}${escapeRegex(host)}/`, 'g');
+            const hostRegex = new RegExp(`${escapeRegex(base)}${escapeRegex(host)}/`, 'g');
             data = data.replace(hostRegex, `https://${host}/`);
         }
-        if (data === proxyBase) {
+        if (data === base) {
             data = returnedInitUrl;
         }
-        else if (data.startsWith(proxyBase)) {
-            data = `https://${defaultAmazonHost}/${data.slice(proxyBase.length)}`;
+        else if (data.startsWith(base)) {
+            data = `https://${defaultAmazonHost}/${data.slice(base.length)}`;
         }
         return data;
     }
@@ -466,7 +467,8 @@ function initAmazonProxy(_options, callbackCookie, callbackListening) {
         _options.proxyPort = undefined;
     }
     const server = app.listen(_options.proxyPort, _options.proxyListenBind, function() {
-        _options.logger && _options.logger(`Alexa-Cookie: Proxy-Server listening on port ${server.address().port}`);
+        _options.proxyPort = this.address().port;
+        _options.logger && _options.logger(`Alexa-Cookie: Proxy-Server listening on port ${_options.proxyPort}`);
         callbackListening && callbackListening(server);
         callbackListening = null;
     }).on('error', err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alexa-cookie2",
-  "version": "5.0.4",
+  "version": "5.0.5",
   "description": "Generate Cookie and CSRF for Alexa Remote",
   "author": {
     "name": "Apollon77",

package/test/proxy-random-port.test.js

@@ -0,0 +1,147 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vm = require('vm');
+
+const testName = 'proxy-random-port';
+const outputDir = process.env.ALEXA_COOKIE_TEST_OUTPUT_DIR || path.join(__dirname, '..', 'test-output');
+const outputFile = path.join(outputDir, `${testName}.txt`);
+const lines = [];
+
+function line(value = '') {
+    lines.push(value);
+}
+
+function writeOutput() {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputFile, `${lines.join('\n')}\n`);
+}
+
+function recordAssertion(description, fn) {
+    try {
+        fn();
+        line(`${description}: PASS`);
+    } catch (err) {
+        line(`${description}: FAIL`);
+        writeOutput();
+        throw err;
+    }
+}
+
+const proxyFile = path.join(__dirname, '..', 'lib', 'proxy.js');
+const source = fs.readFileSync(proxyFile, 'utf8');
+
+const ASSIGNED_PORT = 3456;
+let capturedProxyOptions;
+
+function createExpressStub() {
+    return {
+        use() {},
+        get() {},
+        listen(port, bind, callback) {
+            const server = {
+                address: () => ({ port: ASSIGNED_PORT }),
+                on: () => server
+            };
+            callback && callback.call(server);
+            return server;
+        }
+    };
+}
+
+function loadProxyModule() {
+    capturedProxyOptions = undefined;
+    const module = { exports: {} };
+    const sandbox = {
+        Buffer,
+        URL,
+        __dirname: path.dirname(proxyFile),
+        console,
+        module,
+        exports: module.exports,
+        require(name) {
+            if (name === 'express') return createExpressStub;
+            if (name === 'http-proxy-response-rewrite') return () => {};
+            if (name === 'http-proxy-middleware') {
+                return {
+                    createProxyMiddleware(_context, options) {
+                        capturedProxyOptions = options;
+                        return function proxyMiddleware() {};
+                    }
+                };
+            }
+            if (name === 'cookie') {
+                return { parse: () => ({}) };
+            }
+            return require(name);
+        }
+    };
+    vm.runInNewContext(source, sandbox, { filename: proxyFile });
+    return module.exports;
+}
+
+const proxyModule = loadProxyModule();
+const formerDataStorePath = path.join(os.tmpdir(), `alexa-cookie-proxy-random-port-test-${Date.now()}.json`);
+
+try {
+    const input = {
+        proxyOwnIp: '127.0.0.1',
+        proxyPort: 0,
+        proxyListenBind: '0.0.0.0',
+        baseAmazonPage: 'amazon.de',
+        baseAmazonPageHandle: '_de',
+        amazonPageProxyLanguage: 'de_DE',
+        acceptLanguage: 'de-DE',
+        proxyLogLevel: 'silent',
+        formerDataStorePath
+    };
+    proxyModule.initAmazonProxy(input);
+
+    const refererReq = {
+        method: 'POST',
+        url: '/ap/cvf/verify',
+        headers: {
+            host: `127.0.0.1:${ASSIGNED_PORT}`,
+            referer: `http://127.0.0.1:${ASSIGNED_PORT}/www.amazon.com/ap/signin`
+        }
+    };
+
+    const refererTarget = capturedProxyOptions.router(refererReq);
+
+    line('TEST: proxy random port (proxyPort 0)');
+    line('');
+    line('CODE UNDER TEST:');
+    line('- lib/proxy.js: proxyBase() lazy resolution');
+    line('- lib/proxy.js: listen callback writes assigned port to _options.proxyPort');
+    line('- lib/proxy.js: router()/amazonHostFromProxyUrl()');
+    line('');
+    line('INPUT:');
+    line(`proxyPort: ${input.proxyPort}`);
+    line(`assigned listen port: ${ASSIGNED_PORT}`);
+    line(`referer header: ${refererReq.headers.referer}`);
+    line('');
+    line('OBSERVED:');
+    line(`_options.proxyPort after init: ${input.proxyPort}`);
+    line(`referer router target: ${refererTarget}`);
+    line('');
+    line('ASSERTIONS:');
+    recordAssertion(`_options.proxyPort updated to ${ASSIGNED_PORT}`, () => {
+        assert.strictEqual(input.proxyPort, ASSIGNED_PORT);
+    });
+    recordAssertion('referer router target === "https://www.amazon.com"', () => {
+        assert.strictEqual(refererTarget, 'https://www.amazon.com');
+    });
+    line('');
+    line('RESULT: PASS');
+    writeOutput();
+} catch (err) {
+    if (!lines.includes('RESULT: PASS')) {
+        line('');
+        line('RESULT: FAIL');
+        writeOutput();
+    }
+    throw err;
+} finally {
+    fs.rmSync(formerDataStorePath, { force: true });
+}