@camstack/addon-import-alexa 0.2.174 → 0.2.176

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-import-alexa",
-  "version": "0.2.174",
+  "version": "0.2.176",
   "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",
@@ -68,7 +68,7 @@
       }
     ],
     "requires": {
-      "server": ">=1.2.719"
+      "server": ">=1.2.729"
     }
   },
   "files": [

package/python/alexa_gateway.py

@@ -69,6 +69,9 @@ def normalize_device(raw: dict) -> dict | None:
     return result
 
 
+# The skill alexapy itself names for an AlexaAnnouncement node.
+ANNOUNCEMENT_SKILL_ID = "amzn1.ask.1p.routines.messaging"
+
 class AlexaPyGateway:
     """Holds one AlexaLogin for the life of the process (one process per broker)."""
 
@@ -119,14 +122,32 @@ class AlexaPyGateway:
             bare_domain(domain), label, "", session_output(session_path), False, oauth=oauth
         )
         self._login = login
+        cookies: dict = {}
         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"}
+                return {
+                    "status": "failed",
+                    "error": "step 1 of 3, token exchange: Amazon refused 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"}
+            # The exchange put its cookies in the live session; use them as they are. Reading
+            # them back through the cookie file filters them by host and can come back empty.
+            cookies = _session_cookies(login)
+            if not cookies:
+                cookies = await login.load_cookie() or {}
+            if not cookies:
+                return {
+                    "status": "failed",
+                    "error": "step 2 of 3, cookies: the token exchange was accepted but returned no cookies",
+                }
+        else:
+            cookies = await login.load_cookie() or {}
+            if not cookies:
+                return {
+                    "status": "failed",
+                    "error": "step 2 of 3, cookies: no stored Amazon session and no broker token to start from",
+                }
         await login.login(cookies=cookies)
         await self._persist_session()
         return self._status_result()
@@ -159,13 +180,28 @@ class AlexaPyGateway:
     async def speak(self, sequence: dict, customer_id: str) -> None:
         login = self._require_login()
         _AlexaLogin, AlexaAPI = _import_alexapy()
-        await AlexaAPI.send_sequence(login, sequence, customer_id, None)
+        # alexapy 1.29.20: send_sequence/send_announcement are INSTANCE methods that read the
+        # device behind the API object (type, serial, locale). Our payloads already carry the
+        # target, so run the prebuilt node through run_behavior, which needs only the login.
+        # queue_delay=0 posts at once instead of batching with other queued nodes.
+        await AlexaAPI(None, login).run_behavior(sequence["startNode"], queue_delay=0)
         self._touch_success()
 
     async def announce(self, announcement: dict, customer_id: str) -> None:
         login = self._require_login()
         _AlexaLogin, AlexaAPI = _import_alexapy()
-        await AlexaAPI.send_announcement(login, announcement, customer_id, None)
+        node = {
+            "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",
+            "type": "AlexaAnnouncement",
+            "operationPayload": {
+                "expireAfter": announcement["expireAfter"],
+                "content": announcement["content"],
+                "target": announcement["target"],
+                "customerId": customer_id,
+                "skillId": ANNOUNCEMENT_SKILL_ID,
+            },
+        }
+        await AlexaAPI(None, login).run_behavior(node, queue_delay=0)
         self._touch_success()
 
     async def session_status(self) -> dict:
@@ -213,6 +249,22 @@ def _import_alexapy():
     return AlexaLogin, AlexaAPI
 
 
+def _session_cookies(login) -> dict:
+    """Every cookie the login's live session holds, by name. Values only leave this process
+    inside the library; nothing here logs them."""
+    session = getattr(login, "_session", None)
+    jar = getattr(session, "cookie_jar", None)
+    found: dict = {}
+    if jar is None:
+        return found
+    for morsel in jar:
+        name = getattr(morsel, "key", None)
+        value = getattr(morsel, "value", None)
+        if isinstance(name, str) and isinstance(value, str) and name != "":
+            found[name] = value.strip('"')
+    return found
+
+
 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

package/python/test_alexa_gateway.py

