Cycode

oficial

Mejora la seguridad en tu ciclo de desarrollo mediante escaneo SAST, SCA, Secretos e IaC con Cycode.

¿Qué puedes hacer con Cycode MCP?

Buscar secretos — Pide al asistente que busque secretos codificados directamente en archivos o directorios mediante cycode_secret_scan.
Buscar problemas de SCA — Solicita un análisis de Software Composition Analysis para detectar vulnerabilidades y problemas de licencias mediante cycode_sca_scan.
Buscar errores de configuración de IaC — Pide al asistente que compruebe si hay errores de configuración en la infraestructura como código mediante cycode_iac_scan.
Buscar problemas de SAST — Ejecuta un análisis de Static Application Security Testing para detectar problemas de calidad del código y fallos de seguridad mediante cycode_sast_scan.
Comprobar el estado de la CLI — Solicita la versión de Cycode CLI, el estado de autenticación y los detalles de configuración mediante cycode_status.

Documentación

Guía del usuario de Cycode CLI

Cycode Command Line Interface (CLI) es una aplicación que puedes instalar localmente para analizar tus repositorios en busca de secretos, errores de configuración de infraestructura como código, vulnerabilidades de análisis de composición de software y problemas de pruebas de seguridad de aplicaciones estáticas.

Esta guía te explica cómo instalarla y usarla.

Tabla de contenido

Requisitos previos
Instalación
1. Instalar Cycode CLI
2. Instalar el hook de pre-commit
Comandos de Cycode CLI
Certificados y proxies
Comando MCP
Comando Platform
Protecciones de IA
1. Datos recopilados por las protecciones de IA
Comando Scan
Comando Report
1. Generar un informe SBOM
Comando Import
Registros de análisis
Ayuda de sintaxis

Requisitos previos

La aplicación Cycode CLI requiere Python versión 3.10 o posterior.
Usa el comando cycode auth para autenticarte en Cycode con la CLI
- Como alternativa, puedes obtener un Client ID y una Client Secret Key de Cycode siguiendo los pasos detallados en las páginas Token de cuenta de servicio y Token de acceso personal, que explican cómo obtener estos valores.

Instalación

Los siguientes pasos de instalación se aplican tanto a los sistemas operativos Windows como a UNIX / Linux.

[!NOTE] Los siguientes pasos presuponen el uso de python3 y pip3 para los comandos relacionados con Python; sin embargo, algunos sistemas pueden usar en su lugar los comandos python y pip, según la configuración de tu entorno de Python.

Instalar Cycode CLI

Para instalar la aplicación Cycode CLI en tu equipo local, sigue estos pasos:

Abre la línea de comandos o la aplicación de terminal.
Ejecuta uno de los siguientes comandos:
- Para instalar desde PyPI:
```
pip3 install cycode
```
- Para instalar desde Homebrew:
```
brew install cycode
```
- Para instalar desde GitHub Releases, ve a la página y descarga el ejecutable correspondiente a tu sistema operativo y arquitectura; luego, ejecuta el siguiente comando:
```
cd /path/to/downloaded/cycode-cli
chmod +x cycode
./cycode
```
Por último, autentica la CLI. Hay tres métodos para configurar el ID de cliente y las credenciales de Cycode (el secreto de cliente o el token de ID de OIDC):
- cycode auth (Recomendado)
- cycode configure
- Agrégalos a tus variables de entorno

Usar el comando Auth

[!NOTE] Este es el método recomendado para configurar tu equipo local para que se autentique con Cycode CLI.

Escribe el siguiente comando en la ventana de terminal o línea de comandos:

cycode auth
Aparecerá una ventana del navegador que te pedirá que inicies sesión en Cycode (como se muestra a continuación):
Introduce tus credenciales de inicio de sesión en esta página e inicia sesión.
Se te redirigirá a la página siguiente, donde se te pedirá que elijas el grupo empresarial con el que quieres autorizar Cycode (si corresponde):

[!NOTE] Este será el método predeterminado para autenticarte con Cycode CLI.
Haz clic en el botón Allow para autorizar Cycode CLI en el grupo empresarial seleccionado.
Cuando se complete el proceso, verás la siguiente pantalla si la selección se realizó correctamente:
Al cerrar la ventana del navegador, verás lo siguiente en la ventana de terminal o línea de comandos:

Successfully logged into cycode

Usar el comando Configure

[!NOTE] Si ya configuraste tu Client ID y Client Secret de Cycode mediante las variables de entorno de Linux o Windows, esas credenciales tendrán prioridad sobre este método.

Escribe el siguiente comando en la ventana de terminal o línea de comandos:
```
cycode configure
```
Introduce el valor de la URL de la API de Cycode (puedes dejarlo en blanco para usar el valor predeterminado).

