programgarden-core 1.15.2__tar.gz → 1.16.0__tar.gz

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden-core
-Version: 1.15.2
+Version: 1.16.0
 Summary: ProgramGarden Core - 노드 기반 DSL 핵심 타입 정의
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

programgarden_core-1.16.0/programgarden_core/code_node.py

@@ -0,0 +1,411 @@
+"""ProgramGarden Core — CodeNode static compilation & AST security screening.
+
+This module is the single source of truth for the CodeNode security lists and
+the compile/screen pipeline. It is intentionally dependency-free (stdlib only)
+so it can be reused verbatim by:
+
+  1. `WorkflowResolver.validate()` — pre-flight structured errors before run.
+  2. `CodeNodeExecutor` / subprocess worker — screen again right before `exec`.
+  3. An external web-platform "share gate" server — re-run the same hard AST scan.
+
+Security model (see plan §2): CodeNode runs untrusted Python. Defense is layered:
+
+  * Layer 1 — scrubbed context (runtime, programgarden): the code never receives
+    credential accessors.
+  * Layer 2 — restricted builtins + AST denylist (THIS module): a curated
+    `__builtins__` (no eval/exec/open/getattr/...), a safe `__import__` gated by a
+    whitelist, and a static AST scan that rejects dangerous imports, builtin
+    calls, and introspection-escape dunders BEFORE any code runs.
+  * Layer 3 — binding seal (runtime, resolver): credentials cannot flow into
+    `data`/`params`.
+  * Layer 4 — subprocess isolation (runtime, programgarden): the code always runs
+    in a credential-free child process.
+
+`compile_code_node` NEVER executes the code — it only parses, screens, and
+compiles. Execution (exec + calling `execute`) is the runtime's responsibility.
+
+All user-facing strings are English (AI-chatbot consumer contract).
+"""
+from __future__ import annotations
+
+import ast
+import builtins as _builtins
+from dataclasses import dataclass, field
+from types import CodeType
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+# Name of the entry-point coroutine the code text must define.
+EXECUTE_FN_NAME = "execute"
+
+# ⚠️ SECURITY POSTURE — READ THIS.
+# AST screening + restricted builtins CANNOT be a sound sandbox for CPython.
+# A determined attacker who can run Python can, in the general case, escape any
+# in-process denylist (this is a well-known result; see the pysandbox author's
+# own withdrawal). An adversarial audit of an earlier version of this file
+# reproduced RCE via `operator.attrgetter`, `random._os`, and string-obfuscated
+# dunders. The rules below are HARDENED defense-in-depth that close every
+# demonstrated vector and raise the bar substantially — but they are NOT a
+# containment guarantee. TRUE containment of untrusted code is the runtime's
+# job (subprocess with no in-memory keys) + the operator's job (per-user pod
+# isolation, no-egress NetworkPolicy, restricted file perms, scrubbed env).
+# Treat CodeNode as "run trusted code, defense-in-depth against mistakes and
+# opportunistic abuse", not "safe to run arbitrary hostile code".
+
+# ── Whitelist: modules importable from CodeNode code ────────────────────────
+# Pure-computation stdlib only. `operator` is deliberately EXCLUDED — its
+# attrgetter/methodcaller are getattr/dispatch substitutes. Modules that
+# re-export os/sys as public attributes (e.g. random._os, uuid.os) are still
+# covered by the attribute screen below, not by this set. The embedding app may
+# EXTEND this via `allowed_imports=` (e.g. numpy) but the default is minimal.
+DEFAULT_ALLOWED_IMPORTS: frozenset = frozenset({
+    "math", "cmath", "statistics", "decimal", "fractions", "numbers",
+    "random", "json", "re", "datetime", "time", "calendar",
+    "collections", "itertools", "functools",
+    "string", "textwrap", "unicodedata",
+    "heapq", "bisect", "array", "copy",
+    "dataclasses", "enum", "typing",
+    "hashlib", "hmac", "base64", "binascii", "zlib",
+})
+
+# ── Denylist: modules called out for a clearer error message ────────────────
+# Enforcement is whitelist-based (not in DEFAULT_ALLOWED_IMPORTS → blocked);
+# this set only makes the message explicit for well-known dangerous modules.
+FORBIDDEN_MODULES: frozenset = frozenset({
+    "os", "sys", "subprocess", "socket", "shutil", "importlib", "imp",
+    "ctypes", "cffi", "gc", "inspect", "pathlib", "glob", "tempfile", "io",
+    "urllib", "http", "requests", "ftplib", "smtplib", "asyncio",
+    "multiprocessing", "threading", "concurrent", "_thread", "operator",
+    "builtins", "marshal", "pickle", "shelve", "dbm", "sqlite3",
+    "code", "codeop", "pty", "resource", "signal", "mmap", "fcntl",
+    "platform", "webbrowser", "ssl", "select", "selectors", "uuid",
+})
+
+# ── Denylist: builtin names that must never be called or aliased ────────────
+FORBIDDEN_BUILTINS: frozenset = frozenset({
+    "eval", "exec", "compile", "open", "__import__",
+    "getattr", "setattr", "delattr",
+    "globals", "locals", "vars",
+    "input", "breakpoint", "help", "memoryview",
+    "exit", "quit", "__build_class__",
+})
+
+# ── Denylist: dangerous PUBLIC attribute names (module re-exports & escapes) ──
+# Many stdlib modules re-export `os`/`sys` as public attributes (statistics.sys,
+# uuid.os, ...) — walking those reaches os.system. `mro`/`modules`/`system`/etc.
+# are the follow-on hops. Blocking these attribute NAMES (in addition to the
+# blanket underscore rule below) severs the module-attribute escape path.
+FORBIDDEN_ATTR_NAMES: frozenset = frozenset({
+    "os", "sys", "subprocess", "socket", "builtins", "importlib",
+    "modules", "system", "popen", "spawn", "spawnl", "spawnv", "spawnve",
+    "fork", "forkpty", "execv", "execve", "execl", "execlp", "execvp",
+    "mro", "import_module", "load_module", "reload", "getattr", "setattr",
+    "delattr", "globals", "environ", "getenv", "putenv", "connect",
+    "urlopen", "call", "run", "check_output", "Popen", "loader", "spec",
+})
+
+# ── Denylist: introspection-escape / exfiltration dunders & frame attrs ──────
+# NOTE: enforcement is the BLANKET underscore rule in _scan_ast (any attribute
+# or string beginning with '_' is rejected), which subsumes every dunder. This
+# explicit set is retained for documentation / message clarity.
+FORBIDDEN_DUNDERS: frozenset = frozenset({
+    "__class__", "__bases__", "__base__", "__subclasses__", "__mro__",
+    "__globals__", "__code__", "__closure__", "__func__", "__self__",
+    "__dict__", "__getattribute__", "__setattr__", "__delattr__",
+    "__reduce__", "__reduce_ex__", "__builtins__", "__import__",
+    "__loader__", "__spec__", "__init_subclass__", "__subclasshook__",
+    "__getattr__", "__wrapped__", "__objclass__",
+    "gi_frame", "gi_code", "cr_frame", "cr_code", "ag_frame",
+    "f_back", "f_globals", "f_locals", "f_builtins", "tb_frame",
+})
+
+# Format replacement-field that performs attribute access, e.g. "{0.__class__}"
+# or "{x.sys}" — used to walk attributes via str.format without an AST Attribute
+# node. Rejected wholesale in string constants.
+import re as _re
+_FORMAT_ATTR_RE = _re.compile(r"\{[^{}]*\.[^{}]*\}")
+
+
+@dataclass
+class CodeScreenResult:
+    """Structured outcome of `compile_code_node`. `ok=False` carries an
+    AI-chatbot-consumable error (code + message + suggestion + location)."""
+
+    ok: bool
+    code_object: Optional[CodeType] = None
+    error_code: Optional[str] = None       # one of CODE_NODE_SYNTAX_ERROR / _FORBIDDEN / _NO_EXECUTE
+    message: Optional[str] = None
+    suggestion: Optional[str] = None
+    line: Optional[int] = None
+    offset: Optional[int] = None
+    details: Dict[str, Any] = field(default_factory=dict)
+
+
+def _module_root(name: Optional[str]) -> str:
+    return (name or "").split(".")[0]
+
+
+def _scan_ast(tree: ast.AST, allowed_imports: Set[str]) -> List[Dict[str, Any]]:
+    """Return a list of violation dicts (empty when clean).
+
+    Each violation: {kind, name, line, col, reason}. `kind` ∈
+    {import, builtin, dunder}.
+    """
+    violations: List[Dict[str, Any]] = []
+
+    for node in ast.walk(tree):
+        # ── Imports (whitelist-enforced) ──
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                root = _module_root(alias.name)
+                if root not in allowed_imports:
+                    reason = (
+                        f"module '{alias.name}' is blocked (filesystem/process/network access)"
+                        if root in FORBIDDEN_MODULES
+                        else f"module '{alias.name}' is not in the allowed import list"
+                    )
+                    violations.append({
+                        "kind": "import", "name": alias.name,
+                        "line": node.lineno, "col": node.col_offset, "reason": reason,
+                    })
+        elif isinstance(node, ast.ImportFrom):
+            root = _module_root(node.module)
+            # `from . import x` (level>0) is always blocked — no package context.
+            if node.level and node.level > 0:
+                violations.append({
+                    "kind": "import", "name": node.module or ".",
+                    "line": node.lineno, "col": node.col_offset,
+                    "reason": "relative imports are not allowed in CodeNode",
+                })
+            elif root not in allowed_imports:
+                reason = (
+                    f"module '{node.module}' is blocked (filesystem/process/network access)"
+                    if root in FORBIDDEN_MODULES
+                    else f"module '{node.module}' is not in the allowed import list"
+                )
+                violations.append({
+                    "kind": "import", "name": node.module or "",
+                    "line": node.lineno, "col": node.col_offset, "reason": reason,
+                })
+
+        # ── Forbidden builtin names (call or alias) ──
+        elif isinstance(node, ast.Name):
+            if node.id in FORBIDDEN_BUILTINS:
+                violations.append({
+                    "kind": "builtin", "name": node.id,
+                    "line": node.lineno, "col": node.col_offset,
+                    "reason": f"use of '{node.id}' is not allowed",
+                })
+
+        # ── Attribute access screen ──
+        # (1) BLANKET: any attribute beginning with '_' is rejected — this
+        #     subsumes every dunder (__class__/__globals__/__subclasses__/...)
+        #     AND private module re-exports (random._os, random._urandom, ...).
+        # (2) A denylist of dangerous PUBLIC names (module re-exports & shell
+        #     hops): statistics.sys, uuid.os, x.system, x.modules, type().mro().
+        elif isinstance(node, ast.Attribute):
+            if node.attr.startswith("_"):
+                violations.append({
+                    "kind": "dunder", "name": node.attr,
+                    "line": node.lineno, "col": node.col_offset,
+                    "reason": f"access to underscore attribute '{node.attr}' is not allowed (introspection escape)",
+                })
+            elif node.attr in FORBIDDEN_ATTR_NAMES:
+                violations.append({
+                    "kind": "attr", "name": node.attr,
+                    "line": node.lineno, "col": node.col_offset,
+                    "reason": f"attribute '{node.attr}' access is not allowed (module/escape re-export)",
+                })
+
+        # ── String-constant screen ──
+        # Defeats attribute-walk via strings: getattr/attrgetter args, str.format
+        # attribute fields, subscript-string dunder access. Reject strings that
+        # start with '_', contain a dunder, name a dangerous attribute, or embed
+        # a format field with attribute access.
+        elif isinstance(node, ast.Constant) and isinstance(node.value, str):
+            v = node.value
+            bad = None
+            if v.startswith("_"):
+                bad = f"string literal '{v}' begins with '_' (introspection escape)"
+            elif "__" in v:
+                bad = f"string literal contains a dunder (introspection escape)"
+            elif v in FORBIDDEN_ATTR_NAMES:
+                bad = f"string literal '{v}' names a blocked attribute"
+            elif _FORMAT_ATTR_RE.search(v):
+                bad = "format string performs attribute access (introspection escape)"
+            if bad:
+                violations.append({
+                    "kind": "string", "name": v[:40],
+                    "line": node.lineno, "col": node.col_offset,
+                    "reason": bad,
+                })
+
+    return violations
+
+
+def _has_execute(tree: ast.Module) -> bool:
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == EXECUTE_FN_NAME:
+            return True
+    return False
+
+
+def compile_code_node(
+    code: str,
+    node_id: str,
+    *,
+    screen: bool = True,
+    allowed_imports: Optional[Set[str]] = None,
+) -> CodeScreenResult:
+    """Parse, security-screen, and compile CodeNode source WITHOUT executing it.
+
+    Pipeline:
+      1. `ast.parse` — SyntaxError → CODE_NODE_SYNTAX_ERROR (line/offset).
+      2. AST denylist scan (when `screen=True`) — CODE_NODE_FORBIDDEN.
+      3. `execute` function must be defined — CODE_NODE_NO_EXECUTE.
+      4. `compile(filename=f'<code:{node_id}>')` — preserves traceback lines.
+
+    Args:
+        code: Python source text (must define `execute`).
+        node_id: node id, used only for the compiled filename (traceback anchor).
+        screen: run the AST denylist scan (always True in production).
+        allowed_imports: override the import whitelist (defaults to
+            DEFAULT_ALLOWED_IMPORTS). Enforced both here and by the runtime
+            safe `__import__`.
+
+    Returns:
+        CodeScreenResult — `ok=True` with `code_object`, or `ok=False` with a
+        structured, English, chatbot-consumable error. Never raises for
+        screening/syntax failures (they are returned as data).
+    """
+    allowed = set(allowed_imports) if allowed_imports is not None else set(DEFAULT_ALLOWED_IMPORTS)
+
+    if not isinstance(code, str) or not code.strip():
+        return CodeScreenResult(
+            ok=False,
+            error_code="CODE_NODE_SYNTAX_ERROR",
+            message="CodeNode 'code' is empty.",
+            suggestion="Provide Python source that defines `async def execute(data, params, context)`.",
+            line=1, offset=0,
+        )
+
+    # 1. Parse
+    try:
+        tree = ast.parse(code, filename=f"<code:{node_id}>", mode="exec")
+    except SyntaxError as e:
+        return CodeScreenResult(
+            ok=False,
+            error_code="CODE_NODE_SYNTAX_ERROR",
+            message=f"CodeNode syntax error: {e.msg}",
+            suggestion="Fix the Python syntax at the reported line/offset.",
+            line=e.lineno,
+            offset=e.offset,
+            details={"raw": str(e)},
+        )
+
+    # 2. Screen
+    if screen:
+        violations = _scan_ast(tree, allowed)
+        if violations:
+            first = violations[0]
+            names = sorted({v["name"] for v in violations})
+            return CodeScreenResult(
+                ok=False,
+                error_code="CODE_NODE_FORBIDDEN",
+                message=(
+                    f"CodeNode uses forbidden construct(s): {', '.join(names)} "
+                    f"({first['reason']})."
+                ),
+                suggestion=(
+                    "Remove the blocked import/builtin/introspection. CodeNode allows "
+                    "pure-computation stdlib only (math, statistics, json, datetime, ...); "
+                    "credentials, filesystem, network, subprocess, and object-graph "
+                    "introspection are not available."
+                ),
+                line=first["line"],
+                offset=first["col"],
+                details={"violations": violations, "forbidden_names": names},
+            )
+
+    # 3. execute() must exist
+    if not _has_execute(tree):
+        return CodeScreenResult(
+            ok=False,
+            error_code="CODE_NODE_NO_EXECUTE",
+            message=f"CodeNode code must define a function named '{EXECUTE_FN_NAME}'.",
+            suggestion=(
+                "Define `async def execute(data, params, context):` (a plain "
+                "`def execute(...)` is also accepted and auto-wrapped)."
+            ),
+            line=1, offset=0,
+        )
+
+    # 4. Compile (never exec here)
+    try:
+        code_object = compile(tree, filename=f"<code:{node_id}>", mode="exec")
+    except (SyntaxError, ValueError) as e:  # e.g. too-deeply-nested
+        return CodeScreenResult(
+            ok=False,
+            error_code="CODE_NODE_SYNTAX_ERROR",
+            message=f"CodeNode failed to compile: {e}",
+            suggestion="Simplify the code so it compiles as a module.",
+            line=getattr(e, "lineno", 1) or 1,
+            offset=getattr(e, "offset", 0) or 0,
+            details={"raw": str(e)},
+        )
+
+    return CodeScreenResult(ok=True, code_object=code_object)
+
+
+# The real import machinery, captured once so the sandbox can delegate to it
+# after the whitelist check.
+_REAL_IMPORT = _builtins.__import__
+
+# Curated safe builtins — everything a pure-compute function needs, and nothing
+# that grants escape (no eval/exec/compile/open/getattr/setattr/globals/...).
+_SAFE_BUILTIN_NAMES: Tuple[str, ...] = (
+    "abs", "all", "any", "ascii", "bin", "bool", "bytearray", "bytes",
+    "callable", "chr", "complex", "dict", "divmod", "enumerate", "filter",
+    "float", "format", "frozenset", "hash", "hex", "int", "isinstance",
+    "issubclass", "iter", "len", "list", "map", "max", "min", "next", "oct",
+    "ord", "pow", "print", "range", "repr", "reversed", "round", "set",
+    "slice", "sorted", "str", "sum", "tuple", "type", "zip", "hasattr",
+    # exceptions & sentinels
+    "Exception", "BaseException", "ValueError", "TypeError", "KeyError",
+    "IndexError", "AttributeError", "ZeroDivisionError", "ArithmeticError",
+    "OverflowError", "RuntimeError", "StopIteration", "StopAsyncIteration",
+    "NotImplementedError", "AssertionError", "LookupError", "NameError",
+    "RecursionError", "FloatingPointError", "GeneratorExit", "KeyboardInterrupt",
+    "True", "False", "None", "NotImplemented", "Ellipsis",
+    "object", "property", "staticmethod", "classmethod", "super",
+    # __build_class__ is required for `class` statements in user code; it is not
+    # itself an escape vector (dunder screen blocks the dangerous follow-ups).
+    "__build_class__",
+)
+
+
+def build_restricted_builtins(allowed_imports: Optional[Set[str]] = None) -> Dict[str, Any]:
+    """Build the `__builtins__` dict used when exec-ing CodeNode source.
+
+    Contains only the curated safe builtins plus a whitelist-gated
+    `__import__`. Pure function (no exec, stdlib only) so it lives in core and
+    is reused by the runtime worker.
+    """
+    allowed = set(allowed_imports) if allowed_imports is not None else set(DEFAULT_ALLOWED_IMPORTS)
+
+    def _safe_import(name, globals=None, locals=None, fromlist=(), level=0):
+        if level and level != 0:
+            raise ImportError("relative imports are not allowed in CodeNode")
+        root = _module_root(name)
+        if root not in allowed:
+            raise ImportError(
+                f"import of '{name}' is not allowed in CodeNode "
+                f"(allowed: pure-computation stdlib only)"
+            )
+        return _REAL_IMPORT(name, globals, locals, fromlist, level)
+
+    safe: Dict[str, Any] = {}
+    for bn in _SAFE_BUILTIN_NAMES:
+        if hasattr(_builtins, bn):
+            safe[bn] = getattr(_builtins, bn)
+    safe["__import__"] = _safe_import
+    return safe

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/i18n/locales/en.json

