machinaos 0.0.78 → 0.0.80

package/server/nodes/email/email_send/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#8be9fd"
+}

package/server/nodes/filesystem/_backend.py

@@ -174,11 +174,7 @@ def get_backend(
 
     param_dir = parameters.get("working_directory")
     ctx_dir = context.get("workspace_dir") if context else None
-    root = (
-        param_dir
-        or ctx_dir
-        or os.path.join(Settings().workspace_base_resolved, "default")
-    )
+    root = param_dir or ctx_dir or os.path.join(Settings().workspace_base_resolved, "default")
     os.makedirs(root, exist_ok=True)
     get_logger(__name__).info("[Filesystem] root=%s", root)
     # ``inherit_env=True`` makes the host PATH available so the agent can

package/server/nodes/filesystem/{file_modify.py → file_modify/__init__.py}

@@ -37,6 +37,10 @@ class FileModifyNode(ActionNode):
     subtitle = "Write/Edit"
     group = ("filesystem", "tool")
     description = "Write new files or edit existing files"
+    tool_name = "file_modify"
+    tool_description = (
+        "Write a new file or edit an existing file with string replacement. Operations: write (create/overwrite), edit (find and replace)."
+    )
     component_kind = "square"
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
@@ -53,7 +57,7 @@ class FileModifyNode(ActionNode):
     async def modify(self, ctx: NodeContext, params: FileModifyParams) -> Any:
         """Inlined from handlers/filesystem.py (Wave 11.D.1)."""
         import asyncio
-        from ._backend import get_backend, normalize_virtual_path
+        from .._backend import get_backend, normalize_virtual_path
 
         if not params.file_path:
             raise NodeUserError("file_path is required")
@@ -69,9 +73,7 @@ class FileModifyNode(ActionNode):
                 resolved = backend._resolve_path(file_path)
                 if resolved.exists():
                     if resolved.is_dir():
-                        raise IsADirectoryError(
-                            f"Cannot write to {file_path}: path is a directory"
-                        )
+                        raise IsADirectoryError(f"Cannot write to {file_path}: path is a directory")
                     resolved.unlink()
                 return backend.write(file_path, params.content)
 
@@ -87,7 +89,10 @@ class FileModifyNode(ActionNode):
             if not params.old_string:
                 raise NodeUserError("old_string is required for edit")
             result = await asyncio.to_thread(
-                backend.edit, file_path, params.old_string, params.new_string,
+                backend.edit,
+                file_path,
+                params.old_string,
+                params.new_string,
                 replace_all=params.replace_all,
             )
             if result.error:

package/server/nodes/filesystem/file_modify/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#8be9fd"
+}

package/server/nodes/filesystem/{file_read.py → file_read/__init__.py}

@@ -30,6 +30,8 @@ class FileReadNode(ActionNode):
     subtitle = "Read Contents"
     group = ("filesystem", "tool")
     description = "Read file contents with line numbers and pagination"
+    tool_name = "file_read"
+    tool_description = "Read file contents with pagination. Returns line-numbered text."
     component_kind = "square"
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
@@ -46,7 +48,7 @@ class FileReadNode(ActionNode):
     async def read(self, ctx: NodeContext, params: FileReadParams) -> Any:
         """Inlined from handlers/filesystem.py (Wave 11.D.1)."""
         import asyncio
-        from ._backend import get_backend, normalize_virtual_path
+        from .._backend import get_backend, normalize_virtual_path
 
         if not params.file_path:
             raise NodeUserError("file_path is required")
@@ -54,8 +56,10 @@ class FileReadNode(ActionNode):
         file_path = normalize_virtual_path(params.file_path)
         try:
             content = await asyncio.to_thread(
-                backend.read, file_path,
-                offset=params.offset, limit=params.limit,
+                backend.read,
+                file_path,
+                offset=params.offset,
+                limit=params.limit,
             )
         except (FileNotFoundError, IsADirectoryError, ValueError) as e:
             # File doesn't exist / is a directory / bad offset — the

