18 - Copilot Extensions e Marketplace

{
  "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"
        }
      }
    }
  ]
}

{
  "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"
  }
}

{
  "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"]
        }
      }
    }
  }
}

# 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)            |
                    |                   |
                    +-------------------+

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: ${JSON.stringify({
      choices: [{
        index: 0,
        delta: {
          role: 'assistant',
          content: response
        }
      }]
    })}\n\n`);

    res.write('data: [DONE]\n\n');
    res.end();

  } catch (error) {
    console.error('Extension error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

async function processQuery(
  query: string,
  context: any
): Promise<string> {
  // Logica personalizzata dell'extension
  // Qui puoi chiamare database, API esterne, ecc.

  if (query.includes('status')) {
    return await getSystemStatus();
  }

  if (query.includes('deploy')) {
    return await getDeploymentInfo();
  }

  if (query.includes('metrics')) {
    return await getProjectMetrics();
  }

  return `Ciao! Sono l'extension personalizzata del team.
Posso aiutarti con:
- **status**: Stato attuale dei servizi
- **deploy**: Informazioni sull'ultimo deployment
- **metrics**: Metriche del progetto

Come posso aiutarti?`;
}

async function getSystemStatus(): Promise<string> {
  // Esempio: chiama un health check endpoint
  const services = ['api', 'database', 'cache', 'queue'];
  const results = await Promise.all(
    services.map(async (service) => {
      try {
        const response = await fetch(
          `https://monitoring.example.com/health/${service}`
        );
        const data = await response.json();
        return `- **${service}**: ${data.status} (uptime: ${data.uptime})`;
      } catch {
        return `- **${service}**: UNREACHABLE`;
      }
    })
  );

  return `## System Status\n\n${results.join('\n')}`;
}

async function getDeploymentInfo(): Promise<string> {
  // Esempio: informazioni dall'ultimo deploy
  return `## Last Deployment
- **Version**: v2.4.1
- **Environment**: production
- **Time**: 2 hours ago
- **Status**: Successful
- **Deployed by**: CI/CD Pipeline
- **Commit**: abc1234`;
}

async function getProjectMetrics(): Promise<string> {
  // Esempio: metriche dal sistema di monitoring
  return `## Project Metrics (Last 24h)
- **Requests**: 125,430
- **Error Rate**: 0.12%
- **p95 Latency**: 245ms
- **Active Users**: 3,421
- **CPU Usage**: 45%
- **Memory**: 62%`;
}

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Extension server running on port ${PORT}`);
});

import request from 'supertest';
import { app } from '../server';

describe('Copilot Extension', () => {
  describe('POST /copilot/agent', () => {
    it('should respond to status query', async () => {
      const response = await request(app)
        .post('/copilot/agent')
        .set('Content-Type', 'application/json')
        .send({
          messages: [
            {
              role: 'user',
              content: 'What is the current status?'
            }
          ]
        });

      expect(response.status).toBe(200);
      expect(response.headers['content-type']).toContain('text/event-stream');
    });

    it('should handle unknown queries gracefully', async () => {
      const response = await request(app)
        .post('/copilot/agent')
        .send({
          messages: [
            {
              role: 'user',
              content: 'random question'
            }
          ]
        });

      expect(response.status).toBe(200);
      // Should return help message
    });

    it('should reject unauthenticated requests', async () => {
      // Test without proper GitHub signature headers
      const response = await request(app)
        .post('/copilot/agent')
        .set('github-public-key-signature', 'invalid')
        .set('github-public-key-identifier', 'invalid')
        .send({
          messages: [{ role: 'user', content: 'test' }]
        });

      expect(response.status).toBe(401);
    });
  });
});