Skip to content
Nov 3, 2026 - Version 2026.10 has been released
For the complete documentation index, see llms.txt. This page is also available as Markdown.

Configure GitHub Copilot CLI

Connect the GitHub Copilot CLI to your Datasentinel MCP server on Linux, sign in, install the Datasentinel Skill, and verify the configuration.

This page shows how to wire the GitHub Copilot CLI to your Datasentinel platform on a Linux host: add the MCP server, sign in once, install the Skill that tells the assistant how to use it, and check that everything is connected.

The same pattern applies to other MCP-and-Skill-capable assistants. The commands below are specific to the standalone GitHub Copilot CLI (the copilot command from the @github/copilot npm package), not the older gh copilot extension.

The steps below follow GitHub's documentation, last checked on 2 November 2026 (Copilot CLI 1.0.105). GitHub changes the Copilot CLI often.

Before you start

  • The Copilot CLI is installed and you can run copilot from a terminal. If it is not yet installed, follow the steps below.

  • Your Datasentinel MCP server is reachable over HTTPS at https://<public-host>/mcp. See MCP Server Setup if it is not yet running.

Install the Copilot CLI

The Copilot CLI is the standalone copilot command, which runs on Linux, macOS, and Windows. For the full instructions and alternative install methods, see GitHub's Installing GitHub Copilot CLI guide.

There are two ways to install it on Linux. They differ mainly in whether Node.js is involved:

  • Install script: downloads a self-contained copilot binary. It does not need Node.js or npm, and is the quickest path to a working CLI.

  • npm: installs the @github/copilot package into your Node.js toolchain. It requires Node.js 22 or later, and fits in if you already manage tools through npm or want to update the CLI with it.

Pick one:

Download and run the official installer:

curl -fsSL https://gh.io/copilot-install | bash

This installs a self-contained binary to ~/.local/bin (or /usr/local/bin when run as root) and offers to add that directory to your PATH if it is not already there. Set PREFIX to install into $PREFIX/bin instead (it defaults to $HOME/.local, or /usr/local as root). No Node.js or npm is required.

This method requires Node.js 22 or later (npm ships with Node.js, so installing Node.js gives you both). Check your version:

node --version
npm --version

If Node.js is older than 22 or missing, install a current release first. nvm is the simplest per-user option: it installs Node.js without root and lets you switch versions easily. Install nvm, then restart your shell (or source ~/.bashrc) so the nvm command is available:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Then install and activate Node.js 22:

nvm install 22
nvm use 22

Alternatively, NodeSource provides system-wide packages. Your distribution's own nodejs package often lags behind 22, so check the version if you use it.

Finally, install the CLI from npm:

npm install -g @github/copilot

Once installed, start the CLI and sign in:

On first launch, if you are not logged in to GitHub yet, it prompts you to run the /login slash command and sign in with your GitHub account. Once authenticated, you land in an interactive session and can run the setup steps below.

Set it up

1

Add the Datasentinel MCP server

For the full reference, see GitHub's Adding MCP servers for GitHub Copilot CLI guide.

Register the server with the streamable-HTTP transport:

copilot mcp add writes the server to your user configuration, ~/.copilot/mcp-config.json, so it is available in every directory. A repository can also carry its own servers in .mcp.json or .github/mcp.json; those load once you trust the folder and take precedence over the user file when names clash (see Adding per-repository MCP servers). You can relocate the whole configuration directory by setting the COPILOT_HOME environment variable (Copilot then stops loading Skills from ~/.agents/skills).

You can also edit ~/.copilot/mcp-config.json directly instead of using the command above. Each server is a child of the top-level mcpServers object, with "type": "http" for a remote streamable-HTTP endpoint:

Sign in on first use. The Datasentinel MCP server is protected by OAuth 2.1. Nothing else goes in the configuration: no token, no header. The sign-in is the next step. See How authentication works.

Self-signed or invalid certificate

If your platform serves the /mcp endpoint with a self-signed or otherwise invalid TLS certificate, Copilot CLI rejects the connection. The sign-in goes through the same connection, so a rejected certificate blocks it before the login page even opens.

2

Sign in to the platform

With a browser

