@saulwade/swl-ses 2.6.1 → 2.8.0

package/scripts/lib/w4-harness-bajo-prueba.js

@@ -0,0 +1,155 @@
+'use strict';
+
+/**
+ * Contrato de aislamiento `swl-ses` ↔ `swl-eval` (ADR-0053, F32/T-01).
+ *
+ * Este módulo expone la MAQUINARIA DEL JUEZ para el contrato: la superficie
+ * pura `validateCertificationRequest()` (sin filesystem, sin red, sin reloj de
+ * pared) que el juez externo de `swl-eval` invoca:
+ *
+ *   - `validateCertificationRequest()`: valida el `CertificationRequest`
+ *     (schemas/w4-certification-request.schema.json) que `swl-ses` publica
+ *     con el candidato, la matriz runtime/OS/modelo y el punto de entrada
+ *     del contrato — nunca el corpus ni el veredicto (eso vive en T-02..T-06).
+ *
+ * La superficie del CANDIDATO (`runHarnessBajoPrueba`) vive ahora en
+ * `w4-superficie-candidato.js` (escisión por ADR-0056:100-106 y
+ * `DT-MOTOR-REPLAY-SRP-MUTACIONES-PINEADAS`): el juez la resuelve DESDE EL
+ * TARBALL, mientras que este validador es maquinaria del juez pineada. No
+ * mezclar ambas responsabilidades en un mismo módulo es lo que evita que el
+ * juez arrastre la superficie del candidato desde su copia pineada.
+ *
+ * Modelo de amenaza que T-13 (red-team del aislamiento, fuera de esta
+ * tarea) va a probar activamente contra el mecanismo real de ADR-0053 —
+ * un resumen de una línea por vector, detalle completo en ADR-0053 § Contrato
+ * y .planning/fases/32-PLAN.md § Tanda W4-I:
+ *
+ *   1. leer el corpus con las credenciales locales del maker disponibles.
+ *   2. reproducir el corpus determinista sin conocer la semilla secreta.
+ *   3. exfiltrar un secret editando el workflow de `swl-eval` en una rama
+ *      no protegida del mismo repo (incluye `workflow_dispatch` manual).
+ *   4. forjar un `CertificationVerdict`: sin firma protegida, o con firma
+ *      Sigstore genuina emitida desde un repo/workflow distinto al fijado.
+ *   5. usar una credencial local del maker para reconfigurar branch
+ *      protection o auto-aprobar un deployment del environment `certificacion`.
+ *   6. exfiltrar el corpus vía la red o la credencial de modelo del propio
+ *      candidato durante el replay real (egress fuera del allowlist, o uso
+ *      de la cuenta de modelo personal del maker en vez de la dedicada H-10).
+ *
+ * Este validador NO mitiga ninguno de los seis vectores por sí solo — es
+ * puro y no tiene acceso al corpus real, al veredicto firmado ni a ninguna
+ * credencial. Su única responsabilidad es la validación estructural del
+ * contrato (REQ-32-01).
+ */
+
+
+const SCHEMA_VERSION = '1.0.0';
+const SHA256 = /^[a-f0-9]{64}$/u;
+const GIT_SHA = /^[a-f0-9]{40}$/u;
+const IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const RELATIVE_PATH = /^(?!\/)(?![A-Za-z]:)(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._/-]+$/u;
+const RUNTIMES_CORE3 = new Set(['claude-code', 'codex-cli', 'gemini-cli']);
+const OS_IDS = new Set(['win32', 'linux', 'darwin']);
+const REQUEST_KEYS = ['kind', 'schemaVersion', 'candidate', 'matrix', 'entryPoint'];
+const CANDIDATE_KEYS = ['commit', 'tarballDigest'];
+const ENTRY_POINT_KEYS = ['module', 'function'];
+const MATRIX_ENTRY_KEYS = ['runtime', 'os', 'model'];
+
+function crearError(codigo, mensaje) {
+  const error = new Error(mensaje);
+  error.codigo = codigo;
+  return error;
+}
+
+function fallar(codigo, mensaje) {
+  throw crearError(codigo, mensaje);
+}
+
+function esObjetoPlano(valor) {
+  return Boolean(valor) && typeof valor === 'object' && !Array.isArray(valor)
+    && Object.getPrototypeOf(valor) === Object.prototype
+    && Object.getOwnPropertySymbols(valor).length === 0;
+}
+
+function validarClaves(valor, esperadas, etiqueta) {
+  if (!esObjetoPlano(valor)) fallar('CERTIFICATION_REQUEST_INVALID', `${etiqueta} inválido`);
+  const actuales = Object.keys(valor).sort();
+  const objetivo = [...esperadas].sort();
+  if (JSON.stringify(actuales) !== JSON.stringify(objetivo)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', `${etiqueta} inválido`);
+  }
+}
+
+function validarCandidate(candidate) {
+  validarClaves(candidate, CANDIDATE_KEYS, 'candidate');
+  if (typeof candidate.commit !== 'string' || !GIT_SHA.test(candidate.commit)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'candidate.commit inválido');
+  }
+  if (typeof candidate.tarballDigest !== 'string' || !SHA256.test(candidate.tarballDigest)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'candidate.tarballDigest inválido');
+  }
+}
+
+function validarMatrixEntry(entry) {
+  validarClaves(entry, MATRIX_ENTRY_KEYS, 'matrix[]');
+  if (typeof entry.runtime !== 'string' || !RUNTIMES_CORE3.has(entry.runtime)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'matrix[].runtime inválido');
+  }
+  if (typeof entry.os !== 'string' || !OS_IDS.has(entry.os)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'matrix[].os inválido');
+  }
+  if (typeof entry.model !== 'string' || !IDENTIFICADOR.test(entry.model)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'matrix[].model inválido');
+  }
+}
+
+function validarMatrix(matrix) {
+  if (!Array.isArray(matrix) || matrix.length === 0) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'matrix inválida');
+  }
+  matrix.forEach(validarMatrixEntry);
+  const firmas = new Set(matrix.map((entry) => `${entry.runtime}|${entry.os}|${entry.model}`));
+  if (firmas.size !== matrix.length) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'matrix con entradas duplicadas');
+  }
+}
+
+function validarEntryPoint(entryPoint) {
+  validarClaves(entryPoint, ENTRY_POINT_KEYS, 'entryPoint');
+  if (typeof entryPoint.module !== 'string' || !RELATIVE_PATH.test(entryPoint.module)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'entryPoint.module inválido');
+  }
+  if (typeof entryPoint.function !== 'string' || !IDENTIFICADOR.test(entryPoint.function)) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'entryPoint.function inválido');
+  }
+}
+
+/**
+ * Valida un `CertificationRequest` (ADR-0053 § Contrato) sin efectos: no lee
+ * disco, no hace red, no consulta el reloj. Lanza CERTIFICATION_REQUEST_INVALID
+ * si el valor no cumple `schemas/w4-certification-request.schema.json`;
+ * retorna un valor deeply frozen equivalente si es válido.
+ */
+function validateCertificationRequest(value) {
+  validarClaves(value, REQUEST_KEYS, 'certificationRequest');
+  if (value.kind !== 'swl-certification-request') {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'kind inválido');
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    fallar('CERTIFICATION_REQUEST_INVALID', 'schemaVersion inválida');
+  }
+  validarCandidate(value.candidate);
+  validarMatrix(value.matrix);
+  validarEntryPoint(value.entryPoint);
+  return Object.freeze({
+    kind: value.kind,
+    schemaVersion: value.schemaVersion,
+    candidate: Object.freeze({ ...value.candidate }),
+    matrix: Object.freeze(value.matrix.map((entry) => Object.freeze({ ...entry }))),
+    entryPoint: Object.freeze({ ...value.entryPoint }),
+  });
+}
+
+module.exports = {
+  validateCertificationRequest,
+};

