@beyondwork/docx-react-component 1.0.0

package/scripts/start-wave-10-local.sh

@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage: bash scripts/start-wave-10-local.sh [options]
+
+Starts the Wave 10 local validator and harness together, waits for both health
+checks, and stops both when this shell exits or receives Ctrl+C.
+
+Options:
+  --repo-root PATH        Repo checkout to run against.
+                          Default: repo that contains this script.
+  --validator-port PORT   Validator port. Default: 5081
+  --harness-port PORT     Harness port. Default: 3403
+  --storage-dir PATH      Harness storage root.
+                          Default: <repo-root>/.tmp/wave-10-certification/harness-storage
+  --skip-build            Skip the harness production build before startup.
+  -h, --help              Show this help text.
+EOF
+}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+DEFAULT_REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+REPO_ROOT="$DEFAULT_REPO_ROOT"
+VALIDATOR_PORT="5081"
+HARNESS_PORT="3403"
+STORAGE_DIR=""
+SKIP_BUILD="0"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --repo-root)
+      REPO_ROOT="${2:-}"
+      shift 2
+      ;;
+    --validator-port)
+      VALIDATOR_PORT="${2:-}"
+      shift 2
+      ;;
+    --harness-port)
+      HARNESS_PORT="${2:-}"
+      shift 2
+      ;;
+    --storage-dir)
+      STORAGE_DIR="${2:-}"
+      shift 2
+      ;;
+    --skip-build)
+      SKIP_BUILD="1"
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "start-wave-10-local: unknown argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [[ -z "$REPO_ROOT" ]]; then
+  echo "start-wave-10-local: --repo-root requires a value." >&2
+  exit 2
+fi
+
+if [[ ! -d "$REPO_ROOT" ]]; then
+  echo "start-wave-10-local: repo root does not exist: $REPO_ROOT" >&2
+  exit 1
+fi
+
+if [[ ! -f "$REPO_ROOT/pnpm-workspace.yaml" ]]; then
+  echo "start-wave-10-local: repo root does not look like docx-react-component: $REPO_ROOT" >&2
+  exit 1
+fi
+
+if [[ -z "$STORAGE_DIR" ]]; then
+  STORAGE_DIR="$REPO_ROOT/.tmp/wave-10-certification/harness-storage"
+fi
+
+for required_command in curl dotnet pnpm; do
+  if ! command -v "$required_command" >/dev/null 2>&1; then
+    echo "start-wave-10-local: missing required command: $required_command" >&2
+    exit 1
+  fi
+done
+
+VALIDATOR_URL="http://127.0.0.1:${VALIDATOR_PORT}"
+HARNESS_URL="http://127.0.0.1:${HARNESS_PORT}"
+RUNTIME_DIR="$REPO_ROOT/.tmp/wave-10-local-services"
+VALIDATOR_LOG="$RUNTIME_DIR/validator.log"
+HARNESS_LOG="$RUNTIME_DIR/harness.log"
+VALIDATOR_PID=""
+HARNESS_PID=""
+
+mkdir -p "$RUNTIME_DIR" "$STORAGE_DIR"
+
+cleanup() {
+  local exit_code=$?
+  trap - EXIT INT TERM
+
+  if [[ -n "$HARNESS_PID" ]] && kill -0 "$HARNESS_PID" 2>/dev/null; then
+    kill "$HARNESS_PID" 2>/dev/null || true
+  fi
+
+  if [[ -n "$VALIDATOR_PID" ]] && kill -0 "$VALIDATOR_PID" 2>/dev/null; then
+    kill "$VALIDATOR_PID" 2>/dev/null || true
+  fi
+
+  wait "$HARNESS_PID" 2>/dev/null || true
+  wait "$VALIDATOR_PID" 2>/dev/null || true
+  exit "$exit_code"
+}
+
+wait_for_health() {
+  local label="$1"
+  local url="$2"
+  local pid="$3"
+  local attempt
+
+  for attempt in $(seq 1 60); do
+    if curl -fsS "$url" >/dev/null 2>&1; then
+      return 0
+    fi
+
+    if ! kill -0 "$pid" 2>/dev/null; then
+      echo "start-wave-10-local: ${label} exited before becoming healthy." >&2
+      return 1
+    fi
+
+    sleep 1
+  done
+
+  echo "start-wave-10-local: timed out waiting for ${label} health at ${url}." >&2
+  return 1
+}
+
+trap cleanup EXIT INT TERM
+
+cd "$REPO_ROOT"
+
+if [[ "$SKIP_BUILD" != "1" ]]; then
+  echo "Building harness production app in $REPO_ROOT"
+  pnpm --filter @docx-react-component/react-word-editor-harness build
+fi
+
+echo "Starting validator on ${VALIDATOR_URL}"
+(
+  cd "$REPO_ROOT"
+  VALIDATOR_PRIVATE_MODE=enabled \
+    dotnet run --project services/openxml-validator/OpenXmlValidator.Api.csproj --urls "$VALIDATOR_URL"
+) >"$VALIDATOR_LOG" 2>&1 &
+VALIDATOR_PID="$!"
+
+wait_for_health "validator" "${VALIDATOR_URL}/health" "$VALIDATOR_PID"
+
+echo "Starting harness on ${HARNESS_URL}"
+(
+  cd "$REPO_ROOT"
+  PORT="$HARNESS_PORT" \
+  HARNESS_PRIVATE_MODE=enabled \
+  OPENXML_VALIDATOR_BASE_URL="$VALIDATOR_URL" \
+  HARNESS_STORAGE_DIR="$STORAGE_DIR" \
+    pnpm --filter @docx-react-component/react-word-editor-harness start
+) >"$HARNESS_LOG" 2>&1 &
+HARNESS_PID="$!"
+
+wait_for_health "harness" "${HARNESS_URL}/api/health" "$HARNESS_PID"
+
+cat <<EOF
+Wave 10 local services are ready.
+
+Harness:   ${HARNESS_URL}
+Validator: ${VALIDATOR_URL}
+Storage:   ${STORAGE_DIR}
+
+Logs:
+  ${VALIDATOR_LOG}
+  ${HARNESS_LOG}
+
+Keep this shell open while you use the site. Press Ctrl+C to stop both services.
+EOF
+
+wait -n "$VALIDATOR_PID" "$HARNESS_PID"
+exit $?