@@ -19,7 +19,9 @@ 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):
+def install_fake_alexapy(
+    exchange_ok: bool = True, stored_cookies: dict | None = None, file_readback: bool = True
+):
     """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")
@@ -34,10 +36,13 @@ def install_fake_alexapy(exchange_ok: bool = True, stored_cookies: dict | None =
             calls["jar_path"] = outputpath(".storage/alexa_media.x.pickle")
             self.status = {"login_successful": True}
             self.refresh_token = (oauth or {}).get("refresh_token")
+            self._session = types.SimpleNamespace(cookie_jar=[])
 
         async def exchange_token_for_cookies(self):
             calls["exchange_app_names"].append(module.APP_NAME)
             calls["exchanged_token"] = self.refresh_token
+            if exchange_ok:
+                self._session.cookie_jar.append(types.SimpleNamespace(key="session-id", value="1"))
             return exchange_ok
 
         async def save_cookiefile(self):
@@ -45,7 +50,9 @@ def install_fake_alexapy(exchange_ok: bool = True, stored_cookies: dict | None =
             Path(calls["jar_path"]).write_bytes(b"jar")
 
         async def load_cookie(self):
-            return {"session-id": "1"} if (exchange_ok or stored_cookies) else {}
+            if stored_cookies:
+                return stored_cookies
+            return {"session-id": "1"} if (exchange_ok and file_readback) else {}
 
         async def login(self, cookies=None, data=None):
             calls["logins"].append(cookies)
@@ -68,6 +75,10 @@ def run(coro):
     return asyncio.run(coro)
 
 
+async def _accept_without_cookies(self):
+    return True
+
+
 class GatewayTests(unittest.TestCase):
     def tearDown(self) -> None:
         remove_fake_alexapy()
@@ -113,6 +124,27 @@ class GatewayTests(unittest.TestCase):
         self.assertEqual(calls["logins"], [])
         self.assertEqual(module.APP_NAME, "Alexa Media Player")
 
+    def test_cookies_from_the_exchange_are_used_when_the_file_reads_back_empty(self) -> None:
+        calls, _ = install_fake_alexapy(file_readback=False)
+        with tempfile.TemporaryDirectory() as directory:
+            result = run(
+                AlexaPyGateway().login_broker("alexa_002", "t", "", "amazon.com", "NA", str(Path(directory) / "s"))
+            )
+        self.assertEqual(result, {"status": "ok"})
+        self.assertEqual(calls["logins"], [{"session-id": "1"}])
+
+    def test_an_exchange_that_yields_no_cookies_names_its_step(self) -> None:
+        calls, _ = install_fake_alexapy(file_readback=False)
+        sys.modules["alexapy"].AlexaLogin.exchange_token_for_cookies = _accept_without_cookies
+        with tempfile.TemporaryDirectory() as directory:
+            result = run(
+                AlexaPyGateway().login_broker("alexa_002", "t", "", "amazon.com", "NA", str(Path(directory) / "s"))
+            )
+        self.assertEqual(result["status"], "failed")
+        self.assertIn("cookies", result["error"])
+        self.assertIn("exchange was accepted", result["error"])
+        self.assertEqual(calls["logins"], [])
+
     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:

package/python/test_alexa_gateway_send.py

@@ -0,0 +1,83 @@
+"""speak/announce must call alexapy the way alexapy 1.29.20 defines it.
+
+In that release send_sequence / send_announcement are INSTANCE methods that read
+`self._device`; calling them on the class with a login first (the old code) fails
+with "'AlexaLogin' object has no attribute '_device'". The fake below mirrors the
+real signatures, so the wrong call shape raises the same way.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from alexa_gateway import AlexaPyGateway
+from alexa_sequences import build_announcement, build_speak_sequence
+
+TARGET = {"id": "G090XX", "deviceType": "A3S5BH2HU6VAYF", "customerId": "A1CUST"}
+
+
+def make_fake_api(posted: list):
+    class FakeAlexaAPI:
+        def __init__(self, device, login):
+            self._device = device
+            self._login = login
+
+        async def run_behavior(self, node_data, queue_delay: float = 1.5) -> None:
+            posted.append((node_data, queue_delay))
+
+        # Real signatures: the first positional parameter is `self`, then message/sequence.
+        async def send_sequence(self, sequence, customer_id=None, queue_delay=1.5, extra=None, **kwargs):
+            self._device._device_type  # raises AttributeError without a device, as the real one
+
+        async def send_announcement(self, message, method="all", title="Announcement",
+                                    customer_id=None, targets=None, queue_delay=1.5, extra=None):
+            self._device._locale
+
+    return FakeAlexaAPI
+
+
+class SendTests(unittest.TestCase):
+    def _gateway(self, posted):
+        import types
+
+        package = types.ModuleType("alexapy")
+        package.AlexaLogin = object
+        package.AlexaAPI = make_fake_api(posted)
+        sys.modules["alexapy"] = package
+        sys.modules["alexapy.alexalogin"] = types.ModuleType("alexapy.alexalogin")
+        gateway = AlexaPyGateway()
+        gateway._login = object()
+        return gateway
+
+    def tearDown(self):
+        sys.modules.pop("alexapy", None)
+        sys.modules.pop("alexapy.alexalogin", None)
+
+    def test_speak_posts_the_sequence_start_node_immediately(self):
+        posted: list = []
+        sequence = build_speak_sequence(TARGET, "hello", 30, "it-IT")
+        asyncio.run(self._gateway(posted).speak(sequence, "A1CUST"))
+        self.assertEqual(posted, [(sequence["startNode"], 0)])
+
+    def test_announce_posts_an_announcement_node_with_target_and_content(self):
+        posted: list = []
+        announcement = build_announcement(TARGET, "hello", "it-IT")
+        asyncio.run(self._gateway(posted).announce(announcement, "A1CUST"))
+        self.assertEqual(len(posted), 1)
+        node, delay = posted[0]
+        self.assertEqual(delay, 0)
+        self.assertEqual(node["type"], "AlexaAnnouncement")
+        payload = node["operationPayload"]
+        self.assertEqual(payload["target"], announcement["target"])
+        self.assertEqual(payload["content"], announcement["content"])
+        self.assertEqual(payload["customerId"], "A1CUST")
+        self.assertEqual(payload["skillId"], "amzn1.ask.1p.routines.messaging")
+
+
+if __name__ == "__main__":
+    unittest.main()