Skip to main content
Glama
MCP ChatGPT Full PC Dev

MCP ChatGPT Full PC Dev

by tgzx

MCP ChatGPT Full PC Dev

MVP de servidor MCP local para permitir que o ChatGPT use um computador Windows por meio do OpenAI Secure MCP Tunnel.

Este projeto nasceu para funcionar como um "PC Controller" simples: o ChatGPT descobre ferramentas MCP, chama essas ferramentas pelo tunnel e o servidor local executa ações no PC autorizado.

Status atual

Validado em Windows com OpenAI Tunnel.

Fluxo comprovado:

ChatGPT
→ Custom Connector / App em modo desenvolvedor
→ OpenAI Secure MCP Tunnel
→ tunnel-client.exe rodando no PC
→ servidor MCP local em Node.js via stdio
→ ferramentas como list_directory, read_file e ps

Teste real validado: o ChatGPT conseguiu listar a pasta do projeto usando a ferramenta list_directory.

Related MCP server: ChatGPT Remote Commander

Ferramentas disponíveis

  • ps: executa comando PowerShell.

  • start_ps: inicia comando PowerShell longo em segundo plano.

  • read_process: lê stdout/stderr de processo iniciado por start_ps.

  • stop_process: encerra processo iniciado por start_ps.

  • list_processes: lista processos criados por start_ps.

  • list_directory: lista arquivos e pastas.

  • get_file_info: mostra metadados de arquivo ou pasta.

  • create_directory: cria pasta recursivamente.

  • read_file: lê arquivo de texto.

  • write_file: cria ou sobrescreve arquivo de texto.

  • append_file: adiciona texto ao final de arquivo.

  • delete_path: remove arquivo ou pasta, recusando raiz de unidade.

  • move_path: move ou renomeia arquivo ou pasta.

  • search_names: busca arquivos/pastas por nome.

  • screenshot_url: abre URL em Edge headless, com fallback Chromium, e retorna screenshot.

Estrutura principal

MCP ChatGPT
├─ config/settings.json
├─ src/app.mjs
├─ src/core
├─ src/tools
├─ install-deps.cmd
├─ doctor.cmd
├─ run-mcp.cmd
├─ tunnel-init.cmd
├─ tunnel-doctor.cmd
├─ tunnel-run.cmd
├─ tunnel-client.exe
├─ README.md
└─ TUNNEL_SETUP.md

Requisitos em uma nova máquina

  • Windows.

  • Node.js LTS instalado.

  • Conta OpenAI com acesso a Tunnels e Custom Connectors / Apps em modo desenvolvedor.

  • Um tunnel criado na OpenAI Platform.

  • Uma Runtime API Key / API Key de projeto válida.

  • tunnel-client.exe baixado do release oficial do openai/tunnel-client.

Instalação a partir de ZIP em outro computador

1. Descompactar o projeto

Recomendado descompactar em:

C:\Users\SEU_USUARIO\Documents\MCP ChatGPT

O nome da pasta pode ter espaço, mas isso exige cuidado na configuração do tunnel. Este README já documenta o workaround que funcionou.

2. Instalar dependências

Abra CMD na pasta do projeto:

cd /d "C:\Users\SEU_USUARIO\Documents\MCP ChatGPT"
install-deps.cmd

Esse script roda:

npm install
npx playwright install chromium

3. Validar o servidor local

doctor.cmd

Resultado esperado: JSON com ok: true e a lista de ferramentas.

4. Baixar o tunnel-client

Na página de releases do projeto openai/tunnel-client, baixe o binário compatível com Windows.

Opção recomendada:

windows-amd64.zip

Se baixar o pacote all, o executável costuma ficar em:

bin\windows_amd64\tunnel-client.exe

Copie o executável para a raiz do projeto:

C:\Users\SEU_USUARIO\Documents\MCP ChatGPT\tunnel-client.exe

5. Criar um tunnel na OpenAI Platform

Acesse:

https://platform.openai.com/settings/organization/tunnels

