Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+572
View File
@@ -0,0 +1,572 @@
"""Structured workflow v2: bounded compiler, request-local variables and safe control flow.
The compiler emits ordinary legacy action dictionaries interleaved with private
instructions. BrowserWorkflowMixin still executes EVERY leaf in its existing
media/ownership/cancellation lifecycle. No eval, Python attribute access or
arbitrary jumps. Public schema remains a list of {action,target,optional,value}.
"""
from __future__ import annotations
import copy
import json
import math
import re
import time
from urllib.parse import quote
from typing import Any
from app.core.config import WorkflowError, WorkflowCancelledError
from app.core.driver import as_element
CONTROL_ACTIONS = frozenset({"SET", "CAPTURE", "IF", "SWITCH", "GROUP", "GUARD", "TRY", "LABEL"})
LEAF_ACTIONS = frozenset({"FILL_INPUT", "SELECT_MODEL", "CLICK", "COORD_CLICK", "COORD_SCROLL", "STREAM_WAIT", "STREAM_OUTPUT", "KEY_PRESS", "WAIT", "JS_EXEC", "READONLY_HINT", "PAGE_FETCH"})
OPS = {"eq", "ne", "contains", "starts_with", "ends_with", "matches", "exists", "not_exists", "gt", "gte", "lt", "lte", "in"}
TRANSFORMS = {"trim", "lower", "upper", "string", "number", "boolean", "urlencode", "css_escape", "json"}
NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
TOKEN = re.compile(r"\{\{\s*([A-Za-z_][\w.]*)\s*\}\}|(?<!\{)\{([A-Za-z_][\w.]*)\}(?!\})")
MISSING = object()
MAX_NODES, MAX_DEPTH, MAX_BYTES = 1000, 16, 1_048_576
class FlowValidationError(WorkflowError):
pass
class FlowVariableError(WorkflowError):
pass
class FlowLimitError(WorkflowError):
pass
def _size(value, limit=MAX_BYTES):
try:
if len(json.dumps(value, ensure_ascii=False, allow_nan=False).encode("utf-8")) > limit:
raise FlowValidationError("工作流数据超出大小限制")
except (TypeError, ValueError, RecursionError) as exc:
raise FlowValidationError("工作流必须是有限、可序列化的 JSON 数据") from exc
def validate_inputs(value):
if not isinstance(value, dict) or len(value) > 128:
raise FlowValidationError("workflow_variables 必须为不超过 128 个键的对象")
if any(not isinstance(k, str) or not NAME.fullmatch(k) or k.startswith("__") for k in value):
raise FlowValidationError("变量名只能包含字母、数字及下划线,不能以数字或双下划线开头")
_size(value, 65536)
return value
def has_control_flow(workflow):
return any(isinstance(step, dict) and (step.get("action") in CONTROL_ACTIONS or step.get("flow_version") == 2 or "selector" in step) for step in (workflow or []))
def _condition_valid(condition, depth=0):
if depth > MAX_DEPTH or not isinstance(condition, dict):
raise FlowValidationError("条件必须为对象,嵌套不能超过 16 层")
for mode in ("all", "any"):
if mode in condition:
if not isinstance(condition[mode], list) or not 1 <= len(condition[mode]) <= 64:
raise FlowValidationError("组合条件需要 1–64 个子条件")
for child in condition[mode]:
_condition_valid(child, depth + 1)
return
if "not" in condition:
_condition_valid(condition["not"], depth + 1)
return
if condition.get("op") not in OPS or "left" not in condition:
raise FlowValidationError("条件缺少 left 或使用了未知运算符")
if condition["op"] not in {"exists", "not_exists"} and "right" not in condition:
raise FlowValidationError("比较条件缺少 right")
def validate_workflow(workflow):
"""Validate all branches BEFORE any page action; never mutate user JSON."""
if not isinstance(workflow, list):
raise FlowValidationError("workflow 必须为数组")
_size(workflow)
count = 0
def walk(nodes, depth=0):
nonlocal count
if depth > MAX_DEPTH or not isinstance(nodes, list):
raise FlowValidationError("分支必须为数组,嵌套不能超过 16 层")
labels = {}
for i, node in enumerate(nodes):
count += 1
if count > MAX_NODES or not isinstance(node, dict):
raise FlowValidationError("步骤必须为对象,步骤总数不能超过 1000")
action = node.get("action")
if action not in CONTROL_ACTIONS | LEAF_ACTIONS:
raise FlowValidationError(f"无效工作流动作: {action}")
if "retry_safe" in node and not isinstance(node["retry_safe"], bool):
raise FlowValidationError("retry_safe 必须为布尔值")
if action not in CONTROL_ACTIONS:
continue
v = node.get("value")
if not isinstance(v, dict):
raise FlowValidationError(f"{action}.value 必须为对象")
if action in {"SET", "CAPTURE", "LABEL"}:
name = v.get("name", "")
if not isinstance(name, str) or not NAME.fullmatch(name) or name.startswith("__"):
raise FlowValidationError(f"{action} 需要合法的 name")
if action in {"SET", "CAPTURE"} and v.get("scope", "local") not in {"local", "global"}:
raise FlowValidationError("变量 scope 必须为 local 或 global")
if action == "SET":
if "value" not in v or v.get("mode", "assign") not in {"assign", "default"}:
raise FlowValidationError("SET 需要 value,mode 为 assign/default")
if action == "CAPTURE":
if v.get("source", "text") not in {"text", "attribute", "class", "url", "exists", "value"}:
raise FlowValidationError("不支持的 CAPTURE.source")
if v.get("source") == "attribute" and not v.get("attribute"):
raise FlowValidationError("捕获属性必须指定 attribute")
if not isinstance(v.get("timeout", 2), (int, float)) or not 0 <= v.get("timeout", 2) <= 30:
raise FlowValidationError("捕获超时需为 0–30 秒")
if action in {"IF", "GUARD"}:
_condition_valid(v.get("condition"))
if action == "SWITCH":
cases = v.get("cases")
if not isinstance(cases, list) or not 1 <= len(cases) <= 32:
raise FlowValidationError("多分支需要 1–32 个有序情况")
for case in cases:
if not isinstance(case, dict):
raise FlowValidationError("情况必须是对象")
if "label" in case and (not isinstance(case["label"], str) or len(case["label"]) > 160):
raise FlowValidationError("情况名称必须是 160 字以内的文本")
_condition_valid(case.get("condition"))
walk(case.get("steps", []), depth + 1)
walk(v.get("default", []), depth + 1)
if action == "IF":
walk(v.get("then", []), depth + 1)
walk(v.get("else", []), depth + 1)
if action in {"GROUP", "TRY"}:
walk(v.get("steps", []), depth + 1)
if action == "GROUP":
validate_inputs(v.get("variables", {}))
if action == "TRY":
attempts = v.get("attempts", 1)
if type(attempts) is not int or not 1 <= attempts <= 5:
raise FlowValidationError("TRY.attempts 必须为 1–5 的整数")
delay = v.get("delay", 0.3)
if type(delay) not in (int, float) or not 0 <= delay <= 5:
raise FlowValidationError("TRY.delay 必须为 0–5 秒")
if "retry_side_effects" in v and not isinstance(v["retry_side_effects"], bool):
raise FlowValidationError("retry_side_effects 必须为布尔值")
if "errors" in v and (not isinstance(v["errors"], list) or not v["errors"] or any(not isinstance(x, str) for x in v["errors"])):
raise FlowValidationError("TRY.errors 必须为非空错误类型数组")
if "fallback" in v:
walk(v["fallback"], depth + 1)
if action == "GUARD" and v.get("mode", "skip_group") not in {"skip_group", "goto"}:
raise FlowValidationError("GUARD.mode 必须为 skip_group/goto")
if action == "LABEL":
if v["name"] in labels:
raise FlowValidationError("同一分支内的锚点名称不能重复")
labels[v["name"]] = i
for i, node in enumerate(nodes):
if node.get("action") == "GUARD" and node["value"].get("mode") == "goto":
target = labels.get(node["value"].get("anchor"), -1)
if target <= i:
raise FlowValidationError("只能前往同一分支内位于后方的锚点")
walk(workflow)
return {"valid": True, "nodes": count, "version": 2 if has_control_flow(workflow) else 1}
class Variables:
"""Request globals, explicit lexical locals, read-only inputs/context namespaces."""
def __init__(self, context=None, inputs=None):
self.context = context if context is not None else {}
self.inputs = copy.deepcopy(validate_inputs(inputs if inputs is not None else {}))
self.globals = copy.deepcopy(self.inputs)
self.locals = []
self.error = {}
def merged(self):
result = dict(self.globals)
for scope in self.locals:
result.update(scope["values"])
return result
def lookup(self, path, missing=False):
parts = str(path).split(".")
if any(not NAME.fullmatch(p) or p.startswith("__") for p in parts):
raise FlowVariableError("不合法的变量路径")
namespaces = {"vars": self.merged(), "inputs": self.inputs, "context": self.context, "error": self.error}
if parts[0] in namespaces:
obj = namespaces[parts.pop(0)]
else:
obj = self.merged()
if parts[0] not in obj and parts[0] in self.context:
obj = self.context
for part in parts:
if not isinstance(obj, dict) or part not in obj:
if missing:
return MISSING
raise FlowVariableError(f"变量未定义: {path}")
obj = obj[part]
return copy.deepcopy(obj)
def resolve(self, value, depth=0):
if depth > 32:
raise FlowLimitError("表达式嵌套超过限制")
if isinstance(value, dict):
if "$literal" in value:
return copy.deepcopy(value["$literal"])
if "$var" in value:
result = self.lookup(value["$var"], missing="default" in value)
return self.resolve(value.get("default"), depth + 1) if result is MISSING else result
if "$map" in value:
source = self.resolve(value.get("input"), depth + 1)
table = value["$map"]
if not isinstance(table, dict):
raise FlowVariableError("$map 必须为字典")
key = str(source)
if key in table:
return self.resolve(table[key], depth + 1)
if "default" in value:
return self.resolve(value["default"], depth + 1)
raise FlowVariableError("映射中没有匹配值且未设置 default")
if "$transform" in value:
op = value["$transform"]
if op not in TRANSFORMS:
raise FlowVariableError("未知转换操作")
source = self.resolve(value.get("input"), depth + 1)
text = str(source) if source is not None else ""
if op in {"trim", "lower", "upper"}:
return {"trim": str.strip, "lower": str.lower, "upper": str.upper}[op](text)
if op == "string": return text
if op == "json": return json.dumps(source, ensure_ascii=False, allow_nan=False)
if op == "urlencode": return quote(text, safe="")
if op == "css_escape":
return "".join(c if (c.isascii() and (c.isalpha() or c in "_-" or (i > 0 and c.isdigit()))) else f"\\{ord(c):x} " for i, c in enumerate(text))
if op == "number":
try:
number = float(source)
if not math.isfinite(number): raise ValueError()
return number
except (ValueError, TypeError) as exc:
raise FlowVariableError("无法转换为有限数字") from exc
if op == "boolean":
if source in (True, False) and type(source) is bool: return source
if text.lower() in {"true", "1"}: return True
if text.lower() in {"false", "0", ""}: return False
raise FlowVariableError("布尔转换只接受 true/false/1/0")
return {k: self.resolve(v, depth + 1) for k, v in value.items()}
if isinstance(value, list):
return [self.resolve(v, depth + 1) for v in value]
if not isinstance(value, str):
return value
exact = TOKEN.fullmatch(value)
if exact:
return self.lookup(exact.group(1) or exact.group(2))
return TOKEN.sub(lambda m: str(self.lookup(m.group(1) or m.group(2))), value)
def set(self, name, value, scope="local", mode="assign"):
target = self.locals[-1]["values"] if scope == "local" and self.locals else self.globals
if mode == "default" and self.lookup("vars." + name, missing=True) is not MISSING:
return
_size(value, 65536)
target[name] = copy.deepcopy(value)
_size(self.merged(), 262144)
def condition(self, condition):
if "all" in condition: return all(self.condition(c) for c in condition["all"])
if "any" in condition: return any(self.condition(c) for c in condition["any"])
if "not" in condition: return not self.condition(condition["not"])
op, left = condition["op"], condition["left"]
if op in {"exists", "not_exists"}:
path = left.get("$var") if isinstance(left, dict) else None
if path is None and isinstance(left, str):
match = TOKEN.fullmatch(left)
path = (match.group(1) or match.group(2)) if match else None
result = self.lookup(path, missing=True) if path else self.resolve(left)
exists = result is not MISSING and result is not None
return exists if op == "exists" else not exists
a, b = self.resolve(left), self.resolve(condition["right"])
if op == "eq": return type(a) is type(b) and a == b
if op == "ne": return not (type(a) is type(b) and a == b)
if op in {"gt", "gte", "lt", "lte"}:
if type(a) not in (float, int) or type(b) not in (float, int):
raise FlowVariableError("大小比较要求数字,请先使用 number 转换")
return {"gt": a > b, "gte": a >= b, "lt": a < b, "lte": a <= b}[op]
if op == "contains":
if not isinstance(a, (str, list, dict)): raise FlowVariableError("contains 需要字符串、数组或对象")
return b in a
if op == "in":
if not isinstance(b, (str, list, dict)): raise FlowVariableError("in 需要字符串、数组或对象")
return a in b
if op in {"starts_with", "ends_with"}:
if not isinstance(a, str) or not isinstance(b, str): raise FlowVariableError("前后缀比较需要字符串")
return a.startswith(b) if op == "starts_with" else a.endswith(b)
if op == "matches":
if not isinstance(a, str) or not isinstance(b, str) or len(b) > 512 or len(a) > 65536:
raise FlowVariableError("正则需要字符串,模式≤512字符、输入≤65536字符")
import regex
try:
return bool(regex.search(b, a, timeout=0.025))
except (regex.error, TimeoutError) as exc:
raise FlowVariableError("正则无效或超过 25ms 求值预算") from exc
raise FlowVariableError("未知条件运算符")
class FlowProgram:
def __init__(self, workflow, context=None, inputs=None, capture=None, stop_checker=None, max_transitions=10000, deadline_seconds=300):
validate_workflow(workflow)
self.variables = Variables(context, inputs)
self.capture = capture
self.stop_checker = stop_checker or (lambda: False)
self.steps, self.trace, self.tries = [], [], []
self.output_emitted = False
self.transitions = 0
self.max_transitions = min(10000, max(1, max_transitions))
self.deadline = time.monotonic() + min(3600, max(1, deadline_seconds))
self._compile(copy.deepcopy(workflow), "root", None)
def _emit(self, op, path, **kwargs):
self.steps.append({"action": "__FLOW_INTERNAL", "target": "", "optional": False, "_op": op, "_path": path, **kwargs})
return len(self.steps) - 1
def _compile(self, nodes, path, group_end):
labels, jumps = {}, []
for n, node in enumerate(nodes):
p = f"{path}.{n}"
action, v = node["action"], node.get("value", {})
if action not in CONTROL_ACTIONS:
self.steps.append({**node, "_path": p})
elif action == "IF":
test = self._emit("if", p, condition=v["condition"])
self._compile(v.get("then", []), p + ".then", group_end)
jump = self._emit("jump", p)
self.steps[test]["to"] = len(self.steps)
self._compile(v.get("else", []), p + ".else", group_end)
self.steps[jump]["to"] = self._emit("merge", p)
elif action == "SWITCH":
test = self._emit("switch", p, cases=[])
exits = []
for case_index, case in enumerate(v["cases"]):
branch = f"case_{case_index}"
self.steps[test]["cases"].append({"condition": case["condition"], "to": len(self.steps), "branch": branch})
self._compile(case.get("steps", []), p + "." + branch, group_end)
exits.append(self._emit("jump", p))
self.steps[test]["default_to"] = len(self.steps)
self._compile(v.get("default", []), p + ".default", group_end)
merge = self._emit("merge", p)
for exit_index in exits:
self.steps[exit_index]["to"] = merge
elif action == "GROUP":
ref = {}
enter = self._emit("enter", p, variables=v.get("variables", {}), end=ref)
self._compile(v.get("steps", []), p + ".steps", ref)
ref["index"] = self._emit("leave", p, start=enter)
elif action == "TRY":
start = self._emit("try", p, policy=v)
self._compile(v.get("steps", []), p + ".steps", group_end)
done = self._emit("try_done", p, start=start)
self.steps[start]["fallback"] = len(self.steps) if "fallback" in v else None
self._compile(v.get("fallback", []), p + ".fallback", group_end)
end = self._emit("catch_done", p, start=start)
self.steps[start]["end"] = end
self.steps[done]["to"] = end + 1
elif action == "GUARD":
idx = self._emit("guard", p, condition=v["condition"], end=group_end)
if v.get("mode") == "goto": jumps.append((idx, v["anchor"]))
elif action == "LABEL":
labels[v["name"]] = self._emit("label", p)
else:
self._emit(action.lower(), p, spec=v, target=node.get("target", ""))
for idx, name in jumps:
self.steps[idx]["to"] = labels[name]
def _check(self, transition=True):
if self.stop_checker(): raise WorkflowCancelledError("workflow_cancelled")
if time.monotonic() > self.deadline: raise FlowLimitError("工作流运行时间超过控制流预算")
self.transitions += int(transition)
if self.transitions > self.max_transitions: raise FlowLimitError("工作流转换次数超过限制")
def _record(self, step, status, **meta):
# Deliberately exclude prompt, values, capture contents, selectors and error text.
if len(self.trace) < 500:
self.trace.append({"path": step.get("_path"), "action": step.get("_op", step.get("action")), "status": status, **meta})
def _seek(self, index):
self.variables.locals[:] = [s for s in self.variables.locals if s["start"] < index <= s["end"]]
while self.tries and not (self.tries[-1]["start"] < index <= self.tries[-1]["end"]):
frame = self.tries.pop()
self.variables.error = frame["previous_error"]
def next_leaf(self, index):
while index < len(self.steps):
self._check()
self._seek(index)
step = self.steps[index]
op = step.get("_op")
if not op:
return index
try:
next_index = index + 1
if op == "if":
result = self.variables.condition(step["condition"])
self._record(step, "branch", branch="then" if result else "else")
if not result: next_index = step["to"]
elif op == "switch":
next_index = step["default_to"]
branch = "default"
for case in step["cases"]:
self._check()
if self.variables.condition(case["condition"]):
next_index, branch = case["to"], case["branch"]
break
self._record(step, "branch", branch=branch)
elif op == "guard":
if self.variables.condition(step["condition"]):
next_index = step.get("to", (step["end"]["index"] if step.get("end") is not None else len(self.steps)))
self._record(step, "skipped")
else: self._record(step, "continued")
elif op == "jump": next_index = step["to"]
elif op == "merge": self._record(step, "merged")
elif op == "label": self._record(step, "label")
elif op == "enter":
values = self.variables.resolve(step["variables"])
self.variables.locals.append({"start": index, "end": step["end"]["index"], "values": values})
_size(self.variables.merged(), 262144)
self._record(step, "entered")
elif op == "leave":
if self.variables.locals and self.variables.locals[-1]["start"] == step["start"]:
self.variables.locals.pop()
self._record(step, "merged")
elif op == "set":
v = step["spec"]
if v.get("mode") != "default" or self.variables.lookup("vars." + v["name"], missing=True) is MISSING:
self.variables.set(v["name"], self.variables.resolve(v["value"]), v.get("scope", "local"), v.get("mode", "assign"))
self._record(step, "assigned", variable=v["name"])
elif op == "capture":
if self.capture is None: raise WorkflowError("缺少页面状态捕获适配器")
v = step["spec"]
spec = self.variables.resolve({k: val for k, val in v.items() if k not in {"name", "scope"}})
spec["name"] = v["name"] # Adapter metadata, never evaluated as page code.
result = self.capture(spec, str(self.variables.resolve(step["target"])))
self.variables.set(v["name"], result, v.get("scope", "local"))
self._record(step, "captured", variable=v["name"])
elif op == "try":
self.tries.append({"start": index, "end": step["end"], "fallback": step["fallback"], "policy": step["policy"],
"attempt": 1, "output": False, "effect": False, "catching": False, "previous_error": self.variables.error,
"snapshot": copy.deepcopy((self.variables.globals, self.variables.locals))})
self._record(step, "attempt", attempt=1)
elif op == "try_done":
next_index = step["to"]
elif op == "catch_done":
pass
index = next_index
except (FlowValidationError, FlowLimitError, WorkflowCancelledError):
raise
except Exception as exc:
recovered = self.recover(exc, index)
if recovered is None: raise
index = recovered
self._seek(index)
return index
def prepare_leaf(self, index, selectors):
self._check()
step = copy.deepcopy(self.steps[index])
step["target"] = str(self.variables.resolve(step.get("target", "")))
if step["action"] != "JS_EXEC":
step["value"] = self.variables.resolve(step.get("value"))
step["execution"] = self.variables.resolve(step.get("execution"))
raw = step.get("selector", selectors.get(step["target"], ""))
selector = self.variables.resolve(raw)
if selector is not None and not isinstance(selector, str): raise FlowVariableError("定位器必须解析为字符串")
return step, selector or ""
def leaf_context(self, step):
result = {**self.variables.context, "vars": self.variables.merged(), "inputs": self.variables.inputs, "error": self.variables.error}
if step["action"] == "FILL_INPUT" and step.get("value") is not None:
result["prompt"] = str(step["value"])
return result
def events(self, iterator, index):
step = self.steps[index]
self._record(step, "started")
safe = step.get("retry_safe") is True or step["action"] in {"WAIT", "READONLY_HINT"}
for frame in self.tries:
frame["effect"] |= not safe
error = None
try:
for chunk in iterator:
try:
payload = json.loads(str(chunk).removeprefix("data: ").strip())
except (ValueError, TypeError): payload = None
if isinstance(payload, dict) and payload.get("error"):
error = payload["error"]
if isinstance(error, dict) and str(error.get("code", "")).startswith("attachment"):
raise WorkflowError(error["code"])
self._check(transition=False)
continue # A recovered failure must never leak an error SSE to the client.
self._check(transition=False)
self.output_emitted = True
for frame in self.tries: frame["output"] = True
yield chunk
finally:
if hasattr(iterator, "close"):
iterator.close()
self._check(transition=False)
if error:
raise WorkflowError(str(error.get("message", "workflow_step_failed")) if isinstance(error, dict) else str(error))
self._record(step, "completed")
def recover(self, error, index):
self._record(self.steps[index], "failed", error_type=type(error).__name__)
if self.output_emitted:
return None
if isinstance(error, (FlowValidationError, FlowLimitError, WorkflowCancelledError)):
return None
message = str(error)
if message.startswith(("stream_terminal_error:", "attachment", "file_paste_length_error", "workflow_cancelled")) or message in {"new_chat_transition_timeout", "send_unconfirmed", "arena_send_no_target", "stream_recovery_exhausted", "arena_direct_unexpected_battle_redirect"}:
return None
self._check()
for frame in reversed(self.tries):
policy = frame["policy"]
allowed = policy.get("errors", ["*"])
if frame["catching"] or ("*" not in allowed and type(error).__name__ not in allowed): continue
if frame["output"]: return None
if frame["effect"] and not policy.get("retry_side_effects", False): return None
if frame["attempt"] < policy.get("attempts", 1) and (not frame["effect"] or policy.get("retry_side_effects", False)):
frame["attempt"] += 1
self.variables.globals, self.variables.locals = copy.deepcopy(frame["snapshot"])
self.tries[:] = self.tries[:self.tries.index(frame) + 1]
end = time.monotonic() + policy.get("delay", 0.3)
while time.monotonic() < end:
self._check()
time.sleep(min(0.05, max(0, end - time.monotonic())))
self._record(self.steps[frame["start"]], "retry", attempt=frame["attempt"])
return frame["start"] + 1
if frame["fallback"] is not None:
frame["catching"] = True
self.tries[:] = self.tries[:self.tries.index(frame) + 1]
self.variables.error = {"type": type(error).__name__, "attempt": frame["attempt"]}
self._record(self.steps[frame["start"]], "fallback")
return frame["fallback"]
return None
def capture_page_state(executor, spec, target, variables=None):
"""Read-only capture using ElementFinder, not interpolated JavaScript source."""
if executor._check_cancelled(): raise WorkflowCancelledError("workflow_cancelled")
source = spec.get("source", "text")
if source == "url": return str(getattr(executor.tab, "url", ""))[:65536]
selector = spec.get("selector") or executor._selectors.get(target, "")
if variables is not None:
selector = variables.resolve(selector)
if not selector: raise WorkflowError("CAPTURE 需要 target 或 selector")
element = executor.finder.find(selector, timeout=spec.get("timeout", 2))
if source == "exists": return bool(element)
if not element:
if "default" in spec: return spec["default"]
raise WorkflowError("CAPTURE 未找到页面元素")
if source == "text": result = element.text
elif source == "class": result = element.attr("class")
elif source == "attribute": result = element.attr(spec["attribute"])
elif source == "value": result = as_element(element).run_js("return this.value;")
else: raise FlowValidationError("不支持的捕获类型")
if result is None and "default" in spec: return spec["default"]
if isinstance(result, str) and len(result) > 65536: raise FlowLimitError("捕获结果超过 65536 字符")
return result