package/server/nodes/filesystem/file_read/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#8be9fd"
+}

package/server/nodes/filesystem/{fs_search.py → fs_search/__init__.py}

@@ -30,6 +30,10 @@ class FsSearchNode(ActionNode):
     subtitle = "ls/glob/grep"
     group = ("filesystem", "tool")
     description = "Search the filesystem (ls, glob, grep)"
+    tool_name = "fs_search"
+    tool_description = (
+        "Search the filesystem. Modes: ls (list directory), glob (pattern match files), grep (search file contents for text)."
+    )
     component_kind = "square"
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
@@ -46,7 +50,7 @@ class FsSearchNode(ActionNode):
     async def search(self, ctx: NodeContext, params: FsSearchParams) -> Any:
         """Inlined from handlers/filesystem.py (Wave 11.D.1)."""
         import asyncio
-        from ._backend import get_backend, normalize_virtual_path
+        from .._backend import get_backend, normalize_virtual_path
 
         backend = get_backend(params.model_dump(), ctx.raw)
         path = normalize_virtual_path(params.path)
@@ -63,7 +67,9 @@ class FsSearchNode(ActionNode):
             if not params.pattern:
                 raise NodeUserError("pattern is required for glob mode")
             matches = await asyncio.to_thread(
-                backend.glob_info, params.pattern, path=path,
+                backend.glob_info,
+                params.pattern,
+                path=path,
             )
             return {
                 "path": path,
@@ -76,7 +82,9 @@ class FsSearchNode(ActionNode):
             if not params.pattern:
                 raise NodeUserError("pattern is required for grep mode")
             result = await asyncio.to_thread(
-                backend.grep_raw, params.pattern, path=path,
+                backend.grep_raw,
+                params.pattern,
+                path=path,
             )
             if isinstance(result, str):
                 raise NodeUserError(result)

package/server/nodes/filesystem/fs_search/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#8be9fd"
+}

package/server/nodes/filesystem/{shell.py → shell/__init__.py}

@@ -41,6 +41,8 @@ class ShellNode(ActionNode):
     subtitle = "Run Command"
     group = ("filesystem", "tool")
     description = "Execute shell commands (sandboxed; no system PATH)"
+    tool_name = "shell_execute"
+    tool_description = "Execute a shell command. Returns stdout, stderr, and exit code."
     component_kind = "square"
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
@@ -58,7 +60,7 @@ class ShellNode(ActionNode):
         """Inlined from handlers/filesystem.py (Wave 11.D.1)."""
         import asyncio
         from core.logging import get_logger
-        from ._backend import get_backend
+        from .._backend import get_backend
 
         log = get_logger(__name__)
 
@@ -66,7 +68,7 @@ class ShellNode(ActionNode):
         # Nushell's parser does, so the LLM sees an actionable hint instead
         # of ``nu::parser::shell_andand``. Documented in
         # ``server/skills/terminal/shell-skill/SKILL.md``.
-        if (m := _BASH_CHAIN_RE.search(params.command)):
+        if m := _BASH_CHAIN_RE.search(params.command):
             op = m.group(1)
             replacement = "; (sequential)" if op == "&&" else "try { … } catch { … }"
             raise NodeUserError(
@@ -83,17 +85,22 @@ class ShellNode(ActionNode):
         # misleading users into thinking shell runs daemons.
         log.info(
             "[Shell] Executing: %s (timeout=%ds)",
-            params.command[:200], params.timeout,
+            params.command[:200],
+            params.timeout,
         )
         result = await asyncio.to_thread(
-            backend.execute, params.command, timeout=params.timeout,
+            backend.execute,
+            params.command,
+            timeout=params.timeout,
         )
         if result.exit_code == 124:
             log.warning("[Shell] Timed out after %ds: %s", params.timeout, params.command[:100])
         elif result.exit_code != 0:
             log.warning(
                 "[Shell] Non-zero exit (%d): %s -> %s",
-                result.exit_code, params.command[:100], result.output[:300],
+                result.exit_code,
+                params.command[:100],
+                result.output[:300],
             )
         else:
             log.info("[Shell] Completed: exit=%d len=%d", result.exit_code, len(result.output))

package/server/nodes/filesystem/shell/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#8be9fd"
+}