Crie um tunnel e copie o ID, por exemplo:

tunnel_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

6. Gerar o profile local do tunnel

Rode:

tunnel-init.cmd

Informe o tunnel_id quando solicitado.

Esse script gera o arquivo:

%APPDATA%\tunnel-client\mcp-chatgpt-full-pc-dev.yaml

O profile aponta para o servidor MCP local usando caminhos curtos do Windows e barras /, evitando bugs de escape em YAML/comando.

Formato esperado do comando no YAML:

mcp:
  commands:
    - channel: main
      command: "C:/PROGRA~1/nodejs/node.exe C:/Users/User/DOCUME~1/MCPCHA~1/src/app.mjs"

Atenção: o caminho exato muda conforme usuário, idioma do Windows e local da pasta.

7. Obter Runtime API Key

Acesse:

https://platform.openai.com/settings/organization/api-keys

Crie ou use uma API key ativa. No terminal ela será usada como variável de ambiente CONTROL_PLANE_API_KEY.

Não cole essa chave em chat, README, print público ou commit.

8. Validar o tunnel

Rode:

tunnel-doctor.cmd

Cole a API key quando o terminal pedir.

Resultado esperado:

RESULT ok
NEXT tunnel-client run --profile mcp-chatgpt-full-pc-dev

Alguns SKIP são normais para MCP via stdio:

mcp_server_reachable SKIP
oauth_metadata SKIP
codex_plugin SKIP

9. Rodar o tunnel

Rode:

tunnel-run.cmd

Cole a API key quando pedir.

A janela precisa ficar aberta enquanto o ChatGPT usa o conector.

Resultado esperado no log:

🟢 tunnel-client started

10. Criar o app/conector no ChatGPT

No ChatGPT Web:

Settings
→ Aplicativos / Connectors
→ Criar aplicativo / Custom connector
→ Conexão: Túnel
→ Informar o tunnel_id
→ Sem autenticação
→ Marcar ciência do risco
→ Criar

Se tudo estiver certo, o ChatGPT vai fazer scan das ferramentas e exibir as actions.

Teste inicial pelo ChatGPT

Com tunnel-run.cmd aberto, peça no chat:

Use o PC Controller para listar a pasta C:\Users\SEU_USUARIO\Documents\MCP ChatGPT.

Ou:

Use o PC Controller e leia o arquivo C:\Users\SEU_USUARIO\Documents\MCP ChatGPT\checklist.txt.

Se a resposta listar arquivos da máquina, o tunnel está funcional.

Pegadinha crítica que quebrou o MVP

No Windows, comandos com \ dentro do YAML causaram problema no tunnel-client.

O log ruim mostrava algo parecido com:

fork/exec C:PROGRA~1nodejsnode.exe: The system cannot find the file specified

Ou seja, o tunnel-client removeu as barras invertidas. A solução validada foi:

  • Usar caminho curto 8.3 do Windows.

  • Trocar \ por /.

  • Chamar node.exe direto, sem cmd.exe /c e sem .cmd no campo command.

Comando final funcional neste PC:

command: "C:/PROGRA~1/nodejs/node.exe C:/Users/User/DOCUME~1/MCPCHA~1/src/app.mjs"

Para descobrir caminhos curtos manualmente:

for %I in ("C:\Program Files\nodejs\node.exe") do @echo %~sI
for %I in ("C:\Users\SEU_USUARIO\Documents\MCP ChatGPT\src\app.mjs") do @echo %~sI

Depois substitua \ por / no YAML.

Segurança

Este MVP pode ser poderoso demais se deixado totalmente aberto.

Arquivo de configuração do servidor MCP:

config/settings.json

Campo importante:

"allowedRoots": []

Quando allowedRoots está vazio, o MCP não limita pastas por conta própria.

Recomendação para uso real:

"allowedRoots": [
  "C:\\Users\\SEU_USUARIO\\Documents",
  "C:\\Users\\SEU_USUARIO\\Desktop",
  "C:\\Users\\SEU_USUARIO\\Downloads"
]

