ohos-devloop 0.1.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (58) hide show
  1. ohos_devloop/__init__.py +2 -0
  2. ohos_devloop/_version.py +24 -0
  3. ohos_devloop/agents/skills/collab-delegate/SKILL.md +79 -0
  4. ohos_devloop/agents/skills/loop-iterate/SKILL.md +54 -0
  5. ohos_devloop/agents/skills/openharmony-ci/SKILL.md +71 -0
  6. ohos_devloop/agents/skills/openharmony-ci/agents/openai.yaml +4 -0
  7. ohos_devloop/agents/skills/openharmony-ci/scripts/openharmony_ci.py +520 -0
  8. ohos_devloop/agents/skills/pool-status/SKILL.md +47 -0
  9. ohos_devloop/config/e2e-cases.yaml +31 -0
  10. ohos_devloop/config/e2e-hap.yaml +54 -0
  11. ohos_devloop/config/inventory-template.yaml +35 -0
  12. ohos_devloop/config/inventory.yaml +68 -0
  13. ohos_devloop/config/report-templates/analysis-report.md +48 -0
  14. ohos_devloop/config/report-templates/impl-report.md +47 -0
  15. ohos_devloop/config/task-template.md +21 -0
  16. ohos_devloop/config/tdd-board.yaml +31 -0
  17. ohos_devloop/config/tdd-coverage.yaml +47 -0
  18. ohos_devloop/config/tdd-emulator.yaml +36 -0
  19. ohos_devloop/config/tdd-host.yaml +26 -0
  20. ohos_devloop/config/tdd-suites.yaml +34 -0
  21. ohos_devloop/config/templates/agents-user.md +11 -0
  22. ohos_devloop/config/templates/quickstart.md +82 -0
  23. ohos_devloop/config/verify.yaml +45 -0
  24. ohos_devloop/examples/anchor-e2e.yaml +55 -0
  25. ohos_devloop/examples/assert-smoke.yaml +33 -0
  26. ohos_devloop/examples/diffcov-fixture/cov.json +6688 -0
  27. ohos_devloop/examples/diffcov-fixture/diff.txt +24 -0
  28. ohos_devloop/examples/diffcov-smoke.yaml +32 -0
  29. ohos_devloop/examples/e2e-emu-smoke.yaml +45 -0
  30. ohos_devloop/examples/layout-fixture.norm.json +1 -0
  31. ohos_devloop/examples/smoke.yaml +27 -0
  32. ohos_devloop/ohos_cli.py +131 -0
  33. ohos_devloop/scripts/agent-run-v3.sh +149 -0
  34. ohos_devloop/scripts/apply.py +1448 -0
  35. ohos_devloop/scripts/check_env.py +284 -0
  36. ohos_devloop/scripts/collab.py +303 -0
  37. ohos_devloop/scripts/diffcov.py +211 -0
  38. ohos_devloop/scripts/flash.py +511 -0
  39. ohos_devloop/scripts/mount_ws.py +192 -0
  40. ohos_devloop/scripts/release.py +2645 -0
  41. ohos_devloop/scripts/release_audit.py +260 -0
  42. ohos_devloop/scripts/release_metadata.py +397 -0
  43. ohos_devloop/scripts/release_smoke.py +287 -0
  44. ohos_devloop/scripts/report_draft.py +234 -0
  45. ohos_devloop/scripts/server_init.py +310 -0
  46. ohos_devloop/scripts/sgrep.py +82 -0
  47. ohos_devloop/scripts/sign_hap.py +256 -0
  48. ohos_devloop/scripts/telemetry.py +260 -0
  49. ohos_devloop/scripts/ui_probe.py +396 -0
  50. ohos_devloop/scripts/verify_frame_diff.py +138 -0
  51. ohos_devloop/scripts/ws_init.py +131 -0
  52. ohos_devloop/scripts/wsroot.py +192 -0
  53. ohos_devloop-0.1.2.dist-info/METADATA +177 -0
  54. ohos_devloop-0.1.2.dist-info/RECORD +58 -0
  55. ohos_devloop-0.1.2.dist-info/WHEEL +5 -0
  56. ohos_devloop-0.1.2.dist-info/entry_points.txt +2 -0
  57. ohos_devloop-0.1.2.dist-info/licenses/LICENSE +202 -0
  58. ohos_devloop-0.1.2.dist-info/top_level.txt +1 -0