@@ -54,6 +54,8 @@
   "nodes.CandlestickChartNode.name": "Candlestick Chart",
   "nodes.ConditionNode.description": "Evaluates trading conditions using one of 67 community strategy plugins (RSI, MACD, Bollinger Bands, Ichimoku, ZScore, TurtleBreakout, MagicFormula, SupportResistanceLevels, etc.). Feed OHLCV or price data through the items field with from/extract mapping, and select a plugin with optional parameters. Outputs is_condition_met (boolean), passed_symbols, failed_symbols, and calculated indicator values. Auto-iterates over input symbol arrays. Bind positions field for sell-side conditions (profit target, stop loss). Typical connection: HistoricalDataNode → ConditionNode → LogicNode or → NewOrderNode. Can be used as an AI Agent tool.",
   "nodes.ConditionNode.name": "Condition",
+  "nodes.CodeNode.name": "Code",
+  "nodes.CodeNode.description": "Runs a custom Python function for logic no existing typed node covers — a bespoke indicator, a custom scoring formula, ad-hoc reshaping. The code defines async def execute(data, params, context) and returns a dict mapped to declared output ports (or a single 'result' port). Always sandboxed: it runs in a credential-free subprocess with restricted builtins, an AST denylist (no os/socket/urllib/subprocess/open or introspection), and a scrubbed read-only context — no credential, broker, or network access. Bind the whole upstream value to 'data' and loop in-code. Downstream nodes consume its outputs by writing {{ nodes.<id>.<port> }} into a generic input field (TableDisplayNode.data, IfNode.left/right, ...), not by typed-port matching — so when feeding a typed order/condition node, return the standard [{symbol, exchange, ...}] shape; for a display/sink or If scalar, any shape works. Typical connection: HistoricalDataNode → CodeNode → IfNode. Prefer typed nodes (ConditionNode/FieldMappingNode/IfNode) whenever they already cover the logic.",
   "nodes.CurrencyRateNode.description": "Fetches real-time currency exchange rates based on European Central Bank (ECB) data. No broker connection or API key required. Configure a base currency and target currencies to get conversion rates. Includes a convenience KRW rate output port for Korean investors tracking USD/KRW. Built-in resilience with retry on timeout and rate-limit errors, plus fallback to open.er-api.com. Typical connection: CurrencyRateNode → ConditionNode (for FX-based signals) or → FieldMappingNode. Can be used as an AI Agent tool.",
   "nodes.CurrencyRateNode.name": "Currency Rate",
   "nodes.ErrorHandlerNode.description": "Handles errors from upstream nodes and executes recovery logic. Routes error data for logging, alerting, or fallback processing. Use to build resilient workflows that gracefully handle API failures, timeout errors, or invalid data.",
