Utilisation d’une interface CLI locale avec le Kit de développement logiciel (SDK) Copilot

          Kit de développement logiciel (SDK) Copilot est actuellement en préversion technique. Les fonctionnalités et la disponibilité sont susceptibles de changer.

La connexion SDK GitHub Copilot à votre interface CLI localement connectée est le moyen le plus rapide de commencer.

          **Meilleur pour :** Projets personnels, prototypage, développement local et apprentissage du Kit de développement logiciel (SDK).

Fonctionnement

Lorsque vous installez Copilot CLI et connectez-vous, vos informations d’identification sont stockées dans le trousseau système. Le Kit de développement logiciel (SDK) démarre automatiquement l’interface CLI en tant que processus enfant et utilise ces informations d’identification stockées. Principales caractéristiques :

• L’interface CLI est générée automatiquement par le Kit de développement logiciel (SDK) : aucune configuration n’est nécessaire.
• L’authentification utilise les informations d’identification de l’utilisateur connecté à partir du trousseau système.
• La communication se produit sur stdio (stdin/stdout) : aucun port réseau n’est ouvert.
• Les sessions sont locales sur votre ordinateur.

Démarrage rapide

La configuration par défaut ne nécessite aucune option du tout.

Node.js / TypeScript

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

const client = new CopilotClient();
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, PermissionHandler

client = CopilotClient()
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-4.1")
response = await session.send_and_wait({"prompt": "Hello!"})
print(response.data.content)

await client.stop()

Allez

client := copilot.NewClient(nil)
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!"})
fmt.Println(*response.Data.Content)

.NET

await using var client = new CopilotClient();
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);

Le Kit de développement logiciel (SDK) gère tout : démarrage de l’interface CLI, authentification et gestion de la session.

Comment cela fonctionne-t-il en interne ?

Pour plus d’informations sur l’ordre d’interaction entre les composants, consultez le diagramme de séquence dans le github/copilot-sdkréférentiel.

Options de configuration

Bien que les valeurs par défaut fonctionnent pour la plupart des cas, vous pouvez personnaliser la configuration locale :

const client = new CopilotClient({
    // Override CLI location (default: bundled with @github/copilot)
    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. Cela est utile pour l’intégration continue ou lorsque vous ne souhaitez pas de connexion interactive.

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

Remplacez YOUR-GITHUB-TOKEN par un jeton GitHubpersonal access token ou OAuth valide. Le Kit de développement logiciel (SDK) les récupère automatiquement : aucune modification du code n’est nécessaire.

Gestion des sessions

Avec l’interface CLI locale, les sessions sont éphémères par défaut. Pour créer des sessions pouvant être reprise, fournissez un ID de session :

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

// Resume it in a later run
const resumed = await client.resumeSession("my-project-analysis");

L’état de session est stocké localement, ~/.copilot/session-state/SESSION-ID/où SESSION-ID est l’ID de session que vous avez fourni.

Limites

Limitation	Détails

          **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. | | Nécessite la connexion CLI | L’utilisateur doit d’abord exécuter copilot et s’authentifier. |

Étapes suivantes

• Pour expédier votre application à d’autres utilisateurs, consultez Utilisation d’une interface CLI groupée avec le Kit de développement logiciel (SDK) Copilot.
• Pour permettre à plusieurs utilisateurs de se connecter avec leurs propres GitHub comptes, consultez Utilisation de GitHub OAuth avec le Kit de développement logiciel (SDK) Copilot.
• Pour exécuter le Kit de développement logiciel (SDK) sur un serveur, consultez Configuration du Kit de développement logiciel (SDK) Copilot pour les services principaux.
• Pour votre premier message et installation, consultez Getting started avec le Kit de développement logiciel (SDK) Copilot.