P4 MCP Server

Si tiene uv instalado, puede ejecutar P4 MCP Server directamente sin ninguna instalación manual:

# Run the server
uvx p4mcp-server

# Check version
uvx p4mcp-server --version

# Run with arguments
uvx p4mcp-server --readonly --allow-usage

Esto obtiene y ejecuta automáticamente la última versión desde PyPI. No se necesita configuración de entorno virtual de Python ni gestión de dependencias.

Requisitos:

• uv instalado en su sistema
• Python 3.11+ (uv lo gestionará automáticamente)

Descargue el binario apropiado para su sistema operativo:

• macOS: p4-mcp-server-mac.zip
• Windows: p4-mcp-server-win.zip
• Linux: p4-mcp-server-linux.zip

Extraiga y use el ejecutable directamente. No se requiere instalación de Python.

# macOS / Linux
unzip p4-mcp-server-mac.zip   # or p4-mcp-server-linux.zip
./p4-mcp-server --help

# Windows
Expand-Archive p4-mcp-server-win.zip -DestinationPath .
.\p4-mcp-server.exe --help

Requisitos:

• Python 3.11+ (con Tkinter)

Compilar:

• macOS: chmod +x build.sh && ./build.sh package
• Linux: chmod +x build.sh && ./build.sh package
• Windows: build.bat package

Salida:

• macOS y Linux: p4-mcp-server-<version>.tgz
• Windows: p4-mcp-server-<version>.zip

Ejecute P4 MCP Server directamente en su máquina usando el transporte STDIO predeterminado.

Agregue lo siguiente a su mcp.json:

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Nota: Este ejemplo muestra valores explícitos de env. Si P4CONFIG está configurado, puede omitirlos y usar el ejemplo de configuración genérica en la sección MCP client configuration en su lugar.

Ejecute P4 MCP Server desde un contenedor Docker con transporte STDIO, permitiendo que los clientes MCP gestionen el ciclo de vida del contenedor.

Nota: La ejecución basada en Docker actualmente solo es compatible con macOS y Linux.

Requisitos previos

• Docker instalado y en ejecución
• Credenciales P4 válidas y acceso a un servidor P4

Extraer la imagen de Docker

docker pull ghcr.io/perforce/p4mcp-server:latest

cd /path/to/p4mcp-server
docker build -t ghcr.io/perforce/p4mcp-server .

Configurar el cliente MCP

Agregue lo siguiente a su mcp.json:

{
    "servers": {
        "perforce-p4mcp-docker": {
            "command": "docker",
            "args": [
                "run", "-i", "--rm",
                "--hostname", "your-hostname",
                "-e", "P4PORT=ssl:perforce.example.com:1666",
                "-e", "P4USER=your_username",
                "-e", "P4CLIENT=your_workspace",
                "-v", "/Users/your_username/.p4tickets:/home/mcpuser/.p4tickets:ro",
                "ghcr.io/perforce/p4mcp-server:latest"
            ]
        }
    }
}

Opciones de configuración

Autenticación

Usando tickets de P4:

# macOS/Linux
-v /Users/your_username/.p4tickets:/home/mcpuser/.p4tickets:ro

Nota: Use la ruta completa a su archivo de tickets (no ~). Después de ejecutar p4 login, reinicie el servidor MCP para recoger el nuevo ticket.

Usando una contraseña:

-e P4PASSWD="your_password"

Restricciones de host del workspace

⚠️ Importante: Los contenedores Docker tienen su propio nombre de host, que difiere del de su máquina local. Si su workspace de P4 está restringido a un host específico, operaciones como sync fallarán.

Para resolver esto, configure el nombre de host del contenedor para que coincida con la restricción de host de su workspace:

--hostname your-hostname

Para encontrar el nombre de host de su workspace:

# macOS/Linux
p4 client -o your_workspace | grep "^Host:"

Montaje de la raíz del cliente para operaciones de escritura

⚠️ Importante: Por defecto, el contenedor Docker no puede acceder a sus archivos de workspace locales. Para operaciones de escritura como sync, submit o reconcile, debe montar el directorio raíz de su cliente en el contenedor en la misma ruta.