@@ -288,6 +290,10 @@
   "fields.CurrencyRateNode.resilience": "Retry and fallback settings for API call failures",
   "fields.CurrencyRateNode.target_currencies": "Target currencies. Select currencies to get exchange rates against the base currency.",
   "fields.CurrencyRateNode.timeout_seconds": "API request timeout (seconds). Default 30s, adjust based on your network conditions.",
+  "fields.CodeNode.code": "Python source that defines async def execute(data, params, context). Sandboxed: only pure-computation stdlib imports (math, statistics, json, datetime, ...) are allowed; no credentials, network, filesystem, or introspection.",
+  "fields.CodeNode.outputs": "Output port declarations [{name, type}]. Leave empty for a single 'result' port carrying the whole return value. Declared ports are consumed downstream by {{ nodes.<id>.<port> }} expressions written into a consumer's generic input field (TableDisplayNode.data, IfNode.left/right, ...), not by typed-port matching; declaring them enables static typo-guarding.",
+  "fields.CodeNode.params": "Parameters passed to execute() as `params`. Expression bindings are allowed (e.g. a period or threshold).",
+  "fields.CodeNode.data": "Input data passed to execute() as `data`. Bind the whole upstream value (e.g. {{ nodes.hist.values }}) and loop over it inside the function.",
   "fields.FieldMappingNode.data": "Input data to transform. Bind from HTTPRequestNode response or other node outputs.",
   "fields.FieldMappingNode.mappings": "Field name mapping table. Converts source field names (from) to standard field names (to).",
   "fields.FieldMappingNode.mappings.description": "Field description (for AI agent auto-mapping)",