package/server/nodes/google/__init__.py

@@ -24,9 +24,11 @@ the FastAPI app pick up the plugin's surface without ever importing
 this module by name.
 """
 
+from services.deployment.canary_registry import register_canary_trigger_type
 from services.event_waiter import register_filter_builder
 from services.status_broadcaster import register_service_refresh
 from services.ws_handler_registry import (
+    register_oauth_callback_path,
     register_option_loader,
     register_router,
     register_ws_handlers,
@@ -45,6 +47,7 @@ from ._refresh import refresh_google_status
 
 register_ws_handlers(WS_HANDLERS)
 register_router(_router.router, name="google")
+register_oauth_callback_path("google", "/api/google/callback")
 register_service_refresh(refresh_google_status)
 register_filter_builder("googleGmailReceive", build_gmail_filter)
 
@@ -53,3 +56,12 @@ register_option_loader("gmailLabels", load_gmail_labels)
 register_option_loader("googleCalendarList", load_calendar_list)
 register_option_loader("googleDriveFolders", load_drive_folders)
 register_option_loader("googleTasklists", load_tasklists)
+
+# Wave 12 C2: opt googleGmailReceive into the PollingTriggerWorkflow
+# consumer path. DeploymentManager detects the PollingTriggerNode
+# subclass and routes to PollingTriggerWorkflow (vs the push-side
+# TriggerListenerWorkflow) automatically. Producer side: the per-cycle
+# Temporal activity is emitted by GmailReceiveNode.as_poll_activity()
+# and registered via collect_polling_activities() in the worker. See
+# services/deployment/canary_registry.py.
+register_canary_trigger_type("googleGmailReceive", "com.machinaos.gmail.message.received")

package/server/nodes/google/_auth_helper.py

@@ -39,11 +39,11 @@ async def get_google_credentials(
     """
     from services.plugin.deps import get_auth_service, get_database
 
-    account_mode = parameters.get('account_mode', 'owner')
+    account_mode = parameters.get("account_mode", "owner")
     customer_id = "owner"
 
-    if account_mode == 'customer':
-        customer_id = parameters.get('customer_id')
+    if account_mode == "customer":
+        customer_id = parameters.get("customer_id")
         if not customer_id:
             raise ValueError("customer_id required for customer mode")
 
