machinaos 0.0.76 → 0.0.78

package/server/services/node_option_loaders/__init__.py

@@ -1,77 +0,0 @@
-"""Generic loadOptionsMethod dispatch registry.
-
-Wave 6 Phase 4. Generalises the WhatsApp-only dynamic-options pattern
-to a registry mirroring services/node_executor._build_handler_registry().
-
-The editor calls a single endpoint:
-
-    POST /api/nodes/options/{method}
-
-with body ``{"node_type": "...", "params": {...}}`` and the dispatcher
-looks up the registered async loader, invokes it, and returns the
-resulting ``[{"value": ..., "label": ...}]`` list. WS mirror at
-``load_options`` matches the Wave 3 handler convention.
-
-Registering a new dynamic-option loader: define an async function in
-its own module under this package, import it here, and add the entry
-to ``LOAD_OPTIONS_REGISTRY``. No frontend change needed - the
-``loadOptionsMethod`` string in the Pydantic ``Field(json_schema_extra=)``
-is what wires it through.
-"""
-
-from typing import Any, Awaitable, Callable, Optional
-
-from .android_loaders import load_android_service_actions
-from .google_loaders import (
-    load_gmail_labels,
-    load_google_calendar_list,
-    load_google_drive_folders,
-    load_google_tasklists,
-)
-from .whatsapp_loaders import (
-    load_whatsapp_channels,
-    load_whatsapp_group_members,
-    load_whatsapp_groups,
-)
-
-
-# Async loader signature: (params: dict) -> list of {value, label, ...}
-LoadOptionsFn = Callable[[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
-
-
-LOAD_OPTIONS_REGISTRY: dict[str, LoadOptionsFn] = {
-    # WhatsApp - groups, channels, group members.
-    "whatsappGroups": load_whatsapp_groups,
-    "whatsappChannels": load_whatsapp_channels,
-    "whatsappGroupMembers": load_whatsapp_group_members,
-    # Google Workspace - Gmail labels, Calendar list, Drive folders, Tasks lists.
-    "gmailLabels": load_gmail_labels,
-    "googleCalendarList": load_google_calendar_list,
-    "googleDriveFolders": load_google_drive_folders,
-    "googleTasklists": load_google_tasklists,
-    # Android - service actions enum loaded from the connected bridge.
-    "getAndroidServiceActions": load_android_service_actions,
-}
-
-
-async def dispatch_load_options(
-    method: str, params: Optional[dict[str, Any]] = None
-) -> list[dict[str, Any]]:
-    """Look up and invoke a registered loader.
-
-    Returns an empty list when the method isn't registered (matches
-    n8n's tolerant fallback - the dropdown stays empty rather than
-    erroring out)."""
-
-    loader = LOAD_OPTIONS_REGISTRY.get(method)
-    if loader is None:
-        return []
-    return await loader(params or {})
-
-
-def list_load_options_methods() -> list[str]:
-    """Stable alphabetised list of registered method names. The editor
-    prefetches this once on boot so it knows which ``loadOptionsMethod``
-    values are wired."""
-
-    return sorted(LOAD_OPTIONS_REGISTRY.keys())

package/server/services/node_option_loaders/android_loaders.py

@@ -1,55 +0,0 @@
-"""Android dynamic option loaders.
-
-Returns the list of actions supported by each Android service node.
-The frontend passes ``node_type`` in params; the loader maps it to the
-service's ``action`` enum advertised by the running Android bridge.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-async def load_android_service_actions(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """Return ``[{value, label}]`` for the given Android service node.
-
-    Kept minimal — each service's `execute_action` endpoint validates
-    the action at call time; the dropdown is convenience UX, not a
-    correctness boundary. The frontend falls back to a free-text input
-    if the loader returns an empty list.
-    """
-    node_type = params.get("node_type") or ""
-    service_id = _ANDROID_SERVICE_MAP.get(node_type)
-    if not service_id:
-        return []
-
-    try:
-        from core.container import container
-
-        android_svc = container.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 []]
-    except Exception:
-        # Service offline / discovery failed — dropdown stays empty, user
-        # can still type the action name manually.
-        return []
-
-
-_ANDROID_SERVICE_MAP = {
-    "batteryMonitor": "battery",
-    "networkMonitor": "network",
-    "systemInfo": "system_info",
-    "location": "location",
-    "appLauncher": "app_launcher",
-    "appList": "app_list",
-    "wifiAutomation": "wifi_automation",
-    "bluetoothAutomation": "bluetooth_automation",
-    "audioAutomation": "audio_automation",
-    "deviceStateAutomation": "device_state",
-    "screenControlAutomation": "screen_control",
-    "airplaneModeControl": "airplane_mode",
-    "motionDetection": "motion_detection",
-    "environmentalSensors": "environmental_sensors",
-    "cameraControl": "camera_control",
-    "mediaControl": "media_control",
-}

package/server/services/node_option_loaders/google_loaders.py

@@ -1,97 +0,0 @@
-"""Google Workspace loadOptions adapters.
-
-Wave 6 Phase 4b. Adds dynamic-option loaders for the Gmail label
-picker and Calendar list picker. Reuses
-services/handlers/google_auth.get_google_credentials() so the OAuth
-dance is identical to the workflow-execution path.
-
-Adding more Google loaders (e.g. Drive folder picker, Sheets
-spreadsheet picker) = one async function + one entry in this file's
-exports + one line in services/node_option_loaders/__init__.py.
-"""
-
-import asyncio
-from typing import Any
-
-
-async def _google_service(api: str, version: str, params: dict[str, Any]):
-    """Build a googleapiclient service under the right OAuth credentials.
-    `params` may carry ``account_mode`` / ``customer_id`` (customer-mode
-    multi-tenant) — falls back to owner tokens otherwise."""
-
-    from googleapiclient.discovery import build
-
-    from services.handlers.google_auth import get_google_credentials
-
-    creds = await get_google_credentials(params, {})
-    loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, lambda: build(api, version, credentials=creds))
-
-
-async def load_gmail_labels(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """Gmail labels for the label-filter selector on gmailReceive and
-    gmail (search)."""
-
-    service = await _google_service("gmail", "v1", params)
-    loop = asyncio.get_event_loop()
-    response = await loop.run_in_executor(None, lambda: service.users().labels().list(userId="me").execute())
-    labels = response.get("labels", [])
-    # Stable sort: system labels alphabetical first, then user labels.
-    labels.sort(key=lambda l: (l.get("type") != "system", (l.get("name") or "").lower()))
-    return [
-        {"value": l["id"], "label": l.get("name") or l["id"]}
-        for l in labels
-    ]
-
-
-async def load_google_calendar_list(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """Calendar list for the calendarId picker on calendar CRUD."""
-
-    service = await _google_service("calendar", "v3", params)
-    loop = asyncio.get_event_loop()
-    response = await loop.run_in_executor(None, lambda: service.calendarList().list().execute())
-    entries = response.get("items", [])
-    # Primary first, rest alphabetised.
-    entries.sort(key=lambda c: (not c.get("primary", False), (c.get("summary") or "").lower()))
-    return [
-        {
-            "value": c.get("id", ""),
-            "label": c.get("summary") or c.get("id", ""),
-            "description": "Primary" if c.get("primary") else c.get("description", ""),
-        }
-        for c in entries
-    ]
-
-
-async def load_google_drive_folders(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """Drive folders for the folderId picker on drive upload/list."""
-
-    service = await _google_service("drive", "v3", params)
-    loop = asyncio.get_event_loop()
-    query = "mimeType='application/vnd.google-apps.folder' and trashed=false"
-    response = await loop.run_in_executor(
-        None,
-        lambda: service.files()
-        .list(q=query, fields="files(id, name, parents)", pageSize=200)
-        .execute(),
-    )
-    folders = response.get("files", [])
-    folders.sort(key=lambda f: (f.get("name") or "").lower())
-    return [
-        {"value": f.get("id", ""), "label": f.get("name") or f.get("id", "")}
-        for f in folders
-    ]
-
-
-async def load_google_tasklists(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """Task lists for the tasklistId picker on tasks CRUD."""
-
-    service = await _google_service("tasks", "v1", params)
-    loop = asyncio.get_event_loop()
-    response = await loop.run_in_executor(None, lambda: service.tasklists().list().execute())
-    lists = response.get("items", [])
-    lists.sort(key=lambda l: (l.get("title") or "").lower())
-    return [
-        {"value": l.get("id", ""), "label": l.get("title") or l.get("id", "")}
-        for l in lists
-    ]

package/server/services/node_option_loaders/whatsapp_loaders.py

@@ -1,69 +0,0 @@
-"""WhatsApp loadOptions adapters.
-
-Wave 6 Phase 4. Thin wrappers around the existing WhatsApp WS handlers
-that normalise the response into the unified ``[{value, label}]`` shape
-the frontend ``useLoadOptionsQuery`` consumes.
-
-Today the editor talks to ``handle_whatsapp_groups`` /
-``handle_whatsapp_newsletters`` / ``handle_whatsapp_group_info``
-directly via dedicated WS message types. These adapters expose the
-same data through the unified ``load_options`` dispatcher so the
-``loadOptionsMethod`` schema field wires straight through with no
-per-method WS handler. The legacy WS handlers stay live for back-compat.
-"""
-
-from typing import Any
-
-
-async def load_whatsapp_groups(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """List WhatsApp groups for the recipient_type='group' selector."""
-
-    from services.whatsapp_service import handle_whatsapp_groups as _wa_groups
-
-    response = await _wa_groups()
-    groups = response.get("groups", []) if isinstance(response, dict) else []
-    return [
-        {
-            "value": g.get("group_jid") or g.get("id") or "",
-            "label": g.get("name") or g.get("subject") or g.get("group_jid", ""),
-        }
-        for g in groups
-    ]
-
-
-async def load_whatsapp_channels(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """List subscribed newsletter channels for the channel_jid selector."""
-
-    from services.whatsapp_service import handle_whatsapp_newsletters as _wa_newsletters
-
-    response = await _wa_newsletters()
-    channels = response.get("newsletters", []) if isinstance(response, dict) else []
-    return [
-        {
-            "value": c.get("channel_jid") or c.get("id") or "",
-            "label": c.get("name") or c.get("channel_jid", ""),
-        }
-        for c in channels
-    ]
-
-
-async def load_whatsapp_group_members(params: dict[str, Any]) -> list[dict[str, Any]]:
-    """List members of a specific WhatsApp group for the senderNumber
-    selector. Depends on ``params['group_id']``."""
-
-    from services.whatsapp_service import handle_whatsapp_group_info as _wa_group_info
-
-    group_id = params.get("group_id") or ""
-    if not group_id:
-        return []
-    response = await _wa_group_info(group_id)
-    participants = (
-        response.get("participants", []) if isinstance(response, dict) else []
-    )
-    return [
-        {
-            "value": p.get("phone") or p.get("jid") or "",
-            "label": p.get("name") or p.get("phone") or p.get("jid", ""),
-        }
-        for p in participants
-    ]