@@ -847,6 +853,7 @@
   "fieldNames.TradingHoursFilterNode.timezone": "Timezone",
   "fieldNames.WatchlistNode.symbols": "Symbols",
   "outputs.AIAgentNode.response": "AI agent response (text or JSON object depending on output format)",
+  "outputs.CodeNode.result": "The whole value returned by execute() when no output ports are declared. When outputs are declared, read the named ports instead.",
   "outputs.ExclusionListNode.count": "Number of excluded symbols",
   "outputs.ExclusionListNode.excluded": "Final exclusion list (manual + dynamic, deduplicated)",
   "outputs.ExclusionListNode.filtered": "Source symbols minus excluded symbols (when input_symbols connected)",

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/i18n/locales/ko.json

@@ -54,6 +54,8 @@
   "nodes.CandlestickChartNode.name": "캔들스틱차트",
   "nodes.ConditionNode.description": "67개 커뮤니티 전략 플러그인(RSI, MACD, Bollinger Bands, Ichimoku, ZScore, TurtleBreakout, MagicFormula, SupportResistanceLevels 등)으로 매매 조건을 평가합니다. items 필드의 from/extract 매핑으로 OHLCV 또는 가격 데이터를 입력하고, 플러그인과 매개변수를 선택합니다. 출력: is_condition_met (boolean), passed_symbols, failed_symbols, 계산된 지표 값. 입력 종목 배열에 대해 자동 반복(auto-iterate) 실행합니다. 매도 조건에는 positions 필드를 바인딩하세요(익절, 손절). 일반적인 연결: HistoricalDataNode → ConditionNode → LogicNode 또는 → NewOrderNode. AI Agent 도구로 사용 가능.",
   "nodes.ConditionNode.name": "조건",
