Construye un flujo de trabajo de control de calidad del código

import "dotenv/config";
import { Sandbox } from "e2b";

async function testConnection() {
  console.log(
    "Creando sandbox de E2B con servidores MCP de GitHub y SonarQube...\n",
  );

  const sbx = await Sandbox.betaCreate({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
      GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
      SONARQUBE_TOKEN: process.env.SONARQUBE_TOKEN!,
    },
    mcp: {
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
      },
      sonarqube: {
        org: process.env.SONARQUBE_ORG!,
        token: process.env.SONARQUBE_TOKEN!,
        url: "https://sonarcloud.io",
      },
    },
  });

  const mcpUrl = sbx.betaGetMcpUrl();
  const mcpToken = await sbx.betaGetMcpToken();

  console.log("¡Sandbox creado con éxito!");
  console.log(`URL de la pasarela MCP (MCP Gateway): ${mcpUrl}\n`);

  // Esperar a la inicialización de MCP
  await new Promise((resolve) => setTimeout(resolve, 1000));

  // Configurar Claude para usar la pasarela MCP
  console.log("Conectando Claude CLI a la pasarela MCP...");
  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  console.log("\n¡Conexión exitosa! Limpiando recursos...");
  await sbx.kill();
}

testConnection().catch(console.error);

npx tsx 01-test-connection.ts

import os
import asyncio
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def test_connection():
    print("Creando sandbox de E2B con servidores MCP de GitHub y SonarQube...\n")

    sbx = await AsyncSandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
            "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
            "SONARQUBE_TOKEN": os.getenv("SONARQUBE_TOKEN"),
        },
        mcp={
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
            "sonarqube": {
                "org": os.getenv("SONARQUBE_ORG"),
                "token": os.getenv("SONARQUBE_TOKEN"),
                "url": "https://sonarcloud.io",
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    print("¡Sandbox creado con éxito!")
    print(f"URL de la pasarela MCP (MCP Gateway): {mcp_url}\n")

    # Esperar a la inicialización de MCP
    await asyncio.sleep(1)

    # Configurar Claude para usar la pasarela MCP
    print("Conectando Claude CLI a la pasarela MCP...")
    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    print("\n¡Conexión exitosa! Limpiando recursos...")
    await sbx.kill()

if __name__ == "__main__":
    asyncio.run(test_connection())

python 01_test_connection.py

import "dotenv/config";
import { Sandbox } from "e2b";

async function listTools() {
  console.log("Creando sandbox...\n");

  const sbx = await Sandbox.betaCreate({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
      GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
      SONARQUBE_TOKEN: process.env.SONARQUBE_TOKEN!,
    },
    mcp: {
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
      },
      sonarqube: {
        org: process.env.SONARQUBE_ORG!,
        token: process.env.SONARQUBE_TOKEN!,
        url: "https://sonarcloud.io",
      },
    },
  });

  const mcpUrl = sbx.betaGetMcpUrl();
  const mcpToken = await sbx.betaGetMcpToken();

  // Esperar a la inicialización de MCP
  await new Promise((resolve) => setTimeout(resolve, 1000));

  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
  );

  console.log("\nDescubriendo herramientas de MCP disponibles...\n");

  const prompt =
    "Lista todas las herramientas MCP a las que tienes acceso. Para cada herramienta, muestra su nombre exacto y una breve descripción.";

  await sbx.commands.run(
    `echo '${prompt}' | claude -p --dangerously-skip-permissions`,
    { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
  );

  await sbx.kill();
}

listTools().catch(console.error);

npx tsx 02-list-tools.ts

