@hunter-harness/workflow-harness 0.2.53 → 0.2.55

package/harness/bundles/java/codebuddy/scripts/harness_archive.py

@@ -17,6 +17,7 @@ import argparse
 import datetime as dt
 import hashlib
 import io
+import ipaddress
 import json
 import os
 import re
@@ -31,6 +32,7 @@ import zipfile
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
+from urllib.parse import urlsplit
 
 
 if hasattr(sys.stdout, "reconfigure"):
@@ -192,9 +194,9 @@ def append_event(
     for key, value in fields.items():
         if value is not None:
             event[key] = value
-    line = json.dumps(event, ensure_ascii=False, separators=(",", ":"))
-    he.atomic_append_line(path, line)
-    all_events = existing + [he.normalize_event(event)]
+    result = he.append_with_auto_seal(path, event, existing_events=existing)
+    event = result["event"]
+    all_events = he.load_events(path)
     he.write_execution_log(change_dir, he.render_execution_log(all_events))
     return event
 
@@ -3053,6 +3055,25 @@ def build_verification_projection(
         "apiTests": _ledger_api_tests(effective_ledger, change_dir=change_dir),
     }
     db_compatibility = _ledger_db_compat(effective_ledger)
+    if db_compatibility["status"] == "NOT_RUN" and change_dir is not None:
+        gate_policy_path = change_dir / "meta" / "gate-policy.json"
+        try:
+            gate_policy = read_json(gate_policy_path) if gate_policy_path.is_file() else None
+        except (OSError, json.JSONDecodeError):
+            gate_policy = None
+        if isinstance(gate_policy, dict):
+            capabilities = gate_policy.get("capabilities")
+            required = gate_policy.get("requiredValidations")
+            if (
+                isinstance(capabilities, list)
+                and "database" not in capabilities
+                and (not isinstance(required, list) or "dbCompatibility" not in required)
+            ):
+                db_compatibility = {
+                    "status": "NOT_APPLICABLE",
+                    "reason": "项目能力画像未声明数据库能力",
+                    "source": "capability-profile",
+                }
     projection["dbCompatibility"] = db_compatibility["status"]
     projection["dbCompatibilityEvidence"] = db_compatibility
     api_contract = validations.get("apiContract")
@@ -8377,6 +8398,27 @@ def _read_optional_text(path: Path) -> str:
         return ""
 
 
+def _archive_server_url_allowed(value: str | None) -> bool:
+    """Require TLS remotely while allowing explicit loopback HTTP for local testing."""
+    if value is None or not value.strip() or re.search(r"\s", value):
+        return False
+    try:
+        parsed = urlsplit(value)
+        host = (parsed.hostname or "").lower()
+    except ValueError:
+        return False
+    if parsed.scheme.lower() == "https":
+        return bool(host)
+    if parsed.scheme.lower() != "http":
+        return False
+    if host == "localhost":
+        return True
+    try:
+        return ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        return False
+
+
 def _resolve_archive_remote_credentials(
     project_root: Path,
     environment: Mapping[str, str],
@@ -8403,10 +8445,7 @@ def _resolve_archive_remote_credentials(
         else ""
     )
     token_available = bool(env_token or local_token)
-    url_available = bool(
-        server_url
-        and re.fullmatch(r"https://[^\s]+", server_url, flags=re.IGNORECASE)
-    )
+    url_available = _archive_server_url_allowed(server_url)
     return {
         "configured": bool(url_available and token_available),
         "serverUrl": server_url if url_available else None,

package/harness/bundles/java/codebuddy/scripts/harness_context.py

@@ -23,6 +23,8 @@ PHASE_GRAPH = {
     "submit": (),
 }
 
+DISPLAY_TITLE_MAX_LENGTH = 80
+
 
 def _now() -> dt.datetime:
     return dt.datetime.now(dt.timezone.utc)
@@ -35,6 +37,41 @@ def _read_json(path: Path) -> dict[str, Any]:
     return data
 
 
+def _normalize_display_title(value: Any) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError("display title must be text")
+    title = value.strip()
+    if not title:
+        raise ValueError("display title must not be empty")
+    if len(title) > DISPLAY_TITLE_MAX_LENGTH:
+        raise ValueError(
+            f"display title exceeds {DISPLAY_TITLE_MAX_LENGTH} characters"
+        )
+    if any(ord(character) < 32 or ord(character) == 127 for character in title):
+        raise ValueError("display title contains control characters")
+    return title
+
+
+def _ensure_display_title(contract_root: Path, value: Any) -> str | None:
+    path = contract_root / "meta" / "change-title.json"
+    if path.is_file():
+        payload = _read_json(path)
+        return _normalize_display_title(payload.get("displayTitle"))
+    title = _normalize_display_title(value)
+    if title is None:
+        return None
+    _write_json_atomic(
+        path,
+        {
+            "schemaVersion": 1,
+            "displayTitle": title,
+        },
+    )
+    return title
+
+
 def _write_json_atomic(path: Path, payload: dict[str, Any]) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     fd, raw = tempfile.mkstemp(prefix=f".{path.name}.", dir=str(path.parent))
@@ -243,6 +280,7 @@ def prepare_context(
     phase: str,
     executor: str,
     change: str | None = None,
+    display_title: str | None = None,
     ttl_seconds: int = 3600,
 ) -> dict[str, Any]:
     project = Path(project).resolve()
@@ -265,6 +303,16 @@ def prepare_context(
         contract_root, contract, state_root = _contract(project, change)
     except (OSError, ValueError, json.JSONDecodeError) as exc:
         return {"ok": False, "code": str(exc).split(":", 1)[0], "error": str(exc)}
+    try:
+        resolved_display_title = _ensure_display_title(
+            contract_root, display_title
+        )
+    except (OSError, ValueError, json.JSONDecodeError) as exc:
+        return {
+            "ok": False,
+            "code": "DISPLAY_TITLE_INVALID",
+            "error": str(exc),
+        }
     lifecycle = contract.get("lifecycle")
     if (
         isinstance(lifecycle, dict)
@@ -343,6 +391,7 @@ def prepare_context(
             "executionRoot": str(execution_root),
             "preparedAt": now.isoformat(),
             "receiptHash": latest.get("receiptHash") if latest else None,
+            "displayTitle": resolved_display_title,
         },
     )
     next_phases = (
@@ -363,6 +412,7 @@ def prepare_context(
         "latestTransition": latest,
         "lease": lease,
         "recovery": recovery,
+        "displayTitle": resolved_display_title,
     }
 
 
@@ -424,7 +474,7 @@ def close_transition(
     *,
     from_phase: str,
     to_phase: str,
-    executor: str,
+    executor: str | None,
     artifacts: list[str] | None = None,
     status: str = "OK",
 ) -> dict[str, Any]:
@@ -441,13 +491,81 @@ def close_transition(
     except (OSError, ValueError, json.JSONDecodeError) as exc:
         return {"ok": False, "code": "CHANGE_NOT_FOUND", "error": str(exc)}
     paths = _paths(state_root)
+
+    artifact_entries: list[dict[str, Any]] = []
+    for raw in artifacts or []:
+        requested = Path(raw)
+        candidates = (
+            [requested]
+            if requested.is_absolute()
+            else [project / requested, contract_root / requested]
+        )
+        valid: list[Path] = []
+        for candidate in candidates:
+            try:
+                resolved_candidate = candidate.resolve()
+            except OSError:
+                continue
+            if resolved_candidate in valid:
+                continue
+            if resolved_candidate.is_relative_to(project) and resolved_candidate.is_file():
+                valid.append(resolved_candidate)
+        if len(valid) > 1:
+            return {
+                "ok": False,
+                "code": "TRANSITION_ARTIFACT_AMBIGUOUS",
+                "path": raw,
+                "candidates": [item.relative_to(project).as_posix() for item in valid],
+                "message": "relative artifact exists under both project and change roots",
+            }
+        if not valid:
+            return {
+                "ok": False,
+                "code": "TRANSITION_ARTIFACT_INVALID",
+                "path": raw,
+                "acceptedBases": [str(project), str(contract_root)],
+                "examples": [
+                    str(contract_root / "meta" / "plan-finalization.json"),
+                    f".harness/changes/{change}/meta/plan-finalization.json",
+                    "meta/plan-finalization.json",
+                ],
+            }
+        resolved_artifact = valid[0]
+        artifact_entries.append(
+            {
+                "path": resolved_artifact.relative_to(project).as_posix(),
+                "sha256": _sha256(resolved_artifact),
+            }
+        )
+
+    transitions = _read_ndjson(paths["transitions"])
     if not paths["lease"].is_file():
+        latest = transitions[-1] if transitions else None
+        if (
+            isinstance(latest, dict)
+            and latest.get("fromPhase") == from_phase
+            and latest.get("toPhase") == to_phase
+            and latest.get("status") == status
+            and latest.get("artifacts") == artifact_entries
+            and (executor is None or latest.get("executor") == executor)
+        ):
+            return {
+                "ok": True,
+                "code": "TRANSITION_ALREADY_CLOSED",
+                "idempotent": True,
+                "receipt": latest,
+                "path": str(paths["transitions"]),
+                "invalidation": None,
+            }
         return {"ok": False, "code": "CONTEXT_LEASE_REQUIRED"}
     try:
         lease = _read_json(paths["lease"])
     except (OSError, ValueError, json.JSONDecodeError):
         return {"ok": False, "code": "CONTEXT_LEASE_INVALID"}
-    if lease.get("owner") != executor or lease.get("phase") != from_phase:
+    effective_executor = executor or str(lease.get("owner") or "")
+    if not effective_executor:
+        return {"ok": False, "code": "CONTEXT_EXECUTOR_REQUIRED"}
+    if lease.get("owner") != effective_executor or lease.get("phase") != from_phase:
         return {
             "ok": False,
             "code": "CONTEXT_LEASE_MISMATCH",
@@ -458,25 +576,6 @@ def close_transition(
     if expiry is None or _now() >= expiry:
         return {"ok": False, "code": "CONTEXT_LEASE_EXPIRED"}
 
-    artifact_entries: list[dict[str, Any]] = []
-    for raw in artifacts or []:
-        path = Path(raw)
-        if not path.is_absolute():
-            path = contract_root / path
-        resolved = path.resolve()
-        if not resolved.is_relative_to(project) or not resolved.is_file():
-            return {
-                "ok": False,
-                "code": "TRANSITION_ARTIFACT_INVALID",
-                "path": str(path),
-            }
-        artifact_entries.append(
-            {
-                "path": resolved.relative_to(project).as_posix(),
-                "sha256": _sha256(resolved),
-            }
-        )
-    transitions = _read_ndjson(paths["transitions"])
     previous_hash = transitions[-1].get("receiptHash") if transitions else None
     attempt = (
         1
@@ -493,7 +592,7 @@ def close_transition(
         "fromPhase": from_phase,
         "toPhase": to_phase,
         "status": status,
-        "executor": executor,
+        "executor": effective_executor,
         "productCommit": _head(project),
         "artifacts": artifact_entries,
         "attempt": attempt,
@@ -657,6 +756,7 @@ def build_parser() -> argparse.ArgumentParser:
     prepare.add_argument("--change")
     prepare.add_argument("--phase", required=True)
     prepare.add_argument("--executor", required=True)
+    prepare.add_argument("--title")
     prepare.add_argument("--ttl-seconds", type=int, default=3600)
     close = sub.add_parser("close")
     close.add_argument("--json", action="store_true")
@@ -688,6 +788,7 @@ def main(argv: list[str] | None = None) -> int:
             phase=args.phase,
             executor=args.executor,
             change=args.change,
+            display_title=args.title,
             ttl_seconds=args.ttl_seconds,
         )
     elif args.command == "close":

package/harness/bundles/java/codebuddy/scripts/harness_events.py

@@ -41,7 +41,7 @@ def _project_root_for_change(change_dir: Path) -> Path | None:
     return None
 
 
-def _nudge_remote_sync(change_dir: Path) -> None:
+def nudge_remote_sync(change_dir: Path) -> None:
     """Best-effort wake-up after the event append has been flushed to disk."""
     project_root = _project_root_for_change(change_dir)
     if project_root is None:
@@ -55,6 +55,11 @@ def _nudge_remote_sync(change_dir: Path) -> None:
         return
 
 
+def _nudge_remote_sync(change_dir: Path) -> None:
+    """Compatibility wrapper for older callers and focused tests."""
+    nudge_remote_sync(change_dir)
+
+
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
 if hasattr(sys.stderr, "reconfigure"):
@@ -121,6 +126,12 @@ OPTIONAL_FIELDS = (
     "renamed_from",
     "renamed_to",
     "change_uuid",
+    "execution_mode",
+    "decision_reason_code",
+    "fallback_reason_code",
+    "trigger",
+    "from_phase",
+    "result_status",
 )
 
 _PROVENANCE_FIELDS = frozenset(
@@ -139,6 +150,12 @@ _PROVENANCE_FIELDS = frozenset(
         "orchestration_active_ms",
         "wall_clock_ms",
         "user_wait_ms",
+        "execution_mode",
+        "decision_reason_code",
+        "fallback_reason_code",
+        "trigger",
+        "from_phase",
+        "result_status",
     }
 )
 _EVENT_ALLOWED_FIELDS = {
@@ -1698,6 +1715,22 @@ def append_with_auto_seal(
                 else []
             )
         )
+        if event_type in {"phase.start", "phase.end", "phase.auto_sealed"} and phase:
+            phase_attempts = split_phase_attempts(
+                [item for item in loaded if item.get("phase") == phase]
+            )
+            latest_attempt = max(
+                (
+                    int(item.get("attempt"))
+                    for item in phase_attempts
+                    if isinstance(item.get("attempt"), int)
+                ),
+                default=0,
+            )
+            if not isinstance(event.get("attempt"), int) or int(event["attempt"]) <= 0:
+                event["attempt"] = (
+                    latest_attempt + 1 if event_type == "phase.start" else latest_attempt or 1
+                )
         if event_type == "phase.start" and phase:
             auto_sealed = seal_open_phase_attempts(loaded, phase=phase)
             for seal_event in auto_sealed:
@@ -1967,6 +2000,12 @@ def build_parser() -> argparse.ArgumentParser:
     p_append.add_argument("--orchestration-active-ms", type=int, default=None)
     p_append.add_argument("--wall-clock-ms", type=int, default=None)
     p_append.add_argument("--user-wait-ms", type=int, default=None)
+    p_append.add_argument("--execution-mode", default=None)
+    p_append.add_argument("--decision-reason-code", default=None)
+    p_append.add_argument("--fallback-reason-code", default=None)
+    p_append.add_argument("--trigger", default=None)
+    p_append.add_argument("--from-phase", default=None)
+    p_append.add_argument("--result-status", default=None)
     p_append.add_argument(
         "--legacy-lenient",
         action="store_true",