+  "nodes.CodeNode.name": "코드",
+  "nodes.CodeNode.description": "기존 타입 노드로 표현할 수 없는 커스텀 로직(고유 지표, 커스텀 점수 산식, 임시 데이터 가공)을 파이썬 함수로 실행합니다. 코드는 async def execute(data, params, context) 를 정의하고, 반환한 dict 가 선언한 출력 포트(또는 단일 'result' 포트)로 매핑됩니다. 항상 샌드박스 실행: 앱키 없는 자식 프로세스, 제한된 builtins, AST 차단목록(os/socket/urllib/subprocess/open·introspection 불가), 스크럽된 읽기전용 context — credential·broker·네트워크 접근 없음. 상류 값 전체를 'data' 에 바인딩해 코드 안에서 반복하세요. 다운스트림은 소비자 노드의 범용 입력 필드(TableDisplayNode.data, IfNode.left/right 등)에 {{ nodes.<id>.<port> }} 를 써서 출력을 소비합니다 — 타입드 포트 매칭이 아님. 따라서 타입드 주문/조건 노드로 흘릴 땐 표준 [{symbol, exchange, ...}] 모양을 반환하고, 디스플레이/싱크나 If 스칼라엔 아무 모양이나 됩니다. 일반적 연결: HistoricalDataNode → CodeNode → IfNode. 타입 노드(ConditionNode/FieldMappingNode/IfNode)로 가능한 로직은 그쪽을 우선하세요.",
   "nodes.CurrencyRateNode.description": "유럽중앙은행(ECB) 기반 실시간 환율을 조회합니다. 브로커 연결이나 API 키가 필요 없습니다. 기준 통화와 대상 통화를 설정하여 환율을 가져옵니다. 한국 투자자를 위한 USD/KRW 환율 전용 출력 포트를 제공합니다. 타임아웃 및 속도 제한 오류 시 자동 재시도, open.er-api.com 폴백 기능 내장. 일반적인 연결: CurrencyRateNode → ConditionNode (환율 기반 시그널) 또는 → FieldMappingNode. AI Agent 도구로 사용 가능.",
   "nodes.CurrencyRateNode.name": "환율 조회",
   "nodes.ErrorHandlerNode.description": "상위 노드의 에러를 처리하고 복구 로직을 실행합니다. 에러 데이터를 로깅, 알림, 또는 폴백 처리로 라우팅합니다. API 장애, 타임아웃 에러, 유효하지 않은 데이터를 우아하게 처리하는 견고한 워크플로우를 구축하세요.",
