Skip to main content

GitHub Copilot CLI

This guide explains how to deploy cx-devassist to developer machines using GitHub Copilot’s enterprise managed-settings capabilities.

Using managed settings, organizations can centrally configure GitHub Copilot to register the Checkmarx marketplace and enable the cx-devassist plugin, so developers do not need to install the plugin or configure its marketplace manually. Managed settings can be delivered through three methods — native MDM, file-based deployment, or server-managed settings — described in Deployment Methods. These are independent options; choose whichever fits your organization’s infrastructure.

By default, managed settings can point GitHub Copilot directly to the official Checkmarx repository. Developers can then authenticate to Checkmarx One using either Browser sign-in (OAuth) or an API key. With browser sign-in, developers provide their Checkmarx One URL and tenant during initial authentication; these values are remembered for subsequent use. With API key authentication, the API key contains the URL and tenant information and should be distributed through your organization’s approved secret-management process.

For organizations using Browser sign-in (OAuth), the Checkmarx One URL and tenant can also be preconfigured so developers do not need to enter them during initial authentication. This requires an internal fork or mirror of the Checkmarx repository, as described in Optional — Preconfigure the Checkmarx One URL and Tenant.

Important

There is no separate managed-settings field for onboarding. The Checkmarx One URL and tenant must be baked into the plugin bundle your marketplace serves — the plugin deliberately does not read onboarding values from environment variables, ~/.checkmarx, or any other out-of-tree path.

Prerequisites

Before deploying cx-devassist, ensure developer machines meet the plugin’s host requirements (see README.md):

Requirement

Windows

macOS

Linux

Git for Windows (POSIX sh for hooks)

Required

—

—

Python 3

Required

Required

Required

GitHub Copilot CLI

Installed and managed by your organization

Same

Same

Copilot license

Appropriate organizational license

Same

Same

Windows: Verify that sh is available by running sh --version. If Git for Windows is installed but sh is not recognized, ensure that the Git bin directory is included in PATH.

Deployment Methods

GitHub Copilot managed settings can be delivered through three methods. All three use the same JSON keys and values — only the delivery mechanism differs, and none is required over the others.

Method

Platform

Location / mechanism

Native MDM

Windows

Registry HKLM\SOFTWARE\Policies\GitHubCopilot — string (REG_SZ) values

Native MDM

macOS

Forced managed preferences, domain com.github.copilot

File-based

Windows, macOS, Linux

System-level managed-settings.json file

Server-managed

Requires GitHub Enterprise Cloud

copilot/managed-settings.json in your enterprise’s .github-private repository

An organization is not limited to a single method. When more than one is present, Copilot resolves settings per key, using the following precedence:

  1. MDM-managed — Highest priority for any key it defines.

  2. Server-managed — Supplies keys that are not defined by MDM.

  3. File-based — Supplies keys that are not defined by MDM or server-managed settings.

  4. User settings — Lowest priority and overridden by managed settings.

For example, an organization can use native MDM to enforce security-related settings while server-managed settings supply other Copilot configuration. The methods therefore do not need to contain the same set of keys.

Deployment steps for each method are covered in Step 2 — Deploy the Settings.

Procedure

Step 1 — Configure GitHub Copilot Managed Settings

GitHub Copilot managed settings tell Copilot which marketplace and plugin to make available on managed developer machines.

Configure the settings to register the official Checkmarx marketplace and enable cx-devassist:

{
  "enabledPlugins": {
    "cx-devassist@cx-devassist-marketplace": true
  },
  "extraKnownMarketplaces": {
    "cx-devassist-marketplace": {
      "source": {
        "source": "github",
        "repo": "Checkmarx/cx-agentic-ai",
        "ref": "master",
        "path": ".github/plugin/marketplace.json"
      }
    }
  }
}

This configuration:

  • extraKnownMarketplaces — Registers the Checkmarx marketplace with GitHub Copilot.

  • enabledPlugins — Enables cx-devassist for managed users.

With this configuration, the plugin is delivered directly from the official Checkmarx repository. Developers provide their Checkmarx One URL and tenant during initial authentication.

Step 2 — Deploy the Settings

Deploy the managed settings using the method (or methods) you chose in Deployment Methods.