Cycode API URL [https://api.cycode.com]: https://api.onpremise.com
Introduce el valor de la URL de la aplicación de Cycode (puedes dejarlo en blanco para usar el valor predeterminado).

Cycode APP URL [https://app.cycode.com]: https://app.onpremise.com
Introduce el valor del Client ID de Cycode.

Cycode Client ID []: 7fe5346b-xxxx-xxxx-xxxx-55157625c72d
Introduce el valor del Client Secret de Cycode (omítelo si tienes previsto usar un token de ID de OIDC).

Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
Introduce el valor del token de ID de OIDC de Cycode (opcional).

Cycode ID Token []: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
Si los valores se introdujeron correctamente, verás el siguiente mensaje:

Successfully configured CLI credentials!

o/y

Successfully configured Cycode URLs!

Si accedes a la carpeta .cycode dentro de tu carpeta de usuario, encontrarás las credenciales creadas y guardadas en el archivo credentials.yaml de esa carpeta. Las URL se guardaron en el archivo config.yaml de esa carpeta.

Agregar a las variables de entorno

En Unix/Linux:

export CYCODE_CLIENT_ID={your Cycode ID}

export CYCODE_CLIENT_SECRET={your Cycode Secret Key}

Si tu organización usa autenticación OIDC, puedes proporcionar el token de ID en su lugar (o además):

export CYCODE_ID_TOKEN={your Cycode OIDC ID token}

En Windows

En el Panel de control, ve al menú Sistema:
A continuación, haz clic en Configuración avanzada del sistema:
En la ventana Propiedades del sistema que se abre, haz clic en el botón Variables de entorno:
Crea las variables CYCODE_CLIENT_ID y CYCODE_CLIENT_SECRET con valores que coincidan con tu ID y tu clave secreta, respectivamente. Si te autenticas mediante OIDC, agrega también CYCODE_ID_TOKEN con el valor de tu token de ID de OIDC:
Inserta cycode.exe en la ruta para completar la instalación.

Instalar el hook de pre-commit

Los hooks de pre-commit y pre-push de Cycode se pueden configurar en tu repositorio local para que la aplicación Cycode CLI identifique automáticamente cualquier problema en tu código antes de que lo confirmes o lo envíes a tu base de código.

[!NOTE] Los hooks de pre-commit y pre-push no están disponibles para los análisis de IaC.

Sigue estos pasos para instalar el hook de pre-commit:

Instalar el hook de pre-commit

Instala el framework pre-commit (debes tener instalado Python 3.10 o posterior):
```
pip3 install pre-commit
```
Ve al directorio raíz del repositorio Git local que quieras configurar.
Crea un archivo YAML llamado .pre-commit-config.yaml (incluye el . inicial) en el directorio raíz del repositorio, con el siguiente contenido:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.0
    hooks:
      - id: cycode
        stages: [pre-commit]
```
Modifica el archivo creado según tus necesidades. Usa el ID de hook cycode para habilitar el análisis de secretos. Usa el ID de hook cycode-sca para habilitar el análisis de SCA. Usa el ID de hook cycode-sast para habilitar el análisis de SAST. Si quieres habilitar todos los tipos de análisis, usa esta configuración:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.0
    hooks:
      - id: cycode
        stages: [pre-commit]
      - id: cycode-sca
        stages: [pre-commit]
      - id: cycode-sast
        stages: [pre-commit]
```
Instala el hook de Cycode:
```
pre-commit install
```
Si la instalación del hook se realiza correctamente, aparecerá el mensaje: Pre-commit installed at .git/hooks/pre-commit.
Mantén actualizado el hook de pre-commit:
```
pre-commit autoupdate
```
Esto actualizará automáticamente rev en .pre-commit-config.yaml a la versión más reciente disponible de Cycode CLI.

[!NOTE] El hook se activa con el comando git commit. El hook solo se activa en los archivos preparados para la confirmación.

Instalar el hook de pre-push

Para instalar el hook de pre-push además del hook de pre-commit o en su lugar:

Agrega los hooks de pre-push a tu archivo .pre-commit-config.yaml:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.0
    hooks:
      - id: cycode-pre-push
        stages: [pre-push]

Instala el hook de pre-push:

pre-commit install --hook-type pre-push

Para los hooks de pre-commit y pre-push, usa:

pre-commit install
pre-commit install --hook-type pre-push

[!NOTE] Los hooks de pre-push se activan con el comando git push y analizan únicamente las confirmaciones que están a punto de enviarse.

Comandos de Cycode CLI

A continuación se muestran las opciones y los comandos disponibles en la aplicación Cycode CLI:

Opción	Descripción
`-v`, `--verbose`	Mostrar registros detallados.
`--no-progress-meter`	No mostrar el indicador de progreso.
`--no-update-notifier`	No comprobar si hay actualizaciones de la CLI.
`-o`, `--output [rich\|text\|json\|table]`	Especificar el tipo de salida. El valor predeterminado es `rich`.
`--client-id TEXT`	Especificar un ID de cliente de Cycode para esta ejecución de análisis.
`--client-secret TEXT`	Especificar un secreto de cliente de Cycode para esta ejecución de análisis.
`--id-token TEXT`	Especificar un token de ID de OIDC de Cycode para esta ejecución de análisis.
`--install-completion`	Instalar la finalización para el shell actual..
`--show-completion [bash\|zsh\|fish\|powershell\|pwsh]`	Mostrar la finalización para el shell especificado, para copiarla o personalizar la instalación.
`-h`, `--help`	Mostrar las opciones del comando indicado.
Comando	Descripción
-------------------------------------------	----------------------------------------------------------------------------------------------------------------------------------------------
auth	Autentica tu máquina para asociar la CLI con tu cuenta de Cycode.
configure	Comando inicial para configurar la autenticación del cliente de la CLI.
ignore	Ignora un valor, una ruta o un ID de regla específicos.
mcp	Inicia el servidor Model Context Protocol (MCP) para habilitar la integración de IA con las capacidades de análisis de Cycode.
scan	Analiza el contenido en busca de infracciones de Secrets/IaC/SCA/SAST. You`ll need to specify which scan type to perform: commit-history/path/repository/etc.
report	Genera un informe. Deberás especificar el tipo de informe que quieres generar, como SBOM.
status	Muestra el estado de la CLI y sale.

Certificados y proxies

De forma predeterminada, Cycode CLI verifica las conexiones HTTPS con el paquete de CA incluido con la CLI.

Si tu organización utiliza un proxy que inspecciona el tráfico HTTPS, o una instalación local con su propia CA, tienes dos opciones.

Opción 1 — usar los certificados ya instalados en la máquina. Si tu CA está en el almacén de certificados de la máquina (como suele ocurrir en un dispositivo administrado), habilita esta opción:

export CYCODE_CLI_ENABLE_TRUSTSTORE=1

La CLI verifica entonces los certificados con el almacén de certificados de Windows, el Llavero de macOS o el directorio de CA del sistema en Linux, sin necesidad de configurar rutas de certificados.

[!IMPORTANT] Esta opción es voluntaria por diseño. Confiar en el almacén de la máquina significa confiar en todos los certificados raíz presentes en ella, incluidos los instalados por un administrador o software malicioso. Habilítala cuando sepas que confías en el almacén de certificados de tu máquina.

Opción 2 — indicar a la CLI la ruta a un archivo de paquete de CA. Funciona sin habilitar la opción anterior:

Variable de entorno	Descripción
`REQUESTS_CA_BUNDLE`	Ruta a un archivo de paquete de CA (`.pem` o `.crt`) en el que confiar.
`CURL_CA_BUNDLE`	Alias de `REQUESTS_CA_BUNDLE`, que se utiliza si esta última no está definida.

Las dos opciones se pueden combinar: con CYCODE_CLI_ENABLE_TRUSTSTORE=1, los certificados de REQUESTS_CA_BUNDLE se consideran confiables además de los del almacén de la máquina, no en su lugar.

[!TIP] Ejecuta cualquier comando con -v para ver qué origen de confianza se está usando; por ejemplo, cycode -v status.

Notas:

En Windows, la CLI siempre ha recurrido al almacén de certificados del sistema cuando ni REQUESTS_CA_BUNDLE ni CURL_CA_BUNDLE están definidos. Ese comportamiento no ha cambiado.
Los proxies se configuran con las variables de entorno estándar HTTP_PROXY, HTTPS_PROXY y NO_PROXY.

Comando MCP [EXPERIMENT]

El comando Model Context Protocol (MCP) permite iniciar un servidor MCP que expone las capacidades de análisis de Cycode a sistemas y aplicaciones de IA. Esto permite que los modelos de IA interactúen con las herramientas de Cycode CLI mediante un protocolo estandarizado.

[!TIP] Para obtener la mejor experiencia, instala Cycode CLI globalmente en tu sistema con pip install cycode o brew install cycode y, luego, autentícate una sola vez con cycode auth. Después de la instalación global y la autenticación, no tendrás que configurar las variables de entorno CYCODE_CLIENT_ID y CYCODE_CLIENT_SECRET en tus archivos de configuración de MCP.

Iniciar el servidor MCP

Para iniciar el servidor MCP, usa el siguiente comando:

cycode mcp

De forma predeterminada, el servidor se inicia con el transporte stdio, adecuado para integraciones locales y aplicaciones de IA que pueden iniciar subprocesos.

Opciones disponibles

Opción	Descripción
`-t, --transport`	Tipo de transporte para el servidor MCP: `stdio`, `sse` o `streamable-http` (predeterminado: `stdio`)
`-H, --host`	Dirección del host a la que se enlaza el servidor (solo se usa con transportes distintos de stdio) (predeterminada: `127.0.0.1`)
`-p, --port`	Número de puerto al que se enlaza el servidor (solo se usa con transportes distintos de stdio) (predeterminado: `8000`)
`--help`	Muestra el mensaje de ayuda y las opciones disponibles

Herramientas MCP

El servidor MCP proporciona las siguientes herramientas que pueden usar los sistemas de IA:

Nombre de la herramienta	Descripción
`cycode_secret_scan`	Busca secretos codificados de forma fija
`cycode_sca_scan`	Analiza Software Composition Analysis (SCA): vulnerabilidades y problemas de licencias
`cycode_iac_scan`	Analiza errores de configuración de Infrastructure as Code (IaC)
`cycode_sast_scan`	Analiza Static Application Security Testing (SAST): calidad del código y fallos de seguridad
`cycode_status`	Obtiene la versión de Cycode CLI, el estado de autenticación y la información de configuración

Cada herramienta de análisis acepta dos modos de entrada mutuamente excluyentes:

paths (preferido) — una o varias rutas de archivos o directorios existentes en el disco. Los directorios se analizan de forma recursiva. El motor de Cycode se encarga de descubrir y filtrar los archivos, igual que cycode scan -t <type> path ./src desde la CLI.
files (alternativo) — un diccionario que asigna rutas de archivos a su contenido completo como cadenas. Úsalo solo cuando los archivos no estén disponibles en el disco (p. ej., cambios en memoria que aún no se han guardado).

[!TIP] Usa paths siempre que sea posible. Pasar archivos grandes (como package-lock.json) como contenido insertado puede superar los límites de tokens y ralentizar el cliente de IA. Con paths, el motor de Cycode lee los archivos directamente del disco.

Todas las herramientas de análisis devuelven un objeto JSON que incluye un campo "summary" con un recuento de infracciones legible (p. ej., "Cycode found 3 violations: 1 CRITICAL, 2 HIGH."), además de la matriz completa "detections".

Ejemplos de uso

Ejemplos de comandos básicos

Inicia el servidor MCP con la configuración predeterminada (transporte stdio):

cycode mcp

Inicia el servidor MCP con el transporte stdio explícito:

cycode mcp -t stdio

Inicia el servidor MCP con el transporte Server-Sent Events (SSE):

cycode mcp -t sse -p 8080

Inicia el servidor MCP con el transporte HTTP transmisible en un host y puerto personalizados:

cycode mcp -t streamable-http -H 0.0.0.0 -p 9000

Obtén más información sobre los tipos de transporte MCP en MCP Protocol Specification – Transports.

Ejemplos de configuración

Uso de MCP con Cursor/VS Code/Claude Desktop/etc. (mcp.json)

[!NOTE] Para los entornos de Cycode de la UE, asegúrate de establecer los valores adecuados de CYCODE_API_URL y CYCODE_APP_URL en las variables de entorno (p. ej., https://api.eu.cycode.com y https://app.eu.cycode.com).

Sigue esta guía para configurar el servidor MCP en VS Code/GitHub Copilot. Ten en cuenta que en settings.json hay un objeto mcp que contiene un subobjeto anidado servers, en lugar de un objeto mcpServers independiente.

Para el transporte stdio (ejecución directa):

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

Para el transporte stdio con la instalación de pipx:

{
  "mcpServers": {
    "cycode": {
      "command": "pipx",
      "args": ["run", "cycode", "mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

Para el transporte stdio con la instalación de uvx:

{
  "mcpServers": {
    "cycode": {
      "command": "uvx",
      "args": ["cycode", "mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

Para el transporte SSE (Server-Sent Events):

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/sse"
    }
  }
}

Para el transporte SSE en un puerto personalizado:

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8080/sse"
    }
  }
}

Para el transporte HTTP transmisible:

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

Ejecutar el servidor MCP en segundo plano

Para el transporte SSE (inicia primero el servidor y, luego, configura el cliente):

# Start the MCP server in the background
cycode mcp -t sse -p 8000 &

# Configure in mcp.json
{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/sse"
    }
  }
}

Para el transporte HTTP transmisible:

# Start the MCP server in the background
cycode mcp -t streamable-http -H 127.0.0.2 -p 9000 &

# Configure in mcp.json
{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.2:9000/mcp"
    }
  }
}

Configuración avanzada

Tiempos de espera y certificados personalizados (entornos con proxy)

Si tu cliente MCP interrumpe los análisis de larga duración antes de que terminen, aumenta el tiempo de espera de las llamadas a herramientas.

Variable de entorno	Descripción
`MCP_TOOL_TIMEOUT`	Tiempo de espera (en segundos) que esperan los clientes MCP, como Claude y GitHub Copilot, para que se complete una llamada a una herramienta. Auméntalo si los análisis de larga duración se interrumpen antes de terminar.

Si estás detrás de un proxy corporativo, define las variables de certificados en el bloque env del servidor MCP. Consulta Certificados y proxies para conocer las opciones: usar CYCODE_CLI_ENABLE_TRUSTSTORE=1 para utilizar los certificados ya instalados en la máquina, o REQUESTS_CA_BUNDLE para indicar la ruta a un archivo de paquete de CA.

Ejemplo de configuración de mcp.json con un paquete de CA personalizado y un tiempo de espera más largo:

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "REQUESTS_CA_BUNDLE": "/path/to/your/corporate-ca-bundle.pem",
        "MCP_TOOL_TIMEOUT": "1800"
      }
    }
  }
}

[!NOTE] El servidor MCP requiere que Cycode CLI esté autenticada correctamente para funcionar. Asegúrate de haberte autenticado con cycode auth o de haber configurado tus credenciales antes de iniciar el servidor MCP.

Autorizar previamente herramientas para subagentes (Claude Code)

Cuando Claude Code delega tareas a subagentes en segundo plano (p. ej., para ejecutar análisis en paralelo), estos no pueden mostrar solicitudes interactivas de permisos. Si las herramientas de Cycode no se han aprobado previamente, los análisis fallarán silenciosamente en los contextos de subagentes.

Para autorizar previamente las herramientas MCP de Cycode y que funcionen en todos los contextos, incluidos los subagentes, añádelas a la lista allowedTools en la configuración de Claude Code (~/.claude/settings.json):

{
  "allowedTools": [
    "mcp__cycode__cycode_secret_scan",
    "mcp__cycode__cycode_sca_scan",
    "mcp__cycode__cycode_iac_scan",
    "mcp__cycode__cycode_sast_scan",
    "mcp__cycode__cycode_status"
  ]
}

Una vez añadidas, Claude Code no solicitará aprobación cuando se invoquen estas herramientas y funcionarán correctamente dentro de los subagentes.

Solución de problemas de MCP

Si tienes problemas con el servidor MCP, puedes habilitar el registro de depuración para obtener información más detallada sobre lo que ocurre. Hay dos formas de habilitarlo:

Usar la marca -v o --verbose:

cycode -v mcp

Usar la variable de entorno CYCODE_CLI_VERBOSE:

CYCODE_CLI_VERBOSE=1 cycode mcp

Los registros de depuración mostrarán información detallada sobre:

El inicio y la configuración del servidor
Los intentos y el estado de conexión
La ejecución de herramientas y sus resultados
Los errores o advertencias que se produzcan

Esta información puede ser útil para:

Diagnosticar problemas de conexión
Entender por qué ciertas herramientas no funcionan
Identificar problemas de autenticación
Depurar problemas específicos del transporte

Configuración de MCP

Comando Platform [BETA]

[!WARNING] El comando platform está en beta. Los comandos, argumentos y formatos de salida se generan dinámicamente a partir de la especificación de la API de Cycode y pueden cambiar entre versiones sin previo aviso. Por ahora, no dependas de ellos en automatizaciones de producción.

El comando cycode platform expone las API de lectura de la plataforma Cycode como comandos de CLI. Agrupa los endpoints por recurso (p. ej., projects, violations, workflows) y convierte los parámetros de cada endpoint en argumentos tipados de CLI y marcas --option.

cycode platform projects list --page-size 50
cycode platform violations count
cycode platform workflows view <workflow-id>

La especificación OpenAPI se obtiene de la API de Cycode la primera vez que se usa y se almacena en caché en ~/.cycode/openapi-spec.json durante 24 horas. Los comandos no relacionados (cycode scan, cycode status, etc.) no provocan una solicitud de obtención.

[!NOTE] Debes autenticarte (cycode auth o las variables de entorno CYCODE_CLIENT_ID / CYCODE_CLIENT_SECRET) para que cycode platform descubra y ejecute comandos. Los demás comandos de Cycode CLI funcionan sin autenticación.

Descubrir comandos

Como los comandos se generan a partir de la especificación, la fuente de verdad sobre lo que está disponible es --help:

cycode platform --help                  # list all resource groups
cycode platform projects --help         # list actions on a resource
cycode platform projects list --help    # list options/arguments for an action

Ejemplos de la plataforma

# List projects with pagination
cycode platform projects list --page-size 25

# View a single project by ID
cycode platform projects view <project-id>

# Count violations across the tenant
cycode platform violations count

# Filter using query parameters (see `--help` for what each endpoint supports)
cycode platform violations list --severity CRITICAL

De forma predeterminada, toda la salida está en JSON; pásala por jq para aplicar filtros puntuales:

cycode platform projects list --page-size 100 | jq '.items[].name'

Notas y limitaciones de la plataforma

Solo lectura por ahora. En esta versión beta solo se exponen los endpoints GET.
Basado en especificaciones. Al añadir un endpoint nuevo a la API, este se incorpora automáticamente la próxima vez que se actualiza la caché.
Sin especificación incluida. La primera invocación de cycode platform después de la instalación (o cuando caduca la caché de 24 h) realiza una solicitud de red. En conexiones lentas, esta primera llamada puede tardar unos segundos; las llamadas posteriores son casi instantáneas hasta que caduque la caché.
Anula el TTL de la caché con CYCODE_SPEC_CACHE_TTL=<seconds>.

Protecciones de IA [BETA]

AI Guardrails instala hooks en agentes de programación con IA compatibles (Claude Code, Cursor, Copilot, Codex) para analizar las solicitudes, los archivos que lee el agente y los argumentos de las herramientas MCP en busca de secretos antes de que lleguen al modelo.

Datos recopilados por AI Guardrails

El análisis se realiza en el servidor, por lo que el contenido analizado sale de la máquina: el texto de la solicitud, el contenido de los archivos que lee el agente y los argumentos de las herramientas MCP se envían a tu tenant de Cycode para comprobar si contienen secretos.

Cada evento también se informa con contexto sobre el desarrollador y la máquina, de modo que un hallazgo pueda atribuirse al dispositivo y al usuario de origen. Parte de esta información son datos personales:

Identificadores del dispositivo — el nombre de host de la máquina y el número de serie del hardware.
Identificadores del usuario — la dirección de correo electrónico del usuario que inició sesión en el agente de programación con IA y el nombre de usuario del sistema operativo local.
Detalles del entorno — sistema operativo y versión, el agente de IA, su versión y el modelo en uso, el contenido de los archivos de configuración MCP del agente y sus plugins habilitados.

El número de serie del hardware se almacena en caché en un archivo temporal local, legible solo por el usuario que ejecutó el comando, para evitar volver a consultar el hardware en cada invocación del hook.

Si la recopilación de estos datos no es aceptable en tu entorno, no instales los hooks de protección (cycode ai-guardrails uninstall elimina los hooks que ya estén instalados).

Comando de análisis

Ejecutar un análisis

La aplicación Cycode CLI ofrece varios tipos de análisis para que puedas elegir la opción que mejor se adapte a tu caso. Estas son las opciones y los comandos disponibles actualmente:

Opción	Descripción
`-t, --scan-type [secret\|iac\|sca\|sast]`	Especifica el análisis que quieres ejecutar (`secret`/`iac`/`sca`/`sast`); el valor predeterminado es `secret`.
`--show-secret BOOLEAN`	Muestra los secretos en texto sin formato. Consulta la sección Mostrar/ocultar secretos para obtener más detalles.
`--soft-fail BOOLEAN`	Ejecuta el análisis sin errores; siempre devuelve un código de estado que no indica error. Consulta la sección Fallo suave para obtener más detalles.
`--severity-threshold [INFO\|LOW\|MEDIUM\|HIGH\|CRITICAL]`	Muestra solo las infracciones del nivel especificado o superior.
`--sca-scan`	Especifica el análisis SCA que quieres ejecutar (`package-vulnerabilities`/`license-compliance`/`unmaintained-packages`/`malicious-packages`). El valor predeterminado es todo.
`--monitor`	Si se especifica, los resultados del análisis se registran en Cycode.
`--cycode-report`	Muestra un enlace al informe del análisis en la plataforma Cycode en la salida de la consola.
`--no-restore`	Si se especifica, Cycode no ejecutará el comando de restauración. Esto analizará SOLO las dependencias directas.
`--stop-on-error`	Aborta el análisis si se produce un error al recopilar archivos o restaurar dependencias, en lugar de omitir el archivo con errores y continuar.
`--gradle-all-sub-projects`	Ejecuta el comando de restauración de gradle para todos los subproyectos. Debe ejecutarse desde
`--maven-settings-file`	Solo para Maven, permite usar un archivo settings.xml personalizado al analizar dependencias
`--help`	Muestra las opciones del comando indicado.

Comando	Descripción
commit-history	Analiza el historial de confirmaciones o realiza un análisis de diferencias entre confirmaciones específicas
path	Analiza los archivos de la ruta indicada en el comando
pre-commit	Analiza el contenido que aún no se ha confirmado; también admite el análisis de diferencias locales mediante flags (compatible con IDE)
repository	Analiza el repositorio git, incluido su historial

Opciones

Opción de gravedad

Para limitar los resultados del análisis a un umbral de gravedad específico, se puede añadir el argumento --severity-threshold al comando de análisis.

Por ejemplo, el siguiente comando analizará el repositorio en busca de infracciones de políticas con gravedad Media o superior:

cycode scan --severity-threshold MEDIUM repository ~/home/git/codebase

Opción de supervisión

[!NOTE] Esta opción solo está disponible para análisis SCA.

Para enviar a Cycode los resultados del análisis asociados a las políticas SCA detectadas en un análisis de tipo SCA, añade el argumento --monitor al comando de análisis.

Por ejemplo, el siguiente comando analizará el repositorio en busca de infracciones de políticas SCA y las enviará a la plataforma Cycode:

cycode scan -t sca --monitor repository ~/home/git/codebase

Opción de informe de Cycode

Para cada análisis realizado con Cycode CLI, se genera automáticamente un informe y sus resultados se envían a Cycode. Estos resultados se asocian a las políticas pertinentes (por ejemplo, las políticas SCA para los análisis de repositorios) dentro de la plataforma Cycode.

Para que la URL directa a este informe de Cycode aparezca en la salida de la CLI una vez finalizado el análisis, añade el argumento --cycode-report al comando de análisis.

cycode scan --cycode-report repository ~/home/git/codebase

Todos los resultados de los análisis de la CLI aparecerán en la sección CLI Logs de Cycode. Si incluiste el flag --cycode-report en el comando, se mostrará un enlace directo al informe específico en tu terminal, después de los resultados del análisis.

[!WARNING] Debes tener el rol owner o admin en Cycode para ver esta página.

cli-report

La página del informe tendrá un aspecto similar al siguiente:

Opción de vulnerabilidades de paquetes

[!NOTE] Esta opción solo está disponible para análisis SCA.

Para analizar una vulnerabilidad específica de un paquete en tu repositorio local, añade el argumento --sca-scan package-vulnerabilities después de la opción -t sca o --scan-type sca.

En el ejemplo anterior, si solo quisieras ejecutar un análisis SCA de las vulnerabilidades de paquetes, podrías ejecutar lo siguiente:

cycode scan -t sca --sca-scan package-vulnerabilities repository ~/home/git/codebase

Opción de cumplimiento de licencias

[!NOTE] Esta opción solo está disponible para análisis SCA.

Para analizar una rama específica de tu repositorio local, añade el argumento --sca-scan license-compliance seguido del nombre de la rama que quieras analizar.

En el ejemplo anterior, si solo quisieras analizar una rama llamada dev, podrías ejecutar lo siguiente:

cycode scan -t sca --sca-scan license-compliance repository ~/home/git/codebase -b dev

Opción de paquetes sin mantenimiento

[!NOTE] Esta opción solo está disponible para análisis SCA.

Para analizar solo paquetes sin mantenimiento (paquetes cuya comprobación Maintained de OpenSSF Scorecard tiene una puntuación baja, lo que significa que hay poca o ninguna actividad reciente de confirmaciones e incidencias), añade el argumento --sca-scan unmaintained-packages después de la opción -t sca o --scan-type sca.

[!NOTE] Que se informen o no los paquetes sin mantenimiento depende de la política de tu organización. Esta opción limita los resultados del análisis; no puede habilitar una política desactivada para tu tenant.

En el ejemplo anterior, si solo quisieras ejecutar un análisis SCA de los paquetes sin mantenimiento, podrías ejecutar lo siguiente:

cycode scan -t sca --sca-scan unmaintained-packages repository ~/home/git/codebase

Opción de paquetes maliciosos

[!NOTE] Esta opción solo está disponible para análisis SCA.

Para analizar solo paquetes maliciosos (dependencias que un aviso de seguridad ha identificado como malware, en lugar de simplemente vulnerables), añade el argumento --sca-scan malicious-packages después de la opción -t sca o --scan-type sca.

Las infracciones por paquetes maliciosos siempre se informan como Critical y no incluyen puntuación CVSS ni versión con corrección: la única medida correctiva es eliminar la dependencia.

[!NOTE] Que se informen o no los paquetes maliciosos depende de la política de tu organización. Esta opción limita los resultados del análisis; no puede habilitar una política desactivada para tu tenant.

En el ejemplo anterior, si solo quisieras ejecutar un análisis SCA de los paquetes maliciosos, podrías ejecutar lo siguiente:

cycode scan -t sca --sca-scan malicious-packages repository ~/home/git/codebase

Opción de restauración de archivos de bloqueo

[!NOTE] Esta opción solo está disponible para análisis SCA.

Al ejecutar un análisis SCA, Cycode CLI intenta automáticamente restaurar (generar) un archivo de bloqueo de dependencias para cada archivo de manifiesto compatible que encuentre. Esto permite analizar las dependencias transitivas, no solo las que aparecen directamente en el manifiesto. Para omitir este paso y analizar solo las dependencias directas, usa el flag --no-restore.

Los siguientes ecosistemas admiten la restauración automática de archivos de bloqueo:

Ecosistema	Archivo de manifiesto	Archivo de bloqueo generado	Herramienta invocada (si no existe el archivo de bloqueo)
npm	`package.json`	`package-lock.json`	`npm install --package-lock-only --ignore-scripts --no-audit`
Yarn	`package.json`	`yarn.lock`	`yarn install --ignore-scripts`
pnpm	`package.json`	`pnpm-lock.yaml`	`pnpm install --ignore-scripts`
Deno	`deno.json` / `deno.jsonc`	`deno.lock`	(solo lee el archivo de bloqueo existente)
Go	`go.mod`	`go.mod.graph`	`go list -m -json all` + `go mod graph`
Maven	`pom.xml`	`bcde.mvndeps`	`mvn dependency:tree`
Gradle	`build.gradle` / `build.gradle.kts`	`gradle-dependencies-generated.txt`	`gradle dependencies -q --console plain`
SBT	`build.sbt`	`build.sbt.lock`	`sbt dependencyLockWrite`
NuGet	`*.csproj`	`packages.lock.json`	`dotnet restore --use-lock-file`
Ruby	`Gemfile`	`Gemfile.lock`	`bundle --quiet`
Poetry	`pyproject.toml`	`poetry.lock`	`poetry lock`
pip	`pyproject.toml` / `requirements.txt`	`pylock.toml`	`pip lock .` / `pip lock -r requirements.txt -o pylock.toml`
Pipenv	`Pipfile`	`Pipfile.lock`	`pipenv lock`
PHP Composer	`composer.json`	`composer.lock`	`composer update --no-cache --no-install --no-scripts --ignore-platform-reqs`

Si ya existe un archivo de bloqueo junto al manifiesto, Cycode lo lee directamente sin ejecutar ningún comando de instalación. Requisito previo de SBT: El complemento sbt-dependency-lock debe estar instalado. Añade la siguiente línea a project/plugins.sbt:

addSbtPlugin("software.purpledragon" % "sbt-dependency-lock" % "1.5.1")

Opción de detenerse ante un error

De forma predeterminada, Cycode continúa el análisis aunque no se pueda leer un archivo (por ejemplo, debido a un error de permisos) o no se pueda generar un archivo de bloqueo de dependencias durante un análisis SCA. El elemento que falla se omite con una advertencia y el análisis continúa con los archivos restantes.

Usa --stop-on-error para cambiar este comportamiento: el análisis se interrumpe inmediatamente ante el primer error de este tipo y se informa del error.

cycode scan -t sca --stop-on-error path ~/home/git/codebase

Esto resulta útil en las canalizaciones de CI, donde un fallo silencioso produciría un resultado de análisis incompleto. Cuando se activa --stop-on-error, puedes corregir el problema subyacente o, específicamente en caso de errores al restaurar SCA, añadir --no-restore para omitir la generación del archivo de bloqueo y analizar solo las dependencias directas.

Cuando se usa --stop-on-error, la CLI distingue entre errores de análisis e infracciones de políticas mediante códigos de salida:

Código de salida	Significado
`0`	El análisis se completó sin infracciones
`1`	El análisis se completó y se encontraron infracciones
`2`	El análisis se interrumpió debido a un error (solo cuando se establece `--stop-on-error`)

Análisis del repositorio

Un análisis del repositorio examina todo un repositorio local en busca de secretos expuestos o configuraciones incorrectas no seguras. Este tipo de análisis más exhaustivo examina todo: el estado actual del repositorio y su historial de confirmaciones. Busca no solo secretos que estén expuestos actualmente en el repositorio, sino también secretos eliminados anteriormente.

Para realizar un análisis completo del repositorio, ejecuta lo siguiente:

cycode scan repository {{path}}

Por ejemplo, si quisieras analizar un repositorio almacenado en ~/home/git/codebase, podrías ejecutar lo siguiente:

cycode scan repository ~/home/git/codebase

La siguiente opción está disponible para este comando:

Opción	Descripción
`-b, --branch TEXT`	Rama que se analizará; si no se establece, se analiza la rama predeterminada

Opción de rama

Para analizar una rama específica de tu repositorio local, añade el argumento -b (o, alternativamente, --branch) seguido del nombre de la rama que quieras analizar.

Siguiendo el ejemplo anterior, si quisieras analizar únicamente una rama llamada dev, podrías ejecutar lo siguiente:

cycode scan repository ~/home/git/codebase -b dev

Análisis de rutas

Un análisis de rutas examina un directorio local específico y todo su contenido, en lugar de centrarse únicamente en un repositorio GIT.

Para realizar un análisis de directorio, ejecuta lo siguiente:

cycode scan path {{path}}

Por ejemplo, imagina que quieres analizar el directorio ubicado en ~/home/git/codebase. En ese caso, podrías ejecutar lo siguiente:

cycode scan path ~/home/git/codebase

Análisis de planes de Terraform

Cycode CLI admite el análisis de planes de Terraform (compatible con Terraform 0.12 y versiones posteriores).

El archivo del plan de Terraform debe estar en formato JSON (con la extensión .json).

Si solo tienes un archivo de configuración, puedes generar un plan de la siguiente manera:

Inicializa un directorio de trabajo que contenga un archivo de configuración de Terraform:

terraform init
Crea un plan de ejecución de Terraform y guarda la salida binaria:

terraform plan -out={tfplan_output}
Convierte el archivo de salida binaria en JSON legible:

terraform show -json {tfplan_output} > {tfplan}.json
Analiza tu {tfplan}.json con Cycode CLI:

cycode scan -t iac path ~/PATH/TO/YOUR/{tfplan}.json

Análisis del historial de confirmaciones

[!NOTE] El análisis del historial de confirmaciones no está disponible para los análisis de IaC.

El comando de análisis del historial de confirmaciones ofrece dos capacidades principales:

Análisis del historial completo: analiza todas las confirmaciones del historial del repositorio
Análisis de diferencias: analiza únicamente los cambios entre confirmaciones específicas

El análisis de secretos puede examinar todas las confirmaciones del historial del repositorio, ya que los secretos introducidos y eliminados posteriormente aún pueden filtrarse o quedar expuestos. En los análisis SCA y SAST, el comando del historial de confirmaciones se centra en analizar las diferencias o los cambios entre confirmaciones, por lo que resulta ideal para revisar solicitudes de incorporación de cambios y realizar análisis incrementales.

Un análisis del historial de confirmaciones examina el historial de confirmaciones de tu repositorio Git y puede utilizarse tanto para un análisis histórico exhaustivo como para analizar diferencias específicas.

Para realizar un análisis del historial de confirmaciones, ejecuta lo siguiente:

cycode scan commit-history {{path}}

Por ejemplo, imagina que quieres analizar el historial de confirmaciones de un repositorio almacenado en ~/home/git/codebase. En ese caso, podrías ejecutar lo siguiente:

cycode scan commit-history ~/home/git/codebase

Las siguientes opciones están disponibles para este comando:

Opción	Descripción
`-r, --commit-range TEXT`	Analiza un rango de confirmaciones en este repositorio git; de forma predeterminada, cycode analiza todo el historial de confirmaciones (ejemplo: HEAD~1)

Opción de rango de confirmaciones (análisis de diferencias)

La opción de rango de confirmaciones permite analizar diferencias: analizar únicamente los cambios entre confirmaciones específicas en lugar de todo el historial del repositorio. Esto resulta especialmente útil para:

Validación de solicitudes de incorporación de cambios: analiza únicamente los cambios introducidos en una PR
Análisis incremental de CI/CD: céntrate en los cambios recientes en lugar de en toda la base de código
Revisión de ramas de funcionalidades: compara los cambios con la rama main/master
Optimización del rendimiento: análisis más rápidos al limitar el alcance a los cambios pertinentes

Sintaxis del rango de confirmaciones

La opción --commit-range (-r) admite la sintaxis estándar de revisiones de Git:

Sintaxis	Descripción	Ejemplo
`commit1..commit2`	Cambios de commit1 a commit2	`abc123..def456`
`commit1...commit2`	Cambios de commit2 que no están en commit1	`main...feature-branch`
`commit`	Cambios desde la confirmación hasta HEAD	`HEAD~1`
`branch1..branch2`	Cambios de branch1 a branch2	`main..feature-branch`

Ejemplos de análisis de diferencias

Analizar los cambios de la última confirmación:

cycode scan commit-history -r HEAD~1 ~/home/git/codebase

Analizar los cambios entre dos confirmaciones específicas:

cycode scan commit-history -r abc123..def456 ~/home/git/codebase

Analizar los cambios de tu rama de funcionalidades en comparación con main:

cycode scan commit-history -r main..HEAD ~/home/git/codebase

Analizar los cambios entre main y una rama de funcionalidades:

cycode scan commit-history -r main..feature-branch ~/home/git/codebase

Analizar todos los cambios de las últimas 3 confirmaciones:

cycode scan commit-history -r HEAD~3..HEAD ~/home/git/codebase

[!TIP] En las canalizaciones de CI/CD, puedes usar variables de entorno como ${{ github.event.pull_request.base.sha }}..${{ github.sha }} (GitHub Actions) o $CI_MERGE_REQUEST_TARGET_BRANCH_SHA..$CI_COMMIT_SHA (GitLab CI) para analizar únicamente los cambios de PR/MR.

Análisis previo a la confirmación

Un análisis previo a la confirmación identifica automáticamente cualquier problema antes de que confirmes cambios en tu repositorio. No es necesario ejecutar este análisis manualmente; configura el hook pre-commit como se detalla en la sección Instalación de esta guía.

Después de instalar el hook pre-commit, es posible que ocasionalmente quieras omitir el análisis durante una confirmación específica. Para hacerlo, añade lo siguiente al comando git para omitir el análisis en una sola confirmación:

SKIP=cycode git commit -m <your commit message>`

Las siguientes opciones están disponibles para este comando:

Opción	Descripción
`-b, --base-ref TEXT`	Referencia de Git (confirmación, rama o etiqueta) con la que comparar; de forma predeterminada, se usa `HEAD`, que coincide con el comportamiento del hook pre-commit
`--include-unstaged`	Analiza también los cambios sin preparar de los archivos con seguimiento, no solo los preparados; desactivado de forma predeterminada
`--path PATH`	Ruta(s) opcional(es) para limitar el análisis de diferencias; se puede repetir; de forma predeterminada, abarca todo el directorio de trabajo

Análisis de diferencias locales (integraciones con IDE)

--base-ref y --include-unstaged convierten pre-commit en un análisis de diferencias local de propósito general: compara cualquier confirmación (de forma predeterminada, HEAD) con tu directorio de trabajo actual, incluidos los cambios que aún no están preparados. Está pensado para complementos de IDE y otras herramientas que necesitan ofrecer comentarios continuos en tiempo real mientras trabajas, en lugar de seguir el flujo del hook de git. Combinado con --include-unstaged, --path permite que un IDE limite el análisis únicamente al archivo abierto en el editor.

[!NOTE] El análisis de diferencias locales (mediante estas opciones) no está disponible para los análisis de IaC.

Analizar todos los cambios actuales (preparados y sin preparar) en comparación con la última confirmación:

cycode scan pre-commit --include-unstaged

Analizar los cambios en comparación con una confirmación o rama específica:

cycode scan pre-commit --include-unstaged --base-ref main

Analizar únicamente un archivo específico (por ejemplo, el archivo abierto en tu IDE):

cycode scan pre-commit --include-unstaged --path src/app.py

Análisis previo al envío

Un análisis previo al envío identifica automáticamente cualquier problema antes de que envíes cambios al repositorio remoto. Este hook se ejecuta en el lado del cliente y analiza únicamente las confirmaciones que están a punto de enviarse, lo que permite detectar problemas de forma eficiente antes de que lleguen al repositorio remoto.

[!NOTE] El hook pre-push no está disponible para los análisis de IaC.

El hook pre-push se integra con el framework pre-commit y se puede configurar para que se ejecute antes de cualquier operación git push.

Instalación del hook pre-push

Para configurar el hook pre-push mediante el framework pre-commit:

Instala el framework pre-commit (si aún no está instalado):
```
pip3 install pre-commit
```

Crea o actualiza tu archivo .pre-commit-config.yaml para incluir los hooks pre-push:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.0
    hooks:
      - id: cycode-pre-push
        stages: [pre-push]

Para varios tipos de análisis, usa esta configuración:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.25.0
    hooks:
      - id: cycode-pre-push          # Secrets scan
        stages: [pre-push]
      - id: cycode-sca-pre-push      # SCA scan
        stages: [pre-push]
      - id: cycode-sast-pre-push     # SAST scan
        stages: [pre-push]

Instala el hook pre-push:
```
pre-commit install --hook-type pre-push
```
Si la instalación se realiza correctamente, aparecerá el mensaje: Pre-push installed at .git/hooks/pre-push.
Mantén actualizado el hook pre-push:
```
pre-commit autoupdate
```

Cómo funciona el análisis pre-push

El hook analiza cada confirmación que se va a enviar, una por una, de modo que también detecta un secreto añadido en una confirmación y eliminado en otra posterior. Cuando se instala mediante el framework pre-commit, el rango enviado se obtiene del framework: las nuevas confirmaciones desde la rama remota en el caso de ramas existentes, y las confirmaciones que aún no están en el remoto en el caso de ramas nuevas (todas las confirmaciones al enviar a un remoto vacío). Cuando se ejecuta desde un .git/hooks/pre-push escrito manualmente, el rango se obtiene de la entrada del hook de git, y las ramas nuevas se analizan desde su base de combinación con la rama predeterminada (consulta más abajo).

Los envíos que no tienen nada que analizar, como las etiquetas, las eliminaciones de ramas y los envíos que ya están actualizados, se completan sin análisis. Si el hook no puede determinar qué se está enviando, falla y bloquea el envío en lugar de continuar silenciosamente.

Los hooks pre-push de Cycode establecen always_run: true y pass_filenames: false, porque el análisis abarca las confirmaciones enviadas, no una lista de archivos. Sin always_run, el framework pre-commit omite el hook cuando las confirmaciones enviadas no incluyen ningún archivo modificado, por ejemplo, si se añade un secreto en una confirmación y se elimina en la siguiente. Sin pass_filenames: false, el framework pasa nombres de archivos modificados que el análisis no utiliza y, en envíos grandes, los divide en lotes y ejecuta el análisis completo una vez por lote. Si defines el hook por tu cuenta (por ejemplo, como un hook repo: local), establece ambas opciones.

Detección inteligente de la rama predeterminada

Cuando se ejecuta desde un hook escrito manualmente, el análisis pre-push detecta la rama predeterminada para calcular la base de combinación siguiendo este orden de prioridad:

Variable de entorno: CYCODE_DEFAULT_BRANCH - permite una anulación manual
HEAD remoto de Git: usa git symbolic-ref refs/remotes/origin/HEAD para detectar la rama predeterminada real del remoto
Información del remoto de Git: recurre a git remote show origin si falla symbolic-ref
Alternativas codificadas: usa nombres de ramas predeterminadas habituales (origin/main, origin/master, main, master)

Establecer una rama predeterminada personalizada:

export CYCODE_DEFAULT_BRANCH=origin/develop

Esta detección inteligente garantiza que el hook pre-push funcione correctamente, independientemente de si tu repositorio usa main, master, develop o cualquier otro nombre de rama predeterminado.

Omitir los análisis pre-push

Para omitir el análisis pre-push en una operación de push específica, usa:

SKIP=cycode-pre-push git push

O bien, para omitir todos los hooks pre-push:

git push --no-verify

[!TIP] El hook pre-push se activa con el comando git push y analiza solo los commits que están a punto de enviarse, por lo que es más eficiente que analizar todo el repositorio.

Excluir rutas de los análisis

Puedes usar un archivo .cycodeignore para indicarle a Cycode CLI qué archivos y directorios debe excluir de los análisis. Funciona igual que un archivo .gitignore. Esto te ayuda a centrar los análisis en el código relevante y a evitar que ciertas rutas generen infracciones localmente.

Cómo funciona

Crea un archivo llamado .cycodeignore en tu carpeta de trabajo.
Enumera los archivos y directorios que quieras excluir, usando los mismos patrones que .gitignore.
Coloca este archivo en el directorio desde el que planeas ejecutar el comando cycode scan.

[!WARNING]

Archivos no válidos: Si el archivo .cycodeignore contiene un error de sintaxis, el análisis de CLI fallará y devolverá un error.

Ignorar rutas frente a infracciones: Este archivo sirve para excluir rutas. Es distinto de la capacidad de CLI para ignorar infracciones específicas (por ejemplo, mediante la marca --ignore-violation).

Analizadores compatibles

SAST
IaC (próximamente)
SCA (próximamente)

Resultados del análisis

Cada análisis finalizará con un mensaje que indicará si se encontraron problemas.

Si no se encuentran problemas, el análisis termina con el siguiente mensaje de éxito:

Good job! No issues were found!!! 👏👏👏

Si se encuentra un problema, al finalizar aparecerá una tarjeta de infracción. En ese caso, revisa el archivo en cuestión y la línea específica resaltada en el mensaje del resultado. Implementa los cambios necesarios para resolver el problema y, luego, vuelve a ejecutar el análisis.

Mostrar u ocultar secretos

En los ejemplos siguientes, se encontró un secreto en el archivo secret_test, ubicado en la subcarpeta cli. La segunda parte del mensaje muestra la línea específica en la que aparece el secreto, que en este caso es un valor asignado a googleApiKey.

Observa que el ejemplo oculta el valor real del secreto y reemplaza la mayor parte por asteriscos. De forma predeterminada, los análisis ocultan los secretos, pero puedes desactivar esta función para ver el secreto completo (siempre que el equipo en el que consultes el resultado del análisis esté suficientemente protegido de miradas indiscretas).

Para desactivar la ofuscación de secretos, añade el argumento --show-secret a cualquier tipo de análisis.

En el siguiente ejemplo, se ejecuta un análisis de ruta en el subdirectorio cli con la opción habilitada para mostrar completos los secretos encontrados:

cycode scan --show-secret path ./cli

El resultado ya no estaría ofuscado.

Fallo suave

En condiciones normales, CLI devuelve el código de salida 1 cuando se encuentran problemas en los resultados del análisis. Según la configuración de CI/CD, esto suele provocar un fallo general. Si quieres evitarlo, puedes usar la función de fallo suave.

Al añadir la opción --soft-fail a cualquier tipo de análisis, el código de salida se establecerá en 0, independientemente de si se encuentran resultados.

Ejemplos de resultados del análisis

Ejemplo de resultado de Secrets

╭─────────────────────────────────────────────────────────────── Hardcoded generic-password is used ───────────────────────────────────────────────────────────────╮
│                                                                                                                                               Violation 12 of 12 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity    🟠 MEDIUM                             │ │   34 };                                                                                               │ │
│ │  In file     /Users/cycodemacuser/NodeGoat/test/s  │ │   35                                                                                                  │ │
│ │              ecurity/profile-test.js               │ │   36 var sutUserName = "user1";                                                                       │ │
│ │  Secret SHA  b4ea3116d868b7c982ee6812cce61727856b  │ │ ❱ 37 var sutUserPassword = "Us*****23";                                                               │ │
│ │              802b3063cd5aebe7d796988552e0          │ │   38                                                                                                  │ │
│ │  Rule ID     68b6a876-4890-4e62-9531-0e687223579f  │ │   39 chrome.setDefaultService(service);                                                               │ │
│ ╰────────────────────────────────────────────────────╯ │   40                                                                                                  │ │
│                                                        ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ A generic secret or password is an authentication token used to access a computer or application and is assigned to a password variable.                     │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Ejemplo de resultado de IaC

╭──────────── Enable Content Encoding through the attribute 'MinimumCompressionSize'. This value should be greater than -1 and smaller than 10485760. ─────────────╮
│                                                                                                                                              Violation 45 of 110 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity      🟠 MEDIUM                           │ │   20 BinaryMediaTypes:                                                                                │ │
│ │  In file       ...ads-copy/iac/cft/api-gateway/ap  │ │   21   - !Ref binaryMediaType1                                                                        │ │
│ │                i-gateway-rest-api/deploy.yml       │ │   22   - !Ref binaryMediaType2                                                                        │ │
│ │  IaC Provider  CloudFormation                      │ │ ❱ 23 MinimumCompressionSize: -1                                                                       │ │
│ │  Rule ID       33c4b90c-3270-4337-a075-d3109c141b  │ │   24 EndpointConfiguration:                                                                           │ │
│ │                53                                  │ │   25   Types:                                                                                         │ │
│ ╰────────────────────────────────────────────────────╯ │   26     - EDGE                                                                                       │ │
│                                                        ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ This policy validates the proper configuration of content encoding in AWS API Gateway. Specifically, the policy checks for the attribute                     │ │
│ │ 'minimum_compression_size' in API Gateway REST APIs. Correct configuration of this attribute is important for enabling content encoding of API responses for │ │
│ │ improved API performance and reduced payload sizes.                                                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Ejemplo de resultado de SCA

╭─────────────────────────────────────────────────────── [CVE-2019-10795] Prototype Pollution in undefsafe ────────────────────────────────────────────────────────╮
│                                                                                                                                             Violation 172 of 195 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity               🟠 MEDIUM                  │ │   26758   "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=",                                           │ │
│ │  In file                /Users/cycodemacuser/Node  │ │   26759   "dev": true                                                                                 │ │
│ │                         Goat/package-lock.json     │ │   26760 },                                                                                            │ │
│ │  CVEs                   CVE-2019-10795             │ │ ❱ 26761 "undefsafe": {                                                                                │ │
│ │  Package                undefsafe                  │ │   26762   "version": "2.0.2",                                                                         │ │
│ │  Version                2.0.2                      │ │   26763   "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.2.tgz",                   │ │
│ │  First patched version  Not fixed                  │ │   26764   "integrity": "sha1-Il9rngM3Zj4Njnz9aG/Cg2zKznY=",                                           │ │
│ │  Dependency path        nodemon 1.19.1 ->          │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ │                         undefsafe 2.0.2            │                                                                                                           │
│ │  Rule ID                9c6a8911-e071-4616-86db-4  │                                                                                                           │
│ │                         943f2e1df81                │                                                                                                           │
│ ╰────────────────────────────────────────────────────╯                                                                                                           │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ undefsafe before 2.0.3 is vulnerable to Prototype Pollution. The 'a' function could be tricked into adding or modifying properties of Object.prototype using │ │
│ │ a __proto__ payload.                                                                                                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Ejemplo de resultado de SAST

╭───────────────────────────────────────────── [CWE-208: Observable Timing Discrepancy] Observable Timing Discrepancy ─────────────────────────────────────────────╮
│                                                                                                                                               Violation 24 of 49 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity       🟠 MEDIUM                          │ │   173         " including numbers, lowercase and uppercase letters.";                                 │ │
│ │  In file        /Users/cycodemacuser/NodeGoat/app  │ │   174     return false;                                                                               │ │
│ │                 /routes/session.js                 │ │   175 }                                                                                               │ │
│ │  CWE            CWE-208                            │ │ ❱ 176 if (password !== verify) {                                                                      │ │
│ │  Subcategory    Security                           │ │   177     errors.verifyError = "Password must match";                                                 │ │
│ │  Language       js                                 │ │   178     return false;                                                                               │ │
│ │  Security Tool  Bearer (Powered by Cycode)         │ │   179 }                                                                                               │ │
│ │  Rule ID        19fbca07-a8e7-4fa6-92ac-a36d15509  │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ │                 fa9                                │                                                                                                           │
│ ╰────────────────────────────────────────────────────╯                                                                                                           │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ Observable Timing Discrepancy occurs when the time it takes for certain operations to complete can be measured and observed by attackers. This vulnerability │ │
│ │ is particularly concerning when operations involve sensitive information, such as password checks or secret comparisons. If attackers can analyze how long   │ │
│ │ these operations take, they might be able to deduce confidential details, putting your data at risk.                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Directrices de corrección personalizadas de la empresa