import os
import asyncio
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def list_tools():
    print("Creando sandbox...\n")

    sbx = await AsyncSandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
            "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
            "SONARQUBE_TOKEN": os.getenv("SONARQUBE_TOKEN"),
        },
        mcp={
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
            "sonarqube": {
                "org": os.getenv("SONARQUBE_ORG"),
                "token": os.getenv("SONARQUBE_TOKEN"),
                "url": "https://sonarcloud.io",
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    # Esperar a la inicialización de MCP
    await asyncio.sleep(1)

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    print("\nDescubriendo herramientas de MCP disponibles...\n")

    prompt = "Lista todas las herramientas MCP a las que tienes acceso. Para cada herramienta, muestra su nombre exacto y una breve descripción."

    await sbx.commands.run(
        f"echo '{prompt}' | claude -p --dangerously-skip-permissions",
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    await sbx.kill()

if __name__ == "__main__":
    asyncio.run(list_tools())

python 02_list_tools.py

import "dotenv/config";
import { Sandbox } from "e2b";

async function testGitHub() {
  console.log("Creando sandbox...\n");

  const sbx = await Sandbox.betaCreate({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
      GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
    },
    mcp: {
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
      },
    },
  });

  const mcpUrl = sbx.betaGetMcpUrl();
  const mcpToken = await sbx.betaGetMcpToken();

  await new Promise((resolve) => setTimeout(resolve, 1000));

  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
  );

  const repoPath = `${process.env.GITHUB_OWNER}/${process.env.GITHUB_REPO}`;

  console.log(`\nListando issues en ${repoPath}...\n`);

  const prompt = `Usando las herramientas de MCP de GitHub, lista todos los issues abiertos en el repositorio "${repoPath}". Muestra el número de issue, título y autor para cada uno.`;

  await sbx.commands.run(
    `echo '${prompt.replace(/'/g, "'\\''")}' | claude -p --dangerously-skip-permissions`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  await sbx.kill();
}

testGitHub().catch(console.error);

npx tsx 03-test-github.ts

import os
import asyncio
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def test_github():
    print("Creando sandbox...\n")

    sbx = await AsyncSandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
            "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
        },
        mcp={
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    await asyncio.sleep(1)

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    repo_path = f"{os.getenv('GITHUB_OWNER')}/{os.getenv('GITHUB_REPO')}"

    print(f"\nListando issues en {repo_path}...\n")

    prompt = f'Usando las herramientas de MCP de GitHub, lista todos los issues abiertos en el repositorio "{repo_path}". Muestra el número de issue, título y autor para cada uno.'

    await sbx.commands.run(
        f"echo '{prompt}' | claude -p --dangerously-skip-permissions",
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    await sbx.kill()

if __name__ == "__main__":
    asyncio.run(test_github())

python 03_test_github.py

import "dotenv/config";
import { Sandbox } from "e2b";

async function testSonarQube() {
  console.log("Creando sandbox...\n");

  const sbx = await Sandbox.betaCreate({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
      GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
      SONARQUBE_TOKEN: process.env.SONARQUBE_TOKEN!,
    },
    mcp: {
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
      },
      sonarqube: {
        org: process.env.SONARQUBE_ORG!,
        token: process.env.SONARQUBE_TOKEN!,
        url: "https://sonarcloud.io",
      },
    },
  });

  const mcpUrl = sbx.betaGetMcpUrl();
  const mcpToken = await sbx.betaGetMcpToken();

  await new Promise((resolve) => setTimeout(resolve, 1000));

  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
  );

  console.log("\nAnalizando la calidad del código con SonarQube...\n");

  const prompt = `Usando las herramientas de MCP de SonarQube:
    1. Lista todos los proyectos en mi organización
    2. Para el primer proyecto, muestra:
    - Estado del quality gate (aprobado/fallido)
    - Número de bugs
    - Número de code smells
    - Número de vulnerabilidades de seguridad
    3. Lista los 5 problemas más críticos encontrados`;

  await sbx.commands.run(
    `echo '${prompt.replace(/'/g, "'\\''")}' | claude -p --dangerously-skip-permissions`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  await sbx.kill();
}

testSonarQube().catch(console.error);

npx tsx 04-test-sonarqube.ts