Note: This guide describes the settings that must be deployed. The exact procedure for creating and assigning a native MDM policy depends on the MDM product used by your organization.

Native MDM

Windows

Deploy the settings as string (REG_SZ) values under:

HKLM\SOFTWARE\Policies\GitHubCopilot
macOS

Deploy a configuration profile with forced managed preferences for:

com.github.copilot

Top-level keys mirror managed-settings.json.

Encoding structured values

Native MDM does not deploy a JSON file. On both Windows and macOS, structured settings such as enabledPlugins and extraKnownMarketplaces must be encoded as single-line JSON strings.

For example:

Key

String value

enabledPlugins

{"cx-devassist@cx-devassist-marketplace":true}

extraKnownMarketplaces

{"cx-devassist-marketplace":{"source":{"source":"github","repo":"Checkmarx/cx-agentic-ai","ref":"master","path":".github/plugin/marketplace.json"}}}

Clients check for updated native MDM policies hourly. In VS Code, administrators can force a policy synchronization using Developer: Sync Account Policy.

For additional information, see:

File-based

Deploy a system-level managed-settings.json file:

OS

Path

Windows

C:\Program Files\GitHubCopilot\managed-settings.json

macOS

/Library/Application Support/GitHubCopilot/managed-settings.json

Linux

/etc/github-copilot/managed-settings.json

Administrator or elevated permissions are required to deploy the file.

On macOS and Linux, Copilot CLI rejects file-based managed settings that are:

  • Symbolic links

  • Not owned by root

  • Group-writable or world-writable

Use appropriate ownership and permissions, such as root:root with mode 644 or tighter.

After deploying file-based settings, restart Copilot CLI or the applicable IDE session so plugin hooks are loaded.

For dedicated Copilot Business enterprises without a GitHub Enterprise license, native MDM or file-based deployment can be used without a .github-private repository. See Guidance for dedicated Copilot Business enterprises.

Server-managed

Commit the managed settings to copilot/managed-settings.json in your enterprise’s .github-private repository. No local managed-settings file or device profile is required for keys supplied exclusively through this method.

For configuration instructions, see:

Step 3 — Verify the Deployment

Verify the deployment on a test machine before rolling it out broadly.

  1. Confirm that the managed settings were applied:

    • Native MDM (Windows) — Confirm that the expected values were deployed under HKLM\SOFTWARE\Policies\GitHubCopilot.

    • Native MDM (macOS) — Confirm that the managed preferences were deployed for com.github.copilot.

    • File-based — Confirm the managed-settings.json file exists at the expected system path with correct ownership.

    • Server-managed — Confirm the user’s Copilot license is billed to your enterprise and that settings have refreshed.

  2. Open GitHub Copilot CLI and confirm that cx-devassist is listed and enabled without manually running /plugin install.

  3. Start a Checkmarx operation, for example by asking Copilot to retrieve your Checkmarx projects.

  4. If authentication is required, select your organization’s authentication method:

    • Browser sign-in (OAuth) — Enter the Checkmarx One URL and tenant provided by your organization, then complete authentication in the browser.

    • API key — Provide the Checkmarx One API key according to your organization’s authentication process.

  5. Run another Checkmarx operation and confirm that the Checkmarx MCP server is connected and operational.

When using Browser sign-in (OAuth), the Checkmarx One URL and tenant are remembered after initial configuration and do not need to be entered for subsequent operations.

Native MDM and server-managed settings refresh hourly, so policy changes can take effect without a full redeployment of the plugin. File-based settings apply after restarting Copilot CLI or the applicable IDE session.

Audit logs, if enabled, are written to:

~/.checkmarx/agent-logs/copilot-cli/checkmarx-devassist.jsonl

Optional — Preconfigure the Checkmarx One URL and Tenant

When using Browser sign-in (OAuth), you can preconfigure the Checkmarx One URL and tenant so developers do not need to enter these values during initial authentication.

This requires maintaining an internal fork or mirror of the Checkmarx repository.

Important: With the standard deployment, the plugin is delivered directly from the official Checkmarx repository, so Checkmarx updates can be received directly. If your organization uses an internal fork or mirror to preconfigure the Checkmarx One URL and tenant, your organization administrator must keep the internal repository synchronized with updates from the official Checkmarx repository.

