machinaos 0.0.78 → 0.0.80

package/server/nodes/google/_oauth.py

@@ -215,26 +215,34 @@ class GoogleOAuth:
         }
         self.token_uri = oauth_endpoints["token_uri"]
         self.revoke_uri = oauth_endpoints.get(
-            "revoke_uri", "https://oauth2.googleapis.com/revoke",
+            "revoke_uri",
+            "https://oauth2.googleapis.com/revoke",
         )
 
     def generate_authorization_url(
-        self, *, state_data: Optional[Dict[str, Any]] = None,
+        self,
+        *,
+        state_data: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, str]:
         """Build the Google authorization URL + register state."""
         flow = Flow.from_client_config(
-            self.client_config, scopes=self.scopes, redirect_uri=self.redirect_uri,
+            self.client_config,
+            scopes=self.scopes,
+            redirect_uri=self.redirect_uri,
         )
         authorization_url, state = flow.authorization_url(
             access_type="offline",
             include_granted_scopes="true",
             prompt="consent",  # force consent to get refresh token
         )
-        self.state_store.put(state, {
-            "data": state_data or {"mode": "owner"},
-            "redirect_uri": self.redirect_uri,
-            "code_verifier": getattr(flow, "code_verifier", None),
-        })
+        self.state_store.put(
+            state,
+            {
+                "data": state_data or {"mode": "owner"},
+                "redirect_uri": self.redirect_uri,
+                "code_verifier": getattr(flow, "code_verifier", None),
+            },
+        )
         return {"url": authorization_url, "state": state}
 
     async def exchange_code(self, code: str, state: str) -> Dict[str, Any]:
@@ -302,11 +310,16 @@ class GoogleOAuth:
         """Async wrapper around :meth:`refresh_credentials`."""
         return await asyncio.to_thread(
             self.refresh_credentials,
-            refresh_token, self.client_id, self.client_secret, self.token_uri,
+            refresh_token,
+            self.client_id,
+            self.client_secret,
+            self.token_uri,
         )
 
     async def revoke_token(
-        self, token: str, token_type: str = "access_token",
+        self,
+        token: str,
+        token_type: str = "access_token",
     ) -> Dict[str, Any]:
         """Best-effort token revocation via Google's revoke endpoint."""
         try:
@@ -324,7 +337,8 @@ class GoogleOAuth:
         return {
             "success": False,
             "error": (response.json() if response.text else {}).get(
-                "error_description", "Revocation failed",
+                "error_description",
+                "Revocation failed",
             ),
         }
 

package/server/nodes/google/_option_loaders.py

