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

Empaqueter Copilot pour CLI en même temps que votre application afin que les utilisateurs n’ont pas besoin d’installer ou de configurer quoi que ce soit séparément.

Qui peut utiliser cette fonctionnalité ?

Kit de développement logiciel (SDK) GitHub Copilot est disponible dans tous les forfaits Copilot.

Dans cet article

Remarque

SDK Copilot est actuellement en préversion technique. Les fonctionnalités et la disponibilité sont susceptibles de changer.

Expédier Copilot pour CLI dans le cadre de votre application afin que vos utilisateurs puissent démarrer sans configuration supplémentaire.

          **Meilleur pour :** Applications de bureau, outils autonomes, applications Electron et utilitaires CLI distribuables.

Fonctionnement

Au lieu de vous appuyer sur une interface CLI installée globalement, vous incluez le fichier binaire CLI dans votre ensemble d’applications. Le Kit de développement logiciel (SDK) pointe vers votre copie groupée via l’option cliPath . Les principales caractéristiques sont les suivantes :

  • Le fichier binaire CLI est fourni avec votre application. Aucune installation distincte n’est nécessaire.
  • Vous contrôlez la version exacte de l’interface CLI utilisée par votre application.
  • Les utilisateurs s’authentifient via votre application, les variables d’environnement ou BYOK.
  • Les sessions sont gérées par utilisateur sur leur ordinateur.

Paramétrage

Étape 1 : Inclure l’interface CLI dans votre projet

L’interface CLI est distribuée dans le cadre du @github/copilot package npm.

npm install @github/copilot

Étape 2 : Pointer le KIT DE développement logiciel (SDK) vers votre interface CLI groupée

Node.js / TypeScript

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

const client = new CopilotClient({
    // Point to the CLI binary in your app bundle
    cliPath: path.join(__dirname, "vendor", "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, PermissionHandler
from pathlib import Path

client = CopilotClient({
    "cli_path": str(Path(__file__).parent / "vendor" / "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({"prompt": "Hello!"})
print(response.data.content)

await client.stop()

Allez

client := copilot.NewClient(&copilot.ClientOptions{
    CLIPath: "./vendor/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!"})
fmt.Println(*response.Data.Content)

.NET

var client = new CopilotClient(new CopilotClientOptions
{
    CliPath = Path.Combine(AppContext.BaseDirectory, "vendor", "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);

Stratégies d’authentification

Lorsque vous regroupez l’interface CLI, vous devez décider de la façon dont vos utilisateurs s’authentifient. Le diagramme suivant illustre les modèles courants.

Diagramme montrant les options de stratégie d’authentification pour un déploiement cli groupé.

Option A : Informations d’identification de connexion de l’utilisateur (le plus simple)

L’utilisateur se connecte à l’interface CLI une seule fois, et votre application groupée utilise ces informations d’identification. Aucun code supplémentaire n’est nécessaire : il s’agit du comportement par défaut.

const client = new CopilotClient({
    cliPath: path.join(__dirname, "vendor", "copilot"),
    // Default: uses signed-in user credentials
});

Option B : Jeton via une variable d’environnement

Définissez un jeton par programmation ou demandez aux utilisateurs de définir un jeton avant de démarrer votre application :

const client = new CopilotClient({
    cliPath: path.join(__dirname, "vendor", "copilot"),
    env: {
        COPILOT_GITHUB_TOKEN: getUserToken(),
    },
});

Remplacez getUserToken() par la logique de votre application qui récupère le jeton OAuth de GitHub l’utilisateur.

Option C : BYOK (aucune GitHub authentification nécessaire)

Si vous gérez vos propres clés de fournisseur de modèles, les utilisateurs n’ont pas besoin de créer des comptes GitHub.

const client = new CopilotClient({
    cliPath: path.join(__dirname, "vendor", "copilot"),
});

const session = await client.createSession({
    model: "gpt-4.1",
    provider: {
        type: "openai",
        baseUrl: "https://api.openai.com/v1",
        apiKey: process.env.OPENAI_API_KEY,
    },
});

Gestion des sessions

Les applications groupées veulent généralement des sessions nommées afin que les utilisateurs puissent reprendre les conversations :

const client = new CopilotClient({
    cliPath: path.join(__dirname, "vendor", "copilot"),
});

// Create a session tied to the user's project
const sessionId = `project-${projectName}`;
const session = await client.createSession({
    sessionId,
    model: "gpt-4.1",
});

// Resume the session in a later run
const resumed = await client.resumeSession(sessionId);

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

Modèles de distribution

Application de bureau (Electron, Tauri)

Incluez le fichier binaire CLI dans le répertoire des ressources de votre application :

import { app } from "electron";
import path from "path";

const cliPath = path.join(
    app.isPackaged ? process.resourcesPath : __dirname,
    "copilot"
);

const client = new CopilotClient({ cliPath });

Outil CLI

Pour les outils CLI distribuables, résolvez le chemin d’accès relatif à votre fichier binaire :

import { fileURLToPath } from "url";
import path from "path";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const cliPath = path.join(__dirname, "..", "vendor", "copilot");

const client = new CopilotClient({ cliPath });

Fichiers binaires spécifiques à la plateforme

Lors de la distribution pour plusieurs plateformes, incluez le fichier binaire correct pour chaque cible :

my-app/
├── vendor/
│   ├── copilot-darwin-arm64    # macOS Apple Silicon
│   ├── copilot-darwin-x64      # macOS Intel
│   ├── copilot-linux-x64       # Linux x64
│   └── copilot-win-x64.exe     # Windows x64
└── src/
    └── index.ts

import os from "os";

function getCLIPath(): string {
    const platform = process.platform;   // "darwin", "linux", "win32"
    const arch = os.arch();              // "arm64", "x64"
    const ext = platform === "win32" ? ".exe" : "";
    const name = `copilot-${platform}-${arch}${ext}`;
    return path.join(__dirname, "vendor", name);
}

const client = new CopilotClient({
    cliPath: getCLIPath(),
});

Limites

LimitationDétails
Taille du bundleLe fichier binaire CLI s’ajoute à la taille de distribution de votre application.
Mises à jourVous gérez les mises à jour de version CLI dans votre cycle de publication.
Builds de plateformeDes fichiers binaires distincts sont nécessaires pour chaque système d’exploitation/architecture.
Utilisateur uniqueChaque instance CLI groupée sert un utilisateur.

Étapes suivantes