@camstack/addon-import-alexa 0.2.148 → 0.2.150

package/dist/virtual_mf-exposes-ssr___mfe_internal__addon_import_alexa_page__remoteEntry_js-CViESMdd.mjs

@@ -0,0 +1,10 @@
+//#region virtual:mf-exposes-ssr:__mfe_internal__addon_import_alexa_page__remoteEntry_js
+var e = { "./page": async () => {
+	let e = await import("./_stub.js"), t = {};
+	return Object.assign(t, e), Object.defineProperty(t, "__esModule", {
+		value: !0,
+		enumerable: !1
+	}), t;
+} };
+//#endregion
+export { e as default };

package/dist/virtual_mf-exposes___mfe_internal__addon_import_alexa_page__remoteEntry_js-C3qJCjtV.mjs

@@ -0,0 +1,27 @@
+//#region virtual:mf-exposes:__mfe_internal__addon_import_alexa_page__remoteEntry_js
+var e = {}, t = /* @__PURE__ */ new Set(), n = Promise.resolve();
+async function r(e) {
+	let t = n.then(e, e);
+	return n = t.then(() => void 0, () => void 0), t;
+}
+async function i(n) {
+	if (typeof document > "u") return;
+	let r = e[n] || [];
+	await Promise.all(r.map((e) => {
+		let n = new URL(e, import.meta.url).href;
+		return t.has(n) || (t.add(n), document.querySelector(`link[rel="stylesheet"][data-mf-href="${n}"]`)) ? Promise.resolve() : new Promise((e, t) => {
+			let r = document.createElement("link");
+			r.rel = "stylesheet", r.href = n, r.setAttribute("data-mf-href", n), r.onload = () => e(), r.onerror = () => t(/* @__PURE__ */ Error(`[Module Federation] Failed to load CSS asset: ${n}`)), document.head.appendChild(r);
+		});
+	}));
+}
+var a = { "./page": async () => {
+	await i("./page");
+	let e = await r(() => import("./_stub.js")), t = {};
+	return Object.assign(t, e), Object.defineProperty(t, "__esModule", {
+		value: !0,
+		enumerable: !1
+	}), t;
+} };
+//#endregion
+export { a as t };

package/i18n/en.json

@@ -11,5 +11,12 @@
   "connection.s_alexa-account.amazonDomain.label": "Amazon domain (region)",
   "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)"
+  "connection.s_alexa-account.pollIntervalMs.label": "State poll interval (ms)",
+  "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

@@ -11,5 +11,12 @@
   "connection.s_alexa-account.amazonDomain.label": "Dominio Amazon (regione)",
   "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)"
+  "connection.s_alexa-account.pollIntervalMs.label": "Intervallo di interrogazione dello stato (ms)",
+  "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.148",
+  "version": "0.2.150",
   "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",
@@ -38,7 +38,7 @@
         "category": "providers",
         "name": "Alexa Import",
         "version": "0.1.0",
-        "description": "Import smart-home devices from an Amazon Alexa account (unofficial cookie/token client; poll-based state sync). Maps Alexa capability interfaces onto typed CamStack device caps.",
+        "description": "Import smart-home devices from an Amazon Alexa account (unofficial cookie/token client; poll-based state sync). The same account can speak a notification aloud on Echo devices.",
         "entry": "./dist/addon.js",
         "icon": "assets/icon.svg",
         "color": "#00caff",