Também é prudente manter securityMode como:

"securityMode": "denylist"

Scripts do projeto

install-deps.cmd

Instala dependências Node e navegador Chromium do Playwright.

doctor.cmd

Valida o servidor MCP local sem tunnel.

run-mcp.cmd

Sobe o servidor MCP local via stdio. Normalmente não é chamado direto pelo usuário final.

tunnel-init.cmd

Gera o profile YAML do tunnel em %APPDATA%\tunnel-client.

tunnel-doctor.cmd

Valida o profile do tunnel usando a API key informada no terminal.

tunnel-run.cmd

Sobe o tunnel-client e mantém a ponte ativa para o ChatGPT.

Troubleshooting

Erro: write |1: file already closed

Significa que o ChatGPT tentou inicializar o MCP, mas o processo local já tinha fechado.

Causas comuns:

  • Caminho do comando MCP quebrado.

  • Aspas mal interpretadas.

  • Barra invertida removida pelo YAML/comando.

  • Node.js não encontrado.

  • src/app.mjs não encontrado.

Verifique o YAML:

%APPDATA%\tunnel-client\mcp-chatgpt-full-pc-dev.yaml

Erro: fork/exec C:PROGRA~1nodejsnode.exe

O comando está usando \ e o tunnel-client removeu as barras.

Corrija para /:

command: "C:/PROGRA~1/nodejs/node.exe C:/Users/User/DOCUME~1/MCPCHA~1/src/app.mjs"

Conector criado, mas nenhuma ferramenta aparece

Confira se tunnel-run.cmd está aberto e se o log mostra:

🟢 tunnel-client started

Depois confira se o app local responde:

doctor.cmd

Porta 8080 em uso

O profile usa:

health:
  listen_addr: "127.0.0.1:8080"

Se a porta estiver ocupada, troque para outra porta livre ou encerre o processo antigo do tunnel.

API key

A key é usada apenas no terminal como CONTROL_PLANE_API_KEY.

Não grave a key no YAML, no README ou no Git.

Publicação / ZIP do MVP

Antes de zipar para outra máquina, recomenda-se não incluir:

node_modules
logs
screenshots temporários
chaves de API

O destinatário deve rodar:

install-deps.cmd
tunnel-init.cmd
tunnel-doctor.cmd
tunnel-run.cmd

Checklist rápido em outra máquina

1. Instalar Node.js LTS.
2. Descompactar o projeto.
3. Copiar tunnel-client.exe para a raiz.
4. Rodar install-deps.cmd.
5. Criar tunnel na OpenAI Platform.
6. Rodar tunnel-init.cmd e informar tunnel_id.
7. Rodar tunnel-doctor.cmd e informar API key.
8. Rodar tunnel-run.cmd e deixar aberto.
9. Criar Custom Connector no ChatGPT usando Tunnel.
10. Testar list_directory/read_file.

Estado validado neste PC

  • Profile: mcp-chatgpt-full-pc-dev.

  • Tunnel ID: tunnel_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.

  • Connector/App: PC Controller.

  • Status: conectado em modo desenvolvedor.

  • Ferramentas descobertas pelo ChatGPT: sim.

  • Teste real: list_directory funcionou.

Dependências e pré-requisitos detalhados

Dependências externas obrigatórias

Estas dependências precisam existir na máquina antes do MVP funcionar:

  • Windows.

  • Node.js LTS, incluindo node e npm no PATH.

  • OpenAI tunnel-client.exe compatível com Windows.

  • Conta/OpenAI workspace com acesso a Tunnels e Custom Connectors / Apps em modo desenvolvedor.

  • Tunnel criado na OpenAI Platform.

  • API key ativa para ser usada como CONTROL_PLANE_API_KEY.

Dependências Node do projeto

Declaradas em package.json:

"dependencies": {
  "@modelcontextprotocol/sdk": "latest",
  "playwright": "latest",
  "zod": "^3.25.76"
}