Agregue un montaje de volumen para la raíz de su cliente:

-v /path/to/your/client/root:/path/to/your/client/root

Ejemplo de configuración con la raíz del cliente montada:

{
    "servers": {
        "perforce-p4mcp-docker": {
            "command": "docker",
            "args": [
                "run", "-i", "--rm",
                "--hostname", "your-hostname",
                "-e", "P4PORT=ssl:perforce.example.com:1666",
                "-e", "P4USER=your_username",
                "-e", "P4CLIENT=your_workspace",
                "-v", "/Users/your_username/.p4tickets:/home/mcpuser/.p4tickets",
                "-v", "/path/to/client/root:/path/to/client/root",
                "ghcr.io/perforce/p4mcp-server:latest"
            ]
        }
    }
}

Para encontrar la raíz de su cliente:

p4 client -o your_workspace | grep "^Root:"

Nota: La ruta de montaje dentro del contenedor debe coincidir exactamente con la ruta raíz del cliente, ya que P4 rastrea los archivos por sus rutas absolutas.

Ejecute el servidor MCP en una VM usando el transporte HTTP, permitiendo que los clientes se conecten a través de la red.

Inicie el servidor en la VM:

P4PORT=ssl:perforce.example.com:1666 P4USER=your_username P4PASSWD=YOUR_TICKET ./p4-mcp-server --readonly --transport http --port 8000

Configure el cliente MCP:

Agregue lo siguiente a su mcp.json:

{
    "servers": {
        "perforce-p4-mcp": {
            "type": "http",
            "url": "http://<ip-or-hostname>:8000/mcp"
        }
    }
}

Nota: Asegúrese de que el firewall de la VM permita conexiones entrantes en el puerto elegido. Para uso en producción, considere colocar el servidor detrás de un proxy inverso con TLS.

Ejecute el servidor MCP en un contenedor Docker usando transporte HTTP y exponga el endpoint de MCP a través de un puerto del host.

Inicie el contenedor:

docker run --rm -p 8000:8000 \
  -e P4PORT=ssl:perforce.example.com:1666 \
  -e P4USER=your_username \
  -e P4PASSWD=YOUR_TICKET \
  ghcr.io/perforce/p4mcp-server:latest \
  python3 -m p4mcp.main --readonly --transport http --port 8000

Configure el cliente MCP:

Agregue lo siguiente a su mcp.json:

{
  "servers": {
    "perforce-p4-mcp": {
      "type": "http",
      "url": "http://<ip-or-hostname>:8000/mcp"
    }
  }
}

Nota: Docker también admite el despliegue basado en HTTP. La imagen del contenedor usa transporte STDIO por defecto, por lo que el comando de inicio HTTP debe anular explícitamente el comando predeterminado. Si necesita operaciones de escritura, también monte las rutas de la raíz del cliente y del archivo de tickets en el contenedor.

Consulte la documentación de integración VCS de JetBrains AI Assistant para conocer los pasos de configuración detallados.

Consulte la documentación de MCP de Claude Code para obtener más información.

Usando uvx (sin instalación requerida):

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "uvx",
      "args": [
        "p4mcp-server",
        "--readonly", "--allow-usage"
      ],
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      }
    }
  }
}

Usando binario precompilado:

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Consulte la documentación de MCP de Cursor para obtener más información.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Consulte la documentación de MCP de Eclipse para obtener más información.

{
  "servers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Consulte la documentación de MCP de Kiro para obtener más información.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Consulte la documentación de VS Code para obtener más información.

{
  "servers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Consulte la documentación de MCP de Windsurf para obtener más información.

{
  "mcpServers": {
    "perforce-p4-mcp": {
      "command": "/absolute/path/to/p4-mcp-server",
      "env": {
        "P4PORT": "ssl:perforce.example.com:1666",
        "P4USER": "your_username",
        "P4CLIENT": "your_workspace"
      },
      "args": [
        "--readonly", "--allow-usage"
      ]
    }
  }
}

Para impedir el acceso a todos los miembros de un grupo específico:

p4 property -a -n mcp.enabled -v false -g noaccessgroup

Puede establecer múltiples restricciones de grupo de la misma manera.

Cuando un usuario pertenece a varios grupos con configuraciones conflictivas, la resolución de propiedades de P4 determina qué valor gana.

Gana el número de secuencia más alto (-s). Con números de secuencia iguales, gana el nombre de grupo alfabéticamente primero.

Ejemplo:

p4 property -a -n mcp.enabled -v false -s1 -g noaccessgroup
p4 property -a -n mcp.enabled -v true  -s2 -g accessgroup

En este ejemplo, accessgroup gana porque -s2 es mayor que -s1.

Para bloquear a un usuario específico independientemente de la pertenencia a grupos:

p4 property -a -n mcp.enabled -v false -u noaccessuser

Con el mismo número de secuencia, las propiedades a nivel de usuario anulan las configuraciones a nivel de grupo y globales (el desempate de ámbito de P4).

Ejemplo: Incluso si noaccessuser está en accessgroup (donde MCP está habilitado), la propiedad de usuario con la misma secuencia tiene prioridad y MCP queda deshabilitado.

Nota: Una propiedad de grupo con un valor de -s más alto puede anular una propiedad de usuario con un número de secuencia más bajo. Para asegurar que una propiedad a nivel de usuario siempre gane, asígnele un valor de -s alto o asegúrese de que ninguna propiedad de grupo use una secuencia más alta.

Restrinja qué conjuntos de herramientas están disponibles en todo el servidor usando mcp.toolsets.allowed. Solo se habilitarán los conjuntos de herramientas listados; todos los demás quedan bloqueados.

Conjuntos de herramientas disponibles: server, changelists, files, jobs, reviews, shelves, workspaces, streams

Permitir solo changelists y archivos:

p4 property -a -n mcp.toolsets.allowed -v changelists,files

Elimine la lista de permitidos para restaurar todos los conjuntos de herramientas:

p4 property -d -n mcp.toolsets.allowed

Deshabilite todas las operaciones de escritura (herramientas de modificación) mientras mantiene disponibles las operaciones de lectura (herramientas de consulta):

p4 property -a -n mcp.toolsets.write -v false

Vuelva a habilitar las escrituras:

p4 property -a -n mcp.toolsets.write -v true

Cuando write=false, todas las herramientas de modify_* quedan bloqueadas pero todas las herramientas de query_* continúan funcionando.

Habilite o deshabilite conjuntos de herramientas individuales para un grupo específico.

Deshabilitar un conjunto de herramientas para un grupo específico:

p4 property -a -n mcp.toolset.changelists.enabled -v false -g reviewers

Los usuarios en reviewers quedan bloqueados de los changelists. Los usuarios en otros grupos (sin configuración explícita) conservan el acceso predeterminado.

Para restringir un conjunto de herramientas a solo un grupo, deshabilítelo para cada otro grupo que no deba tener acceso:

p4 property -a -n mcp.toolset.files.enabled -v false -g reviewers
p4 property -a -n mcp.toolset.files.enabled -v false -g interns
# Only groups without an explicit "false" retain default access to files

Nota: Todos los conjuntos de herramientas están habilitados por defecto. Establecer enabled=true para un grupo es redundante a menos que esté anulando explícitamente una configuración previa de false. Con el mismo número de secuencia, una propiedad de grupo anula una propiedad global (el desempate de ámbito de P4), por lo que un enabled=true de grupo puede anular un enabled=false global. Para asegurar que una configuración global no pueda ser anulada, asígnele un valor de -s alto. Para aislar un conjunto de herramientas a grupos específicos, deshabilítelo para los grupos que desee bloquear.

Controla el acceso de escritura para cada conjunto de herramientas a nivel de grupo.

Deshabilita escrituras para un conjunto de herramientas específico por grupo:

p4 property -a -n mcp.toolset.workspaces.write -v false -g reviewers

Esto bloquea modify_workspaces para el grupo mientras query_workspaces permanece accesible.

Restringe un grupo a herramientas específicas dentro de un conjunto de herramientas usando mcp.toolset.<name>.tools.

Permite solo query_files (bloquea modify_files) para desarrolladores:

p4 property -a -n mcp.toolset.files.tools -v query_files -g developers

Permite consulta y modificación para líderes:

p4 property -a -n mcp.toolset.reviews.tools -v query_reviews,modify_reviews -g leads

Las anulaciones específicas de herramientas pueden restringir el acceso incluso cuando las escrituras están habilitadas:

p4 property -a -n mcp.toolsets.write -v true
p4 property -a -n mcp.toolset.files.tools -v query_files -g developers
# Result: modify_files is BLOCKED — tool list restricts

Nota: Las anulaciones específicas de herramientas no pueden eludir las restricciones de escritura. El servidor verifica los permisos de escritura antes de evaluar las listas de herramientas. Si write=false está configurado en cualquier nivel, las herramientas de escritura se bloquean independientemente de la lista de herramientas.

Cuando un usuario pertenece a múltiples grupos con configuraciones conflictivas, P4 resuelve cada propiedad a un único valor. El servidor MCP no realiza su propia lógica multi-grupo: utiliza el valor que P4 devuelva.

Reglas de resolución de P4 para un nombre de propiedad dado:

1. Gana el -s más alto (número de secuencia). Esta es la clave de ordenación principal.
2. Con el mismo número de secuencia: ámbito de usuario > ámbito de grupo > ámbito global.
3. Entre grupos con la misma secuencia: gana el nombre de grupo alfabéticamente primero.

P4 no compara valores. Elige la entrada ganadora por posición, no por contenido.

Ejemplo: grupos con la misma secuencia (predeterminado):

p4 property -a -n mcp.toolset.files.enabled -v true -g developers
p4 property -a -n mcp.toolset.files.enabled -v false -g leads
# User in both groups → resolved value is "true"
# Reason: "developers" < "leads" alphabetically, so developers wins

Intercambiar los valores daría false — developers sigue ganando independientemente del valor.

Ejemplo: solo un grupo tiene una configuración:

p4 property -a -n mcp.toolset.files.enabled -v false -g leads
# developers has no setting
# User in developers + leads → resolved value is "false"
# Reason: leads is the only group with a value, so it wins

Ejemplo: acceso de escritura:

p4 property -a -n mcp.toolset.files.write -v false -g developers
p4 property -a -n mcp.toolset.files.write -v true -g leads
# User in both groups → resolved value is "false"
# Reason: "developers" < "leads" alphabetically, not because false is "more restrictive"

Ejemplo: listas de herramientas (sin unión):

p4 property -a -n mcp.toolset.reviews.tools -v query_reviews -g developers
p4 property -a -n mcp.toolset.reviews.tools -v query_reviews,modify_reviews -g leads
# User in both groups → resolved value is "query_reviews"
# Reason: "developers" wins alphabetically. P4 returns one value, not a union.

Ejemplo: uso de -s para controlar qué grupo gana:

p4 property -a -n mcp.enabled -v false -s1 -g noaccessgroup
p4 property -a -n mcp.enabled -v true  -s2 -g accessgroup
# accessgroup wins because -s2 > -s1 (highest sequence wins)

Consejo: Para obtener resultados predecibles con múltiples grupos, usa siempre valores explícitos de -s en lugar de depender del orden alfabético de los nombres de grupo.

Deshabilita un único conjunto de herramientas para todos los usuarios sin afectar a otros:

p4 property -a -n mcp.toolset.reviews.enabled -v false

Esto bloquea tanto query_reviews como modify_reviews para todos los usuarios. Los demás conjuntos de herramientas no se ven afectados.

Restringe un grupo específico a solo lectura sin afectar a otros grupos:

p4 property -a -n mcp.toolsets.write -v false -g problematic_group

Los usuarios de otros grupos conservan acceso completo de escritura. Si un usuario pertenece tanto al grupo restringido como a un grupo no restringido, la resolución de propiedades de P4 determina el resultado: normalmente gana el nombre de grupo alfabéticamente primero con números de secuencia iguales. Usa valores explícitos de -s para obtener resultados predecibles.

• Acciones:
  • server_info - Obtener versión de P4, tiempo de actividad y configuración
  • current_user - Obtener información y permisos del usuario actual
• Casos de uso - Diagnóstico del servidor, verificación de usuario, prueba de conexión

• Acciones:
  • list - Listar todos los espacios de trabajo (opcionalmente filtrados por usuario)
  • get - Obtener una especificación detallada del espacio de trabajo
  • type - Verificar el tipo y la configuración del espacio de trabajo
  • status - Verificar el estado de sincronización del espacio de trabajo
• Parámetros: workspace_name, user, max_results
• Casos de uso: Descubrimiento de espacios de trabajo, revisión de configuración, verificación de estado

• Acciones:
  • get - Obtener información detallada del changelist (archivos, descripción, trabajos)
  • list - Listar changelists con filtros (estado, usuario, espacio de trabajo)
• Parámetros: changelist_id, status (pendiente/enviado), workspace_name, max_results
• Casos de uso: Revisión de código, seguimiento de historial, análisis de changelists

• Acciones:
  • content - Obtener contenido del archivo en una revisión específica
  • history - Obtener historial de revisiones del archivo y registros de integración
  • info - Obtener detalles básicos del archivo (tipo, tamaño, permisos)
  • metadata - Obtener metadatos del archivo (atributos, tamaño, etc.)
  • diff - Comparar versiones de archivos (depot a depot o mixto)
  • annotations - Obtener anotaciones del archivo con información de blame
  • search - Buscar archivos por patrón de nombre (coincidencia con comodines)
  • grep - Buscar archivos por patrón de contenido (búsqueda de texto)
• Parámetros: file_path, file2 (para diff), pattern (para búsqueda/grep), case_insensitive (para grep), max_results, diff2 (booleano)
• Casos de uso: Análisis de código, comparación de archivos, seguimiento de historial, análisis de blame, descubrimiento de archivos, búsqueda de contenido

• Acciones:
  • list - Listar cambios shelved por usuario o globalmente
  • diff - Mostrar diferencias en archivos shelved
  • files - Listar archivos en un shelf específico
• Parámetros: changelist_id, user, max_results
• Casos de uso: Revisión de código, seguimiento de trabajo en progreso, colaboración

• Acciones:
  • list_jobs - Listar trabajos asociados con un changelist
  • get_job - Obtener información detallada y estado del trabajo
• Parámetros: changelist_id, job_id, max_results
• Casos de uso: Seguimiento de defectos, trazabilidad de requisitos, gestión de proyectos

• Acciones:
  • list - Listar todas las revisiones con filtrado opcional
  • dashboard - Obtener el panel de revisiones del usuario actual (mis revisiones, requiere atención)
  • get - Obtener información detallada de la revisión
  • transitions - Obtener transiciones de estado disponibles para una revisión
  • files_readby - Obtener estado de archivos leídos por usuarios
  • files - Obtener archivos en una revisión (con rango de versiones opcional)
  • activity - Obtener historial de actividad de la revisión
  • comments - Obtener comentarios en una revisión
• Parámetros:
  • review_id - ID de revisión (requerido para get, transitions, files_readby, files, comments, activity)
  • review_fields - Campos separados por comas a devolver (p. ej., "id,description,author,state")
  • comments_fields - Campos para comentarios (predeterminado: "id,body,user,time")
  • up_voters - Lista de votos positivos para transiciones
  • from_version, to_version - Rango de versiones para la acción de archivos
  • max_results - Resultados máximos (predeterminado: 10)
• Casos de uso: Descubrimiento de revisiones de código, seguimiento de estado de revisiones, recuperación de comentarios, monitoreo de actividad de revisiones

• Acciones - create, update, delete, switch
• Parámetros - name, specs (objeto WorkspaceSpec con View, Root, Options, etc.)
• Requiere - Modo de solo lectura desactivado, permisos adecuados
• Casos de uso - Configuración del entorno, mantenimiento de workspaces, cambio de rama

• Acciones - create, update, submit, delete, move_files
• Parámetros - changelist_id, description, file_paths
• Seguridad - Comprobaciones de propiedad, aviso interactivo de solicitud PROCEED/CANCEL para operaciones de eliminación con detalles de los elementos
• Casos de uso - Envío de código, organización del trabajo, agrupación de archivos

• Acciones - add, edit, delete, move, revert, reconcile, resolve, sync
• Parámetros - file_paths, changelist, force, mode (para operaciones de resolución)
• Modos de resolución - auto, safe, force, preview, theirs, yours
• Casos de uso - Edición de archivos, resolución de conflictos, sincronización de workspaces

• Acciones - shelve, unshelve, update, delete, unshelve_to_changelist
• Parámetros - changelist_id, file_paths, target_changelist, force
• Casos de uso - Almacenamiento temporal, compartición de código, copia de seguridad antes de experimentos

• Acciones - link_job, unlink_job
• Parámetros - changelist_id, job_id
• Casos de uso - Integración de seguimiento de defectos, vinculación de requisitos

• Acciones:
  • create - Crear un nuevo review a partir de un changelist
  • refresh_projects - Actualizar las asociaciones de proyecto
  • vote - Votar en un review (a favor, en contra, limpiar)
  • transition - Cambiar el estado del review (needsRevision, needsReview, approved, committed, rejected, archived)
  • append_participants - Añadir revisores/grupos a un review
  • replace_participants - Reemplazar todos los participantes
  • delete_participants - Eliminar participantes de un review
  • add_comment - Añadir un comentario a un review
  • reply_comment - Responder a un comentario existente
  • append_change - Añadir un changelist a un review existente
  • replace_with_change - Reemplazar el contenido del review con un changelist
  • join - Unirse a un review como participante
  • leave - Abandonar un review
  • archive_inactive - Archivar reviews inactivos
  • mark_comment_read / mark_comment_unread - Marcar el estado de lectura de un comentario individual
  • mark_all_comments_read / mark_all_comments_unread - Marcar el estado de lectura de todos los comentarios
  • update_author - Cambiar el autor del review
  • update_description - Actualizar la descripción del review
  • obliterate - Eliminar permanentemente un review
• Parámetros:
  • review_id - ID del review (requerido para la mayoría de las acciones)
  • change_id - ID del changelist (requerido para create, append_change, replace_with_change)
  • description - Descripción del review
  • reviewers, required_reviewers - Listas de nombres de usuario de revisores
  • reviewer_groups - Grupos de revisores con requisitos
  • vote_value - Valor del voto: up, down, clear
  • version - Versión del review para votar
  • transition - Estado objetivo: needsRevision, needsReview, approved, committed, approved:commit, rejected, archived
  • jobs, fix_status, cleanup - Opciones de vinculación de jobs y limpieza para transiciones
  • users, groups - Datos estructurados de participantes para append/replace/delete
  • body - Texto del cuerpo del comentario
  • task_state - Estado de la tarea del comentario: open, comment
  • notify - Modo de notificación: immediate, delayed
  • comment_id - ID del comentario para respuestas o para marcar como leído/no leído
  • context - Contexto del comentario (archivo, números de línea, contenido, versión)
  • not_updated_since, max_reviews - Filtros para archive_inactive
  • new_author, new_description - Valores para acciones de actualización
• Casos de uso: Flujo de trabajo de revisión de código, gestión del estado de reviews, comentarios colaborativos, gestión de participantes, limpieza de reviews

• Acciones:
  • create - Crear un nuevo stream (mainline, development, release, task, virtual, etc.)
  • update - Actualizar propiedades del stream (name, description, options, paths, parent_view)
  • delete - Eliminar un stream
  • edit_spec - Abrir la especificación del stream para edición (p4 stream edit)
  • resolve_spec - Resolver conflictos de especificación de stream
  • revert_spec - Revertir ediciones de la especificación del stream
  • shelve_spec - Hacer shelve de las ediciones de la especificación del stream a un changelist numerado
  • unshelve_spec - Hacer unshelve de las ediciones de la especificación del stream
  • copy - Copiar cambios entre streams padre e hijo
  • merge - Fusionar cambios entre streams padre e hijo
  • integrate - Integrar cambios con opciones avanzadas
  • populate - Poblar un nuevo stream con archivos (branch)
  • switch - Cambiar un workspace a un stream diferente
  • create_workspace - Crear un nuevo workspace vinculado a un stream
• Parámetros:
  • stream_name - Ruta de depot del stream (requerida para create, update, delete, edit_spec, resolve_spec, revert_spec, switch)
  • stream_type - Tipo de stream para create: mainline, development, sparsedev, release, sparserel, task, virtual
  • parent - Stream padre para create que no sea mainline
  • name, description - Nombre visible y descripción del stream
  • options - Opciones del stream: allsubmit/ownersubmit, unlocked/locked, toparent/notoparent, fromparent/nofromparent, mergedown/mergeany
  • parent_view - Tratamiento de la vista del padre: inherit o noinherit
  • paths, remapped, ignored - Mapeos de vista del stream
  • changelist - Changelist para operaciones de edición de especificación o propagación
  • resolve_mode - Modo de resolución para resolve_spec: auto, accept_theirs, accept_yours
  • parent_stream - Anular el padre para propagación (bandera -P)
  • branch - Especificación de branch para integrate/populate (bandera -b)
  • file_paths - Rutas de archivo para propagación
  • preview - Solo vista previa, sin cambios (bandera -n)
  • force - Forzar operación (bandera -f)
  • reverse - Invertir dirección (bandera -r)
  • max_files - Limitar archivos procesados (bandera -m)
  • quiet - Suprimir mensajes informativos (bandera -q)
  • output_base - Mostrar la revisión base con resolución programada (bandera -Ob para merge/integrate) o listar archivos creados (bandera -o para populate)
  • virtual - Copiar usando stream virtual (bandera -v, solo copy)
  • schedule_branch_resolve - Programar resoluciones de branch en lugar de ramificación automática (bandera -Rb, solo integrate)
  • integrate_around_deleted - Integrar omitiendo revisiones eliminadas (bandera -Di, solo integrate)
  • skip_cherry_picked - Omitir revisiones cherry-picked ya integradas (bandera -Rs, solo integrate)
  • source_path, target_path - Rutas de origen y destino para populate
  • workspace - Nombre del workspace para switch
  • workspace_name, root, host, alt_roots - Parámetros de creación de workspace
• Seguridad: Validación de existencia del stream, detección de streams bloqueados, advertencias de workspaces vinculados, comprobaciones de archivos abiertos para cambios que afectan a la vista
• Casos de uso: Creación y gestión de streams, propagación de ramas (merge/copy/integrate), resolución de conflictos de especificación, aprovisionamiento de workspaces

Síntomas: El sistema operativo no puede encontrar o ejecutar el binario; el error incluye ENOENT o "No such file or directory".
Soluciones:

1. Verifica la ruta: Asegúrate de que el campo command use la ruta absoluta correcta para tu sistema operativo:
   • macOS/Linux: /absolute/path/to/p4-mcp-server
   • Windows: C:\absolute\path\to\p4-mcp-server.exe
2. Asegúrate de que el binario exista y sea ejecutable:
   • macOS/Linux:

     ls -l /absolute/path/to/p4-mcp-server && chmod +x /absolute/path/to/p4-mcp-server
     

   • Windows:

     dir C:\absolute\path\to\p4-mcp-server.exe
     

3. En Windows, asegúrate de que el binario no esté bloqueado:
   • Haz clic derecho en el archivo .exe, selecciona Propiedades y, si está presente, haz clic en Desbloquear.

Síntomas: No se puede conectar al servidor P4
Soluciones:

1. Verifica la variable de entorno P4PORT: echo $P4PORT (macOS) o echo $env:P4PORT (Windows)
2. Prueba la conexión directa: p4 info
3. Verifica la disponibilidad del servidor: ping perforce.example.com
4. Verifica el puerto y el protocolo (prefijo ssl: para conexiones SSL).

Síntomas: Errores de confianza SSL al conectar con el servidor P4 Soluciones:

1. Confía en el servidor: p4 trust -f -y
2. Verifica el estado de confianza: p4 trust -l
3. Para problemas persistentes, verifica la configuración SSL.

Síntomas: Errores CERTIFICATE_VERIFY_FAILED al usar herramientas de revisión Soluciones:

1. Almacén de confianza del sistema: Por defecto, el servidor usa el almacén de confianza del sistema operativo a través de truststore. Asegúrate de que tu CA corporativa esté instalada en el almacén de certificados del sistema operativo.
2. Paquete de CA personalizado: Para usar un certificado CA personalizado, primero debes establecer P4MCP_TLS_CA_MODE=certifi (para deshabilitar truststore), luego proporcionar la ruta de CA mediante --ca-bundle /path/to/ca.pem o P4MCP_CA_BUNDLE. En el modo system predeterminado, truststore anula los paquetes de CA personalizados y se ignoran silenciosamente.
3. Deshabilitar verificación: Usa --ssl-no-verify o establece P4MCP_SSL_VERIFY=false (no recomendado para producción). Esto funciona en ambos modos TLS.

Nota: Estos ajustes SSL solo se aplican cuando la URL de Swarm usa HTTPS. Si Swarm está configurado con una URL http://, no se realiza verificación SSL y estos ajustes no tienen efecto.

Síntomas: Fallos de autenticación
Soluciones:

1. Inicia sesión en P4: p4 login -a
2. Verifica el estado de inicio de sesión: p4 login -s
3. Verifica que el usuario exista: p4 users -m 1 your_username
4. Para problemas persistentes, verifica la contraseña o usa autenticación basada en tickets.

Síntomas: Fallos de inicio de sesión
Soluciones:

1. Restablece la contraseña a través de un administrador de P4.
2. Usa autenticación basada en tickets: p4 login -a
3. Verifica que el nombre de usuario sea correcto: p4 info

Síntomas: Errores de espacio de trabajo no encontrado
Soluciones:

1. Lista los espacios de trabajo disponibles: p4 clients
2. Verifica la variable de entorno P4CLIENT.
3. Crea un espacio de trabajo si es necesario: p4 client workspace_name
4. Verifica la propiedad del espacio de trabajo: p4 client -o workspace_name

Síntomas: Los archivos están fuera del mapeo del espacio de trabajo
Soluciones:

1. Verifica la vista del cliente: p4 client -o workspace_name
2. Actualiza el mapeo del espacio de trabajo para incluir las rutas requeridas.
3. Usa p4 where file_path para verificar el mapeo.

Síntomas: Permisos insuficientes para operaciones
Soluciones:

1. Verifica la propiedad del archivo: p4 opened file_path
2. Verifica los permisos del usuario: p4 protects file_path
3. Asegúrate de tener la membresía de grupo adecuada.
4. Para operaciones de administración, verifica los permisos de administrador.

Síntomas: Conflictos de bloqueo exclusivo
Soluciones:

1. Verifica quién tiene el archivo abierto: p4 opened file_path
2. Contacta al usuario para resolver conflictos.
3. El administrador puede forzar operaciones si es necesario.

Síntomas: Tiempos de respuesta largos
Soluciones:

1. Usa el parámetro max_results para limitar el tamaño de la consulta.
2. Usa rutas de archivo específicas en lugar de comodines.
3. Verifica la conectividad de red con P4.
4. Monitorea el rendimiento del servidor.

Síntomas: Alto uso de memoria
Soluciones:

1. Reduce max_results para consultas grandes.
2. Procesa archivos en lotes.
3. Reinicia el servidor MCP periódicamente para sesiones de larga duración.

Síntomas: Conflicto con herramientas integradas u otras herramientas MCP
Soluciones:

1. Desactiva cualquier herramienta integrada o en conflicto del servidor MCP en tu entorno o configuración.
2. Asegúrate de que las herramientas del servidor MCP P4 estén correctamente registradas y habilitadas.
3. Reinicia el servidor MCP después de aplicar cambios de configuración para cargar las herramientas correctas.

Síntomas: Contexto inválido o historial de sesión desactualizado
Soluciones:

1. Proporciona un contexto relacionado con P4 al escribir indicaciones.
2. Inicia una nueva sesión si la sesión existente es antigua o contiene historial de indicaciones conflictivo.