P4 MCP Server

Se você tiver o uv instalado, pode executar o P4 MCP Server diretamente sem qualquer instalação manual:

# Run the server
uvx p4mcp-server

# Check version
uvx p4mcp-server --version

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

Isso busca e executa automaticamente a versão mais recente do PyPI. Não é necessário configurar ambiente virtual Python ou gerenciar dependências.

Requisitos:

• uv instalado no seu sistema
• Python 3.11+ (o uv cuidará disso automaticamente)

Baixe o binário apropriado para o seu sistema operacional:

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

Extraia e use o executável diretamente. Nenhuma instalação do Python é necessária.

# 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+ (com Tkinter)

Compilar:

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

Saída:

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

Execute o P4 MCP Server diretamente na sua máquina usando o transporte STDIO padrão.

Adicione o seguinte ao seu 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 exemplo mostra valores explícitos de env. Se P4CONFIG estiver definido, você pode omiti-los e usar o exemplo de configuração genérica na seção MCP client configuration.

Execute o P4 MCP Server a partir de um contêiner Docker com transporte STDIO, permitindo que clientes MCP gerenciem o ciclo de vida do contêiner.

Nota: A execução baseada em Docker é atualmente suportada apenas em macOS e Linux.

Pré-requisitos

• Docker instalado e em execução
• Credenciais P4 válidas e acesso a um servidor P4

Baixar a imagem Docker

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

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

Configurar o Cliente MCP

Adicione o seguinte ao seu 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"
            ]
        }
    }
}

Opções de Configuração

Autenticação

Usando tickets P4:

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

Nota: Use o caminho completo para o seu arquivo de tickets (não ~). Após executar p4 login, reinicie o servidor MCP para aplicar o novo ticket.

Usando uma senha:

-e P4PASSWD="your_password"

Restrições de Host do Workspace

⚠️ Importante: Contêineres Docker têm seu próprio hostname, que difere da sua máquina local. Se o seu workspace P4 estiver restrito a um host específico, operações como sync falharão.

Para resolver isso, defina o hostname do contêiner para corresponder à restrição de host do seu workspace:

--hostname your-hostname

Para descobrir o nome do host do seu workspace:

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

Montando o Client Root para Operações de Escrita

⚠️ Importante: Por padrão, o contêiner Docker não pode acessar os arquivos locais do seu workspace. Para operações de escrita como sync, submit ou reconcile, você deve montar o diretório do seu client root no contêiner no mesmo caminho.

Adicione uma montagem de volume para o seu client root:

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

Exemplo de configuração com client root montado:

