mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 16:45:34 +08:00
## Description
Supersedes #3403 (parked, stacked on the conflicting #3402) as a
standalone change on `main`.
GitHub's token exchange advertises a per-plan chat host in
`endpoints.api`: `api.business.githubcopilot.com` for Business seats and
`api.enterprise.githubcopilot.com` for Enterprise seats, and GitHub's
own clients route with it. Since #2441 Headroom has folded both into the
generic `api.githubcopilot.com`, because the segmented hosts lagged on
newer Claude models at the time.
That fold breaks enterprises on GitHub's [subscription-based network
routing](https://docs.github.com/en/copilot/how-tos/administer-copilot/manage-for-enterprise/manage-access/manage-network-access):
their firewall allows only the plan host, the generic host is
unreachable, and the failure looks like a random connection error. It
also made the VS Code guide's Enterprise section wrong, which said
Headroom uses the advertised URL.
This PR honours the Business and Enterprise advertised hosts by default
and adds `GITHUB_COPILOT_USE_ADVERTISED_HOST=0` (also
`false`/`no`/`off`) to restore the generic-host fold for seats where the
segmented host still lags. An explicit `GITHUB_COPILOT_API_URL` or
enterprise domain still wins over both. The individual host keeps being
folded (#610 is unchanged).
Refs #2441, #610, #3352 (an Enterprise seat behind a corporate firewall;
the inline-completions 401 there is #4144).
## Type of Change
- [x] Bug fix (non-breaking change that fixes an issue)
- [x] Documentation update
## Changes Made
- `headroom/copilot_auth.py`:
`_subscription_api_url_from_user_info_payload` returns the advertised
host for the two plan hosts unless `GITHUB_COPILOT_USE_ADVERTISED_HOST`
opts out, and logs the chosen host with the opt-out next to it. That
line is emitted where the host is resolved: the `wrap` process for the
subscription lanes, which does not write to `proxy.log`. The dedicated
proxy's `/health` (`config.openai_api_url`) is where the chosen host
shows up. The generic and individual hosts still normalize to
`DEFAULT_API_URL`. `resolve_copilot_api_url`'s docstring no longer
claims the advertised host is ignored on purpose. Every subscription
lane (`wrap vscode`, `wrap copilot --subscription`, OpenCode
`--copilot-subscription`) already pins `resolution.api_url` into the
dedicated proxy as `--openai-api-url` and `GITHUB_COPILOT_API_URL`, so
they pick this up without changes; `is_copilot_api_url`,
`copilot_completions_base_url` and `_github_host` already treat
`*.githubcopilot.com` as a public Copilot host (verified by an
independent review of the diff).
- `headroom/cli/wrap.py`: `wrap copilot` help text describes the
per-plan routing for `--subscription`; the implicit OAuth lane still
uses the generic host (it performs no token exchange), which the text
now says.
- Docs: `docs/content/docs/vscode-copilot.mdx` Enterprise section is now
true and names the opt-out and the firewall case;
`docs/content/docs/corporate-networks.mdx` lists the plan hosts;
`TESTING-copilot-subscription.md` host section split by lane:
`--subscription` / `wrap vscode` / OpenCode honour the plan host, the
implicit OAuth `wrap copilot` lane is explicitly generic-host (it
performs no token exchange at launch, and `resolve_copilot_api_url` is
pinned network-free by an existing test), and its "open an issue for
auto-detection" paragraph removed.
- Tests: Business and Enterprise honoured; individual and generic still
folded; opt-out restores the fold; explicit pin wins; `wrap copilot
--subscription` pins the advertised host; the implicit OAuth lane stays
on the generic host even when user-info advertises the Enterprise host;
OpenCode subscription lane expectation updated. Three existing tests
that asserted the fold were updated to the new contract.
Follow-ups, not in this PR: `headroom doctor --network` still probes
only `api.githubcopilot.com` (it should probe the resolved plan host);
the implicit OAuth `wrap copilot` lane could resolve the plan host
through the token exchange too.
## Testing
- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy`)
- [x] New tests added for new functionality
- [x] Manual testing performed (live Copilot Business seat, 2026-10-13;
see Live verification)
### Test Output
```text
$ pytest tests/test_copilot_auth.py tests/test_cli/test_wrap_copilot.py tests/test_cli/test_wrap_vscode.py \
tests/test_copilot_vscode_completions_routing.py tests/test_provider_copilot_vscode_config.py \
tests/test_cli/test_wrap_opencode.py tests/test_proxy_copilot_auth_hooks.py tests/test_provider_proxy_routes.py \
tests/test_copilot_integration_id_hmac.py tests/test_proxy/test_anthropic_copilot_upstream_auth.py \
tests/test_copilot_native_mode.py tests/test_copilot_subscription_smoke.py tests/test_cli/test_copilot_auth.py \
tests/test_cli/test_wrap_persistent.py
449 passed, 4 deselected
# the 4 deselected tests (test_wrap_persistent.py::*recover*) fail identically on the base commit 976aa714
# with AttributeError: 'TaskManifest' object has no attribute 'runtime_kind'; unrelated to this change
$ uvx ruff@0.16.8 check . && uvx ruff@0.16.8 format --check .
All checks passed! / 1777 files already formatted
$ mypy headroom/copilot_auth.py headroom/cli/wrap.py --ignore-missing-imports
Success: no issues found in 2 source files
```
## Real Behavior Proof
- Environment: macOS, Python 3.12, repo venv, native core loaded.
- Exact command / steps: the suites above, with the new regressions
failing when `_subscription_api_url_from_user_info_payload` is reverted
to the fold.
- Observed result: the token-exchange and user-info producers, `wrap
vscode`, `wrap copilot --subscription` and the OpenCode lane all hand
the dedicated proxy `https://api.enterprise.githubcopilot.com` (or
`.business.`) as both `--openai-api-url` and `GITHUB_COPILOT_API_URL`;
completions still resolve to `copilot-proxy.githubusercontent.com`.
- Live seat: see "Live verification" below. Not tested: an
Enterprise-plan seat (`api.enterprise.`; same code branch as Business),
and the `wrap copilot --subscription` lane (the test seat has the
Copilot CLI policy off).
### Verification needed before release
No Business or Enterprise seat is available to us. Carrier (Enterprise
seats behind a subscription-routed firewall) runs, on this branch, with
`SSL_CERT_FILE` unset and no `GITHUB_COPILOT_API_URL` exported:
```bash
headroom copilot-auth login # device flow; approve in the browser
headroom wrap vscode # leave running; note the port it prints
curl -s http://127.0.0.1:<port>/health | python3 -m json.tool | grep openai_api_url
# expected: "openai_api_url": "https://api.enterprise.githubcopilot.com"
# then send one Copilot Chat turn in VS Code (any model) and one inline completion
headroom wrap copilot --subscription -- --model claude-sonnet-4.6 -s -p "Reply with exactly: OK"
# expected: the banner shows COPILOT_PROVIDER_API_URL=https://api.enterprise.githubcopilot.com and the reply is OK
```
`curl -s http://127.0.0.1:<port>/health` on the dedicated proxy should
report `"openai_api_url": "https://api.enterprise.githubcopilot.com"`
(the "advertised plan host" log line is printed by the wrap process, not
written to `proxy.log`). If a model that the generic host serves is
rejected on the plan host (`400 ... model is not supported`), the #2455
condition still holds for that seat: set
`GITHUB_COPILOT_USE_ADVERTISED_HOST=0`, restart the wrapper, and report
the model and the response body on this PR before it is released.
### Live verification (2026-10-13, Copilot Business seat)
Branch merged with #4154 on current `main`, isolated
`HEADROOM_WORKSPACE_DIR`, `SSL_CERT_FILE` and `GITHUB_COPILOT_API_URL`
unset, `headroom copilot-auth login` device flow.
- `/copilot_internal/user` for the seat: `copilot_plan: business`,
`endpoints.api: https://api.business.githubcopilot.com`. (For about
three hours after the seat was assigned GitHub still advertised
`api.individual.`; the plan host appeared on its own.)
- Resolution: default → `https://api.business.githubcopilot.com`;
`GITHUB_COPILOT_USE_ADVERTISED_HOST=0` →
`https://api.githubcopilot.com`; explicit `GITHUB_COPILOT_API_URL` wins.
`main`'s `copilot_auth.py` resolves the same seat to
`https://api.githubcopilot.com`.
- `headroom wrap vscode`: dedicated proxy started with `--openai-api-url
https://api.business.githubcopilot.com`; `/health` reports it.
- Model sweep through the proxy, one turn per picker model on each
endpoint it lists (plus `gpt-4o-mini`): **36/36 returned 200** on the
plan host (Claude Haiku/Sonnet/Opus 4.x–5.5 on `/v1/messages` and
`/chat/completions`, Gemini 3.7/3.8/4, GPT-5.x/6.x and Grok on
`/responses`, `gpt-5-mini`, `gpt-4o-mini`). No `model_not_supported`, so
the #2441/#2455 lag does not reproduce on Business today.
- Real VS Code (Copilot Chat 0.69): Ask mode on Auto (`gpt-6-luna`),
Claude Sonnet 5.5 chat (`/v1/messages`), and Agent mode with tool calls
(wrote and ran a pytest file) all went to
`api.business.githubcopilot.com`; every Copilot upstream call in the
proxy log used the plan host, none the generic host.
- Found while testing, not caused by this PR and present on `main`:
ghost text / next edits (`copilot-nes-*` on `/chat/completions`) are
sent to CAPI and get `400 model_not_supported` on both the plan host and
the generic host. Fixed separately in #4188.
## Runtime Rollout Safety
- Rollout-managed feature(s): none; env-gated.
- Minimum rollout channel: stable.
- Stable/default behavior changed: yes. Business and Enterprise
subscription sessions now route to their advertised plan host instead of
`api.githubcopilot.com`. Individual seats, explicit pins and GHE domains
are unchanged.
- Kill switch / disable path: `GITHUB_COPILOT_USE_ADVERTISED_HOST=0`
restores the previous fold without a rollback; `GITHUB_COPILOT_API_URL`
pins any host.
- Unsafe override required: no.
- Qualification impact: adds plan-host routing coverage to the Copilot
auth and wrap suites.
- Rollback path: revert the commit.
## Review Readiness
- [x] I have performed a self-review
- [x] This PR is ready for human review
## Checklist
- [x] My code follows the project's style guidelines
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md`
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
1136 lines
42 KiB
Python
1136 lines
42 KiB
Python
"""Tests for `headroom wrap copilot` command."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import importlib
|
|
import sys
|
|
import types
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
from urllib.parse import quote
|
|
|
|
import click
|
|
import pytest
|
|
from click.testing import CliRunner
|
|
|
|
from headroom.copilot_auth import DEFAULT_API_URL, CopilotSubscriptionTokenResolution
|
|
|
|
|
|
def _expected_project_prefix() -> str:
|
|
"""The /p/<name> prefix the wrap now embeds (launch-directory basename)."""
|
|
return f"/p/{quote(Path.cwd().name, safe='')}"
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _no_retired_context_tool_env(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""A developer's exported HEADROOM_CONTEXT_TOOL would abort every wrap below."""
|
|
monkeypatch.delenv("HEADROOM_CONTEXT_TOOL", raising=False)
|
|
|
|
|
|
@pytest.fixture
|
|
def runner() -> CliRunner:
|
|
return CliRunner()
|
|
|
|
|
|
def _subscription_resolution(
|
|
token: str = "gho-existing",
|
|
*,
|
|
api_url: str = DEFAULT_API_URL,
|
|
source: str = "headroom-copilot-auth:/tmp/copilot_auth.json:token-exchange",
|
|
confidence: str = "copilot-token-exchange",
|
|
refresh_oauth_token: str | None = None,
|
|
api_token_expires_at: float | None = None,
|
|
) -> CopilotSubscriptionTokenResolution:
|
|
return CopilotSubscriptionTokenResolution(
|
|
token=token,
|
|
source=source,
|
|
confidence=confidence,
|
|
api_url=api_url,
|
|
token_fingerprint="sha256:0123456789ab",
|
|
refresh_oauth_token=refresh_oauth_token,
|
|
api_token_expires_at=api_token_expires_at,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def wrap_modules(monkeypatch: pytest.MonkeyPatch) -> tuple[types.ModuleType, click.Group]:
|
|
headroom_pkg = sys.modules.get("headroom")
|
|
saved_headroom_cli_attr = (
|
|
headroom_pkg.cli if headroom_pkg is not None and hasattr(headroom_pkg, "cli") else None
|
|
)
|
|
saved_modules = {
|
|
name: sys.modules.get(name)
|
|
for name in ("headroom.cli", "headroom.cli.main", "headroom.cli.wrap")
|
|
}
|
|
|
|
fake_main_module = types.ModuleType("headroom.cli.main")
|
|
fake_main_module.main = click.Group()
|
|
sys.modules["headroom.cli.main"] = fake_main_module
|
|
sys.modules.pop("headroom.cli", None)
|
|
sys.modules.pop("headroom.cli.wrap", None)
|
|
|
|
wrap_cli = importlib.import_module("headroom.cli.wrap")
|
|
monkeypatch.setattr(wrap_cli, "_check_proxy", lambda _port: False)
|
|
|
|
try:
|
|
yield wrap_cli, fake_main_module.main
|
|
finally:
|
|
for name in ("headroom.cli.wrap", "headroom.cli.main", "headroom.cli"):
|
|
sys.modules.pop(name, None)
|
|
for name, module in saved_modules.items():
|
|
if module is not None:
|
|
sys.modules[name] = module
|
|
if saved_modules["headroom.cli"] is not None:
|
|
cli_pkg = saved_modules["headroom.cli"]
|
|
if saved_modules["headroom.cli.main"] is not None:
|
|
cli_pkg.main = saved_modules["headroom.cli.main"]
|
|
if saved_modules["headroom.cli.wrap"] is not None:
|
|
cli_pkg.wrap = saved_modules["headroom.cli.wrap"]
|
|
if headroom_pkg is not None:
|
|
if saved_headroom_cli_attr is None:
|
|
if hasattr(headroom_pkg, "cli"):
|
|
delattr(headroom_pkg, "cli")
|
|
else:
|
|
headroom_pkg.cli = saved_headroom_cli_attr
|
|
|
|
|
|
def test_wrap_copilot_auto_anthropic_sets_provider_env(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
tmp_path: Path,
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.chdir(tmp_path)
|
|
monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test-dummy")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--", "--model", "claude-sonnet-4-20250514"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "anthropic"
|
|
assert env["COPILOT_PROVIDER_BASE_URL"] == f"http://127.0.0.1:8787{_expected_project_prefix()}"
|
|
assert "COPILOT_PROVIDER_WIRE_API" not in env
|
|
assert captured["agent_type"] == "copilot"
|
|
assert captured["tool_label"] == "COPILOT"
|
|
assert captured["args"] == ("--model", "claude-sonnet-4-20250514")
|
|
|
|
|
|
def test_wrap_copilot_openai_backend_sets_completions_env(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.setenv("OPENAI_API_KEY", "sk-test-dummy")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"wrap",
|
|
"copilot",
|
|
"--backend",
|
|
"anyllm",
|
|
"--anyllm-provider",
|
|
"groq",
|
|
"--region",
|
|
"us-central1",
|
|
"--",
|
|
"--model",
|
|
"gpt-4o",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_BASE_URL"] == (
|
|
f"http://127.0.0.1:8787{_expected_project_prefix()}/v1"
|
|
)
|
|
assert env["COPILOT_PROVIDER_WIRE_API"] == "completions"
|
|
|
|
|
|
def test_wrap_copilot_byok_rejects_auto_model_before_launch(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.setenv("OPENAI_API_KEY", "sk-test-dummy")
|
|
|
|
def fail_launch_tool(**_kwargs: object) -> None:
|
|
raise AssertionError("_launch_tool must not run with --model auto in BYOK mode")
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fail_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"wrap",
|
|
"copilot",
|
|
"--provider-type",
|
|
"openai",
|
|
"--",
|
|
"--model",
|
|
"auto",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "'--model auto' is not supported in Copilot BYOK mode" in result.output
|
|
assert "Use a concrete model" in result.output
|
|
|
|
|
|
def test_wrap_copilot_auto_detects_running_proxy_backend(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.setenv("OPENAI_API_KEY", "sk-test-dummy")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._check_proxy", return_value=True),
|
|
patch("headroom.cli.wrap._detect_running_proxy_backend", return_value="anyllm"),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--", "--model", "gpt-4o"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_BASE_URL"] == (
|
|
f"http://127.0.0.1:8787{_expected_project_prefix()}/v1"
|
|
)
|
|
assert env["COPILOT_PROVIDER_WIRE_API"] == "completions"
|
|
|
|
|
|
def test_wrap_copilot_prefers_existing_oauth_session(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test-dummy")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
|
|
with patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-existing"):
|
|
with patch("headroom.cli.wrap.has_oauth_auth", return_value=True):
|
|
with patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--", "--model", "claude-sonnet-4.6"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_API_URL"] == f"http://127.0.0.1:8787{_expected_project_prefix()}"
|
|
assert "COPILOT_PROVIDER_TYPE" not in env
|
|
assert "COPILOT_PROVIDER_BASE_URL" not in env
|
|
assert "COPILOT_PROVIDER_WIRE_API" not in env
|
|
assert "COPILOT_PROVIDER_BEARER_TOKEN" not in env
|
|
assert env["GITHUB_COPILOT_API_URL"] == DEFAULT_API_URL
|
|
assert env["OPENAI_TARGET_API_URL"] == DEFAULT_API_URL
|
|
assert "COPILOT_PROVIDER_API_KEY" not in env
|
|
assert captured["openai_api_url"] == DEFAULT_API_URL
|
|
assert "COPILOT_AUTH_MODE=github-native" in captured["env_vars_display"]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("model", "expected_wire_api"),
|
|
[
|
|
("gpt-5.4", "responses"),
|
|
("gpt-4.1", "completions"),
|
|
],
|
|
)
|
|
def test_wrap_copilot_oauth_defaults_wire_api_for_selected_model(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
model: str,
|
|
expected_wire_api: str,
|
|
) -> None:
|
|
"""Implicit OAuth leaves wire selection to Copilot's native router."""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-existing"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--no-rtk", "--", "--model", model],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert "COPILOT_PROVIDER_WIRE_API" not in env
|
|
assert env["COPILOT_API_URL"].startswith("http://127.0.0.1:8787")
|
|
|
|
|
|
@pytest.mark.parametrize("wire_api", ["completions", "responses"])
|
|
def test_wrap_copilot_oauth_honors_existing_wire_api(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
wire_api: str,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
monkeypatch.setenv("COPILOT_PROVIDER_WIRE_API", wire_api)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-existing"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--no-rtk", "--", "--model", "gpt-5.4"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert "COPILOT_PROVIDER_WIRE_API" not in env
|
|
assert env["COPILOT_API_URL"].startswith("http://127.0.0.1:8787")
|
|
|
|
|
|
def test_wrap_copilot_subscription_uses_github_auth_without_provider_key(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
for var in ("COPILOT_PROVIDER_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"):
|
|
monkeypatch.delenv(var, raising=False)
|
|
monkeypatch.setenv("GITHUB_COPILOT_API_TOKEN", "stale-parent-token")
|
|
monkeypatch.setenv("GITHUB_COPILOT_REFRESH_OAUTH_TOKEN", "stale-parent-refresh")
|
|
monkeypatch.setenv("GITHUB_COPILOT_API_TOKEN_EXPIRES_AT", "1")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution(),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "Copilot BYOK requires a model" not in result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_BASE_URL"] == (
|
|
f"http://127.0.0.1:8787{_expected_project_prefix()}/v1"
|
|
)
|
|
assert env["COPILOT_PROVIDER_WIRE_API"] == "completions"
|
|
assert env["COPILOT_PROVIDER_BEARER_TOKEN"] == "gho-existing"
|
|
assert "COPILOT_PROVIDER_API_KEY" not in env
|
|
assert captured["openai_api_url"] == DEFAULT_API_URL
|
|
|
|
|
|
def test_wrap_copilot_subscription_defaults_to_responses_for_reasoning_model(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution("gho-existing"),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--", "--model", "gpt-5.4"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_WIRE_API"] == "responses"
|
|
assert "COPILOT_PROVIDER_WIRE_API=responses" in captured["env_vars_display"]
|
|
|
|
|
|
def test_wrap_copilot_subscription_keeps_gpt4_on_completions(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Subscription routing must not blanket-promote every model to the responses
|
|
API: a non-reasoning model such as gpt-4.1 still defaults to ``completions``.
|
|
The provider-helper unit tests cover the wire-API decision in isolation; this
|
|
exercises the full CLI path (args -> subscription resolution -> launch env) so
|
|
the default can't silently regress to ``responses`` for GPT-4 traffic.
|
|
"""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution("gho-existing"),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--", "--model", "gpt-4.1"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_WIRE_API"] == "completions"
|
|
|
|
|
|
def test_wrap_copilot_subscription_allows_explicit_responses_wire_api(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution("gho-existing"),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"wrap",
|
|
"copilot",
|
|
"--subscription",
|
|
"--wire-api",
|
|
"responses",
|
|
"--",
|
|
"--model",
|
|
"gpt-5.4",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_WIRE_API"] == "responses"
|
|
|
|
|
|
def test_wrap_copilot_subscription_pins_validated_token_for_proxy(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""`--subscription` must hand the *validated* token to the proxy.
|
|
|
|
The proxy honours ``GITHUB_COPILOT_API_TOKEN``; the wrapper passes the
|
|
resolved token as the ``copilot_api_token`` launch argument so the proxy
|
|
pins exactly it (rather than re-discovering a possibly different,
|
|
unvalidated token). The token rides the launch arg, never the child env or
|
|
the parent's global ``os.environ``. This guards the deterministic handoff.
|
|
"""
|
|
_wrap_cli, main = wrap_modules
|
|
for var in ("COPILOT_PROVIDER_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"):
|
|
monkeypatch.delenv(var, raising=False)
|
|
|
|
business_api = "https://api.business.githubcopilot.com"
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs: object) -> None:
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution(
|
|
"gho-validated",
|
|
api_url=business_api,
|
|
refresh_oauth_token="gho-refresh",
|
|
api_token_expires_at=1234567890.0,
|
|
),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription"],
|
|
env={
|
|
"GITHUB_COPILOT_API_TOKEN": "stale-parent-token",
|
|
"GITHUB_COPILOT_REFRESH_OAUTH_TOKEN": "stale-parent-refresh",
|
|
"GITHUB_COPILOT_API_TOKEN_EXPIRES_AT": "1",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
# The validated token is handed to the proxy as an explicit launch
|
|
# argument — not via the child env, not via the parent's os.environ.
|
|
assert captured["copilot_api_token"] == "gho-validated"
|
|
assert captured["copilot_refresh_oauth_token"] == "gho-refresh"
|
|
assert captured["copilot_api_token_expires_at"] == 1234567890.0
|
|
assert "GITHUB_COPILOT_API_TOKEN" not in env
|
|
assert "GITHUB_COPILOT_REFRESH_OAUTH_TOKEN" not in env
|
|
assert "GITHUB_COPILOT_API_TOKEN_EXPIRES_AT" not in env
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
assert env["COPILOT_PROVIDER_BEARER_TOKEN"] == "gho-validated"
|
|
assert env["GITHUB_COPILOT_USE_TOKEN_EXCHANGE"] == "false"
|
|
assert env["OPENAI_TARGET_API_URL"] == business_api
|
|
assert captured["openai_api_url"] == business_api
|
|
assert "COPILOT_PROVIDER_API_KEY" not in env
|
|
# The secret must never be echoed to the terminal.
|
|
assert "gho-validated" not in result.output
|
|
|
|
|
|
def test_wrap_copilot_subscription_requires_reusable_auth(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.resolve_subscription_bearer_token_details", return_value=None),
|
|
):
|
|
result = runner.invoke(main, ["wrap", "copilot", "--subscription"])
|
|
|
|
assert result.exit_code != 0
|
|
assert "subscription mode requires a reusable GitHub/Copilot bearer token" in result.output
|
|
assert "headroom copilot-auth login" in result.output
|
|
|
|
|
|
def test_wrap_copilot_subscription_rejects_translated_backend(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--backend", "anyllm"],
|
|
)
|
|
|
|
assert result.exit_code != 0
|
|
assert "cannot be combined with translated backends" in result.output
|
|
|
|
|
|
def test_wrap_copilot_subscription_rejects_anthropic_provider_type(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--provider-type", "anthropic"],
|
|
)
|
|
|
|
assert result.exit_code != 0
|
|
assert "do not combine it with --provider-type anthropic" in result.output
|
|
|
|
|
|
def test_wrap_copilot_translated_backend_still_requires_byok(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
# The point of the test is that BYOK is required even with `--backend
|
|
# anyllm`, but the BYOK check only fires when no provider key is in
|
|
# the environment. The test runs against the real `os.environ`, so
|
|
# explicitly clear every key the CLI checks first.
|
|
for var in (
|
|
"COPILOT_PROVIDER_API_KEY",
|
|
"OPENAI_API_KEY",
|
|
"ANTHROPIC_API_KEY",
|
|
"GEMINI_API_KEY",
|
|
"GROQ_API_KEY",
|
|
"MISTRAL_API_KEY",
|
|
"TOGETHER_API_KEY",
|
|
):
|
|
monkeypatch.delenv(var, raising=False)
|
|
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
|
|
with patch("headroom.cli.wrap.has_oauth_auth", return_value=True):
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"wrap",
|
|
"copilot",
|
|
"--backend",
|
|
"anyllm",
|
|
"--",
|
|
"--model",
|
|
"gpt-4o",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "Copilot BYOK mode requires a provider API key" in result.output
|
|
|
|
|
|
def test_wrap_copilot_rejects_wire_api_for_anthropic_provider(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"wrap",
|
|
"copilot",
|
|
"--wire-api",
|
|
"responses",
|
|
"--",
|
|
"--model",
|
|
"claude-sonnet-4-20250514",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code != 0
|
|
assert "--wire-api is only valid" in result.output
|
|
|
|
|
|
def test_wrap_copilot_rejects_responses_for_translated_backends(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"wrap",
|
|
"copilot",
|
|
"--backend",
|
|
"anyllm",
|
|
"--wire-api",
|
|
"responses",
|
|
"--",
|
|
"--model",
|
|
"gpt-4o",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code != 0
|
|
assert "not supported with translated backends" in result.output
|
|
|
|
|
|
def test_wrap_copilot_clears_stale_wire_api_in_anthropic_mode(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test-dummy")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--", "--model", "claude-sonnet-4-20250514"],
|
|
env={
|
|
"COPILOT_PROVIDER_WIRE_API": "responses",
|
|
"ANTHROPIC_API_KEY": "sk-test-dummy",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "anthropic"
|
|
assert "COPILOT_PROVIDER_WIRE_API" not in env
|
|
|
|
|
|
def test_wrap_copilot_fails_when_binary_missing(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
) -> None:
|
|
_wrap_cli, main = wrap_modules
|
|
with patch("headroom.cli.wrap.shutil.which", return_value=None):
|
|
result = runner.invoke(main, ["wrap", "copilot", "--", "--model", "gpt-4o"])
|
|
|
|
assert result.exit_code == 1
|
|
assert "'copilot' not found in PATH" in result.output
|
|
assert "Install GitHub Copilot CLI" in result.output
|
|
|
|
|
|
def test_unwrap_copilot_stops_proxy(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
tmp_path: Path,
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""`unwrap copilot` stops the local proxy on the requested port.
|
|
|
|
Copilot is env-var wrapped, so there is no config to restore — stopping the
|
|
proxy (and reporting it) is the whole contract.
|
|
"""
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.chdir(tmp_path)
|
|
|
|
with patch(
|
|
"headroom.cli.wrap._stop_local_proxy_for_unwrap",
|
|
return_value="stopped",
|
|
) as stop_proxy:
|
|
result = runner.invoke(main, ["unwrap", "copilot", "--port", "9999"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
stop_proxy.assert_called_once_with(9999)
|
|
assert "Stopped local Headroom proxy on port 9999" in result.output
|
|
|
|
|
|
def test_unwrap_copilot_leaves_user_instruction_file_untouched(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
tmp_path: Path,
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""A user-authored copilot-instructions.md is never rewritten or deleted."""
|
|
_wrap_cli, main = wrap_modules
|
|
monkeypatch.chdir(tmp_path)
|
|
instructions = tmp_path / ".github" / "copilot-instructions.md"
|
|
instructions.parent.mkdir()
|
|
instructions.write_text("Keep user guidance.\n", encoding="utf-8")
|
|
|
|
result = runner.invoke(main, ["unwrap", "copilot", "--no-stop-proxy"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert instructions.read_text(encoding="utf-8") == "Keep user guidance.\n"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Regression suite for #610 — GitHub Copilot endpoint routing per auth mode.
|
|
#
|
|
# 0.23.0 (commit f4dff9b) re-pointed the *shared* OAuth branch away from the
|
|
# generic https://api.githubcopilot.com to the account-specific endpoints.api
|
|
# host returned by /copilot_internal/user, and made resolve_copilot_api_url()
|
|
# ignore the GITHUB_COPILOT_API_URL override whenever a token resolves. For
|
|
# individual-plan users that broke newer models (gpt-5.4) on the responses API
|
|
# that had worked on 0.22.4. The pre-existing oauth test passed only because it
|
|
# left _fetch_copilot_user_info unmocked — the network call fails in CI, so
|
|
# resolve_copilot_api_url() fell back to the generic host and the real-world
|
|
# success path was never exercised. These tests mock a *successful* user-info
|
|
# response (the real world) so the routing for every auth mode is locked.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_ACCOUNT_USER_INFO = {"endpoints": {"api": "https://api.individual.githubcopilot.com"}}
|
|
|
|
|
|
def _clear_copilot_env(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
for var in (
|
|
"COPILOT_PROVIDER_API_KEY",
|
|
"COPILOT_PROVIDER_BEARER_TOKEN",
|
|
"OPENAI_API_KEY",
|
|
"ANTHROPIC_API_KEY",
|
|
"GITHUB_COPILOT_API_TOKEN",
|
|
"GITHUB_COPILOT_API_URL",
|
|
"GITHUB_COPILOT_API_TOKEN_EXPIRES_AT",
|
|
"GITHUB_COPILOT_ENTERPRISE_URL",
|
|
"GITHUB_COPILOT_ENTERPRISE_DOMAIN",
|
|
"GITHUB_COPILOT_REFRESH_OAUTH_TOKEN",
|
|
"GITHUB_COPILOT_TOKEN",
|
|
"GITHUB_COPILOT_GITHUB_TOKEN",
|
|
"COPILOT_MODEL",
|
|
"COPILOT_PROVIDER_MODEL_ID",
|
|
"COPILOT_PROVIDER_WIRE_API",
|
|
):
|
|
monkeypatch.delenv(var, raising=False)
|
|
|
|
|
|
def test_wrap_copilot_oauth_keeps_generic_endpoint_when_account_advertised(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""#610: non-subscription OAuth must route to the generic Copilot endpoint
|
|
even when /copilot_internal/user advertises an account-specific host. The
|
|
account host (api.individual.githubcopilot.com) does not serve newer models
|
|
such as gpt-5.4 on the responses API — exactly what regressed after 0.22.4.
|
|
"""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-oauth"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.copilot_auth._fetch_copilot_user_info", return_value=_ACCOUNT_USER_INFO),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(main, ["wrap", "copilot", "--", "--model", "gpt-5.4"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert "COPILOT_PROVIDER_BEARER_TOKEN" not in env
|
|
assert env["COPILOT_API_URL"].startswith("http://127.0.0.1:8787")
|
|
assert captured["openai_api_url"] == DEFAULT_API_URL
|
|
assert env["OPENAI_TARGET_API_URL"] == DEFAULT_API_URL
|
|
assert env["GITHUB_COPILOT_API_URL"] == DEFAULT_API_URL
|
|
|
|
|
|
def test_wrap_copilot_implicit_oauth_stays_generic_and_does_no_account_lookup(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""The implicit OAuth lane performs no user-info or token-exchange lookup at
|
|
launch, so it cannot see a plan host and always routes to the generic host.
|
|
Pinned so the guide's split between the lanes stays true: an Enterprise seat
|
|
that needs its plan host must use --subscription or wrap vscode."""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
enterprise = {"endpoints": {"api": "https://api.enterprise.githubcopilot.com"}}
|
|
user_info = MagicMock(return_value=enterprise)
|
|
exchange = MagicMock(return_value={"token": "copilot-api", **enterprise})
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-oauth"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.copilot_auth._fetch_copilot_user_info", user_info),
|
|
patch(
|
|
"headroom.copilot_auth.CopilotTokenProvider._exchange_token_sync",
|
|
staticmethod(exchange),
|
|
),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(main, ["wrap", "copilot", "--", "--model", "gpt-5.4"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["openai_api_url"] == DEFAULT_API_URL
|
|
# The lane never asks GitHub which host the seat is on: neither the
|
|
# user-info lookup nor the token exchange that would advertise the
|
|
# Enterprise host is consulted.
|
|
assert user_info.call_count == 0
|
|
assert exchange.call_count == 0
|
|
|
|
|
|
def test_wrap_copilot_oauth_honors_api_url_override(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""The GITHUB_COPILOT_API_URL escape hatch must be honored even when a token
|
|
resolves and user-info advertises a different host (it was silently lost)."""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
monkeypatch.setenv("GITHUB_COPILOT_API_URL", "https://proxy.internal.example.com")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-oauth"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.copilot_auth._fetch_copilot_user_info", return_value=_ACCOUNT_USER_INFO),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(main, ["wrap", "copilot", "--", "--model", "gpt-5.4"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert captured["openai_api_url"] == "https://proxy.internal.example.com"
|
|
assert env["OPENAI_TARGET_API_URL"] == "https://proxy.internal.example.com"
|
|
|
|
|
|
def test_wrap_copilot_byok_never_resolves_copilot_endpoint(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""BYOK (provider key, no OAuth) routes to the model provider through the
|
|
proxy and must never resolve the Copilot hosted endpoint. It was unaffected
|
|
by #610 — this pins that independence so a future change can't entangle it.
|
|
"""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
monkeypatch.setenv("COPILOT_PROVIDER_API_KEY", "sk-test-dummy")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
def tripwire(*_args, **_kwargs): # noqa: ANN002,ANN003
|
|
raise AssertionError("BYOK must not resolve the Copilot hosted endpoint")
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=False),
|
|
patch("headroom.cli.wrap.resolve_copilot_api_url", side_effect=tripwire),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--provider-type", "openai", "--", "--model", "gpt-4o"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert captured["openai_api_url"] is None
|
|
assert env["COPILOT_PROVIDER_TYPE"] == "openai"
|
|
|
|
|
|
def test_wrap_copilot_subscription_uses_resolved_subscription_endpoint(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Subscription mode uses the endpoint returned with the resolved token."""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
business_api = "https://api.business.githubcopilot.com"
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution("copilot-api", api_url=business_api),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.copilot_auth._fetch_copilot_user_info", return_value=_ACCOUNT_USER_INFO),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--", "--model", "gpt-5.4"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
assert captured["openai_api_url"] == business_api
|
|
assert env["OPENAI_TARGET_API_URL"] == business_api
|
|
assert env["COPILOT_PROVIDER_BEARER_TOKEN"] == "copilot-api"
|
|
|
|
|
|
def test_wrap_copilot_subscription_honours_advertised_enterprise_host(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""An Enterprise seat routes to the host its token exchange advertised; a
|
|
firewall on GitHub's subscription-based routing allows only that host."""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch(
|
|
"headroom.copilot_auth.iter_oauth_token_candidates",
|
|
return_value=[
|
|
types.SimpleNamespace(
|
|
token="gho-oauth",
|
|
source="headroom-copilot-auth:/tmp/copilot_auth.json",
|
|
confidence="copilot-oauth",
|
|
validate_for_subscription=True,
|
|
)
|
|
],
|
|
),
|
|
patch(
|
|
"headroom.copilot_auth.CopilotTokenProvider._exchange_token_sync",
|
|
staticmethod(
|
|
lambda _headers: {
|
|
"token": "copilot-api",
|
|
"expires_at": 9999999999,
|
|
"endpoints": {"api": "https://api.enterprise.githubcopilot.com"},
|
|
}
|
|
),
|
|
),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--", "--model", "gpt-5.4"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
env = captured["env"]
|
|
assert isinstance(env, dict)
|
|
enterprise_api = "https://api.enterprise.githubcopilot.com"
|
|
assert captured["openai_api_url"] == enterprise_api
|
|
assert env["OPENAI_TARGET_API_URL"] == enterprise_api
|
|
assert env["GITHUB_COPILOT_API_URL"] == enterprise_api
|
|
|
|
|
|
def test_wrap_copilot_subscription_honors_api_url_override(
|
|
runner: CliRunner,
|
|
wrap_modules: tuple[types.ModuleType, click.Group],
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Enterprise / data-residency accounts that require a dedicated host pin it
|
|
via GITHUB_COPILOT_API_URL — the override must flow through --subscription."""
|
|
_wrap_cli, main = wrap_modules
|
|
_clear_copilot_env(monkeypatch)
|
|
monkeypatch.setenv("GITHUB_COPILOT_API_URL", "https://api.enterprise.example.com")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_launch_tool(**kwargs): # noqa: ANN003
|
|
captured.update(kwargs)
|
|
|
|
with (
|
|
patch("headroom.cli.wrap.shutil.which", return_value="copilot"),
|
|
patch(
|
|
"headroom.cli.wrap.resolve_subscription_bearer_token_details",
|
|
return_value=_subscription_resolution(
|
|
"gho-sub",
|
|
api_url="https://api.enterprise.example.com",
|
|
source="env:GITHUB_COPILOT_API_TOKEN",
|
|
confidence="explicit-api-token",
|
|
),
|
|
),
|
|
patch("headroom.cli.wrap.has_oauth_auth", return_value=True),
|
|
patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool),
|
|
):
|
|
result = runner.invoke(
|
|
main,
|
|
["wrap", "copilot", "--subscription", "--", "--model", "gpt-5.4"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert captured["openai_api_url"] == "https://api.enterprise.example.com"
|
|
|
|
|
|
def test_resolve_copilot_api_url_ignores_user_info_and_never_calls_network(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""Unit lock for #610: routing is override -> generic and must NOT depend on a
|
|
user-info lookup. Even with a token in hand and user-info advertising an
|
|
account host, the generic host is returned and no network call is made."""
|
|
from headroom import copilot_auth
|
|
|
|
monkeypatch.delenv("GITHUB_COPILOT_API_URL", raising=False)
|
|
with patch.object(copilot_auth, "_fetch_copilot_user_info") as fetch:
|
|
assert copilot_auth.resolve_copilot_api_url("gho-real") == copilot_auth.DEFAULT_API_URL
|
|
fetch.assert_not_called()
|
|
|
|
monkeypatch.setenv("GITHUB_COPILOT_API_URL", "https://pin.example.com")
|
|
with patch.object(copilot_auth, "_fetch_copilot_user_info") as fetch:
|
|
assert copilot_auth.resolve_copilot_api_url("gho-real") == "https://pin.example.com"
|
|
fetch.assert_not_called()
|