> ## Documentation Index
> Fetch the complete documentation index at: https://docs.boxd.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Integrations

> Connect Linear, Slack, and GitHub once — every personal machine can use them, and the coding agents on board discover them automatically.

Integrations connect a third-party account to boxd **once**, at the account level. After that, every personal machine you own can use it — no per-VM setup, no tokens to copy around. The token lives server-side; boxd injects it into your machines on demand.

Three integrations ship today:

<Columns cols={3}>
  <Card title="GitHub" icon="https://mintcdn.com/azin/Ax1V0serIwQf0x_2/images/icons/github.svg?fit=max&auto=format&n=Ax1V0serIwQf0x_2&q=85&s=356db9ba697339bc42f46e2999e57725" href="/integrations/github" width="16" height="16" data-path="images/icons/github.svg">
    Clone and push private repos from any machine.
  </Card>

  <Card title="Linear" icon="https://mintcdn.com/azin/gycLgw-regpBRyIk/images/icons/linear.svg?fit=max&auto=format&n=gycLgw-regpBRyIk&q=85&s=858db4db0a559fe11797c24b96fd5c1f" href="/integrations/linear" width="16" height="16" data-path="images/icons/linear.svg">
    Linear's GraphQL API and an optional MCP server for your agents.
  </Card>

  <Card title="Slack" icon="https://mintcdn.com/azin/gycLgw-regpBRyIk/images/icons/slack.svg?fit=max&auto=format&n=gycLgw-regpBRyIk&q=85&s=ab29cf0026c3c082da6a02c2797316a4" href="/integrations/slack" width="16" height="16" data-path="images/icons/slack.svg">
    The Slack Web API as the bot or as you, plus an optional MCP server.
  </Card>
</Columns>

## Connect an integration

There are two ways to connect, and both end at the same place:

**From the console** — open [`boxd.sh/app`](https://boxd.sh/app) → **Integrations** and click **Connect** on the service you want. This is the simplest path.

**From the CLI** — `boxd manage integrations connect <id>` (for example `github`, `linear`, or `slack`) prints an authorize URL, then polls until you approve it:

```bash theme={"theme":"github-dark"}
boxd manage integrations connect linear
```

```
Open this URL in a browser to connect linear:

  https://linear.app/oauth/authorize?client_id=…

Waiting for authorization (up to 5 minutes)...
✓ linear connected — available on your personal and private VMs.
```

You open the URL in any browser and approve; the CLI finishes on its own. The browser step is why **a human** has to do the connect — an agent can kick it off but can't click through the consent screen.

<Note color="#E05A6D">
  `boxd manage integrations connect` works for all three — `github`, `linear`, and `slack`. GitHub can *also* be connected with the **Connect GitHub repos** button in the console; both routes land the same grant.
</Note>

## Where integrations are available

A connected integration reaches your **personal machines** and your **private org-billed machines** — anywhere only you have a shell.

It is deliberately **never** exposed on **shared or public org machines**. A teammate with a shell on a shared box must never be able to read your personal Linear or Slack token, so boxd withholds it there. Fork a shared machine to get a private copy, and your integrations come back.

## How a machine uses an integration

Once connected, each integration shows up two ways inside your machine.

**As environment variables**, exported into every login shell (and into the coding agents' environment):

| Integration | Variables                                                              |
| ----------- | ---------------------------------------------------------------------- |
| Linear      | `LINEAR_ACCESS_TOKEN`                                                  |
| Slack       | `SLACK_BOT_TOKEN`, `SLACK_USER_TOKEN`, `SLACK_TEAM_ID`                 |
| GitHub      | (none needed — a git credential helper and `gh` are wired up directly) |

### Discover what's wired in

Inside any machine, run **`boxd manage integrations`** (no subcommand) to see which accounts are connected and how to use each, plus what else you can still connect — the live source of truth:

```text theme={"theme":"github-dark"}
$ boxd manage integrations
Connected integrations (usable from this VM):

  GitHub
    git          pre-configured credential helper — clone & push private repos directly
    gh CLI       the `gh` command works out of the box (GH_TOKEN injected per call)

  Linear
    GraphQL API  POST https://api.linear.app/graphql with header `Authorization: Bearer $LINEAR_ACCESS_TOKEN`
    MCP server   the `linear-server` MCP is configured in Claude Code (https://mcp.linear.app/mcp)

Available to connect:
  Slack       boxd manage integrations connect slack
```

The **Available to connect** section lists every catalog integration that's available on the deployment but not yet connected, with the exact `connect` command — so an agent can discover and wire one up without guessing.

Add `--json` for a structured version: connected integrations come back under `integrations` (each with `access` methods tagged by a machine-readable `kind` — `git`, `cli`, `graphql`, `api`, `mcp`), and the not-yet-connected ones under `connectable`. The coding agents pre-installed on every machine are told to run `boxd manage integrations` rather than guessing — new integrations appear here automatically.

## MCP servers

Linear and Slack each also offer a [Model Context Protocol](https://modelcontextprotocol.io) server that a coding agent can call directly. It's **opt-in per agent**:

```bash theme={"theme":"github-dark"}
boxd manage integrations mcp linear                 # install into all agents (Claude Code, Codex, OpenCode)
boxd manage integrations mcp linear claude codex    # only these agents
boxd manage integrations mcp linear --disable       # remove from every agent
```

The agent ids are `claude` (Claude Code), `codex`, and `opencode`. With no agents listed, the MCP installs into all three; `--disable` removes it everywhere. You can also toggle this from the console with **Enable MCP** on the integration's card. The MCP is only active while the integration is connected — disconnecting clears the opt-in too.

## The `boxd manage integrations` command

The same command behaves the same everywhere you drive boxd:

| Subcommand           | [CLI](/reference/external-cli) (laptop) | [In-VM CLI](/reference/internal-cli) | Console |
| -------------------- | :-------------------------------------: | :----------------------------------: | :-----: |
| `list` (default)     |                    ✓                    |                   ✓                  |    ✓    |
| `connect <id>`       |                    ✓                    |                   ✓                  |    ✓    |
| `disconnect <id>`    |                    ✓                    |                   ✓                  |    ✓    |
| `mcp <id> [agents…]` |                    ✓                    |                   ✓                  |    ✓    |

`integ` is an alias for `integrations`, and `ls` an alias for `list`. All four subcommands work on every surface — the laptop CLI, inside a machine, and the console. Service names are case-insensitive (`Slack` = `slack`).

## Disconnect

```bash theme={"theme":"github-dark"}
boxd manage integrations disconnect linear
```

Disconnecting revokes the token at the provider, clears it from boxd, and removes any MCP opt-in. From the console, **Disconnect** on a card offers the same — with the choice to remove just the MCP server or disconnect the service entirely.