package/scripts/lib/w4-matriz-combos.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Fuente de verdad de la matriz OS×runtime Core-3 para el CI matricial de
+ * replay del juez (F32/T-08, 32-PLAN.md § Tanda W4-J, REQ-32-08).
+ *
+ * Dos dominios de identificador de "sistema operativo" coexisten en este
+ * repositorio y este módulo usa DELIBERADAMENTE el de GitHub Actions, no el
+ * de Node.js:
+ *   - `OS_IDS` en w4-corpus-generador.js / w4-motor-replay.js son
+ *     identificadores de `os.platform()` (`win32`/`linux`/`darwin`): el
+ *     sistema operativo del PROCESO Node que corre el candidato dentro del
+ *     replay.
+ *   - `OS_MATRIZ` de este módulo son etiquetas de runner de GitHub Actions
+ *     (`windows-latest`/`ubuntu-latest`/`macos-latest`): el runner que
+ *     EJECUTA el job de CI. Mezclar ambos dominios produciría un YAML con
+ *     `runs-on: win32`, que GitHub Actions rechaza — nunca traducir de uno
+ *     a otro en este módulo.
+ *
+ * `RUNTIMES_CORE3` sí es el MISMO valor que el `Set` interno (no exportado)
+ * declarado en w4-corpus-generador.js y w4-motor-replay.js. Se redeclara
+ * aquí como array congelado porque ninguno de esos dos módulos lo exporta;
+ * `tests/lib/w4-matriz.test.js` ancla el valor contra ambos para detectar
+ * drift si alguno de los tres cambia sin los otros.
+ */
+
+const OS_MATRIZ = Object.freeze(['windows-latest', 'ubuntu-latest', 'macos-latest']);
+const RUNTIMES_CORE3 = Object.freeze(['claude-code', 'codex-cli', 'gemini-cli']);
+
+function congelarProfundo(valor) {
+  if (valor && typeof valor === 'object' && !Object.isFrozen(valor)) {
+    Object.values(valor).forEach(congelarProfundo);
+    Object.freeze(valor);
+  }
+  return valor;
+}
+
+/**
+ * Producto cruzado `OS_MATRIZ × RUNTIMES_CORE3`: 9 combinaciones explícitas
+ * (sin `exclude`), en orden estable (OS externo, runtime interno). El
+ * resultado y cada elemento quedan deeply frozen — el gate "ninguna
+ * combinación oculta o implícitamente omitida" (32-PLAN.md § Tanda W4-J)
+ * depende de que nadie pueda mutar la lista tras generarla.
+ */
+function combos() {
+  const resultado = [];
+  for (const os of OS_MATRIZ) {
+    for (const runtime of RUNTIMES_CORE3) {
+      resultado.push({ os, runtime });
+    }
+  }
+  return congelarProfundo(resultado);
+}
+
+module.exports = { OS_MATRIZ, RUNTIMES_CORE3, combos };