{
    "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 descobrir o seu client root:

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

Nota: O caminho de montagem dentro do contêiner deve corresponder exatamente ao caminho do client root, pois o P4 rastreia arquivos por seus caminhos absolutos.

Execute o servidor MCP em uma VM usando o transporte HTTP, permitindo que clientes se conectem pela rede.

Inicie o servidor na VM:

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

Configure o cliente MCP:

Adicione o seguinte ao seu mcp.json:

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

Nota: Certifique-se de que o firewall da VM permita conexões de entrada na porta escolhida. Para uso em produção, considere colocar o servidor atrás de um proxy reverso com TLS.

Execute o servidor MCP em um contêiner Docker usando transporte HTTP e exponha o endpoint MCP em uma porta do host.

Inicie o contêiner:

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 o cliente MCP:

Adicione o seguinte ao seu mcp.json:

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

Nota: Docker também suporta implantação baseada em HTTP. A imagem do contêiner usa transporte STDIO por padrão, então o comando de inicialização HTTP deve substituir explicitamente o comando padrão. Se você precisar de operações de escrita, monte também os caminhos do client root e do arquivo de tickets no contêiner.

Consulte a documentação de Integração VCS do JetBrains AI Assistant para etapas detalhadas de configuração.

Consulte a documentação MCP do Claude Code para mais informações.

Usando uvx (sem necessidade de instalação):

{
  "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 binário pré-compilado:

{
  "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 a documentação MCP do Cursor para mais informações.

{
  "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 a documentação MCP do Eclipse para mais informações.

{
  "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 a documentação MCP do Kiro para mais informações.

{
  "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 a documentação do VS Code para mais informações.

{
  "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 a documentação MCP do Windsurf para mais informações.

{
  "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 o acesso de todos os membros de um grupo específico:

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

Você pode definir várias restrições de grupo da mesma maneira.

Quando um usuário pertence a vários grupos com configurações conflitantes, a resolução de propriedades do P4 determina qual valor vence.

O maior número de sequência (-s) vence. Em números de sequência iguais, o nome do grupo em ordem alfabética primeiro vence.

Exemplo:

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

Neste exemplo, accessgroup vence porque -s2 é maior que -s1.

Para bloquear um usuário específico independentemente da associação ao grupo:

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

No mesmo número de sequência, propriedades em nível de usuário substituem configurações em nível de grupo e global (desempate de escopo do P4).

Exemplo: Mesmo se noaccessuser estiver em accessgroup (onde o MCP está habilitado), a propriedade do usuário no mesmo número de sequência tem precedência e o MCP é desativado.

Nota: Uma propriedade de grupo com um valor de -s maior pode substituir uma propriedade de usuário com um número de sequência menor. Para garantir que uma propriedade em nível de usuário sempre vença, dê a ela um valor alto de -s ou garanta que nenhuma propriedade de grupo use um número de sequência maior.

Restrinja quais conjuntos de ferramentas estão disponíveis em todo o servidor usando mcp.toolsets.allowed. Apenas os conjuntos de ferramentas listados serão habilitados; todos os outros são bloqueados.

Conjuntos de ferramentas disponíveis: server, changelists, files, jobs, reviews, shelves, workspaces, streams

Permitir apenas changelists e arquivos:

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

Remova a lista de permissões para restaurar todos os conjuntos de ferramentas:

p4 property -d -n mcp.toolsets.allowed

Desative todas as operações de escrita (ferramentas de modificação) mantendo as operações de leitura (ferramentas de consulta) disponíveis:

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

Reative as escritas:

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

Quando write=false, todas as ferramentas modify_* são bloqueadas, mas todas as ferramentas query_* continuam funcionando.

Habilite ou desabilite conjuntos de ferramentas individuais para um grupo específico.

Desabilite um conjunto de ferramentas para um grupo específico:

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

Usuários em reviewers são bloqueados de changelists. Usuários em outros grupos (sem configuração explícita) mantêm o acesso padrão.

Para restringir um conjunto de ferramentas a apenas um grupo, desabilite-o para todos os outros grupos que não devem ter acesso:

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 os conjuntos de ferramentas são habilitados por padrão. Definir enabled=true para um grupo é redundante, a menos que você esteja explicitamente substituindo uma configuração anterior de false. No mesmo número de sequência, uma propriedade de grupo substitui uma propriedade global (desempate de escopo do P4), portanto, um enabled=true de grupo pode substituir um enabled=false global. Para garantir que uma configuração global não possa ser substituída, dê a ela um valor alto de -s. Para isolar um conjunto de ferramentas para grupos específicos, desabilite-o para os grupos que você deseja bloquear.

Controle o acesso de escrita para cada toolset no nível do grupo.

Desative gravações para um toolset específico por grupo:

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

Isso bloqueia modify_workspaces para o grupo enquanto query_workspaces permanece acessível.

Restrinja um grupo a ferramentas específicas dentro de um toolset usando mcp.toolset.<name>.tools.

Permita apenas query_files (bloqueie modify_files) para desenvolvedores:

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

Permita consulta e modificação para leads:

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

Substituições específicas por ferramenta podem restringir o acesso mesmo quando as gravações estão 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: Substituições específicas por ferramenta não podem contornar restrições de escrita. O servidor verifica as permissões de escrita antes de avaliar as listas de ferramentas. Se write=false estiver definido em qualquer nível, as ferramentas de escrita são bloqueadas independentemente da lista de ferramentas.

Quando um usuário pertence a vários grupos com configurações conflitantes, o P4 resolve cada propriedade para um único valor. O servidor MCP não executa sua própria lógica de múltiplos grupos — ele usa o valor que o P4 retorna.

Regras de resolução do P4 para um determinado nome de propriedade:

1. Maior -s (número de sequência) vence. Esta é a chave de ordenação primária.
2. No mesmo número de sequência: escopo do usuário > escopo do grupo > escopo global.
3. Entre grupos na mesma sequência: o nome do grupo em ordem alfabética primeiro vence.

O P4 não compara valores. Ele escolhe a entrada vencedora pela posição, não pelo conteúdo.

Exemplo — grupos na mesma sequência (padrão):

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

Trocar os valores daria false — developers ainda vence independentemente do valor.

Exemplo — apenas um grupo tem uma configuração:

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

Exemplo — acesso de escrita:

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"

Exemplo — listas de ferramentas (sem união):

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.

Exemplo — usando -s para controlar qual grupo vence:

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)

Dica: Para obter resultados previsíveis com vários grupos, use sempre valores explícitos de -s em vez de depender da ordem alfabética dos nomes dos grupos.

Desative um único toolset para todos os usuários sem afetar os outros:

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

Isso bloqueia tanto query_reviews quanto modify_reviews para todos os usuários. Os demais toolsets permanecem inalterados.

Restrinja um grupo específico a somente leitura sem afetar outros grupos:

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

Usuários em outros grupos mantêm acesso total de escrita. Se um usuário pertencer tanto ao grupo restrito quanto a um grupo não restrito, a resolução de propriedades do P4 determina o resultado — normalmente o nome do grupo em ordem alfabética primeiro vence em números de sequência iguais. Use valores explícitos de -s para resultados previsíveis.

• Ações:
  • server_info - Obter versão do P4, tempo de atividade e configuração
  • current_user - Obter informações do usuário atual e permissões
• Casos de uso - Diagnóstico do servidor, verificação de usuário, teste de conexão

• Ações:
  • list - Listar todos os workspaces (opcionalmente filtrados por usuário)
  • get - Obter uma especificação detalhada do workspace
  • type - Verificar tipo e configuração do workspace
  • status - Verificar status de sincronização do workspace
• Parâmetros: workspace_name, user, max_results
• Casos de uso: Descoberta de workspaces, revisão de configuração, verificação de status

• Ações:
  • get - Obter informações detalhadas do changelist (arquivos, descrição, jobs)
  • list - Listar changelists com filtros (status, usuário, workspace)
• Parâmetros: changelist_id, status (pendente/enviado), workspace_name, max_results
• Casos de uso: Revisão de código, rastreamento de histórico, análise de changelists

• Ações:
  • content - Obter conteúdo do arquivo em uma revisão específica
  • history - Obter histórico de revisões do arquivo e registros de integração
  • info - Obter detalhes básicos do arquivo (tipo, tamanho, permissões)
  • metadata - Obter metadados do arquivo (atributos, tamanho, etc.)
  • diff - Comparar versões de arquivo (depot a depot ou misto)
  • annotations - Obter anotações do arquivo com informações de blame
  • search - Pesquisar arquivos por padrão de nome (correspondência com curingas)
  • grep - Pesquisar arquivos por padrão de conteúdo (pesquisa de texto)
• Parâmetros: file_path, file2 (para diff), pattern (para pesquisa/grep), case_insensitive (para grep), max_results, diff2 (booleano)
• Casos de uso: Análise de código, comparação de arquivos, rastreamento de histórico, análise de blame, descoberta de arquivos, pesquisa de conteúdo

• Ações:
  • list - Listar alterações shelved por usuário ou globalmente
  • diff - Mostrar diferenças em arquivos shelved
  • files - Listar arquivos em um shelf específico
• Parâmetros: changelist_id, user, max_results
• Casos de uso: Revisão de código, rastreamento de trabalho em andamento, colaboração

• Ações:
  • list_jobs - Listar jobs associados a um changelist
  • get_job - Obter informações detalhadas do job e status
• Parâmetros: changelist_id, job_id, max_results
• Casos de uso: Rastreamento de defeitos, rastreabilidade de requisitos, gerenciamento de projetos

• Ações:
  • list - Listar todos os reviews com filtragem opcional
  • dashboard - Obter o painel de reviews do usuário atual (meus reviews, precisa de atenção)
  • get - Obter informações detalhadas do review
  • transitions - Obter transições de estado disponíveis para um review
  • files_readby - Obter status de leitura de arquivos por usuários
  • files - Obter arquivos em um review (com intervalo de versão opcional)
  • activity - Obter histórico de atividade do review
  • comments - Obter comentários em um review
• Parâmetros:
  • review_id - ID do review (obrigatório para get, transitions, files_readby, files, comments, activity)
  • review_fields - Campos separados por vírgula a retornar (ex.: "id,description,author,state")
  • comments_fields - Campos para comentários (padrão: "id,body,user,time")
  • up_voters - Lista de up voters para transições
  • from_version, to_version - Intervalo de versão para a ação de arquivos
  • max_results - Máximo de resultados (padrão: 10)
• Casos de uso: Descoberta de reviews de código, rastreamento de status de reviews, recuperação de comentários, monitoramento de atividade de reviews

• Ações - create, update, delete, switch
• Parâmetros - name, specs (objeto WorkspaceSpec com View, Root, Options, etc.)
• Requisitos - Modo somente leitura desabilitado, permissões apropriadas
• Casos de uso - Configuração de ambiente, manutenção de workspace, troca de branch

• Ações - create, update, submit, delete, move_files
• Parâmetros - changelist_id, description, file_paths
• Segurança - Verificações de propriedade, prompt interativo PROCEED/CANCEL para operações de exclusão com detalhes dos itens
• Casos de uso - Submissão de código, organização de trabalho, agrupamento de arquivos

• Ações - add, edit, delete, move, revert, reconcile, resolve, sync
• Parâmetros - file_paths, changelist, force, mode (para operações de resolve)
• Modos de resolve - auto, safe, force, preview, theirs, yours
• Casos de uso - Edição de arquivos, resolução de conflitos, sincronização de workspace

• Ações - shelve, unshelve, update, delete, unshelve_to_changelist
• Parâmetros - changelist_id, file_paths, target_changelist, force
• Casos de uso - Armazenamento temporário, compartilhamento de código, backup antes de experimentos

• Ações - link_job, unlink_job
• Parâmetros - changelist_id, job_id
• Casos de uso - Integração de rastreamento de defeitos, vinculação de requisitos

• Ações:
  • create - Criar um novo review a partir de um changelist
  • refresh_projects - Atualizar associações de projeto
  • vote - Votar em um review (up, down, clear)
  • transition - Alterar o estado do review (needsRevision, needsReview, approved, committed, rejected, archived)
  • append_participants - Adicionar revisores/grupos a um review
  • replace_participants - Substituir todos os participantes
  • delete_participants - Remover participantes de um review
  • add_comment - Adicionar um comentário a um review
  • reply_comment - Responder a um comentário existente
  • append_change - Adicionar um changelist a um review existente
  • replace_with_change - Substituir o conteúdo do review por um changelist
  • join - Entrar em um review como participante
  • leave - Sair de um review
  • archive_inactive - Arquivar reviews inativos
  • mark_comment_read / mark_comment_unread - Marcar status de leitura de comentário individual
  • mark_all_comments_read / mark_all_comments_unread - Marcar status de leitura de todos os comentários
  • update_author - Alterar o autor do review
  • update_description - Atualizar a descrição do review
  • obliterate - Excluir permanentemente um review
• Parâmetros:
  • review_id - ID do review (obrigatório para a maioria das ações)
  • change_id - ID do changelist (obrigatório para create, append_change, replace_with_change)
  • description - Descrição do review
  • reviewers, required_reviewers - Listas de nomes de usuário dos revisores
  • reviewer_groups - Grupos de revisores com requisitos
  • vote_value - Valor do voto: up, down, clear
  • version - Versão do review para votação
  • transition - Estado alvo: needsRevision, needsReview, approved, committed, approved:commit, rejected, archived
  • jobs, fix_status, cleanup - Opções de vinculação de jobs e limpeza para transições
  • users, groups - Dados estruturados de participantes para append/replace/delete
  • body - Texto do corpo do comentário
  • task_state - Estado de tarefa do comentário: open, comment
  • notify - Modo de notificação: immediate, delayed
  • comment_id - ID do comentário para respostas ou marcação de lido/não lido
  • context - Contexto do comentário (arquivo, números de linha, conteúdo, versão)
  • not_updated_since, max_reviews - Filtros para archive_inactive
  • new_author, new_description - Valores para ações de atualização
• Casos de uso: Fluxo de trabalho de revisão de código, gerenciamento de estado de review, comentários colaborativos, gerenciamento de participantes, limpeza de reviews

• Ações:
  • create - Criar um novo stream (mainline, development, release, task, virtual, etc.)
  • update - Atualizar propriedades do stream (nome, descrição, opções, paths, parent_view)
  • delete - Excluir um stream
  • edit_spec - Abrir especificação do stream para edição (p4 stream edit)
  • resolve_spec - Resolver conflitos de especificação de stream
  • revert_spec - Reverter edições de especificação de stream
  • shelve_spec - Shelve de edições de especificação de stream em um changelist numerado
  • unshelve_spec - Unshelve de edições de especificação de stream
  • copy - Copiar alterações entre streams pai e filho
  • merge - Mesclar alterações entre streams pai e filho
  • integrate - Integrar alterações com opções avançadas
  • populate - Popular um novo stream com arquivos (branch)
  • switch - Alternar um workspace para um stream diferente
  • create_workspace - Criar um novo workspace vinculado a um stream
• Parâmetros:
  • stream_name - Caminho de depósito do stream (obrigatório 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 pai para create não-mainline
  • name, description - Nome de exibição e descrição do stream
  • options - Opções do stream: allsubmit/ownersubmit, unlocked/locked, toparent/notoparent, fromparent/nofromparent, mergedown/mergeany
  • parent_view - Tratamento da view do pai: inherit ou noinherit
  • paths, remapped, ignored - Mapeamentos de view do stream
  • changelist - Changelist para edição de especificação ou operações de propagação
  • resolve_mode - Modo de resolve para resolve_spec: auto, accept_theirs, accept_yours
  • parent_stream - Substituir pai para propagação (flag -P)
  • branch - Especificação de branch para integrate/populate (flag -b)
  • file_paths - Caminhos de arquivo para propagação
  • preview - Somente pré-visualização, sem alterações (flag -n)
  • force - Forçar operação (flag -f)
  • reverse - Inverter direção (flag -r)
  • max_files - Limitar arquivos processados (flag -m)
  • quiet - Suprimir mensagens informativas (flag -q)
  • output_base - Mostrar revisão base com resolve agendado (flag -Ob para merge/integrate) ou listar arquivos criados (flag -o para populate)
  • virtual - Copiar usando stream virtual (flag -v, somente copy)
  • schedule_branch_resolve - Agendar resolves de branch em vez de branch automático (flag -Rb, somente integrate)
  • integrate_around_deleted - Integrar ignorando revisões excluídas (flag -Di, somente integrate)
  • skip_cherry_picked - Pular revisões cherry-picked já integradas (flag -Rs, somente integrate)
  • source_path, target_path - Caminhos de origem e destino para populate
  • workspace - Nome do workspace para switch
  • workspace_name, root, host, alt_roots - Parâmetros de criação de workspace
• Segurança: Validação de existência do stream, detecção de stream bloqueado, avisos de workspace vinculado, verificações de arquivos abertos para alterações que afetam a view
• Casos de uso: Criação e gerenciamento de streams, propagação de branch (merge/copy/integrate), resolução de conflitos de especificação, provisionamento de workspaces

Sintomas: O sistema operacional não consegue encontrar ou executar o binário; o erro inclui ENOENT ou "No such file or directory".
Soluções:

1. Verifique o caminho: Certifique-se de que o campo command use o caminho absoluto correto para o seu sistema operacional:
   • macOS/Linux: /absolute/path/to/p4-mcp-server
   • Windows: C:\absolute\path\to\p4-mcp-server.exe
2. Garanta que o binário exista e seja executável:
   • 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. No Windows, garanta que o binário não esteja bloqueado:
   • Clique com o botão direito no arquivo .exe, selecione Propriedades e, se presente, clique em Desbloquear.

Sintomas: Não é possível conectar ao servidor P4
Soluções:

1. Verifique a variável de ambiente P4PORT: echo $P4PORT (macOS) ou echo $env:P4PORT (Windows)
2. Teste a conexão direta: p4 info
3. Verifique a disponibilidade do servidor: ping perforce.example.com
4. Verifique a porta e o protocolo (prefixo ssl: para conexões SSL).

Sintomas: Erros de confiança SSL ao conectar ao servidor P4 Soluções:

1. Confie no servidor: p4 trust -f -y
2. Verifique o status de confiança: p4 trust -l
3. Para problemas persistentes, verifique a configuração SSL.

Sintomas: Erros CERTIFICATE_VERIFY_FAILED ao usar ferramentas de revisão Soluções:

1. Repositório de confiança do sistema: Por padrão, o servidor usa o repositório de confiança do sistema operacional via truststore. Certifique-se de que o CA corporativo esteja instalado no repositório de certificados do sistema operacional.
2. Pacote de CA personalizado: Para usar um certificado CA personalizado, você deve primeiro definir P4MCP_TLS_CA_MODE=certifi (para desabilitar truststore) e, em seguida, fornecer o caminho do CA via --ca-bundle /path/to/ca.pem ou P4MCP_CA_BUNDLE. No modo padrão system, truststore substitui os pacotes de CA personalizados e eles são silenciosamente ignorados.
3. Desabilitar verificação: Use --ssl-no-verify ou defina P4MCP_SSL_VERIFY=false (não recomendado para produção). Isso funciona em ambos os modos TLS.

Nota: Essas configurações SSL se aplicam somente quando a URL do Swarm usa HTTPS. Se o Swarm estiver configurado com uma URL http://, a verificação SSL não é realizada e essas configurações não têm efeito.

Sintomas: Falhas de autenticação
Soluções:

1. Faça login no P4: p4 login -a
2. Verifique o status do login: p4 login -s
3. Verifique se o usuário existe: p4 users -m 1 your_username
4. Para problemas persistentes, verifique a senha ou use autenticação baseada em ticket.

Sintomas: Falhas de login
Soluções:

1. Redefina a senha por meio de um administrador do P4.
2. Use autenticação baseada em ticket: p4 login -a
3. Verifique se o nome de usuário está correto: p4 info

Sintomas: Erros de workspace não encontrado
Soluções:

1. Liste os workspaces disponíveis: p4 clients
2. Verifique a variável de ambiente P4CLIENT.
3. Crie um workspace se necessário: p4 client workspace_name
4. Verifique a propriedade do workspace: p4 client -o workspace_name

Sintomas: Arquivos fora do mapeamento do workspace
Soluções:

1. Verifique a visão do cliente: p4 client -o workspace_name
2. Atualize o mapeamento do workspace para incluir os caminhos necessários.
3. Use p4 where file_path para verificar o mapeamento.

Sintomas: Permissões insuficientes para operações
Soluções:

1. Verifique a propriedade do arquivo: p4 opened file_path
2. Verifique as permissões do usuário: p4 protects file_path
3. Garanta a associação adequada ao grupo.
4. Para operações de administrador, verifique as permissões de administrador.

Sintomas: Conflitos de bloqueio exclusivo
Soluções:

1. Verifique quem tem o arquivo aberto: p4 opened file_path
2. Entre em contato com o usuário para resolver conflitos.
3. O administrador pode forçar operações se necessário.

Sintomas: Tempos de resposta longos
Soluções:

1. Use o parâmetro max_results para limitar o tamanho da consulta.
2. Use caminhos de arquivo específicos em vez de curingas.
3. Verifique a conectividade de rede com o P4.
4. Monitore o desempenho do servidor.

Sintomas: Alto uso de memória
Soluções:

1. Reduza max_results para consultas grandes.
2. Processe arquivos em lotes.
3. Reinicie o servidor MCP periodicamente para sessões de longa duração.

Sintomas: Conflito com ferramentas integradas ou outras ferramentas MCP
Soluções:

1. Desative quaisquer ferramentas integradas ou conflitantes do servidor MCP em seu ambiente ou configuração.
2. Garanta que as ferramentas do servidor MCP P4 estejam devidamente registradas e habilitadas.
3. Reinicie o servidor MCP após aplicar alterações de configuração para carregar as ferramentas corretas.

Sintomas: Contexto inválido ou histórico de sessão desatualizado
Soluções:

1. Forneça um contexto relacionado ao P4 ao escrever prompts.
2. Inicie uma nova sessão se a sessão existente for antiga ou contiver histórico de prompts conflitante.