@@ -65,15 +65,11 @@ async def get_google_credentials(
         tokens = await auth_service.get_oauth_tokens("google", customer_id="owner")
 
         if not tokens or not tokens.get("access_token"):
-            raise ValueError(
-                "Google Workspace not connected. Please authenticate via Credentials."
-            )
+            raise ValueError("Google Workspace not connected. Please authenticate via Credentials.")
 
         access_token = tokens["access_token"]
         # refresh_token is read from DB directly (RFC 9700; not cached).
-        refresh_token = await auth_service.get_oauth_refresh_token(
-            "google", customer_id="owner"
-        )
+        refresh_token = await auth_service.get_oauth_refresh_token("google", customer_id="owner")
 
     auth_service = get_auth_service()
     client_id = await auth_service.get_api_key("google_client_id") or ""
@@ -94,9 +90,7 @@ async def get_google_credentials(
     # best-effort optimization that persists the new token to the DB.
     if refresh_token and client_id and client_secret:
         try:
-            await _try_refresh_and_persist(
-                creds, auth_service, customer_id, account_mode
-            )
+            await _try_refresh_and_persist(creds, auth_service, customer_id, account_mode)
         except Exception as e:
             # Non-fatal: the Credentials object will auto-refresh on 401 anyway
             logger.debug(f"Proactive token refresh skipped: {e}")
@@ -132,7 +126,7 @@ async def _try_refresh_and_persist(
         return
 
     # Persist refreshed token back to the correct store
-    if account_mode == 'owner':
+    if account_mode == "owner":
         tokens = await auth_service.get_oauth_tokens("google", customer_id="owner")
         await auth_service.store_oauth_tokens(
             provider="google",

package/server/nodes/google/_base.py

@@ -41,7 +41,8 @@ async def build_google_service(
     creds = await GoogleCredential.build_credentials(parameters, context)
     loop = asyncio.get_event_loop()
     return await loop.run_in_executor(
-        None, lambda: build(api_name, api_version, credentials=creds),
+        None,
+        lambda: build(api_name, api_version, credentials=creds),
     )
 
 
@@ -65,16 +66,18 @@ async def track_google_usage(
     cost_data = pricing.calculate_api_cost(service, action, resource_count)
 
     db = get_database()
-    await db.save_api_usage_metric({
-        'session_id': context.get('session_id', 'default'),
-        'node_id': node_id,
-        'workflow_id': context.get('workflow_id'),
-        'service': service,
-        'operation': cost_data.get('operation', action),
-        'endpoint': action,
-        'resource_count': resource_count,
-        'cost': cost_data.get('total_cost', 0.0),
-    })
+    await db.save_api_usage_metric(
+        {
+            "session_id": context.get("session_id", "default"),
+            "node_id": node_id,
+            "workflow_id": context.get("workflow_id"),
+            "service": service,
+            "operation": cost_data.get("operation", action),
+            "endpoint": action,
+            "resource_count": resource_count,
+            "cost": cost_data.get("total_cost", 0.0),
+        }
+    )
     return cost_data
 
 

package/server/nodes/google/_credentials.py

@@ -22,7 +22,6 @@ class GoogleCredential(OAuth2Credential):
     id = "google"
     display_name = "Google Workspace"
     category = "Productivity"
-    icon = "asset:google"
     authorization_url = "https://accounts.google.com/o/oauth2/auth"
     token_url = "https://oauth2.googleapis.com/token"
     client_id_api_key = "google_client_id"
@@ -39,6 +38,7 @@ class GoogleCredential(OAuth2Credential):
         """Return the live scope list (lazy import)."""
         if not cls.scopes:
             from nodes.google._oauth import GOOGLE_WORKSPACE_SCOPES
+
             cls.scopes = tuple(GOOGLE_WORKSPACE_SCOPES)
         return cls.scopes
 
@@ -58,4 +58,5 @@ class GoogleCredential(OAuth2Credential):
         policy.
         """
         from nodes.google._auth_helper import get_google_credentials
+
         return await get_google_credentials(parameters, context)

package/server/nodes/google/_events.py

@@ -0,0 +1,47 @@
+"""CloudEvents factory for gmail.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live in
+the plugin folder.
+
+No dispatcher wrapper: the canary delivery path for ``googleGmailReceive``
+is :class:`services.temporal.polling_trigger_workflow.PollingTriggerWorkflow`
+(not Signal-based). The polling activity (built by
+:meth:`services.plugin.polling.PollingTriggerNode.as_poll_activity`)
+returns the raw email dict back to the workflow which spawns the child
+MachinaWorkflow directly — no envelope-on-the-wire step is needed.
+
+The factory below is kept for parity with the other plugin ``_events.py``
+modules (and for any future ad-hoc emit usage); the legacy
+``dispatch_gmail_received`` shim was deleted in Wave 13 because it
+dispatched to ``event_waiter`` waiters that were never registered in
+canary-on mode (the polling workflow owns delivery).
+
+OAuth completion broadcasts route through the cross-cutting
+``StatusBroadcaster.broadcast_credential_event("credential.oauth.connected", ...)``
+path (RFC §6.4 cross-cutting tier) — NOT a plugin-named broadcast.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from services.events.envelope import WorkflowEvent
+
+
+def gmail_message_received(email_data: Mapping[str, Any]) -> WorkflowEvent:
+    """Incoming Gmail message envelope. ``subject`` is the Gmail
+    message_id (correlation key for the consumer-side ``markAsRead``
+    + dedup paths)."""
+    payload = dict(email_data)
+    message_id = payload.get("message_id") or payload.get("id")
+    return WorkflowEvent(
+        source="machinaos://nodes/google",
+        type="com.machinaos.gmail.message.received",
+        subject=str(message_id) if message_id else None,
+        data=payload,
+    )
+
+
+__all__ = [
+    "gmail_message_received",
+]

package/server/nodes/google/_filters.py

@@ -13,11 +13,11 @@ from typing import Callable, Dict
 
 def build_gmail_filter(params: Dict) -> Callable[[Dict], bool]:
     """Build filter function for Gmail email events."""
-    label_filter = params.get('label_filter', 'INBOX')
+    label_filter = params.get("label_filter", "INBOX")
 
     def matches(data: Dict) -> bool:
-        if label_filter and label_filter != 'all':
-            labels = data.get('labels', [])
+        if label_filter and label_filter != "all":
+            labels = data.get("labels", [])
             if label_filter not in labels:
                 return False
         return True

package/server/nodes/google/_gmail.py

@@ -15,74 +15,95 @@ from ._base import run_sync
 
 async def poll_gmail_ids(service, query: str, max_results: int = 20) -> Set[str]:
     """Fetch message IDs matching a Gmail query."""
-    result = await run_sync(lambda: service.users().messages().list(
-        userId='me', q=query, maxResults=max_results,
-    ).execute())
-    return {m.get('id') for m in result.get('messages', []) if m.get('id')}
+    result = await run_sync(
+        lambda: service.users()
+        .messages()
+        .list(
+            userId="me",
+            q=query,
+            maxResults=max_results,
+        )
+        .execute()
+    )
+    return {m.get("id") for m in result.get("messages", []) if m.get("id")}
 
 
 async def fetch_email_details(service, message_id: str) -> Dict[str, Any]:
     """Fetch full email message + format it for output."""
-    result = await run_sync(lambda: service.users().messages().get(
-        userId='me', id=message_id, format='full',
-        metadataHeaders=['From', 'To', 'Subject', 'Date', 'Cc', 'Bcc'],
-    ).execute())
+    result = await run_sync(
+        lambda: service.users()
+        .messages()
+        .get(
+            userId="me",
+            id=message_id,
+            format="full",
+            metadataHeaders=["From", "To", "Subject", "Date", "Cc", "Bcc"],
+        )
+        .execute()
+    )
     return format_message(result, include_body=True)
 
 
 async def mark_email_as_read(service, message_id: str) -> None:
     """Remove the UNREAD label from a message."""
-    await run_sync(lambda: service.users().messages().modify(
-        userId='me', id=message_id, body={'removeLabelIds': ['UNREAD']},
-    ).execute())
+    await run_sync(
+        lambda: service.users()
+        .messages()
+        .modify(
+            userId="me",
+            id=message_id,
+            body={"removeLabelIds": ["UNREAD"]},
+        )
+        .execute()
+    )
 
 
 def format_message(message: Dict[str, Any], include_body: bool = False) -> Dict[str, Any]:
     """Convert a raw Gmail message payload into a flat, LLM-friendly dict."""
     headers: Dict[str, str] = {}
-    payload = message.get('payload', {})
-    for header in payload.get('headers', []):
-        name = header.get('name', '').lower()
-        if name in ('from', 'to', 'subject', 'date', 'cc', 'bcc'):
-            headers[name] = header.get('value', '')
+    payload = message.get("payload", {})
+    for header in payload.get("headers", []):
+        name = header.get("name", "").lower()
+        if name in ("from", "to", "subject", "date", "cc", "bcc"):
+            headers[name] = header.get("value", "")
 
     formatted: Dict[str, Any] = {
-        'message_id': message.get('id'),
-        'thread_id': message.get('threadId'),
-        'from': headers.get('from', ''),
-        'to': headers.get('to', ''),
-        'cc': headers.get('cc', ''),
-        'subject': headers.get('subject', ''),
-        'date': headers.get('date', ''),
-        'snippet': message.get('snippet', ''),
-        'labels': message.get('labelIds', []),
-        'size_estimate': message.get('sizeEstimate', 0),
+        "message_id": message.get("id"),
+        "thread_id": message.get("threadId"),
+        "from": headers.get("from", ""),
+        "to": headers.get("to", ""),
+        "cc": headers.get("cc", ""),
+        "subject": headers.get("subject", ""),
+        "date": headers.get("date", ""),
+        "snippet": message.get("snippet", ""),
+        "labels": message.get("labelIds", []),
+        "size_estimate": message.get("sizeEstimate", 0),
     }
 
     if include_body:
-        formatted['body'] = _extract_body(payload)
+        formatted["body"] = _extract_body(payload)
 
     attachments = _extract_attachments(payload)
     if attachments:
-        formatted['attachments'] = attachments
+        formatted["attachments"] = attachments
 
     return formatted
 
 
 def _extract_body(payload: Dict[str, Any]) -> str:
     """Extract text body from a (possibly multipart) Gmail payload."""
-    if payload.get('body', {}).get('data'):
-        return base64.urlsafe_b64decode(payload['body']['data']).decode('utf-8', errors='ignore')
+    if payload.get("body", {}).get("data"):
+        return base64.urlsafe_b64decode(payload["body"]["data"]).decode("utf-8", errors="ignore")
 
     body = ""
-    for part in payload.get('parts', []):
-        mime = part.get('mimeType', '')
-        data = part.get('body', {}).get('data')
-        if mime == 'text/plain' and data:
-            return base64.urlsafe_b64decode(data).decode('utf-8', errors='ignore')
-        if mime == 'text/html' and data and not body:
-            body = base64.urlsafe_b64decode(data).decode('utf-8', errors='ignore')
-        elif mime.startswith('multipart/'):
+    for part in payload.get("parts", []):
+        mime = part.get("mimeType", "")
+        data = part.get("body", {}).get("data")
+        if mime == "text/plain" and data:
+            return base64.urlsafe_b64decode(data).decode("utf-8", errors="ignore")
+        if mime == "text/html" and data and not body:
+            body = base64.urlsafe_b64decode(data).decode("utf-8", errors="ignore")
+        elif mime.startswith("multipart/"):
             nested = _extract_body(part)
             if nested:
                 return nested
@@ -92,15 +113,17 @@ def _extract_body(payload: Dict[str, Any]) -> str:
 def _extract_attachments(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
     """Flatten attachment metadata from a multipart payload."""
     attachments: List[Dict[str, Any]] = []
-    for part in payload.get('parts', []):
-        filename = part.get('filename', '')
+    for part in payload.get("parts", []):
+        filename = part.get("filename", "")
         if filename:
-            attachments.append({
-                'filename': filename,
-                'mime_type': part.get('mimeType', ''),
-                'size': part.get('body', {}).get('size', 0),
-                'attachment_id': part.get('body', {}).get('attachmentId', ''),
-            })
-        if part.get('parts'):
+            attachments.append(
+                {
+                    "filename": filename,
+                    "mime_type": part.get("mimeType", ""),
+                    "size": part.get("body", {}).get("size", 0),
+                    "attachment_id": part.get("body", {}).get("attachmentId", ""),
+                }
+            )
+        if part.get("parts"):
             attachments.extend(_extract_attachments(part))
     return attachments

package/server/nodes/google/_handlers.py

@@ -22,7 +22,9 @@ from ._oauth import GoogleOAuth
 
 
 async def _google_oauth_factory(
-    *, redirect_uri: Optional[str] = None, **_kwargs,
+    *,
+    redirect_uri: Optional[str] = None,
+    **_kwargs,
 ) -> GoogleOAuth:
     """Build a :class:`GoogleOAuth` from stored client credentials."""
     from services.plugin.deps import get_auth_service