How to define MCP servers once and use them in Claude Code, Codex, and OpenCode (across all your machines)

If you’ve ever set up MCP servers “properly”, you’ve probably done this dance:

paste MCP JSON into Claude Code
paste a slightly different MCP JSON into Codex
discover OpenCode uses another location
do it again on your laptop and your server

It works.

It’s also how you end up with sessions that behave differently depending on which machine you’re on.

What I actually want is:

define tools once
make them available consistently
still keep machine-specific tools machine-specific

This guide is about that workflow.

TL;DR

Decide what you want MCP for (browser automation, GitHub, docs search, internal tools).
The common failure mode is config drift: different MCP JSON on different machines/providers.
A better model is “one tool library + explicit apply scopes”.
In Happier, you can define MCP servers once, detect existing provider MCP configs, preview the effective tool set for a session, and apply servers to:
- all machines
- one machine
- one workspace on one machine

The problem

MCP is a great idea, but the naive setup path is brittle:

multiple config files
multiple machines
multiple providers

So the question isn’t “can I run MCP?”

It’s:

can I make the tool surface consistent enough that I trust it?

What I tried first (and where I bounced off)

Copy/paste JSON everywhere: works until you forget one machine.
Only set it up on one provider: then you lose the whole point of portability.
Keep tools per-project only: good for some cases, but painful for universal tools like GitHub.

If you’re new to Happier

If you haven’t seen Happier before: it’s an open-source companion app (mobile/web/desktop) for running sessions like Claude Code, Codex, and OpenCode across machines.

The relevant part here is: it gives you one place to manage MCP servers and apply them consistently.

Get set up:

How to run Happier from your phone
GitHub: https://github.com/happier-dev/happier
Install/download: https://github.com/happier-dev/happier#how-it-works
Discord: https://discord.gg/W6Pb8KuHfg

A workflow that works

1) Treat tools as a library, not a pile of JSON

The moment you have more than one machine, MCP config becomes infrastructure.

So I treat it like a library:

saved
reviewable
scoped

2) Use “Configured vs Detected vs Preview” as your mental model

In Happier, MCP servers are organized into three tabs:

Configured: servers you manage in the app
Detected: servers found in provider-native config files (Claude, Codex, OpenCode)
Preview: the effective tool set for a specific backend + machine + workspace

Preview is the secret weapon.

It answers: “what will this session actually see?”

3) Apply the right scope: all machines vs one machine vs one workspace

Most drift comes from not being explicit about scope.

Rules that work:

remote HTTP/SSE servers → all machines
local stdio servers installed via npx → one machine
project-local servers → one workspace on one machine

4) Keep secrets out of JSON (and stop leaking tokens)

Any time you paste a token directly into MCP JSON, you create secret sprawl:

it ends up in shell history
it ends up in dotfiles
it ends up in screenshots
it eventually ends up in a repo by accident

What I want instead is:

a place to store secrets once
a way to reference them from MCP config without embedding them
a way to reuse that safely across machines

Happier supports three value sources for MCP server headers/env:

Saved Secrets (recommended)
machine env references like ${MY_TOKEN}
plain text (avoid this unless it’s genuinely not sensitive)

That “Saved Secrets” option is the big unlock for multi-machine MCP.

You bind the secret once, and then your MCP server definition can stay identical across machines.

Worked example: GitHub MCP server with an Authorization header (Saved Secret)

A very common pattern is a remote MCP server (HTTP/SSE) that needs:

Authorization: Bearer <token>

Here’s the full end-to-end setup that avoids ever pasting the token into JSON.

Step 1: create a GitHub token

Create a GitHub token with the minimum scopes you need (classic PAT or fine-grained token).

(Which scopes you need depends on what MCP tools you plan to call — repos, issues, PRs, etc.)

Step 2: save the token as a Saved Secret

In Happier:

Settings → Saved Secrets (or Settings → Secrets)
New secret
Name it something you’ll recognize, e.g. github_pat_work
Paste the token value

Now the value lives in Happier’s encrypted settings store instead of your config files.

Step 3: add the GitHub MCP server in Happier

In Happier:

Settings → MCP servers → Add server
Choose Remote HTTP or Remote SSE (depending on what the server supports)
Give it a name, e.g. github

Then set:

Applies to: usually All machines (because remote servers are portable)

Step 4: set the Authorization header using the Saved Secret

In the MCP server config, add a header:

Header name: Authorization
Header value: Bearer <your-saved-secret>

The important part is how you reference the secret:

don’t paste the token value
select/reference your Saved Secret (e.g. github_pat_work) in the header value field

In the header editor, you can choose the value source:

Literal (plain text)
Saved Secret

When you choose Saved Secret, Happier stores a reference to the secret (not the secret value) and resolves it at runtime when testing/launching the MCP server.

Step 5: Test, then Preview

Use Test to verify Happier can:
- resolve the Saved Secret reference,
- connect/start the server,
- and list tools.
Use Preview (backend + machine + workspace) to confirm the GitHub tools are actually present for the session you care about.

If Test works but Preview shows 0 tools for the session, it’s almost always a scope mismatch (All machines vs One machine vs Workspace).