@@ -0,0 +1,1448 @@
1
+ #!/usr/bin/env python3
2
+ # -*- coding: utf-8 -*-
3
+ """
4
+ apply.py —— 薄调度器:job spec(verify.yaml)× 资源清单(inventory.yaml)→ 执行 → 结构化结果
5
+
6
+ 用法:
7
+ python scripts/apply.py config/verify.yaml plan # 离线解析,输出执行计划(不连任何机器)
8
+ python scripts/apply.py config/verify.yaml run # 执行(长任务后台跑 + 轮询 results.json)
9
+ python scripts/apply.py config/verify.yaml run --from-step push # 断点续跑(复用同一 run 目录)
10
+ python scripts/apply.py config/verify.yaml run --run-id <id> # 复用已有 run 目录续跑
11
+ python scripts/apply.py config/verify.yaml run --params artifacts=tasks/x/context/libs.txt reboot_after_push=false
12
+
13
+ 约定(详见 RUNBOOK「资源清单与调度器」):
14
+ - config/inventory.yaml 是唯一事实来源;扩容 = 加条目,不改代码
15
+ - 推库铁律固化在 push 步骤:基线预检 → 全量备份 → remount → 写入 → md5 校验 → chmod/sync
16
+ - hdc 退出码不可信:每步以产物/输出校验成败
17
+ - runs/<run-id>/results.json 每步落盘,可被外部(如 agent 后台任务)轮询
18
+ """
19
+
20
+ from __future__ import annotations
21
+
22
+ import argparse
23
+ import hashlib
24
+ import json
25
+ import os
26
+ import re
27
+ import shlex
28
+ import shutil
29
+ import subprocess
30
+ import sys
31
+ import time
32
+ from datetime import datetime
33
+ from pathlib import Path
34
+
35
+ import yaml
36
+
37
+ import ui_probe # UI 树证据层(同目录模块;assert node / capture layout / ui_click 的逻辑都在那边)
38
+ import diffcov # TDD 差分覆盖率(同目录模块;tdd_host coverage 模式与 diffcov 步骤的计算都在那边)
39
+ import telemetry # 遥测(M6):opt-in 匿名使用统计;emit 开关关时 no-op、永不抛异常
40
+ import wsroot # 工作区解析(M6:用户数据在工作区,包资产在正本仓;维护者形态两者同一)
41
+
42
+ # 版本单点(D-08):正本在 ohos_cli.version(metadata → git 兜底(仅裸跑)→ unknown)。
43
+ # 机制 (a):插入包根后裸 import,再取模块级别名——sys.path[0]=脚本目录的裸跑形态也可解析;
44
+ # 别名保持模块级名,供 mock.patch.object(apply, "tool_version") 替换。
45
+ sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
46
+ import ohos_cli # noqa: E402
47
+ tool_version = ohos_cli.version
48
+
49
+ REPO = wsroot.PKG # 工具正本仓(包资产:sign_hap/smoke fixture 等)
50
+
51
+
52
+ def runs_root() -> Path:
53
+ """run 档案根(归工作区)——调用点经 require_ws() 求值,绝不 import 期:
54
+ 安装态无工作区时在此抛 WorkspaceRequiredError 引导 init(坑位 2:模块级锚点会在
55
+ import 期 TypeError 或静默写 site-packages)。"""
56
+ return wsroot.require_ws() / "runs"
57
+
58
+
59
+ def _ver_tuple(v: str) -> tuple[int, ...] | None:
60
+ """'0.2.1' / 'v0.2-3-g<sha>-dirty' → (0,2,1)/(0,2);解析不出(纯 sha/unknown)→ None。"""
61
+ m = re.match(r"v?(\d+(?:\.\d+)*)", str(v).strip())
62
+ return tuple(int(x) for x in m.group(1).split(".")) if m else None
63
+
64
+
65
+ class ApplyError(Exception):
66
+ """可预期的失败:信息直接进 results.json 的 detail,不再向上抛栈。"""
67
+
68
+
69
+ def now() -> str:
70
+ return datetime.now().astimezone().isoformat(timespec="seconds")
71
+
72
+
73
+ def log(msg: str, run_dir: Path | None = None) -> None:
74
+ line = f"[{datetime.now().strftime('%H:%M:%S')}] {msg}"
75
+ print(line, flush=True)
76
+ if run_dir is not None:
77
+ with open(run_dir / "apply.log", "a", encoding="utf-8") as f:
78
+ f.write(line + "\n")
79
+
80
+
81
+ def sh(args: list[str], timeout: int | None = None, cwd: str | Path | None = None,
82
+ env: dict | None = None) -> tuple[int, str, str]:
83
+ """list 参数起子进程(不做 shell 字符串拼接,绕开 Git Bash 引号/路径转换问题)。"""
84
+ try:
85
+ p = subprocess.run(args, capture_output=True, text=True, encoding="utf-8",
86
+ errors="replace", timeout=timeout, cwd=cwd, env=env)
87
+ return p.returncode, p.stdout or "", p.stderr or ""
88
+ except subprocess.TimeoutExpired:
89
+ return 124, "", f"timeout after {timeout}s"
90
+ except FileNotFoundError as e:
91
+ return 127, "", str(e)
92
+
93
+
94
+ class Tmpl(dict):
95
+ def __missing__(self, k):
96
+ raise ApplyError(f"模板变量 {{{k}}} 未定义(可用键:{', '.join(sorted(self))})")
97
+
98
+
99
+ def fmt(s, ctx: dict):
100
+ return s.format_map(Tmpl(ctx)) if isinstance(s, str) else s
101
+
102
+
103
+ def posix(p) -> str:
104
+ return str(p).replace("\\", "/")
105
+
106
+
107
+ # --------------------------------------------------------------------------- 资源
108
+
109
+ class Server:
110
+ def __init__(self, name: str, cfg: dict):
111
+ self.name, self.cfg = name, cfg
112
+
113
+ @property
114
+ def target(self) -> str:
115
+ return f"{self.cfg['user']}@{self.cfg['host']}"
116
+
117
+ @property
118
+ def port(self) -> str:
119
+ return str(self.cfg.get("port", 22))
120
+
121
+ def ssh(self, cmd: str, timeout: int = 60, check: bool = True) -> str:
122
+ rc, out, err = sh(["ssh", "-o", "ConnectTimeout=15", "-p", self.port,
123
+ self.target, cmd], timeout=timeout)
124
+ if check and rc != 0:
125
+ raise ApplyError(f"ssh 失败(rc={rc}): {cmd[:160]}\n{err.strip()[:400]}")
126
+ return out
127
+
128
+ def scp_get(self, remote: str, local: Path) -> None:
129
+ local.parent.mkdir(parents=True, exist_ok=True)
130
+ rc, _, err = sh(["scp", "-P", self.port, "-o", "ConnectTimeout=15",
131
+ f"{self.target}:{remote}", str(local)])
132
+ if rc != 0 or not local.exists():
133
+ raise ApplyError(f"scp 拉取失败: {remote}\n{err.strip()[:400]}")
134
+
135
+
136
+ class Board:
137
+ def __init__(self, name: str, cfg: dict, local_cfg: dict):
138
+ self.name, self.cfg = name, cfg
139
+ self.hdc = local_cfg["hdc"]
140
+ self.target = (cfg.get("hdc_target") or "").strip()
141
+
142
+ def _argv(self, *args: str) -> list[str]:
143
+ base = [self.hdc]
144
+ if self.target:
145
+ base += ["-t", self.target]
146
+ return base + list(args)
147
+
148
+ def raw(self, *args: str, timeout: int = 30) -> tuple[int, str, str]:
149
+ return sh(self._argv(*args), timeout=timeout)
150
+
151
+ def targets(self) -> list[str]:
152
+ _, out, _ = self.raw("list", "targets")
153
+ return [l.strip() for l in out.splitlines()
154
+ if l.strip() and "ERROR" not in l and "[" not in l]
155
+
156
+ def shell(self, cmd: str, timeout: int = 30) -> str:
157
+ _, out, _ = self.raw("shell", cmd, timeout=timeout)
158
+ return out.strip()
159
+
160
+ def param(self, key: str) -> str:
161
+ return self.shell(f"param get {key}")
162
+
163
+ def md5(self, dev_path: str) -> str:
164
+ out = self.shell(f"md5sum {shlex.quote(dev_path)}")
165
+ m = re.match(r"([0-9a-fA-F]{32})", out)
166
+ if not m:
167
+ raise ApplyError(f"板上 md5sum 无法解析: {dev_path} → {out[:120]!r}")
168
+ return m.group(1).lower()
169
+
170
+ def recv(self, dev_path: str, local: Path) -> bool:
171
+ """拉文件到本机;返回板上文件是否存在(hdc 退出码不可信,以落盘为准)。"""
172
+ local.parent.mkdir(parents=True, exist_ok=True)
173
+ if local.exists():
174
+ local.unlink()
175
+ self.raw("file", "recv", dev_path, str(local))
176
+ ok = local.exists() and local.stat().st_size > 0
177
+ if ok:
178
+ return True
179
+ local.unlink(missing_ok=True)
180
+ return False
181
+
182
+ def send(self, local: Path, dev_path: str) -> None:
183
+ if not local.exists() or local.stat().st_size == 0:
184
+ raise ApplyError(f"待推送本地文件缺失或为空: {local}")
185
+ rc, out, err = self.raw("file", "send", str(local), dev_path)
186
+ if "fail" in (out + err).lower():
187
+ raise ApplyError(f"hdc file send 疑似失败(退出码不可信,按输出判定): {dev_path}\n{out[:200]}{err[:200]}")
188
+
189
+ def remount_rw(self) -> None:
190
+ self.shell(self.cfg.get("remount_cmd", "mount -o remount,rw /"))
191
+ probe = self.shell("touch /system/.apply_probe && rm /system/.apply_probe && echo __RW__")
192
+ if "__RW__" not in probe:
193
+ raise ApplyError("remount 后 /system 仍不可写(探测失败)")
194
+
195
+ def wait_boot(self, expect_version: str, total: int = 300) -> None:
196
+ deadline = time.time() + total
197
+ stage = 1
198
+ while time.time() < deadline:
199
+ try:
200
+ if self.shell("echo alive", timeout=15) == "alive":
201
+ break
202
+ except Exception:
203
+ pass
204
+ time.sleep(5)
205
+ else:
206
+ raise ApplyError(f"重启后 {total}s 内 shell 未就绪")
207
+ if not expect_version:
208
+ stage = 2
209
+ while time.time() < deadline and stage != 2:
210
+ try:
211
+ if expect_version in self.param("const.product.software.version"):
212
+ stage = 2
213
+ break
214
+ except Exception:
215
+ pass
216
+ time.sleep(5)
217
+ if stage != 2:
218
+ raise ApplyError("重启后系统版本参数未就绪(system 未起完)")
219
+ self.shell(f"date -s @{int(time.time())}") # 板上无 RTC,重启后校时
220
+
221
+
222
+ # --------------------------------------------------------------------------- job/inventory
223
+
224
+ def load_yaml(path: Path) -> dict:
225
+ with open(path, encoding="utf-8") as f:
226
+ return yaml.safe_load(f) or {}
227
+
228
+
229
+ def _unmsys(arg: str) -> str:
230
+ """还原 Git Bash 的 MSYS 路径转换:/srv/... 会被改成 <Git安装目录>/srv/...
231
+ (转换发生在 bash→python 参数边界,脚本内防不住,只能识别后还原;与 flash.py 同款)。"""
232
+ return re.sub(r"^[A-Za-z]:/[Pp]rogram [Ff]iles/Git(/.*)$", r"\1", arg)
233
+
234
+
235
+ def parse_params(pairs: list[str], base: dict) -> dict:
236
+ for kv in pairs or []:
237
+ if "=" not in kv:
238
+ raise ApplyError(f"--params 需要 k=v 形式: {kv}")
239
+ k, v = kv.split("=", 1)
240
+ v = _unmsys(v)
241
+ base[k] = yaml.safe_load(v)
242
+ return base
243
+
244
+
245
+ def resolve_artifacts(ctx: dict) -> list[str]:
246
+ """artifacts 参数:内联列表 / 清单文件 / detect-changed 产出的 artifacts.txt。"""
247
+ p = ctx["params"].get("artifacts") or []
248
+ items: list[str] = []
249
+ if isinstance(p, str):
250
+ f = Path(p)
251
+ if not f.is_absolute():
252
+ ws = wsroot.ws_root()
253
+ if ws is not None: # 安装态无工作区:保持相对路径(按 cwd 解析),跳过工作区分支
254
+ f = ws / f # 清单文件相对路径基于工作区(tasks/<tid>/context/ 等)
255
+ lines = f.read_text(encoding="utf-8").splitlines()
256
+ items = [l.strip() for l in lines if l.strip() and not l.strip().startswith("#")]
257
+ elif isinstance(p, list):
258
+ items = [str(x).strip() for x in p if str(x).strip()]
259
+ if not items:
260
+ f = ctx["run_dir"] / "artifacts.txt"
261
+ if f.exists():
262
+ items = [l.strip() for l in f.read_text(encoding="utf-8").splitlines()
263
+ if l.strip() and not l.strip().startswith("#")]
264
+ return items
265
+
266
+
267
+ def resolve_ohos_root(server: Server, spec: str, product: str = "") -> str:
268
+ if spec and spec != "latest":
269
+ server.ssh(f"test -d {shlex.quote(spec)}")
270
+ return spec
271
+ glob = server.cfg.get("ohos_root_glob")
272
+ if not glob:
273
+ raise ApplyError(f"inventory servers.{server.name} 未配置 ohos_root_glob")
274
+ out = ""
275
+ if product:
276
+ # 多快照并存防跨基线(2026-11-16 实况:x86_64_virt 快照字典序排最后,会劫持裸 latest)
277
+ out = server.ssh(
278
+ f'for d in $(ls -d {glob} 2>/dev/null | sort); do '
279
+ f'test -d "$d/out/{product}" && echo "$d"; done | tail -1').strip()
280
+ if not out:
281
+ out = server.ssh(f"ls -d {glob} 2>/dev/null | sort | tail -1").strip()
282
+ if not out:
283
+ why = f"(含 out/{product})" if product else ""
284
+ raise ApplyError(f"服务器无匹配大仓快照: {glob}{why}")
285
+ return out
286
+
287
+
288
+ # --------------------------------------------------------------------------- 步骤实现
289
+ # 每个处理器返回 (status, detail):status ∈ ok | skip | warn | fail
290
+
291
+ def step_build(ctx: dict, step: dict) -> tuple[str, dict]:
292
+ server, params = ctx["server"], ctx["params"]
293
+ ohos_root = resolve_ohos_root(server, params.get("ohos_root", "latest"),
294
+ (ctx.get("board_cfg") or {}).get("product", ""))
295
+ ctx["state"]["ohos_root"] = ohos_root
296
+ log(f"大仓快照: {ohos_root}", ctx["run_dir"])
297
+
298
+ rdir = server.cfg.get("run_dir", "/tmp/apply-runs")
299
+ run_id = ctx["run_id"]
300
+ marker, done = f"{rdir}/{run_id}.start", f"{rdir}/{run_id}.done"
301
+ slog = f"{rdir}/{run_id}.build.log"
302
+ ctx["state"]["build_marker"] = marker
303
+ server.ssh(f"mkdir -p {shlex.quote(rdir)} && touch {shlex.quote(marker)}")
304
+
305
+ product = ctx["board_cfg"]["product"]
306
+ cmd = fmt(params.get("build_command") or step["command"], {"product": product})
307
+ mode = step.get("mode", "detach")
308
+ tmo_min = int(step.get("timeout_min", 300))
309
+
310
+ if mode == "block":
311
+ log(f"构建(block,超时 {tmo_min}min): {cmd}", ctx["run_dir"])
312
+ rc, out, err = sh(["ssh", "-o", "ConnectTimeout=15", "-p", server.port,
313
+ server.target, f"cd {shlex.quote(ohos_root)} && {cmd}"],
314
+ timeout=tmo_min * 60)
315
+ (ctx["run_dir"] / "build.log").write_text(out + "\n" + err, encoding="utf-8")
316
+ if rc != 0:
317
+ return "fail", {"exit": rc, "log": "build.log",
318
+ "hint": "构建失败,读 build.log 尾部定位"}
319
+ return "ok", {"exit": 0, "log": "build.log"}
320
+
321
+ # detach:服务器 nohup,断 ssh 不死;本进程轮询完成标记
322
+ # 坑位(2026-11-10 实测):rm 必须放前台——若进后台复合(rm && nohup … &),
323
+ # 子 shell 抱着会话 fd 活到构建结束,ssh 客户端一直等到超时;后台只留单条
324
+ # nohup(0/1/2 全重定向)才能 exec 优化成干净进程,launch 秒回。
325
+ inner = (f"cd {shlex.quote(ohos_root)} && ({cmd}) >{shlex.quote(slog)} 2>&1; "
326
+ f"echo $? >{shlex.quote(done)}")
327
+ server.ssh(f"rm -f {shlex.quote(done)}; nohup bash -c {shlex.quote(inner)} "
328
+ f">/dev/null 2>&1 </dev/null & echo launched")
329
+ log(f"构建(detach)已提交,轮询完成标记(超时 {tmo_min}min)…", ctx["run_dir"])
330
+ deadline = time.time() + tmo_min * 60
331
+ while time.time() < deadline:
332
+ rc_out = server.ssh(f"cat {shlex.quote(done)} 2>/dev/null || true").strip()
333
+ if rc_out:
334
+ break
335
+ time.sleep(30)
336
+ else:
337
+ return "fail", {"hint": (f"超时 {tmo_min}min。服务器侧 nohup 仍在跑,不影响构建本身;"
338
+ f"回收方式: ssh 查看完成标记 {done}(0=成功)与日志 {slog}")}
339
+
340
+ brc = int(rc_out.strip() or "1")
341
+ tail = server.ssh(f"tail -n 200 {shlex.quote(slog)}")
342
+ (ctx["run_dir"] / "build.log").write_text(tail, encoding="utf-8")
343
+ if brc != 0:
344
+ return "fail", {"exit": brc, "log": "build.log", "hint": "构建失败,读 build.log 尾部定位"}
345
+ return "ok", {"exit": 0, "log": "build.log", "marker": marker}
346
+
347
+
348
+ def step_detect_changed(ctx: dict, step: dict) -> tuple[str, dict]:
349
+ server, state = ctx["server"], ctx["state"]
350
+ marker = state.get("build_marker")
351
+ if not marker:
352
+ return "skip", {"reason": "无 build 基准标记(未跑 build 或复用旧目录);可手工提供 artifacts 清单"}
353
+ ohos_root = state.get("ohos_root") or resolve_ohos_root(server, ctx["params"].get("ohos_root", "latest"))
354
+ state["ohos_root"] = ohos_root
355
+ layout = ctx["board_cfg"]["build_layout"]
356
+ pats = step.get("patterns", ["*.so"])
357
+ name_expr = " -o ".join(f"-name {shlex.quote(p)}" for p in pats)
358
+ cmd = (f"cd {shlex.quote(ohos_root)} && find {shlex.quote(layout)} \\( {name_expr} \\) "
359
+ f"-newer {shlex.quote(marker)} 2>/dev/null | "
360
+ f"sed -e 's|^{layout}/||' | sort")
361
+ out = server.ssh(cmd, timeout=120)
362
+ rels = [l.strip() for l in out.splitlines() if l.strip()]
363
+ (ctx["run_dir"] / "artifacts.txt").write_text("\n".join(rels) + "\n", encoding="utf-8")
364
+ state["artifacts"] = rels
365
+ if not rels:
366
+ return "ok", {"changed": 0, "note": "构建后无新增/更新产物(后续 fetch/push 将跳过)"}
367
+ return "ok", {"changed": len(rels), "list": "artifacts.txt"}
368
+
369
+
370
+ def step_fetch(ctx: dict, step: dict) -> tuple[str, dict]:
371
+ items = ctx["state"].get("artifacts") or resolve_artifacts(ctx)
372
+ if not items:
373
+ return "skip", {"reason": "无产物清单(params.artifacts 为空且无 artifacts.txt)"}
374
+ server, state = ctx["server"], ctx["state"]
375
+ ohos_root = state.get("ohos_root") or resolve_ohos_root(server, ctx["params"].get("ohos_root", "latest"))
376
+ state["ohos_root"] = ohos_root
377
+ layout = ctx["board_cfg"]["build_layout"]
378
+ fetched = []
379
+ for rel in items:
380
+ remote = f"{ohos_root}/{layout}/{rel}"
381
+ local = ctx["run_dir"] / "fetch" / rel
382
+ server.scp_get(remote, local)
383
+ size = local.stat().st_size
384
+ if size == 0:
385
+ raise ApplyError(f"取回的产物为空: {remote}")
386
+ fetched.append({"rel": rel, "size": size})
387
+ log(f" fetched {rel} ({size} bytes)", ctx["run_dir"])
388
+ return "ok", {"count": len(fetched), "dir": "fetch/"}
389
+
390
+
391
+ def step_push(ctx: dict, step: dict) -> tuple[str, dict]:
392
+ items = ctx["state"].get("artifacts") or resolve_artifacts(ctx)
393
+ if not items:
394
+ return "skip", {"reason": "无产物清单"}
395
+ board, params = ctx["board"], ctx["params"]
396
+ run_dir = ctx["run_dir"]
397
+ root = board.cfg.get("device_root", "/system")
398
+ expect = board.cfg.get("software_version", "")
399
+
400
+ # ---- 基线预检(禁止混基线,RUNBOOK 铁律)
401
+ ver = board.param("const.product.software.version")
402
+ if expect and expect not in ver:
403
+ raise ApplyError(f"基线不匹配: 板上 {ver!r} 不含期望 {expect!r} —— 禁止混基线推送")
404
+ tgts = board.targets()
405
+ if not tgts:
406
+ raise ApplyError("hdc 未发现设备(hdc list targets 为空)")
407
+
408
+ # ---- 第一步:全量备份(任何一项备份失败都不允许写入)
409
+ backup = run_dir / "backup"
410
+ persistent = Path(board.cfg.get("backup_dir", "")) / expect / datetime.now().strftime("%Y%m%d") if board.cfg.get("backup_dir") else None
411
+ backed, fresh = [], []
412
+ for rel in items:
413
+ dev = f"{root}/{rel}"
414
+ local = backup / rel
415
+ if board.recv(dev, local):
416
+ backed.append(rel)
417
+ if persistent:
418
+ dst = persistent / rel
419
+ dst.parent.mkdir(parents=True, exist_ok=True)
420
+ shutil.copy2(local, dst)
421
+ else:
422
+ fresh.append(rel) # 板上不存在 = 新文件,无需备份
423
+ if persistent:
424
+ log(f"长期备份目录: {persistent}", run_dir)
425
+
426
+ # ---- 写入:remount 一次 → 逐个 send + md5 校验 + chmod
427
+ board.remount_rw()
428
+ pushed = []
429
+ for rel in items:
430
+ dev = f"{root}/{rel}"
431
+ src = run_dir / "fetch" / rel
432
+ if not src.exists():
433
+ raise ApplyError(f"推送源缺失(先跑 fetch,或把文件放到 {posix(src)}): {rel}")
434
+ board.send(src, dev)
435
+ local_md5 = hashlib.md5(src.read_bytes()).hexdigest()
436
+ dev_md5 = board.md5(dev)
437
+ if local_md5 != dev_md5:
438
+ raise ApplyError(f"md5 不一致(hdc 退出码不可信的典型场景): {rel} "
439
+ f"local={local_md5} device={dev_md5}")
440
+ board.shell(f"chmod 644 {shlex.quote(dev)}")
441
+ pushed.append({"rel": rel, "md5": dev_md5})
442
+ log(f" pushed {rel} md5={dev_md5}", run_dir)
443
+ board.shell("sync")
444
+
445
+ detail = {"backed_up": len(backed), "new_files": fresh, "pushed": pushed,
446
+ "backup_dir": "backup/", "device_version": ver}
447
+
448
+ # ---- 重启验证 + 校时
449
+ if params.get("reboot_after_push"):
450
+ log("重启开发板验证系统健康…", run_dir)
451
+ board.shell("reboot")
452
+ board.wait_boot(expect)
453
+ detail["reboot"] = "ok+timesync"
454
+ return "ok", detail
455
+
456
+
457
+ def step_capture(ctx: dict, step: dict) -> tuple[str, dict]:
458
+ board = ctx["board"]
459
+ ev = ctx["run_dir"] / "evidence"
460
+ ev.mkdir(parents=True, exist_ok=True)
461
+ warnings: list[str] = []
462
+ got = 0
463
+
464
+ if step.get("hilog", True):
465
+ out = board.shell("hilog -x", timeout=60)
466
+ (ev / "hilog.txt").write_text(out + "\n", encoding="utf-8")
467
+ got += 1
468
+ marker = ctx["params"].get("marker")
469
+ if marker:
470
+ found = marker in out
471
+ warnings.append(f"marker {marker!r} 在 hilog 中: {'命中' if found else '未命中'}")
472
+
473
+ shots = int(step.get("shots", 1))
474
+ interval = int(step.get("shot_interval_s", 3))
475
+ for i in range(shots):
476
+ dev = f"/data/local/tmp/apply_{ctx['run_id']}_{i}.jpeg"
477
+ try:
478
+ if step.get("layout"): # 组件树标准形与截图成对(语义证据层,ROADMAP M4)
479
+ ui_probe.dump_layout(ev / f"layout_{i}.json", hdc=board._argv(), settle_s=0)
480
+ board.shell(f"snapshot_display -f {dev}", timeout=30)
481
+ local = ev / f"shot_{i}.jpeg"
482
+ if board.recv(dev, local):
483
+ got += 1
484
+ else:
485
+ warnings.append(f"截图 {i} 拉取失败(snapshot_display 退出码不可信)")
486
+ board.shell(f"rm -f {dev}")
487
+ except ApplyError as e:
488
+ warnings.append(f"截图 {i} 失败: {e}")
489
+ if i < shots - 1:
490
+ time.sleep(interval)
491
+
492
+ if got == 0:
493
+ return "fail", {"warnings": warnings, "hint": "未采集到任何证据"}
494
+ status = "warn" if warnings else "ok"
495
+ return status, {"evidence": got, "dir": "evidence/", "warnings": warnings}
496
+
497
+
498
+ def step_shell(ctx: dict, step: dict) -> tuple[str, dict]:
499
+ where = step.get("where", "local")
500
+ cmd = fmt(step["command"], ctx["tmpl_ctx"])
501
+ name = step.get("name", "shell")
502
+ tmo = int(step.get("timeout_min", 5)) * 60
503
+ if where == "server":
504
+ out = ctx["server"].ssh(cmd, timeout=tmo)
505
+ rc = 0
506
+ elif where == "board":
507
+ out = ctx["board"].shell(cmd, timeout=min(tmo, 120))
508
+ rc = 0
509
+ else:
510
+ rc, out, err = sh(["bash", "-c", cmd], timeout=tmo)
511
+ out = out + ("\n" + err if err.strip() else "")
512
+ (ctx["run_dir"] / "logs").mkdir(exist_ok=True)
513
+ (ctx["run_dir"] / "logs" / f"{name}.log").write_text(out, encoding="utf-8")
514
+ if rc != 0:
515
+ return "fail", {"exit": rc, "log": f"logs/{name}.log"}
516
+ return "ok", {"log": f"logs/{name}.log"}
517
+
518
+
519
+ # --------------------------------------------------------------------------- e2e 用例注册表
520
+
521
+ def load_e2e_case(ctx: dict, step: dict) -> dict:
522
+ """按名取 config/e2e-cases.yaml 用例;bundle/ability/hap 未显式给出时从工程文件自动派生。
523
+
524
+ 派生规则(与 sign_hap.py 的解析口径一致):
525
+ bundle ← AppScope/app.json5 的 bundleName
526
+ ability ← entry/src/main/module.json5 的 mainAbility,退化取首个 *Ability
527
+ hap ← entry/build/default/outputs/default/entry-default-signed.hap
528
+ """
529
+ name = step.get("case") or ctx["params"].get("case") or ""
530
+ reg = wsroot.load_registry("e2e-cases.yaml", "cases")
531
+ entry = reg.get(name)
532
+ if entry is None:
533
+ raise ApplyError(f"e2e-cases.yaml 无用例 {name!r}(可用: {', '.join(sorted(reg)) or '无'})")
534
+ project = Path(entry.get("project", ""))
535
+ if not project.is_absolute():
536
+ ws = wsroot.ws_root()
537
+ if ws is not None: # 安装态无工作区:保持相对路径,跳过工作区分支
538
+ project = ws / project # 测试应用工程归工作区
539
+ if not project.is_dir():
540
+ raise ApplyError(f"用例工程目录不存在: {posix(project)}")
541
+ info: dict = {"name": name, "project": project}
542
+
543
+ bundle = entry.get("bundle") or ""
544
+ if not bundle:
545
+ app_json = project / "AppScope" / "app.json5"
546
+ m = re.search(r'"bundleName"\s*:\s*"([^"]+)"',
547
+ app_json.read_text(encoding="utf-8")) if app_json.is_file() else None
548
+ bundle = m.group(1) if m else ""
549
+ if not bundle:
550
+ raise ApplyError(f"无法确定 bundleName({posix(project / 'AppScope' / 'app.json5')}),"
551
+ f"请在 e2e-cases.yaml 条目显式填 bundle")
552
+ info["bundle"] = bundle
553
+
554
+ ability = entry.get("ability") or ""
555
+ if not ability:
556
+ mod = project / "entry" / "src" / "main" / "module.json5"
557
+ if mod.is_file():
558
+ t = mod.read_text(encoding="utf-8")
559
+ m = re.search(r'"mainAbility"\s*:\s*"([^"]+)"', t) or \
560
+ re.search(r'"name"\s*:\s*"(\w*Ability)"', t)
561
+ ability = m.group(1) if m else ""
562
+ info["ability"] = ability
563
+ # hap 缺省名跟随 params.sign_mode(release=entry-release-signed.hap;显式 hap 字段最优先)
564
+ hap_default = ("entry-release-signed.hap" if ctx["params"].get("sign_mode") == "release"
565
+ else "entry-default-signed.hap")
566
+ info["hap"] = project / (entry.get("hap")
567
+ or f"entry/build/default/outputs/default/{hap_default}")
568
+ info["unsigned_hap"] = project / "entry/build/default/outputs/default/entry-default-unsigned.hap"
569
+ ctx["state"]["e2e_case"] = {k: (posix(v) if isinstance(v, Path) else v) for k, v in info.items()}
570
+ return info
571
+
572
+
573
+ # --------------------------------------------------------------------------- hap e2e 应用链
574
+
575
+ def step_hap_build(ctx: dict, step: dict) -> tuple[str, dict]:
576
+ case = load_e2e_case(ctx, step)
577
+ cli = shutil.which("devecocli")
578
+ if not cli:
579
+ raise ApplyError("devecocli 不在 PATH(npm install -g @deveco/deveco-cli,见 RUNBOOK「测试应用」节)")
580
+ lname = step.get("name", "hap_build")
581
+ rc, out, err = sh([cli, "build"], cwd=case["project"],
582
+ timeout=int(step.get("timeout_min", 10)) * 60)
583
+ (ctx["run_dir"] / "logs").mkdir(exist_ok=True)
584
+ (ctx["run_dir"] / "logs" / f"{lname}.log").write_text(
585
+ out + ("\n" + err if err.strip() else ""), encoding="utf-8")
586
+ unsigned = case["unsigned_hap"]
587
+ if rc != 0 or not unsigned.is_file():
588
+ return "fail", {"exit": rc, "log": f"logs/{lname}.log",
589
+ "hint": f"devecocli build 失败或缺 unsigned 产物 {posix(unsigned)}"}
590
+ return "ok", {"case": case["name"], "bundle": case["bundle"],
591
+ "unsigned_hap": posix(unsigned), "size": unsigned.stat().st_size,
592
+ "log": f"logs/{lname}.log"}
593
+
594
+
595
+ def step_hap_sign(ctx: dict, step: dict) -> tuple[str, dict]:
596
+ case = load_e2e_case(ctx, step)
597
+ board = ctx["board"]
598
+ # UDID 取自目标板:多设备并存(板+模拟器隧道)必须 -t 隔离;
599
+ # HDC env 传「hdc 前缀参数」整串,sign_hap.py 侧 shlex 切分回 list。
600
+ # params.sign_mode=release 时走发布链(无 UDID,HDC 不被使用,可离线)
601
+ mode = ctx["params"].get("sign_mode", "debug")
602
+ env = dict(os.environ)
603
+ env["HDC"] = " ".join(shlex.quote(p) for p in board._argv())
604
+ rc, out, err = sh([sys.executable, str(wsroot.PKG / "scripts" / "sign_hap.py"),
605
+ str(case["project"]), "--mode", mode],
606
+ timeout=int(step.get("timeout_min", 5)) * 60, env=env)
607
+ signed = case["hap"]
608
+ if rc != 0 or not signed.is_file() or signed.stat().st_size == 0:
609
+ return "fail", {"exit": rc, "output_tail": (out + err).strip()[-800:],
610
+ "hint": "签名失败(debug 须板在线取 UDID;release 须 hapsigner-dist 材料;"
611
+ "坑位见 RUNBOOK「签名」小节)"}
612
+ return "ok", {"case": case["name"], "bundle": case["bundle"], "sign_mode": mode,
613
+ "signed_hap": posix(signed), "size": signed.stat().st_size}
614
+
615
+
616
+ def step_hap_install(ctx: dict, step: dict) -> tuple[str, dict]:
617
+ case = load_e2e_case(ctx, step)
618
+ board = ctx["board"]
619
+ signed = case["hap"]
620
+ if not signed.is_file():
621
+ raise ApplyError(f"签名产物缺失: {posix(signed)}(先跑 hap_sign)")
622
+ bundle = case["bundle"]
623
+ # 板上无 RTC:时钟漂移会让 profile validity 判定失败(装 hap 报 grant request permissions failed)
624
+ board.shell(f"date -s @{int(time.time())}")
625
+ if step.get("uninstall", True):
626
+ # 脏代码缓存坑:install 前必 uninstall(未安装时卸载失败无害)
627
+ board.raw("shell", f"bm uninstall -n {bundle}")
628
+ time.sleep(2)
629
+ _, out, err = board.raw("install", str(signed), timeout=120)
630
+ # hdc 退出码不可信 → bm dump 产物校验
631
+ dump = board.shell(f"bm dump -n {bundle}", timeout=30)
632
+ (ctx["run_dir"] / "logs").mkdir(exist_ok=True)
633
+ (ctx["run_dir"] / "logs" / "bm_dump.txt").write_text(dump, encoding="utf-8")
634
+ if "applicationinfo" not in dump.lower(): # bm dump 实测键名 applicationInfo(2026-11-10 板上验证)
635
+ return "fail", {"install_out": (out + err)[:300], "bm_dump_head": dump[:300],
636
+ "hint": "bm dump 未见 applicationInfo(安装失败;先校时/重签/读 faultlog)"}
637
+ return "ok", {"case": case["name"], "bundle": bundle, "bm_dump": "logs/bm_dump.txt"}
638
+
639
+
640
+ def step_app_run(ctx: dict, step: dict) -> tuple[str, dict]:
641
+ case = load_e2e_case(ctx, step)
642
+ board = ctx["board"]
643
+ if not case["ability"]:
644
+ raise ApplyError("无法确定 ability(module.json5 解析失败),请在 e2e-cases.yaml 显式填 ability")
645
+ out = board.shell(f"aa start -a {case['ability']} -b {case['bundle']}", timeout=60)
646
+ time.sleep(int(step.get("settle_s", 6)))
647
+ # 进程存活为地面真值(aa start 输出不可靠);grep -v grep 防自匹配
648
+ ps = board.shell(f"ps -ef | grep {case['bundle']} | grep -v grep", timeout=30)
649
+ running = case["bundle"] in ps
650
+ detail = {"case": case["name"], "ability": case["ability"],
651
+ "aa_out": out.strip()[:200], "process": running}
652
+ if not running:
653
+ hint = {"hint": "应用进程未运行(先读 jscrash/faultlog:hdc shell ls /data/log/faultlog/faultlogger)"}
654
+ if step.get("require_process", True):
655
+ return "fail", {**detail, **hint}
656
+ return "warn", {**detail, **hint} # 显式放宽时只降级告警(断言仍可判 hilog)
657
+ return "ok", detail
658
+
659
+
660
+ # --------------------------------------------------------------------------- 判定(assert)
661
+
662
+ def _local_path(ctx: dict, raw: str) -> Path:
663
+ p = Path(fmt(raw, ctx["tmpl_ctx"]))
664
+ return p if p.is_absolute() else ctx["run_dir"] / p
665
+
666
+
667
+ def _default_layout(ctx: dict) -> Path:
668
+ """node 断言缺省标准形:ui_click 的 layout_last.json 优先,退 capture 的 layout_0.json。"""
669
+ ev = ctx["run_dir"] / "evidence"
670
+ for cand in ("layout_last.json", "layout_0.json"):
671
+ if (ev / cand).exists():
672
+ return ev / cand
673
+ return ev / "layout_last.json"
674
+
675
+
676
+ def step_assert(ctx: dict, step: dict) -> tuple[str, dict]:
677
+ """结构化断言:逐条判定 PASS/FAIL(全部通过才算 ok),结果进 results.json。
678
+
679
+ 断言种类:
680
+ hilog_marker {marker, expect: present|absent} hilog 证据里查标记(无证据文件则现场 dump)
681
+ text {path, pattern, expect: match|no_match} 本地/证据文件正则
682
+ file_exists {path, expect: present|absent}
683
+ frame_diff {shot_a, shot_b, max_diff_ratio, tolerance} evidence/ 两帧像素差
684
+ param {key, contains, expect: contains|not_contains} 板端 param get
685
+ params.marker 非空时自动兑现为一条 hilog_marker 断言(verify.yaml 的预留字段)。
686
+ """
687
+ board = ctx["board"]
688
+ assertions = [a for a in (step.get("assertions") or [])
689
+ if not (a.get("kind") == "hilog_marker" and not a.get("marker"))]
690
+ marker = ctx["params"].get("marker")
691
+ if marker and not any(a.get("kind") == "hilog_marker" for a in assertions):
692
+ assertions.insert(0, {"kind": "hilog_marker", "marker": marker})
693
+ if not assertions:
694
+ return "skip", {"reason": "无有效断言(step.assertions 与 params.marker 均空)"}
695
+
696
+ ev = ctx["run_dir"] / "evidence"
697
+ results = []
698
+ for a in assertions:
699
+ kind, rec = a.get("kind", "?"), {"kind": a.get("kind", "?")}
700
+ try:
701
+ if kind == "hilog_marker":
702
+ f = ev / "hilog.txt"
703
+ if not f.exists():
704
+ if board is None:
705
+ raise ApplyError("无 evidence/hilog.txt 且 job 未配 board,无法现场采集")
706
+ f.parent.mkdir(parents=True, exist_ok=True)
707
+ f.write_text(board.shell("hilog -x", timeout=60) + "\n", encoding="utf-8")
708
+ text = f.read_text(encoding="utf-8", errors="replace")
709
+ hit = a["marker"] in text
710
+ want = a.get("expect", "present") == "present"
711
+ rec.update({"marker": a["marker"], "expect": a.get("expect", "present"),
712
+ "hits": text.count(a["marker"]), "pass": hit == want})
713
+ elif kind == "text":
714
+ p = _local_path(ctx, a["path"])
715
+ text = p.read_text(encoding="utf-8", errors="replace")
716
+ n = len(re.findall(a["pattern"], text, re.M))
717
+ want = a.get("expect", "match") == "match"
718
+ rec.update({"path": posix(p), "pattern": a["pattern"],
719
+ "matches": n, "pass": (n > 0) == want})
720
+ elif kind == "file_exists":
721
+ p = _local_path(ctx, a["path"])
722
+ want = a.get("expect", "present") == "present"
723
+ rec.update({"path": posix(p), "pass": p.exists() == want})
724
+ elif kind == "frame_diff":
725
+ try:
726
+ from PIL import Image, ImageChops
727
+ except ImportError:
728
+ raise ApplyError("frame_diff 需要 Pillow(python -m pip install Pillow)")
729
+ pa = Image.open(ev / a.get("shot_a", "shot_0.jpeg")).convert("RGB")
730
+ pb = Image.open(ev / a.get("shot_b", "shot_1.jpeg")).convert("RGB")
731
+ if pa.size != pb.size:
732
+ raise ApplyError(f"两帧尺寸不一致: {pa.size} vs {pb.size}")
733
+ tol = int(a.get("tolerance", 8)) # 每像素灰度差容限(抗 JPEG 压缩噪声)
734
+ gray = ImageChops.difference(pa, pb).convert("L")
735
+ changed = sum(1 for v in gray.getdata() if v > tol)
736
+ total = pa.size[0] * pa.size[1]
737
+ ratio = changed / total if total else 1.0
738
+ thr = float(a.get("max_diff_ratio", 0.02))
739
+ rec.update({"shot_a": a.get("shot_a", "shot_0.jpeg"),
740
+ "shot_b": a.get("shot_b", "shot_1.jpeg"),
741
+ "diff_ratio": round(ratio, 6), "threshold": thr, "pass": ratio <= thr})
742
+ elif kind == "param":
743
+ if board is None:
744
+ raise ApplyError("param 断言需要 board 资源")
745
+ val = board.param(a["key"])
746
+ want = a.get("expect", "contains") == "contains"
747
+ rec.update({"key": a["key"], "value": val[:80],
748
+ "pass": (a.get("contains", "") in val) == want})
749
+ elif kind == "node":
750
+ # UI 树断言(ROADMAP M4):选择器选中节点 → fact 提取 → op/expect 判定。
751
+ # layout 缺省用 evidence/layout_last.json(ui_click 点击后自动产出);缺失且有板则现场 dump。
752
+ lp = _local_path(ctx, a["layout"]) if a.get("layout") else \
753
+ _default_layout(ctx)
754
+ if not lp.exists():
755
+ if board is None:
756
+ raise ApplyError(f"无标准形且无板卡(先跑 ui_click/dump 或显式给 layout): {posix(lp)}")
757
+ ui_probe.dump_layout(lp, hdc=board._argv(), settle_s=float(a.get("settle_s", 1)))
758
+ sel = a.get("selector") or {}
759
+ nodes = ui_probe.query_nodes(ui_probe.load(lp), sel)
760
+ fact = a.get("fact", "count")
761
+ val = ui_probe.extract_fact(nodes, fact, int(a.get("nth", 0)))
762
+ op = a.get("op") or ("re" if fact == "text" else "eq")
763
+ rec.update({"layout": posix(lp), "selector": sel, "fact": fact, "op": op,
764
+ "value": val, "expect": a.get("expect"), "matched": len(nodes),
765
+ "pass": ui_probe.compare(val, op, a.get("expect"))})
766
+ else:
767
+ raise ApplyError(f"未知断言类型 {kind!r}")
768
+ except (ApplyError, OSError, KeyError) as e:
769
+ rec.update({"pass": False, "error": str(e)})
770
+ rec.setdefault("pass", False)
771
+ results.append(rec)
772
+
773
+ passed = sum(1 for r in results if r["pass"])
774
+ detail = {"assertions": results, "passed": passed, "failed": len(results) - passed}
775
+ return ("ok" if passed == len(results) else "fail"), detail
776
+
777
+
778
+ # --------------------------------------------------------------------------- TDD 双通道
779
+
780
+ def _tdd_target_list(ctx: dict, step: dict) -> list[str]:
781
+ t = step.get("targets") or ctx["params"].get("tdd_targets") or []
782
+ if isinstance(t, str):
783
+ t = t.split()
784
+ if not t:
785
+ raise ApplyError("未声明 TDD target(step.targets 或 params.tdd_targets;"
786
+ "可用 tdd-suites.yaml 别名(如 ph-list),或 target 名查 test/<域>/BUILD.gn)")
787
+ return [str(x) for x in t]
788
+
789
+
790
+ def _expand_tdd_entries(ctx: dict, step: dict) -> list[dict]:
791
+ """targets → 逐条解析 [{target, gtest_filter, expected}]。
792
+
793
+ 别名(tdd-suites.yaml 键)展开为 target + filter + 钉数;裸 target 保持原样,
794
+ filter/钉数用 step/params 全局值。显式全局值优先于注册表。
795
+ """
796
+ reg = wsroot.load_registry("tdd-suites.yaml", "suites")
797
+ out = []
798
+ for e in _tdd_target_list(ctx, step):
799
+ r = reg.get(e)
800
+ if r:
801
+ out.append({"target": str(r["target"]),
802
+ "gtest_filter": str(r.get("gtest_filter") or ""),
803
+ "expected": int(r.get("expected_tests") or 0)})
804
+ else:
805
+ out.append({"target": e, "gtest_filter": "", "expected": 0})
806
+ # 全局 filter / 钉数覆盖注册表缺省(CLI 显式意图优先)
807
+ gf = (step.get("gtest_filter") or ctx["params"].get("gtest_filter") or "").strip()
808
+ exp = step.get("expected_tests") or ctx["params"].get("expected_tests") or {}
809
+ for e in out:
810
+ if gf:
811
+ e["gtest_filter"] = gf
812
+ if isinstance(exp, dict) and exp.get(e["target"]):
813
+ e["expected"] = int(exp[e["target"]])
814
+ elif isinstance(exp, int) and exp:
815
+ e["expected"] = exp
816
+ return out
817
+
818
+
819
+ def _gtest_filter_arg(f: str) -> str:
820
+ return f" --gtest_filter={shlex.quote(f)}" if f else ""
821
+
822
+
823
+ def _server_build_target(ctx: dict, product: str, target: str, log_name: str,
824
+ timeout_min: int, extra_args: str = "") -> str:
825
+ """服务器定向构建(detach 模式,与 build 步骤同款:断 ssh 不死)。返回构建起点 epoch(供 mtime 防假绿)。
826
+
827
+ extra_args:预构建好的 build.sh 附加参数(如 coverage 模式的 " --gn-args use_clang_coverage=true")。
828
+ """
829
+ server = ctx["server"]
830
+ ohos_root = ctx["state"].get("ohos_root") or \
831
+ resolve_ohos_root(server, ctx["params"].get("ohos_root", "latest"))
832
+ ctx["state"]["ohos_root"] = ohos_root
833
+ started = int(time.time())
834
+ rdir = server.cfg.get("run_dir", "/tmp/apply-runs")
835
+ slog, done = f"{rdir}/{ctx['run_id']}.{log_name}.log", f"{rdir}/{ctx['run_id']}.{log_name}.done"
836
+ cmd = f"./build.sh --product-name {product} --ccache --build-target {shlex.quote(target)}{extra_args}"
837
+ inner = (f"cd {shlex.quote(ohos_root)} && ({cmd}) >{shlex.quote(slog)} 2>&1; "
838
+ f"echo $? >{shlex.quote(done)}")
839
+ # 同 step_build 坑位:rm 前台、后台只留单条全重定向 nohup,launch 才能秒回
840
+ server.ssh(f"rm -f {shlex.quote(done)}; nohup bash -c {shlex.quote(inner)} "
841
+ f">/dev/null 2>&1 </dev/null & echo launched")
842
+ deadline = time.time() + timeout_min * 60
843
+ while time.time() < deadline:
844
+ if server.ssh(f"cat {shlex.quote(done)} 2>/dev/null || true", timeout=30).strip():
845
+ break
846
+ time.sleep(30)
847
+ else:
848
+ raise ApplyError(f"构建超时 {timeout_min}min(服务器侧 nohup 仍在跑,标记: {done})")
849
+ rc_out = server.ssh(f"cat {shlex.quote(done)}").strip()
850
+ if rc_out.strip() != "0":
851
+ tail = server.ssh(f"tail -n 100 {shlex.quote(slog)}")
852
+ (ctx["run_dir"] / "logs").mkdir(exist_ok=True)
853
+ (ctx["run_dir"] / "logs" / f"{log_name}.log").write_text(tail, encoding="utf-8")
854
+ raise ApplyError(f"target {target!r} 构建失败(日志 logs/{log_name}.log)")
855
+ return started
856
+
857
+
858
+ def _locate_binary(ctx: dict, out_rel: str, target: str, started: int) -> tuple[str, str]:
859
+ """在服务器 out 子树定位产物(返回 (绝对路径, 提示))。
860
+
861
+ mtime 只作遥测不作门槛:增量 no-op 构建(目标本就最新)产物 mtime 合法地早于本次构建,
862
+ 强判会误伤;防「构建未完成跑旧二进制出假绿」的真正保障是 detach 完成标记协议
863
+ (rm done → build → echo $? > done,rc=0 才走到这里)。
864
+ """
865
+ server = ctx["server"]
866
+ ohos_root = ctx["state"]["ohos_root"]
867
+ found = server.ssh(
868
+ f"cd {shlex.quote(ohos_root)} && find {shlex.quote(out_rel)} -type f -name {shlex.quote(target)} "
869
+ f"-not -name '*.unstripped' | head -1", timeout=120).strip()
870
+ if not found:
871
+ raise ApplyError(f"产物未找到: {out_rel}/**/{target}")
872
+ bin_path = found if found.startswith("/") else f"{ohos_root}/{found}"
873
+ mtime = int(server.ssh(f"stat -c %Y {shlex.quote(bin_path)}").strip() or "0")
874
+ note = "" if mtime >= started - 120 else \
875
+ f"产物 mtime 早于本次构建(增量 up-to-date 属正常;若怀疑陈旧产物,清 out 后重建)"
876
+ return bin_path, note
877
+
878
+
879
+ def _parse_gtest(out: str) -> tuple[int, int]:
880
+ """解析 gtest 汇总行 → (passed, failed)。"""
881
+ m = re.search(r"\[\s*PASSED\s*\]\s*(\d+)\s*tests?", out)
882
+ f = re.search(r"\[\s*FAILED\s*\]\s*(\d+)\s*tests?", out)
883
+ return (int(m.group(1)) if m else 0), (int(f.group(1)) if f else 0)
884
+
885
+
886
+ def _tdd_expected(ctx: dict, step: dict, target: str) -> int:
887
+ """期望用例数(别名展开后一般已在条目里;此处供裸 target 走 step/params 全局值)。"""
888
+ conf = step.get("expected_tests") or ctx["params"].get("expected_tests") or {}
889
+ return int((conf.get(target) if isinstance(conf, dict) else 0) or 0)
890
+
891
+
892
+ # ------------------------------------------------- TDD 差分覆盖率(tdd_host coverage 模式)
893
+ # 配方实测来源:diffcov-20261111 任务(合成 A/B 判别力验证),坑位细节见 RUNBOOK「TDD 差分覆盖率」节。
894
+
895
+ def _truthy(v) -> bool:
896
+ return str(v).strip().lower() in ("1", "true", "yes", "on")
897
+
898
+
899
+ def _sparam(ctx: dict, step: dict, key: str, default):
900
+ """step 级覆盖 params 级(空串/None 视为未设置),都缺则用 default。"""
901
+ for src in (step.get(key), (ctx["params"] or {}).get(key)):
902
+ if src is not None and str(src).strip() != "":
903
+ return src
904
+ return default
905
+
906
+
907
+ def _cov_setup(ctx: dict, step: dict) -> dict | None:
908
+ """coverage 模式预检:拉子仓 diff → 无源码改动降级普通构建 → 推导 obj 聚合目录。None=未启用。"""
909
+ if not _truthy(_sparam(ctx, step, "coverage", "")):
910
+ return None
911
+ server = ctx["server"]
912
+ ohos_root = ctx["state"].get("ohos_root") or \
913
+ resolve_ohos_root(server, ctx["params"].get("ohos_root", "latest"))
914
+ ctx["state"]["ohos_root"] = ohos_root
915
+ base = str(_sparam(ctx, step, "diff_base", "HEAD")).strip() or "HEAD"
916
+ repos = _sparam(ctx, step, "diff_repos", ["foundation/arkui/ace_engine"])
917
+ if isinstance(repos, str):
918
+ repos = [r for r in repos.replace(",", " ").split() if r]
919
+ pathspec = " ".join(shlex.quote(p) for p in ("*.cpp", "*.cc", "*.cxx", "*.c", "*.h", "*.hpp"))
920
+ diffs, changed = {}, {}
921
+ for repo in repos:
922
+ out = server.ssh(
923
+ f"cd {shlex.quote(ohos_root + '/' + repo)} && "
924
+ f"git diff --no-color -U0 {shlex.quote(base)} -- {pathspec}", check=False)
925
+ diffs[repo] = out
926
+ for f in diffcov.changed_source_files(out):
927
+ changed.setdefault(repo, {})[f] = None
928
+ if not changed:
929
+ log(f" coverage: diff_base={base} 无源码改动,本轮降级普通构建(不插桩)", ctx["run_dir"])
930
+ return {"inactive": "no-diff"}
931
+ # obj 聚合目录推导:源码目录在 obj 树下恰为「目录/<聚合库>/」一级(diffcov-20261111 实测规律)
932
+ obj_dirs = set()
933
+ for repo, files in changed.items():
934
+ for f in files:
935
+ d = f.rsplit("/", 1)[0] if "/" in f else "."
936
+ out = server.ssh(
937
+ f"cd {shlex.quote(ohos_root)} && "
938
+ f"ls -d out/host/host_product/obj/{repo}/{d}/*/ 2>/dev/null", check=False)
939
+ for l in out.splitlines():
940
+ if l.strip().endswith("/"):
941
+ obj_dirs.add(l.strip().rstrip("/"))
942
+ obj_dirs = sorted(obj_dirs)
943
+ if not obj_dirs:
944
+ log(" coverage: 改动文件未映射到 obj 目录(未编进 target?),覆盖走 no_cov_data 报告",
945
+ ctx["run_dir"])
946
+ try:
947
+ line_min = int(_sparam(ctx, step, "line_min", 100))
948
+ except ValueError:
949
+ raise ApplyError("line_min 必须是整数百分比")
950
+ return {"ohos_root": ohos_root, "base": base, "repos": repos, "diffs": diffs,
951
+ "changed": changed, "obj_dirs": obj_dirs, "line_min": line_min}
952
+
953
+
954
+ def _gcda_clean(ctx: dict, cfg: dict) -> None:
955
+ """删重编对象的旧 .gcda(坑:.gcno 结构变后运行时合并写回报 corrupt arc tag,diffcov-20261111 实测)。"""
956
+ server, ohos_root = ctx["server"], cfg["ohos_root"]
957
+ for d in cfg["obj_dirs"]:
958
+ server.ssh(f"cd {shlex.quote(ohos_root)} && rm -f {shlex.quote(d)}/*.gcda", check=False)
959
+
960
+
961
+ def _cov_collect(ctx: dict, cfg: dict, target: str, tdir: Path) -> dict:
962
+ """跑完套件后:gcovr 服务器侧转换(按 obj 目录收敛)→ 拉回本地 → diffcov 差分 → 证据落盘。"""
963
+ server, ohos_root = ctx["server"], cfg["ohos_root"]
964
+ if not server.ssh("gcovr --version 2>/dev/null | head -1", check=False).strip().startswith("gcovr"):
965
+ raise ApplyError("服务器缺 gcovr:pip3 install gcovr(实测 8.8;8.x 分支数据默认采集、无 -b 开关)")
966
+ if cfg["obj_dirs"]:
967
+ # gcovr 坑(实测):必须按改动目录收敛搜索路径(整 ace_engine 范围 4m42s / 单目录 0.8s);
968
+ # llvm-cov 记录的源码相对路径锚在构建目录 → --gcov-allowed-working-directory-root 放行
969
+ rdir = server.cfg.get("run_dir", "/tmp/apply-runs")
970
+ remote_json = f"{rdir}/{ctx['run_id']}.cov-{target}.json"
971
+ llvm = f"{ohos_root}/prebuilts/clang/ohos/linux-x86_64/llvm/bin/llvm-cov"
972
+ cmd = (f"cd {shlex.quote(ohos_root)} && gcovr -r . "
973
+ + " ".join(shlex.quote(d) for d in cfg["obj_dirs"])
974
+ + f" --gcov-executable {shlex.quote(llvm + ' gcov')}"
975
+ + f" --gcov-allowed-working-directory-root {shlex.quote(ohos_root)}"
976
+ + f" -j 4 --json -o {shlex.quote(remote_json)}")
977
+ out = server.ssh(cmd, timeout=420, check=False)
978
+ if server.ssh(f"test -s {shlex.quote(remote_json)} && echo OK", check=False).strip() != "OK":
979
+ raise ApplyError(f"gcovr 未产出覆盖 JSON(输出尾部: {out.strip()[-300:] or '(空)'})")
980
+ local_json = tdir / f"{target}.cov.json"
981
+ server.scp_get(remote_json, local_json)
982
+ cov_json_path = str(local_json)
983
+ else:
984
+ # 无 obj 映射:改动文件没编进 target,覆盖数据必然为空 → 直接 no_cov_data 报告
985
+ local_json = tdir / f"{target}.cov.json"
986
+ local_json.write_text('{"files": []}', encoding="utf-8")
987
+ cov_json_path = str(local_json)
988
+ diff_text = "\n".join(cfg["diffs"].values())
989
+ (tdir / f"{target}.diff.txt").write_text(diff_text, encoding="utf-8")
990
+ try:
991
+ res = diffcov.compute(diff_text, cov_json_path, cfg["repos"], cfg["line_min"])
992
+ except (ValueError, json.JSONDecodeError) as exc:
993
+ raise ApplyError(f"diffcov 计算失败(cov JSON 或 diff 文本异常): {exc}")
994
+ (tdir / f"{target}.diffcov.md").write_text(diffcov.render_md(res), encoding="utf-8")
995
+ (tdir / f"{target}.diffcov.json").write_text(
996
+ json.dumps(res, ensure_ascii=False, indent=2), encoding="utf-8")
997
+ s = res["summary"]
998
+ log(f" diffcov {target}: 行覆盖 {s['covered']}/{s['executable']}"
999
+ + (f" = {s['line_pct']}%" if s["line_pct"] is not None else "")
1000
+ + f",未覆盖 {s['uncovered']},阈值 {cfg['line_min']}% → {'PASS' if res['ok'] else 'FAIL'}",
1001
+ ctx["run_dir"])
1002
+ return res
1003
+
1004
+
1005
+ def step_tdd_host(ctx: dict, step: dict) -> tuple[str, dict]:
1006
+ """小循环:服务器 host_product 构建 + 直跑 TDD 套件,红绿判定(快反馈;宿主绿不豁免板端门)。
1007
+
1008
+ coverage 模式(RUNBOOK「TDD 差分覆盖率」):构建加 --gn-args use_clang_coverage=true 插桩
1009
+ → 跑套件(.gcda 随对象树落盘)→ gcovr 转换 → diffcov 差分(新增行 × 覆盖)→
1010
+ 行级阈值判据并入本步 ok;红绿灯与覆盖判据独立记录、并集生效(套件已知挂例不拦覆盖报告)。
1011
+ """
1012
+ server = ctx["server"]
1013
+ entries = _expand_tdd_entries(ctx, step)
1014
+ tdir = ctx["run_dir"] / "tdd_host"
1015
+ tdir.mkdir(parents=True, exist_ok=True)
1016
+ cov_cfg = _cov_setup(ctx, step)
1017
+ cov_on = bool(cov_cfg and not cov_cfg.get("inactive"))
1018
+ per, all_ok = [], True
1019
+ for e in entries:
1020
+ t, filt = e["target"], e["gtest_filter"]
1021
+ started = _server_build_target(
1022
+ ctx, "host_product", t, f"tddhost-{t}", int(step.get("build_timeout_min", 30)),
1023
+ extra_args=(" --gn-args use_clang_coverage=true" if cov_on else ""))
1024
+ if cov_on:
1025
+ _gcda_clean(ctx, cov_cfg)
1026
+ bin_path, mt_note = _locate_binary(ctx, "out/host/host_product/tests", t, started)
1027
+ ohos_root = ctx["state"]["ohos_root"]
1028
+ libdir = f"{ohos_root}/out/host/host_product/thirdparty/bounds_checking_function"
1029
+ rdir = server.cfg.get("run_dir", "/tmp/apply-runs")
1030
+ xml = f"{rdir}/{ctx['run_id']}.tddhost-{t}.xml"
1031
+ run_cmd = (f"cd {shlex.quote(bin_path.rsplit('/', 1)[0])} && "
1032
+ f"LD_LIBRARY_PATH={shlex.quote(libdir)} ./{t}{_gtest_filter_arg(filt)} "
1033
+ f"--gtest_output=xml:{shlex.quote(xml)} 2>&1 | tail -60")
1034
+ out = server.ssh(run_cmd, timeout=int(step.get("run_timeout_min", 15)) * 60, check=False)
1035
+ (tdir / f"{t}.log").write_text(out, encoding="utf-8")
1036
+ passed, failed = _parse_gtest(out)
1037
+ ok = passed > 0 and failed == 0
1038
+ expected = e["expected"] or _tdd_expected(ctx, step, t)
1039
+ if expected and passed != expected:
1040
+ ok = False # 钉死本轮应跑用例数,防子集跑绿
1041
+ entry = {"target": t, "filter": filt or None, "passed": passed, "failed": failed,
1042
+ "expected": expected or None, "ok": ok,
1043
+ **({"mtime": mt_note} if mt_note else {}), "log": f"tdd_host/{t}.log"}
1044
+ if cov_on:
1045
+ dc = _cov_collect(ctx, cov_cfg, t, tdir)
1046
+ entry["diffcov"] = dc["summary"]
1047
+ entry["diffcov_ok"] = dc["ok"]
1048
+ entry["diffcov_md"] = f"tdd_host/{t}.diffcov.md"
1049
+ ok = ok and dc["ok"] # 覆盖判据与红绿灯并集:套件挂照报覆盖,覆盖挂照出红绿灯
1050
+ entry["ok"] = ok
1051
+ per.append(entry)
1052
+ log(f" host {t}: PASSED={passed} FAILED={failed}"
1053
+ + (f" (期望 {expected})" if expected else ""), ctx["run_dir"])
1054
+ all_ok &= ok
1055
+ detail = {"targets": per, "dir": "tdd_host/"}
1056
+ if cov_cfg and cov_cfg.get("inactive"):
1057
+ detail["coverage"] = f"skipped: {cov_cfg['inactive']}"
1058
+ elif cov_on:
1059
+ detail["coverage"] = "on"
1060
+ return ("ok" if all_ok else "fail"), detail
1061
+
1062
+
1063
+ def step_tdd_board(ctx: dict, step: dict) -> tuple[str, dict]:
1064
+ """大循环 TDD 门(铁律 8 机制化):rk3568 设备版构建 → stripped 产物 md5 校验推板 → 直跑全过判定。"""
1065
+ server, board = ctx["server"], ctx["board"]
1066
+ entries = _expand_tdd_entries(ctx, step)
1067
+ product = ctx["board_cfg"]["product"]
1068
+ # ohos_root 按板 product 过滤解析(多快照防跨基线),state 供 _server_build_target 复用
1069
+ ctx["state"]["ohos_root"] = resolve_ohos_root(
1070
+ server, ctx["params"].get("ohos_root", "latest"), product)
1071
+ tdir = ctx["run_dir"] / "tdd_board"
1072
+ tdir.mkdir(parents=True, exist_ok=True)
1073
+ per, all_ok = [], True
1074
+ for e in entries:
1075
+ t, filt = e["target"], e["gtest_filter"]
1076
+ started = _server_build_target(ctx, product, t, f"tddboard-{t}",
1077
+ int(step.get("build_timeout_min", 40)))
1078
+ bin_path, mt_note = _locate_binary(ctx, f"out/{product}/tests", t, started)
1079
+ local = tdir / t
1080
+ server.scp_get(bin_path, local)
1081
+ if local.stat().st_size == 0:
1082
+ raise ApplyError(f"取回的 TDD 产物为空: {t}")
1083
+ dev = f"/data/local/tmp/{t}"
1084
+ board.send(local, dev)
1085
+ local_md5 = hashlib.md5(local.read_bytes()).hexdigest()
1086
+ if local_md5 != board.md5(dev):
1087
+ raise ApplyError(f"TDD 产物 md5 不一致: {t}")
1088
+ board.shell(f"chmod +x {shlex.quote(dev)}")
1089
+ lib_path = board.cfg.get(
1090
+ "tdd_lib_path", "/system/lib/platformsdk:/system/lib:/lib:/usr/lib") # x86_64 板填 lib64 布局
1091
+ out = board.shell(
1092
+ f"export LD_LIBRARY_PATH={lib_path}; "
1093
+ f"cd /data/local/tmp && ./{t}{_gtest_filter_arg(filt)} "
1094
+ f"--gtest_output=xml:/data/local/tmp/{t}.xml 2>&1 | tail -60",
1095
+ timeout=int(step.get("run_timeout_min", 15)) * 60)
1096
+ (tdir / f"{t}.log").write_text(out, encoding="utf-8")
1097
+ board.recv(f"/data/local/tmp/{t}.xml", tdir / f"{t}.xml")
1098
+ passed, failed = _parse_gtest(out)
1099
+ ok = passed > 0 and failed == 0
1100
+ expected = e["expected"] or _tdd_expected(ctx, step, t)
1101
+ if expected and passed != expected:
1102
+ ok = False
1103
+ per.append({"target": t, "filter": filt or None, "passed": passed, "failed": failed,
1104
+ "md5": local_md5, "expected": expected or None, "ok": ok,
1105
+ **({"mtime": mt_note} if mt_note else {}), "log": f"tdd_board/{t}.log"})
1106
+ log(f" board {t}: PASSED={passed} FAILED={failed}"
1107
+ + (f" (期望 {expected})" if expected else ""), ctx["run_dir"])
1108
+ all_ok &= ok
1109
+ return ("ok" if all_ok else "fail"), {"targets": per, "dir": "tdd_board/"}
1110
+
1111
+
1112
+ def step_diffcov(ctx: dict, step: dict) -> tuple[str, dict]:
1113
+ """本地差分覆盖判定(纯本地,不连机器):gcovr JSON + git diff 文本 → 清单 + 行级阈值判据。
1114
+
1115
+ smoke 自测(examples/diffcov-smoke.yaml)与已有产物事后重析用;
1116
+ 服务器侧全链(插桩构建→跑套件→gcovr→差分)在 tdd_host 的 coverage 模式。
1117
+ """
1118
+ def _p(raw) -> Path:
1119
+ p = Path(fmt(raw, ctx["tmpl_ctx"]))
1120
+ if p.is_absolute():
1121
+ return p
1122
+ cand = ctx["run_dir"] / p
1123
+ if cand.exists():
1124
+ return cand
1125
+ ws = wsroot.ws_root()
1126
+ if ws is not None: # 先工作区再包(fixture 类在包 examples/);安装态无工作区直取包回落
1127
+ ws_p = ws / p
1128
+ if ws_p.exists():
1129
+ return ws_p
1130
+ return wsroot.PKG / p
1131
+
1132
+ cov_path = _p(_sparam(ctx, step, "cov_json", "examples/diffcov-fixture/cov.json"))
1133
+ diff_path = _p(_sparam(ctx, step, "diff_file", "examples/diffcov-fixture/diff.txt"))
1134
+ if not cov_path.exists() or not diff_path.exists():
1135
+ raise ApplyError(f"diffcov 输入缺失: cov_json={cov_path} diff_file={diff_path}")
1136
+ anchors = _sparam(ctx, step, "anchors", ["foundation/arkui/ace_engine"])
1137
+ if isinstance(anchors, str):
1138
+ anchors = [a for a in anchors.replace(",", " ").split() if a]
1139
+ line_min = int(_sparam(ctx, step, "line_min", 100))
1140
+ try:
1141
+ res = diffcov.compute(diff_path.read_text(encoding="utf-8", errors="replace"),
1142
+ str(cov_path), anchors, line_min)
1143
+ except (ValueError, json.JSONDecodeError) as exc:
1144
+ raise ApplyError(f"diffcov 计算失败(cov JSON 或 diff 文本异常): {exc}")
1145
+ out_dir = ctx["run_dir"] / "diffcov"
1146
+ out_dir.mkdir(parents=True, exist_ok=True)
1147
+ (out_dir / "diffcov-list.md").write_text(diffcov.render_md(res), encoding="utf-8")
1148
+ (out_dir / "diffcov-list.json").write_text(
1149
+ json.dumps(res, ensure_ascii=False, indent=2), encoding="utf-8")
1150
+ s = res["summary"]
1151
+ log(f" diffcov: 行覆盖 {s['covered']}/{s['executable']}"
1152
+ + (f" = {s['line_pct']}%" if s["line_pct"] is not None else "")
1153
+ + f",未覆盖 {s['uncovered']},阈值 {line_min}% → {'PASS' if res['ok'] else 'FAIL'}",
1154
+ ctx["run_dir"])
1155
+ return ("ok" if res["ok"] else "fail"), {"summary": s,
1156
+ "md": "diffcov/diffcov-list.md",
1157
+ "json": "diffcov/diffcov-list.json"}
1158
+
1159
+
1160
+ # --------------------------------------------------------------------------- 板端预检
1161
+
1162
+ def step_ui_click(ctx: dict, step: dict) -> tuple[str, dict]:
1163
+ """UI 交互步骤(ROADMAP M4):dump→选择器定位→uinput 点击→点击后 dump 落 layout_last.json。
1164
+
1165
+ selector 同 assert node 断言(type/text_re/region/min_h,rollup 默认开——GridItem 按
1166
+ 后代 Text 定位);dump_after 产出的标准形供后续 node 断言缺省消费。
1167
+ """
1168
+ board = ctx["board"]
1169
+ ev = ctx["run_dir"] / "evidence"
1170
+ ev.mkdir(parents=True, exist_ok=True)
1171
+ sel = step.get("selector") or {}
1172
+ if step.get("dump_before"):
1173
+ ui_probe.dump_layout(ev / "layout_before.json", hdc=board._argv(), settle_s=0.3)
1174
+ r = ui_probe.resolve_and_click(sel, hdc=board._argv(),
1175
+ settle_s=float(step.get("settle_s", 1.5)))
1176
+ if not r["ok"]:
1177
+ return "fail", {"selector": sel, "x": r.get("x"), "y": r.get("y"),
1178
+ "hint": "选择器无匹配或 uinput 失败(用 ui_probe query 排查树内容)"}
1179
+ detail = {"selector": sel, "clicked_text": ui_probe.node_text(r["node"]),
1180
+ "x": r["x"], "y": r["y"]}
1181
+ if step.get("dump_after", True):
1182
+ ui_probe.dump_layout(ev / "layout_last.json", hdc=board._argv(), settle_s=0.3)
1183
+ detail["after_layout"] = "evidence/layout_last.json"
1184
+ return "ok", detail
1185
+
1186
+
1187
+ def step_preflight(ctx: dict, step: dict) -> tuple[str, dict]:
1188
+ """e2e 前置一步固化散坑:设备在线 + 基线版本 + 校时 + 熄屏调 24h + 存量 faultlog 盘点。"""
1189
+ board = ctx["board"]
1190
+ tgts = board.targets()
1191
+ if not tgts:
1192
+ raise ApplyError("hdc 未发现设备(hdc list targets 为空)")
1193
+ ver = board.param("const.product.software.version")
1194
+ expect = ctx["board_cfg"].get("software_version", "")
1195
+ if expect and expect not in ver:
1196
+ raise ApplyError(f"基线不匹配: 板上 {ver!r} 不含期望 {expect!r}(禁止混基线推送)")
1197
+ board.shell(f"date -s @{int(time.time())}") # 板上无 RTC:重启后必校时
1198
+ board.shell("power-shell timeout -o 86400000") # 熄屏 30s 打断长取证:调 24h(重启后失效)
1199
+ faults = board.shell("ls /data/log/faultlog/faultlogger 2>/dev/null | tail -5", timeout=20)
1200
+ detail = {"device": tgts[:2], "version": ver, "timesync": "done",
1201
+ "screen_timeout": "24h", "pre_faults": faults.strip()[:300]}
1202
+ return ("warn" if faults.strip() else "ok"), detail
1203
+
1204
+
1205
+ STEPS = {
1206
+ "build": step_build,
1207
+ "detect_changed": step_detect_changed,
1208
+ "fetch": step_fetch,
1209
+ "push": step_push,
1210
+ "capture": step_capture,
1211
+ "shell": step_shell,
1212
+ # —— 2026-11-10 ROADMAP M1/M2 新增(见 ROADMAP.md 与 RUNBOOK 对应节)——
1213
+ "assert": step_assert, # 结构化判定:证据 → PASS/FAIL 进 results.json
1214
+ "board_preflight": step_preflight, # 校时/基线预检/熄屏/存量 faultlog
1215
+ "hap_build": step_hap_build, # devecocli build(e2e-cases.yaml 用例)
1216
+ "hap_sign": step_hap_sign, # sign_hap.py 离线签名(板在线取 UDID)
1217
+ "hap_install": step_hap_install, # 校时 + uninstall→install + bm dump 校验
1218
+ "app_run": step_app_run, # aa start + 进程存活校验
1219
+ "tdd_host": step_tdd_host, # 小循环:host_product 跑 TDD(快反馈;coverage=差分覆盖模式)
1220
+ "tdd_board": step_tdd_board, # 铁律 8:设备版 TDD 推板直跑全过判定
1221
+ "diffcov": step_diffcov, # 本地差分覆盖判定(纯本地 smoke/重析;服务器全链在 tdd_host coverage)
1222
+ "ui_click": step_ui_click, # UI 交互:选择器点击 + 前后组件树 dump(M4 证据层)
1223
+ }
1224
+
1225
+
1226
+ # --------------------------------------------------------------------------- plan / run
1227
+
1228
+ def check_job(inv: dict, job: dict) -> None:
1229
+ res = job.get("resources") or {}
1230
+ for kind, key in (("servers", res.get("server")), ("boards", res.get("board"))):
1231
+ if key and key not in inv.get(kind, {}):
1232
+ raise ApplyError(f"inventory.{kind} 中不存在条目 {key!r}")
1233
+ for s in job.get("steps", []):
1234
+ if s.get("type") not in STEPS:
1235
+ raise ApplyError(f"未知步骤类型 {s.get('type')!r}(步骤 {s.get('name')})")
1236
+ # min_tool_version(M6 版本契约,等价 package.json engines):spec 可声明最低工具版本,
1237
+ # plan/run 均在解析期硬拒绝;版本不可解析(纯 sha checkout)时 WARN 放行——不打断维护者开发流
1238
+ mtv = job.get("min_tool_version")
1239
+ if mtv:
1240
+ cur, need = _ver_tuple(tool_version()), _ver_tuple(mtv)
1241
+ if cur is None:
1242
+ print(f"WARN: 工具版本 {tool_version()!r} 不可解析,无法对账 min_tool_version={mtv!r}")
1243
+ elif need is None:
1244
+ raise ApplyError(f"spec min_tool_version={mtv!r} 不是可解析的版本号")
1245
+ elif cur < need:
1246
+ raise ApplyError(f"工具版本过低: {tool_version()} < min_tool_version={mtv}"
1247
+ "(普通源码升级: git pull;入口/元数据/依赖变化时按 QUICKSTART 重装)")
1248
+
1249
+
1250
+ def preview_plan(ctx: dict) -> list[dict]:
1251
+ rows = []
1252
+ for s in ctx["job"].get("steps", []):
1253
+ row = {"name": s.get("name"), "type": s.get("type")}
1254
+ if s.get("type") in ("fetch", "push"):
1255
+ n = len(resolve_artifacts(ctx))
1256
+ row["note"] = f"{n} 个产物" + ("(跳过)" if n == 0 else "")
1257
+ elif s.get("type") == "build":
1258
+ row["note"] = (ctx["params"].get("build_command") or s.get("command", "")) + \
1259
+ f" [{s.get('mode', 'detach')}, ≤{s.get('timeout_min', 300)}min]"
1260
+ elif s.get("type") == "capture":
1261
+ row["note"] = f"{s.get('shots', 1)} 截图 + hilog → evidence/"
1262
+ elif s.get("type") == "assert":
1263
+ n = len(s.get("assertions") or []) + (1 if ctx["params"].get("marker") else 0)
1264
+ row["note"] = f"{n} 条断言 → PASS/FAIL"
1265
+ elif s.get("type") in ("hap_build", "hap_sign", "hap_install", "app_run"):
1266
+ case = s.get("case") or ctx["params"].get("case") or "?"
1267
+ row["note"] = f"用例 {case}(e2e-cases.yaml)"
1268
+ elif s.get("type") in ("tdd_host", "tdd_board"):
1269
+ t = s.get("targets") or ctx["params"].get("tdd_targets") or []
1270
+ t = t.split() if isinstance(t, str) else t
1271
+ row["note"] = f"targets: {' '.join(t) or '(params.tdd_targets)'}"
1272
+ elif s.get("type") == "board_preflight":
1273
+ row["note"] = "校时 + 基线预检 + 熄屏 24h + 存量 faultlog"
1274
+ elif s.get("type") == "ui_click":
1275
+ sel = s.get("selector") or {}
1276
+ row["note"] = f"点击 {sel.get('text_re') or sel.get('type')} + 前后树 dump"
1277
+ rows.append(row)
1278
+ return rows
1279
+
1280
+
1281
+ def write_results(ctx: dict) -> None:
1282
+ payload = dict(ctx["results"])
1283
+ payload["state"] = ctx["state"] # 跨进程持久化:--run-id 复用目录时恢复(如 build 基准标记)
1284
+ with open(ctx["run_dir"] / "results.json", "w", encoding="utf-8") as f:
1285
+ json.dump(payload, f, ensure_ascii=False, indent=2)
1286
+
1287
+
1288
+ def new_ctx(inv: dict, job: dict, params: dict, run_id: str, run_dir: Path) -> dict:
1289
+ res = dict(job.get("resources") or {})
1290
+ if params.get("board") and params["board"] != res.get("board"):
1291
+ # --params board=<条目>:同 spec 换板复用(如 e2e-hap 在 x86 模拟器上演练)
1292
+ if params["board"] not in inv["boards"]:
1293
+ raise ApplyError(f"inventory.boards 中不存在条目 {params['board']!r}(--params board 覆盖)")
1294
+ res["board"] = params["board"]
1295
+ board_cfg = inv["boards"].get(res.get("board"), {})
1296
+ tmpl = {
1297
+ "run_id": run_id, "run_dir": posix(run_dir),
1298
+ "product": board_cfg.get("product", ""),
1299
+ "device_root": board_cfg.get("device_root", "/system"),
1300
+ "build_layout": board_cfg.get("build_layout", ""),
1301
+ "ohos_root": params.get("ohos_root", "latest"),
1302
+ }
1303
+ state: dict = {}
1304
+ prev = run_dir / "results.json"
1305
+ if prev.exists():
1306
+ with open(prev, encoding="utf-8") as f:
1307
+ state = json.load(f).get("state") or {}
1308
+ return {
1309
+ "inv": inv, "job": job, "params": params, "run_id": run_id, "run_dir": run_dir,
1310
+ "server": Server(res["server"], inv["servers"][res["server"]]) if res.get("server") else None,
1311
+ "board": Board(res["board"], board_cfg, inv["local"]) if res.get("board") else None,
1312
+ "board_cfg": board_cfg, "state": state, "tmpl_ctx": tmpl,
1313
+ "results": {"job": job.get("job"), "run_id": run_id, "started": now(),
1314
+ "tool_version": tool_version(), # M6 版本契约:证据链可回答"哪个工具版本产出"
1315
+ "params": params, "resources": res, "steps": [], "outcome": None},
1316
+ }
1317
+
1318
+
1319
+ def action_run(job_path: Path, args) -> int:
1320
+ inv = load_yaml(wsroot.inventory_path())
1321
+ job = load_yaml(job_path)
1322
+ check_job(inv, job)
1323
+ params = parse_params(args.params, dict(job.get("params") or {}))
1324
+
1325
+ run_id = args.run_id or f"{job.get('job', 'job')}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
1326
+ run_dir = runs_root() / run_id
1327
+ run_dir.mkdir(parents=True, exist_ok=True)
1328
+ ctx = new_ctx(inv, job, params, run_id, run_dir)
1329
+ log(f"run {run_id} → {posix(run_dir)}", run_dir)
1330
+ write_results(ctx)
1331
+
1332
+ steps = job.get("steps", [])
1333
+ if args.only:
1334
+ want = {x.strip() for x in args.only.split(",")}
1335
+ steps = [s for s in steps if s.get("name") in want]
1336
+ if args.from_step:
1337
+ names = [s.get("name") for s in steps]
1338
+ if args.from_step not in names:
1339
+ raise ApplyError(f"--from-step {args.from_step!r} 不在步骤序列中: {names}")
1340
+ steps = steps[names.index(args.from_step):]
1341
+
1342
+ fail = None
1343
+ run_t0 = time.time()
1344
+ for s in steps:
1345
+ name, typ = s.get("name"), s.get("type")
1346
+ log(f"== {name} ({typ}) ==", run_dir)
1347
+ step_t0 = time.time()
1348
+ started = now()
1349
+ try:
1350
+ status, detail = STEPS[typ](ctx, s)
1351
+ except ApplyError as e:
1352
+ status, detail = "fail", {"error": str(e)}
1353
+ rec = {"name": name, "type": typ, "status": status, "detail": detail,
1354
+ "started": started, "ended": now()}
1355
+ ctx["results"]["steps"].append(rec)
1356
+ write_results(ctx)
1357
+ log(f" → {status} {json.dumps(detail, ensure_ascii=False)[:200]}", run_dir)
1358
+ telemetry.emit("step_done", job=ctx["job"].get("job"), run_id=run_id,
1359
+ step=name, step_type=typ, status=status,
1360
+ error_kind=telemetry.classify_error(detail, status),
1361
+ dur_s=round(time.time() - step_t0, 1))
1362
+ if status == "fail":
1363
+ fail = name
1364
+ if not args.keep_going:
1365
+ break
1366
+
1367
+ ctx["results"]["outcome"] = "fail" if fail else "ok"
1368
+ ctx["results"]["ended"] = now()
1369
+ write_results(ctx)
1370
+ telemetry.emit("job_done", job=ctx["job"].get("job"), run_id=run_id,
1371
+ outcome=ctx["results"]["outcome"], fail_step=fail or "",
1372
+ steps=len(ctx["results"]["steps"]), dur_s=round(time.time() - run_t0, 1))
1373
+ log(f"outcome: {ctx['results']['outcome']}" + (f"(失败于 {fail})" if fail else ""), run_dir)
1374
+ return 1 if fail else 0
1375
+
1376
+
1377
+ def action_plan(job_path: Path, args) -> int:
1378
+ inv = load_yaml(wsroot.inventory_path())
1379
+ job = load_yaml(job_path)
1380
+ check_job(inv, job)
1381
+ params = parse_params(args.params, dict(job.get("params") or {}))
1382
+ run_id = f"{job.get('job', 'job')}-plan-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
1383
+ ctx = new_ctx(inv, job, params, run_id, runs_root() / run_id)
1384
+ ctx["plan_rows"] = []
1385
+ rows = preview_plan(ctx)
1386
+
1387
+ plan = {"job": job.get("job"), "description": job.get("description"),
1388
+ "params": params, "resources": job.get("resources"), "steps": rows,
1389
+ "generated": now()}
1390
+ runs = runs_root()
1391
+ runs.mkdir(exist_ok=True)
1392
+ with open(runs / f"{run_id}.json", "w", encoding="utf-8") as f:
1393
+ json.dump(plan, f, ensure_ascii=False, indent=2)
1394
+
1395
+ print(f"job: {job.get('job')} ({job.get('description', '')})")
1396
+ print(f"server: {job['resources'].get('server')} → {ctx['server'].target}:{ctx['server'].port}"
1397
+ if ctx["server"] else "server: (无)")
1398
+ bc = ctx["board_cfg"]
1399
+ print(f"board: {job['resources'].get('board')} → {bc.get('product')} @hdc"
1400
+ f"(期望版本 {bc.get('software_version')})" if ctx["board"] else "board: (无)")
1401
+ print(f"ohos_root: {params.get('ohos_root') or '-'}"
1402
+ + (f" (latest → {inv['servers'][job['resources']['server']]['ohos_root_glob']})"
1403
+ if params.get("ohos_root") == "latest" else ""))
1404
+ print("steps:")
1405
+ for r in rows:
1406
+ note = f" — {r['note']}" if r.get("note") else ""
1407
+ print(f" {r['name']:<16} {r['type']}{note}")
1408
+ print(f"\n计划已写 runs/{run_id}.json(plan 不连任何机器;ohos_root 在 run 时解析)")
1409
+ return 0
1410
+
1411
+
1412
+ def main() -> int:
1413
+ try:
1414
+ sys.stdout.reconfigure(encoding="utf-8", errors="replace")
1415
+ except Exception:
1416
+ pass
1417
+ ap = argparse.ArgumentParser(description="薄调度器:job spec × inventory → plan/run")
1418
+ ap.add_argument("job", help="job spec 路径,如 verify.yaml")
1419
+ ap.add_argument("action", choices=["plan", "run"])
1420
+ ap.add_argument("--params", nargs="*", default=[], help="覆盖参数,k=v(值按 YAML 解析)")
1421
+ ap.add_argument("--from-step", help="从指定步骤开始(断点续跑)")
1422
+ ap.add_argument("--only", help="只跑指定步骤,逗号分隔")
1423
+ ap.add_argument("--run-id", help="复用已有 run 目录")
1424
+ ap.add_argument("--keep-going", action="store_true", help="步骤失败后继续")
1425
+ args = ap.parse_args()
1426
+
1427
+ job_path = Path(args.job)
1428
+ if not job_path.is_absolute():
1429
+ # 相对路径三级回退:cwd → 工作区 → 包正本(用户形态下 config/*.yaml 缺省在包里)
1430
+ cand = Path.cwd() / job_path
1431
+ if cand.is_file():
1432
+ job_path = cand
1433
+ else:
1434
+ ws = wsroot.ws_root()
1435
+ ws_c = (ws / job_path) if ws is not None else None # 安装态无工作区:跳过工作区分支
1436
+ pkg_c = wsroot.PKG / job_path
1437
+ job_path = ws_c if (ws_c is not None and ws_c.is_file()) \
1438
+ else (pkg_c if pkg_c.is_file() else cand)
1439
+ try:
1440
+ return action_plan(job_path, args) if args.action == "plan" else action_run(job_path, args)
1441
+ except (ApplyError, wsroot.WorkspaceRequiredError) as e:
1442
+ # WorkspaceRequiredError 同走本出口:安装态无工作区 rc==2 + require_ws 引导文案
1443
+ print(f"ERROR: {e}", file=sys.stderr)
1444
+ return 2
1445
+
1446
+
1447
+ if __name__ == "__main__":
1448
+ sys.exit(main())