@@ -24,9 +24,7 @@ async def _google_service(api: str, version: str, params: Dict[str, Any]):
     """Build a googleapiclient service under the right OAuth 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)
-    )
+    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]]:
@@ -34,9 +32,7 @@ async def load_gmail_labels(params: Dict[str, Any]) -> List[Dict[str, Any]]:
     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()
-    )
+    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(
@@ -45,24 +41,17 @@ async def load_gmail_labels(params: Dict[str, Any]) -> List[Dict[str, Any]]:
             (label.get("name") or "").lower(),
         )
     )
-    return [
-        {"value": label["id"], "label": label.get("name") or label["id"]}
-        for label in labels
-    ]
+    return [{"value": label["id"], "label": label.get("name") or label["id"]} for label in labels]
 
 
 async def load_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()
-    )
+    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())
-    )
+    entries.sort(key=lambda c: (not c.get("primary", False), (c.get("summary") or "").lower()))
     return [
         {
             "value": c.get("id", ""),
@@ -80,28 +69,18 @@ async def load_drive_folders(params: Dict[str, Any]) -> List[Dict[str, Any]]:
     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(),
+        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
-    ]
+    return [{"value": f.get("id", ""), "label": f.get("name") or f.get("id", "")} for f in folders]
 
 
 async def load_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()
-    )
+    response = await loop.run_in_executor(None, lambda: service.tasklists().list().execute())
     lists = response.get("items", [])
     lists.sort(key=lambda label: (label.get("title") or "").lower())
-    return [
-        {"value": label.get("id", ""), "label": label.get("title") or label.get("id", "")}
-        for label in lists
-    ]
+    return [{"value": label.get("id", ""), "label": label.get("title") or label.get("id", "")} for label in lists]

package/server/nodes/google/_refresh.py

@@ -32,9 +32,7 @@ async def refresh_google_status(broadcaster: "StatusBroadcaster") -> None:
             from services.plugin.deps import get_auth_service
 
             auth_service = get_auth_service()
-            tokens = await auth_service.get_oauth_tokens(
-                "google", customer_id="owner"
-            )
+            tokens = await auth_service.get_oauth_tokens("google", customer_id="owner")
             if not tokens or not tokens.get("access_token"):
                 broadcaster._status["google"] = {
                     "connected": False,
@@ -52,15 +50,13 @@ async def refresh_google_status(broadcaster: "StatusBroadcaster") -> None:
                     tokens.get("email"),
                 )
 
-            await broadcaster.broadcast({
-                "type": "google_status",
-                "data": broadcaster._status["google"],
-            })
-            span.set_attribute(
-                "connected", bool(broadcaster._status["google"]["connected"])
+            await broadcaster.broadcast(
+                {
+                    "type": "google_status",
+                    "data": broadcaster._status["google"],
+                }
             )
+            span.set_attribute("connected", bool(broadcaster._status["google"]["connected"]))
         except Exception as exc:  # noqa: BLE001
             span.record_exception(exc)
-            logger.debug(
-                "[StatusBroadcaster] Could not refresh Google status: %s", exc
-            )
+            logger.debug("[StatusBroadcaster] Could not refresh Google status: %s", exc)

package/server/nodes/google/_router.py

@@ -60,10 +60,7 @@ async def _customer_mode_handler(
 
     overrides: Dict[str, Any] = {"customer_id": customer_id}
     if redirect_after:
-        overrides["redirect_after"] = (
-            f"{redirect_after}?google_connected=true"
-            f"&customer={customer_id}&email={email}"
-        )
+        overrides["redirect_after"] = f"{redirect_after}?google_connected=true" f"&customer={customer_id}&email={email}"
     return overrides
 
 
@@ -82,7 +79,9 @@ router: APIRouter = make_oauth_callback_router(
 
 @router.post("/customer-auth-url")
 async def generate_customer_auth_url(
-    request: Request, customer_id: str, redirect_after: Optional[str] = None,
+    request: Request,
+    customer_id: str,
+    redirect_after: Optional[str] = None,
 ):
     """Generate OAuth URL for a customer to connect their Google account."""
     from services.oauth_utils import get_redirect_uri

package/server/nodes/google/{calendar.py → calendar/__init__.py}

@@ -9,9 +9,9 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
 
-from ._credentials import GoogleCredential
+from .._credentials import GoogleCredential
 
-from ._base import build_google_service, run_sync, track_google_usage
+from .._base import build_google_service, run_sync, track_google_usage
 
 
 _CREATE = {"displayOptions": {"show": {"operation": ["create"]}}}
@@ -47,7 +47,8 @@ class CalendarParams(BaseModel):
 
     # Update + delete
     send_updates: Literal["all", "externalOnly", "none"] = Field(
-        default="all", json_schema_extra=_UPDATE_OR_DELETE,
+        default="all",
+        json_schema_extra=_UPDATE_OR_DELETE,
     )
 
     # Update-only fields
@@ -81,7 +82,11 @@ class CalendarOutput(BaseModel):
 def _iso_or_shortcut(value: Optional[str], default_offset_days: int = 0) -> str:
     now = datetime.utcnow()
     if not value or value.lower() == "today":
-        base = now.replace(hour=0, minute=0, second=0, microsecond=0) if default_offset_days == 0 else now + timedelta(days=default_offset_days)
+        base = (
+            now.replace(hour=0, minute=0, second=0, microsecond=0)
+            if default_offset_days == 0
+            else now + timedelta(days=default_offset_days)
+        )
         return base.isoformat() + "Z"
     if value.startswith("today+"):
         days = int(value.replace("today+", "").replace("d", ""))
@@ -96,11 +101,11 @@ class CalendarNode(ActionNode):
     group = ("google", "tool")
     description = "Google Calendar create / list / update / delete events"
     component_kind = "square"
+    tool_name = "google_calendar"
+    tool_description = "Manage Google Calendar events. Operations: create (new event), list (events in date range), update (modify event), delete (remove event)."
     handles = (
-        {"name": "input-main", "kind": "input", "position": "left",
-         "label": "Input", "role": "main"},
-        {"name": "output-main", "kind": "output", "position": "right",
-         "label": "Output", "role": "main"},
+        {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+        {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
     )
     annotations = {"destructive": False, "readonly": False, "open_world": True}
     credentials = (GoogleCredential,)
@@ -124,37 +129,41 @@ class CalendarNode(ActionNode):
                 raise RuntimeError("Start time and end time are required")
 
             event = {
-                'summary': params.title,
-                'start': {'dateTime': params.start_time, 'timeZone': params.timezone},
-                'end': {'dateTime': params.end_time, 'timeZone': params.timezone},
+                "summary": params.title,
+                "start": {"dateTime": params.start_time, "timeZone": params.timezone},
+                "end": {"dateTime": params.end_time, "timeZone": params.timezone},
             }
             if params.description:
-                event['description'] = params.description
+                event["description"] = params.description
             if params.location:
-                event['location'] = params.location
+                event["location"] = params.location
             if params.attendees:
-                att = [{'email': e.strip()} for e in params.attendees.split(',') if e.strip()]
+                att = [{"email": e.strip()} for e in params.attendees.split(",") if e.strip()]
                 if att:
-                    event['attendees'] = att
+                    event["attendees"] = att
             if params.reminder_minutes:
-                event['reminders'] = {
-                    'useDefault': False,
-                    'overrides': [{'method': 'popup', 'minutes': int(params.reminder_minutes)}],
+                event["reminders"] = {
+                    "useDefault": False,
+                    "overrides": [{"method": "popup", "minutes": int(params.reminder_minutes)}],
                 }
 
-            result = await run_sync(lambda: events_svc.insert(
-                calendarId=cal_id, body=event, sendUpdates=params.send_updates,
-            ).execute())
+            result = await run_sync(
+                lambda: events_svc.insert(
+                    calendarId=cal_id,
+                    body=event,
+                    sendUpdates=params.send_updates,
+                ).execute()
+            )
             await track_google_usage("google_calendar", ctx.node_id, "create", 1, ctx.raw)
             return CalendarOutput(
                 operation="create",
-                event_id=result.get('id'),
-                title=result.get('summary'),
-                start=result.get('start', {}).get('dateTime'),
-                end=result.get('end', {}).get('dateTime'),
-                html_link=result.get('htmlLink'),
-                status=result.get('status'),
-                created=result.get('created'),
+                event_id=result.get("id"),
+                title=result.get("summary"),
+                start=result.get("start", {}).get("dateTime"),
+                end=result.get("end", {}).get("dateTime"),
+                html_link=result.get("htmlLink"),
+                status=result.get("status"),
+                created=result.get("created"),
             )
 
         if op == "list":
@@ -162,25 +171,31 @@ class CalendarNode(ActionNode):
             time_max = _iso_or_shortcut(params.end_date, default_offset_days=7)
             single = params.single_events
             kwargs = dict(
-                calendarId=cal_id, timeMin=time_min, timeMax=time_max,
-                maxResults=min(params.max_results, 250), singleEvents=single,
+                calendarId=cal_id,
+                timeMin=time_min,
+                timeMax=time_max,
+                maxResults=min(params.max_results, 250),
+                singleEvents=single,
             )
             if single:
-                kwargs['orderBy'] = params.order_by
+                kwargs["orderBy"] = params.order_by
 
             result = await run_sync(lambda: events_svc.list(**kwargs).execute())
-            raw = result.get('items', [])
-            formatted = [{
-                "event_id": e.get('id'),
-                "title": e.get('summary', 'No Title'),
-                "start": e.get('start', {}).get('dateTime', e.get('start', {}).get('date')),
-                "end": e.get('end', {}).get('dateTime', e.get('end', {}).get('date')),
-                "description": e.get('description', ''),
-                "location": e.get('location', ''),
-                "status": e.get('status'),
-                "html_link": e.get('htmlLink'),
-                "attendees": [a.get('email') for a in e.get('attendees', [])],
-            } for e in raw]
+            raw = result.get("items", [])
+            formatted = [
+                {
+                    "event_id": e.get("id"),
+                    "title": e.get("summary", "No Title"),
+                    "start": e.get("start", {}).get("dateTime", e.get("start", {}).get("date")),
+                    "end": e.get("end", {}).get("dateTime", e.get("end", {}).get("date")),
+                    "description": e.get("description", ""),
+                    "location": e.get("location", ""),
+                    "status": e.get("status"),
+                    "html_link": e.get("htmlLink"),
+                    "attendees": [a.get("email") for a in e.get("attendees", [])],
+                }
+                for e in raw
+            ]
             await track_google_usage("google_calendar", ctx.node_id, "list", len(formatted), ctx.raw)
             return CalendarOutput(
                 operation="list",
@@ -194,9 +209,13 @@ class CalendarNode(ActionNode):
                 raise RuntimeError("Event ID is required")
 
             if op == "delete":
-                await run_sync(lambda: events_svc.delete(
-                    calendarId=cal_id, eventId=params.event_id, sendUpdates=params.send_updates,
-                ).execute())
+                await run_sync(
+                    lambda: events_svc.delete(
+                        calendarId=cal_id,
+                        eventId=params.event_id,
+                        sendUpdates=params.send_updates,
+                    ).execute()
+                )
                 await track_google_usage("google_calendar", ctx.node_id, "delete", 1, ctx.raw)
                 return CalendarOutput(operation="delete", deleted=True, event_id=params.event_id)
 
@@ -208,31 +227,35 @@ class CalendarNode(ActionNode):
             loc = params.update_location if params.update_location is not None else params.location
 
             if title:
-                event['summary'] = title
+                event["summary"] = title
             if start:
-                tz = event.get('start', {}).get('timeZone', 'UTC')
-                event['start'] = {'dateTime': start, 'timeZone': tz}
+                tz = event.get("start", {}).get("timeZone", "UTC")
+                event["start"] = {"dateTime": start, "timeZone": tz}
             if end:
-                tz = event.get('end', {}).get('timeZone', 'UTC')
-                event['end'] = {'dateTime': end, 'timeZone': tz}
+                tz = event.get("end", {}).get("timeZone", "UTC")
+                event["end"] = {"dateTime": end, "timeZone": tz}
             if desc is not None:
-                event['description'] = desc
+                event["description"] = desc
             if loc is not None:
-                event['location'] = loc
-
-            result = await run_sync(lambda: events_svc.update(
-                calendarId=cal_id, eventId=params.event_id, body=event,
-                sendUpdates=params.send_updates,
-            ).execute())
+                event["location"] = loc
+
+            result = await run_sync(
+                lambda: events_svc.update(
+                    calendarId=cal_id,
+                    eventId=params.event_id,
+                    body=event,
+                    sendUpdates=params.send_updates,
+                ).execute()
+            )
             await track_google_usage("google_calendar", ctx.node_id, "update", 1, ctx.raw)
             return CalendarOutput(
                 operation="update",
-                event_id=result.get('id'),
-                title=result.get('summary'),
-                start=result.get('start', {}).get('dateTime'),
-                end=result.get('end', {}).get('dateTime'),
-                updated=result.get('updated'),
-                html_link=result.get('htmlLink'),
+                event_id=result.get("id"),
+                title=result.get("summary"),
+                start=result.get("start", {}).get("dateTime"),
+                end=result.get("end", {}).get("dateTime"),
+                updated=result.get("updated"),
+                html_link=result.get("htmlLink"),
             )
 
         raise RuntimeError(f"Unknown Calendar operation: {op}")

package/server/nodes/google/calendar/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#4285F4"
+}