Preconfiguration applies to Browser sign-in (OAuth). API key authentication does not use cx-onboarding.properties; see API Key Authentication.

Step 1 — Create an Internal Fork or Mirror

  1. Fork or mirror Checkmarx/cx-agentic-ai into a repository controlled by your organization, for example YourOrg/cx-agentic-ai.

  2. Create a branch or tag for the managed deployment, for example mdm-v1.

  3. Ensure managed developer machines have read access to the repository.

For a private repository, use an access mechanism appropriate for your organization, such as organization-wide repository access, a GitHub App or deploy key available to managed devices, or an internal Git hosting solution.

Step 2 — Configure the Checkmarx One URL and Tenant

In the internal repository, edit:

plugins/copilot-devassist/config/cx-onboarding.properties

For example:

cx_base_auth_uri=https://eu.ast.checkmarx.net
cx_tenant=your-org-tenant

Use the Checkmarx One base authentication URL for your region or your on-premises deployment.

You can find the tenant in Checkmarx One under Settings → Identity and Access Management → General Settings (Display Name), or in the Checkmarx One welcome email.

Value formats and common regions

Key

Format

Example

cx_base_auth_uri

https://<host>[:port] — no path, query, userinfo, or trailing slash

https://eu.ast.checkmarx.net

cx_tenant

Starts with alphanumeric; then letters, digits, ., _, - only; max 64 characters

acme-corp

Region

URL

US

https://ast.checkmarx.net

US2

https://us.ast.checkmarx.net

EU

https://eu.ast.checkmarx.net

ANZ

https://anz.ast.checkmarx.net

India

https://ind.ast.checkmarx.net

Use your on-premises URL if applicable.

If either value is missing or invalid, the plugin falls back to requesting the information from the developer rather than blocking authentication.

Step 3 — Point Managed Settings to the Internal Repository

Update the marketplace source in the managed settings to reference the internal repository and the branch, tag, or SHA used for the deployment:

{
  "enabledPlugins": {
    "cx-devassist@cx-devassist-marketplace": true
  },
  "extraKnownMarketplaces": {
    "cx-devassist-marketplace": {
      "source": {
        "source": "github",
        "repo": "YourOrg/cx-agentic-ai",
        "ref": "mdm-v1",
        "path": ".github/plugin/marketplace.json"
      }
    }
  }
}

The marketplace name can remain cx-devassist-marketplace when using a fork. If you rename the marketplace in marketplace.json, update both the marketplace key and the enabledPlugins entry to match.

Step 4 — Deploy the Updated Settings

Deploy the updated managed settings through the same method described in Step 2 — Deploy the Settings.

Step 5 — Verify Preconfigured Onboarding

On a test machine:

  1. Confirm that cx-devassist is installed and enabled through managed settings.

  2. Start a Checkmarx operation.

  3. Select Browser sign-in (OAuth) if authentication is required.

  4. Verify that the authentication flow uses the configured Checkmarx One URL and tenant without asking the developer to provide them.

  5. Complete browser authentication.

  6. Run a Checkmarx operation and confirm that the MCP server can access Checkmarx One.

Depending on the authentication flow, Copilot may instruct the developer to run the generated cx auth login command manually. The important verification is that the command contains the configured --base-auth-uri and --tenant values without requiring the developer to supply them.

Maintain the Internal Repository

When Checkmarx publishes an updated version:

  1. Merge or cherry-pick the upstream Checkmarx changes into the internal repository.

  2. Confirm that the configured cx-onboarding.properties values were preserved.

  3. Test the updated plugin on a pilot machine.

  4. Create or update the deployment ref if your organization pins the marketplace to a branch, tag, or SHA.

  5. Update the managed settings if the configured ref changed and redeploy as required.

Do not edit cx-onboarding.properties directly in a developer’s installed plugin directory. Installed plugin files can be overwritten during an update.

Managed enabledPlugins entries cannot be disabled through a developer’s local settings. Change the managed policy to change the organization-wide plugin configuration.

Optional — Enterprise Policy Controls