import os
import asyncio
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def test_sonarqube():
    print("Creando sandbox...\n")

    sbx = await AsyncSandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
            "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
            "SONARQUBE_TOKEN": os.getenv("SONARQUBE_TOKEN"),
        },
        mcp={
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
            "sonarqube": {
                "org": os.getenv("SONARQUBE_ORG"),
                "token": os.getenv("SONARQUBE_TOKEN"),
                "url": "https://sonarcloud.io",
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    await asyncio.sleep(1)

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    print("\nAnalizando la calidad del código con SonarQube...\n")

    prompt = """Usando las herramientas de MCP de SonarQube:
    1. Lista todos los proyectos en mi organización
    2. Para el primer proyecto, muestra:
    - Estado del quality gate (aprobado/fallido)
    - Número de bugs
    - Número de code smells
    - Número de vulnerabilidades de seguridad
    3. Lista los 5 problemas más críticos encontrados"""

    await sbx.commands.run(
        f"echo '{prompt}' | claude -p --dangerously-skip-permissions",
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    await sbx.kill()

if __name__ == "__main__":
    asyncio.run(test_sonarqube())

python 04_test_sonarqube.py

import "dotenv/config";
import { Sandbox } from "e2b";

async function fixCodeIssue() {
  console.log("Creando sandbox...\n");

  const sbx = await Sandbox.betaCreate({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
      GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
      SONARQUBE_TOKEN: process.env.SONARQUBE_TOKEN!,
    },
    mcp: {
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
      },
      sonarqube: {
        org: process.env.SONARQUBE_ORG!,
        token: process.env.SONARQUBE_TOKEN!,
        url: "https://sonarcloud.io",
      },
    },
  });

  const mcpUrl = sbx.betaGetMcpUrl();
  const mcpToken = await sbx.betaGetMcpToken();

  await new Promise((resolve) => setTimeout(resolve, 1000));

  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
  );

  const repoPath = `${process.env.GITHUB_OWNER}/${process.env.GITHUB_REPO}`;
  const branchName = `quality-fix-${Date.now()}`;

  console.log("\nCorrigiendo un problema de calidad de código...\n");

  const prompt = `Usando las herramientas de MCP de GitHub y SonarQube:

    1. Analiza la calidad del código en el repositorio "${repoPath}" con SonarQube
    2. Encuentra UN problema sencillo que se pueda corregir con total seguridad (como una variable no utilizada o un code smell)
    3. Crea una nueva rama llamada "${branchName}"
    4. Lee el archivo que contiene el problema usando las herramientas de GitHub
    5. Corrige el problema en el código
    6. Confirma (commit) la corrección en la nueva rama con un mensaje de commit claro

    Importante: Solo corrige problemas sobre los que tengas un 100% de seguridad. Explica qué estás corrigiendo y por qué.`;

  await sbx.commands.run(
    `echo '${prompt.replace(/'/g, "'\\''")}' | claude -p --dangerously-skip-permissions`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  console.log(`\nRevisa tu repositorio para ver la rama: ${branchName}`);

  await sbx.kill();
}

fixCodeIssue().catch(console.error);

npx tsx 05-fix-code-issue.ts

import os
import asyncio
import time
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def fix_code_issue():
    print("Creando sandbox...\n")

    sbx = await AsyncSandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
            "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
            "SONARQUBE_TOKEN": os.getenv("SONARQUBE_TOKEN"),
        },
        mcp={
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
            "sonarqube": {
                "org": os.getenv("SONARQUBE_ORG"),
                "token": os.getenv("SONARQUBE_TOKEN"),
                "url": "https://sonarcloud.io",
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    await asyncio.sleep(1)

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    repo_path = f"{os.getenv('GITHUB_OWNER')}/{os.getenv('GITHUB_REPO')}"
    branch_name = f"quality-fix-{int(time.time() * 1000)}"

    print("\nCorrigiendo un problema de calidad de código...\n")

    prompt = f"""Usando las herramientas de MCP de GitHub y SonarQube:

    1. Analiza la calidad del código en el repositorio "{repo_path}" con SonarQube
    2. Encuentra UN problema sencillo que se pueda corregir con total seguridad (como una variable no utilizada o un code smell)
    3. Crea una nueva rama llamada "{branch_name}"
    4. Lee el archivo que contiene el problema usando las herramientas de GitHub
    5. Corrige el problema en el código
    6. Confirma (commit) la corrección en la nueva rama con un mensaje de commit claro

    Importante: Solo corrige problemas sobre los que tengas un 100% de seguridad. Explica qué estás corrigiendo y por qué."""

    await sbx.commands.run(
        f"echo '{prompt}' | claude -p --dangerously-skip-permissions",
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    print(f"\n Revisa tu repositorio para ver la rama: {branch_name}")

    await sbx.kill()

if __name__ == "__main__":
    asyncio.run(fix_code_issue())

python 05_fix_code_issue.py

import "dotenv/config";
import { Sandbox } from "e2b";

async function qualityGatedPR() {
  console.log(
    "Creando sandbox para el flujo de trabajo de PR con control de calidad...\n",
  );

  const sbx = await Sandbox.betaCreate({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
      GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
      SONARQUBE_TOKEN: process.env.SONARQUBE_TOKEN!,
    },
    mcp: {
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
      },
      sonarqube: {
        org: process.env.SONARQUBE_ORG!,
        token: process.env.SONARQUBE_TOKEN!,
        url: "https://sonarcloud.io",
      },
    },
  });

  const mcpUrl = sbx.betaGetMcpUrl();
  const mcpToken = await sbx.betaGetMcpToken();

  await new Promise((resolve) => setTimeout(resolve, 1000));

  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
  );

  const repoPath = `${process.env.GITHUB_OWNER}/${process.env.GITHUB_REPO}`;
  const branchName = `quality-improvements-${Date.now()}`;

  console.log(
    "\nEjecutando el flujo de trabajo de PR con control de calidad...\n",
  );

  const prompt = `Eres un ingeniero de calidad de código. Usando las herramientas de MCP de GitHub y SonarQube:

    PASO 1: ANÁLISIS
    - Obtén el estado actual de la calidad del código de SonarQube para "${repoPath}"
    - Registra el número actual de bugs, code smells y vulnerabilidades
    - Identifica de 1 a 3 problemas que puedas corregir con seguridad

    PASO 2: CORREGIR PROBLEMAS
    - Crea la rama "${branchName}"
    - Para cada problema que vayas a corregir:
        * Lee el archivo que contiene el problema
        * Realiza la corrección
        * Confirma los cambios (commit) con un mensaje descriptivo
    - Solo corrige problemas si tienes un 100% de seguridad de que la corrección es correcta

    PASO 3: VERIFICACIÓN
    - Tras tus correcciones, comprueba si las métricas de calidad mejorarían
    - Calcula: ¿reduciría esto los bugs, smells o vulnerabilidades?

    PASO 4: CONTROL DE CALIDAD (QUALITY GATE)
    - Solo continúa si tus cambios mejoran la calidad
    - Si la calidad no mejora, explica por qué y detén el proceso

    PASO 5: CREAR PR (solo si pasa el control de calidad)
    - Crea un pull request desde "${branchName}" hacia la rama main
    - Título: "Mejoras de calidad: [describe qué has corregido]"
    - La descripción debe incluir:
        * Qué problemas has corregido
        * Métricas de calidad antes y después
        * Por qué estas correcciones mejoran la calidad del código
    - Agrega un comentario con el análisis detallado de SonarQube

    Sé minucioso y explica tus decisiones en cada paso.`;

  await sbx.commands.run(
    `echo '${prompt.replace(/'/g, "'\\''")}' | claude -p --dangerously-skip-permissions`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  console.log(
    `\n ¡Flujo de trabajo completado! Revisa ${repoPath} para ver la nueva pull request.`,
  );

  await sbx.kill();
}

qualityGatedPR().catch(console.error);

npx tsx 06-quality-gated-pr.ts

import os
import asyncio
import time
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def quality_gated_pr():
    print("Creando sandbox para el flujo de trabajo de PR con control de calidad...\n")

    sbx = await AsyncSandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
            "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
            "SONARQUBE_TOKEN": os.getenv("SONARQUBE_TOKEN"),
        },
        mcp={
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
            "sonarqube": {
                "org": os.getenv("SONARQUBE_ORG"),
                "token": os.getenv("SONARQUBE_TOKEN"),
                "url": "https://sonarcloud.io",
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    await asyncio.sleep(1)

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer ${mcp_token}"',
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    repo_path = f"{os.getenv('GITHUB_OWNER')}/{os.getenv('GITHUB_REPO')}"
    branch_name = f"quality-improvements-{int(time.time() * 1000)}"

    print("\nEjecutando el flujo de trabajo de PR con control de calidad...\n")

    prompt = f"""Eres un ingeniero de calidad de código. Usando las herramientas de MCP de GitHub y SonarQube:

    PASO 1: ANÁLISIS
    - Obtén el estado actual de la calidad del código de SonarQube para "{repo_path}"
    - Registra el número actual de bugs, code smells y vulnerabilidades
    - Identifica de 1 a 3 problemas que puedas corregir con seguridad

    PASO 2: CORREGIR PROBLEMAS
    - Crea la rama "${branch_name}"
    - Para cada problema que vayas a corregir:
        Lee el archivo que contiene el problema
        Realiza la corrección
        Confirma los cambios (commit) con un mensaje descriptivo
    - Solo corrige problemas si tienes un 100 por ciento de seguridad de que la corrección es correcta

    PASO 3: VERIFICACIÓN
    - Tras tus correcciones, comprueba si las métricas de calidad mejorarían
    - Calcula: ¿reduciría esto los bugs, smells o vulnerabilidades?

    PASO 4: CONTROL DE CALIDAD (QUALITY GATE)
    - Solo continúa si tus cambios mejoran la calidad
    - Si la calidad no mejora, explica por qué y detén el proceso

    PASO 5: CREAR PR (solo si pasa el control de calidad)
    - Crea un pull request desde "${branch_name}" hacia la rama main
    - Título: "Mejoras de calidad: [describe qué has corregido]"
    - La descripción debe incluir:
        Qué problemas has corregido
        Métricas de calidad antes y después
        Por qué estas correcciones mejoran la calidad del código
    - Agrega un comentario con el análisis detallado de SonarQube

    Sé minucioso y explica tus decisiones en cada paso."""

    await sbx.commands.run(
        f"echo '{prompt.replace(chr(39), chr(39) + chr(92) + chr(39) + chr(39))}' | claude -p --dangerously-skip-permissions",
        timeout=0,
        on_stdout=print,
        on_stderr=print,
    )

    print(f"\n ¡Flujo de trabajo completado! Revisa {repo_path} para ver la nueva pull request.")

    await sbx.kill()

if __name__ == "__main__":
    asyncio.run(quality_gated_pr())

python 06_quality_gated_pr.py

import "dotenv/config";
import { Sandbox } from "e2b";

async function robustWorkflow() {
  let sbx: Sandbox | undefined;

  try {
    console.log("Creando sandbox...\n");

    sbx = await Sandbox.betaCreate({
      envs: {
        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
        GITHUB_TOKEN: process.env.GITHUB_TOKEN!,
        SONARQUBE_TOKEN: process.env.SONARQUBE_TOKEN!,
      },
      mcp: {
        githubOfficial: {
          githubPersonalAccessToken: process.env.GITHUB_TOKEN!,
        },
        sonarqube: {
          org: process.env.SONARQUBE_ORG!,
          token: process.env.SONARQUBE_TOKEN!,
          url: "https://sonarcloud.io",
        },
      },
    });

    const mcpUrl = sbx.betaGetMcpUrl();
    const mcpToken = await sbx.betaGetMcpToken();

    await new Promise((resolve) => setTimeout(resolve, 1000));

    await sbx.commands.run(
      `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
      { timeoutMs: 0, onStdout: console.log, onStderr: console.log },
    );

    const repoPath = `${process.env.GITHUB_OWNER}/${process.env.GITHUB_REPO}`;

    console.log("\nEjecutando flujo de trabajo con manejo de errores...\n");

    const prompt = `Ejecuta un flujo de trabajo de mejora de calidad para "${repoPath}".

    REGLAS DE MANEJO DE ERRORES:
    1. Si SonarQube es inaccesible, explica el error y detén el proceso de forma controlada
    2. Si falla la API de GitHub, reintenta una vez, luego explica y detén el proceso
    3. Si no se encuentran problemas corregibles, explica por qué y sal (esto no es un error)
    4. Si las modificaciones de archivos fallan, explica qué archivo y por qué
    5. En cada paso, comprueba si hay errores antes de continuar

    Ejecuta el flujo de trabajo y maneja cualquier error que encuentres de manera profesional.`;

    await sbx.commands.run(
      `echo '${prompt.replace(/'/g, "'\\''")}' | claude -p --dangerously-skip-permissions`,
      {
        timeoutMs: 0,
        onStdout: console.log,
        onStderr: console.log,
      },
    );

    console.log("\n Flujo de trabajo completado");
  } catch (error) {
    const err = error as Error;
    console.error("\n El flujo de trabajo falló:", err.message);

    if (err.message.includes("403")) {
      console.error(
        "\n Comprueba que tu cuenta de E2B tenga acceso a la pasarela MCP",
      );
    } else if (err.message.includes("401")) {
      console.error("\n Comprueba que tus tokens de API sean válidos");
    } else if (err.message.includes("Credit balance")) {
      console.error("\n Comprueba el saldo de créditos de tu API de Anthropic");
    }

    process.exit(1);
  } finally {
    if (sbx) {
      console.log("\n Limpiando sandbox...");
      await sbx.kill();
    }
  }
}

