rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98 Download lambdas/codegen/wave1_core_emitters.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 7.64 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/codegen/wave1_core_emitters.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/lambdas/codegen/wave1_core_emitters.py
-
curl -L -o wave1_core_emitters.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/codegen/wave1_core_emitters.py
7.64 kB
| """ | |
| ALLI Codegen Subpackage: Safe Wave-1 Core & Workspace Env Emitters | |
| Eliminates raw code-string interpolation for type_cast, variable/constant literals, | |
| and emits AST-validated sys.env_get / sys.env_set statements. | |
| """ | |
| import re | |
| from typing import Any, Optional, Tuple | |
| from lambdas.codegen.context import NodeCodegenCtx | |
| from language_core.codegen_contracts import format_literal, sanitize_identifier | |
| from language_core.executor.wave1_handlers import normalize_cast_target | |
| from language_core.workspace_env_contracts import validate_env_key | |
| SAFE_HTTP_METHODS = frozenset({"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}) | |
| SAFE_BINARY_OPS = frozenset({"+", "-", "*", "/", "//", "%", "**"}) | |
| SAFE_COMPARE_OPS = frozenset({"==", "!=", "<", "<=", ">", ">="}) | |
| SAFE_LOGICAL_OPS = frozenset({"and", "or", "not"}) | |
| SAFE_ROUNDING_MODES = frozenset({"none", "round", "floor", "ceil"}) | |
| _ENCODING_RE = re.compile(r"^[a-zA-Z0-9_-]{2,24}$") | |
| def sanitize_encoding_name(raw_enc: Any, default: str = "utf-8") -> str: | |
| """Validate text encoding identifier strictly to prevent string interpolation escape.""" | |
| candidate = str(raw_enc or default).strip() | |
| return candidate if _ENCODING_RE.match(candidate) else default | |
| def validate_safe_op(raw_op: Any, allowed: frozenset, default: str, nctx: NodeCodegenCtx, kind: str) -> str: | |
| """Allowlist operator string cleanly before code interpolation.""" | |
| op = str(raw_op or default).strip() | |
| if op not in allowed: | |
| nctx.cg.diagnostics.append({ | |
| "code": "CODEGEN-SECURITY-VIOLATION", | |
| "severity": "error", | |
| "message": f"Unsafe {kind} operator '{op}' rejected on node '{nctx.label}' ({nctx.node_id}).", | |
| "node_id": nctx.node_id, | |
| }) | |
| return default | |
| return op | |
| def emit_safe_constant_node(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: | |
| """Emit literal constant assignment supporting both literal_value and value aliases.""" | |
| raw_type, node_id, safe_id, params, cg = nctx.raw_type, nctx.node_id, nctx.safe_id, nctx.params, nctx.cg | |
| lines = cg.code_body_lines | |
| raw_val = params.get("literal_value") | |
| if raw_val is None: | |
| raw_val = params.get("value", 0) | |
| ctype = str(params.get("const_type") or "").strip().lower() | |
| _tmap = ( | |
| ("int", "int"), ("integer", "int"), ("float", "float"), ("number", "float"), | |
| ("str", "str"), ("string", "str"), ("text", "str"), ("bool", "bool"), | |
| ("boolean", "bool"), ("list", "list"), ("dict", "dict"), | |
| ) | |
| dtype = ctype if ctype in ("int", "float", "str", "bool", "list", "dict", "any") else next((v for k, v in _tmap if k in raw_type), "any") | |
| try: | |
| formatted_val = format_literal(raw_val, dtype) | |
| except ValueError as ve: | |
| cg.diagnostics.append({"code": "VAL-NON-FINITE-NUMBER", "severity": "error", "message": f"Node '{nctx.label}' ({node_id}): {ve}", "node_id": node_id}) | |
| formatted_val = "0.0" | |
| nv = sanitize_identifier(params.get("const_name"), f"val_{safe_id}") | |
| lines.append(f" {nv} = {formatted_val}") | |
| return True, nv | |
| def emit_safe_variable_node(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: | |
| """Emit variable assignment preserving explicit type annotations and upstream input overrides.""" | |
| params, safe_id, cg = nctx.params, nctx.safe_id, nctx.cg | |
| nv = sanitize_identifier(params.get("var_name", "my_var"), f"var_{safe_id}") | |
| default_val = params.get("literal_value") if params.get("literal_value") is not None else params.get("value", 0) | |
| vtype = str(params.get("var_type") or ("str" if isinstance(default_val, str) and not default_val.lstrip("-").isdigit() else "int")).lower() | |
| if nctx.incoming: | |
| assigned = nctx.resolve_input(["in_val", "in", "val", "value"], default_val) | |
| else: | |
| assigned = format_literal(default_val, vtype) | |
| cg.code_body_lines.append(f" {nv} = {assigned}") | |
| return True, nv | |
| def emit_safe_type_cast(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: | |
| """Emit AST-safe explicit type conversion with strict target_type allowlisting (zero code injection).""" | |
| node_id, safe_id, params, cg = nctx.node_id, nctx.safe_id, nctx.params, nctx.cg | |
| lines, nv = cg.code_body_lines, f"cast_{safe_id}" | |
| raw_target = params.get("target_type", "str") | |
| try: | |
| ttype = normalize_cast_target(raw_target) | |
| except ValueError as exc: | |
| cg.diagnostics.append({ | |
| "code": "CODEGEN-SECURITY-VIOLATION", | |
| "severity": "error", | |
| "message": str(exc), | |
| "node_id": node_id, | |
| "port_id": "target_type", | |
| }) | |
| lines.append(f" {nv} = None") | |
| return True, nv | |
| val_expr = nctx.resolve_input(["value", "in_val", "val", "raw"], params.get("value", 0)) | |
| if ttype == "bool": | |
| lines.append(f" {nv} = (({val_expr}).strip().lower() in ('true', '1', 'yes', 'on') if isinstance({val_expr}, str) else bool({val_expr}))") | |
| elif ttype == "json": | |
| cg.discovered_modules.add("json") | |
| lines.append(f" {nv} = (json.loads({val_expr}) if isinstance({val_expr}, str) else json.dumps({val_expr}))") | |
| else: | |
| lines.append(f" {nv} = {ttype}({val_expr})") | |
| return True, nv | |
| def emit_safe_sys_env(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: | |
| """Emit clean Python os.getenv / os.environ[KEY] code for workspace env nodes.""" | |
| raw_type, node_id, safe_id, params, cg = nctx.raw_type, nctx.node_id, nctx.safe_id, nctx.params, nctx.cg | |
| lines, ovm = cg.code_body_lines, cg.output_var_map | |
| if raw_type not in ("alli.sys.env", "sys.env_get", "sys.env", "sys.env_set"): | |
| return False, None | |
| is_set_mode = raw_type == "sys.env_set" or (raw_type in ("sys.env", "alli.sys.env") and str(params.get("mode") or "get").strip().lower() == "set") | |
| raw_key = str(params.get("key") or ("APP_CONFIG_VAR" if is_set_mode else "ENV_VAR")).strip() | |
| ok_key, clean_key_or_code, key_err = validate_env_key(raw_key) | |
| if not ok_key: | |
| cg.diagnostics.append({ | |
| "code": clean_key_or_code, | |
| "severity": "error", | |
| "message": key_err, | |
| "node_id": node_id, | |
| "port_id": "key", | |
| }) | |
| return True, f"env_err_{safe_id}" | |
| cg.discovered_modules.add("os") | |
| cg.referenced_env_keys.add(clean_key_or_code) | |
| key_lit = format_literal(clean_key_or_code) | |
| is_secret = bool(params.get("is_secret")) | |
| if is_set_mode: | |
| if nctx.is_wired(["value", "val", "in"]): | |
| val_expr = nctx.resolve_input(["value", "val", "in"], "") | |
| lines.append(f" os.environ[{key_lit}] = str({val_expr})") | |
| elif is_secret: | |
| lines.append(f" os.environ[{key_lit}] = os.getenv({key_lit}, \"\")") | |
| else: | |
| raw_val = nctx.node_inputs.get("value") if "value" in nctx.node_inputs else params.get("value") | |
| val_expr = format_literal(raw_val if raw_val is not None else "") | |
| lines.append(f" os.environ[{key_lit}] = str({val_expr})") | |
| nv = f"env_set_{safe_id}" | |
| lines.append(f" {nv} = {key_lit}") | |
| ovm.update({f"{node_id}:result": nv, f"{node_id}:key": nv, f"{node_id}:out": nv, node_id: nv}) | |
| return True, nv | |
| def_val = "" if is_secret else (params.get("default_val") if params.get("default_val") is not None else "") | |
| def_expr = format_literal(str(def_val)) | |
| nv = sanitize_identifier(params.get("var_name"), f"env_{safe_id}") | |
| lines.append(f" {nv} = os.getenv({key_lit}, {def_expr})") | |
| ovm.update({f"{node_id}:result": nv, f"{node_id}:val": nv, f"{node_id}:out": nv, node_id: nv}) | |
| return True, nv | |