Copilot Extensions e Marketplace
GitHub Copilot e' progettato per essere estensibile. Attraverso le Copilot Extensions, e' possibile ampliare le capacità' dell'assistente AI con integrazioni di terze parti, strumenti personalizzati e agenti specializzati. Le extensions permettono di collegare Copilot a database, servizi cloud, piattaforme di testing, strumenti di monitoring e molto altro, trasformandolo in un hub centralizzato per l'intero workflow di sviluppo.
In questo articolo esploreremo l'ecosistema delle extensions, le tipologie disponibili, come integrarle nel proprio flusso di lavoro e come costruire estensioni personalizzate per le esigenze specifiche del proprio team.
Panoramica della Serie Completa
| # | Articolo | Focus |
|---|---|---|
| 1 | Foundation e Mindset | Setup e mentalita' |
| 2 | Ideazione e Requisiti | Da idea a MVP |
| 3 | Architettura Backend/Frontend | API e database |
| 4 | Struttura del Codice | Organizzazione e naming |
| 5 | Prompt Engineering | Prompt e Agenti MCP |
| 6 | Testing e qualità' | Unit, integration, E2E |
| 7 | Documentazione | README, API docs, ADR |
| 8 | Deploy e DevOps | Docker, CI/CD |
| 9 | Evoluzione | Scalabilità' e manutenzione |
| 10 | Coding Agent | Agente autonomo GitHub |
| 11 | Code Review | Review automatizzata |
| 12 | Copilot Edits | Editing multi-file |
| 13 | GitHub Spark | Micro-app senza codice |
| 14 | Copilot Spaces | Contesto condiviso |
| 15 | Modelli AI | Multi-model e selezione |
| 16 | Personalizzazione | Istruzioni e configurazione |
| 17 | Enterprise e Business | Piani, analytics, policy |
| 18 | Sei qui → Extensions e Marketplace | Estensioni e integrazioni |
| 19 | Sicurezza e Uso Responsabile | Security e compliance |
Panoramica delle Copilot Extensions
Le Copilot Extensions sono applicazioni che estendono le funzionalità' di GitHub Copilot. Sono disponibili sul GitHub Marketplace e possono essere installate sia a livello individuale che organizzativo. Le extensions si integrano direttamente con Copilot Chat, permettendo agli sviluppatori di interagire con strumenti esterni senza uscire dal proprio IDE o dal browser.
Architettura delle Extensions
Le Copilot Extensions sono costruite come GitHub Apps, il che garantisce compatibilità' cross-platform e un modello di autenticazione e autorizzazione robusto. Quando un utente invoca un'extension tramite Copilot Chat, la richiesta viene instradata attraverso l'infrastruttura GitHub verso l'endpoint dell'extension, che elabora la richiesta e restituisce una risposta.
Flusso di una Copilot Extension
| Step | Attore | Azione | Dettaglio |
|---|---|---|---|
| 1 | Utente | Invoca l'extension in chat | @extension-name come posso...? |
| 2 | GitHub | Autentica la richiesta | Verifica permessi utente e app |
| 3 | GitHub | Inoltra all'endpoint | HTTP POST al server dell'extension |
| 4 | Extension | Elabora la richiesta | Chiama API esterne, analizza dati |
| 5 | Extension | Genera risposta | Testo, codice, link, azioni |
| 6 | GitHub | Restituisce risposta | Formattata nella chat di Copilot |
Tipi di Extensions
GitHub distingue due tipologie principali di extensions, ciascuna con caratteristiche e complessità' di implementazione diverse.
Full Extensions (Agents)
- Applicazioni complete con logica server-side
- Possono chiamare API esterne
- Gestiscono stato e sessioni
- Supportano flussi complessi multi-step
- Richiedono infrastruttura di hosting propria
- Maggiore flessibilità' e potenza
- Tempo di sviluppo: settimane/mesi
Skillsets (Lightweight)
- Estensioni leggere e task-specific
- Definite tramite configurazione, poco codice
- Focus su una singola capacità'
- Veloci da costruire e deployare
- Nessuna infrastruttura complessa richiesta
- Ideali per automazioni semplici
- Tempo di sviluppo: ore/giorni
Skillsets: Estensioni Leggere
Gli skillsets sono il modo più' semplice per estendere Copilot con funzionalità' personalizzate. Sono ideali per task specifici e ripetitivi che non richiedono logica complessa. Uno skillset e' essenzialmente una definizione di tool che Copilot può' utilizzare per rispondere a richieste specifiche.
Struttura di uno Skillset
{
"name": "db-query-helper",
"description": "Helps developers write and optimize SQL queries for PostgreSQL",
"version": "1.0.0",
"skills": [
{
"name": "explain-query",
"description": "Analyze and explain a SQL query step by step",
"parameters": {
"query": {
"type": "string",
"description": "The SQL query to analyze"
},
"database": {
"type": "string",
"description": "Target database type",
"enum": ["postgresql", "mysql", "sqlite"],
"default": "postgresql"
}
}
},
{
"name": "optimize-query",
"description": "Suggest optimizations for a SQL query including index recommendations",
"parameters": {
"query": {
"type": "string",
"description": "The SQL query to optimize"
},
"table_info": {
"type": "string",
"description": "Table schemas and current indexes"
},
"expected_rows": {
"type": "number",
"description": "Expected number of rows in result"
}
}
},
{
"name": "generate-migration",
"description": "Generate a database migration script from a description",
"parameters": {
"description": {
"type": "string",
"description": "Description of schema changes"
},
"format": {
"type": "string",
"description": "Migration format",
"enum": ["flyway", "liquibase", "prisma", "raw-sql"],
"default": "flyway"
}
}
}
]
}Casi d'Uso per Skillsets
Skillsets Comuni per Team di Sviluppo
| Skillset | Funzione | Trigger | Output |
|---|---|---|---|
| Code Formatter | Formatta codice secondo standard aziendali | @formatter format this code | Codice formattato + diff |
| Regex Builder | Genera regex da descrizione naturale | @regex validate Italian fiscal code | Pattern regex + test cases |
| API Mock Generator | Genera mock data da schema OpenAPI | @mock generate 10 users | JSON con dati realistici |
| Changelog Writer | Genera changelog da commit history | @changelog since v2.1.0 | Markdown changelog formattato |
| Dependency Checker | Verifica dipendenze outdated e vulnerabili | @deps check this project | Report con versioni e CVE |
| i18n Helper | Genera traduzioni per chiavi mancanti | @i18n translate to Italian | File JSON/YAML con traduzioni |
GitHub Apps Integration
Le Copilot Extensions complete sono costruite come GitHub Apps. Questo significa che ereditano tutto il modello di sicurezza, autenticazione e autorizzazione delle GitHub Apps, garantendo un'integrazione sicura e controllabile.
Autenticazione e Autorizzazione
Modello di Sicurezza delle Extensions
| Livello | Meccanismo | Descrizione |
|---|---|---|
| App-level | JWT (JSON Web Token) | Identifica l'app stessa presso GitHub |
| Installation-level | Installation Access Token | Token specifico per l'installazione nell'org |
| User-level | OAuth User Access Token | Azioni per conto dell'utente specifico |
| Permissions | Granular permissions | Accesso solo alle risorse necessarie (repo, issues, PRs) |
| Webhooks | HMAC-SHA256 signature | Verifica autenticita' degli eventi ricevuti |
Permessi Richiesti
Ogni extension dichiara i permessi di cui ha bisogno. L'utente o l'admin dell'organizzazione deve approvarli esplicitamente prima dell'installazione. Il principio di minimo privilegio deve guidare la scelta dei permessi.
{
"name": "Copilot DB Assistant",
"description": "Database query helper for Copilot Chat",
"url": "https://db-assistant.example.com",
"hook_attributes": {
"url": "https://db-assistant.example.com/webhooks"
},
"redirect_url": "https://db-assistant.example.com/auth/callback",
"public": true,
"default_events": [
"issues",
"pull_request"
],
"default_permissions": {
"contents": "read",
"issues": "write",
"pull_requests": "read",
"metadata": "read"
},
"copilot_agent": {
"url": "https://db-assistant.example.com/copilot/agent",
"description": "Helps with database queries and migrations"
}
}Integrazione MCP nel Contesto delle Extensions
Il Model Context Protocol (MCP) e' un'alternativa complementare alle Copilot Extensions per collegare strumenti esterni a Copilot. Mentre le extensions seguono il modello GitHub Apps, MCP offre un protocollo standardizzato per la connessione di tool e fonti di dati.
GitHub MCP Registry
Il GitHub MCP Registry e' un servizio di discovery curato per server MCP. Funziona come un catalogo che permette di trovare e installare rapidamente server MCP verificati, riducendo il rischio di integrazioni non sicure.
Confronto: Extensions vs MCP Servers
| Aspetto | Copilot Extensions | MCP Servers |
|---|---|---|
| Piattaforma | GitHub Marketplace | MCP Registry + configurazione locale |
| Autenticazione | GitHub OAuth / App tokens | Varia (API key, OAuth, none) |
| Hosting | Server esterno (cloud) | Locale (stdio) o remoto (HTTP/SSE) |
| Complessità' setup | Media (GitHub App) | Bassa (config file) |
| Cross-platform | Tutti gli ambienti Copilot | Principalmente IDE (VS Code) |
| Governance | GitHub Marketplace review | Responsabilità' dell'utente/org |
| Caso d'uso | Integrazioni SaaS, workflow complessi | Tool locali, database, file system |
| Distribuzione | Pubblica (Marketplace) | Privata o pubblica (Registry) |
Toolsets: Raggruppare i Tool MCP
I toolsets sono un meccanismo per raggruppare tool MCP correlati sotto un unico namespace. Questo semplifica la gestione quando si hanno molti server MCP attivi contemporaneamente, permettendo di abilitare/disabilitare gruppi di tool con una singola operazione.
{
"servers": {
"development-tools": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@dev-tools/mcp-server"],
"toolsets": {
"database": {
"description": "Database management tools",
"tools": ["query", "migrate", "seed", "backup"]
},
"testing": {
"description": "Testing utilities",
"tools": ["generate-test", "run-test", "coverage-report"]
},
"documentation": {
"description": "Documentation generation",
"tools": ["generate-docs", "update-readme", "create-adr"]
}
}
},
"cloud-services": {
"type": "remote",
"url": "https://cloud-mcp.example.com/sse",
"toolsets": {
"aws": {
"description": "AWS service management",
"tools": ["s3-upload", "lambda-deploy", "cloudwatch-logs"]
},
"monitoring": {
"description": "Monitoring and alerting",
"tools": ["check-health", "get-metrics", "create-alert"]
}
}
}
}
}Third-Party Agents
Una delle evoluzioni più' significative dell'ecosistema Copilot e' l'integrazione di agenti di terze parti direttamente nella piattaforma. Questi agenti portano le capacità' di modelli AI alternativi all'interno dell'esperienza Copilot.
Agenti Disponibili
Third-Party Agents in Copilot
| Agente | Provider | Specializzazione | Disponibilità' | Modello |
|---|---|---|---|---|
| Claude | Anthropic | Analisi codice approfondita, refactoring, documentazione | Pro+ / Enterprise | Claude Sonnet 4 |
| Codex | OpenAI | Generazione codice, completamenti avanzati | Pro+ / Enterprise | Codex / o3-mini |
| Gemini | Comprensione multimodale, contesto lungo | Pro+ / Enterprise | Gemini 2.5 Pro |
Quando Usare Ciascun Agente
| Scenario | Agente Consigliato | Motivazione |
|---|---|---|
| Refactoring codebase legacy | Claude | Eccellente nell'analisi di codice complesso e nel proporre ristrutturazioni graduali |
| Generazione boilerplate rapida | Copilot nativo (GPT-4) | Ottimizzato per completamenti veloci e scaffolding |
| Analisi screenshot UI | Gemini | Comprensione multimodale per analizzare immagini di interfacce |
| Debugging algoritmico complesso | Codex / o3-mini | Forte nel ragionamento logico e nella risoluzione di problemi algoritmici |
| Documentazione tecnica dettagliata | Claude | Produce testo tecnico di alta qualità' con contesto lungo |
| Migrazione tra framework | Claude o Copilot nativo | Comprensione profonda dei pattern di diversi framework |
Nota sulla Disponibilità'
Gli agenti di terze parti sono attualmente in public preview e disponibili solo per i piani Pro+ e Enterprise. La disponibilità' e i modelli specifici possono variare nel tempo man mano che nuovi provider vengono integrati nella piattaforma.
L'utilizzo degli agenti di terze parti consuma premium requests dal proprio budget mensile. Richieste a modelli avanzati possono consumare più' premium requests rispetto a richieste al modello base di Copilot.
Costruire la Propria Copilot Extension
Se le estensioni disponibili sul Marketplace non coprono le esigenze specifiche del tuo team, puoi costruire la tua Copilot Extension. Il processo richiede la creazione di una GitHub App con un endpoint server che gestisca le richieste di Copilot.
Prerequisiti
Cosa Serve per Costruire un'Extension
- Account GitHub: Con accesso alla creazione di GitHub Apps
- Server web: Per ospitare l'endpoint dell'extension (Node.js, Python, Go, ecc.)
- Dominio HTTPS: L'endpoint deve essere accessibile via HTTPS
- Conoscenza delle GitHub Apps API: Per gestire autenticazione e webhook
- Copilot Extensions SDK: SDK ufficiale per semplificare lo sviluppo
Architettura di un'Extension
# Architettura di una Copilot Extension
GitHub Infrastructure
+-------------------+
| |
User in IDE ---> | Copilot Chat |
"@my-ext help" | (message router) |
| |
+--------+----------+
|
HTTP POST (authenticated)
|
+--------v----------+
| |
| Your Extension |
| Server |
| |
| +---------------+ |
| | Request | |
| | Handler | |
| +-------+-------+ |
| | |
| +-------v-------+ |
| | Business | |
| | Logic | |
| +-------+-------+ |
| | |
| +-------v-------+ |
| | External | |
| | Services | |
| | (DB, API, | |
| | tools) | |
| +---------------+ |
| |
+--------+----------+
|
HTTP Response (streaming)
|
+--------v----------+
| |
| Copilot Chat |
| (rendered to |
| user) |
| |
+-------------------+Implementazione Base con Node.js
import express from 'express';
import { Octokit } from '@octokit/rest';
import { createNodeMiddleware } from '@octokit/webhooks';
import { verifyRequestByKeyId } from '@copilot-extensions/preview-sdk';
const app = express();
app.use(express.json());
// Endpoint principale per Copilot Chat
app.post('/copilot/agent', async (req, res) => {
try {
// 1. Verifica autenticita' della richiesta
const signature = req.headers['github-public-key-signature'] as string;
const keyId = req.headers['github-public-key-identifier'] as string;
const body = JSON.stringify(req.body);
const isValid = await verifyRequestByKeyId(body, signature, keyId, {
token: process.env.GITHUB_TOKEN!
});
if (!isValid) {
return res.status(401).json({ error: 'Invalid signature' });
}
// 2. Estrai il messaggio dell'utente
const messages = req.body.messages;
const lastMessage = messages[messages.length - 1];
const userQuery = lastMessage.content;
// 3. Elabora la richiesta in base al contenuto
const response = await processQuery(userQuery, req.body);
// 4. Restituisci risposta in streaming (SSE format)
res.setHeader('Content-Type', 'text/event-stream');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('Connection', 'keep-alive');
// Invia la risposta come stream di eventi
res.write(`data: