machinaos 0.0.78 → 0.0.80

package/server/nodes/android/_events.py

@@ -0,0 +1,154 @@
+"""Wave 12 B1: CloudEvents factories + broadcaster wrappers for android.
+
+Plugin-specific event emission — replaces the
+``StatusBroadcaster.update_android_status`` method (deleted in this
+commit) and the direct ``broadcaster._status["android"]`` mutations
+inside ``_refresh.py`` / ``_relay/broadcaster.py``.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live in
+the plugin folder. The cross-cutting ``WorkflowEvent.connection_status``
+factory in ``services/events/envelope.py`` is borderline (parametrized
+by plugin but each plugin's payload differs) — Phase B moves the
+plugin-specific shape into per-plugin factories.
+
+Wire format (Wave 12 D4 — legacy ``android_status`` raw frame retired):
+  - Typed CloudEvents sibling: ``{type: "plugin_connection_status",
+    data: <WorkflowEvent envelope>}``
+
+The FE handler at ``client/src/contexts/WebSocketContext.tsx::case
+'plugin_connection_status'`` routes by ``envelope.source`` substring to
+the matching Zustand setter.
+
+Caller pattern (from ``_refresh.py`` / ``_relay/broadcaster.py``):
+    from nodes.android import broadcast_android_status
+    await broadcast_android_status(connected=True, device_id="...", ...)
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from services.events.envelope import WorkflowEvent
+
+
+# Wire-routing key — outer ``type`` field on the WS frame.
+_TYPED_WIRE_KEY = "plugin_connection_status"
+
+# Module-level cache mirror — kept in sync with
+# ``StatusBroadcaster._status["android"]`` until the framework's
+# ``get_status()`` snapshot path migrates to a per-plugin getter
+# registry. The plugin owns the SHAPE of this dict; the broadcaster
+# stores it.
+_DEFAULT_STATUS: Dict[str, Any] = {
+    "connected": False,
+    "paired": False,
+    "device_id": None,
+    "device_name": None,
+    "connected_devices": [],
+    "connection_type": None,
+    "qr_data": None,
+    "session_token": None,
+}
+
+
+# ---- Typed factory ---------------------------------------------------------
+
+
+def android_connection_status(
+    *,
+    connected: bool,
+    paired: bool = False,
+    device_id: Optional[str] = None,
+    device_name: Optional[str] = None,
+    connected_devices: Optional[List[str]] = None,
+    connection_type: Optional[str] = None,
+    qr_data: Optional[str] = None,
+    session_token: Optional[str] = None,
+) -> WorkflowEvent:
+    """Build a typed CloudEvents envelope describing the android relay
+    connection state.
+
+    ``subject`` is the device id so the FE can route per-device updates.
+    ``data`` carries the full android status payload (mirrors
+    ``_DEFAULT_STATUS`` shape).
+    """
+    return WorkflowEvent(
+        source="machinaos://nodes/android",
+        type=("com.machinaos.android.connection.opened" if connected else "com.machinaos.android.connection.closed"),
+        subject=device_id,
+        data={
+            "connected": connected,
+            "paired": paired,
+            "device_id": device_id,
+            "device_name": device_name,
+            "connected_devices": list(connected_devices or []),
+            "connection_type": connection_type,
+            "qr_data": qr_data,
+            "session_token": session_token,
+        },
+    )
+
+
+# ---- Broadcaster wrapper ---------------------------------------------------
+
+
+async def broadcast_android_status(
+    *,
+    connected: bool,
+    paired: bool = False,
+    device_id: Optional[str] = None,
+    device_name: Optional[str] = None,
+    connected_devices: Optional[List[str]] = None,
+    connection_type: Optional[str] = None,
+    qr_data: Optional[str] = None,
+    session_token: Optional[str] = None,
+) -> None:
+    """Update the android status cache + emit the typed
+    ``plugin_connection_status`` CloudEvents envelope.
+
+    Replaces ``StatusBroadcaster.update_android_status``. The legacy
+    raw ``android_status`` frame retired in Wave 12 D4 — FE consumes
+    via the envelope-aware ``plugin_connection_status`` case in
+    ``WebSocketContext.tsx`` (routes by ``envelope.source``).
+    """
+    from services.status_broadcaster import get_status_broadcaster
+
+    broadcaster = get_status_broadcaster()
+
+    # Status cache lives on the broadcaster (still consumed by
+    # ``StatusBroadcaster.get_android_status()`` + the WS-connect
+    # initial-status snapshot). Plugin owns the SHAPE of the cache.
+    payload: Dict[str, Any] = {
+        "connected": connected,
+        "paired": paired,
+        "device_id": device_id,
+        "device_name": device_name,
+        "connected_devices": list(connected_devices or []),
+        "connection_type": connection_type,
+        "qr_data": qr_data,
+        "session_token": session_token,
+    }
+    broadcaster._status["android"] = payload
+
+    event = android_connection_status(
+        connected=connected,
+        paired=paired,
+        device_id=device_id,
+        device_name=device_name,
+        connected_devices=connected_devices,
+        connection_type=connection_type,
+        qr_data=qr_data,
+        session_token=session_token,
+    )
+    await broadcaster.broadcast(
+        {
+            "type": _TYPED_WIRE_KEY,
+            "data": event.model_dump(mode="json"),
+        }
+    )
+
+
+__all__ = [
+    "android_connection_status",
+    "broadcast_android_status",
+]

package/server/nodes/android/_handlers.py

@@ -29,6 +29,12 @@ from services.status_broadcaster import get_status_broadcaster
 logger = get_logger(__name__)
 
 
+async def handle_get_android_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get Android connection status (Wave 13.9 — moved from routers/websocket.py)."""
+    broadcaster = get_status_broadcaster()
+    return {"type": "android_status", "data": broadcaster.get_android_status()}
+
+
 async def handle_get_android_devices(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
     """Get list of connected Android devices."""
     from services.plugin.deps import get_android_service
@@ -49,16 +55,16 @@ async def handle_execute_android_action(data: Dict[str, Any], websocket: WebSock
 
     await broadcaster.update_node_status(node_id, "executing")
     result = await android_service.execute_service(
-        node_id=node_id, service_id=service_id, action=action,
+        node_id=node_id,
+        service_id=service_id,
+        action=action,
         parameters=data.get("parameters", {}),
         android_host=data.get("android_host", "localhost"),
-        android_port=data.get("android_port", 8888)
+        android_port=data.get("android_port", 8888),
     )
 
     status = "success" if result.get("success") else "error"
-    await broadcaster.update_node_status(
-        node_id, status, result.get("result") or {"error": result.get("error")}
-    )
+    await broadcaster.update_node_status(node_id, status, result.get("result") or {"error": result.get("error")})
     return result
 
 
@@ -84,8 +90,7 @@ async def handle_android_relay_connect(data: Dict[str, Any], websocket: WebSocke
     client, error = await get_relay_client(url, api_key)
     if client:
         logger.info(
-            f"[WebSocket] Android relay connect success, qr_data present: "
-            f"{bool(client.qr_data)}, session_token: {client.session_token}"
+            f"[WebSocket] Android relay connect success, qr_data present: " f"{bool(client.qr_data)}, session_token: {client.session_token}"
         )
         return {
             "success": True,
@@ -146,6 +151,7 @@ async def handle_android_relay_reconnect(data: Dict[str, Any], websocket: WebSoc
 
 
 WS_HANDLERS = {
+    "get_android_status": handle_get_android_status,
     "get_android_devices": handle_get_android_devices,
     "execute_android_action": handle_execute_android_action,
     "android_relay_connect": handle_android_relay_connect,

package/server/nodes/android/_option_loaders.py

@@ -36,9 +36,6 @@ async def load_service_actions(params: Dict[str, Any]) -> List[Dict[str, Any]]:
 
         android_svc = get_android_service()
         actions = await android_svc.list_actions(service_id)  # type: ignore[attr-defined]
-        return [
-            {"value": a, "label": a.replace("_", " ").title()}
-            for a in actions or []
-        ]
+        return [{"value": a, "label": a.replace("_", " ").title()} for a in actions or []]
     except Exception:
         return []

package/server/nodes/android/_refresh.py

@@ -37,27 +37,27 @@ async def refresh_android_status(broadcaster: "StatusBroadcaster") -> None:
 
 
 async def _auto_reconnect_body(broadcaster: "StatusBroadcaster", span) -> None:
+    # Single source of truth for android status emission — owns both
+    # the cache update + the dual-emit (legacy raw + typed sibling).
+    from ._events import broadcast_android_status
+
     try:
         # Already connected? Refresh the cached snapshot and stop.
         from ._relay.manager import get_current_relay_client
 
         existing = get_current_relay_client()
         if existing and existing.is_connected():
-            broadcaster._status["android"] = {
-                "connected": True,
-                "paired": existing.is_paired(),
-                "device_id": existing.paired_device_id,
-                "device_name": existing.paired_device_name,
-                "connected_devices": list(existing.get_connected_devices()),
-                "connection_type": "relay",
-                "qr_data": existing.qr_data,
-                "session_token": existing.session_token,
-            }
+            await broadcast_android_status(
+                connected=True,
+                paired=existing.is_paired(),
+                device_id=existing.paired_device_id,
+                device_name=existing.paired_device_name,
+                connected_devices=list(existing.get_connected_devices()),
+                connection_type="relay",
+                qr_data=existing.qr_data,
+                session_token=existing.session_token,
+            )
             logger.debug("[StatusBroadcaster] Android relay already connected")
-            await broadcaster.broadcast({
-                "type": "android_status",
-                "data": broadcaster._status["android"],
-            })
             span.set_attribute("path", "already_connected")
             return
 
@@ -77,9 +77,7 @@ async def _auto_reconnect_body(broadcaster: "StatusBroadcaster", span) -> None:
 
         if not relay_url or not api_key:
             span.set_attribute("path", "session_missing_creds")
-            logger.debug(
-                "[StatusBroadcaster] Stored session missing relay URL or API key"
-            )
+            logger.debug("[StatusBroadcaster] Stored session missing relay URL or API key")
             return
 
         span.set_attribute("path", "auto_reconnect")
@@ -98,30 +96,22 @@ async def _auto_reconnect_body(broadcaster: "StatusBroadcaster", span) -> None:
             # The relay server creates a new session on each connect, so
             # pairing may be lost -- mirror whatever the new client
             # reports.
-            broadcaster._status["android"] = {
-                "connected": True,
-                "paired": client.is_paired(),
-                "device_id": client.paired_device_id,
-                "device_name": client.paired_device_name,
-                "connected_devices": list(client.get_connected_devices()),
-                "connection_type": "relay",
-                "qr_data": client.qr_data,
-                "session_token": client.session_token,
-            }
-            await broadcaster.broadcast({
-                "type": "android_status",
-                "data": broadcaster._status["android"],
-            })
+            await broadcast_android_status(
+                connected=True,
+                paired=client.is_paired(),
+                device_id=client.paired_device_id,
+                device_name=client.paired_device_name,
+                connected_devices=list(client.get_connected_devices()),
+                connection_type="relay",
+                qr_data=client.qr_data,
+                session_token=client.session_token,
+            )
             span.set_attribute("reconnect_ok", True)
         else:
             span.set_attribute("reconnect_ok", False)
-            logger.warning(
-                "[StatusBroadcaster] Failed to reconnect Android relay: %s", error
-            )
+            logger.warning("[StatusBroadcaster] Failed to reconnect Android relay: %s", error)
             # Stored session is stale; drop it.
             await database.clear_android_relay_session()
     except Exception as exc:  # noqa: BLE001 -- mirror pre-migration behaviour
         span.record_exception(exc)
-        logger.debug(
-            "[StatusBroadcaster] Could not auto-reconnect Android relay: %s", exc
-        )
+        logger.debug("[StatusBroadcaster] Could not auto-reconnect Android relay: %s", exc)

package/server/nodes/android/_relay/broadcaster.py

@@ -1,39 +1,37 @@
 """
 Android Status Broadcaster
 
-Broadcasts Android relay connection status changes to frontend WebSocket clients.
+Relay-specific helpers that translate relay-shaped arguments
+(``devices: Set[str]``, derived ``connection_type="relay"``) into the
+canonical :func:`nodes.android.broadcast_android_status` shape. Wave 12
+B1 — the actual broadcast emission moved into
+:mod:`nodes.android._events` (plugin-owned). This file just adapts
+relay-state to that shape.
 """
+
 from typing import Optional, Set
 import structlog
 
 logger = structlog.get_logger()
 
 
-async def broadcast_android_status(
+async def _emit_relay_status(
     connected: bool,
     paired: bool = False,
     device_id: Optional[str] = None,
     device_name: Optional[str] = None,
     devices: Optional[Set[str]] = None,
     qr_data: Optional[str] = None,
-    session_token: Optional[str] = None
+    session_token: Optional[str] = None,
 ):
-    """
-    Broadcast Android relay status changes to frontend WebSocket clients.
-
-    Args:
-        connected: Whether connected to relay server
-        paired: Whether paired with Android device
-        device_id: Paired device ID (if any)
-        device_name: Paired device name (if any)
-        devices: Set of all connected device IDs
-        qr_data: QR code data for pairing (app://pair?token=...)
-        session_token: Relay session token
-    """
+    """Translate relay-shaped args and route to the canonical
+    plugin-owned broadcaster (``nodes.android._events``)."""
     try:
-        from services.status_broadcaster import get_status_broadcaster
-        broadcaster = get_status_broadcaster()
-        await broadcaster.update_android_status(
+        # Import from the plugin package — single source of truth
+        # for the android status wire format (Wave 12 B1).
+        from nodes.android import broadcast_android_status
+
+        await broadcast_android_status(
             connected=connected,
             paired=paired,
             device_id=device_id,
@@ -41,7 +39,7 @@ async def broadcast_android_status(
             connected_devices=list(devices) if devices else [],
             connection_type="relay" if connected else None,
             qr_data=qr_data,
-            session_token=session_token
+            session_token=session_token,
         )
     except Exception as e:
         logger.warning("[Android] Failed to broadcast status", error=str(e))
@@ -49,20 +47,12 @@ async def broadcast_android_status(
 
 async def broadcast_connected(device_id: str, device_name: Optional[str] = None):
     """Broadcast that Android device is paired"""
-    await broadcast_android_status(
-        connected=True,
-        paired=True,
-        device_id=device_id,
-        device_name=device_name,
-        devices={device_id} if device_id else set()
+    await _emit_relay_status(
+        connected=True, paired=True, device_id=device_id, device_name=device_name, devices={device_id} if device_id else set()
     )
 
 
-async def broadcast_device_disconnected(
-    relay_connected: bool = True,
-    qr_data: Optional[str] = None,
-    session_token: Optional[str] = None
-):
+async def broadcast_device_disconnected(relay_connected: bool = True, qr_data: Optional[str] = None, session_token: Optional[str] = None):
     """Broadcast that Android device is disconnected (but relay may still be connected).
 
     This is called when the Android device unpairs. The relay connection may still be active.
@@ -73,26 +63,20 @@ async def broadcast_device_disconnected(
         qr_data: QR code data for re-pairing
         session_token: Current session token
     """
-    await broadcast_android_status(
+    await _emit_relay_status(
         connected=relay_connected,  # Relay may still be connected
         paired=False,  # Device is disconnected
         device_id=None,
         device_name=None,
         devices=set(),
         qr_data=qr_data,  # Keep QR data for re-pairing
-        session_token=session_token
+        session_token=session_token,
     )
 
 
 async def broadcast_relay_disconnected():
     """Broadcast that relay connection is closed (fully disconnected)"""
-    await broadcast_android_status(
-        connected=False,
-        paired=False,
-        device_id=None,
-        device_name=None,
-        devices=set()
-    )
+    await _emit_relay_status(connected=False, paired=False, device_id=None, device_name=None, devices=set())
 
 
 # Legacy alias for backwards compatibility
@@ -103,12 +87,12 @@ async def broadcast_disconnected():
 
 async def broadcast_qr_code(qr_data: str, session_token: Optional[str] = None):
     """Broadcast QR code for pairing"""
-    await broadcast_android_status(
+    await _emit_relay_status(
         connected=True,  # Connected to relay but not paired
         paired=False,
         device_id=None,
         device_name=None,
         devices=set(),
         qr_data=qr_data,
-        session_token=session_token
+        session_token=session_token,
     )

package/server/nodes/android/_relay/client.py

@@ -10,6 +10,7 @@ Connection flow:
 4. Receive pairing.connected when Android pairs
 5. Exchange messages via relay.send / relay.message
 """
+
 import asyncio
 import json
 import uuid
@@ -18,12 +19,7 @@ from typing import Optional, Dict, Any, Set, Callable
 import structlog
 
 from .protocol import RPCResponse, RPCRequestTracker, is_response
-from .broadcaster import (
-    broadcast_connected,
-    broadcast_device_disconnected,
-    broadcast_relay_disconnected,
-    broadcast_qr_code
-)
+from .broadcaster import broadcast_connected, broadcast_device_disconnected, broadcast_relay_disconnected, broadcast_qr_code
 
 logger = structlog.get_logger()
 
@@ -90,7 +86,7 @@ class RelayWebSocketClient:
                 self.url,
                 heartbeat=30,
                 autoping=True,
-                ssl=True  # Explicit SSL for wss://
+                ssl=True,  # Explicit SSL for wss://
             )
             self.connected = True
             self._running = True
@@ -111,9 +107,7 @@ class RelayWebSocketClient:
                     self.session_token = params.get("session_token")
                     self.qr_data = params.get("qr_data")
 
-                    logger.info("[Relay] Connection established",
-                               session_token=self.session_token,
-                               has_qr=bool(self.qr_data))
+                    logger.info("[Relay] Connection established", session_token=self.session_token, has_qr=bool(self.qr_data))
 
                     # Broadcast QR data to frontend
                     if self.qr_data:
@@ -208,6 +202,7 @@ class RelayWebSocketClient:
         """Clear stored pairing session from database."""
         try:
             from services.plugin.deps import get_database
+
             database = get_database()
 
             await database.clear_android_relay_session()
@@ -277,11 +272,7 @@ class RelayWebSocketClient:
                 await asyncio.sleep(25)
                 if self._running and self.ws and not self.ws.closed:
                     try:
-                        await self.ws.send_json({
-                            "jsonrpc": "2.0",
-                            "method": "ping",
-                            "params": {}
-                        })
+                        await self.ws.send_json({"jsonrpc": "2.0", "method": "ping", "params": {}})
                     except Exception as e:
                         logger.error("[Relay] Keepalive error", error=str(e))
                         self._running = False
@@ -335,9 +326,7 @@ class RelayWebSocketClient:
         self.paired_device_id = params.get("device_id")
         self.paired_device_name = params.get("device_name")
 
-        logger.info("[Relay] Android paired",
-                   device_id=self.paired_device_id,
-                   device_name=self.paired_device_name)
+        logger.info("[Relay] Android paired", device_id=self.paired_device_id, device_name=self.paired_device_name)
 
         await broadcast_connected(self.paired_device_id, self.paired_device_name)
 
@@ -353,9 +342,9 @@ class RelayWebSocketClient:
         self.paired_device_id = params.get("device_id")
         self.paired_device_name = params.get("device_name")
 
-        logger.info("[Relay] Android pairing restored (auto-reconnect)",
-                   device_id=self.paired_device_id,
-                   device_name=self.paired_device_name)
+        logger.info(
+            "[Relay] Android pairing restored (auto-reconnect)", device_id=self.paired_device_id, device_name=self.paired_device_name
+        )
 
         await broadcast_connected(self.paired_device_id, self.paired_device_name)
 
@@ -369,6 +358,7 @@ class RelayWebSocketClient:
         """Save pairing session to database for auto-reconnect."""
         try:
             from services.plugin.deps import get_database
+
             database = get_database()
 
             await database.save_android_relay_session(
@@ -376,7 +366,7 @@ class RelayWebSocketClient:
                 api_key=self.api_key,
                 device_id=self.paired_device_id,
                 device_name=self.paired_device_name,
-                session_token=self.session_token
+                session_token=self.session_token,
             )
             logger.debug("[Relay] Pairing session saved for auto-reconnect")
         except Exception as e:
@@ -396,11 +386,7 @@ class RelayWebSocketClient:
         self.paired_device_name = None
 
         # Broadcast device disconnection - relay is still connected, pass QR data for re-pairing
-        await broadcast_device_disconnected(
-            relay_connected=self.is_connected(),
-            qr_data=self.qr_data,
-            session_token=self.session_token
-        )
+        await broadcast_device_disconnected(relay_connected=self.is_connected(), qr_data=self.qr_data, session_token=self.session_token)
 
         if self.on_pairing_disconnected:
             await self.on_pairing_disconnected(params)
@@ -414,8 +400,7 @@ class RelayWebSocketClient:
         # Schema: params = {"data": {...}}
         data = params.get("data", {})
 
-        logger.debug("[Relay] relay.message received",
-                   data_keys=list(data.keys()) if isinstance(data, dict) else "not_dict")
+        logger.debug("[Relay] relay.message received", data_keys=list(data.keys()) if isinstance(data, dict) else "not_dict")
 
         # Route to service response queue if matching request_id
         # Android app uses "request_id" (underscore), not "requestId" (camelCase)
@@ -505,7 +490,7 @@ class RelayWebSocketClient:
         action: str,
         parameters: Dict[str, Any] = None,
         target_id: Optional[str] = None,  # Ignored, kept for compatibility
-        timeout: float = 30.0
+        timeout: float = 30.0,
     ) -> Optional[Dict[str, Any]]:
         """
         Send service request to paired Android device.
@@ -535,17 +520,11 @@ class RelayWebSocketClient:
             # - action
             # - request_id (not requestId)
             # - params (not parameters)
-            await self.relay_send({
-                "service": service_id,
-                "action": action,
-                "request_id": request_id,
-                "params": parameters or {}
-            }, timeout=5.0)
-
-            logger.debug("[Relay] Sent service request",
-                       request_id=request_id,
-                       service_id=service_id,
-                       action=action)
+            await self.relay_send(
+                {"service": service_id, "action": action, "request_id": request_id, "params": parameters or {}}, timeout=5.0
+            )
+
+            logger.debug("[Relay] Sent service request", request_id=request_id, service_id=service_id, action=action)
 
             # Wait for response
             logger.debug("[Relay] Waiting for response", request_id=request_id, timeout=timeout)
@@ -554,7 +533,9 @@ class RelayWebSocketClient:
             return response
 
         except asyncio.TimeoutError:
-            logger.warning("[Relay] Service response timeout", request_id=request_id, timeout=timeout, pending_queues=list(self._service_queues.keys()))
+            logger.warning(
+                "[Relay] Service response timeout", request_id=request_id, timeout=timeout, pending_queues=list(self._service_queues.keys())
+            )
             return None
         except Exception as e:
             logger.error("[Relay] Service request error", error=str(e))

package/server/nodes/android/_relay/manager.py

@@ -4,6 +4,7 @@ Android Relay Client Manager
 Global instance management for persistent WebSocket connection.
 Provides singleton pattern for reusing connection across API requests.
 """
+
 from typing import Optional
 import structlog
 

package/server/nodes/android/_relay/protocol.py

@@ -15,6 +15,7 @@ Error codes:
 - -32002: Pairing failed
 - -32003: Relay error
 """
+
 import asyncio
 from dataclasses import dataclass, field
 from typing import Dict, Any, Optional
@@ -23,6 +24,7 @@ from enum import Enum
 
 class RPCErrorCode(Enum):
     """JSON-RPC 2.0 error codes"""
+
     INVALID_REQUEST = -32600
     METHOD_NOT_FOUND = -32601
     INVALID_PARAMS = -32602
@@ -34,6 +36,7 @@ class RPCErrorCode(Enum):
 @dataclass
 class RPCRequest:
     """JSON-RPC 2.0 request"""
+
     method: str
     params: Dict[str, Any] = field(default_factory=dict)
     id: Optional[int] = None
@@ -52,6 +55,7 @@ class RPCRequest:
 @dataclass
 class RPCResponse:
     """JSON-RPC 2.0 response"""
+
     id: int
     result: Optional[Any] = None
     error: Optional[Dict[str, Any]] = None
@@ -72,6 +76,7 @@ class RPCResponse:
 @dataclass
 class RPCEvent:
     """JSON-RPC 2.0 server event (notification without id)"""
+
     method: str
     params: Dict[str, Any] = field(default_factory=dict)
 
@@ -142,6 +147,7 @@ class RPCRequestTracker:
 
 class RPCError(Exception):
     """JSON-RPC error"""
+
     def __init__(self, message: str, code: int = None):
         super().__init__(message)
         self.code = code