@@ -57,20 +57,42 @@
           },
           {
             "name": "addon-routes"
+          },
+          {
+            "name": "notification-output"
+          },
+          {
+            "name": "addon-pages-source"
+          }
+        ],
+        "pages": [
+          {
+            "id": "speak",
+            "label": "Speak on Echo",
+            "icon": "megaphone",
+            "path": "/addon/import-alexa",
+            "remoteName": "addon_import_alexa_page",
+            "bundle": "remoteEntry.js",
+            "section": "administration"
           }
-        ]
+        ],
+        "python": {
+          "requirements": "./python/requirements.txt"
+        }
       }
     ]
   },
   "files": [
     "dist",
+    "python",
     "i18n",
     "assets",
     "README.md",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && vite build -c vite.page.config.ts",
+    "build:page": "vite build -c vite.page.config.ts",
     "dev": "vite build --watch",
     "typecheck": "tsc --noEmit -p tsconfig.spec.json",
     "test": "vitest run",

package/python/NOTICE

@@ -0,0 +1,4 @@
+Echo speech is driven by alexapy (Apache License 2.0).
+The library is installed from python/requirements.txt; it is not copied into this tree.
+Upstream: https://gitlab.com/keatontaylor/alexapy
+Copyright of alexapy remains with its authors.

package/python/alexa_gateway.py

@@ -0,0 +1,226 @@
+"""alexapy adapter. Imported only when the worker starts, so unit tests can mock the gateway.
+
+Never log the refresh token, the cookie blob, or the session file contents.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from alexa_sequences import EchoTarget
+
+REGIONS = ("NA", "EU", "FE")
+
+
+def classify_login(status: dict) -> str:
+    """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:
+    serial = raw.get("serialNumber") or raw.get("deviceSerialNumber")
+    if not isinstance(serial, str) or serial == "":
+        return None
+    family = str(raw.get("deviceFamily") or "")
+    name = str(raw.get("accountName") or raw.get("deviceOwnerCustomerId") or serial)
+    online = bool(raw.get("online", True))
+    dnd = bool(raw.get("dnd") or raw.get("dndEnabled"))
+    kind = "group" if family.upper() == "WHA" else "device"
+    room = str(raw.get("roomName") or raw.get("room") or "")
+    result = {
+        "id": serial,
+        "name": name,
+        "family": family,
+        "online": online,
+        "kind": kind,
+        "dnd": dnd,
+        "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 (one process per broker)."""
+
+    def __init__(self) -> None:
+        self._login = None
+        self._devices: list[dict] = []
+        self._logged_in = False
+        self._signed_in_at: float | None = None
+        self._last_success_at: float | None = None
+        self._session_path = ""
+        self._region = "EU"
+
+    @property
+    def region(self) -> str:
+        return self._region
+
+    def target_for(self, serial: str) -> EchoTarget | None:
+        for device in self._devices:
+            if device["id"] == serial:
+                return {
+                    "id": device["id"],
+                    "deviceType": device["deviceType"],
+                    "customerId": device["customerId"],
+                }
+        return None
+
+    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
+        AlexaLogin, _AlexaAPI = _import_alexapy()
+        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()
+
+    async def devices(self) -> dict:
+        login = self._require_login()
+        _AlexaLogin, AlexaAPI = _import_alexapy()
+        raw = await AlexaAPI.get_devices(login)
+        rows = raw.get("devices") if isinstance(raw, dict) else raw
+        if not isinstance(rows, list):
+            rows = []
+        devices = []
+        for row in rows:
+            if isinstance(row, dict):
+                normalized = normalize_device(row)
+                if normalized is not None:
+                    devices.append(normalized)
+        self._devices = devices
+        self._touch_success()
+        public = [
+            {
+                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}
+
+    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)
+        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)
+        self._touch_success()
+
+    async def session_status(self) -> dict:
+        age = 0
+        if self._signed_in_at is not None:
+            age = int(time.time() - self._signed_in_at)
+        last = int(self._last_success_at) if self._last_success_at is not None else None
+        return {"loggedIn": self._logged_in, "ageSec": age, "lastSuccessAt": last}
+
+    def _require_login(self):
+        if self._login is None:
+            raise RuntimeError("not signed in")
+        return self._login
+
+    def _status_result(self) -> dict:
+        login = self._require_login()
+        status = getattr(login, "status", {}) or {}
+        if not isinstance(status, dict):
+            status = {}
+        kind = classify_login(status)
+        self._logged_in = kind == "ok"
+        if self._logged_in and self._signed_in_at is None:
+            self._signed_in_at = time.time()
+            self._touch_success()
+        result: dict = {"status": kind}
+        if kind == "failed":
+            # 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
+
+    def _touch_success(self) -> None:
+        self._last_success_at = time.time()
+
+    async def _persist_session(self) -> None:
+        login = self._login
+        if login is None or self._session_path == "":
+            return
+        await login.save_cookiefile()
+
+
+def _import_alexapy():
+    from alexapy import AlexaAPI, AlexaLogin
+
+    return AlexaLogin, AlexaAPI
+
+
+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

@@ -0,0 +1,115 @@
+"""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 broker's refresh token is read from a file the request
+names; it is never taken from the JSON body.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol
+
+from alexa_sequences import EchoTarget, build_announcement, build_speak_sequence
+
+REGION_LOCALE = {"NA": "en-US", "EU": "en-GB", "FE": "ja-JP"}
+
+
+class Gateway(Protocol):
+    region: 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 devices(self) -> dict: ...
+
+    async def speak(self, sequence: dict, customer_id: str) -> None: ...
+
+    async def announce(self, announcement: dict, customer_id: str) -> None: ...
+
+    async def session_status(self) -> dict: ...
+
+    def target_for(self, serial: str) -> EchoTarget | None: ...
+
+
+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:
+    def __init__(self, gateway: Gateway) -> None:
+        self._gateway = gateway
+
+    async def handle(self, message: dict) -> dict:
+        op = message.get("op")
+        request_id = message.get("id")
+        if not isinstance(request_id, str) or request_id == "":
+            return {"id": "", "ok": False, "error": "missing id"}
+        try:
+            result = await self._dispatch(op, message)
+        except Exception as err:  # noqa: BLE001 — the line must answer; the message is the error
+            return {"id": request_id, "ok": False, "error": str(err)}
+        return {"id": request_id, "ok": True, "result": result}
+
+    async def _dispatch(self, op: object, message: dict) -> dict:
+        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 == "devices":
+            return await self._gateway.devices()
+        if op == "speak":
+            return await self._utter("speak", message)
+        if op == "announce":
+            return await self._utter("announce", message)
+        if op == "session_status":
+            return await self._gateway.session_status()
+        raise ValueError(f"unknown op {op!r}")
+
+    async def _utter(self, op: str, message: dict) -> dict:
+        targets = message.get("targets")
+        if not isinstance(targets, list) or not targets:
+            raise ValueError("targets required")
+        text = message.get("text")
+        if not isinstance(text, str) or text == "":
+            raise ValueError("text required")
+        volume = message.get("volume")
+        if not isinstance(volume, int):
+            volume = 40
+        locale = REGION_LOCALE.get(self._gateway.region, "en-GB")
+        outcomes: list[dict] = []
+        for serial in targets:
+            if not isinstance(serial, str):
+                outcomes.append({"targetId": "", "ok": False, "error": "bad target"})
+                continue
+            target = self._gateway.target_for(serial)
+            if target is None:
+                outcomes.append({"targetId": serial, "ok": False, "error": "unknown echo"})
+                continue
+            try:
+                if op == "speak":
+                    sequence = build_speak_sequence(target, text, volume, locale)
+                    await self._gateway.speak(sequence, target["customerId"])
+                else:
+                    announcement = build_announcement(target, text, locale)
+                    await self._gateway.announce(announcement, target["customerId"])
+                outcomes.append({"targetId": serial, "ok": True})
+            except Exception as err:  # noqa: BLE001 — one Echo failing must not drop the others
+                outcomes.append({"targetId": serial, "ok": False, "error": str(err)})
+        return {"outcomes": outcomes}

package/python/alexa_sequences.py

@@ -0,0 +1,74 @@
+"""Speak and announce payloads, the shape alexapy forwards to Amazon.
+
+Built here so the protocol tests can see them without importing alexapy
+and without contacting Amazon.
+"""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class EchoTarget(TypedDict):
+    id: str
+    deviceType: str
+    customerId: str
+
+
+def _speak_node(target: EchoTarget, text: str, locale: str) -> dict:
+    return {
+        "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",
+        "type": "Alexa.Speak",
+        "operationPayload": {
+            "deviceType": target["deviceType"],
+            "deviceSerialNumber": target["id"],
+            "locale": locale,
+            "customerId": target["customerId"],
+            "textToSpeak": text,
+        },
+    }
+
+
+def _volume_node(target: EchoTarget, volume: int, nxt: dict) -> dict:
+    return {
+        "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",
+        "type": "Alexa.DeviceControls.Volume",
+        "operationPayload": {
+            "deviceType": target["deviceType"],
+            "deviceSerialNumber": target["id"],
+            "customerId": target["customerId"],
+            "value": volume,
+        },
+        "next": nxt,
+    }
+
+
+def build_speak_sequence(target: EchoTarget, text: str, volume: int, locale: str) -> dict:
+    """Volume, then speech. Speak honours Do Not Disturb on the device."""
+    speak = _speak_node(target, text, locale)
+    start = _volume_node(target, volume, speak) if volume >= 0 else speak
+    return {
+        "@type": "com.amazon.alexa.behaviors.model.Sequence",
+        "startNode": start,
+    }
+
+
+def build_announcement(target: EchoTarget, text: str, locale: str) -> dict:
+    """Chime plus speech. The caller skips a device that is in Do Not Disturb."""
+    return {
+        "customerId": target["customerId"],
+        "expireAfter": "PT5S",
+        "content": [
+            {
+                "locale": locale,
+                "display": {"title": "CamStack", "body": text},
+                "speak": {"type": "text", "value": text},
+            }
+        ],
+        "target": {
+            "customerId": target["customerId"],
+            "devices": [
+                {"deviceSerialNumber": target["id"], "deviceTypeId": target["deviceType"]}
+            ],
+        },
+    }

package/python/alexa_worker.py

@@ -0,0 +1,50 @@
+"""Long-lived Echo worker. One process, line-delimited JSON on stdin/stdout.
+
+Spawned once by the addon and restarted by it with a bound. Never one
+process per message. Logs go to stderr so stdout stays a protocol.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+import traceback
+
+
+async def serve() -> None:
+    # Imported here so `python -m unittest` of the protocol does not need alexapy.
+    from alexa_gateway import AlexaPyGateway
+    from alexa_protocol import Session
+
+    session = Session(AlexaPyGateway())
+    loop = asyncio.get_running_loop()
+    reader = asyncio.StreamReader()
+    protocol = asyncio.StreamReaderProtocol(reader)
+    await loop.connect_read_pipe(lambda: protocol, sys.stdin.buffer)
+    while True:
+        line = await reader.readline()
+        if not line:
+            return
+        text = line.decode("utf-8", errors="replace").strip()
+        if text == "":
+            continue
+        try:
+            message = json.loads(text)
+            if not isinstance(message, dict):
+                response = {"id": "", "ok": False, "error": "request must be an object"}
+            else:
+                response = await session.handle(message)
+        except Exception as err:  # noqa: BLE001 — one bad line must not kill the process
+            traceback.print_exc(file=sys.stderr)
+            response = {"id": "", "ok": False, "error": str(err)}
+        sys.stdout.write(json.dumps(response) + "\n")
+        sys.stdout.flush()
+
+
+def main() -> None:
+    asyncio.run(serve())
+
+
+if __name__ == "__main__":
+    main()

package/python/requirements.txt

@@ -0,0 +1,3 @@
+# Pinned. Echo login, discovery, speak and announce come from this library.
+# Apache-2.0. Installed by the node from this file; not vendored.
+alexapy==1.29.20