Si tu empresa ha establecido directrices de corrección personalizadas en la política correspondiente a través del portal de Cycode, verás un campo «Directrices de la empresa» que contiene las directrices de corrección que añadiste. Ten en cuenta que, si no has añadido directrices de la empresa, este campo no aparecerá en la herramienta CLI.

Ignorar resultados del análisis

Se pueden añadir reglas de exclusión para ignorar valores de secretos específicos, valores SHA512 específicos, rutas específicas e ID de reglas específicas de secretos y de IaC de Cycode. Esto hará que el análisis no genere alertas para esos valores. Las reglas de exclusión se escriben y guardan localmente en el archivo ./.cycode/config.yaml.

[!WARNING] Añade valores para ignorar con cuidado y teniendo en cuenta los valores, las rutas y las políticas, para garantizar que los análisis detecten los verdaderos positivos.

Estas son las opciones disponibles para el comando cycode ignore:

Opción	Descripción
`--by-value TEXT`	Ignora un valor específico al buscar secretos. Consulta Ignorar un valor de secreto para obtener más información.
`--by-sha TEXT`	Ignora una representación SHA512 específica de una cadena al buscar secretos. Consulta Ignorar un valor SHA de secreto para obtener más información.
`--by-path TEXT`	Evita analizar una ruta específica. Es necesario especificar el tipo de análisis. Consulta Ignorar una ruta para obtener más información.
`--by-rule TEXT`	Ignora el análisis de un ID de regla de secretos, IaC o SCA específico. Consulta Ignorar una regla de secretos o IaC para obtener más información.
`--by-package TEXT`	Ignora el análisis de una versión específica de un paquete durante un análisis de SCA. Patrón esperado: `name@version`. Consulta Ignorar un paquete para obtener más información.
`--by-cve TEXT`	Ignora el análisis de un CVE específico durante un análisis de SCA. Patrón esperado: CVE-YYYY-NNN.
`-t, --scan-type [secret\|iac\|sca\|sast]`	Especifica el análisis que quieres ejecutar (`secret`/`iac`/`sca`/`sast`). El valor predeterminado es `secret`.
`-g, --global`	Añade una regla de exclusión y la actualiza en el archivo de configuración global `.cycode`.

