fw-nodes-code 0.0.1a1__tar.gz

fw_nodes_code-0.0.1a1/.forgejo/workflows/publish.yml

@@ -0,0 +1,20 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: Public-Mirrors/actions_checkout@v6
+
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+
+      - name: Build and publish
+        run: |
+          uv build
+          uv publish --token ${{ secrets.PYPI_API_TOKEN }}

fw_nodes_code-0.0.1a1/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Environment files
+.env
+.env.local
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+coverage.xml
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+.eggs/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# uv
+uv.lock

fw_nodes_code-0.0.1a1/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 Eddy Hintze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

fw_nodes_code-0.0.1a1/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: fw-nodes-code
+Version: 0.0.1a1
+Summary: Code execution nodes for Flowire workflow automation
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: flowire-sdk>=0.0.1a2
+Requires-Dist: httpx>=0.26.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Flowire Code Nodes
+
+Code execution node package for Flowire workflow automation.
+
+This package is intentionally separate from `fw-nodes-core` so servers can opt into code execution support by installing this package.
+
+## Installation
+
+```bash
+cd flowire-app/backend
+uv pip install fw-nodes-code
+```
+
+Enable it in your `.env` file:
+
+```bash
+INSTALLED_NODE_PACKAGES=fw-nodes-core,fw-nodes-code
+```
+
+## Included Node
+
+| Node | Description |
+|------|-------------|
+| `Code` | Execute JavaScript or Python code in an isolated sandbox |
+
+The node supports a `runtime` input (default `latest`) so you can route
+different versions to different sandbox services (for example `3.13`, `3.9`, `20`).
+
+## Sandbox Services
+
+This package includes the sandbox runtimes used by the Code node:
+
+- `js-sandbox/` - JavaScript sandbox (isolated-vm + Fastify)
+- `py-sandbox/` - Python sandbox (FastAPI + subprocess execution)
+
+### Local sandbox commands
+
+```bash
+cd fw-nodes-code
+just js-sandbox-install
+just py-sandbox-install
+just js-sandbox
+just py-sandbox
+```
+
+## Environment Variables
+
+- `CODE_NODE_SANDBOX_URL_MAP` - JSON object mapping runtime keys to sandbox URLs.
+
+Example:
+
+```bash
+CODE_NODE_SANDBOX_URL_MAP='{
+  "javascript@latest":"http://localhost:3100",
+  "javascript@20":"http://localhost:3110",
+  "python@latest":"http://localhost:3200",
+  "python@3.13":"http://localhost:3213",
+  "python@3.9":"http://localhost:3209"
+}'
+```
+
+Runtime keys are resolved as:
+
+1. `{language}@{runtime}` (for example `python@3.13`)
+2. `{language}@latest`
+3. (no fallback route; configuration must exist in the map)
+
+If `CODE_NODE_SANDBOX_URL_MAP` is not set, defaults are used:
+
+- `javascript@latest -> http://localhost:3100`
+- `python@latest -> http://localhost:3200`
+
+## Development
+
+```bash
+just install
+just js-sandbox-install
+just py-sandbox-install
+just js-sandbox
+just py-sandbox
+just test
+just lint
+```

fw_nodes_code-0.0.1a1/README.md