package/scripts/wave-agent-attach.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -lt 2 || $# -gt 3 ]]; then
+  echo "Usage: bash scripts/wave-agent-attach.sh <wave> <agent> [--print-session]" >&2
+  exit 2
+fi
+
+WAVE="$1"
+AGENT="${2,,}"
+MODE="${3:-attach}"
+
+if [[ "$MODE" != "attach" && "$MODE" != "--print-session" ]]; then
+  echo "Usage: bash scripts/wave-agent-attach.sh <wave> <agent> [--print-session]" >&2
+  exit 2
+fi
+
+TMUX_ROOT="/tmp/tmux-$(id -u)"
+PATTERN="_wave${WAVE}_${WAVE}-${AGENT}_"
+
+best_socket=""
+best_session=""
+best_created="0"
+
+while IFS= read -r socket; do
+  while IFS='|' read -r session created; do
+    [[ -n "$session" ]] || continue
+    if [[ "$session" == *"$PATTERN"* ]] && [[ "$created" -ge "$best_created" ]]; then
+      best_socket="$socket"
+      best_session="$session"
+      best_created="$created"
+    fi
+  done < <(TMUX= tmux -S "$socket" ls -F '#{session_name}|#{session_created}' 2>/dev/null || true)
+done < <(find "$TMUX_ROOT" -maxdepth 1 -type s -name '*waves*' | sort)
+
+if [[ -z "$best_session" || -z "$best_socket" ]]; then
+  echo "No live tmux session matched wave ${WAVE} agent ${AGENT}." >&2
+  echo "Searched sockets under ${TMUX_ROOT} for pattern ${PATTERN}." >&2
+  exit 1
+fi
+
+if [[ "$MODE" == "--print-session" ]]; then
+  printf '%s\t%s\n' "$best_socket" "$best_session"
+  exit 0
+fi
+
+exec env TMUX= tmux -S "$best_socket" attach -t "$best_session"