Ignorar un valor de secreto

Para ignorar un valor de secreto específico, debes usar la marca --by-value. Esto hará que el valor de secreto indicado se ignore en todos los análisis futuros. Usa el siguiente comando para añadir un valor de secreto a la lista de exclusión:

cycode ignore --by-value {{secret-value}}

En el ejemplo al principio de esta sección, el comando para ignorar un valor de secreto específico es el siguiente:

cycode ignore --by-value h3110w0r1d!@#$350

En el ejemplo anterior, sustituye el valor h3110w0r1d!@#$350 por el valor de tu secreto sin enmascarar. Consulta las opciones de análisis de Cycode para obtener información sobre cómo ver los valores de los secretos en los resultados del análisis.

Ignorar un valor SHA de secreto

Para ignorar un valor SHA de secreto específico, debes usar la marca --by-sha. Esto hará que el valor SHA de secreto indicado se ignore en todos los análisis futuros. Usa el siguiente comando para añadir un valor SHA de secreto a la lista de exclusión:

cycode ignore --by-sha {{secret-sha-value}}

En el ejemplo al principio de esta sección, el comando para ignorar un valor SHA de secreto específico es el siguiente:

cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0

En el ejemplo anterior, sustituye el valor a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0 por el valor SHA de tu secreto.

