Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
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.pynew file mode 100644index 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.pynew file mode 100644index 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 = CodeExecutorOutputdiff --git a/server/nodes/code/javascript_executor.py b/server/nodes/code/javascript_executor.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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_HANDLERSregistry = {# 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).