package/scripts/wave-auto-answer.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+LANE="${WAVE_LANE:-main}"
+WAVE=""
+AGENT=""
+OPERATOR="${WAVE_AUTO_ANSWER_OPERATOR:-codex-auto-answer}"
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --lane)
+      LANE="${2:-}"
+      shift 2
+      ;;
+    --wave)
+      WAVE="${2:-}"
+      shift 2
+      ;;
+    --agent)
+      AGENT="${2:-}"
+      shift 2
+      ;;
+    --operator)
+      OPERATOR="${2:-$OPERATOR}"
+      shift 2
+      ;;
+    --help|-h)
+      cat <<'EOF'
+Usage:
+  bash scripts/wave-auto-answer.sh [--lane <lane>] [--wave <n>] [--agent <id>] [--operator <name>]
+EOF
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 2
+      ;;
+  esac
+done
+
+list_args=(feedback list --lane "$LANE" --pending --json)
+if [[ -n "$WAVE" ]]; then
+  list_args+=(--wave "$WAVE")
+fi
+if [[ -n "$AGENT" ]]; then
+  list_args+=(--agent "$AGENT")
+fi
+
+requests_json="$(pnpm exec wave "${list_args[@]}")"
+
+responses_json="$(
+  REQUESTS_JSON="$requests_json" node <<'NODE'
+const requests = JSON.parse(process.env.REQUESTS_JSON || "[]");
+
+function buildResponse(request) {
+  const question = String(request?.question || "").trim();
+  const context = String(request?.context || "").trim();
+  const combined = `${question}\n${context}`.toLowerCase();
+  const base =
+    "Operator decision: continue using the latest on-disk owned deliverables, canonical control state, and authoritative proof bundles as the source of truth for this attempt. Do not reopen this clarification unless a new non-owned conflicting edit or a real product-level ambiguity appears.";
+
+  if (
+    combined.includes("conflicting edits") ||
+    combined.includes("stale contract variants") ||
+    combined.includes("diverged from recent") ||
+    combined.includes("owned model files")
+  ) {
+    return "Operator decision: proceed with the current on-disk files inside the requesting agent's owned scope as authoritative for this attempt. Treat earlier stale variants as superseded artifacts. Do not reopen unless a new non-owner edit lands in that owned scope during the active attempt.";
+  }
+
+  if (
+    combined.includes("shared-plan") ||
+    combined.includes("docs delta") ||
+    combined.includes("component matrix") ||
+    combined.includes("documentation steward")
+  ) {
+    return "Operator decision: treat the canonical shared-plan set as the authoritative closure target for this wave and continue. Route the exact delta to A9, update only the owned shared-plan files, and do not block on stale projections once those docs are aligned.";
+  }
+
+  if (
+    combined.includes("prompt drift") ||
+    combined.includes("status mismatch") ||
+    combined.includes("stale projection") ||
+    combined.includes("stale blocker") ||
+    combined.includes("dashboard")
+  ) {
+    return "Operator decision: trust the latest authoritative proof bundles, current on-disk artifacts, and active-attempt control state over stale projections or prompt-drift residue. Continue without reopening superseded blockers.";
+  }
+
+  return base;
+}
+
+process.stdout.write(
+  JSON.stringify(
+    requests.map((request) => ({
+      id: request.id,
+      response: buildResponse(request),
+    })),
+  ),
+);
+NODE
+)"
+
+pending_count="$(REQUESTS_JSON="$requests_json" node -e 'const requests=JSON.parse(process.env.REQUESTS_JSON||"[]"); process.stdout.write(String(requests.length));')"
+
+if [[ "$pending_count" == "0" ]]; then
+  printf 'answered=0 pending=0 lane=%s\n' "$LANE"
+  exit 0
+fi
+
+while IFS= read -r entry; do
+  request_id="$(ENTRY="$entry" node -e 'const payload=JSON.parse(process.env.ENTRY||"{}"); process.stdout.write(String(payload.id||""));')"
+  response_text="$(ENTRY="$entry" node -e 'const payload=JSON.parse(process.env.ENTRY||"{}"); process.stdout.write(String(payload.response||""));')"
+  pnpm exec wave feedback respond --id "$request_id" --response "$response_text" --operator "$OPERATOR" >/dev/null
+  printf 'answered_request=%s lane=%s\n' "$request_id" "$LANE"
+done < <(RESPONSES_JSON="$responses_json" node -e 'const items=JSON.parse(process.env.RESPONSES_JSON||"[]"); for (const item of items) { console.log(JSON.stringify(item)); }')
+
+printf 'answered=%s pending=%s lane=%s\n' "$pending_count" "$pending_count" "$LANE"

