Ir al contenido principal
Español— Elegir un idioma
Menú

Integración con CI/CD

Lección 14 de 20 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Codex en tu canal de entrega
  2. La acción oficial de GitHub
  3. Automatiza la revisión de cada PR
  4. Rellena las pruebas faltantes
  5. Reacciona ante un fallo de CI
  6. Llama a Codex desde tus propios scripts
  7. Mapea los puntos de integración
  8. Mantén el control de la automatización
  9. Puntos clave

Actualizado el 3 de noviembre de 2026 según las páginas Codex GitHub Action y Non-interactive mode de la documentación de Codex: las entradas heredadas task, criteria, scope, framework y api-key no existen en openai/codex-action@v1 (sustituidas por openai-api-key, prompt/prompt-file, sandbox, output-file, etc.). La acción no publica comentarios por sí sola. La expresión == failure sin comillas no funcionaba. La bandera --apply se sustituye por codex exec --sandbox workspace-write. Fuentes: Codex GitHub Action · Non-interactive mode.

Codex en tu canal de entrega

Codex no se limita a las tareas que un desarrollador lanza manualmente. Se integra en tus canalizaciones de CI/CD para automatizar tareas de desarrollo en cada fase del ciclo de entrega. Este cambio va más allá del ahorro de tiempo: la revisión de código, la generación de pruebas y la corrección de errores dejan de depender de la disciplina individual para convertirse en pasos de la canalización activados por eventos, no por la buena voluntad del viernes por la tarde.

La acción oficial de GitHub

OpenAI publica una acción, openai/codex-action@v1, que instala la CLI, inicia el proxy de la API de Responses cuando proporcionas una clave y ejecuta codex exec con los permisos que establezcas. Sus entradas principales son:

EntradaFunción
openai-api-keyLa clave, almacenada como un secreto de GitHub (por ejemplo OPENAI_API_KEY)
prompt o prompt-fileLa instrucción en línea o un archivo en el repositorio; uno u otro, no ambos
sandboxread-only, workspace-write o danger-full-access: elige el ámbito más restringido que sea suficiente
model, effortEl modelo y el esfuerzo de razonamiento; si están vacíos, se aplican los valores predeterminados
output-fileGuarda el mensaje final de Codex para pasos posteriores
codex-argsOpciones adicionales para codex exec
safety-strategyPor defecto es drop-sudo, que elimina sudo antes de la ejecución y protege los secretos en memoria

La acción se ejecuta en runners de Linux o macOS (en Windows necesitas safety-strategy: unsafe) tras un actions/checkout del código. No publica nada por sí sola: expone el último mensaje de Codex en la salida final-message, que un paso posterior puede publicar.

Automatiza la revisión de cada PR

El siguiente flujo de trabajo sigue la estructura del ejemplo oficial: un primer trabajo ejecuta Codex en modo de solo lectura y un segundo, con permisos de escritura en las PR, publica el resultado como un comentario. Tus criterios van en el prompt.

# .github/workflows/codex-review.yml
name: Revisión de Codex
on:
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  codex:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    outputs:
      final_message: ${{ steps.run_codex.outputs.final-message }}
    steps:
      - uses: actions/checkout@v5
        with:
          ref: refs/pull/${{ github.event.pull_request.number }}/merge
          fetch-depth: 0
          persist-credentials: false
      - name: Ejecutar Codex
        id: run_codex
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          sandbox: read-only
          prompt: |
            Revisa los cambios en esta pull request frente a la rama base.
            Prioridades: seguridad (inyecciones, falta de autenticación), rendimiento
            (consultas N+1), tipos (sin any), pruebas (cobertura de los cambios).
            Cita los archivos y líneas implicados.

  post_feedback:
    runs-on: ubuntu-latest
    needs: codex
    if: needs.codex.outputs.final_message != ''
    permissions:
      issues: write
      pull-requests: write
    steps:
      - uses: actions/github-script@v7
        with:
          github-token: ${{ github.token }}
          script: |
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.pull_request.number,
              body: process.env.CODEX_FINAL_MESSAGE,
            });
        env:
          CODEX_FINAL_MESSAGE: ${{ needs.codex.outputs.final_message }}

El prompt merece más atención que el resto del archivo: transforma una revisión genérica en una que se ajusta a tus prioridades. Puedes moverlo fuera del YAML a un archivo versionado, por ejemplo .github/codex/prompts/review.md, y referenciarlo mediante prompt-file. Para una revisión simple de PR, la revisión automática integrada en GitHub (lección 11) evita tener que escribir un flujo de trabajo completo.

Rellena las pruebas faltantes

Un segundo flujo de trabajo aborda el código entregado sin pruebas. Aquí Codex necesita escribir en el espacio de trabajo (sandbox: workspace-write), pero el resultado sigue siendo una propuesta: el flujo de trabajo lo convierte en un parche descargable que el desarrollador revisa y aplica él mismo.

# .github/workflows/codex-tests.yml
name: Generación de pruebas con Codex
on:
  pull_request:
    types: [opened]

