forgedock 1.3.0 → 1.4.0

package/scripts/check-phase-registry-drift.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * CI drift check: bin/engine/phases.mjs's `PHASES` array (the authoritative
+ * engine phase table) must have exactly the same phase-id list, in the same
+ * order, as packages/protocol/src/phases.js's `PHASE_IDS` — the single-source
+ * registry both bin/engine/phases.mjs and bin/hooks/interactive-engine.mjs
+ * import their marker strings from (forge#2378).
+ *
+ * This does NOT re-validate the marker *strings* themselves — both consumer
+ * files import the registry directly, so a string-level mismatch between them
+ * is now structurally impossible (there is exactly one literal declaration of
+ * each marker, in packages/protocol/src/phases.js / types.js). What CAN still
+ * drift is the *phase-id list itself*: someone adds/removes/reorders a phase
+ * in bin/engine/phases.mjs's PHASES array without updating the registry's
+ * PHASE_IDS (or vice versa). This script catches that.
+ *
+ * Usage: node scripts/check-phase-registry-drift.mjs
+ * Exit codes: 0 = no drift, 1 = drift detected, 2 = usage/import error.
+ */
+
+import { fileURLToPath, pathToFileURL } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, "..");
+
+async function main() {
+  let registryModule;
+  let phasesModule;
+  try {
+    registryModule = await import(
+      pathToFileURL(path.join(REPO_ROOT, "packages/protocol/src/phases.js")).href
+    );
+  } catch (err) {
+    console.error(`ERROR: failed to import packages/protocol/src/phases.js: ${err.message}`);
+    process.exit(2);
+  }
+  try {
+    phasesModule = await import(
+      pathToFileURL(path.join(REPO_ROOT, "bin/engine/phases.mjs")).href
+    );
+  } catch (err) {
+    console.error(`ERROR: failed to import bin/engine/phases.mjs: ${err.message}`);
+    process.exit(2);
+  }
+
+  const registryIds = registryModule.PHASE_IDS;
+  const enginePhaseIds = (phasesModule.PHASES || []).map((p) => p.id);
+
+  if (!Array.isArray(registryIds)) {
+    console.error("ERROR: packages/protocol/src/phases.js did not export a PHASE_IDS array.");
+    process.exit(2);
+  }
+  if (!Array.isArray(enginePhaseIds) || enginePhaseIds.length === 0) {
+    console.error("ERROR: bin/engine/phases.mjs did not export a non-empty PHASES array.");
+    process.exit(2);
+  }
+
+  const drifted =
+    registryIds.length !== enginePhaseIds.length ||
+    registryIds.some((id, i) => id !== enginePhaseIds[i]);
+
+  if (drifted) {
+    console.error("ERROR: phase-id list drift detected between the registry and the engine.");
+    console.error(`  packages/protocol/src/phases.js PHASE_IDS: ${JSON.stringify(registryIds)}`);
+    console.error(`  bin/engine/phases.mjs PHASES ids:          ${JSON.stringify(enginePhaseIds)}`);
+    console.error("  Update packages/protocol/src/phases.js's PHASE_IDS to match bin/engine/phases.mjs's");
+    console.error("  PHASES array (or vice versa) so the two stay single-sourced. See forge#2378.");
+    process.exit(1);
+  }
+
+  // Also verify every registry marker entry that has a `completionMarker` or
+  // `completionLabel` field is a non-empty string — catches an accidental
+  // undefined/null slipping in (e.g. a typo'd RESERVED_TYPES key whose
+  // completionSentinel is null) which would otherwise fail silently at
+  // has(blob, undefined) → substring "undefined" never matches, masking a
+  // real bug as "phase never completes".
+  const emptyMarkers = [];
+  for (const [phaseId, entry] of Object.entries(registryModule.PHASE_MARKERS || {})) {
+    const marker = entry.completionMarker ?? entry.completionLabel;
+    if (typeof marker !== "string" || marker.length === 0) {
+      emptyMarkers.push(phaseId);
+    }
+  }
+  if (emptyMarkers.length > 0) {
+    console.error(
+      `ERROR: PHASE_MARKERS entries with no usable completionMarker/completionLabel: ${emptyMarkers.join(", ")}`
+    );
+    process.exit(1);
+  }
+
+  console.log("OK: phase-id list and marker registry are consistent (no drift detected).");
+  process.exit(0);
+}
+
+main();