package/scripts/wave-dashboard-attach.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+LANE="${WAVE_LANE:-main}"
+TARGET="${1:-current}"
+
+if [[ "$TARGET" != "current" && "$TARGET" != "global" ]]; then
+  echo "Usage: bash scripts/wave-dashboard-attach.sh [current|global]" >&2
+  exit 2
+fi
+
+bash "$SCRIPT_DIR/context7-export-env.sh" run pnpm exec wave dashboard --lane "$LANE" --attach "$TARGET"

package/scripts/wave-launch.sh

@@ -0,0 +1,273 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+LANE="${WAVE_LANE:-main}"
+RUN_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"
+STATE_DIR="$REPO_ROOT/.tmp/${LANE}-wave-launcher"
+LOG_DIR="$STATE_DIR/logs"
+EXIT_DIR="$STATE_DIR/exits"
+
+mkdir -p "$LOG_DIR" "$EXIT_DIR"
+
+args=("$@")
+resolved_args=()
+explicit_lane=0
+explicit_terminal_surface=0
+explicit_session_policy=0
+explicit_terminal_policy=0
+explicit_auto_next=0
+single_wave=""
+start_wave=""
+end_wave=""
+
+infer_next_wave() {
+  node - "$REPO_ROOT" "$LANE" <<'NODE'
+const fs = require("node:fs");
+const path = require("node:path");
+
+const repoRoot = process.argv[2];
+const lane = process.argv[3] || "main";
+const runStatePath = path.join(repoRoot, ".tmp", `${lane}-wave-launcher`, "run-state.json");
+const manualCompletionsPath = path.join(repoRoot, ".tmp", `${lane}-wave-launcher`, "manual-completions.json");
+
+let payload = null;
+try {
+  payload = JSON.parse(fs.readFileSync(runStatePath, "utf8"));
+} catch {
+  payload = null;
+}
+let manualCompletions = [];
+try {
+  const manualPayload = JSON.parse(fs.readFileSync(manualCompletionsPath, "utf8"));
+  manualCompletions = Array.isArray(manualPayload?.waves) ? manualPayload.waves : [];
+} catch {
+  manualCompletions = [];
+}
+const manualCompletedSet = new Set(
+  manualCompletions
+    .map((value) => Number.parseInt(String(value), 10))
+    .filter((value) => Number.isFinite(value)),
+);
+
+const waves = Object.values(payload?.waves || {})
+  .filter((entry) => entry && typeof entry === "object")
+  .map((entry) => ({
+    wave: Number.parseInt(String(entry.wave ?? ""), 10),
+    state: manualCompletedSet.has(Number.parseInt(String(entry.wave ?? ""), 10))
+      ? "completed_with_drift"
+      : String(entry.currentState || "").trim().toLowerCase(),
+  }))
+  .filter((entry) => Number.isFinite(entry.wave))
+  .sort((left, right) => left.wave - right.wave);
+
+const isComplete = (value) => String(value || "").trim().toLowerCase().startsWith("completed");
+const isTerminalFailure = (value) => ["failed", "timed_out", "timed-out"].includes(String(value || "").trim().toLowerCase());
+const highestCompleted = Math.max(
+  -1,
+  ...((Array.isArray(payload?.completedWaves) ? payload.completedWaves : [])
+    .map((value) => Number.parseInt(String(value), 10))
+    .filter((value) => Number.isFinite(value))),
+  ...manualCompletedSet,
+  ...waves.filter((entry) => isComplete(entry.state)).map((entry) => entry.wave),
+);
+const next = waves.find(
+  (entry) =>
+    entry.wave > highestCompleted &&
+    !isComplete(entry.state) &&
+    !isTerminalFailure(entry.state),
+);
+process.stdout.write(String(next ? next.wave : (waves.at(-1)?.wave ?? 0)));
+NODE
+}
+
+for ((i = 0; i < ${#args[@]}; i += 1)); do
+  arg="${args[$i]}"
+  case "$arg" in
+    --auto-next)
+      explicit_auto_next=1
+      ;;
+    --lane)
+      if (( i + 1 < ${#args[@]} )); then
+        explicit_lane=1
+        LANE="${args[$((i + 1))]}"
+        resolved_args+=("$arg")
+        resolved_args+=("${args[$((i + 1))]}")
+        i=$((i + 1))
+      fi
+      ;;
+    --start-wave)
+      if (( i + 1 < ${#args[@]} )); then
+        start_wave="${args[$((i + 1))]}"
+        resolved_args+=("$arg")
+        resolved_args+=("${args[$((i + 1))]}")
+        i=$((i + 1))
+      fi
+      ;;
+    --end-wave)
+      if (( i + 1 < ${#args[@]} )); then
+        end_wave="${args[$((i + 1))]}"
+        resolved_args+=("$arg")
+        resolved_args+=("${args[$((i + 1))]}")
+        i=$((i + 1))
+      fi
+      ;;
+    --terminal-surface)
+      if (( i + 1 < ${#args[@]} )); then
+        explicit_terminal_surface=1
+        resolved_args+=("$arg")
+        resolved_args+=("${args[$((i + 1))]}")
+        i=$((i + 1))
+      fi
+      ;;
+    --cleanup-sessions|--keep-sessions)
+      resolved_args+=("$arg")
+      explicit_session_policy=1
+      ;;
+    --keep-terminals)
+      resolved_args+=("$arg")
+      explicit_terminal_policy=1
+      ;;
+    *)
+      resolved_args+=("$arg")
+      ;;
+  esac
+done
+
+if (( explicit_auto_next == 1 )) && [[ -z "$start_wave" && -z "$end_wave" ]]; then
+  next_wave="$(infer_next_wave)"
+  start_wave="$next_wave"
+  end_wave="$next_wave"
+  resolved_args+=(--start-wave "$next_wave" --end-wave "$next_wave")
+fi
+
+if [[ -n "$start_wave" && -n "$end_wave" && "$start_wave" == "$end_wave" ]]; then
+  single_wave="$start_wave"
+fi
+
+if (( explicit_lane == 0 )); then
+  resolved_args=(--lane "$LANE" "${resolved_args[@]}")
+fi
+
+if (( explicit_terminal_surface == 0 )); then
+  resolved_args+=(--terminal-surface vscode)
+fi
+
+if (( explicit_session_policy == 0 )); then
+  resolved_args+=(--keep-sessions)
+fi
+
+if (( explicit_terminal_policy == 0 )); then
+  resolved_args+=(--keep-terminals)
+fi
+
+STATE_DIR="$REPO_ROOT/.tmp/${LANE}-wave-launcher"
+LOG_DIR="$STATE_DIR/logs"
+EXIT_DIR="$STATE_DIR/exits"
+mkdir -p "$LOG_DIR" "$EXIT_DIR"
+
+LOG_PATH="$LOG_DIR/launch-${RUN_ID}.log"
+STATUS_PATH="$EXIT_DIR/launch-${RUN_ID}.json"
+LATEST_PATH="$EXIT_DIR/latest.json"
+RAW_STATUS_PATH="$EXIT_DIR/launch-${RUN_ID}.status.json"
+
+cmd=(pnpm exec wave launch "${resolved_args[@]}")
+
+echo "wave-launch: lane=${LANE} run=${RUN_ID}" | tee "$LOG_PATH"
+echo "wave-launch: command=${cmd[*]}" | tee -a "$LOG_PATH"
+
+set +e
+bash "$SCRIPT_DIR/context7-export-env.sh" run "${cmd[@]}" 2>&1 | tee -a "$LOG_PATH"
+exit_code=${PIPESTATUS[0]}
+set -e
+
+if [[ -n "$single_wave" ]]; then
+  STATUS_WAVE="$single_wave"
+  set +e
+  status_json="$(pnpm exec wave control status --lane "$LANE" --wave "$STATUS_WAVE" --json 2>/dev/null)"
+  status_exit=$?
+  set -e
+  if (( status_exit == 0 )) && [[ -n "$status_json" ]]; then
+    printf '%s\n' "$status_json" >"$RAW_STATUS_PATH"
+  else
+    rm -f "$RAW_STATUS_PATH"
+  fi
+else
+  status_json=""
+  status_exit=0
+  rm -f "$RAW_STATUS_PATH"
+fi
+
+node - "$STATUS_PATH" "$LATEST_PATH" "$RUN_AT" "$RUN_ID" "$LANE" "$single_wave" "$exit_code" "$LOG_PATH" "$status_exit" "$RAW_STATUS_PATH" <<'NODE'
+const fs = require("fs");
+
+const [
+  ,
+  ,
+  statusPath,
+  latestPath,
+  runAt,
+  runId,
+  lane,
+  singleWave,
+  exitCodeText,
+  logPath,
+  statusExitText,
+  rawStatusPath,
+] = process.argv;
+
+let parsedStatus = null;
+if (Number(statusExitText) === 0 && rawStatusPath) {
+  try {
+    const statusJson = fs.readFileSync(rawStatusPath, "utf8");
+    parsedStatus = JSON.parse(statusJson);
+  } catch {
+    parsedStatus = null;
+  }
+}
+
+const payload = {
+  runAt,
+  runId,
+  lane,
+  wave: singleWave || null,
+  exitCode: Number(exitCodeText),
+  logPath,
+  status: parsedStatus,
+};
+
+fs.writeFileSync(statusPath, `${JSON.stringify(payload, null, 2)}\n`);
+fs.writeFileSync(latestPath, `${JSON.stringify(payload, null, 2)}\n`);
+
+if (singleWave) {
+  const waveLatestPath = statusPath.replace(/launch-[^.]+\.json$/, `wave-${singleWave}-latest.json`);
+  fs.writeFileSync(waveLatestPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+NODE
+
+echo "wave-launch: exit=${exit_code} log=${LOG_PATH}"
+if [[ -n "$single_wave" ]]; then
+  status_summary=""
+  if [[ -s "$RAW_STATUS_PATH" ]]; then
+    status_summary="$(node - "$RAW_STATUS_PATH" <<'NODE' 2>/dev/null || true
+const fs = require("fs");
+const rawStatusPath = process.argv[2];
+if (!rawStatusPath) {
+  process.exit(0);
+}
+const input = fs.readFileSync(rawStatusPath, "utf8").trim();
+if (!input) {
+  process.exit(0);
+}
+const payload = JSON.parse(input);
+const blocking = payload.blockingEdge ? `${payload.blockingEdge.kind}:${payload.blockingEdge.id}` : "none";
+process.stdout.write(`wave=${payload.wave} phase=${payload.phase} blocking=${blocking}`);
+NODE
+)"
+  fi
+  echo "wave-launch: status=${status_summary}"
+fi
+
+exit "$exit_code"