@@ -0,0 +1,83 @@
+# Flowire Code Nodes
+
+Code execution node package for Flowire workflow automation.
+
+This package is intentionally separate from `fw-nodes-core` so servers can opt into code execution support by installing this package.
+
+## Installation
+
+```bash
+cd flowire-app/backend
+uv pip install fw-nodes-code
+```
+
+Enable it in your `.env` file:
+
+```bash
+INSTALLED_NODE_PACKAGES=fw-nodes-core,fw-nodes-code
+```
+
+## Included Node
+
+| Node | Description |
+|------|-------------|
+| `Code` | Execute JavaScript or Python code in an isolated sandbox |
+
+The node supports a `runtime` input (default `latest`) so you can route
+different versions to different sandbox services (for example `3.13`, `3.9`, `20`).
+
+## Sandbox Services
+
+This package includes the sandbox runtimes used by the Code node:
+
+- `js-sandbox/` - JavaScript sandbox (isolated-vm + Fastify)
+- `py-sandbox/` - Python sandbox (FastAPI + subprocess execution)
+
+### Local sandbox commands
+
+```bash
+cd fw-nodes-code
+just js-sandbox-install
+just py-sandbox-install
+just js-sandbox
+just py-sandbox
+```
+
+## Environment Variables
+
+- `CODE_NODE_SANDBOX_URL_MAP` - JSON object mapping runtime keys to sandbox URLs.
+
+Example:
+
+```bash
+CODE_NODE_SANDBOX_URL_MAP='{
+  "javascript@latest":"http://localhost:3100",
+  "javascript@20":"http://localhost:3110",
+  "python@latest":"http://localhost:3200",
+  "python@3.13":"http://localhost:3213",
+  "python@3.9":"http://localhost:3209"
+}'
+```
+
+Runtime keys are resolved as:
+
+1. `{language}@{runtime}` (for example `python@3.13`)
+2. `{language}@latest`
+3. (no fallback route; configuration must exist in the map)
+
+If `CODE_NODE_SANDBOX_URL_MAP` is not set, defaults are used:
+
+- `javascript@latest -> http://localhost:3100`
+- `python@latest -> http://localhost:3200`
+
+## Development
+
+```bash
+just install
+just js-sandbox-install
+just py-sandbox-install
+just js-sandbox
+just py-sandbox
+just test
+just lint
+```

fw_nodes_code-0.0.1a1/fw_nodes_code/__init__.py

@@ -0,0 +1,3 @@
+"""Code nodes for Flowire workflow automation."""
+
+__version__ = "0.1.0"

fw_nodes_code-0.0.1a1/fw_nodes_code/nodes/__init__.py

@@ -0,0 +1,4 @@
+"""Code node implementations for Flowire.
+
+Nodes in this package are auto-discovered via entry points.
+"""

fw_nodes_code-0.0.1a1/fw_nodes_code/nodes/code.py