jobs:
  generate-tests:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Generar pruebas faltantes
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          sandbox: workspace-write
          prompt: |
            Para cada archivo modificado en esta pull request que carezca de pruebas,
            escribe las pruebas faltantes usando Vitest y luego ejecútalas.
      - name: Guardar las pruebas propuestas como un parche
        run: git diff > codex-tests.patch
      - uses: actions/upload-artifact@v4
        with:
          name: codex-tests
          path: codex-tests.patch

El desarrollador mantiene el control de principio a fin: descarga el parche, lo adapta o lo rechaza. La documentación de la acción recomienda ejecutar Codex al final de un trabajo para que los pasos posteriores no hereden cambios inesperados; aquí, el único paso siguiente solo lee el diff.

Reacciona ante un fallo de CI

El tercer flujo de trabajo se engancha al resultado de otro flujo de trabajo. Cuando la CI falla, Codex vuelve a ejecutar las pruebas en la confirmación relevante, busca la causa y genera un diagnóstico sin empujar nada:

# .github/workflows/codex-diagnose.yml
name: Diagnóstico de CI con Codex
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]

jobs:
  diagnose:
    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v5
        with:
          ref: ${{ github.event.workflow_run.head_sha }}
          persist-credentials: false
      - name: Analizar el fallo de CI
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          sandbox: workspace-write
          output-file: codex-diagnostic.md
          prompt: |
            La CI falló en esta confirmación. Ejecuta las pruebas, identifica la causa del fallo
            y propone una corrección sin modificar la lógica de las pruebas.
      - uses: actions/upload-artifact@v4
        with:
          name: codex-diagnostic
          path: codex-diagnostic.md

Este caso exige la máxima precaución. A veces una prueba fallida señala un defecto de diseño, y una corrección automática plausible puede hacer que desaparezca de la pantalla sin resolverlo: la CI vuelve a ponerse en verde, pero el problema persiste. De ahí la elección de un diagnóstico para revisar en lugar de una confirmación empujada automáticamente.

Llama a Codex desde tus propios scripts

Fuera de GitHub Actions, codex exec encaja en cualquier script. Por defecto, se ejecuta en un sandbox de solo lectura; dale permiso de escritura con --sandbox workspace-write cuando la tarea lo requiera. El siguiente gancho pre-commit marca los archivos TypeScript sin pruebas y genera uno al vuelo:

#!/bin/bash
# Script de gancho pre-commit

# Comprueba que los archivos modificados tengan pruebas
CHANGED=$(git diff --cached --name-only --diff-filter=ACM | grep '\.ts$' | grep -v '\.test\.ts$')
for file in $CHANGED; do
  test_file="${file%.ts}.test.ts"
  if [ ! -f "$test_file" ]; then
    echo "⚠️ Archivo sin prueba: $file"
    codex exec --sandbox workspace-write "Escribe pruebas para $file en $test_file"
    git add "$test_file"
  fi
done

En CI, codex exec reutiliza la autenticación guardada por defecto; en su lugar, proporciona las credenciales explícitamente usando una clave de API dedicada.

Mapea los puntos de integración

Una vez que tienes estos bloques de construcción, piensa en términos de eventos del ciclo de entrega en lugar de archivos YAML. Los cinco escenarios siguientes cubren los casos más comunes:

Fase de CI/CDTarea de CodexDisparador
PR abiertaRevisión automáticapull_request opened
PR abiertaGeneración de pruebaspull_request opened
Fallo de CIAnálisis y correcciónworkflow_run failure
LanzamientoChangelog automáticotag push
Actualización de dependenciasComprobación de compatibilidadDependabot PR

Mantén el control de la automatización

Una integración con CI/CD se ejecuta sin supervisión, lo que exige algunas precauciones básicas. Limita quién puede disparar los flujos de trabajo; por defecto, solo los usuarios con permisos de escritura pueden ejecutar la acción (usa allow-users, allow-bots para ampliarlo explícitamente). Saneiza las entradas procedentes de PR, mensajes de confirmación o incidencias antes de pasarlas a Codex: el texto oculto puede contener una inyección de prompt. Usa una clave de API dedicada con permisos mínimos en lugar de la clave personal de un desarrollador, que se llevará consigo al dejar la empresa, rompiendo tus canalizaciones. Nunca fusiones automáticamente una corrección producida por Codex: la revisión humana sigue siendo la puerta de entrada a la rama principal. Establece límites explícitos en el número de tareas por día y el coste máximo para que un bucle de corrección mal configurado no queme tu presupuesto mensual durante la noche. Por último, mantén un historial de las tareas de Codex ejecutadas en CI: el día que aparezca un comportamiento inesperado en producción, estos registros serán tu única pista sólida.

Puntos clave

  • Codex se integra en GitHub Actions y otros sistemas de CI/CD
  • La revisión automática en las PR es el caso de uso más común
  • Codex puede corregir fallos de CI automáticamente
  • La CLI permite la integración en scripts personalizados
  • Mantén siempre a un humano en el bucle para validar las correcciones