Descrição rápida:

  • @modelcontextprotocol/sdk: SDK usado para criar o servidor MCP e expor as ferramentas.

  • zod: valida os schemas de entrada das tools MCP.

  • playwright: usado pela ferramenta screenshot_url para abrir páginas em navegador headless.

Dependência de navegador headless

Além do pacote playwright, o projeto precisa instalar o navegador Chromium usado como fallback:

npx playwright install chromium

O script install-deps.cmd já executa isso.

O que o install-deps.cmd instala

npm install
npx playwright install chromium

Ou seja, ele instala:

  • node_modules com @modelcontextprotocol/sdk, playwright e zod.

  • navegador Chromium do Playwright.

O que o ZIP não precisa levar

Para distribuir o MVP em ZIP, normalmente não é necessário incluir:

node_modules
package-lock.json, se quiser reinstalação limpa
logs
screenshots temporários
chaves de API

Ao abrir em outra máquina, rode install-deps.cmd para reconstruir as dependências.

Verificação rápida das dependências

node -v
npm -v
npm list @modelcontextprotocol/sdk playwright zod

E para validar sintaxe do servidor:

npm run check

Available Tools

15 tools
append_fileC

Adiciona texto ao final de um arquivo.

Inputs: targetPath (required), content (required).

create_directoryC

Cria uma pasta recursivamente.

Inputs: targetPath (required).

delete_pathC

Remove arquivo ou pasta. Recusa raiz de unidade.

Inputs: targetPath (required), recursive.

get_file_infoC

Mostra metadados básicos de arquivo ou pasta.

Inputs: targetPath (required).

list_directoryC

Lista arquivos e pastas de um caminho.

Inputs: targetPath.

list_processesA

Lista processos criados por start_ps nesta sessão MCP.

Inputs: no named parameters.

move_pathD

Move ou renomeia arquivo/pasta.

Inputs: sourcePath (required), destinationPath (required).

psD

Executa um comando PowerShell no PC.

Inputs: command (required), cwd, timeoutMs.

read_fileD

Lê arquivo de texto.

Inputs: targetPath (required), maxChars.

read_processC

Lê stdout/stderr de um processo iniciado por start_ps.

Inputs: sessionId (required), maxChars.

screenshot_urlB

Abre uma URL em Edge headless, com fallback Chromium, e retorna screenshot.

Inputs: url (required), waitMs, fullPage, width, +2 more.

search_namesC

Busca arquivos e pastas por nome.

Inputs: rootPath (required), pattern (required), maxResults.

start_psC

Inicia um comando PowerShell longo em segundo plano.

Inputs: command (required), cwd.

stop_processC

Encerra um processo iniciado por start_ps.

Inputs: sessionId (required).

write_fileB

Cria ou sobrescreve arquivo de texto.

Inputs: targetPath (required), content (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.7/5.0

    Scored across 15 tools

    Disambiguation4/5

    Most tools have distinct purposes, but ps and start_ps could cause confusion as both execute PowerShell commands. Additionally, append_file and write_file are clearly different (append vs overwrite). Overall, only minor overlap exists.

    Naming Consistency4/5

    The majority of tools follow a consistent verb_noun pattern (e.g., create_directory, delete_path). Exceptions are ps (abbreviated) and screenshot_url (uppercase URL), but these are minor deviations from an otherwise consistent naming scheme.

    Tool Count4/5

    15 tools is appropriate for a PC development server covering file operations, process management, and screenshots. It is slightly above the typical 3-15 range but still well-scoped and not overwhelming.

    Completeness3/5

    The tool set covers basic file CRUD (create, read, write, append, delete, move, list) and process lifecycle (start, stop, read output, list). However, notable gaps include a missing copy tool and lack of partial file update functionality, limiting completeness for development tasks.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables ChatGPT to read and write local files, view the screen, and operate Windows desktop windows, mouse, and keyboard through MCP stdio and OpenAI's Secure MCP Tunnel.
      7
      MIT