Ignorar una ruta

Para ignorar una ruta específica en los análisis de secretos, IaC o SCA, debes usar la marca --by-path junto con la marca -t, --scan-type (debes especificar el tipo de análisis). Esto hará que la ruta indicada se ignore en todos los análisis futuros del tipo especificado. Usa el siguiente comando para añadir una ruta a la lista de exclusión:

cycode ignore -t {{scan-type}} --by-path {{path}}

En el ejemplo al principio de esta sección, el comando para ignorar una ruta específica en un análisis de secretos es el siguiente:

cycode ignore -t secret --by-path ~/home/my-repo/config

En el ejemplo anterior, sustituye el valor ~/home/my-repo/config por tu ruta.

En el ejemplo al principio de esta sección, el comando para ignorar una ruta específica en los análisis de IaC es el siguiente:

cycode ignore -t iac --by-path ~/home/my-repo/config

En el ejemplo anterior, sustituye el valor ~/home/my-repo/config por tu ruta.

En el ejemplo al principio de esta sección, el comando para ignorar una ruta específica en los análisis de SCA es el siguiente:

cycode ignore -t sca --by-path ~/home/my-repo/config

En el ejemplo anterior, sustituye el valor ~/home/my-repo/config por tu ruta.

Ignorar una regla de secretos, IaC, SCA o SAST

