machinaos 0.0.78 → 0.0.80

package/server/nodes/proxy/{proxy_config.py → proxy_config/__init__.py}

@@ -29,9 +29,16 @@ _ROUTING_REMOVE_OPS = ["remove_routing_rule"]
 
 class ProxyConfigParams(BaseModel):
     operation: Literal[
-        "list_providers", "add_provider", "update_provider", "remove_provider",
-        "set_credentials", "test_provider", "get_stats",
-        "add_routing_rule", "list_routing_rules", "remove_routing_rule",
+        "list_providers",
+        "add_provider",
+        "update_provider",
+        "remove_provider",
+        "set_credentials",
+        "test_provider",
+        "get_stats",
+        "add_routing_rule",
+        "list_routing_rules",
+        "remove_routing_rule",
     ] = Field(
         default="list_providers",
         description="Proxy management operation. list_providers / get_stats / list_routing_rules need no extra params.",
@@ -57,7 +64,7 @@ class ProxyConfigParams(BaseModel):
     )
     url_template: Any = Field(
         default="{}",
-        description="JSON template for proxy URL formatting (e.g. {\"username\": \"{user}-country-{country}\"}).",
+        description='JSON template for proxy URL formatting (e.g. {"username": "{user}-country-{country}"}).',
         json_schema_extra={
             "rows": 4,
             "displayOptions": {"show": {"operation": _PROVIDER_EDIT_OPS}},
@@ -75,7 +82,8 @@ class ProxyConfigParams(BaseModel):
     )
     priority: int = Field(
         default=50,
-        ge=0, le=100,
+        ge=0,
+        le=100,
         description="Selection priority (higher ranks first).",
         json_schema_extra={"displayOptions": {"show": {"operation": _PROVIDER_EDIT_OPS}}},
     )
@@ -170,22 +178,22 @@ async def _add_provider(p: Dict[str, Any], proxy_svc) -> Dict[str, Any]:
 
     url_template_raw = p.get("url_template", "{}")
     try:
-        url_template = (
-            json.loads(url_template_raw) if isinstance(url_template_raw, str) else url_template_raw
-        )
+        url_template = json.loads(url_template_raw) if isinstance(url_template_raw, str) else url_template_raw
     except json.JSONDecodeError:
         return {"success": False, "error": f"Invalid url_template JSON: {url_template_raw}"}
 
     db = get_database()
-    await db.save_proxy_provider({
-        "name": name,
-        "enabled": p.get("enabled", True),
-        "priority": int(p.get("priority", 50)),
-        "cost_per_gb": float(p.get("cost_per_gb", 0)),
-        "gateway_host": p.get("gateway_host", ""),
-        "gateway_port": int(p.get("gateway_port", 0)),
-        "url_template": json.dumps(url_template),
-    })
+    await db.save_proxy_provider(
+        {
+            "name": name,
+            "enabled": p.get("enabled", True),
+            "priority": int(p.get("priority", 50)),
+            "cost_per_gb": float(p.get("cost_per_gb", 0)),
+            "gateway_host": p.get("gateway_host", ""),
+            "gateway_port": int(p.get("gateway_port", 0)),
+            "url_template": json.dumps(url_template),
+        }
+    )
     if proxy_svc:
         await proxy_svc.reload_providers()
     return {"success": True, "name": name}
@@ -210,9 +218,7 @@ async def _update_provider(p: Dict[str, Any], proxy_svc) -> Dict[str, Any]:
     url_template_raw = p.get("url_template")
     if url_template_raw:
         try:
-            url_template = (
-                json.loads(url_template_raw) if isinstance(url_template_raw, str) else url_template_raw
-            )
+            url_template = json.loads(url_template_raw) if isinstance(url_template_raw, str) else url_template_raw
             updates["url_template"] = json.dumps(url_template)
         except json.JSONDecodeError:
             return {"success": False, "error": "Invalid url_template JSON"}
@@ -264,7 +270,8 @@ async def _test_provider(p: Dict[str, Any], proxy_svc) -> Dict[str, Any]:
 
     try:
         proxy_url = await proxy_svc.get_proxy_url(
-            "https://httpbin.org/ip", {"proxyProvider": name},
+            "https://httpbin.org/ip",
+            {"proxyProvider": name},
         )
         if not proxy_url:
             return {"success": False, "error": f"Could not get proxy URL for '{name}'"}
@@ -299,19 +306,19 @@ async def _add_routing_rule(p: Dict[str, Any], proxy_svc) -> Dict[str, Any]:
 
     preferred_raw = p.get("preferred_providers", "[]")
     try:
-        preferred = (
-            json.loads(preferred_raw) if isinstance(preferred_raw, str) else preferred_raw
-        )
+        preferred = json.loads(preferred_raw) if isinstance(preferred_raw, str) else preferred_raw
     except json.JSONDecodeError:
         preferred = []
 
     db = get_database()
-    await db.save_proxy_routing_rule({
-        "domain_pattern": domain_pattern,
-        "preferred_providers": json.dumps(preferred),
-        "required_country": p.get("required_country", ""),
-        "session_type": p.get("session_type", "rotating"),
-    })
+    await db.save_proxy_routing_rule(
+        {
+            "domain_pattern": domain_pattern,
+            "preferred_providers": json.dumps(preferred),
+            "required_country": p.get("required_country", ""),
+            "session_type": p.get("session_type", "rotating"),
+        }
+    )
     if proxy_svc:
         await proxy_svc.reload_providers()
     return {"success": True, "domain_pattern": domain_pattern}
@@ -369,6 +376,8 @@ class ProxyConfigNode(ActionNode):
     group = ("proxy", "tool")
     description = "Configure proxy providers and routing rules"
     component_kind = "square"
+    tool_name = "proxy_config"
+    tool_description = "Manage proxy providers and routing rules. Operations: list_providers, add_provider, update_provider, remove_provider, set_credentials, test_provider, get_stats, add_routing_rule, list_routing_rules, remove_routing_rule."
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
         {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},

package/server/nodes/proxy/proxy_config/meta.json

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

package/server/nodes/proxy/{proxy_request.py → proxy_request/__init__.py}

@@ -46,6 +46,8 @@ class ProxyRequestNode(ActionNode):
     group = ("proxy", "tool")
     description = "Make HTTP requests through residential proxy providers"
     component_kind = "square"
+    tool_name = "proxy_request"
+    tool_description = "Make HTTP requests through residential proxy providers with geo-targeting, session control, and automatic failover. Supports GET, POST, PUT, DELETE, PATCH methods."
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
         {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
@@ -73,14 +75,13 @@ class ProxyRequestNode(ActionNode):
 
         from services.proxy.models import ProxyResult
         from services.proxy.service import get_proxy_service
-        from ._usage import track_proxy_usage
+        from .._usage import track_proxy_usage
 
         log = get_logger(__name__)
         svc = get_proxy_service()
         if not svc or not svc.is_enabled():
             raise NodeUserError(
-                "Proxy service not initialized. Use proxy_config tool to add a "
-                "provider first.",
+                "Proxy service not initialized. Use proxy_config tool to add a " "provider first.",
             )
 
         raw = params.model_dump()
@@ -116,15 +117,21 @@ class ProxyRequestNode(ActionNode):
                 latency_ms = (time.monotonic() - req_start) * 1000
                 bytes_transferred = len(response.content) if response.content else 0
 
-                svc.report_result(provider_name, ProxyResult(
-                    success=response.status_code < 400,
-                    latency_ms=latency_ms,
-                    bytes_transferred=bytes_transferred,
-                    status_code=response.status_code,
-                ))
+                svc.report_result(
+                    provider_name,
+                    ProxyResult(
+                        success=response.status_code < 400,
+                        latency_ms=latency_ms,
+                        bytes_transferred=bytes_transferred,
+                        status_code=response.status_code,
+                    ),
+                )
                 await track_proxy_usage(
-                    ctx.node_id, provider_name, bytes_transferred,
-                    workflow_id=ctx.workflow_id, session_id=ctx.session_id,
+                    ctx.node_id,
+                    provider_name,
+                    bytes_transferred,
+                    workflow_id=ctx.workflow_id,
+                    session_id=ctx.session_id,
                 )
                 try:
                     response_data = response.json()
@@ -148,13 +155,20 @@ class ProxyRequestNode(ActionNode):
             except Exception as e:
                 latency_ms = (time.monotonic() - req_start) * 1000
                 last_error = str(e)
-                svc.report_result(provider_name, ProxyResult(
-                    success=False, latency_ms=latency_ms, error=last_error,
-                ))
+                svc.report_result(
+                    provider_name,
+                    ProxyResult(
+                        success=False,
+                        latency_ms=latency_ms,
+                        error=last_error,
+                    ),
+                )
                 log.warning(
                     "Proxy request attempt failed",
-                    node_id=ctx.node_id, attempt=attempt + 1,
-                    max_retries=max_retries, error=last_error,
+                    node_id=ctx.node_id,
+                    attempt=attempt + 1,
+                    max_retries=max_retries,
+                    error=last_error,
                 )
                 if not failover or attempt >= max_retries:
                     break

package/server/nodes/proxy/proxy_request/meta.json

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

package/server/nodes/proxy/{proxy_status.py → proxy_status/__init__.py}

@@ -29,6 +29,8 @@ class ProxyStatusNode(ActionNode):
     group = ("proxy", "tool")
     description = "View proxy provider health, scores, and usage statistics"
     component_kind = "square"
+    tool_name = "proxy_status"
+    tool_description = "Get proxy provider health stats, scores, and usage statistics. Returns enabled status, provider list with health scores, and aggregated stats."
     handles = (
         {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
         {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},

package/server/nodes/proxy/proxy_status/meta.json

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

package/server/nodes/scheduler/{cron_scheduler.py → cron_scheduler/__init__.py}

@@ -3,6 +3,21 @@
 Cron-expression-based scheduling trigger. Deployment-mode lifecycle
 (starting/stopping the cron job) is owned by ``deployment/triggers.py``;
 the run-button path executes this plugin once for testing.
+
+Self-registration on import (Wave 12 C3 — Temporal Schedules canary):
+  - ``CronTriggerWorkflow`` (the per-firing workflow shipped in
+    ``._workflow``) is wrapped in :class:`temporalio.plugin.SimplePlugin`
+    and registered with
+    :func:`services.temporal.plugin_registry.register_temporal_plugin`.
+    The Temporal worker passes the registered list to
+    ``Worker(plugins=[...])`` and the SDK's plugin chain merges this
+    plugin's workflow class into the effective worker configuration —
+    framework worker stays plugin-agnostic.
+  - ``cronScheduler`` opts into the canary set via
+    :func:`services.deployment.canary_registry.register_canary_trigger_type`.
+    ``DeploymentManager._setup_cron_trigger`` checks the registry +
+    feature flag; when both are on, the deploy path creates a Temporal
+    ``Schedule`` instead of the in-process APScheduler job.
 """
 
 from __future__ import annotations
@@ -13,12 +28,20 @@ from datetime import datetime, timedelta
 from typing import Any, Dict, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
+from temporalio.plugin import SimplePlugin
 
 from core.logging import get_logger
+from services.deployment.canary_registry import register_canary_trigger_type
 from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+from services.temporal.plugin_registry import register_temporal_plugin
+
+from ._workflow import CronTriggerWorkflow
 
 logger = get_logger(__name__)
 
+register_temporal_plugin(SimplePlugin(name="cron-scheduler", workflows=[CronTriggerWorkflow]))
+register_canary_trigger_type("cronScheduler", "com.machinaos.cron.tick")
+
 
 def _calculate_wait_seconds(p: Dict[str, Any]) -> int:
     frequency = p.get("frequency", "minutes")
@@ -79,30 +102,45 @@ def _get_schedule_description(p: Dict[str, Any]) -> str:
 
 
 class CronSchedulerParams(BaseModel):
-    frequency: Literal[
-        "seconds", "minutes", "hours", "days", "weeks", "months", "once"
-    ] = Field(
+    frequency: Literal["seconds", "minutes", "hours", "days", "weeks", "months", "once"] = Field(
         default="minutes",
         description="How often the schedule fires",
     )
     interval: int = Field(
-        default=30, ge=5, le=59,
+        default=30,
+        ge=5,
+        le=59,
         description="Seconds between fires (5-59)",
         json_schema_extra={"displayOptions": {"show": {"frequency": ["seconds"]}}},
     )
     interval_minutes: int = Field(
-        default=5, ge=1, le=59,
+        default=5,
+        ge=1,
+        le=59,
         description="Minutes between fires (1-59)",
         json_schema_extra={"displayOptions": {"show": {"frequency": ["minutes"]}}},
     )
     interval_hours: int = Field(
-        default=1, ge=1, le=23,
+        default=1,
+        ge=1,
+        le=23,
         description="Hours between fires (1-23)",
         json_schema_extra={"displayOptions": {"show": {"frequency": ["hours"]}}},
     )
     daily_time: Literal[
-        "00:00", "02:00", "04:00", "06:00", "08:00", "09:00",
-        "10:00", "12:00", "14:00", "16:00", "18:00", "20:00", "22:00",
+        "00:00",
+        "02:00",
+        "04:00",
+        "06:00",
+        "08:00",
+        "09:00",
+        "10:00",
+        "12:00",
+        "14:00",
+        "16:00",
+        "18:00",
+        "20:00",
+        "22:00",
     ] = Field(
         default="09:00",
         description="Time of day (HH:MM) for daily schedule",
@@ -114,17 +152,54 @@ class CronSchedulerParams(BaseModel):
         json_schema_extra={"displayOptions": {"show": {"frequency": ["weeks"]}}},
     )
     weekly_time: Literal[
-        "00:00", "02:00", "04:00", "06:00", "08:00", "09:00",
-        "10:00", "12:00", "14:00", "16:00", "18:00", "20:00", "22:00",
+        "00:00",
+        "02:00",
+        "04:00",
+        "06:00",
+        "08:00",
+        "09:00",
+        "10:00",
+        "12:00",
+        "14:00",
+        "16:00",
+        "18:00",
+        "20:00",
+        "22:00",
     ] = Field(
         default="09:00",
         description="Time of day for weekly schedule",
         json_schema_extra={"displayOptions": {"show": {"frequency": ["weeks"]}}},
     )
     month_day: Literal[
-        "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
-        "11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
-        "21", "22", "23", "24", "25", "26", "27", "28", "L",
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+        "7",
+        "8",
+        "9",
+        "10",
+        "11",
+        "12",
+        "13",
+        "14",
+        "15",
+        "16",
+        "17",
+        "18",
+        "19",
+        "20",
+        "21",
+        "22",
+        "23",
+        "24",
+        "25",
+        "26",
+        "27",
+        "28",
+        "L",
     ] = Field(
         default="1",
         description="Day of month (1-28, or 'L' for last day)",
@@ -171,10 +246,9 @@ class CronSchedulerNode(ActionNode):
     group = ("scheduler", "trigger", "tool")
     description = "Cron expression-based scheduling trigger"
     component_kind = "trigger"
-    handles = (
-        {"name": "output-main", "kind": "output", "position": "right",
-         "label": "Output", "role": "main"},
-    )
+    tool_name = "cron_scheduler"
+    tool_description = "Schedule a delayed or recurring execution. Supports seconds, minutes, hours, daily, weekly, monthly frequencies with timezone. Use frequency to set schedule type, then set the relevant interval/time parameters."
+    handles = ({"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},)
     annotations = {"destructive": False, "readonly": True, "open_world": False}
     task_queue = TaskQueue.TRIGGERS_POLL
     usable_as_tool = True
@@ -198,7 +272,8 @@ class CronSchedulerNode(ActionNode):
         trigger_time = now + timedelta(seconds=wait_seconds)
 
         await get_status_broadcaster().update_node_status(
-            ctx.node_id, "waiting",
+            ctx.node_id,
+            "waiting",
             {
                 "message": f"Waiting {schedule_desc}...",
                 "trigger_time": trigger_time.isoformat(),
@@ -209,7 +284,8 @@ class CronSchedulerNode(ActionNode):
 
         logger.info(
             f"[CronScheduler] Waiting {wait_seconds}s for trigger",
-            node_id=ctx.node_id, trigger_time=trigger_time.isoformat(),
+            node_id=ctx.node_id,
+            trigger_time=trigger_time.isoformat(),
         )
 
         try:
@@ -232,8 +308,5 @@ class CronSchedulerNode(ActionNode):
             output.message = f"Triggered after waiting {_format_wait_time(wait_seconds)}"
         else:
             output.next_run = schedule_desc
-            output.message = (
-                f"Triggered after {_format_wait_time(wait_seconds)}, "
-                f"will repeat: {schedule_desc}"
-            )
+            output.message = f"Triggered after {_format_wait_time(wait_seconds)}, " f"will repeat: {schedule_desc}"
         return output

package/server/nodes/scheduler/cron_scheduler/_workflow.py

@@ -0,0 +1,155 @@
+"""Wave 12 C3: per-firing Temporal workflow for the cron trigger.
+
+Plugin-owned per RFC §6.1 — the cron-specific workflow lives in the
+cron_scheduler plugin folder, not at the framework level. The plugin's
+``__init__.py`` publishes the class via
+:func:`services.temporal.workflow_registry.register_temporal_workflow`;
+the Temporal worker collects it on startup.
+
+How it fits with the Temporal Schedule
+--------------------------------------
+
+Wave 12 C3 replaces APScheduler-driven cron with a Temporal Schedule
+(``client.create_schedule``). The Schedule's action is
+``ScheduleActionStartWorkflow`` targeting THIS class. Each firing
+(per the cron expression) starts one :class:`CronTriggerWorkflow`
+run; the run spawns a child :class:`MachinaWorkflow` with the cron
+trigger node pre-executed, then exits. ``parent_close_policy=ABANDON``
+keeps the spawned MachinaWorkflow alive after this workflow returns.
+
+Why we need a separate workflow (vs the Schedule starting MachinaWorkflow
+directly): Schedule action args are **frozen at create time**. Per-tick
+data (firing timestamp) must be computed inside a workflow. This thin
+shim does exactly that and nothing more.
+
+Refs:
+  - https://docs.temporal.io/develop/python/schedules
+  - https://docs.temporal.io/encyclopedia/scheduled-execution
+"""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any, Dict
+
+from temporalio import workflow
+from temporalio.common import WorkflowIDReusePolicy
+from temporalio.workflow import ParentClosePolicy
+
+
+@workflow.defn(name="CronTriggerWorkflow", sandboxed=False)
+class CronTriggerWorkflow:
+    """One-shot per-firing workflow that spawns a child MachinaWorkflow.
+
+    Determinism note: the only mutable state is the firing-time
+    timestamp from ``workflow.now()`` (deterministic per run);
+    everything else is computed from the static action args.
+    """
+
+    @workflow.run
+    async def run(self, listener_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Spawn one MachinaWorkflow child per cron firing.
+
+        ``listener_data`` shape (deployment-supplied, frozen at
+        schedule creation)::
+
+            {
+                "workflow_id": str,        # MachinaOs deployment workflow_id
+                "trigger_node_id": str,    # cron node id
+                "node_type": "cronScheduler",
+                "cron_expression": str,    # raw crontab string
+                "frequency": str,          # human-readable bucket
+                "timezone": str,           # IANA tz name
+                "schedule": str,           # human-readable description
+                "filter_params": Dict,     # plugin params
+                "nodes": List[Dict],       # full deployment graph snapshot
+                "edges": List[Dict],
+                "session_id": str,
+                "tenant_id": Optional[str],
+            }
+
+        Returns ``{spawned_child_id, timestamp}`` for the schedule's
+        per-firing history visibility.
+        """
+        trigger_output = _build_trigger_output(listener_data)
+
+        # Reuse the listener filter-graph helper so cron / push / poll
+        # canary paths share identical n8n stop-at-trigger / config-node /
+        # toolkit / agent-tool semantics — single source of truth.
+        from services.temporal.trigger_listener_workflow import _build_run_graph
+
+        trigger_node_id = listener_data["trigger_node_id"]
+        nodes = listener_data["nodes"]
+        edges = listener_data["edges"]
+        session_id = listener_data.get("session_id", "default")
+        deployment_workflow_id = listener_data.get("workflow_id")
+        tenant_id = listener_data.get("tenant_id")
+
+        filtered_nodes, filtered_edges = _build_run_graph(
+            trigger_node_id=trigger_node_id,
+            trigger_output=trigger_output,
+            nodes=nodes,
+            edges=edges,
+        )
+
+        # Schedule fires multiple times; the firing-time component in
+        # the child workflow id makes each tick unique.
+        # WorkflowIDReusePolicy.ALLOW_DUPLICATE_FAILED_ONLY guards
+        # against a duplicate at the same instant (Temporal retry of
+        # the schedule action) double-spawning a successful run.
+        firing_iso = trigger_output["timestamp"]
+        child_id = f"cron-{deployment_workflow_id}-{trigger_node_id}-{firing_iso}"
+
+        await workflow.start_child_workflow(
+            "MachinaWorkflow",
+            args=[
+                {
+                    "nodes": filtered_nodes,
+                    "edges": filtered_edges,
+                    "session_id": session_id,
+                    "workflow_id": deployment_workflow_id,
+                    "tenant_id": tenant_id,
+                }
+            ],
+            id=child_id,
+            parent_close_policy=ParentClosePolicy.ABANDON,
+            id_reuse_policy=WorkflowIDReusePolicy.ALLOW_DUPLICATE_FAILED_ONLY,
+            execution_timeout=timedelta(hours=1),
+            run_timeout=timedelta(hours=1),
+        )
+
+        workflow.logger.info(f"CronTriggerWorkflow spawned child run: child_id={child_id} " f"timestamp={firing_iso}")
+
+        return {
+            "spawned_child_id": child_id,
+            "timestamp": firing_iso,
+        }
+
+
+def _build_trigger_output(listener_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Construct the cron trigger's output payload for one firing.
+
+    Shape matches the pre-Wave-12 APScheduler tick callback in
+    ``DeploymentManager._setup_cron_trigger.on_tick`` so downstream
+    nodes that read ``{{cronTrigger.timestamp}}`` etc. keep working.
+
+    **Iteration counter trade-off**: APScheduler kept an in-memory
+    ``self._cron_iterations[node_id]`` that incremented per firing.
+    Temporal Schedules don't expose a built-in firing counter and
+    persisting one would require either a long-lived workflow (we'd
+    lose the one-shot simplicity) or DB writes on the hot path.
+    The canary intentionally sets ``iteration`` to ``None`` —
+    downstream nodes that need monotonic iteration can switch to the
+    firing ``timestamp`` (deterministic per run, sortable).
+    """
+    return {
+        "timestamp": workflow.now().isoformat(),
+        "iteration": None,
+        "frequency": listener_data.get("frequency"),
+        "timezone": listener_data.get("timezone"),
+        "schedule": listener_data.get("schedule"),
+        "cron_expression": listener_data.get("cron_expression"),
+    }
+
+
+__all__ = ["CronTriggerWorkflow"]

package/server/nodes/scheduler/cron_scheduler/meta.json

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

package/server/nodes/scheduler/{timer.py → timer/__init__.py}

@@ -34,11 +34,11 @@ class TimerNode(ActionNode):
     group = ("scheduler",)
     description = "Timer-based trigger with configurable delay"
     component_kind = "square"  # has input handle
+    tool_name = "timer"
+    tool_description = "Wait/sleep for a specified duration. Specify duration (1-3600) and unit (seconds, minutes, or hours). Returns timestamp and elapsed time after waiting."
     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": True, "open_world": False}
     task_queue = TaskQueue.DEFAULT
@@ -68,7 +68,8 @@ class TimerNode(ActionNode):
 
         complete_time = datetime.now() + timedelta(seconds=wait_seconds)
         await get_status_broadcaster().update_node_status(
-            ctx.node_id, "waiting",
+            ctx.node_id,
+            "waiting",
             {
                 "message": f"Waiting {duration} {unit}...",
                 "complete_time": complete_time.isoformat(),

package/server/nodes/scheduler/timer/meta.json

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

package/server/nodes/scraper/_credentials.py

@@ -13,7 +13,6 @@ class ApifyCredential(ApiKeyCredential):
     id = "apify"
     display_name = "Apify"
     category = "Scrapers"
-    icon = "asset:apify"
     key_name = "Authorization"
     key_location = "bearer"
     docs_url = "https://docs.apify.com/api/v2"