Merge branch 'main' into feat/provider-improvements

Author: mowree

README.md

@@ -7,50 +7,62 @@ GitHub Copilot SDK integration for Amplifier via Copilot CLI.
 ## Prerequisites
 
 - **Python 3.11+**
-- **Node.js 18+** — Required to install the Copilot CLI
 - **GitHub Copilot subscription** — Active Business or Enterprise subscription
 - **[UV](https://github.com/astral-sh/uv)** (optional) — Fast Python package manager (pip works too)
 
-### Installing Copilot CLI
+> **No Node.js required.** The Copilot SDK binary is bundled with the Python package
+> and discovered automatically.
 
-The Copilot CLI is a Node.js binary that the Python SDK controls via JSON-RPC.
-Both the CLI and the SDK are required.
+## Authentication
 
-```bash
-# Install Copilot CLI (requires Node.js/npm)
-npm install -g @github/copilot
+Set a GitHub token as an environment variable. The provider checks these in order:
+`COPILOT_GITHUB_TOKEN`, `GH_TOKEN`, `GITHUB_TOKEN`.
+
+### Option 1: Environment variable (recommended)
 
-# Verify installation
-copilot --version
+```bash
+export GITHUB_TOKEN="ghp_your_token_here"
 ```
 
-### Authentication
+> **Tip:** Many developers already have `GITHUB_TOKEN` set from `gh` CLI usage —
+> if so, you're already authenticated. No extra setup needed.
+
+### Option 2: `amplifier init` setup wizard
+
+```bash
+amplifier init
+# Select "GitHub Copilot" from the provider list
+# Launches browser OAuth flow if no token is set
+```
 
-You must be authenticated to GitHub Copilot:
+### Option 3: `gh` CLI bridge
 
 ```bash
-copilot auth login
+export GITHUB_TOKEN=$(gh auth token)
 ```
 
+One command to bridge your existing `gh` CLI authentication into Amplifier.
+
 ## Installation
 
-Register the module, install its dependencies, and set it as your active provider:
+GitHub Copilot is a well-known provider — `amplifier init` handles everything:
 
 ```bash
-amplifier module add provider-github-copilot \
-  --source git+https://github.com/microsoft/amplifier-module-provider-github-copilot@main
+# Interactive setup — select Copilot from the provider list
+amplifier init
 
-amplifier provider install github-copilot
+# Non-interactive — auto-detects GITHUB_TOKEN
+amplifier init --yes
+```
+
+Or install manually:
 
+```bash
+amplifier provider install github-copilot
 amplifier provider use github-copilot
 ```
 
-> **Note:** The `provider install` step is required to install the module's Python
-> dependencies (including the GitHub Copilot SDK) into the Amplifier environment.
-> The built-in providers skip this step because they are pre-installed during
-> `amplifier init`.
-
-Or reference it directly in a bundle (no separate install needed):
+Or reference it directly in a bundle:
 
 ```yaml
 providers:

amplifier_module_provider_github_copilot/__init__.py

@@ -322,9 +322,12 @@ def _find_copilot_cli(config: dict[str, Any]) -> str | None:
     """
     Find the Copilot CLI executable path.
 
-    Uses the SDK's bundled CLI binary by default. Falls back to system PATH
-    if the bundled binary is not found. The SDK bundles its own CLI binary
-    which is version-matched, avoiding potential version mismatches.
+    Resolution order:
+    1. SDK bundled binary (import copilot -> copilot/bin/copilot)
+    2. System PATH fallback (shutil.which)
+
+    The SDK bundles its own CLI binary which is version-matched,
+    avoiding potential version mismatches with separately installed CLIs.
 
     Args:
         config: Provider configuration (unused, kept for API compatibility)
@@ -333,14 +336,32 @@ def _find_copilot_cli(config: dict[str, Any]) -> str | None:
         Resolved CLI path, or None if not found
     """
     try:
-        # Let SDK use its bundled CLI - only fall back to system PATH
+        try:
+            from pathlib import Path
+
+            import copilot as _copilot_mod  # type: ignore[import-untyped]
+
+            _mod_file = _copilot_mod.__file__
+            if _mod_file is None:
+                raise ImportError("copilot module has no __file__")
+            _cli_bin = Path(_mod_file).parent / "bin" / "copilot"
+            if _cli_bin.exists():
+                cli_path = str(_cli_bin)
+                _ensure_executable(cli_path)
+                logger.debug(f"[MOUNT] Found SDK bundled CLI at: {cli_path}")
+                return cli_path
+            else:
+                logger.debug("[MOUNT] SDK bundled CLI binary not found on disk")
+        except ImportError:
+            logger.debug("[MOUNT] copilot SDK not installed, trying PATH")
+
         found = shutil.which("copilot") or shutil.which("copilot.exe")
         if found:
             _ensure_executable(found)
-            logger.debug(f"[MOUNT] Found Copilot CLI at: {found}")
+            logger.debug(f"[MOUNT] Found Copilot CLI in PATH at: {found}")
             return found
 
-        logger.debug("[MOUNT] Copilot CLI not found in PATH")
+        logger.debug("[MOUNT] Copilot CLI not found via SDK or PATH")
         return None
 
     except Exception as e:

amplifier_module_provider_github_copilot/client.py

@@ -315,6 +315,13 @@ def _build_client_options(self) -> dict[str, Any]:
 
         The SDK bundles its own CLI binary which is version-matched to the SDK.
         We always use the bundled CLI to avoid version mismatches and auth issues.
+
+        Token precedence (highest to lowest):
+        1. config["github_token"] (explicit config)
+        2. COPILOT_GITHUB_TOKEN env var (SDK-preferred)
+        3. GH_TOKEN env var (gh CLI compat)
+        4. GITHUB_TOKEN env var (most common)
+        5. No token — SDK uses stored OAuth creds (use_logged_in_user=True)
         """
         options: dict[str, Any] = {}
 
@@ -327,6 +334,18 @@ def _build_client_options(self) -> dict[str, Any]:
         if self._config.get("cwd"):
             options["cwd"] = self._config["cwd"]
 
+        # Token resolution: config > COPILOT_GITHUB_TOKEN > GH_TOKEN > GITHUB_TOKEN
+        token = self._config.get("github_token") or None
+        if not token:
+            for env_var in ("COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"):
+                token = os.environ.get(env_var)
+                if token:
+                    logger.debug(f"[CLIENT] Using token from {env_var}")
+                    break
+
+        if token:
+            options["github_token"] = token
+
         return options
 
     async def _verify_authentication(self) -> None:
@@ -343,7 +362,9 @@ async def _verify_authentication(self) -> None:
             auth_status = await self._client.get_auth_status()
             if not auth_status.isAuthenticated:
                 raise CopilotAuthenticationError(
-                    "Not authenticated to GitHub Copilot. Run 'copilot auth login' to authenticate."
+                    "Not authenticated to GitHub Copilot. "
+                    "Set GITHUB_TOKEN, run 'gh auth login', "
+                    "or run 'amplifier init' to authenticate."
                 )
             logger.debug(f"[CLIENT] Authenticated as: {auth_status.login}")
         except CopilotAuthenticationError: