Skip to content

Self-improving AI Employees for everyone

feat(plugin): Wave 11.C batch 5 — migrate remaining 35 nodes (FINAL)

trohitgbf61d21d0a7a
diff --git a/server/nodes/browser/browser.py b/server/nodes/browser/browser.py
new file mode 100644
index 00000000..5784e58a
--- /dev/null
+++ b/server/nodes/browser/browser.py
@@ -0,0 +1,62 @@
+"""Browser — Wave 11.C migration. agent-browser CLI wrapper."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class BrowserParams(BaseModel):
+ operation: Literal[
+ "navigate", "click", "type", "fill", "screenshot", "snapshot",
+ "get_text", "get_html", "eval", "wait", "scroll", "select", "batch",
+ ] = "navigate"
+ url: str = Field(default="")
+ selector: str = Field(default="")
+ text: str = Field(default="")
+ session: str = Field(default="")
+
+ model_config = ConfigDict(extra="allow")
+
+
+class BrowserOutput(BaseModel):
+ operation: Optional[str] = None
+ snapshot: Optional[Any] = None
+ text: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class BrowserNode(ActionNode):
+ type = "browser"
+ display_name = "Browser"
+ subtitle = "Browser Automation"
+ icon = "asset:chrome"
+ color = "#ff79c6"
+ group = ("browser", "tool")
+ description = "Interactive browser automation via agent-browser CLI"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": True}
+ task_queue = TaskQueue.BROWSER
+ usable_as_tool = True
+
+ Params = BrowserParams
+ Output = BrowserOutput
+
+ @Operation("dispatch")
+ async def dispatch(self, ctx: NodeContext, params: BrowserParams) -> Any:
+ from services.handlers.browser import handle_browser
+ response = await handle_browser(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Browser op failed")
diff --git a/server/nodes/code/_base.py b/server/nodes/code/_base.py
new file mode 100644
index 00000000..715f329f
--- /dev/null
+++ b/server/nodes/code/_base.py
@@ -0,0 +1,47 @@
+"""Shared base for code-executor plugins.
+
+Python / JavaScript / TypeScript executors all need ``connected_outputs``
+(injected by the executor's _NEEDS_CONNECTED_OUTPUTS path). Each
+delegates to its language-specific handler.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class CodeExecutorParams(BaseModel):
+ code: str = Field(..., min_length=1, json_schema_extra={"editor": "code"})
+ timeout: int = Field(default=30, ge=1, le=600)
+
+ model_config = ConfigDict(extra="allow")
+
+
+class CodeExecutorOutput(BaseModel):
+ output: Optional[Any] = None
+ console_output: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class CodeExecutorBase(ActionNode, abstract=True):
+ """Subclass and set type / display_name / icon / handler import."""
+
+ color = "#ffb86c"
+ group = ("code", "tool")
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": False}
+ task_queue = TaskQueue.CODE_EXEC
+ usable_as_tool = True
+ ui_hints = {"hasCodeEditor": True}
+
+ Params = CodeExecutorParams
+ Output = CodeExecutorOutput
diff --git a/server/nodes/code/javascript_executor.py b/server/nodes/code/javascript_executor.py
new file mode 100644
index 00000000..59b471ae
--- /dev/null
+++ b/server/nodes/code/javascript_executor.py
@@ -0,0 +1,30 @@
+"""JavaScript Executor — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from services.plugin import NodeContext, Operation
+
+from ._base import CodeExecutorBase, CodeExecutorParams
+
+
+class JavaScriptExecutorNode(CodeExecutorBase):
+ type = "javascriptExecutor"
+ display_name = "JavaScript Executor"
+ subtitle = "Run JS"
+ icon = "📜"
+ description = "Execute JavaScript code via persistent Node.js server"
+
+ @Operation("execute")
+ async def execute_op(self, ctx: NodeContext, params: CodeExecutorParams) -> Any:
+ from services.handlers.code import handle_javascript_executor
+ outputs = ctx.raw.get("connected_outputs") or {}
+ response = await handle_javascript_executor(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True),
+ context=ctx.raw, connected_outputs=outputs,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "JavaScript executor failed")
diff --git a/server/nodes/code/python_executor.py b/server/nodes/code/python_executor.py
new file mode 100644
index 00000000..12fe1a7e
--- /dev/null
+++ b/server/nodes/code/python_executor.py
@@ -0,0 +1,30 @@
+"""Python Executor — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from services.plugin import NodeContext, Operation
+
+from ._base import CodeExecutorBase, CodeExecutorParams
+
+
+class PythonExecutorNode(CodeExecutorBase):
+ type = "pythonExecutor"
+ display_name = "Python Executor"
+ subtitle = "Run Python"
+ icon = "🐍"
+ description = "Execute Python code for calculations, data processing, and automation"
+
+ @Operation("execute")
+ async def execute_op(self, ctx: NodeContext, params: CodeExecutorParams) -> Any:
+ from services.handlers.code import handle_python_executor
+ outputs = ctx.raw.get("connected_outputs") or {}
+ response = await handle_python_executor(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True),
+ context=ctx.raw, connected_outputs=outputs,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Python executor failed")
diff --git a/server/nodes/code/typescript_executor.py b/server/nodes/code/typescript_executor.py
new file mode 100644
index 00000000..a61b7f74
--- /dev/null
+++ b/server/nodes/code/typescript_executor.py
@@ -0,0 +1,30 @@
+"""TypeScript Executor — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from services.plugin import NodeContext, Operation
+
+from ._base import CodeExecutorBase, CodeExecutorParams
+
+
+class TypeScriptExecutorNode(CodeExecutorBase):
+ type = "typescriptExecutor"
+ display_name = "TypeScript Executor"
+ subtitle = "Run TS"
+ icon = "📘"
+ description = "Execute TypeScript code via persistent Node.js server with type safety"
+
+ @Operation("execute")
+ async def execute_op(self, ctx: NodeContext, params: CodeExecutorParams) -> Any:
+ from services.handlers.code import handle_typescript_executor
+ outputs = ctx.raw.get("connected_outputs") or {}
+ response = await handle_typescript_executor(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True),
+ context=ctx.raw, connected_outputs=outputs,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "TypeScript executor failed")
diff --git a/server/nodes/document/_helpers.py b/server/nodes/document/_helpers.py
new file mode 100644
index 00000000..97783246
--- /dev/null
+++ b/server/nodes/document/_helpers.py
@@ -0,0 +1,22 @@
+"""Helpers for thin-delegating document plugins to their handlers."""
+
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable, Dict
+
+
+async def delegate(
+ handler: Callable[..., Awaitable[Dict[str, Any]]],
+ *,
+ node_type: str,
+ node_id: str,
+ payload: Dict[str, Any],
+ context: Dict[str, Any],
+) -> Any:
+ response = await handler(
+ node_id=node_id, node_type=node_type,
+ parameters=payload, context=context,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or f"{node_type} failed")
diff --git a/server/nodes/document/document_parser.py b/server/nodes/document/document_parser.py
new file mode 100644
index 00000000..bce35f02
--- /dev/null
+++ b/server/nodes/document/document_parser.py
@@ -0,0 +1,53 @@
+"""Document Parser — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._helpers import delegate
+
+
+class DocumentParserParams(BaseModel):
+ file_path: str = Field(..., alias="filePath")
+ parser: Literal["pypdf", "marker", "unstructured", "beautifulsoup"] = "pypdf"
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class DocumentParserOutput(BaseModel):
+ text: Optional[str] = None
+ pages: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class DocumentParserNode(ActionNode):
+ type = "documentParser"
+ display_name = "Document Parser"
+ subtitle = "Parse to Text"
+ icon = "📄"
+ color = "#bd93f9"
+ group = ("document",)
+ description = "Parse documents to text using configurable parsers"
+ component_kind = "square"
+ handles = (
+ {"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
+
+ Params = DocumentParserParams
+ Output = DocumentParserOutput
+
+ @Operation("parse")
+ async def parse(self, ctx: NodeContext, params: DocumentParserParams) -> Any:
+ from services.handlers.document import handle_document_parser
+ return await delegate(
+ handle_document_parser, node_type=self.type, node_id=ctx.node_id,
+ payload=params.model_dump(by_alias=True), context=ctx.raw,
+ )
diff --git a/server/nodes/document/embedding_generator.py b/server/nodes/document/embedding_generator.py
new file mode 100644
index 00000000..946a7ded
--- /dev/null
+++ b/server/nodes/document/embedding_generator.py
@@ -0,0 +1,54 @@
+"""Embedding Generator — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._helpers import delegate
+
+
+class EmbeddingGeneratorParams(BaseModel):
+ chunks: List[str] = Field(default_factory=list)
+ provider: Literal["huggingface", "openai", "ollama"] = "huggingface"
+ model: str = Field(default="BAAI/bge-small-en-v1.5")
+
+ model_config = ConfigDict(extra="allow")
+
+
+class EmbeddingGeneratorOutput(BaseModel):
+ embeddings: Optional[list] = None
+ dimension: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class EmbeddingGeneratorNode(ActionNode):
+ type = "embeddingGenerator"
+ display_name = "Embedding Generator"
+ subtitle = "Vectorize"
+ icon = "🧮"
+ color = "#bd93f9"
+ group = ("document",)
+ description = "Generate vector embeddings from text chunks"
+ component_kind = "square"
+ handles = (
+ {"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": True}
+ task_queue = TaskQueue.AI_HEAVY
+
+ Params = EmbeddingGeneratorParams
+ Output = EmbeddingGeneratorOutput
+
+ @Operation("embed")
+ async def embed(self, ctx: NodeContext, params: EmbeddingGeneratorParams) -> Any:
+ from services.handlers.document import handle_embedding_generator
+ return await delegate(
+ handle_embedding_generator, node_type=self.type, node_id=ctx.node_id,
+ payload=params.model_dump(by_alias=True), context=ctx.raw,
+ )
diff --git a/server/nodes/document/file_downloader.py b/server/nodes/document/file_downloader.py
new file mode 100644
index 00000000..a429198c
--- /dev/null
+++ b/server/nodes/document/file_downloader.py
@@ -0,0 +1,57 @@
+"""File Downloader — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._helpers import delegate
+
+
+class FileDownloaderParams(BaseModel):
+ urls: List[str] = Field(default_factory=list)
+ output_dir: str = Field(default="downloads", alias="outputDir")
+ max_workers: int = Field(default=4, alias="maxWorkers", ge=1, le=32)
+ skip_existing: bool = Field(default=True, alias="skipExisting")
+ timeout: int = Field(default=60, ge=1, le=600)
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class FileDownloaderOutput(BaseModel):
+ downloaded: Optional[list] = None
+ skipped: Optional[list] = None
+ failed: Optional[list] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class FileDownloaderNode(ActionNode):
+ type = "fileDownloader"
+ display_name = "File Downloader"
+ subtitle = "Parallel DL"
+ icon = "⬇️"
+ color = "#bd93f9"
+ group = ("document",)
+ description = "Download files from URLs in parallel"
+ component_kind = "square"
+ handles = (
+ {"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}
+ task_queue = TaskQueue.REST_API
+
+ Params = FileDownloaderParams
+ Output = FileDownloaderOutput
+
+ @Operation("download")
+ async def download(self, ctx: NodeContext, params: FileDownloaderParams) -> Any:
+ from services.handlers.document import handle_file_downloader
+ return await delegate(
+ handle_file_downloader, node_type=self.type, node_id=ctx.node_id,
+ payload=params.model_dump(by_alias=True), context=ctx.raw,
+ )
diff --git a/server/nodes/document/http_scraper.py b/server/nodes/document/http_scraper.py
new file mode 100644
index 00000000..263cf323
--- /dev/null
+++ b/server/nodes/document/http_scraper.py
@@ -0,0 +1,55 @@
+"""HTTP Scraper — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._helpers import delegate
+
+
+class HttpScraperParams(BaseModel):
+ url: str = Field(default="")
+ pagination_mode: str = Field(default="single", alias="paginationMode")
+ max_pages: int = Field(default=10, alias="maxPages", ge=1, le=1000)
+ use_proxy: bool = Field(default=False, alias="useProxy")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class HttpScraperOutput(BaseModel):
+ items: Optional[list] = None
+ count: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class HttpScraperNode(ActionNode):
+ type = "httpScraper"
+ display_name = "HTTP Scraper"
+ subtitle = "Page Pagination"
+ icon = "🔍"
+ color = "#bd93f9"
+ group = ("document",)
+ description = "Scrape links from web pages with date/page pagination support"
+ component_kind = "square"
+ handles = (
+ {"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": True}
+ task_queue = TaskQueue.REST_API
+
+ Params = HttpScraperParams
+ Output = HttpScraperOutput
+
+ @Operation("scrape")
+ async def scrape(self, ctx: NodeContext, params: HttpScraperParams) -> Any:
+ from services.handlers.document import handle_http_scraper
+ return await delegate(
+ handle_http_scraper, node_type=self.type, node_id=ctx.node_id,
+ payload=params.model_dump(by_alias=True), context=ctx.raw,
+ )
diff --git a/server/nodes/document/text_chunker.py b/server/nodes/document/text_chunker.py
new file mode 100644
index 00000000..d683b60c
--- /dev/null
+++ b/server/nodes/document/text_chunker.py
@@ -0,0 +1,55 @@
+"""Text Chunker — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._helpers import delegate
+
+
+class TextChunkerParams(BaseModel):
+ text: str = Field(default="")
+ strategy: Literal["recursive", "markdown", "token"] = "recursive"
+ chunk_size: int = Field(default=1000, alias="chunkSize", ge=100, le=8000)
+ overlap: int = Field(default=200, ge=0, le=1000)
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class TextChunkerOutput(BaseModel):
+ chunks: Optional[list] = None
+ count: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TextChunkerNode(ActionNode):
+ type = "textChunker"
+ display_name = "Text Chunker"
+ subtitle = "Chunk Text"
+ icon = "✂️"
+ color = "#bd93f9"
+ group = ("document",)
+ description = "Split text into overlapping chunks for embedding"
+ component_kind = "square"
+ handles = (
+ {"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
+
+ Params = TextChunkerParams
+ Output = TextChunkerOutput
+
+ @Operation("chunk")
+ async def chunk(self, ctx: NodeContext, params: TextChunkerParams) -> Any:
+ from services.handlers.document import handle_text_chunker
+ return await delegate(
+ handle_text_chunker, node_type=self.type, node_id=ctx.node_id,
+ payload=params.model_dump(by_alias=True), context=ctx.raw,
+ )
diff --git a/server/nodes/document/vector_store.py b/server/nodes/document/vector_store.py
new file mode 100644
index 00000000..b968ab2c
--- /dev/null
+++ b/server/nodes/document/vector_store.py
@@ -0,0 +1,58 @@
+"""Vector Store — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+from ._helpers import delegate
+
+
+class VectorStoreParams(BaseModel):
+ operation: Literal["store", "query", "delete"] = "store"
+ backend: Literal["chromadb", "qdrant", "pinecone"] = "chromadb"
+ collection: str = Field(default="default")
+ embeddings: Optional[list] = None
+ query: str = Field(default="")
+ top_k: int = Field(default=5, alias="topK", ge=1, le=100)
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class VectorStoreOutput(BaseModel):
+ operation: Optional[str] = None
+ matches: Optional[list] = None
+ stored_count: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class VectorStoreNode(ActionNode):
+ type = "vectorStore"
+ display_name = "Vector Store"
+ subtitle = "Store/Query"
+ icon = "🗄"
+ color = "#bd93f9"
+ group = ("document",)
+ description = "Store and query vector embeddings"
+ component_kind = "square"
+ handles = (
+ {"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": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = VectorStoreParams
+ Output = VectorStoreOutput
+
+ @Operation("dispatch")
+ async def dispatch(self, ctx: NodeContext, params: VectorStoreParams) -> Any:
+ from services.handlers.document import handle_vector_store
+ return await delegate(
+ handle_vector_store, node_type=self.type, node_id=ctx.node_id,
+ payload=params.model_dump(by_alias=True), context=ctx.raw,
+ )
diff --git a/server/nodes/email/email_receive.py b/server/nodes/email/email_receive.py
new file mode 100644
index 00000000..e5535ad7
--- /dev/null
+++ b/server/nodes/email/email_receive.py
@@ -0,0 +1,71 @@
+"""Email Receive — Wave 11.C migration (polling trigger).
+
+IMAP polling for new mail via Himalaya CLI. Thin delegation to
+``handle_email_receive`` which owns the poll loop + baseline tracking.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, TriggerNode
+
+
+class EmailReceiveParams(BaseModel):
+ provider: Literal[
+ "gmail", "outlook", "yahoo", "icloud",
+ "protonmail", "fastmail", "custom",
+ ] = "gmail"
+ folder: str = Field(default="INBOX")
+ poll_interval: int = Field(default=60, ge=30, le=3600)
+ filter_query: str = Field(default="")
+ mark_as_read: bool = False
+
+ model_config = ConfigDict(extra="ignore")
+
+
+class EmailReceiveOutput(BaseModel):
+ message_id: Optional[str] = None
+ subject: Optional[str] = None
+ from_: Optional[str] = Field(default=None, alias="from")
+ body: Optional[str] = None
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class EmailReceiveNode(TriggerNode):
+ type = "emailReceive"
+ display_name = "Email Receive"
+ subtitle = "IMAP Polling"
+ icon = "asset:receive"
+ color = "#8be9fd"
+ group = ("email", "trigger")
+ description = "Polling trigger for new emails via IMAP"
+ component_kind = "trigger"
+ handles = (
+ {"name": "output-main", "kind": "output", "position": "right",
+ "label": "Output", "role": "main"},
+ )
+ task_queue = TaskQueue.TRIGGERS_POLL
+ mode = "polling"
+
+ Params = EmailReceiveParams
+ Output = EmailReceiveOutput
+
+ async def execute(
+ self,
+ node_id: str,
+ parameters: Dict[str, Any],
+ context: NodeContext,
+ ) -> Dict[str, Any]:
+ from services.handlers.email import handle_email_receive
+ return await handle_email_receive(
+ node_id=node_id, node_type=self.type,
+ parameters=parameters, context=context.raw,
+ )
+
+ @Operation("wait")
+ async def wait(self, ctx: NodeContext, params: EmailReceiveParams) -> EmailReceiveOutput:
+ raise NotImplementedError("Polling trigger uses execute() override")
diff --git a/server/nodes/filesystem/file_modify.py b/server/nodes/filesystem/file_modify.py
new file mode 100644
index 00000000..4482cd3d
--- /dev/null
+++ b/server/nodes/filesystem/file_modify.py
@@ -0,0 +1,59 @@
+"""File Modify — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class FileModifyParams(BaseModel):
+ operation: Literal["write", "edit"] = "write"
+ file_path: str = Field(..., alias="filePath")
+ content: str = Field(default="")
+ old_string: str = Field(default="", alias="oldString")
+ new_string: str = Field(default="", alias="newString")
+ replace_all: bool = Field(default=False, alias="replaceAll")
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class FileModifyOutput(BaseModel):
+ written: Optional[bool] = None
+ replacements: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class FileModifyNode(ActionNode):
+ type = "fileModify"
+ display_name = "File Modify"
+ subtitle = "Write/Edit"
+ icon = "✏️"
+ color = "#8be9fd"
+ group = ("filesystem", "tool")
+ description = "Write new files or edit existing files"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+ usable_as_tool = True
+
+ Params = FileModifyParams
+ Output = FileModifyOutput
+
+ @Operation("modify")
+ async def modify(self, ctx: NodeContext, params: FileModifyParams) -> Any:
+ from services.handlers.filesystem import handle_file_modify
+ response = await handle_file_modify(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "File modify failed")
diff --git a/server/nodes/filesystem/file_read.py b/server/nodes/filesystem/file_read.py
new file mode 100644
index 00000000..d29873e5
--- /dev/null
+++ b/server/nodes/filesystem/file_read.py
@@ -0,0 +1,56 @@
+"""File Read — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class FileReadParams(BaseModel):
+ file_path: str = Field(..., alias="filePath")
+ offset: int = Field(default=0, ge=0)
+ limit: int = Field(default=2000, ge=1, le=10000)
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class FileReadOutput(BaseModel):
+ content: Optional[str] = None
+ line_count: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class FileReadNode(ActionNode):
+ type = "fileRead"
+ display_name = "File Read"
+ subtitle = "Read Contents"
+ icon = "📖"
+ color = "#8be9fd"
+ group = ("filesystem", "tool")
+ description = "Read file contents with line numbers and pagination"
+ component_kind = "square"
+ handles = (
+ {"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
+ usable_as_tool = True
+
+ Params = FileReadParams
+ Output = FileReadOutput
+
+ @Operation("read")
+ async def read(self, ctx: NodeContext, params: FileReadParams) -> Any:
+ from services.handlers.filesystem import handle_file_read
+ response = await handle_file_read(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "File read failed")
diff --git a/server/nodes/filesystem/fs_search.py b/server/nodes/filesystem/fs_search.py
new file mode 100644
index 00000000..650d8ec6
--- /dev/null
+++ b/server/nodes/filesystem/fs_search.py
@@ -0,0 +1,56 @@
+"""FS Search — Wave 11.C migration. ls / glob / grep modes."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class FsSearchParams(BaseModel):
+ mode: Literal["ls", "glob", "grep"] = "ls"
+ path: str = Field(default=".")
+ pattern: str = Field(default="")
+
+ model_config = ConfigDict(extra="ignore")
+
+
+class FsSearchOutput(BaseModel):
+ matches: Optional[list] = None
+ count: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class FsSearchNode(ActionNode):
+ type = "fsSearch"
+ display_name = "FS Search"
+ subtitle = "ls/glob/grep"
+ icon = "🔍"
+ color = "#8be9fd"
+ group = ("filesystem", "tool")
+ description = "Search the filesystem (ls, glob, grep)"
+ component_kind = "square"
+ handles = (
+ {"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
+ usable_as_tool = True
+
+ Params = FsSearchParams
+ Output = FsSearchOutput
+
+ @Operation("search")
+ async def search(self, ctx: NodeContext, params: FsSearchParams) -> Any:
+ from services.handlers.filesystem import handle_fs_search
+ response = await handle_fs_search(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "FS search failed")
diff --git a/server/nodes/filesystem/shell.py b/server/nodes/filesystem/shell.py
new file mode 100644
index 00000000..d101aba5
--- /dev/null
+++ b/server/nodes/filesystem/shell.py
@@ -0,0 +1,57 @@
+"""Shell — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class ShellParams(BaseModel):
+ command: str = Field(..., min_length=1)
+ cwd: str = Field(default="")
+ timeout: int = Field(default=30, ge=1, le=600)
+
+ model_config = ConfigDict(extra="ignore")
+
+
+class ShellOutput(BaseModel):
+ stdout: Optional[str] = None
+ exit_code: Optional[int] = None
+ truncated: Optional[bool] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class ShellNode(ActionNode):
+ type = "shell"
+ display_name = "Shell"
+ subtitle = "Run Command"
+ icon = "$_"
+ color = "#8be9fd"
+ group = ("filesystem", "tool")
+ description = "Execute shell commands (sandboxed; no system PATH)"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": True}
+ task_queue = TaskQueue.DEFAULT
+ usable_as_tool = True
+
+ Params = ShellParams
+ Output = ShellOutput
+
+ @Operation("execute")
+ async def execute_op(self, ctx: NodeContext, params: ShellParams) -> Any:
+ from services.handlers.filesystem import handle_shell
+ response = await handle_shell(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Shell command failed")
diff --git a/server/nodes/proxy/proxy_config.py b/server/nodes/proxy/proxy_config.py
new file mode 100644
index 00000000..a35bc82f
--- /dev/null
+++ b/server/nodes/proxy/proxy_config.py
@@ -0,0 +1,62 @@
+"""Proxy Config — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+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"
+ provider_name: str = Field(default="", alias="providerName")
+ config: Dict[str, Any] = Field(default_factory=dict)
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class ProxyConfigOutput(BaseModel):
+ operation: Optional[str] = None
+ providers: Optional[list] = None
+ rules: Optional[list] = None
+ success: Optional[bool] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class ProxyConfigNode(ActionNode):
+ type = "proxyConfig"
+ display_name = "Proxy Config"
+ subtitle = "Routing Rules"
+ icon = "🔧"
+ color = "#ffb86c"
+ group = ("proxy", "tool")
+ description = "Configure proxy providers and routing rules"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+ usable_as_tool = True
+
+ Params = ProxyConfigParams
+ Output = ProxyConfigOutput
+
+ @Operation("dispatch")
+ async def dispatch(self, ctx: NodeContext, params: ProxyConfigParams) -> Any:
+ from services.handlers.proxy import handle_proxy_config
+ response = await handle_proxy_config(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Proxy config failed")
diff --git a/server/nodes/proxy/proxy_request.py b/server/nodes/proxy/proxy_request.py
new file mode 100644
index 00000000..eb80a586
--- /dev/null
+++ b/server/nodes/proxy/proxy_request.py
@@ -0,0 +1,64 @@
+"""Proxy Request — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class ProxyRequestParams(BaseModel):
+ method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"] = "GET"
+ url: str = Field(...)
+ headers: Dict[str, str] = Field(default_factory=dict)
+ body: Optional[Any] = None
+ timeout: int = Field(default=30, ge=1, le=600)
+ proxy_provider: str = Field(default="auto", alias="proxyProvider")
+ proxy_country: str = Field(default="", alias="proxyCountry")
+ session_type: Literal["rotating", "sticky"] = Field(default="rotating", alias="sessionType")
+ sticky_duration: int = Field(default=600, alias="stickyDuration", ge=1)
+ max_retries: int = Field(default=3, alias="maxRetries", ge=0, le=10)
+ follow_redirects: bool = Field(default=True, alias="followRedirects")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class ProxyRequestOutput(BaseModel):
+ status: Optional[int] = None
+ body: Optional[Any] = None
+ proxy_used: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class ProxyRequestNode(ActionNode):
+ type = "proxyRequest"
+ display_name = "Proxy Request"
+ subtitle = "Routed HTTP"
+ icon = "🛡"
+ color = "#ffb86c"
+ group = ("proxy",)
+ description = "Make HTTP requests through residential proxy providers"
+ component_kind = "square"
+ handles = (
+ {"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}
+ task_queue = TaskQueue.REST_API
+
+ Params = ProxyRequestParams
+ Output = ProxyRequestOutput
+
+ @Operation("request")
+ async def request(self, ctx: NodeContext, params: ProxyRequestParams) -> Any:
+ from services.handlers.proxy import handle_proxy_request
+ response = await handle_proxy_request(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Proxy request failed")
diff --git a/server/nodes/proxy/proxy_status.py b/server/nodes/proxy/proxy_status.py
new file mode 100644
index 00000000..d23a60a8
--- /dev/null
+++ b/server/nodes/proxy/proxy_status.py
@@ -0,0 +1,53 @@
+"""Proxy Status — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class ProxyStatusParams(BaseModel):
+ provider_name: str = Field(default="", alias="providerName")
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class ProxyStatusOutput(BaseModel):
+ providers: Optional[list] = None
+ stats: Optional[dict] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class ProxyStatusNode(ActionNode):
+ type = "proxyStatus"
+ display_name = "Proxy Status"
+ subtitle = "Health Stats"
+ icon = "📊"
+ color = "#ffb86c"
+ group = ("proxy",)
+ description = "View proxy provider health, scores, and usage statistics"
+ component_kind = "square"
+ handles = (
+ {"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
+
+ Params = ProxyStatusParams
+ Output = ProxyStatusOutput
+
+ @Operation("status")
+ async def status(self, ctx: NodeContext, params: ProxyStatusParams) -> Any:
+ from services.handlers.proxy import handle_proxy_status
+ response = await handle_proxy_status(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Proxy status failed")
diff --git a/server/nodes/scheduler/cron_scheduler.py b/server/nodes/scheduler/cron_scheduler.py
new file mode 100644
index 00000000..6a402f16
--- /dev/null
+++ b/server/nodes/scheduler/cron_scheduler.py
@@ -0,0 +1,59 @@
+"""Cron Scheduler — Wave 11.C migration.
+
+Cron-expression-based scheduling trigger. Deployment-mode lifecycle
+(starting/stopping the cron job) is owned by ``deployment/triggers.py``;
+the run-button path runs handle_cron_scheduler directly for one-shot
+testing.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class CronSchedulerParams(BaseModel):
+ cron_expression: str = Field(default="0 * * * *", alias="cronExpression")
+ timezone: str = Field(default="UTC")
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class CronSchedulerOutput(BaseModel):
+ triggered_at: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class CronSchedulerNode(ActionNode):
+ type = "cronScheduler"
+ display_name = "Cron Scheduler"
+ subtitle = "Time-Based Trigger"
+ icon = "⏱"
+ color = "#ffb86c"
+ group = ("scheduler", "trigger")
+ description = "Cron expression-based scheduling trigger"
+ component_kind = "trigger"
+ 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
+
+ Params = CronSchedulerParams
+ Output = CronSchedulerOutput
+
+ @Operation("trigger")
+ async def trigger(self, ctx: NodeContext, params: CronSchedulerParams) -> Any:
+ from services.handlers.utility import handle_cron_scheduler
+ response = await handle_cron_scheduler(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success") is False:
+ raise RuntimeError(response.get("error") or "Cron failed")
+ return response.get("result") or {}
diff --git a/server/nodes/scheduler/timer.py b/server/nodes/scheduler/timer.py
new file mode 100644
index 00000000..e7e3824c
--- /dev/null
+++ b/server/nodes/scheduler/timer.py
@@ -0,0 +1,61 @@
+"""Timer — Wave 11.C migration.
+
+Sleep / delay node. Has both input and output handles (componentKind
+"square") so it can be inserted mid-workflow as a deliberate pause,
+not just at the start.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class TimerParams(BaseModel):
+ duration: int = Field(default=1, ge=1, le=86400)
+ unit: Literal["seconds", "minutes", "hours"] = "seconds"
+
+ model_config = ConfigDict(extra="ignore")
+
+
+class TimerOutput(BaseModel):
+ elapsed: Optional[float] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TimerNode(ActionNode):
+ type = "timer"
+ display_name = "Timer"
+ subtitle = "Delay Trigger"
+ icon = "⏰"
+ color = "#ffb86c"
+ group = ("scheduler",)
+ description = "Timer-based trigger with configurable delay"
+ component_kind = "square" # has input handle
+ handles = (
+ {"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
+ usable_as_tool = True
+
+ Params = TimerParams
+ Output = TimerOutput
+
+ @Operation("wait")
+ async def wait(self, ctx: NodeContext, params: TimerParams) -> Any:
+ from services.handlers.utility import handle_timer
+ response = await handle_timer(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success") is False:
+ raise RuntimeError(response.get("error") or "Timer failed")
+ return response.get("result") or {}
diff --git a/server/nodes/scraper/apify_actor.py b/server/nodes/scraper/apify_actor.py
new file mode 100644
index 00000000..1c6f20bc
--- /dev/null
+++ b/server/nodes/scraper/apify_actor.py
@@ -0,0 +1,59 @@
+"""Apify Actor — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class ApifyActorParams(BaseModel):
+ actor_id: str = Field(..., alias="actorId")
+ actor_input: Dict[str, Any] = Field(default_factory=dict, alias="actorInput")
+ max_results: int = Field(default=20, alias="maxResults", ge=1, le=10000)
+ timeout: int = Field(default=300, ge=1, le=3600)
+ memory: int = Field(default=512, ge=128, le=8192)
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class ApifyActorOutput(BaseModel):
+ items: Optional[list] = None
+ count: Optional[int] = None
+ run_id: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class ApifyActorNode(ActionNode):
+ type = "apifyActor"
+ display_name = "Apify Actor"
+ subtitle = "Web Scraper"
+ icon = "asset:apify"
+ color = "#ff79c6"
+ group = ("api", "scraper", "tool")
+ description = "Run Apify actors for Instagram, TikTok, Twitter, LinkedIn, etc."
+ component_kind = "square"
+ handles = (
+ {"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": True}
+ task_queue = TaskQueue.REST_API
+ usable_as_tool = True
+
+ Params = ApifyActorParams
+ Output = ApifyActorOutput
+
+ @Operation("run")
+ async def run(self, ctx: NodeContext, params: ApifyActorParams) -> Any:
+ from services.handlers.apify import handle_apify_actor
+ response = await handle_apify_actor(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Apify run failed")
diff --git a/server/nodes/scraper/crawlee_scraper.py b/server/nodes/scraper/crawlee_scraper.py
new file mode 100644
index 00000000..25f757c4
--- /dev/null
+++ b/server/nodes/scraper/crawlee_scraper.py
@@ -0,0 +1,62 @@
+"""Crawlee Scraper — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class CrawleeScraperParams(BaseModel):
+ url: str = Field(...)
+ crawler_type: Literal["beautifulsoup", "playwright", "adaptive"] = Field(
+ default="beautifulsoup", alias="crawlerType",
+ )
+ mode: Literal["single", "crawl"] = "single"
+ css_selector: str = Field(default="", alias="cssSelector")
+ extract_links: bool = Field(default=False, alias="extractLinks")
+ max_pages: int = Field(default=10, alias="maxPages", ge=1, le=1000)
+ take_screenshot: bool = Field(default=False, alias="takeScreenshot")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class CrawleeScraperOutput(BaseModel):
+ items: Optional[list] = None
+ pages_crawled: Optional[int] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class CrawleeScraperNode(ActionNode):
+ type = "crawleeScraper"
+ display_name = "Web Scraper"
+ subtitle = "Crawlee"
+ icon = "🕷"
+ color = "#ff79c6"
+ group = ("scraper", "tool")
+ description = "Web scraper supporting static HTML (BeautifulSoup) and JS-rendered (Playwright)"
+ component_kind = "square"
+ handles = (
+ {"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": True}
+ task_queue = TaskQueue.BROWSER
+ usable_as_tool = True
+
+ Params = CrawleeScraperParams
+ Output = CrawleeScraperOutput
+
+ @Operation("scrape")
+ async def scrape(self, ctx: NodeContext, params: CrawleeScraperParams) -> Any:
+ from services.handlers.crawlee import handle_crawlee_scraper
+ response = await handle_crawlee_scraper(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Crawlee scrape failed")
diff --git a/server/nodes/services.py b/server/nodes/services.py
index 712d99a6..dcea4973 100644
--- a/server/nodes/services.py
+++ b/server/nodes/services.py
@@ -1,108 +1,6 @@
-"""Service-node plugins (Wave 10.C batch 4 — bulk migration).
+"""Services legacy bulk file — fully migrated to per-domain folders.
-Migrates the remaining 72 entries from NODE_METADATA to the plugin
-pattern: every node carries its own visual contract. Organized into
-sections by family for skim-readability; each register_node call is
-fully explicit (no group-based lookup, no shared color tables).
-
-Sections:
- 1. Android services (16)
- 2. AI chat models + memory/skill (11)
- 3. Messaging (WhatsApp, Telegram, Twitter, Email, Chat) — 12
- 4. Google Workspace (6)
- 5. Web (search, browser, apify, crawlee, proxy, location) — 11
- 6. Data (filesystem, document, text) — 12
+All 60 service plugins (Android, AI models, messaging, Google,
+search, browser, scrapers, proxy, maps, filesystem, document, text)
+now live in their own folders under nodes/. Delete in Wave 11.D.
"""
-
-from __future__ import annotations
-
-from services.node_registry import register_node
-
-
-# Standard square-node handles: input-main + output-main. Used by the
-# vast majority of single-input/single-output square nodes below. Local
-# to this module — not a global lookup.
-_IO: list[dict] = [
- {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
- {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
-]
-
-# Output-only (model nodes connect upward to agents, no main I/O flow)
-_MODEL_OUT: list[dict] = [
- {"name": "output-model", "kind": "output", "position": "right", "label": "Model", "role": "model"},
-]
-
-
-# ---------------------------------------------------------------------------
-# 1. Android services (16) — green family, all SquareNode
-# ---------------------------------------------------------------------------
-
-_GREEN = "#50fa7b"
-
-# All 16 Android services — migrated to nodes/android/*.py (Wave 11.C).
-
-
-# ---------------------------------------------------------------------------
-# 2. AI chat models (9) + memory + skill — model dispatch + accent colors
-# ---------------------------------------------------------------------------
-
-# All 9 chat models — migrated to nodes/model/*.py (Wave 11.C).
-
-# simpleMemory + masterSkill — migrated to nodes/skill/*.py (Wave 11.C).
-
-
-# ---------------------------------------------------------------------------
-# 3. Messaging — WhatsApp, Telegram, Twitter, Email, Chat
-# ---------------------------------------------------------------------------
-
-# whatsappSend + whatsappDb — migrated to nodes/whatsapp/*.py (Wave 11.C).
-# telegramSend — migrated to nodes/telegram/telegram_send.py (Wave 11.C).
-
-# twitterSend / twitterSearch / twitterUser — migrated to nodes/twitter/*.py (Wave 11.C).
-# emailSend / emailRead — migrated to nodes/email/*.py (Wave 11.C).
-# chatSend / chatHistory — migrated to nodes/chat/*.py (Wave 11.C).
-
-
-# ---------------------------------------------------------------------------
-# 4. Google Workspace (6) — branded blue
-# ---------------------------------------------------------------------------
-
-# All Google Workspace nodes — migrated to nodes/google/*.py (Wave 11.B/11.C).
-
-
-# ---------------------------------------------------------------------------
-# 5. Web — search, browser, scrapers, proxy, location
-# ---------------------------------------------------------------------------
-
-# All search nodes (brave / serper / perplexity) — migrated to nodes/search/*.py.
-
-register_node(type="browser", metadata={"displayName": "Browser", "subtitle": "Browser Automation","icon": "asset:chrome", "color": "#ff79c6", "group": ["browser", "tool"], "componentKind": "square", "handles": _IO, "description": "Interactive browser automation via agent-browser CLI", "version": 1})
-register_node(type="apifyActor", metadata={"displayName": "Apify Actor", "subtitle": "Web Scraper", "icon": "asset:apify", "color": "#ff79c6", "group": ["api", "scraper", "tool"], "componentKind": "square", "handles": _IO, "description": "Run Apify actors for Instagram, TikTok, Twitter, LinkedIn, etc.", "version": 1})
-register_node(type="crawleeScraper", metadata={"displayName": "Web Scraper", "subtitle": "Crawlee", "icon": "🕷", "color": "#ff79c6", "group": ["scraper", "tool"], "componentKind": "square", "handles": _IO, "description": "Web scraper supporting static HTML (BeautifulSoup) and JS-rendered (Playwright)", "version": 1})
-
-register_node(type="proxyRequest", metadata={"displayName": "Proxy Request", "subtitle": "Routed HTTP", "icon": "🛡", "color": "#ffb86c", "group": ["proxy"], "componentKind": "square", "handles": _IO, "description": "Make HTTP requests through residential proxy providers", "version": 1})
-register_node(type="proxyConfig", metadata={"displayName": "Proxy Config", "subtitle": "Routing Rules", "icon": "🔧", "color": "#ffb86c", "group": ["proxy", "tool"], "componentKind": "square", "handles": _IO, "description": "Configure proxy providers and routing rules", "version": 1})
-register_node(type="proxyStatus", metadata={"displayName": "Proxy Status", "subtitle": "Health Stats", "icon": "📊", "color": "#ffb86c", "group": ["proxy"], "componentKind": "square", "handles": _IO, "description": "View proxy provider health, scores, and usage statistics", "version": 1})
-
-# All Maps nodes (gmaps_create / gmaps_locations / gmaps_nearby_places) —
-# migrated to nodes/location/*.py (Wave 11.C).
-
-
-# ---------------------------------------------------------------------------
-# 6. Data — filesystem, document, text
-# ---------------------------------------------------------------------------
-
-register_node(type="fileRead", metadata={"displayName": "File Read", "subtitle": "Read Contents", "icon": "📖", "color": "#8be9fd", "group": ["filesystem", "tool"], "componentKind": "square", "handles": _IO, "description": "Read file contents with line numbers and pagination", "version": 1})
-register_node(type="fileModify", metadata={"displayName": "File Modify", "subtitle": "Write/Edit", "icon": "✏️", "color": "#8be9fd", "group": ["filesystem", "tool"], "componentKind": "square", "handles": _IO, "description": "Write new files or edit existing files", "version": 1})
-register_node(type="shell", metadata={"displayName": "Shell", "subtitle": "Run Command", "icon": "$_", "color": "#8be9fd", "group": ["filesystem", "tool"], "componentKind": "square", "handles": _IO, "description": "Execute shell commands (sandboxed; no system PATH)", "version": 1})
-register_node(type="fsSearch", metadata={"displayName": "FS Search", "subtitle": "ls/glob/grep", "icon": "🔍", "color": "#8be9fd", "group": ["filesystem", "tool"], "componentKind": "square", "handles": _IO, "description": "Search the filesystem (ls, glob, grep)", "version": 1})
-
-register_node(type="httpScraper", metadata={"displayName": "HTTP Scraper", "subtitle": "Page Pagination","icon": "🔍", "color": "#bd93f9", "group": ["document"], "componentKind": "square", "handles": _IO, "description": "Scrape links from web pages with date/page pagination support", "version": 1})
-register_node(type="fileDownloader", metadata={"displayName": "File Downloader", "subtitle": "Parallel DL", "icon": "⬇️", "color": "#bd93f9", "group": ["document"], "componentKind": "square", "handles": _IO, "description": "Download files from URLs in parallel", "version": 1})
-register_node(type="documentParser", metadata={"displayName": "Document Parser", "subtitle": "Parse to Text", "icon": "📄", "color": "#bd93f9", "group": ["document"], "componentKind": "square", "handles": _IO, "description": "Parse documents to text using configurable parsers", "version": 1})
-register_node(type="textChunker", metadata={"displayName": "Text Chunker", "subtitle": "Chunk Text", "icon": "✂️", "color": "#bd93f9", "group": ["document"], "componentKind": "square", "handles": _IO, "description": "Split text into overlapping chunks for embedding", "version": 1})
-register_node(type="embeddingGenerator",metadata={"displayName": "Embedding Generator","subtitle": "Vectorize", "icon": "🧮", "color": "#bd93f9", "group": ["document"], "componentKind": "square", "handles": _IO, "description": "Generate vector embeddings from text chunks", "version": 1})
-register_node(type="vectorStore", metadata={"displayName": "Vector Store", "subtitle": "Store/Query", "icon": "🗄", "color": "#bd93f9", "group": ["document"], "componentKind": "square", "handles": _IO, "description": "Store and query vector embeddings", "version": 1})
-
-register_node(type="fileHandler", metadata={"displayName": "File Handler", "subtitle": "Read/Write Files", "icon": "📁", "color": "#bd93f9", "group": ["text"], "componentKind": "square", "handles": _IO, "description": "Read, write, and process files", "version": 1})
-register_node(type="textGenerator", metadata={"displayName": "Text Generator", "subtitle": "Static / AI Text", "icon": "📝", "color": "#bd93f9", "group": ["text"], "componentKind": "square", "handles": _IO, "description": "Generate text using static, AI, file, or API source", "version": 1})
diff --git a/server/nodes/text/file_handler.py b/server/nodes/text/file_handler.py
new file mode 100644
index 00000000..92d290ca
--- /dev/null
+++ b/server/nodes/text/file_handler.py
@@ -0,0 +1,61 @@
+"""File Handler — Wave 11.C migration. Read/write/process files."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class FileHandlerParams(BaseModel):
+ operation: Literal["read", "write", "append", "delete"] = "read"
+ file_path: str = Field(..., alias="filePath")
+ content: str = Field(default="")
+ encoding: str = Field(default="utf-8")
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class FileHandlerOutput(BaseModel):
+ operation: Optional[str] = None
+ content: Optional[str] = None
+ success: Optional[bool] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class FileHandlerNode(ActionNode):
+ type = "fileHandler"
+ display_name = "File Handler"
+ subtitle = "Read/Write Files"
+ icon = "📁"
+ color = "#bd93f9"
+ group = ("text",)
+ description = "Read, write, and process files"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = FileHandlerParams
+ Output = FileHandlerOutput
+
+ @Operation("dispatch")
+ async def dispatch(self, ctx: NodeContext, params: FileHandlerParams) -> Any:
+ from core.container import container
+ from services.handlers.utility import handle_file_handler
+
+ text_service = container.text_service()
+ response = await handle_file_handler(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True),
+ context=ctx.raw, text_service=text_service,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "File handler failed")
diff --git a/server/nodes/text/text_generator.py b/server/nodes/text/text_generator.py
new file mode 100644
index 00000000..efd60cc3
--- /dev/null
+++ b/server/nodes/text/text_generator.py
@@ -0,0 +1,60 @@
+"""Text Generator — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class TextGeneratorParams(BaseModel):
+ source: Literal["static", "ai", "file", "api"] = "static"
+ text: str = Field(default="", json_schema_extra={"rows": 4})
+ file_path: str = Field(default="", alias="filePath")
+ api_url: str = Field(default="", alias="apiUrl")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class TextGeneratorOutput(BaseModel):
+ text: Optional[str] = None
+ source: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TextGeneratorNode(ActionNode):
+ type = "textGenerator"
+ display_name = "Text Generator"
+ subtitle = "Static / AI Text"
+ icon = "📝"
+ color = "#bd93f9"
+ group = ("text",)
+ description = "Generate text using static, AI, file, or API source"
+ component_kind = "square"
+ handles = (
+ {"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": True}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = TextGeneratorParams
+ Output = TextGeneratorOutput
+
+ @Operation("generate")
+ async def generate(self, ctx: NodeContext, params: TextGeneratorParams) -> Any:
+ from core.container import container
+ from services.handlers.utility import handle_text_generator
+
+ text_service = container.text_service()
+ response = await handle_text_generator(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True),
+ context=ctx.raw, text_service=text_service,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Text generator failed")
diff --git a/server/nodes/tool/current_time_tool.py b/server/nodes/tool/current_time_tool.py
new file mode 100644
index 00000000..fdbc08e1
--- /dev/null
+++ b/server/nodes/tool/current_time_tool.py
@@ -0,0 +1,61 @@
+"""Current Time Tool — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, ToolNode
+
+
+class CurrentTimeParams(BaseModel):
+ timezone: str = Field(
+ default="UTC",
+ description="Timezone (e.g. UTC, America/New_York, Europe/London)",
+ )
+
+
+class CurrentTimeOutput(BaseModel):
+ iso: str
+ timezone: str
+ unix: int
+
+
+class CurrentTimeToolNode(ToolNode):
+ type = "currentTimeTool"
+ display_name = "Current Time"
+ subtitle = "Date / Time"
+ icon = "🕒"
+ color = "#f1fa8c"
+ group = ("tool", "ai")
+ description = "Get current date/time with timezone support"
+ component_kind = "tool"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left",
+ "label": "Input", "role": "main"},
+ {"name": "output-tool", "kind": "output", "position": "top",
+ "label": "Tool", "role": "tools"},
+ )
+ ui_hints = {"isToolPanel": True, "hideRunButton": True}
+ annotations = {"destructive": False, "readonly": True, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = CurrentTimeParams
+ Output = CurrentTimeOutput
+
+ @Operation("now")
+ async def now(self, ctx: NodeContext, params: CurrentTimeParams) -> CurrentTimeOutput:
+ try:
+ from zoneinfo import ZoneInfo
+ tz = ZoneInfo(params.timezone)
+ except Exception:
+ from zoneinfo import ZoneInfo
+ tz = ZoneInfo("UTC")
+ now = datetime.now(tz)
+ return CurrentTimeOutput(
+ iso=now.isoformat(),
+ timezone=params.timezone,
+ unix=int(now.timestamp()),
+ )
diff --git a/server/nodes/tool/task_manager.py b/server/nodes/tool/task_manager.py
new file mode 100644
index 00000000..a2cfa8e8
--- /dev/null
+++ b/server/nodes/tool/task_manager.py
@@ -0,0 +1,57 @@
+"""Task Manager Tool — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, ToolNode
+
+
+class TaskManagerParams(BaseModel):
+ action: Literal["create", "list", "complete", "delete", "update"] = "create"
+ task_id: Optional[str] = Field(default=None)
+ title: Optional[str] = None
+ description: Optional[str] = None
+ status: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TaskManagerOutput(BaseModel):
+ task_id: Optional[str] = None
+ tasks: Optional[list] = None
+ success: Optional[bool] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TaskManagerNode(ToolNode):
+ type = "taskManager"
+ display_name = "Task Manager"
+ subtitle = "AI Task Tracking"
+ icon = "📋"
+ color = "#f1fa8c"
+ group = ("tool", "ai")
+ description = "Task management tool for AI agents to create, track, and manage tasks"
+ component_kind = "tool"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left",
+ "label": "Input", "role": "main"},
+ {"name": "output-tool", "kind": "output", "position": "top",
+ "label": "Tool", "role": "tools"},
+ )
+ ui_hints = {"isToolPanel": True, "hideRunButton": True}
+ annotations = {"destructive": True, "readonly": False, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = TaskManagerParams
+ Output = TaskManagerOutput
+
+ @Operation("manage")
+ async def manage(self, ctx: NodeContext, params: TaskManagerParams) -> Any:
+ from services.handlers.tools import _execute_task_manager
+ return await _execute_task_manager(
+ params.model_dump(), {"node_id": ctx.node_id, "workspace_dir": ctx.workspace_dir or ""},
+ )
diff --git a/server/nodes/tool/write_todos.py b/server/nodes/tool/write_todos.py
new file mode 100644
index 00000000..3756134c
--- /dev/null
+++ b/server/nodes/tool/write_todos.py
@@ -0,0 +1,62 @@
+"""Write Todos Tool — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, ToolNode
+
+
+class TodoItem(BaseModel):
+ id: Optional[str] = None
+ content: str
+ status: Literal["pending", "in_progress", "completed"] = "pending"
+
+
+class WriteTodosParams(BaseModel):
+ todos: List[TodoItem] = Field(default_factory=list)
+
+ model_config = ConfigDict(extra="allow")
+
+
+class WriteTodosOutput(BaseModel):
+ todos: Optional[list] = None
+ summary: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class WriteTodosNode(ToolNode):
+ type = "writeTodos"
+ display_name = "Write Todos"
+ subtitle = "Plan-Work-Update Loop"
+ icon = "✅"
+ color = "#bd93f9"
+ group = ("tool", "ai")
+ description = "Structured task list planning for complex multi-step operations"
+ component_kind = "tool"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left",
+ "label": "Input", "role": "main"},
+ {"name": "output-tool", "kind": "output", "position": "top",
+ "label": "Tool", "role": "tools"},
+ )
+ ui_hints = {"isToolPanel": True, "hideRunButton": True}
+ annotations = {"destructive": False, "readonly": False, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = WriteTodosParams
+ Output = WriteTodosOutput
+
+ @Operation("write")
+ async def write(self, ctx: NodeContext, params: WriteTodosParams) -> Any:
+ from services.handlers.todo import execute_write_todos
+ config = {
+ "node_id": ctx.node_id,
+ "workspace_dir": ctx.workspace_dir or "",
+ "workflow_id": ctx.workflow_id,
+ "session_id": ctx.session_id,
+ }
+ return await execute_write_todos(params.model_dump(), config)
diff --git a/server/nodes/tools.py b/server/nodes/tools.py
index a485954f..ed830a65 100644
--- a/server/nodes/tools.py
+++ b/server/nodes/tools.py
@@ -1,75 +1,12 @@
-"""Dedicated tool node plugins (Wave 10.G.3).
+"""Tool legacy bulk file — fully migrated.
-Five nodes that connect to an AI Agent's ``input-tools`` handle as
-passive capabilities: calculator, current-time, duckduckgo-search,
-task-manager, write-todos. Each emits ``componentKind: "tool"``,
-``isToolPanel: True`` so MiddleSection renders the Tool Schema Editor
-without consulting a hardcoded ``TOOL_NODE_TYPES`` array.
+Tool plugins now live in nodes/tool/ + nodes/skill/ + nodes/search/:
+ - tool/calculator_tool.py
+ - tool/current_time_tool.py
+ - tool/task_manager.py
+ - tool/write_todos.py
+ - search/duckduckgo_search.py
+ - skill/master_skill.py
-Handle shape: input-main (trigger) on the left, a top ``output-tool``
-handle (so the agent can draw an arc upward). No right-side output —
-these are passive tool nodes, not general-purpose squares.
+Delete in Wave 11.D.
"""
-
-from __future__ import annotations
-
-from services.node_registry import register_node
-
-
-_TOOL_HANDLES: list[dict] = [
- {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
- {"name": "output-tool", "kind": "output", "position": "top", "label": "Tool", "role": "tools"},
-]
-
-
-# calculatorTool — migrated to nodes/calculator_tool.py (Wave 11.B class-based plugin).
-
-register_node(
- type="currentTimeTool",
- metadata={
- "displayName": "Current Time",
- "subtitle": "Date / Time",
- "icon": "🕒",
- "color": "#f1fa8c",
- "group": ["tool", "ai"],
- "componentKind": "tool",
- "handles": _TOOL_HANDLES,
- "description": "Get current date/time with timezone support",
- "version": 1,
- "uiHints": {"isToolPanel": True, "hideRunButton": True},
- },
-)
-
-# duckduckgoSearch — migrated to nodes/search/duckduckgo_search.py (Wave 11.C).
-
-register_node(
- type="taskManager",
- metadata={
- "displayName": "Task Manager",
- "subtitle": "AI Task Tracking",
- "icon": "📋",
- "color": "#f1fa8c",
- "group": ["tool", "ai"],
- "componentKind": "tool",
- "handles": _TOOL_HANDLES,
- "description": "Task management tool for AI agents to create, track, and manage tasks",
- "version": 1,
- "uiHints": {"isToolPanel": True, "hideRunButton": True},
- },
-)
-
-register_node(
- type="writeTodos",
- metadata={
- "displayName": "Write Todos",
- "subtitle": "Plan-Work-Update Loop",
- "icon": "✅",
- "color": "#bd93f9",
- "group": ["tool", "ai"],
- "componentKind": "tool",
- "handles": _TOOL_HANDLES,
- "description": "Structured task list planning for complex multi-step operations",
- "version": 1,
- "uiHints": {"isToolPanel": True, "hideRunButton": True},
- },
-)
diff --git a/server/nodes/trigger/task_trigger.py b/server/nodes/trigger/task_trigger.py
new file mode 100644
index 00000000..554c0c6a
--- /dev/null
+++ b/server/nodes/trigger/task_trigger.py
@@ -0,0 +1,82 @@
+"""Task Trigger — Wave 11.C migration.
+
+Event-based trigger that fires when a delegated child agent completes
+its task (success or error). Listens for ``task_completed`` events on
+``event_waiter``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, TriggerNode
+
+
+class TaskTriggerParams(BaseModel):
+ task_id: str = Field(default="", alias="taskId")
+ agent_name: str = Field(default="", alias="agentName")
+ status_filter: Literal["all", "completed", "error"] = Field(
+ default="all", alias="statusFilter",
+ )
+ parent_node_id: str = Field(default="", alias="parentNodeId")
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class TaskTriggerOutput(BaseModel):
+ task_id: Optional[str] = None
+ status: Optional[str] = None
+ agent_name: Optional[str] = None
+ result: Optional[str] = None
+ error: Optional[str] = None
+ workflow_id: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TaskTriggerNode(TriggerNode):
+ type = "taskTrigger"
+ display_name = "Task Completed"
+ subtitle = "Delegated Task Done"
+ icon = "📨"
+ color = "#ffb86c"
+ group = ("trigger", "workflow")
+ description = "Triggers when a delegated child agent completes its task (success or error)"
+ component_kind = "trigger"
+ handles = (
+ {"name": "output-main", "kind": "output", "position": "right",
+ "label": "Output", "role": "main"},
+ )
+ task_queue = TaskQueue.TRIGGERS_EVENT
+ mode = "event"
+ event_type = "task_completed"
+
+ Params = TaskTriggerParams
+ Output = TaskTriggerOutput
+
+ def build_filter(self, params: TaskTriggerParams) -> Callable[[Dict[str, Any]], bool]:
+ task_id = params.task_id
+ agent_name = params.agent_name.lower()
+ status = params.status_filter
+ parent = params.parent_node_id
+
+ def matches(event: Dict[str, Any]) -> bool:
+ if task_id and event.get("task_id") != task_id:
+ return False
+ if status != "all" and event.get("status") != status:
+ return False
+ if agent_name and agent_name not in str(event.get("agent_name", "")).lower():
+ return False
+ if parent and event.get("parent_node_id") != parent:
+ return False
+ return True
+
+ return matches
+
+ @Operation("wait")
+ async def wait(self, ctx: NodeContext, params: TaskTriggerParams) -> TaskTriggerOutput:
+ raise NotImplementedError(
+ "Event triggers return via TriggerNode.execute, not the op body"
+ )
diff --git a/server/nodes/triggers.py b/server/nodes/triggers.py
index fd121988..9f0f389f 100644
--- a/server/nodes/triggers.py
+++ b/server/nodes/triggers.py
@@ -1,151 +1,13 @@
-"""Trigger node plugins (Wave 10.C migration batch 2).
-
-The 10 trigger types: start, cronScheduler, timer, webhookTrigger,
-chatTrigger, taskTrigger, whatsappReceive, telegramReceive,
-twitterReceive, gmailReceive, emailReceive.
-
-Triggers all share the same React Flow component (`TriggerNode`) and
-the same handle topology: a single output handle on the right that
-emits event data to downstream nodes. The legacy frontend hardcoded
-`TRIGGER_NODE_TYPES` to recognize them; with each registration declaring
-its own ``componentKind: "trigger"`` and handles, that array goes away
-in Wave 10.E.
-
-Each register_node call carries everything the frontend needs to
-render the trigger correctly. No global lookup tables.
+"""Trigger legacy bulk file — fully migrated to per-domain folders.
+
+ - workflow/start.py
+ - scheduler/cron_scheduler.py + timer.py
+ - trigger/webhook_trigger.py + chat_trigger.py + task_trigger.py
+ - whatsapp/whatsapp_receive.py
+ - telegram/telegram_receive.py
+ - twitter/twitter_receive.py
+ - google/gmail_receive.py
+ - email/email_receive.py
+
+Delete in Wave 11.D.
"""
-
-from __future__ import annotations
-
-from services.node_registry import register_node
-
-
-_TRIGGER_OUTPUT_HANDLES: list[dict] = [
- {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
-]
-
-
-# `start` is special: kept as componentKind "start" so the frontend
-# StartNode component (different visual treatment, no input section)
-# can render it. Triggers proper start with `componentKind: "trigger"`.
-
-register_node(
- type="start",
- metadata={
- "displayName": "Start",
- "subtitle": "Workflow Start",
- "icon": "▶",
- "color": "#bd93f9",
- "group": ["workflow"],
- "componentKind": "start",
- "handles": _TRIGGER_OUTPUT_HANDLES,
- "description": "Starting point for workflow execution. Provides initial data to connected nodes.",
- "version": 1,
- # `hasInitialDataBlob` tells the InputSection the output shape comes
- # from a user-authored JSON blob on the node itself (the `initialData`
- # field), not a backend Pydantic schema. Used to be an inline
- # `nodeType === 'start'` check on the frontend.
- "uiHints": {"hideInputSection": True, "hideOutputSection": True, "hasInitialDataBlob": True},
- },
-)
-
-register_node(
- type="cronScheduler",
- metadata={
- "displayName": "Cron Scheduler",
- "subtitle": "Time-Based Trigger",
- "icon": "⏱",
- "color": "#ffb86c",
- "group": ["scheduler", "trigger"],
- "componentKind": "trigger",
- "handles": _TRIGGER_OUTPUT_HANDLES,
- "description": "Cron expression-based scheduling trigger",
- "version": 1,
- },
-)
-
-register_node(
- type="timer",
- metadata={
- "displayName": "Timer",
- "subtitle": "Delay Trigger",
- "icon": "⏰",
- "color": "#ffb86c",
- "group": ["scheduler"],
- "componentKind": "square", # has input handle, not a trigger node visually
- "handles": [
- {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
- {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
- ],
- "description": "Timer-based trigger with configurable delay",
- "version": 1,
- },
-)
-
-# webhookTrigger — migrated to nodes/webhook_trigger.py (Wave 11.B class-based plugin).
-
-# chatTrigger — migrated to nodes/trigger/chat_trigger.py (Wave 11.C).
-
-register_node(
- type="taskTrigger",
- metadata={
- "displayName": "Task Completed",
- "subtitle": "Delegated Task Done",
- "icon": "📨",
- "color": "#ffb86c",
- "group": ["trigger", "workflow"],
- "componentKind": "trigger",
- "handles": _TRIGGER_OUTPUT_HANDLES,
- "description": "Triggers when a delegated child agent completes its task (success or error)",
- "version": 1,
- },
-)
-
-register_node(
- type="whatsappReceive",
- metadata={
- "displayName": "WhatsApp Receive",
- "subtitle": "Inbound Message",
- "icon": "asset:whatsapp-receive",
- "color": "#25D366",
- "group": ["whatsapp", "trigger"],
- "componentKind": "trigger",
- "handles": _TRIGGER_OUTPUT_HANDLES,
- "description": "Trigger workflow when WhatsApp message is received",
- "version": 1,
- },
-)
-
-# telegramReceive — migrated to nodes/telegram/telegram_receive.py (Wave 11.C).
-
-register_node(
- type="twitterReceive",
- metadata={
- "displayName": "Twitter Receive",
- "subtitle": "Mentions / DMs",
- "icon": "asset:x",
- "color": "#1DA1F2",
- "group": ["social", "trigger"],
- "componentKind": "trigger",
- "handles": _TRIGGER_OUTPUT_HANDLES,
- "description": "Trigger workflow on Twitter mentions, search results, or timeline updates (polling-based)",
- "version": 1,
- },
-)
-
-# gmailReceive — migrated to nodes/gmail_receive.py (Wave 11.B class-based plugin).
-
-register_node(
- type="emailReceive",
- metadata={
- "displayName": "Email Receive",
- "subtitle": "IMAP Polling",
- "icon": "asset:receive",
- "color": "#8be9fd",
- "group": ["email", "trigger"],
- "componentKind": "trigger",
- "handles": _TRIGGER_OUTPUT_HANDLES,
- "description": "Polling trigger for new emails via IMAP",
- "version": 1,
- },
-)
diff --git a/server/nodes/twitter/twitter_receive.py b/server/nodes/twitter/twitter_receive.py
new file mode 100644
index 00000000..2a3f4367
--- /dev/null
+++ b/server/nodes/twitter/twitter_receive.py
@@ -0,0 +1,67 @@
+"""Twitter Receive — Wave 11.C migration (polling trigger)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, TriggerNode
+
+
+class TwitterReceiveParams(BaseModel):
+ trigger_type: Literal["mentions", "search", "timeline"] = Field(
+ default="mentions", alias="triggerType",
+ )
+ search_query: str = Field(default="", alias="searchQuery")
+ user_id: str = Field(default="", alias="userId")
+ filter_retweets: bool = Field(default=True, alias="filterRetweets")
+ filter_replies: bool = Field(default=False, alias="filterReplies")
+ poll_interval: int = Field(default=60, alias="pollInterval", ge=15, le=3600)
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class TwitterReceiveOutput(BaseModel):
+ tweet_id: Optional[str] = None
+ text: Optional[str] = None
+ author: Optional[str] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TwitterReceiveNode(TriggerNode):
+ type = "twitterReceive"
+ display_name = "Twitter Receive"
+ subtitle = "Mentions / DMs"
+ icon = "asset:x"
+ color = "#1DA1F2"
+ group = ("social", "trigger")
+ description = "Trigger workflow on Twitter mentions, search results, or timeline updates (polling-based)"
+ component_kind = "trigger"
+ handles = (
+ {"name": "output-main", "kind": "output", "position": "right",
+ "label": "Output", "role": "main"},
+ )
+ task_queue = TaskQueue.TRIGGERS_POLL
+ mode = "polling"
+ default_poll_interval = 60
+
+ Params = TwitterReceiveParams
+ Output = TwitterReceiveOutput
+
+ async def execute(
+ self,
+ node_id: str,
+ parameters: Dict[str, Any],
+ context: NodeContext,
+ ) -> Dict[str, Any]:
+ from services.handlers.triggers import handle_trigger_node
+ return await handle_trigger_node(
+ node_id=node_id, node_type=self.type,
+ parameters=parameters, context=context.raw,
+ )
+
+ @Operation("wait")
+ async def wait(self, ctx: NodeContext, params: TwitterReceiveParams) -> TwitterReceiveOutput:
+ raise NotImplementedError("Polling trigger uses execute() override")
diff --git a/server/nodes/utilities.py b/server/nodes/utilities.py
index fc04d744..b0f52740 100644
--- a/server/nodes/utilities.py
+++ b/server/nodes/utilities.py
@@ -1,142 +1,7 @@
-"""Utility / code / process / messaging node plugins (Wave 10.C batch 3).
+"""Utilities legacy bulk file — fully migrated to per-domain folders.
-Migrates the bulk of square-shaped tool nodes that the editor renders
-via SquareNode. Each node carries its own icon, brand color, handle
-topology, and any uiHints (e.g. hasCodeEditor for code executors).
-No global lookup tables.
-"""
-
-from __future__ import annotations
-
-from services.node_registry import register_node
-
-
-# Standard square-node handles: one main input on the left, one main
-# output on the right. Most tool/utility nodes use this exact shape.
-_SQUARE_HANDLES: list[dict] = [
- {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
- {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
-]
-
-
-# -- Utility ---------------------------------------------------------------
-
-register_node(
- type="httpRequest",
- metadata={
- "displayName": "HTTP Request",
- "subtitle": "Outbound HTTP",
- "icon": "🌐",
- "color": "#8be9fd",
- "group": ["utility", "tool"],
- "componentKind": "square",
- "handles": _SQUARE_HANDLES,
- "description": "Make HTTP requests to external APIs",
- "version": 1,
- },
-)
-
-register_node(
- type="webhookResponse",
- metadata={
- "displayName": "Webhook Response",
- "subtitle": "Send Response",
- "icon": "↩️",
- "color": "#8be9fd",
- "group": ["utility"],
- "componentKind": "square",
- "handles": _SQUARE_HANDLES,
- "description": "Send response back to webhook caller",
- "version": 1,
- },
-)
-
-# console — migrated to nodes/utility/console.py (Wave 11.C).
+ - utility/{http_request,webhook_response,team_monitor,console,process_manager}.py
+ - code/{python,javascript,typescript}_executor.py
-register_node(
- type="teamMonitor",
- metadata={
- "displayName": "Team Monitor",
- "subtitle": "Live Team View",
- "icon": "📊",
- "color": "#bd93f9",
- "group": ["utility", "agent"],
- "componentKind": "square",
- "handles": [
- {"name": "input-main", "kind": "input", "position": "left", "label": "Team", "role": "main"},
- ],
- "description": "Monitor agent team operations, tasks, and messages in real-time",
- "version": 1,
- "uiHints": {"hideInputSection": True, "hideOutputSection": True, "isMonitorPanel": True, "hideRunButton": True},
- "hideOutputHandle": True,
- },
-)
-
-
-# -- Code (with code editor uiHint) ---------------------------------------
-
-register_node(
- type="pythonExecutor",
- metadata={
- "displayName": "Python Executor",
- "subtitle": "Run Python",
- "icon": "https://cdn.jsdelivr.net/gh/devicons/devicon/icons/python/python-original.svg",
- "color": "#ff79c6",
- "group": ["code", "tool"],
- "componentKind": "square",
- "handles": _SQUARE_HANDLES,
- "description": "Execute Python code with input data access",
- "version": 1,
- "uiHints": {"hasCodeEditor": True},
- },
-)
-
-register_node(
- type="javascriptExecutor",
- metadata={
- "displayName": "JavaScript Executor",
- "subtitle": "Run JS",
- "icon": "https://cdn.jsdelivr.net/gh/devicons/devicon/icons/javascript/javascript-original.svg",
- "color": "#ff79c6",
- "group": ["code", "tool"],
- "componentKind": "square",
- "handles": _SQUARE_HANDLES,
- "description": "Execute JavaScript code with input data access",
- "version": 1,
- "uiHints": {"hasCodeEditor": True},
- },
-)
-
-register_node(
- type="typescriptExecutor",
- metadata={
- "displayName": "TypeScript Executor",
- "subtitle": "Run TS",
- "icon": "https://cdn.jsdelivr.net/gh/devicons/devicon/icons/typescript/typescript-original.svg",
- "color": "#ff79c6",
- "group": ["code", "tool"],
- "componentKind": "square",
- "handles": _SQUARE_HANDLES,
- "description": "Execute TypeScript code with input data access and type safety",
- "version": 1,
- "uiHints": {"hasCodeEditor": True},
- },
-)
-
-
-# -- Process management ---------------------------------------------------
-
-register_node(
- type="processManager",
- metadata={
- "displayName": "Process Manager",
- "subtitle": "Long-running Procs",
- "icon": "⚙️",
- "color": "#ffb86c",
- "group": ["utility", "tool"],
- "componentKind": "square",
- "handles": _SQUARE_HANDLES,
- "description": "Start, stop, and manage long-running processes (dev servers, watchers, build tools). Streams output to Terminal tab.",
- "version": 1,
- },
-)
+Delete in Wave 11.D.
+"""
diff --git a/server/nodes/utility/http_request.py b/server/nodes/utility/http_request.py
new file mode 100644
index 00000000..07b52fac
--- /dev/null
+++ b/server/nodes/utility/http_request.py
@@ -0,0 +1,60 @@
+"""HTTP Request — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class HttpRequestParams(BaseModel):
+ method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"] = "GET"
+ url: str = Field(...)
+ headers: Dict[str, str] = Field(default_factory=dict)
+ body: Optional[Any] = None
+ timeout: int = Field(default=30, ge=1, le=600)
+ use_proxy: bool = Field(default=False, alias="useProxy")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class HttpRequestOutput(BaseModel):
+ status: Optional[int] = None
+ headers: Optional[dict] = None
+ body: Optional[Any] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class HttpRequestNode(ActionNode):
+ type = "httpRequest"
+ display_name = "HTTP Request"
+ subtitle = "REST Call"
+ icon = "🌐"
+ color = "#bd93f9"
+ group = ("utility", "tool")
+ description = "Make HTTP requests to external APIs (GET, POST, PUT, DELETE, PATCH)"
+ component_kind = "square"
+ handles = (
+ {"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}
+ task_queue = TaskQueue.REST_API
+ usable_as_tool = True
+
+ Params = HttpRequestParams
+ Output = HttpRequestOutput
+
+ @Operation("request")
+ async def request(self, ctx: NodeContext, params: HttpRequestParams) -> Any:
+ from services.handlers.http import handle_http_request
+ response = await handle_http_request(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "HTTP request failed")
diff --git a/server/nodes/utility/process_manager.py b/server/nodes/utility/process_manager.py
new file mode 100644
index 00000000..1c3b15d8
--- /dev/null
+++ b/server/nodes/utility/process_manager.py
@@ -0,0 +1,64 @@
+"""Process Manager — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class ProcessManagerParams(BaseModel):
+ operation: Literal["start", "stop", "restart", "list", "send_input", "get_output"] = "list"
+ name: str = Field(default="")
+ command: str = Field(default="")
+ cwd: str = Field(default="")
+ env: Dict[str, str] = Field(default_factory=dict)
+ input_text: str = Field(default="", alias="inputText")
+ stream: Literal["stdout", "stderr"] = "stdout"
+ tail: int = Field(default=100, ge=1, le=10000)
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class ProcessManagerOutput(BaseModel):
+ operation: Optional[str] = None
+ pid: Optional[int] = None
+ status: Optional[str] = None
+ output: Optional[str] = None
+ processes: Optional[list] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class ProcessManagerNode(ActionNode):
+ type = "processManager"
+ display_name = "Process Manager"
+ subtitle = "Long-Running Subprocess"
+ icon = "⚙️"
+ color = "#bd93f9"
+ group = ("utility", "tool")
+ description = "Start, stop, restart, and manage long-running processes"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ annotations = {"destructive": True, "readonly": False, "open_world": True}
+ task_queue = TaskQueue.DEFAULT
+ usable_as_tool = True
+
+ Params = ProcessManagerParams
+ Output = ProcessManagerOutput
+
+ @Operation("dispatch")
+ async def dispatch(self, ctx: NodeContext, params: ProcessManagerParams) -> Any:
+ from services.handlers.process import handle_process_manager
+ response = await handle_process_manager(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success"):
+ return response.get("result") or response
+ raise RuntimeError(response.get("error") or "Process manager failed")
diff --git a/server/nodes/utility/team_monitor.py b/server/nodes/utility/team_monitor.py
new file mode 100644
index 00000000..18ef4cd1
--- /dev/null
+++ b/server/nodes/utility/team_monitor.py
@@ -0,0 +1,56 @@
+"""Team Monitor — Wave 11.C migration."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class TeamMonitorParams(BaseModel):
+ team_id: str = Field(default="", alias="teamId")
+ auto_refresh: bool = Field(default=True, alias="autoRefresh")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class TeamMonitorOutput(BaseModel):
+ team: Optional[dict] = None
+ members: Optional[list] = None
+ tasks: Optional[list] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class TeamMonitorNode(ActionNode):
+ type = "teamMonitor"
+ display_name = "Team Monitor"
+ subtitle = "Agent Team Status"
+ icon = "📊"
+ color = "#bd93f9"
+ group = ("utility",)
+ description = "Real-time monitoring of Agent Team operations"
+ component_kind = "square"
+ handles = (
+ {"name": "input-main", "kind": "input", "position": "left", "label": "Input", "role": "main"},
+ {"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},
+ )
+ ui_hints = {"isMonitorPanel": True, "hideInputSection": True, "hideOutputSection": True}
+ annotations = {"destructive": False, "readonly": True, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = TeamMonitorParams
+ Output = TeamMonitorOutput
+
+ @Operation("monitor")
+ async def monitor(self, ctx: NodeContext, params: TeamMonitorParams) -> Any:
+ from services.handlers.utility import handle_team_monitor
+ response = await handle_team_monitor(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success") is False:
+ raise RuntimeError(response.get("error") or "Team monitor failed")
+ return response.get("result") or {}
diff --git a/server/nodes/utility/webhook_response.py b/server/nodes/utility/webhook_response.py
new file mode 100644
index 00000000..e151b80e
--- /dev/null
+++ b/server/nodes/utility/webhook_response.py
@@ -0,0 +1,57 @@
+"""Webhook Response — Wave 11.C migration. Reads connected_outputs."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class WebhookResponseParams(BaseModel):
+ status_code: int = Field(default=200, alias="statusCode", ge=100, le=599)
+ body: Any = Field(default=None)
+ headers: Dict[str, str] = Field(default_factory=dict)
+ content_type: str = Field(default="application/json", alias="contentType")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class WebhookResponseOutput(BaseModel):
+ sent: Optional[bool] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class WebhookResponseNode(ActionNode):
+ type = "webhookResponse"
+ display_name = "Webhook Response"
+ subtitle = "HTTP Reply"
+ icon = "↩️"
+ color = "#bd93f9"
+ group = ("utility",)
+ description = "Send custom response back to webhook caller with configurable status code, body, and headers"
+ component_kind = "square"
+ handles = (
+ {"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}
+ task_queue = TaskQueue.REST_API
+
+ Params = WebhookResponseParams
+ Output = WebhookResponseOutput
+
+ @Operation("respond")
+ async def respond(self, ctx: NodeContext, params: WebhookResponseParams) -> Any:
+ from services.handlers.http import handle_webhook_response
+ outputs = ctx.raw.get("connected_outputs") or {}
+ response = await handle_webhook_response(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True),
+ context=ctx.raw, connected_outputs=outputs,
+ )
+ if response.get("success") is False:
+ raise RuntimeError(response.get("error") or "Webhook response failed")
+ return response.get("result") or {}
diff --git a/server/nodes/whatsapp/whatsapp_receive.py b/server/nodes/whatsapp/whatsapp_receive.py
new file mode 100644
index 00000000..bb275da8
--- /dev/null
+++ b/server/nodes/whatsapp/whatsapp_receive.py
@@ -0,0 +1,80 @@
+"""WhatsApp Receive — Wave 11.C migration (event-based trigger).
+
+Inbound WhatsApp message events arrive via the whatsapp-rpc bridge.
+``build_filter`` delegates to the existing ``build_whatsapp_filter``
+to preserve the full sender/group/forwarded/keyword filter matrix.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import NodeContext, Operation, TaskQueue, TriggerNode
+
+
+class WhatsAppReceiveParams(BaseModel):
+ message_type_filter: Literal[
+ "all", "text", "image", "video", "audio",
+ "document", "location", "contact",
+ ] = Field(default="all", alias="messageTypeFilter")
+ filter: Literal["all", "any_contact", "contact", "group", "channel", "keywords"] = "all"
+ phone_number: str = Field(default="", alias="phoneNumber")
+ group_id: str = Field(default="", alias="groupId")
+ channel_jid: str = Field(default="", alias="channelJid")
+ keywords: str = Field(default="")
+ forwarded_filter: Literal["all", "only_forwarded", "ignore_forwarded"] = Field(
+ default="all", alias="forwardedFilter",
+ )
+ ignore_own_messages: bool = Field(default=True, alias="ignoreOwnMessages")
+ include_media_data: bool = Field(default=False, alias="includeMediaData")
+
+ model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+
+class WhatsAppReceiveOutput(BaseModel):
+ message_id: Optional[str] = None
+ sender: Optional[str] = None
+ chat_id: Optional[str] = None
+ message_type: Optional[str] = None
+ text: Optional[str] = None
+ timestamp: Optional[str] = None
+ is_group: Optional[bool] = None
+ is_from_me: Optional[bool] = None
+ push_name: Optional[str] = None
+ media: Optional[dict] = None
+ group_info: Optional[dict] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class WhatsAppReceiveNode(TriggerNode):
+ type = "whatsappReceive"
+ display_name = "WhatsApp Receive"
+ subtitle = "Inbound Message"
+ icon = "asset:whatsapp-receive"
+ color = "#25D366"
+ group = ("whatsapp", "trigger")
+ description = "Trigger workflow when WhatsApp message is received"
+ component_kind = "trigger"
+ handles = (
+ {"name": "output-main", "kind": "output", "position": "right",
+ "label": "Output", "role": "main"},
+ )
+ task_queue = TaskQueue.TRIGGERS_EVENT
+ mode = "event"
+ event_type = "whatsapp_message_received"
+
+ Params = WhatsAppReceiveParams
+ Output = WhatsAppReceiveOutput
+
+ def build_filter(self, params: WhatsAppReceiveParams) -> Callable[[Dict[str, Any]], bool]:
+ from services.event_waiter import build_whatsapp_filter
+ return build_whatsapp_filter(params.model_dump(by_alias=True))
+
+ @Operation("wait")
+ async def wait(self, ctx: NodeContext, params: WhatsAppReceiveParams) -> WhatsAppReceiveOutput:
+ raise NotImplementedError(
+ "Event triggers return via TriggerNode.execute, not the op body"
+ )
diff --git a/server/nodes/workflow/start.py b/server/nodes/workflow/start.py
new file mode 100644
index 00000000..710b00f3
--- /dev/null
+++ b/server/nodes/workflow/start.py
@@ -0,0 +1,63 @@
+"""Start node — Wave 11.C migration.
+
+Workflow entry point. Provides initial data to downstream nodes from
+a user-authored JSON blob (``initialData``) on the node itself. Has
+its own componentKind="start" because the StartNode component is a
+distinct visual treatment from generic triggers.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+
+
+class StartParams(BaseModel):
+ initial_data: Any = Field(default=None, alias="initialData")
+
+ model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class StartOutput(BaseModel):
+ data: Optional[Any] = None
+
+ model_config = ConfigDict(extra="allow")
+
+
+class StartNode(ActionNode):
+ type = "start"
+ display_name = "Start"
+ subtitle = "Workflow Start"
+ icon = "▶"
+ color = "#bd93f9"
+ group = ("workflow",)
+ description = "Starting point for workflow execution. Provides initial data to connected nodes."
+ component_kind = "start"
+ handles = (
+ {"name": "output-main", "kind": "output", "position": "right",
+ "label": "Output", "role": "main"},
+ )
+ ui_hints = {
+ "hideInputSection": True,
+ "hideOutputSection": True,
+ "hasInitialDataBlob": True,
+ }
+ annotations = {"destructive": False, "readonly": True, "open_world": False}
+ task_queue = TaskQueue.DEFAULT
+
+ Params = StartParams
+ Output = StartOutput
+
+ @Operation("emit")
+ async def emit(self, ctx: NodeContext, params: StartParams) -> Any:
+ from services.handlers.utility import handle_start
+ response = await handle_start(
+ node_id=ctx.node_id, node_type=self.type,
+ parameters=params.model_dump(by_alias=True), context=ctx.raw,
+ )
+ if response.get("success") is False:
+ raise RuntimeError(response.get("error") or "Start failed")
+ return response.get("result") or {}
diff --git a/server/services/node_executor.py b/server/services/node_executor.py
index bfa89159..d623ba3d 100644
--- a/server/services/node_executor.py
+++ b/server/services/node_executor.py
@@ -138,58 +138,15 @@ class NodeExecutor:
from services.node_registry import _HANDLER_REGISTRY as _PLUGIN_HANDLERS
registry = {
# Workflow control
- 'start': handle_start,
- 'cronScheduler': handle_cron_scheduler,
- 'timer': handle_timer,
+ # start / cronScheduler / timer — migrated to nodes/{workflow,scheduler}/*.py (Wave 11.C).
# AI agents — all migrated to nodes/agent/*.py (Wave 11.C).
# Plugin handlers win via registry.update(_PLUGIN_HANDLERS) merge below.
# simpleMemory + masterSkill: migrated to nodes/skill/*.py (Wave 11.C).
# Maps — all 3 migrated to nodes/location/*.py (Wave 11.C).
- # Text
- 'textGenerator': partial(handle_text_generator, text_service=self.text_service),
- 'fileHandler': partial(handle_file_handler, text_service=self.text_service),
- # WhatsApp / Telegram / Twitter / Email send+read — all migrated to
- # nodes/{whatsapp,telegram,twitter,email}/*.py (Wave 11.C).
- 'emailReceive': handle_email_receive, # polling trigger, deferred
- # Google Workspace — all 7 migrated to nodes/google/*.py (Wave 11.B/C).
- # Search — all 3 migrated to nodes/search/*.py (Wave 11.B/C).
- # Social (unified messaging)
- # Note: socialReceive handled in _dispatch with connected_outputs
- # socialSend: migrated to nodes/social/social_send.py (Wave 11.C).
- # Chat — chatSend / chatHistory migrated to nodes/chat/*.py (Wave 11.C).
- # HTTP
- 'httpRequest': handle_http_request,
- # Document processing
- 'httpScraper': handle_http_scraper,
- 'fileDownloader': handle_file_downloader,
- 'documentParser': handle_document_parser,
- 'textChunker': handle_text_chunker,
- 'embeddingGenerator': handle_embedding_generator,
- 'vectorStore': handle_vector_store,
- # Task management
- 'taskManager': handle_task_manager,
- # Todo planning (dual-purpose: workflow node + AI tool)
- 'writeTodos': handle_write_todos,
- # Process manager (dual-purpose: workflow node + AI tool)
- 'processManager': handle_process_manager,
- # Team monitoring
- 'teamMonitor': handle_team_monitor,
- # Apify web scraping
- 'apifyActor': handle_apify_actor,
- # Crawlee web scraping
- 'crawleeScraper': handle_crawlee_scraper,
- # Browser automation (agent-browser CLI)
- 'browser': handle_browser,
- # Proxy nodes
- 'proxyRequest': handle_proxy_request,
- 'proxyStatus': handle_proxy_status,
- 'proxyConfig': handle_proxy_config,
- # Filesystem and shell nodes (deepagents backends)
- 'fileRead': handle_file_read,
- 'fileModify': handle_file_modify,
- 'shell': handle_shell,
- 'fsSearch': handle_fs_search,
- # Note: 'console' handled in _dispatch with connected_outputs
+ # All other node types migrated to plugin classes under nodes/*/.
+ # Plugin handlers register themselves into _PLUGIN_HANDLERS via
+ # BaseNode.__init_subclass__ at import time. The merge below is
+ # now the sole population of the registry.
}
# AI chat models — all 9 migrated to nodes/model/*.py (Wave 11.C).