package/scripts/check-spec-markers.sh

@@ -135,6 +135,7 @@ MARKER_REGISTRY="
   PUSH_BLOCKED_EMPTY_BRANCH
   PUSH_FAILED
   REMEDIATION
+  REREVIEW_SKIPPED
   REVIEW
   REVIEWER
   REVIEW_ROUTE

package/scripts/forge-run.sh

@@ -72,17 +72,48 @@ die() {
   local message="$2"
   local ts_val
   ts_val=$(ts)
-  # Escape double quotes in message for JSON embedding
-  message="${message//\"/\\\"}"
+  # Route through json_str for full JSON-string escaping (backslash, quote, and
+  # control characters) — die() is fed raw multi-line `gh` CLI stderr, which may
+  # contain backslashes and newlines that a quote-only escape would not handle.
+  message=$(json_str "$message")
   emit "{\"event\":\"error\",\"code\":\"${code}\",\"message\":\"${message}\",\"ts\":\"${ts_val}\"}"
   exit 1
 }
 
-# JSON-escape a string (double-quote characters only — sufficient for ASCII label/branch values)
+# JSON-escape a string: backslash, double-quote, and the full C0 control range
+# (U+0000-U+001F), per RFC 8259 section 7. Order matters:
+#   1. Backslash escaping runs first so a literal backslash becomes \\ before
+#      any other pass runs, avoiding double-escaping ambiguity.
+#   2. Double-quote next.
+#   3. The three named control escapes (\n, \r, \t) next, so they get their
+#      short two-character form rather than falling through to \u00XX.
+#   4. Every remaining C0 control byte (U+0000-U+001F, excluding \n/\r/\t
+#      already handled above) is escaped as \u00XX — bash's ${s//pat/rep}
+#      cannot loop over an arbitrary byte range in one substitution, so this
+#      is a bounded loop over hex 00-1F.
 json_str() {
   local s="$1"
   s="${s//\\/\\\\}"
   s="${s//\"/\\\"}"
+  s="${s//$'\n'/\\n}"
+  s="${s//$'\r'/\\r}"
+  s="${s//$'\t'/\\t}"
+  local i
+  for ((i = 0; i <= 31; i++)); do
+    # \n (10=0x0a), \r (13=0x0d), \t (9=0x09) already escaped above — skip them
+    # here so they keep their short named form instead of becoming \u00XX.
+    if [ "$i" -eq 9 ] || [ "$i" -eq 10 ] || [ "$i" -eq 13 ]; then
+      continue
+    fi
+    local hex
+    hex=$(printf '%02x' "$i")
+    local ctrl_char
+    printf -v ctrl_char '\\x%02x' "$i"
+    ctrl_char=$(printf "$ctrl_char")
+    if [[ "$s" == *"$ctrl_char"* ]]; then
+      s="${s//$ctrl_char/\\u00$hex}"
+    fi
+  done
   printf '%s' "$s"
 }
 
@@ -315,7 +346,7 @@ emit "{\"event\":\"phase_detail\",\"phase\":\"$(json_str "${PHASE}")\",\"lane\":
 # Event 3: action_required (only for non-terminal active phases)
 if [ -n "$ACTION" ]; then
   ts_val=$(ts)
-  ACTION_ESCAPED="${ACTION//\"/\\\"}"
+  ACTION_ESCAPED=$(json_str "${ACTION}")
   emit "{\"event\":\"action_required\",\"phase\":\"$(json_str "${PHASE}")\",\"action\":\"${ACTION_ESCAPED}\",\"ts\":\"${ts_val}\"}"
 fi