Copilot CLI authenticates to remote MCP servers with OAuth 2.0, using PKCE and dynamic client registration, so nothing is configured on your side (see OAuth re-authentication in GitHub's command reference). The first time Copilot needs a Datasentinel tool, it opens the Datasentinel login page in your browser and waits for the sign-in. Sign in with your platform login and password, the same ones as the Datasentinel web interface. The page names the assistant that is asking. After the sign-in, the browser hands the session back to Copilot. From then on the tools run as you.

You sign in once. Copilot renews the session by itself. The login page comes back only after ten days without using the server, or when an administrator ends the session; the server then shows a needs-auth status and /mcp auth datasentinel-production runs the sign-in again. Your password goes to the login page only. Copilot never sees it, and never asks for a token.

Without a browser

On a server without a browser (an SSH session, a build machine), the sign-in still runs in the browser of your laptop. Copilot CLI has no paste-the-link mode (issue #3009), and its two official headless routes, the device-code flow behind --device-code and the client-credentials grant (see Headless OAuth), need features the Datasentinel authorization server does not provide. What works is an SSH port forward. Pin the port Copilot listens on with auth.redirectPort in ~/.copilot/mcp-config.json, an option introduced in Copilot CLI 1.0.49 and described in its changelog:

Then open the SSH session with that port forwarded:

In an SSH session the sign-in link is easy to miss: Copilot starts the sign-in on its own as soon as it finds a server that needs authentication, and the link it prints at launch is drawn over by the interface. Point the BROWSER variable at a command that prints its argument, so the link stays readable (the variable is mentioned in issue #3418). Set it before starting Copilot:

Then run the sign-in from the Copilot prompt:

  1. Type /mcp. The dashboard opens on the list of your MCP servers.

  2. Select datasentinel-production.

  3. Select Authenticate.

/mcp auth datasentinel-production runs the same sign-in in one command (see OAuth re-authentication in GitHub's command reference). Recent versions also show the link in the authentication panel, under If your browser didn't open, copy this URL manually.

Open the printed link in the laptop's browser and sign in. The way back to localhost:19876 travels through the tunnel to Copilot on the server. The general procedure is in How authentication works.

For a script or a scheduled run

Where nobody can sign in, register the server with a user token as an authorization header instead, with the --header option of copilot mcp add or the headers field of the server entry (both documented in GitHub's Adding MCP servers guide and remote server configuration fields). The token is the platform's 24-hour user token. Read it from an environment variable rather than writing it in the configuration:

or, in ~/.copilot/mcp-config.json, a headers entry with the same variable reference:

A server registered with a header never opens the login page. When the token expires, the calls fail until a fresh one is set. See Refresh the user token automatically to keep it current.

3

Install the Datasentinel Skill

The Datasentinel Skill is made of several files (a SKILL.md entrypoint plus supporting files) and ships as a single archive, datasentinel-skill.zip. Download it from https://app.datasentinel.io/ds-api/download/datasentinel-skill.zip.

Skills in Copilot CLI are file-based. Create the Skills directory if it does not exist yet, then unzip the archive into it so it produces a datasentinel/ folder. Copilot CLI discovers it on the next session; in a running session, enter /skills reload.

You should end up with ~/.copilot/skills/datasentinel/SKILL.md (or .github/skills/datasentinel/SKILL.md) alongside the Skill's supporting files. Each Skill lives in its own directory whose SKILL.md is the entrypoint. Its frontmatter carries the description the assistant uses to decide when to apply the Skill:

Cross-agent location: .agents/skills. Copilot CLI also discovers Skills under the vendor-neutral .agents/ directory (~/.agents/skills for personal Skills, .agents/skills in the repo for project Skills) and, for project Skills, under .claude/skills, so a single SKILL.md folder can serve other assistants without duplication. The ~/.copilot/skills and .github/skills paths above are Copilot's own locations; all of them work. See GitHub's Adding Agent Skills for Copilot CLI reference.

copilot skill add. Copilot CLI also has a copilot skill add <source> command (/skills add in a session) that takes a file, a URL or a directory. A directory is registered as a skill source rather than copied, so if you use it, unzip the archive to a permanent place first and pass its datasentinel/ folder. See Managing skills non-interactively in GitHub's command reference.

4

Check your configuration

Inside an interactive copilot session, open the MCP dashboard on the configured servers and their connection status (/mcp list prints the same list as plain text; copilot mcp list and copilot mcp get <name> do it from the shell):

A healthy entry shows the server connected with its tools available. A server you have not signed in to yet shows a needs-auth status. The sign-in runs the first time a tool is needed, or on demand with /mcp auth datasentinel-production. If it shows an error, check the URL and that the server is up. Inspect one server in detail (transport, URL, status):

The companion slash commands let you /mcp add, /mcp edit, /mcp enable, and /mcp disable a server. To remove one:

Approve the Datasentinel tools

The first time the assistant calls a Datasentinel tool, Copilot CLI prompts you to allow it. You can allow it once, for the rest of the session, or for the current location. A location approval is saved to ~/.copilot/permissions-config.json and applies to the Git repository you are in (or the working directory outside a repository), so the prompt does not come back there.

To skip the prompts for every tool of the server at once, name the server in the --allow-tool option when you start Copilot; a tool name in parentheses restricts the rule to that tool:

The Datasentinel tools only read monitoring data, so allowing the whole server is safe. --allow-all-tools approves every tool of every kind, including shell commands and file writes; /allow-all inside a session (alias /yolo, the same as /permissions allow-all) goes further and allows all paths and URLs too. Use them with care. /reset-allowed-tools revokes what was granted during the session, and also clears the approvals saved for the current location in permissions-config.json, so the Datasentinel prompts come back there. The syntax and the file format are in GitHub's Allowing and denying tool use guide.

Once the server shows as connected and the Skill is in place, run through the checks below to confirm the end-to-end flow.

How the Skill loads

The Datasentinel Skill loads on demand. Copilot reads every Skill's name and description up front, and applies the full instructions automatically when your prompt relates to Datasentinel: asking about PostgreSQL performance, instances, sessions, or the platform itself is enough. One Skill serves every platform, because it discovers all the datasentinel-* MCP servers you registered, so adding a second platform needs no Skill change.

If Copilot answers generically instead (no Datasentinel tool calls in the response), load the Skill manually:

  • Name it with a slash in the prompt: Use the /datasentinel skill to check the platform status.

  • Run /skills list to confirm the Skill is discovered, and /skills to check it is enabled.

If the Skill is missing from /skills list, re-check the unzip location from the setup step, then enter /skills reload or start a new session. /skills info datasentinel shows where the Skill was loaded from.

Test the MCP server and Skill

Run these checks inside an interactive copilot session.

You exercise the Skill by asking in plain language and letting it drive the MCP tools (see How the Skill loads above). The Datasentinel Skill recognises four built-in checks. Run them in order:

Ask Copilot for…
What it does

datasentinel help

Displays the Skill's help, listing the available commands.

datasentinel platforms

Lists every MCP server (platform) the Skill discovered by its datasentinel- prefix.

datasentinel status

Checks the platform status, confirming the MCP server answers and the sign-in is in place.

datasentinel whoami

Shows who the session is connected as: platform, identity, privilege, real-time access, style, language.

These four are the setup checks. The full command list, with what each one needs, is in the Skill commands reference.

Start with datasentinel help to confirm the Skill responds. It needs no sign-in. Then run datasentinel platforms to verify your server is discovered. Each datasentinel-* MCP server you registered should appear in the list. Run datasentinel status to confirm the platform is reachable and the MCP tools return live data. The first call opens the login page if you have not signed in yet. Finally, datasentinel whoami confirms the account the session runs under and the communication style the assistant will use.

Server not discovered? Ask the assistant to find the root cause.

If datasentinel platforms lists nothing, or your server is missing from it, ask Copilot to debug the setup rather than hunting by hand. It can run /mcp show, read ~/.copilot/mcp-config.json, and probe the endpoint itself, so it usually pinpoints the cause in one pass.

Ask it something like:

Typical causes it surfaces: a server name that misses the datasentinel- prefix, a typo in the URL, a disabled server, a sign-in that was never completed, a rejected TLS certificate, or a platform that is down.

Last updated