# Code editors and CLI agents

Code editors and command-line agents take the server URL and a token in a header. Issue a token on your [profile page](https://publicwww.com/profile/api) - one per tool, so any of them can be cut off alone - and keep it out of files you commit.

In the examples the token is read from the environment variable `PUBLICWWW_TOKEN`, or asked for once; where a client cannot do either, `YOUR_TOKEN` stands for the token itself. Claude Code is on the [Claude](https://publicwww.com/docs/mcp/claude/) page.

Without a token only the tool list and `read_docs` work; the rest answers `401`.

## VS Code

GitHub Copilot's agent mode. Add to `.vscode/mcp.json` in the project, or to the user configuration (command palette: MCP: Open User Configuration):

```
{
  "inputs": [
    { "type": "promptString", "id": "publicwww-token",
      "description": "PublicWWW token", "password": true }
  ],
  "servers": {
    "publicwww": {
      "type": "http",
      "url": "https://api.publicwww.com/mcp",
      "headers": { "Authorization": "Bearer ${input:publicwww-token}" }
    }
  }
}
```

VS Code asks for the token the first time the server starts and stores it in its secret storage, not in the file. The same in one click: [Install in VS Code](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522publicwww%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fapi.publicwww.com%252Fmcp%2522%252C%2522headers%2522%253A%257B%2522Authorization%2522%253A%2522Bearer%2520%2524%257Binput%253Apublicwww-token%257D%2522%257D%252C%2522inputs%2522%253A%255B%257B%2522type%2522%253A%2522promptString%2522%252C%2522id%2522%253A%2522publicwww-token%2522%252C%2522description%2522%253A%2522PublicWWW%2520token%2522%252C%2522password%2522%253Atrue%257D%255D%257D).

## Cursor

`~/.cursor/mcp.json` for every project, or `.cursor/mcp.json` in one:

```
{
  "mcpServers": {
    "publicwww": {
      "url": "https://api.publicwww.com/mcp",
      "headers": { "Authorization": "Bearer ${env:PUBLICWWW_TOKEN}" }
    }
  }
}
```

Or in one click: [Add to Cursor](https://cursor.com/install-mcp?name=publicwww&config=eyJ1cmwiOiJodHRwczovL2FwaS5wdWJsaWN3d3cuY29tL21jcCIsImhlYWRlcnMiOnsiQXV0aG9yaXphdGlvbiI6IkJlYXJlciAke2VudjpQVUJMSUNXV1dfVE9LRU59In19) - it reads the token from `PUBLICWWW_TOKEN`.

## Devin Desktop (formerly Windsurf)

`~/.config/devin/mcp_config.json`, on Windows `%APPDATA%\devin\mcp_config.json`:

```
{
  "mcpServers": {
    "publicwww": {
      "url": "https://api.publicwww.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}
```

Use `url`; `serverUrl` worked only in the old Cascade agent.

## Gemini CLI

As an extension - it asks for the token once, keeps it in the system keychain and brings a skill with the query syntax:

```
gemini extensions install https://github.com/publicwww-com/publicwww-mcp
```

Or by hand in `~/.gemini/settings.json`. The key is `httpUrl`: with `url`, Gemini CLI would use the older SSE transport, which this server does not serve.

```
{
  "mcpServers": {
    "publicwww": {
      "httpUrl": "https://api.publicwww.com/mcp",
      "headers": { "Authorization": "Bearer ${PUBLICWWW_TOKEN}" }
    }
  }
}
```

## Codex CLI

```
codex mcp add publicwww --url https://api.publicwww.com/mcp \
     --bearer-token-env-var PUBLICWWW_TOKEN
```

or the same by hand in `~/.codex/config.toml`; Codex reads the token from the variable it is told to:

```
[mcp_servers.publicwww]
url = "https://api.publicwww.com/mcp"
bearer_token_env_var = "PUBLICWWW_TOKEN"
```

Codex can also sign in with OAuth instead of a token:

```
codex mcp add publicwww --url https://api.publicwww.com/mcp
codex mcp login publicwww
```

**Codex on a server over SSH.** After you press Allow, the browser is sent to `http://127.0.0.1:<port>/callback?code=…` - an address only Codex itself listens on, on the server, so your browser shows a connection error. Copy that whole address from the address bar and, while `codex mcp login` is still waiting, open it on the server:

```
curl "http://127.0.0.1:<port>/callback?code=...&state=..."
```

Codex reports the sign-in as done. The code works once and for ten minutes, and the address has to come from the same `codex mcp login` run.

## opencode

Add to `opencode.json` in the project, or to `~/.config/opencode/opencode.json`, with the token in the environment. Sign-in with OAuth does not work here: opencode wants to register itself with the server first, which PublicWWW does not support.

```
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "publicwww": {
      "type": "remote",
      "url": "https://api.publicwww.com/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:PUBLICWWW_TOKEN}" }
    }
  }
}
```

`opencode mcp list` shows the server as connected.

## MiMo Code

The same settings as opencode, in `~/.config/mimocode/mimocode.json`, with the token in the environment. Sign-in with OAuth does not work here either, for the same reason.

```
{
  "mcp": {
    "publicwww": {
      "type": "remote",
      "url": "https://api.publicwww.com/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:PUBLICWWW_TOKEN}" }
    }
  }
}
```

## Goose

Add to `~/.config/goose/config.yaml`, with the token in the environment:

```
extensions:
  publicwww:
    enabled: true
    type: streamable_http
    name: publicwww
    uri: https://api.publicwww.com/mcp
    env_keys: [PUBLICWWW_TOKEN]
    headers:
      Authorization: Bearer ${PUBLICWWW_TOKEN}
    timeout: 120
```

Without `headers` and `env_keys`, Goose starts signing in with OAuth when a search needs an account, and prints the address to open if no browser appears.

## Qwen Code

Add to `~/.qwen/settings.json`, with the token in the environment:

```
{
  "mcpServers": {
    "publicwww": {
      "httpUrl": "https://api.publicwww.com/mcp",
      "headers": { "Authorization": "Bearer $PUBLICWWW_TOKEN" }
    }
  }
}
```

Or from the command line, in single quotes so that the shell does not expand the variable:

```
qwen mcp add --scope user --transport http publicwww https://api.publicwww.com/mcp \
     --header 'Authorization: Bearer $PUBLICWWW_TOKEN'
```

`qwen mcp list` shows the server as connected.

## DeepSeek Harness

```
dsh plugin --profile web add github:publicwww-com/dsh-publicwww
```

Here `web` is the profile: put the name you start DeepSeek Harness with, such as `headless`. The plugin connects the server through DeepSeek Harness's own MCP client and reads the token from `PUBLICWWW_TOKEN`, so set it first and start the profile again: a plugin loads when the profile starts. See [the plugin page](https://github.com/publicwww-com/dsh-publicwww).

## Anything else

Any client that can add a remote MCP server over Streamable HTTP and set a request header will work with the URL and the `Authorization: Bearer` header. A client that only starts local servers can reach this one through the `mcp-remote` bridge (needs Node.js):

```
{
  "mcpServers": {
    "publicwww": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.publicwww.com/mcp",
               "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer YOUR_TOKEN" }
    }
  }
}
```

No space after `Authorization:` on purpose: some clients pass arguments with spaces in them incorrectly, so the part with the space lives in `env`.

Ready-made files for all of these, an agent skill with the query syntax and the install buttons are on [GitHub](https://github.com/publicwww-com/publicwww-mcp).

Source: https://publicwww.com/docs/mcp/editors/