GitHub Copilot managed settings can also restrict marketplaces, plugins, MCP servers, and other Copilot behavior. These controls are not required to deploy cx-devassist.

Restrict Marketplaces

Use strictKnownMarketplaces if your organization wants to restrict which marketplaces users can add.

For example:

{
  "strictKnownMarketplaces": [
    {
      "source": "github",
      "repo": "Checkmarx/cx-agentic-ai",
      "ref": "master",
      "path": ".github/plugin/marketplace.json"
    }
  ],
  "extraKnownMarketplaces": {
    "cx-devassist-marketplace": {
      "source": {
        "source": "github",
        "repo": "Checkmarx/cx-agentic-ai",
        "ref": "master",
        "path": ".github/plugin/marketplace.json"
      }
    }
  },
  "enabledPlugins": {
    "cx-devassist@cx-devassist-marketplace": true
  }
}

An empty strictKnownMarketplaces array ([]) prevents users from adding marketplaces.

If you use an internal fork, the source in strictKnownMarketplaces must match the repository, ref, and path used by the managed marketplace configuration.

Restrict MCP Servers

GitHub Copilot also supports MCP server policies such as allowedMcpServers and deniedMcpServers.

Because cx-devassist uses the Checkmarx MCP server through cx mcp bridge, ensure that any MCP allowlist used by your organization permits the Checkmarx MCP server.

If your organization does not need MCP restrictions, these settings are not required for the Checkmarx deployment.

Additional Security Controls

GitHub Copilot managed settings provide additional controls such as:

  • permissions.disableBypassPermissionsMode

  • sandbox

Use these settings according to your organization’s Copilot security policy. They are not Checkmarx-specific requirements.

For the complete set of available controls and their syntax, see the Enterprise managed settings reference.

API Key Authentication

API key authentication does not use cx-onboarding.properties. The API key contains the Checkmarx One URL and tenant information, so these values do not need to be preconfigured in the plugin.

If your organization uses API key authentication, distribute the Checkmarx One API key through your organization’s approved secret-management process, separately from the managed-settings deployment.

Developers select API key as the authentication method during setup.

Troubleshooting

Symptom

Likely cause

Action

Plugin is not installed automatically

Managed settings are missing, invalid, or deployed to the wrong location

Verify the delivery method, configuration syntax, and marketplace source. For file-based deployment, restart Copilot CLI after applying the settings.

Managed settings do not apply

The expected enterprise or device policy is not being applied

Verify the user’s Copilot organization/account and the applicable managed-settings source.

strictKnownMarketplaces blocks the Checkmarx plugin

The allowlist does not match the configured marketplace source

Ensure the repository, ref, and path in the allowlist match the marketplace configuration.

Checkmarx MCP server reports program not found on Windows

sh is not available on PATH

Run sh --version. If it is not recognized, ensure Git for Windows is installed and its bin directory is included in PATH, then restart Copilot CLI.

Developer is prompted for URL and tenant when using the official Checkmarx repository

This is the expected first-use flow

Enter the organization’s Checkmarx One URL and tenant. They are remembered for subsequent use.

Developer is prompted for URL and tenant when using a preconfigured internal repository

The onboarding configuration is missing, invalid, or the wrong plugin ref was deployed

Verify cx-onboarding.properties and confirm that managed settings point to the expected repository and ref.

Authentication uses the wrong tenant or region

Incorrect onboarding values

Verify cx_base_auth_uri and cx_tenant.

Internal deployment does not receive new Checkmarx versions

The internal fork or mirror has not been synchronized

Merge or cherry-pick the latest upstream changes and roll out the updated ref.

Private internal repository cannot be accessed

Managed machines do not have repository access

Configure an organization-approved repository authentication/access method.

Updated plugin hooks do not load

The current Copilot session is still using the previous plugin state

Restart Copilot CLI or the applicable IDE session.

Native MDM structured values do not apply

Object or array values were not encoded correctly

Store structured settings as JSON strings as required by GitHub Copilot native MDM configuration.

File-based settings are ignored on macOS/Linux

Invalid file ownership or permissions

Ensure the file is owned by root, is not a symbolic link, and is not group- or world-writable.

Related Documentation