robustWorkflow().catch(console.error);

npx tsx 07-robust-workflow.ts

import os
import asyncio
import sys
from dotenv import load_dotenv
from e2b import AsyncSandbox

load_dotenv()

async def robust_workflow():
    sbx = None

    try:
        print("Creando sandbox...\n")

        sbx = await AsyncSandbox.beta_create(
            envs={
                "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
                "GITHUB_TOKEN": os.getenv("GITHUB_TOKEN"),
                "SONARQUBE_TOKEN": os.getenv("SONARQUBE_TOKEN"),
            },
            mcp={
                "githubOfficial": {
                    "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
                },
                "sonarqube": {
                    "org": os.getenv("SONARQUBE_ORG"),
                    "token": os.getenv("SONARQUBE_TOKEN"),
                    "url": "https://sonarcloud.io",
                },
            },
        )

        mcp_url = sbx.beta_get_mcp_url()
        mcp_token = await sbx.beta_get_mcp_token()

        await asyncio.sleep(1)

        await sbx.commands.run(
            f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
            timeout=0,
            on_stdout=print,
            on_stderr=print,
        )

        repo_path = f"{os.getenv('GITHUB_OWNER')}/{os.getenv('GITHUB_REPO')}"

        print("\nEjecutando flujo de trabajo con manejo de errores...\n")

        prompt = f"""Ejecuta un flujo de trabajo de mejora de calidad para "{repo_path}".

        REGLAS DE MANEJO DE ERRORES:
        1. Si SonarQube es inaccesible, explica el error y detén el proceso de forma controlada
        2. Si falla la API de GitHub, reintenta una vez, luego explica y detén el proceso
        3. Si no se encuentran problemas corregibles, explica por qué y sal (esto no es un error)
        4. Si las modificaciones de archivos fallan, explica qué archivo y por qué
        5. En cada paso, comprueba si hay errores antes de continuar

        Ejecuta el flujo de trabajo y maneja cualquier error que encuentres de manera profesional."""

        await sbx.commands.run(
            f"echo '{prompt}' | claude -p --dangerously-skip-permissions",
            timeout=0,
            on_stdout=print,
            on_stderr=print,
        )

        print("\n Flujo de trabajo completado")

    except Exception as error:
        print(f"\n✗ El flujo de trabajo falló: {str(error)}")

        error_msg = str(error)
        if "403" in error_msg:
            print("\n Comprueba que tu cuenta de E2B tenga acceso a la pasarela MCP")
        elif "401" in error_msg:
            print("\n Comprueba que tus tokens de API sean válidos")
        elif "Credit balance" in error_msg:
            print("\n Comprueba el saldo de créditos de tu API de Anthropic")

        sys.exit(1)

    finally:
        if sbx:
            print("\n Limpiando sandbox...")
            await sbx.kill()

if __name__ == "__main__":
    asyncio.run(robust_workflow())

python 07_robust_workflow.py