@beyondwork/docx-react-component 1.0.0 → 1.0.1

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

@@ -1,189 +0,0 @@
-#!/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

@@ -1,47 +0,0 @@
-#!/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

@@ -1,118 +0,0 @@
-#!/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

@@ -1,13 +0,0 @@
-#!/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

@@ -1,273 +0,0 @@
-#!/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"