@@ -288,6 +290,10 @@
   "fields.CurrencyRateNode.resilience": "API 호출 실패 시 재시도 및 폴백 설정",
   "fields.CurrencyRateNode.target_currencies": "대상 통화 목록. 기준 통화 대비 환율을 조회할 통화를 선택하세요.",
   "fields.CurrencyRateNode.timeout_seconds": "API 요청 타임아웃 (초). 기본 30초, 네트워크 환경에 따라 조정하세요.",
+  "fields.CodeNode.code": "async def execute(data, params, context) 를 정의하는 파이썬 소스. 샌드박스: 순수 계산용 표준 라이브러리(math, statistics, json, datetime, ...) import 만 허용, credential·네트워크·파일시스템·introspection 불가.",
+  "fields.CodeNode.outputs": "출력 포트 선언 [{name, type}]. 비워두면 반환값 전체를 담는 단일 'result' 포트가 됩니다. 선언한 포트는 소비자 노드의 범용 입력 필드(TableDisplayNode.data, IfNode.left/right 등)에 {{ nodes.<id>.<port> }} 표현식으로 소비됩니다 — 타입드 포트 매칭이 아니라 이름으로 dict 키를 꺼내는 방식. 선언하면 정적 오타 검증이 적용됩니다.",
+  "fields.CodeNode.params": "execute() 에 `params` 로 전달되는 파라미터. 표현식 바인딩 허용(예: 기간·임계값).",
+  "fields.CodeNode.data": "execute() 에 `data` 로 전달되는 입력 데이터. 상류 값 전체를 바인딩(예: {{ nodes.hist.values }})하고 함수 안에서 반복하세요.",
   "fields.FieldMappingNode.data": "변환할 입력 데이터. HTTPRequestNode 응답이나 다른 노드 출력을 바인딩하세요.",
   "fields.FieldMappingNode.mappings": "필드명 매핑 테이블. 원본 필드명(from)을 표준 필드명(to)으로 변환합니다.",
   "fields.FieldMappingNode.mappings.description": "필드 설명 (AI 에이전트 자동 매핑용)",
@@ -847,6 +853,7 @@
   "fieldNames.TradingHoursFilterNode.timezone": "시간대",
   "fieldNames.WatchlistNode.symbols": "종목",
   "outputs.AIAgentNode.response": "AI 에이전트 응답 (출력 형식에 따라 텍스트 또는 JSON 객체)",
+  "outputs.CodeNode.result": "출력 포트를 선언하지 않았을 때 execute() 가 반환한 값 전체. 출력 포트를 선언하면 해당 포트를 대신 읽으세요.",
   "outputs.ExclusionListNode.count": "제외 종목 수",
   "outputs.ExclusionListNode.excluded": "최종 제외 종목 목록 (수동 + 동적 합산, 중복 제거)",
   "outputs.ExclusionListNode.filtered": "원본 종목에서 제외 종목을 뺀 결과 (input_symbols 연결 시)",

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/models/validation.py