@@ -0,0 +1,296 @@
+"""Code node for executing custom code in sandboxed environments."""
+
+import json
+import logging
+import os
+from enum import Enum
+from typing import Any
+
+import httpx
+from flowire_sdk import BaseNode, BaseNodeOutput, CodeEditorContract, NodeExecutionContext, NodeMetadata
+from pydantic import BaseModel, ConfigDict, Field
+
+logger = logging.getLogger(__name__)
+
+JS_DEFAULT_CODE = (
+    '// Available: $node["node-id"], $flow\n// Return your output as an object\n\nreturn {\n  result: "hello"\n}'
+)
+
+PYTHON_DEFAULT_CODE = (
+    '# Available: nodes["node-id"], flow\n'
+    "# Assign your output to 'result'\n"
+    "\n"
+    "result = {\n"
+    '    "message": "Hello from Python",\n'
+    "}"
+)
+
+
+class Language(str, Enum):
+    """Supported code execution languages."""
+
+    JAVASCRIPT = "javascript"
+    PYTHON = "python"
+
+
+SUPPORTED_LANGUAGE_VALUES = {language.value for language in Language}
+
+
+DEFAULT_SANDBOX_URL_MAP: dict[str, str] = {
+    "javascript@latest": "http://localhost:3100",
+    "python@latest": "http://localhost:3200",
+}
+
+
+def _normalize_runtime(runtime: str | None) -> str:
+    """Normalize runtime hint to a stable lower-case token."""
+    normalized = (runtime or "latest").strip().lower()
+    return normalized or "latest"
+
+
+def _parse_map_key(key: str) -> tuple[str, str] | None:
+    """Parse map key into language/runtime tokens."""
+    token = key.strip().lower()
+    if not token:
+        return None
+    if "@" in token:
+        language_token, runtime_token = token.split("@", 1)
+    else:
+        language_token, runtime_token = token, "latest"
+
+    language_token = language_token.strip()
+    runtime_token = _normalize_runtime(runtime_token)
+
+    if language_token not in SUPPORTED_LANGUAGE_VALUES:
+        return None
+    return language_token, runtime_token
+
+
+def _load_sandbox_url_map() -> dict[str, str]:
+    """Load language/runtime -> sandbox URL mapping from environment."""
+    raw = os.environ.get("CODE_NODE_SANDBOX_URL_MAP", "").strip()
+    if not raw:
+        return DEFAULT_SANDBOX_URL_MAP.copy()
+
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError:
+        logger.warning("Invalid CODE_NODE_SANDBOX_URL_MAP JSON; using default sandbox routing")
+        return DEFAULT_SANDBOX_URL_MAP.copy()
+
+    if not isinstance(parsed, dict):
+        logger.warning("CODE_NODE_SANDBOX_URL_MAP must be a JSON object; using default sandbox routing")
+        return DEFAULT_SANDBOX_URL_MAP.copy()
+
+    result: dict[str, str] = {}
+    for key, value in parsed.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            continue
+        parsed_key = _parse_map_key(key)
+        if not parsed_key:
+            continue
+        language_token, runtime_token = parsed_key
+        normalized_key = f"{language_token}@{runtime_token}"
+        normalized_url = value.strip()
+        if normalized_key and normalized_url:
+            result[normalized_key] = normalized_url
+
+    if not result:
+        logger.warning("CODE_NODE_SANDBOX_URL_MAP had no valid entries; using default sandbox routing")
+        return DEFAULT_SANDBOX_URL_MAP.copy()
+
+    return result
+
+
+def _build_editor_options(url_map: dict[str, str]) -> tuple[list[str], dict[str, list[str]]]:
+    """Derive language/runtime dropdown options from sandbox map keys."""
+    language_order: list[str] = []
+    runtime_options: dict[str, list[str]] = {}
+
+    for key in url_map:
+        parsed_key = _parse_map_key(key)
+        if not parsed_key:
+            continue
+        language_token, runtime_token = parsed_key
+
+        if language_token not in language_order:
+            language_order.append(language_token)
+
+        runtimes = runtime_options.setdefault(language_token, [])
+        if runtime_token not in runtimes:
+            if runtime_token == "latest":
+                runtimes.insert(0, runtime_token)
+            else:
+                runtimes.append(runtime_token)
+
+    if not language_order:
+        language_order = [Language.JAVASCRIPT.value, Language.PYTHON.value]
+        runtime_options = {
+            Language.JAVASCRIPT.value: ["latest"],
+            Language.PYTHON.value: ["latest"],
+        }
+
+    return language_order, runtime_options
+
+
+def _build_code_editor_contract() -> CodeEditorContract:
+    """Build code editor metadata contract including language/runtime dropdown options."""
+    url_map = _load_sandbox_url_map()
+    language_options, runtime_options = _build_editor_options(url_map)
+
+    return CodeEditorContract(
+        code_field="code",
+        language_field="language",
+        runtime_field="runtime",
+        code_format="code",
+        language_defaults={
+            "javascript": JS_DEFAULT_CODE,
+            "python": PYTHON_DEFAULT_CODE,
+        },
+        language_options=language_options,
+        runtime_options=runtime_options,
+    )
+
+
+def _resolve_sandbox_url(language: Language, runtime: str | None) -> tuple[str, str]:
+    """Resolve target sandbox URL from runtime mapping."""
+    runtime_token = _normalize_runtime(runtime)
+    candidates = [f"{language.value}@{runtime_token}"]
+    if runtime_token != "latest":
+        candidates.append(f"{language.value}@latest")
+
+    url_map = _load_sandbox_url_map()
+    for key in candidates:
+        url = url_map.get(key)
+        if url:
+            return url, key
+
+    available_routes = sorted(url_map.keys())
+    raise RuntimeError(
+        "No sandbox URL configured for "
+        f"{language.value}@{runtime_token}. "
+        "Set CODE_NODE_SANDBOX_URL_MAP with a matching route. "
+        f"Available routes: {available_routes}"
+    )
+
+
+class CodeNodeInput(BaseModel):
+    """Input schema for Code node."""
+
+    language: Language = Field(
+        default=Language.JAVASCRIPT,
+        description="Programming language for the code",
+        json_schema_extra={
+            "x-code-defaults": {
+                "javascript": JS_DEFAULT_CODE,
+                "python": PYTHON_DEFAULT_CODE,
+            }
+        },
+    )
+    code: str = Field(
+        default=JS_DEFAULT_CODE,
+        description='Code to execute. Use $node["id"]/$flow (JS) or nodes["id"]/flow (Python).',
+        json_schema_extra={"format": "code"},
+    )
+    runtime: str = Field(
+        default="latest",
+        description=("Runtime version hint for selecting the sandbox backend, e.g. 'latest', '3.13', '3.9', or '20'."),
+    )
+    timeout: int = Field(
+        default=10,
+        ge=1,
+        le=60,
+        description="Maximum execution time in seconds",
+    )
+
+
+class CodeNodeOutput(BaseNodeOutput):
+    """Output schema for Code node - allows arbitrary fields from user code."""
+
+    model_config = ConfigDict(extra="allow")
+
+
+class CodeNode(BaseNode):
+    """Execute custom code in a sandboxed environment."""
+
+    input_schema = CodeNodeInput
+    output_schema = CodeNodeOutput
+
+    metadata = NodeMetadata(
+        name="Code",
+        description="Execute custom code with access to workflow data",
+        category="developer",
+        icon="<>",
+        color="#1e1e1e",
+        display_component="code",
+        code_editor=_build_code_editor_contract(),
+    )
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> CodeNodeOutput:
+        """Execute code in the appropriate sandbox."""
+        language = Language(validated_inputs.get("language", Language.JAVASCRIPT))
+        code = validated_inputs["code"]
+        runtime = validated_inputs.get("runtime", "latest")
+        timeout = validated_inputs.get("timeout", 10)
+
+        sandbox_url, sandbox_route = _resolve_sandbox_url(language, runtime)
+
+        # Build the request payload
+        # js-sandbox expects timeout in milliseconds, py-sandbox in seconds
+        sandbox_timeout = timeout * 1000 if language == Language.JAVASCRIPT else timeout
+        payload = {
+            "language": language.value,
+            "runtime": runtime,
+            "code": code,
+            "input": context.node_results,
+            "nodeResults": context.node_results,
+            "flow": {
+                "execution_id": context.execution_id,
+                "flow_id": context.workflow_id,
+                "project_id": context.project_id,
+                "node_id": context.node_id,
+            },
+            "timeout": sandbox_timeout,
+        }
+
+        # Call the sandbox
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{sandbox_url}/execute",
+                    json=payload,
+                    timeout=timeout + 5,  # Add buffer for network
+                )
+                response.raise_for_status()
+                result = response.json()
+            except httpx.ConnectError as e:
+                raise RuntimeError(
+                    "Could not connect to code sandbox service for "
+                    f"{language.value}@{_normalize_runtime(runtime)} "
+                    f"(route '{sandbox_route}' -> {sandbox_url}). "
+                    "Configure CODE_NODE_SANDBOX_URL_MAP."
+                ) from e
+            except httpx.TimeoutException as e:
+                raise RuntimeError(f"Code execution timed out after {timeout} seconds") from e
+
+        # Check for execution errors
+        if not result.get("success"):
+            error = result.get("error", {})
+            error_msg = error.get("message", "Unknown error")
+            error_stack = error.get("stack", "")
+            raise RuntimeError(f"Code execution failed: {error_msg}\n{error_stack}")
+
+        # Build output from result
+        output_data = result.get("result", {})
+        if not isinstance(output_data, dict):
+            output_data = {"result": output_data}
+
+        # Include execution metadata
+        output_data["_logs"] = result.get("logs", [])
+        output_data["_duration"] = result.get("duration", 0)
+
+        return CodeNodeOutput(**output_data)

fw_nodes_code-0.0.1a1/js-sandbox/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+dist/

fw_nodes_code-0.0.1a1/js-sandbox/.nvmrc

@@ -0,0 +1 @@
+22

fw_nodes_code-0.0.1a1/js-sandbox/Dockerfile

@@ -0,0 +1,16 @@
+FROM node:22-alpine
+
+WORKDIR /app
+
+# Install build dependencies for isolated-vm (needs python, make, g++)
+RUN apk add --no-cache python3 make g++ curl
+
+COPY package*.json ./
+RUN npm ci
+
+COPY . .
+RUN npm run build
+
+EXPOSE 3100
+
+CMD ["npm", "start"]