@camstack/addon-import-alexa 0.2.149 → 0.2.151

package/dist/{hostInit-_k3o3MHN.mjs → hostInit-CRUwUtSm.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.422",
+				version: "1.2.424",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.334",
+				version: "1.2.335",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

package/dist/{player-overlays-CJBC2I_E.mjs → player-overlays-DNpsEqAe.mjs}

@@ -1,6 +1,6 @@
 import { S as e, d as t, u as n, v as r } from "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare__react__loadShare__.js-DwXXYAlk.mjs";
 import { n as i, r as a, t as o } from "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-CUiVYNMY.mjs";
-import { h as s, m as c } from "./responsive-N99niSJu.mjs";
+import { h as s, m as c } from "./responsive-B82v3AbM.mjs";
 var l = s("chevron-down", [["path", {
 	d: "m6 9 6 6 6-6",
 	key: "qrunsl"

package/dist/remoteEntry.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_import_alexa_page__remoteEntry_js-CsdMNhUS.mjs";
+import { n as e, t } from "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_import_alexa_page__remoteEntry_js-DMdgQOgz.mjs";
 export { t as get, e as init };

package/dist/{responsive-N99niSJu.mjs → responsive-B82v3AbM.mjs}

@@ -1,6 +1,6 @@
 import { S as e, d as t, g as n, i as r, l as i, n as a, r as o, u as s, v as c, y as l } from "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare__react__loadShare__.js-DwXXYAlk.mjs";
 import "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-CUiVYNMY.mjs";
-import { l as u } from "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-I8eNxvdp.mjs";
+import { c as u } from "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-Msberbw_.mjs";
 //#region ../../node_modules/lucide-react/dist/esm/shared/src/utils/mergeClasses.js
 e();
 var d = (...e) => e.filter((e, t, n) => !!e && e.trim() !== "" && n.indexOf(e) === t).join(" ").trim(), f = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), p = (e) => e.replace(/^([A-Z])|[\s-_]+(\w)/g, (e, t, n) => n ? n.toUpperCase() : t.toLowerCase()), m = (e) => {

package/dist/{scene-monitor-copy-DeuPVYmS.mjs → scene-monitor-copy-CPnjwzw6.mjs}

@@ -1,6 +1,6 @@
 import { S as e, g as t, l as n, v as r } from "./_virtual_mf___mfe_internal__addon_import_alexa_page__loadShare__react__loadShare__.js-DwXXYAlk.mjs";
 import { n as i } from "./ui-text-B5YO4hoJ.mjs";
-import { h as a } from "./responsive-N99niSJu.mjs";
+import { h as a } from "./responsive-B82v3AbM.mjs";
 var o = a("camera", [["path", {
 	d: "M13.997 4a2 2 0 0 1 1.76 1.05l.486.9A2 2 0 0 0 18.003 7H20a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2h1.997a2 2 0 0 0 1.759-1.048l.489-.904A2 2 0 0 1 10.004 4z",
 	key: "18u6gg"

package/dist/{square-CnLcG0Zc.mjs → square-YTl_L1_3.mjs}

@@ -1,4 +1,4 @@
-import { h as e } from "./responsive-N99niSJu.mjs";
+import { h as e } from "./responsive-B82v3AbM.mjs";
 var t = e("eye-off", [
 	["path", {
 		d: "M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49",

package/dist/{trash-2-BzimUQsl.mjs → trash-2-DCHugLVt.mjs}

@@ -1,4 +1,4 @@
-import { h as e } from "./responsive-N99niSJu.mjs";
+import { h as e } from "./responsive-B82v3AbM.mjs";
 var t = e("trash-2", [
 	["path", {
 		d: "M10 11v6",

package/dist/{virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_import_alexa_page__remoteEntry_js-CsdMNhUS.mjs → virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_import_alexa_page__remoteEntry_js-DMdgQOgz.mjs}

@@ -2753,7 +2753,7 @@ async function rr(e) {
 	}
 }
 async function ir() {
-	return tr ||= rr(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_import_alexa_page-CdRL7bFZ.mjs")).catch((e) => {
+	return tr ||= rr(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_import_alexa_page-CcQjQJmj.mjs")).catch((e) => {
 		throw tr = void 0, e;
 	}), tr;
 }

package/i18n/en.json

@@ -12,9 +12,11 @@
   "connection.s_alexa-account.cookie.label": "Cookie blob (from proxy login)",
   "connection.s_alexa-account.refreshToken.label": "Refresh token (alternative to cookie)",
   "connection.s_alexa-account.pollIntervalMs.label": "State poll interval (ms)",
-  "globalSettings.s_alexa-speak.title": "Speak on Echo",
-  "globalSettings.s_alexa-speak.description": "Sign in on the Speak on Echo page, pick the devices, and use them as a notification target. The text is the rule template, read aloud.",
-  "globalSettings.s_alexa-speak.speak_email.label": "Amazon email",
-  "globalSettings.s_alexa-speak.speak_password.label": "Amazon password",
-  "globalSettings.s_alexa-speak.speak_region.label": "Region"
+  "echoTarget.s_echo.title": "Echo",
+  "echoTarget.s_echo.brokerId.label": "Amazon account",
+  "echoTarget.s_echo.echoId.label": "Echo",
+  "echoTarget.s_echo.echoId.empty": "No Echo found yet. Sign the Amazon account in on Integrations, Alexa.",
+  "echoTarget.s_echo.mode.label": "Mode",
+  "echoTarget.s_echo.volume.label": "Volume",
+  "echoTarget.s_echo.respectDnd.label": "Respect Do Not Disturb"
 }

package/i18n/it.json

@@ -12,9 +12,11 @@
   "connection.s_alexa-account.cookie.label": "Blocco cookie (dal proxy di accesso)",
   "connection.s_alexa-account.refreshToken.label": "Refresh token (alternativa al cookie)",
   "connection.s_alexa-account.pollIntervalMs.label": "Intervallo di interrogazione dello stato (ms)",
-  "globalSettings.s_alexa-speak.title": "Parla sugli Echo",
-  "globalSettings.s_alexa-speak.description": "Accedi dalla pagina Parla sugli Echo, scegli i dispositivi e usali come destinazione di una notifica. Il testo è il modello della regola, letto ad alta voce.",
-  "globalSettings.s_alexa-speak.speak_email.label": "Email Amazon",
-  "globalSettings.s_alexa-speak.speak_password.label": "Password Amazon",
-  "globalSettings.s_alexa-speak.speak_region.label": "Regione"
+  "echoTarget.s_echo.title": "Echo",
+  "echoTarget.s_echo.brokerId.label": "Account Amazon",
+  "echoTarget.s_echo.echoId.label": "Echo",
+  "echoTarget.s_echo.echoId.empty": "Nessun Echo trovato. Accedi con l'account Amazon da Integrazioni, Alexa.",
+  "echoTarget.s_echo.mode.label": "Modalità",
+  "echoTarget.s_echo.volume.label": "Volume",
+  "echoTarget.s_echo.respectDnd.label": "Rispetta Non disturbare"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-import-alexa",
-  "version": "0.2.149",
+  "version": "0.2.151",
   "description": "Alexa device-import provider for CamStack — imports the smart-home devices in a user's Alexa account via the unofficial alexa-remote2 cookie/token client (the inverse of the Alexa exporter)",
   "keywords": [
     "camstack",

package/python/alexa_gateway.py

@@ -1,34 +1,47 @@
 """alexapy adapter. Imported only when the worker starts, so unit tests can mock the gateway.
 
-Never log the password, the cookie blob, or the session file contents.
+Never log the refresh token, the cookie blob, or the session file contents.
 """
 
 from __future__ import annotations
 
-import asyncio
 import time
 from pathlib import Path
 
 from alexa_sequences import EchoTarget
 
-REGION_URL = {
-    "NA": "https://alexa.amazon.com",
-    "EU": "https://alexa.amazon.co.uk",
-    "FE": "https://alexa.amazon.co.jp",
-}
+REGIONS = ("NA", "EU", "FE")
 
 
 def classify_login(status: dict) -> str:
-    if status.get("login_successful") is True:
-        return "ok"
-    failed = str(status.get("login_failed") or status.get("error_message") or "").lower()
-    if "captcha" in failed:
-        return "captcha"
-    if any(word in failed for word in ("otp", "2fa", "mfa", "verification code", "one-time")):
-        return "otp_needed"
-    if failed == "" and status.get("login_successful") is not True:
-        return "failed"
-    return "failed"
+    """The worker signs in with the broker's token, so a sign-in either works or it does not."""
+    return "ok" if status.get("login_successful") is True else "failed"
+
+
+def bare_domain(domain: str) -> str:
+    """alexapy wants the registrable Amazon domain: no scheme, no `www.` or `alexa.` host."""
+    text = domain.strip().lower()
+    for prefix in ("https://", "http://"):
+        if text.startswith(prefix):
+            text = text[len(prefix) :]
+    text = text.split("/", 1)[0]
+    for host in ("www.", "alexa."):
+        if text.startswith(host):
+            text = text[len(host) :]
+    return text or "amazon.com"
+
+
+def session_output(session_path: str):
+    """alexapy asks a callable where each of its files goes. Its primary cookie jar
+    is ours: the file the addon keeps (in the keychain) between runs."""
+    session = Path(session_path)
+
+    def output(name: str) -> str:
+        if name.startswith(".storage/") and name.endswith(".pickle"):
+            return str(session)
+        return str(session.parent / name.replace("/", "_"))
+
+    return output
 
 
 def normalize_device(raw: dict) -> dict | None:
@@ -40,7 +53,8 @@ def normalize_device(raw: dict) -> dict | None:
     online = bool(raw.get("online", True))
     dnd = bool(raw.get("dnd") or raw.get("dndEnabled"))
     kind = "group" if family.upper() == "WHA" else "device"
-    return {
+    room = str(raw.get("roomName") or raw.get("room") or "")
+    result = {
         "id": serial,
         "name": name,
         "family": family,
@@ -50,10 +64,13 @@ def normalize_device(raw: dict) -> dict | None:
         "deviceType": str(raw.get("deviceType") or raw.get("deviceTypeId") or ""),
         "customerId": str(raw.get("deviceOwnerCustomerId") or raw.get("customerId") or ""),
     }
+    if room != "":
+        result["room"] = room
+    return result
 
 
 class AlexaPyGateway:
-    """Holds one AlexaLogin for the life of the process."""
+    """Holds one AlexaLogin for the life of the process (one process per broker)."""
 
     def __init__(self) -> None:
         self._login = None
@@ -78,27 +95,39 @@ class AlexaPyGateway:
                 }
         return None
 
-    async def login_start(self, email: str, password: str, region: str, session_path: str) -> dict:
-        self._region = region if region in REGION_URL else "EU"
+    async def login_broker(
+        self,
+        label: str,
+        refresh_token: str,
+        device_app_name: str,
+        domain: str,
+        region: str,
+        session_path: str,
+    ) -> dict:
+        """Sign in as the account an import broker already signed in as.
+
+        The broker's refresh token is exchanged for this session's cookies; with
+        no token, the jar stored from an earlier run is tried. `label` is not an
+        e-mail address, so alexapy takes it as a mobile account and does not
+        compare it with the account's address.
+        """
+        self._region = region if region in REGIONS else "EU"
         self._session_path = session_path
-        url = REGION_URL[self._region]
         AlexaLogin, _AlexaAPI = _import_alexapy()
-        output = str(Path(session_path).parent)
-        self._login = AlexaLogin(url, email, password, output, False)
-        cookies = await _load_session(self._login, session_path)
-        await self._login.login(cookies=cookies)
-        await self._persist_session()
-        return self._status_result()
-
-    async def login_otp(self, code: str, session_path: str = "") -> dict:
-        if session_path != "":
-            self._session_path = session_path
-        login = self._require_login()
-        submit = getattr(login, "submit_otp", None)
-        if callable(submit):
-            await submit(code)
-        else:
-            await login.login(data={"otpCode": code})
+        oauth = {"refresh_token": refresh_token} if refresh_token != "" else {}
+        login = AlexaLogin(
+            bare_domain(domain), label, "", session_output(session_path), False, oauth=oauth
+        )
+        self._login = login
+        if refresh_token != "":
+            exchanged = await _exchange_refresh_token(login, device_app_name)
+            if not exchanged:
+                return {"status": "failed", "error": "Amazon did not accept the broker's token"}
+            await login.save_cookiefile()
+        cookies = await login.load_cookie()
+        if not cookies:
+            return {"status": "failed", "error": "no Amazon session to start from"}
+        await login.login(cookies=cookies)
         await self._persist_session()
         return self._status_result()
 
@@ -118,7 +147,11 @@ class AlexaPyGateway:
         self._devices = devices
         self._touch_success()
         public = [
-            {key: device[key] for key in ("id", "name", "family", "online", "kind", "dnd", "deviceType")}
+            {
+                key: device[key]
+                for key in ("id", "name", "family", "online", "kind", "dnd", "deviceType", "room")
+                if key in device
+            }
             for device in devices
         ]
         return {"devices": public}
@@ -159,8 +192,7 @@ class AlexaPyGateway:
             self._touch_success()
         result: dict = {"status": kind}
         if kind == "failed":
-            # The library's message can echo the account. Never include the password:
-            # the caller already scrubbed it before it reached us, and we do not attach it.
+            # Never attach the token: the library's message can echo the account, not our secret.
             failed = str(status.get("login_failed") or status.get("error_message") or "login failed")
             result["error"] = failed[:300]
         return result
@@ -172,12 +204,7 @@ class AlexaPyGateway:
         login = self._login
         if login is None or self._session_path == "":
             return
-        save = getattr(login, "save_cookie", None)
-        if not callable(save):
-            return
-        result = save(self._session_path)
-        if asyncio.iscoroutine(result):
-            await result
+        await login.save_cookiefile()
 
 
 def _import_alexapy():
@@ -186,14 +213,14 @@ def _import_alexapy():
     return AlexaLogin, AlexaAPI
 
 
-async def _load_session(login, session_path: str):
-    path = Path(session_path)
-    if not path.is_file() or path.stat().st_size == 0:
-        return None
-    load = getattr(login, "load_cookie", None)
-    if not callable(load):
-        return None
-    loaded = load(session_path)
-    if asyncio.iscoroutine(loaded):
-        return await loaded
-    return loaded
+async def _exchange_refresh_token(login, device_app_name: str) -> bool:
+    """Trade the broker's refresh token for cookies, under the name that token was registered with."""
+    import alexapy.alexalogin as module
+
+    previous = module.APP_NAME
+    if device_app_name != "":
+        module.APP_NAME = device_app_name
+    try:
+        return bool(await login.exchange_token_for_cookies())
+    finally:
+        module.APP_NAME = previous

package/python/alexa_protocol.py

@@ -1,8 +1,8 @@
 """Line-delimited JSON session for the long-lived Echo worker.
 
 One request object per stdin line, one response object per stdout line,
-matched by ``id``. The password is read from a file the request names;
-it is never taken from the JSON body.
+matched by ``id``. The broker's refresh token is read from a file the request
+names; it is never taken from the JSON body.
 """
 
 from __future__ import annotations
@@ -18,12 +18,16 @@ REGION_LOCALE = {"NA": "en-US", "EU": "en-GB", "FE": "ja-JP"}
 class Gateway(Protocol):
     region: str
 
-    async def login_start(
-        self, email: str, password: str, region: str, session_path: str
+    async def login_broker(
+        self,
+        label: str,
+        refresh_token: str,
+        device_app_name: str,
+        domain: str,
+        region: str,
+        session_path: str,
     ) -> dict: ...
 
-    async def login_otp(self, code: str, session_path: str) -> dict: ...
-
     async def devices(self) -> dict: ...
 
     async def speak(self, sequence: dict, customer_id: str) -> None: ...
@@ -35,8 +39,11 @@ class Gateway(Protocol):
     def target_for(self, serial: str) -> EchoTarget | None: ...
 
 
-def _read_password(path: str) -> str:
-    return Path(path).read_text(encoding="utf-8")
+def _read_secret(path: str) -> str:
+    """A secret handed over as an owner-only file. An empty path means there is none."""
+    if path == "":
+        return ""
+    return Path(path).read_text(encoding="utf-8").strip()
 
 
 class Session:
@@ -55,18 +62,16 @@ class Session:
         return {"id": request_id, "ok": True, "result": result}
 
     async def _dispatch(self, op: object, message: dict) -> dict:
-        if op == "login_start":
-            password = _read_password(str(message.get("passwordPath", "")))
-            return await self._gateway.login_start(
-                str(message.get("email", "")),
-                password,
+        if op == "login_broker":
+            refresh_token = _read_secret(str(message.get("refreshTokenPath", "")))
+            return await self._gateway.login_broker(
+                str(message.get("label", "")),
+                refresh_token,
+                str(message.get("deviceAppName", "")),
+                str(message.get("domain", "")),
                 str(message.get("region", "EU")),
                 str(message.get("sessionPath", "")),
             )
-        if op == "login_otp":
-            return await self._gateway.login_otp(
-                str(message.get("code", "")), str(message.get("sessionPath", ""))
-            )
         if op == "devices":
             return await self._gateway.devices()
         if op == "speak":

package/python/test_alexa_gateway.py

@@ -0,0 +1,141 @@
+"""The gateway signs in as a broker's account, with alexapy replaced by a fake module.
+
+These tests must not contact Amazon. They check what the gateway hands to alexapy
+(the broker's token, the registered app name, where the cookie jar lives) and what
+it does when Amazon refuses.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from alexa_gateway import AlexaPyGateway, bare_domain, normalize_device, session_output
+
+
+def install_fake_alexapy(exchange_ok: bool = True, stored_cookies: dict | None = None):
+    """Put a fake `alexapy` (and `alexapy.alexalogin`) in sys.modules; return the call log."""
+    calls: dict = {"exchange_app_names": [], "logins": [], "saved": 0}
+    module = types.ModuleType("alexapy.alexalogin")
+    module.APP_NAME = "Alexa Media Player"
+
+    class FakeLogin:
+        def __init__(self, url, email, password, outputpath, debug=False, oauth=None, **_):
+            calls["url"] = url
+            calls["email"] = email
+            calls["password"] = password
+            calls["oauth"] = dict(oauth or {})
+            calls["jar_path"] = outputpath(".storage/alexa_media.x.pickle")
+            self.status = {"login_successful": True}
+            self.refresh_token = (oauth or {}).get("refresh_token")
+
+        async def exchange_token_for_cookies(self):
+            calls["exchange_app_names"].append(module.APP_NAME)
+            calls["exchanged_token"] = self.refresh_token
+            return exchange_ok
+
+        async def save_cookiefile(self):
+            calls["saved"] += 1
+            Path(calls["jar_path"]).write_bytes(b"jar")
+
+        async def load_cookie(self):
+            return {"session-id": "1"} if (exchange_ok or stored_cookies) else {}
+
+        async def login(self, cookies=None, data=None):
+            calls["logins"].append(cookies)
+
+    package = types.ModuleType("alexapy")
+    package.AlexaLogin = FakeLogin
+    package.AlexaAPI = object
+    package.alexalogin = module
+    sys.modules["alexapy"] = package
+    sys.modules["alexapy.alexalogin"] = module
+    return calls, module
+
+
+def remove_fake_alexapy() -> None:
+    sys.modules.pop("alexapy", None)
+    sys.modules.pop("alexapy.alexalogin", None)
+
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+class GatewayTests(unittest.TestCase):
+    def tearDown(self) -> None:
+        remove_fake_alexapy()
+
+    def test_exchanges_the_brokers_token_under_its_registered_name_and_restores_the_default(self) -> None:
+        calls, module = install_fake_alexapy()
+        with tempfile.TemporaryDirectory() as directory:
+            session_path = str(Path(directory) / "session")
+            result = run(
+                AlexaPyGateway().login_broker(
+                    "alexa_001", "broker-refresh-token", "Registered App", "amazon.it", "EU", session_path
+                )
+            )
+            self.assertEqual(result, {"status": "ok"})
+            self.assertEqual(Path(session_path).read_bytes(), b"jar")
+        self.assertEqual(calls["exchanged_token"], "broker-refresh-token")
+        self.assertEqual(calls["exchange_app_names"], ["Registered App"])
+        self.assertEqual(module.APP_NAME, "Alexa Media Player")
+        self.assertEqual(calls["url"], "amazon.it")
+        self.assertEqual(calls["password"], "")
+        self.assertEqual(calls["email"], "alexa_001")
+        self.assertNotIn("@", calls["email"])
+        self.assertEqual(len(calls["logins"]), 1)
+
+    def test_an_account_two_brokers_share_is_still_two_labels(self) -> None:
+        first, _ = install_fake_alexapy()
+        with tempfile.TemporaryDirectory() as directory:
+            run(AlexaPyGateway().login_broker("alexa_001", "t1", "", "amazon.it", "EU", str(Path(directory) / "s1")))
+            second, _ = install_fake_alexapy()
+            run(AlexaPyGateway().login_broker("alexa_002", "t2", "", "amazon.com", "NA", str(Path(directory) / "s2")))
+        self.assertEqual(first["email"], "alexa_001")
+        self.assertEqual(second["email"], "alexa_002")
+        self.assertEqual(second["exchanged_token"], "t2")
+
+    def test_a_token_amazon_refuses_is_a_named_failure_and_never_logs_in(self) -> None:
+        calls, module = install_fake_alexapy(exchange_ok=False)
+        with tempfile.TemporaryDirectory() as directory:
+            result = run(
+                AlexaPyGateway().login_broker("alexa_001", "bad", "X", "amazon.com", "NA", str(Path(directory) / "s"))
+            )
+        self.assertEqual(result["status"], "failed")
+        self.assertNotIn("bad", result["error"])
+        self.assertEqual(calls["logins"], [])
+        self.assertEqual(module.APP_NAME, "Alexa Media Player")
+
+    def test_with_no_token_only_the_stored_jar_is_tried(self) -> None:
+        calls, _ = install_fake_alexapy(stored_cookies={"session-id": "1"})
+        with tempfile.TemporaryDirectory() as directory:
+            result = run(
+                AlexaPyGateway().login_broker("alexa_001", "", "", "amazon.it", "EU", str(Path(directory) / "s"))
+            )
+        self.assertEqual(result, {"status": "ok"})
+        self.assertEqual(calls["exchange_app_names"], [])
+
+    def test_helpers(self) -> None:
+        self.assertEqual(bare_domain("https://alexa.amazon.co.uk/"), "amazon.co.uk")
+        self.assertEqual(bare_domain("www.amazon.de"), "amazon.de")
+        self.assertEqual(bare_domain(""), "amazon.com")
+        output = session_output("/tmp/x/session")
+        self.assertEqual(output(".storage/alexa_media.a.pickle"), "/tmp/x/session")
+        self.assertEqual(output("alexa_media.a.pickle"), "/tmp/x/alexa_media.a.pickle")
+
+    def test_a_room_is_passed_on_only_when_amazon_names_one(self) -> None:
+        with_room = normalize_device({"serialNumber": "s", "accountName": "Kitchen", "roomName": "Living room"})
+        without = normalize_device({"serialNumber": "s", "accountName": "Kitchen"})
+        self.assertEqual(with_room["room"], "Living room")
+        self.assertNotIn("room", without)
+
+
+if __name__ == "__main__":
+    unittest.main()