Einrichtung von GitHub OAuth

Best for: Multi-User Apps, interne Tools mit Organisationszugriffskontrolle, SaaS-Produkte, Apps, bei denen Benutzer über GitHub Konten verfügen.

So funktioniert es

Sie erstellen eine GitHub OAuth-App (oder GitHub App), benutzer autorisieren sie, und Sie übergeben ihr Zugriffstoken an das SDK. Copilot Anfragen werden im Namen jedes authentifizierten Benutzers unter Verwendung seines Copilot-Abonnements vorgenommen.

Wichtige Merkmale:

• Jeder Benutzer authentifiziert sich mit einem eigenen GitHub Konto
• Die Copilot-Nutzung wird dem Abonnement jedes Benutzers in Rechnung gestellt.
• Unterstützt GitHub Organisationen und Unternehmenskonten
• Ihre App verarbeitet niemals Modell-API-Schlüssel – GitHub verwaltet alles

Aufbau

Schritt 1: Erstellen einer GitHub OAuth-App

1. Wechseln Sie zu GitHub Einstellungen → Entwicklereinstellungen → OAuth-Apps → neue OAuth-App (oder für Organisationen: Organisierungseinstellungen → Entwicklereinstellungen)

2. Ausfüllen:

   • Anwendungsname: Name Ihrer App
   • Homepage-URL: Url Ihrer App
   • Autorisierungsrückruf-URL: Ihr OAuth-Rückrufendpunkt (z. B. https://yourapp.com/auth/callback)

3. Notieren Sie Sich Ihre Client-ID, und generieren Sie einen geheimen Clientschlüssel.

GitHub App vs OAuth App: Beide funktionieren. GitHub Apps bieten detailliertere Berechtigungen und werden für neue Projekte empfohlen. OAuth-Apps sind einfacher einzurichten. Der Tokenfluss ist aus Sicht des SDK identisch.

Schritt 2: Implementieren des OAuth-Flusses

Ihre Anwendung behandelt den Standard-GitHub OAuth-Fluss. Hier sehen Sie den serverseitigen Tokenaustausch:

// Server-side: Exchange authorization code for user token
async function handleOAuthCallback(code: string): Promise<string> {
    const response = await fetch("https://github.com/login/oauth/access_token", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
        },
        body: JSON.stringify({
            client_id: process.env.GITHUB_CLIENT_ID,
            client_secret: process.env.GITHUB_CLIENT_SECRET,
            code,
        }),
    });

    const data = await response.json();
    return data.access_token; // gho_xxxx or ghu_xxxx
}

Schritt 3: Übergeben des Tokens an das SDK

Erstellen Sie einen SDK-Client für jeden authentifizierten Benutzer, und übergeben Sie ihr Token:

import { CopilotClient } from "@github/copilot-sdk";

// Create a client for an authenticated user
function createClientForUser(userToken: string): CopilotClient {
    return new CopilotClient({
        gitHubToken: userToken,
        useLoggedInUser: false,  // Don't fall back to CLI login
    });
}

// Usage
const client = createClientForUser("gho_user_access_token");
const session = await client.createSession({
    sessionId: `user-${userId}-session`,
    model: "gpt-4.1",
});

const response = await session.sendAndWait({ prompt: "Hello!" });

from copilot import CopilotClient
from copilot.session import PermissionHandler

def create_client_for_user(user_token: str) -> CopilotClient:
    return CopilotClient({
        "github_token": user_token,
        "use_logged_in_user": False,
    })

# Usage
client = create_client_for_user("gho_user_access_token")
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-4.1", session_id=f"user-{user_id}-session")

response = await session.send_and_wait("Hello!")

package main

import (
    "context"
    "fmt"
    copilot "github.com/github/copilot-sdk/go"
)

func createClientForUser(userToken string) *copilot.Client {
    return copilot.NewClient(&copilot.ClientOptions{
        GitHubToken:     userToken,
        UseLoggedInUser: copilot.Bool(false),
    })
}

func main() {
    ctx := context.Background()
    userID := "user1"

    client := createClientForUser("gho_user_access_token")
    client.Start(ctx)
    defer client.Stop()

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
        SessionID: fmt.Sprintf("user-%s-session", userID),
        Model:     "gpt-4.1",
    })
    response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
    _ = response
}

func createClientForUser(userToken string) *copilot.Client {
    return copilot.NewClient(&copilot.ClientOptions{
        GithubToken:     userToken,
        UseLoggedInUser: copilot.Bool(false),
    })
}

// Usage
client := createClientForUser("gho_user_access_token")
client.Start(ctx)
defer client.Stop()

session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
    SessionID: fmt.Sprintf("user-%s-session", userID),
    Model:     "gpt-4.1",
})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})

using GitHub.Copilot;