@@ -31,12 +31,16 @@ class ErrorCode(str, Enum):
 
     # Node / plugin registry
     UNKNOWN_NODE_TYPE = "UNKNOWN_NODE_TYPE"
-    UNKNOWN_DYNAMIC_NODE_SCHEMA = "UNKNOWN_DYNAMIC_NODE_SCHEMA"
-    DYNAMIC_NODE_CREDENTIAL_FORBIDDEN = "DYNAMIC_NODE_CREDENTIAL_FORBIDDEN"
-    DYNAMIC_NODE_CLASS_NOT_INJECTED = "DYNAMIC_NODE_CLASS_NOT_INJECTED"
     MISSING_PLUGIN = "MISSING_PLUGIN"
     UNKNOWN_PLUGIN = "UNKNOWN_PLUGIN"
 
+    # CodeNode (custom Python code node)
+    CODE_NODE_SYNTAX_ERROR = "CODE_NODE_SYNTAX_ERROR"        # ast.parse / compile failed (line/offset)
+    CODE_NODE_FORBIDDEN = "CODE_NODE_FORBIDDEN"              # AST denylist violation (blocked import/builtin/dunder)
+    CODE_NODE_NO_EXECUTE = "CODE_NODE_NO_EXECUTE"           # code does not define execute()
+    CODE_NODE_EXEC_ERROR = "CODE_NODE_EXEC_ERROR"          # runtime exception / worker crash / timeout / bad serialization
+    CODE_NODE_DISABLED = "CODE_NODE_DISABLED"              # allow_code_node=False environment
+
     # Edges
     INVALID_EDGE_REF = "INVALID_EDGE_REF"
     INVALID_EDGE_PORT = "INVALID_EDGE_PORT"

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/nodes/__init__.py

@@ -48,6 +48,7 @@ from programgarden_core.nodes.symbol_stock import OverseasStockSymbolQueryNode
 from programgarden_core.nodes.symbol_futures import OverseasFuturesSymbolQueryNode
 # Data (상품 무관)
 from programgarden_core.nodes.data import SQLiteNode, HTTPRequestNode, FieldMappingNode
+from programgarden_core.nodes.code import CodeNode
 # Market External (credential 불필요, 무료 외부 API)
 from programgarden_core.nodes.market_external import CurrencyRateNode
 # Market Status (JIF 장운영정보 — broker credential agnostic)
@@ -146,6 +147,7 @@ __all__ = [
     "SQLiteNode",
     "HTTPRequestNode",
     "FieldMappingNode",
+    "CodeNode",
     # Market External (credential 불필요)
     "CurrencyRateNode",
     # Market Status (JIF 장운영정보)

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/nodes/account_futures.py

@@ -124,7 +124,7 @@ class OverseasFuturesAccountNode(BaseNode):
                     {"id": "start", "type": "StartNode"},
                     {"id": "broker", "type": "OverseasFuturesBrokerNode", "credential_id": "futures_cred", "paper_trading": True},
                     {"id": "account", "type": "OverseasFuturesAccountNode"},
-                    {"id": "if_margin", "type": "IfNode", "left": "{{ nodes.account.balance.orderable_margin }}", "operator": ">=", "right": 10000},
+                    {"id": "if_margin", "type": "IfNode", "left": "{{ nodes.account.balance.orderable_amount }}", "operator": ">=", "right": 10000},
                     {"id": "order", "type": "OverseasFuturesNewOrderNode", "symbol": "ESH26", "exchange": "CME", "side": "buy", "order_type": "limit", "quantity": 1, "price": 5200.0},
                 ],
                 "edges": [
@@ -144,7 +144,7 @@ class OverseasFuturesAccountNode(BaseNode):
                     }
                 ],
             },
-            "expected_output": "When orderable_margin >= 10000: NewOrderNode places a buy limit order. Otherwise the order branch is skipped.",
+            "expected_output": "When orderable_amount >= 10000: NewOrderNode places a buy limit order. Otherwise the order branch is skipped.",
         },
     ]
     _node_guide: ClassVar[Dict[str, Any]] = {

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/nodes/account_stock.py

@@ -125,7 +125,7 @@ class OverseasStockAccountNode(BaseNode):
                     {"id": "broker", "type": "OverseasStockBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "account", "type": "OverseasStockAccountNode"},
                     {"id": "market", "type": "OverseasStockMarketDataNode", "symbol": "{{ item }}"},
-                    {"id": "display", "type": "TableDisplayNode", "title": "Live Prices", "data": "{{ nodes.market.data }}"},
+                    {"id": "display", "type": "TableDisplayNode", "title": "Live Prices", "data": "{{ nodes.market.values }}"},
                 ],
                 "edges": [
                     {"from": "start", "to": "broker"},

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/nodes/backtest.py

@@ -203,7 +203,7 @@ class BacktestEngineNode(BaseNode):
                     {"id": "start", "type": "StartNode"},
                     {"id": "broker", "type": "OverseasStockBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "historical", "type": "OverseasStockHistoricalDataNode", "symbols": [{"symbol": "AAPL", "exchange": "NASDAQ"}], "period": "1d", "count": 252},
-                    {"id": "condition", "type": "ConditionNode", "plugin": "RSI", "data": "{{ nodes.historical.values }}", "period": 14, "oversold": 30, "overbought": 70},
+                    {"id": "condition", "type": "ConditionNode", "plugin": "RSI", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"period": 14, "threshold": 30, "direction": "below"}},
                     {
                         "id": "backtest",
                         "type": "BacktestEngineNode",
@@ -261,7 +261,7 @@ class BacktestEngineNode(BaseNode):
                     {"id": "start", "type": "StartNode"},
                     {"id": "broker", "type": "OverseasStockBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "historical", "type": "OverseasStockHistoricalDataNode", "symbols": [{"symbol": "SPY", "exchange": "NYSE"}], "period": "1d", "count": 504},
-                    {"id": "condition", "type": "ConditionNode", "plugin": "MACD", "data": "{{ nodes.historical.values }}"},
+                    {"id": "condition", "type": "ConditionNode", "plugin": "MACD", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"fast": 12, "slow": 26, "signal": 9, "direction": "bullish_cross"}},
                     {
                         "id": "backtest",
                         "type": "BacktestEngineNode",
@@ -748,8 +748,8 @@ class BenchmarkCompareNode(BaseNode):
                     {"id": "start", "type": "StartNode"},
                     {"id": "broker", "type": "OverseasStockBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "historical", "type": "OverseasStockHistoricalDataNode", "symbols": [{"symbol": "SPY", "exchange": "NYSE"}], "period": "1d", "count": 252},
-                    {"id": "rsi_cond", "type": "ConditionNode", "plugin": "RSI", "data": "{{ nodes.historical.values }}", "period": 14, "oversold": 30, "overbought": 70},
-                    {"id": "macd_cond", "type": "ConditionNode", "plugin": "MACD", "data": "{{ nodes.historical.values }}"},
+                    {"id": "rsi_cond", "type": "ConditionNode", "plugin": "RSI", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"period": 14, "threshold": 30, "direction": "below"}},
+                    {"id": "macd_cond", "type": "ConditionNode", "plugin": "MACD", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"fast": 12, "slow": 26, "signal": 9, "direction": "bullish_cross"}},
                     {
                         "id": "backtest_rsi",
                         "type": "BacktestEngineNode",
@@ -807,7 +807,7 @@ class BenchmarkCompareNode(BaseNode):
                     {"id": "start", "type": "StartNode"},
                     {"id": "broker", "type": "OverseasStockBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "historical", "type": "OverseasStockHistoricalDataNode", "symbols": [{"symbol": "QQQ", "exchange": "NASDAQ"}], "period": "1d", "count": 252},
-                    {"id": "condition", "type": "ConditionNode", "plugin": "MACD", "data": "{{ nodes.historical.values }}"},
+                    {"id": "condition", "type": "ConditionNode", "plugin": "MACD", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"fast": 12, "slow": 26, "signal": 9, "direction": "bullish_cross"}},
                     {
                         "id": "backtest",
                         "type": "BacktestEngineNode",

{programgarden_core-1.15.2 → programgarden_core-1.16.0}/programgarden_core/nodes/backtest_futures.py

@@ -121,7 +121,7 @@ class OverseasFuturesHistoricalDataNode(BaseNode):
                     {"id": "broker", "type": "OverseasFuturesBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "split", "type": "SplitNode", "items": [{"symbol": "ESH26", "exchange": "CME"}]},
                     {"id": "historical", "type": "OverseasFuturesHistoricalDataNode", "symbol": "{{ nodes.split.item }}", "start_date": "{{ date.ago(60, format='yyyymmdd') }}", "end_date": "{{ date.today(format='yyyymmdd') }}", "interval": "1d", "adjust": False},
-                    {"id": "condition", "type": "ConditionNode", "plugin": "BollingerBands", "data": "{{ nodes.historical.value.time_series }}"},
+                    {"id": "condition", "type": "ConditionNode", "plugin": "BollingerBands", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"period": 20, "std": 2.0, "direction": "below_lower"}},
                 ],
                 "edges": [
                     {"from": "start", "to": "broker"},
@@ -154,7 +154,7 @@ class OverseasFuturesHistoricalDataNode(BaseNode):
                     {"id": "broker", "type": "OverseasFuturesBrokerNode", "credential_id": "broker_cred", "paper_trading": False},
                     {"id": "split", "type": "SplitNode", "items": [{"symbol": "MHIH26", "exchange": "HKEX"}]},
                     {"id": "historical", "type": "OverseasFuturesHistoricalDataNode", "symbol": "{{ nodes.split.item }}", "start_date": "{{ date.ago(10, format='yyyymmdd') }}", "end_date": "{{ date.today(format='yyyymmdd') }}", "interval": "1h", "adjust": False},
-                    {"id": "condition", "type": "ConditionNode", "plugin": "MACD", "data": "{{ nodes.historical.value.time_series }}"},
+                    {"id": "condition", "type": "ConditionNode", "plugin": "MACD", "items": {"from": "{{ item.time_series }}", "extract": {"symbol": "{{ item.symbol }}", "exchange": "{{ item.exchange }}", "date": "{{ row.date }}", "close": "{{ row.close }}"}}, "fields": {"fast": 12, "slow": 26, "signal": 9, "direction": "bullish_cross"}},
                 ],
                 "edges": [
                     {"from": "start", "to": "broker"},