@camstack/addon-import-alexa 0.2.147 → 0.2.149

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,10 @@
   "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)",
+  "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"
 }

package/i18n/it.json

@@ -11,5 +11,10 @@
   "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)",
+  "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"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-import-alexa",
-  "version": "0.2.147",
+  "version": "0.2.149",
   "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,18 +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"
+    "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,199 @@
+"""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.
+"""
+
+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",
+}
+
+
+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"
+
+
+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"
+    return {
+        "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 ""),
+    }
+
+
+class AlexaPyGateway:
+    """Holds one AlexaLogin for the life of the process."""
+
+    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_start(self, email: str, password: str, region: str, session_path: str) -> dict:
+        self._region = region if region in REGION_URL 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})
+        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")}
+            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":
+            # 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.
+            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
+        save = getattr(login, "save_cookie", None)
+        if not callable(save):
+            return
+        result = save(self._session_path)
+        if asyncio.iscoroutine(result):
+            await result
+
+
+def _import_alexapy():
+    from alexapy import AlexaAPI, AlexaLogin
+
+    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

package/python/alexa_protocol.py

@@ -0,0 +1,110 @@
+"""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.
+"""
+
+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_start(
+        self, email: str, password: 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: ...
+
+    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_password(path: str) -> str:
+    return Path(path).read_text(encoding="utf-8")
+
+
+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_start":
+            password = _read_password(str(message.get("passwordPath", "")))
+            return await self._gateway.login_start(
+                str(message.get("email", "")),
+                password,
+                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":
+            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