Configuration de l’interface CLI locale

À utiliser lorsque : Vous devez fixer une version spécifique de la CLI ou travailler avec le SDK Go (qui n’intègre pas de CLI).

Fonctionnement

Par défaut, les sdk Node.js, Python et .NET incluent leur propre dépendance CLI (voir Configuration par défaut (interface CLI groupée)). Si vous devez remplacer cela, par exemple, pour utiliser une interface CLI installée par le système, vous pouvez utiliser l’option Connection .

Diagramme : Organigramme montrant le processus décrit.

Principales caractéristiques :

Vous fournissez explicitement le chemin binaire CLI
Vous êtes responsable de la compatibilité de la version CLI avec le Kit de développement logiciel (SDK)
L’authentification utilise les identifiants de l’utilisateur connecté stockés dans le trousseau système (ou les variables d’environnement)
La communication s’effectue via stdio

Paramétrage

Utilisation d’un binaire CLI local

TypeScript

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

const client = new CopilotClient({
    cliPath: "/usr/local/bin/copilot",
});

const session = await client.createSession({ model: "gpt-4.1" });
const response = await session.sendAndWait({ prompt: "Hello!" });
console.log(response?.data.content);

await client.stop();

Python

from copilot import CopilotClient
from copilot.generated.session_events import AssistantMessageData
from copilot.session import PermissionHandler

client = CopilotClient({
    "cli_path": "/usr/local/bin/copilot",
})
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-4.1")
response = await session.send_and_wait("Hello!")
if response:
    match response.data:
        case AssistantMessageData() as data:
            print(data.content)

await client.stop()

Remarque

Le Kit de développement logiciel (SDK) Go ne regroupe pas d’interface CLI. Vous devez donc toujours fournir Connection.

package main

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

func main() {
    ctx := context.Background()

    client := copilot.NewClient(&copilot.ClientOptions{
        Connection: copilot.StdioConnection{Path: "/usr/local/bin/copilot"},
    })
    if err := client.Start(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1"})
    response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
    if response != nil {
        if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
            fmt.Println(d.Content)
        }
    }
}

client := copilot.NewClient(&copilot.ClientOptions{
    Connection: copilot.StdioConnection{Path: "/usr/local/bin/copilot"},
})
if err := client.Start(ctx); err != nil {
    log.Fatal(err)
}
defer client.Stop()

session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1"})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
if response != nil {
    if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
        fmt.Println(d.Content)
    }
}

.NET

var client = new CopilotClient(new CopilotClientOptions
{
    Connection = RuntimeConnection.ForStdio(path: "/usr/local/bin/copilot"),
});

await using var session = await client.CreateSessionAsync(
    new SessionConfig { Model = "gpt-4.1" });

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });
Console.WriteLine(response?.Data.Content);

Options supplémentaires

const client = new CopilotClient({
    cliPath: "/usr/local/bin/copilot",

    // Set log level for debugging
    logLevel: "debug",

    // Pass extra CLI arguments
    cliArgs: ["--log-dir=/tmp/copilot-logs"],

    // Set working directory
    cwd: "/path/to/project",
});

Utilisation de variables d’environnement

Au lieu du trousseau d'accès, vous pouvez vous authentifier via des variables d’environnement. Ceci est utile pour la CI ou lorsque vous ne souhaitez pas d’authentification interactive.

# Set one of these (in priority order):
export COPILOT_GITHUB_TOKEN="gho_xxxx"   # Recommended
export GH_TOKEN="gho_xxxx"               # GitHub CLI compatible
export GITHUB_TOKEN="gho_xxxx"           # GitHub Actions compatible

Le Kit de développement logiciel (SDK) les récupère automatiquement, sans modification du code nécessaire.

Gestion des sessions

Les sessions par défaut sont éphémères. Pour créer des sessions pouvant être reprise, fournissez votre propre ID de session :

// Create a named session
const session = await client.createSession({
    sessionId: "my-project-analysis",
    model: "gpt-4.1",
});

// Later, resume it
const resumed = await client.resumeSession("my-project-analysis");

L’état de session est stocké localement à l’adresse ~/.copilot/session-state/{sessionId}/.

Limitations

Limitation	Détails
Compatibilité des versions	Vous devez vous assurer que votre version cli est compatible avec le Kit de développement logiciel (SDK)
Utilisateur unique	Les informations d’identification sont liées à la personne qui s’est connectée à l’interface CLI
Local uniquement	L’interface CLI s’exécute sur la même machine que votre application
Pas de multi-locataire	Impossible de servir plusieurs utilisateurs à partir d’une instance CLI

Étapes suivantes

Configuration par défaut (interface CLI groupée) : Utiliser l’interface CLI intégrée du SDK (recommandée pour la plupart des cas d’usage)
Créez votre première application avec Copilot : Créer une application interactive complète
Authentification : toutes les méthodes d’authentification en détail

Configuration de l’interface CLI locale

Dans cet article