CopilotClient CreateClientForUser(string userToken) =>
    new CopilotClient(new CopilotClientOptions
    {
        GitHubToken = userToken,
        UseLoggedInUser = false,
    });

var userId = "user1";

await using var client = CreateClientForUser("gho_user_access_token");
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    SessionId = $"user-{userId}-session",
    Model = "gpt-4.1",
});

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });

CopilotClient CreateClientForUser(string userToken) =>
    new CopilotClient(new CopilotClientOptions
    {
        GitHubToken = userToken,
        UseLoggedInUser = false,
    });

// Usage
await using var client = CreateClientForUser("gho_user_access_token");
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    SessionId = $"user-{userId}-session",
    Model = "gpt-4.1",
});

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });

import com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.events.*;
import com.github.copilot.sdk.json.*;

CopilotClient createClientForUser(String userToken) throws Exception {
    var client = new CopilotClient(new CopilotClientOptions()
        .setGitHubToken(userToken)
        .setUseLoggedInUser(false)
    );
    client.start().get();
    return client;
}

// Usage — use try-with-resources to ensure cleanup
var userId = "user1";
try (var client = createClientForUser("gho_user_access_token")) {
    var session = client.createSession(new SessionConfig()
        .setSessionId(String.format("user-%s-session", userId))
        .setModel("gpt-4.1")
        .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    ).get();

    var response = session.sendAndWait(new MessageOptions()
        .setPrompt("Hello!")).get();
}

Unternehmens- und Organisationszugriff

GitHub OAuth unterstützt natürlich Unternehmensszenarien. Wenn sich Benutzer mit GitHub authentifizieren, kommen ihre Organisationsmitgliedschaften und Unternehmenszuordnungen zusammen.

Überprüfen der Organisationsmitgliedschaft

Überprüfen Sie nach OAuth, ob der Benutzer zu Ihrer Organisation gehört:

async function verifyOrgMembership(
    token: string,
    requiredOrg: string
): Promise<boolean> {
    const response = await fetch("https://api.github.com/user/orgs", {
        headers: { Authorization: `Bearer ${token}` },
    });
    const orgs = await response.json();
    return orgs.some((org: any) => org.login === requiredOrg);
}

// In your auth flow
const token = await handleOAuthCallback(code);
if (!await verifyOrgMembership(token, "my-company")) {
    throw new Error("User is not a member of the required organization");
}
const client = createClientForUser(token);

Von Unternehmen verwaltete Benutzer (EMU)

Für GitHub vom Unternehmen verwaltete Benutzer ist der Ablauf identisch – EMU-Benutzer authentifizieren sich über GitHub OAuth wie jeder andere Benutzer. Ihre Unternehmensrichtlinien (IP-Einschränkungen, SAML-SSO) werden von GitHub automatisch erzwungen.

// No special SDK configuration needed for EMU
// Enterprise policies are enforced server-side by GitHub
const client = new CopilotClient({
    gitHubToken: emuUserToken,  // Works the same as regular tokens
    useLoggedInUser: false,
});

Unterstützte Tokentypen

Tokenlebenszyklus

Wichtig: Ihre Anwendung ist für die Tokenspeicherung, Aktualisierung und Ablaufbehandlung verantwortlich. Das SDK verwendet das von Ihnen bereitgestellte Token – er verwaltet nicht den OAuth-Lebenszyklus.

Tokenaktualisierungsmuster

async function getOrRefreshToken(userId: string): Promise<string> {
    const stored = await tokenStore.get(userId);

    if (stored && !isExpired(stored)) {
        return stored.accessToken;
    }

    if (stored?.refreshToken) {
        const refreshed = await refreshGitHubToken(stored.refreshToken);
        await tokenStore.set(userId, refreshed);
        return refreshed.accessToken;
    }

    throw new Error("User must re-authenticate");
}

Mehrbenutzermuster

Ein Client pro Benutzer (empfohlen)

Jeder Benutzer erhält einen eigenen SDK-Client mit einem eigenen Token. Dies bietet die stärkste Isolation.

const clients = new Map<string, CopilotClient>();

function getClientForUser(userId: string, token: string): CopilotClient {
    if (!clients.has(userId)) {
        clients.set(userId, new CopilotClient({
            gitHubToken: token,
            useLoggedInUser: false,
        }));
    }
    return clients.get(userId)!;
}

Freigegebene CLI mit Token pro Anforderung

Für einen leichteren Ressourcenbedarf können Sie einen einzelnen externen CLI-Server ausführen und Token pro Sitzung übergeben. Siehe Einrichtung von Back-End-Diensten für dieses Muster.

Einschränkungen

Wann muss ich fortfahren?

Nächste Schritte

• Authentication: Vollständige Authentifizierungsmethodereferenz
• Einrichtung von Back-End-Diensten: Ausführen des serverseitigen SDK
• Skalierung und Mehrinstanzenfähigkeit: Viele Benutzer in großem Maßstab verwalten