Para ignorar una regla específica de secretos, IaC, SCA o SAST, debes usar la marca --by-rule junto con la marca -t, --scan-type (debes especificar el tipo de análisis). Esto hará que el ID de regla indicado se ignore en todos los análisis futuros. Usa el siguiente comando para añadir un ID de regla a la lista de exclusión:

cycode ignore -t {{scan-type}} --by-rule {{rule-ID}}

En el ejemplo al principio de esta sección, el comando para ignorar un ID de regla de secretos específico es el siguiente:

cycode ignore -t secret --by-rule ce3a4de0-9dfc-448b-a004-c538cf8b4710

En el ejemplo anterior, sustituye el valor ce3a4de0-9dfc-448b-a004-c538cf8b4710 por el ID de la regla que quieras ignorar.

En el ejemplo al principio de esta sección, el comando para ignorar un ID de regla de IaC específico es el siguiente:

cycode ignore -t iac --by-rule bdaa88e2-5e7c-46ff-ac2a-29721418c59c

En el ejemplo anterior, sustituye el valor bdaa88e2-5e7c-46ff-ac2a-29721418c59c por el ID de la regla que quieras ignorar.

En el ejemplo al principio de esta sección, el comando para ignorar un ID de regla de SCA específico es el siguiente:

cycode ignore -t sca --by-rule dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b

En el ejemplo anterior, sustituye el valor dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b por el ID de la regla que quieras ignorar.

Ignorar un paquete

[!NOTE] Esta opción solo está disponible para los análisis de SCA.

Para ignorar un paquete específico en los análisis de SCA, debes usar la marca --by-package junto con la marca -t, --scan-type (debes especificar el tipo de análisis sca). Esto hará que el paquete indicado, con el formato {{package_name}}@{{package_version}}, se ignore en todos los análisis futuros. Usa el siguiente comando para añadir un paquete y una versión a la lista de exclusión:

cycode ignore --scan-type sca --by-package {{package_name}}@{{package_version}}

cycode ignore -t sca --by-package {{package_name}}@{{package_version}}

En el ejemplo siguiente, el comando para ignorar un paquete específico de SCA es el siguiente:

cycode ignore --scan-type sca --by-package pyyaml@5.3.1

En el ejemplo anterior, sustituye pyyaml por el nombre del paquete y 5.3.1 por la versión del paquete que quieras ignorar.

Ignorar mediante un archivo de configuración

Las reglas de exclusión aplicadas se almacenan en el archivo de configuración llamado config.yaml. Este archivo se puede compartir fácilmente entre desarrolladores o incluso confirmar en un repositorio Git remoto. Estos archivos siempre se encuentran en la carpeta .cycode. El nombre de la carpeta empieza con un punto (.), por lo que debes habilitar la visualización de archivos ocultos para verla.

Ubicación de los archivos de configuración

De forma predeterminada, todos los comandos cycode ignore guardan la regla de exclusión en el directorio actual desde el que se ejecutó CLI.

Ejemplo: al ejecutar un comando CLI de exclusión desde /Users/name/projects/backend, se creará config.yaml en /Users/name/projects/backend/.cycode

➜  backend  pwd
/Users/name/projects/backend
➜  backend  cycode ignore --by-value test-value
➜  backend  tree -a
.
└── .cycode
    └── config.yaml

2 directories, 1 file

La segunda opción consiste en guardar las reglas de exclusión en los archivos de configuración globales. La ruta de la configuración global es ~/.cycode/config.yaml, donde ~ significa users home directory, for example, /Users/name` en macOS.

Para guardar en el espacio global, se puede usar la marca -g del comando cycode ignore. Por ejemplo: cycode ignore -g --by-value test-value.

Directorio de trabajo adecuado

Es muy importante colocar la carpeta .cycode y ejecutar CLI desde el mismo lugar. Debes comprobarlo con atención cuando trabajes en distintos entornos, como CI/CD (GitHub Actions, Jenkins, etc.).

Puedes confirmar la carpeta .cycode en la raíz de tu repositorio. En ese caso, debes ejecutar los análisis de CLI desde la raíz del repositorio. Si esto no se ajusta a tus requisitos, puedes copiar temporalmente la carpeta .cycode donde quieras y ejecutar un análisis de CLI desde esa carpeta.

Reglas de exclusión de estructura en la configuración

Es importante comprender cómo CLI almacena las reglas de exclusión para poder leer estos archivos de configuración o incluso modificarlos sin CLI.

La estructura YAML abstracta:

exclusions:
  {scanTypeName}:
    {ignoringType}:
    - someIgnoringValue1
    - someIgnoringValue2

Valores posibles de scanTypeName: iac, sca, sast, secret.

Valores posibles de ignoringType: paths, values, rules, packages, shas, cves.

[!WARNING] ¡Los valores de «ignorar por valor» no se almacenan como texto sin formato! CLI almacena hashes sha256 de los valores. Al modificar manualmente el archivo de configuración, debes incluir hashes de la cadena.

Ejemplo real de config.yaml:

exclusions:
  iac:
    rules:
    - bdaa88e2-5e7c-46ff-ac2a-29721418c59c
  sca:
    packages:
    - pyyaml@5.3.1
  secret:
    paths:
    - /Users/name/projects/build
    rules:
    - ce3a4de0-9dfc-448b-a004-c538cf8b4710
    shas:
    - a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0
    values:
    - a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
    - 60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752

Comando Report

Generar un informe SBOM

Una lista de materiales de software (SBOM) es un inventario de todos los componentes y dependencias de software que intervienen en el desarrollo y la entrega de una aplicación. Con este comando, puedes crear un informe SBOM para tu proyecto local o para el URI de tu repositorio.

Las siguientes opciones están disponibles para este comando:

Opción	Descripción	Obligatorio	Valor predeterminado
`-f, --format [spdx-2.2\|spdx-2.3\|cyclonedx-1.4]`	Formato SBOM	Sí
`-o, --output-format [JSON]`	Especificar el formato del archivo de salida	No	json
`--output-file PATH`	Archivo de salida	No	nombre de archivo generado automáticamente, guardado en el directorio actual
`--include-vulnerabilities`	Incluir vulnerabilidades	No	False
`--include-dev-dependencies`	Incluir dependencias de desarrollo	No	False

Los siguientes comandos están disponibles para este comando:

Comando	Descripción
`path`	Generar un informe SBOM para la ruta especificada en el comando
`repository-url`	Generar un informe SBOM para el URI del repositorio especificado en el comando

Repositorio

Para crear un informe SBOM para un URI de repositorio:
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> repository_url <repository url>

Por ejemplo:
cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies repository_url https://github.com/cycodehq/cycode-cli.git

Proyecto local

Para crear un informe SBOM para una ruta:
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> path </path/to/project>

Por ejemplo:
cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies path /path/to/local/project

El subcomando path admite las siguientes opciones adicionales:

Opción	Descripción
`--no-restore`	Omitir la restauración del archivo de bloqueo y analizar solo las dependencias directas. Consulta Opción de restauración de bloqueo para obtener más información.
`--gradle-all-sub-projects`	Ejecutar el comando de restauración de Gradle para todos los subproyectos (usar desde la raíz de una compilación Gradle multiproyecto).
`--maven-settings-file`	Solo para Maven, permite usar un archivo settings.xml personalizado al crear el árbol de dependencias.

Comando Import

Importar SBOM

Una lista de materiales de software (SBOM) es un inventario de todos los componentes y dependencias de software que intervienen en el desarrollo y la entrega de una aplicación. Con este comando, puedes importar un archivo SBOM desde tu sistema de archivos a Cycode.

Las siguientes opciones están disponibles para este comando:

Opción	Descripción	Obligatorio	Valor predeterminado
`-n, --name TEXT`	Nombre para mostrar del SBOM	Sí
`-v, --vendor TEXT`	Nombre de la entidad que proporcionó el SBOM	Sí
`-l, --label TEXT`	Añadir una etiqueta al SBOM	No
`-o, --owner TEXT`	Dirección de correo electrónico del usuario de Cycode que actúa como punto de contacto para este SBOM	No
`-b, --business-impact [High \| Medium \| Low]`	Impacto empresarial	No	Medium

Por ejemplo:
cycode import sbom --name example-sbom --vendor cycode -label tag1 -label tag2 --owner example@cycode.com /path/to/local/project

Registros de análisis

Todos los análisis de CLI se registran en Cycode. Los registros se encuentran en Settings > CLI Logs.

Ayuda de sintaxis

Puedes añadir el argumento --help a cualquier comando en cualquier momento para ver un mensaje de ayuda que muestra las opciones disponibles y su sintaxis.

Para ver la ayuda general, simplemente introduce el comando:

cycode --help

Para ver las opciones de análisis, introduce:

cycode scan --help

Para ver las opciones disponibles para un tipo específico de análisis, introduce:

cycode scan {{option}} --help

Por ejemplo, para ver las opciones disponibles para un análisis de ruta, introducirías:

cycode scan path --help

Para ver las opciones disponibles para la función de análisis de exclusiones, usa este comando:

cycode ignore --help

Para ver las opciones disponibles para un informe, usa este comando:

cycode report --help

Para ver las opciones disponibles para un tipo específico de informe, introduce:

cycode scan {{option}} --help