duoops 0.2.8 → 0.2.12

package/dist/commands/mcp/deploy.js

@@ -6,7 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { configManager } from '../../lib/config.js';
-import { detectGcpProject, enableApis, ensureCloudBuildServiceAccount, getActiveAccount, requireGcloud, validateProjectAccess } from '../../lib/gcloud.js';
+import { detectGcpProject, enableApis, ensureBigQueryAccess, ensureCloudBuildServiceAccount, getActiveAccount, requireGcloud, validateProjectAccess } from '../../lib/gcloud.js';
 export default class McpDeploy extends Command {
     static description = 'Deploy the DuoOps MCP server to Google Cloud Run';
     static flags = {
@@ -75,6 +75,8 @@ export default class McpDeploy extends Command {
         }
         this.log(gray('\nConfiguring Cloud Build service account...'));
         ensureCloudBuildServiceAccount(gcpProject, (msg) => this.log(gray(msg)));
+        this.log(gray('\nConfiguring BigQuery access for MCP server...'));
+        ensureBigQueryAccess(gcpProject, (msg) => this.log(gray(msg)));
         const mcpServerDir = flags.source || path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../mcp-server');
         if (!fs.existsSync(path.join(mcpServerDir, 'Dockerfile'))) {
             this.error(`MCP server source not found at ${mcpServerDir}. Provide --source flag or run from the DuoOps repo.`);

package/dist/lib/gcloud.d.ts

@@ -4,4 +4,5 @@ export declare function detectGcpProject(): string | undefined;
 export declare function validateProjectAccess(project: string): void;
 export declare function enableApis(project: string, apis: string[], log: (msg: string) => void): void;
 export declare function getProjectNumber(project: string): string | undefined;
+export declare function ensureBigQueryAccess(project: string, log: (msg: string) => void): void;
 export declare function ensureCloudBuildServiceAccount(project: string, log: (msg: string) => void): void;

package/dist/lib/gcloud.js

@@ -75,6 +75,34 @@ export function getProjectNumber(project) {
         return undefined;
     }
 }
+export function ensureBigQueryAccess(project, log) {
+    const projectNumber = getProjectNumber(project);
+    if (!projectNumber) {
+        log('  ? Could not determine project number, skipping BigQuery permissions');
+        return;
+    }
+    const computeSa = `${projectNumber}-compute@developer.gserviceaccount.com`;
+    const roles = [
+        'roles/bigquery.user',
+        'roles/bigquery.dataViewer',
+    ];
+    log(`  Granting BigQuery permissions to ${computeSa}...`);
+    for (const role of roles) {
+        try {
+            execSync(`gcloud projects add-iam-policy-binding ${project} --member="serviceAccount:${computeSa}" --role="${role}" --quiet`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            log(`  ✓ ${role}`);
+        }
+        catch (error) {
+            const stderr = error.stderr || '';
+            if (stderr.includes('PERMISSION_DENIED')) {
+                log(`  ? ${role} — no permission to grant`);
+            }
+            else {
+                log(`  ? ${role} — failed: ${stderr.trim().split('\n')[0]}`);
+            }
+        }
+    }
+}
 export function ensureCloudBuildServiceAccount(project, log) {
     const projectNumber = getProjectNumber(project);
     if (!projectNumber) {

package/mcp-server/src/auth.ts

@@ -5,17 +5,25 @@ import {NextFunction, Request, Response} from 'express'
 export const GITLAB_URL = process.env.GITLAB_URL || 'https://gitlab.com'
 
 export async function validateGitLabToken(token: string): Promise<boolean> {
+  try {
+    const response = await axios.get(`${GITLAB_URL}/oauth/token/info`, {
+      headers: {Authorization: `Bearer ${token}`},
+      validateStatus: (status) => status < 500,
+    })
+
+    if (response.status === 200) return true
+  } catch {/* ignore */}
+
   try {
     const response = await axios.get(`${GITLAB_URL}/api/v4/user`, {
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
+      headers: {Authorization: `Bearer ${token}`},
+      validateStatus: (status) => status < 500,
     })
-    return response.status === 200
-  } catch (error) {
-    console.error('GitLab token validation failed:', error)
-    return false
-  }
+
+    if (response.status === 200) return true
+  } catch {/* ignore */}
+
+  return false
 }
 
 export function authMiddleware(req: Request, res: Response, next: NextFunction) {

package/mcp-server/src/index.ts

@@ -1,5 +1,6 @@
 import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js'
 import {SSEServerTransport} from '@modelcontextprotocol/sdk/server/sse.js'
+import {StreamableHTTPServerTransport} from '@modelcontextprotocol/sdk/server/streamableHttp.js'
 import express from 'express'
 
 import {authMiddleware, oauthEndpoints} from './auth.js'
@@ -12,11 +13,11 @@ async function main() {
     version: '1.0.0',
   })
 
-  // Register tools
   registerEmissionsTools(server)
   registerProfileTools(server)
 
   const app = express()
+  app.use(express.json())
 
   app.get('/health', (_req, res) => {
     res.json({service: 'duoops-mcp', status: 'ok', version: '1.0.0'})
@@ -24,30 +25,48 @@ async function main() {
 
   oauthEndpoints(app)
 
-  // MCP SSE Transport setup
-  let transport: SSEServerTransport
+  let sseTransport: SSEServerTransport
 
   app.get('/sse', authMiddleware, async (req, res) => {
-    transport = new SSEServerTransport('/message', res)
-    await server.connect(transport)
+    sseTransport = new SSEServerTransport('/message', res)
+    await server.connect(sseTransport)
   })
 
   app.post('/message', authMiddleware, async (req, res) => {
-    if (!transport) {
+    if (!sseTransport) {
       res.sendStatus(400)
       return
     }
 
-    await transport.handlePostMessage(req, res)
+    await sseTransport.handlePostMessage(req, res)
+  })
+
+  app.post('/mcp', authMiddleware, async (req, res) => {
+    const transport = new StreamableHTTPServerTransport({sessionIdGenerator: undefined})
+    res.on('close', () => {
+      transport.close()
+    })
+    await server.connect(transport)
+    await transport.handleRequest(req, res)
+  })
+
+  app.get('/mcp', authMiddleware, async (req, res) => {
+    const transport = new StreamableHTTPServerTransport({sessionIdGenerator: undefined})
+    res.on('close', () => {
+      transport.close()
+    })
+    await server.connect(transport)
+    await transport.handleRequest(req, res)
   })
 
-  // Legacy/Simple HTTP endpoint (optional, if SSE not supported by some clients)
-  // Currently we focus on SSE as per SDK standard for HTTP transport
+  app.delete('/mcp', async (_req, res) => {
+    res.status(405).send('Session termination not supported')
+  })
 
   const port = process.env.PORT || 8080
   app.listen(port, () => {
     console.log(`DuoOps MCP Server running on port ${port}`)
-    console.log(`OAuth discovery at /.well-known/oauth-protected-resource`)
+    console.log(`Transports: SSE at /sse, HTTP Streamable at /mcp`)
   })
 }
 

package/mcp-server/src/lib/bigquery.ts

@@ -23,18 +23,9 @@ export class BigQueryService {
 
   async getJobEmissions(jobId: number, projectId?: number): Promise<EmissionsRecord | null> {
     const query = `
-      SELECT
-        job_id,
-        pipeline_id,
-        gitlab_project_id as project_id,
-        machine_type,
-        region,
-        total_emissions,
-        (cpu_energy_kwh + ram_energy_kwh) as total_energy_kwh,
-        created_at,
-        runtime_seconds
+      SELECT *
       FROM \`${this.projectId}.${this.datasetId}.${this.tableId}\`
-      WHERE job_id = @jobId
+      WHERE gitlab_job_id = @jobId
       ${projectId ? 'AND gitlab_project_id = @projectId' : ''}
       LIMIT 1
     `
@@ -48,75 +39,61 @@ export class BigQueryService {
     return rows.length > 0 ? (rows[0] as EmissionsRecord) : null
   }
 
-  async getPipelineEmissions(pipelineId: number, projectId?: number): Promise<{
+  async getProjectEmissionsSummary(projectId: number, limit: number = 10): Promise<EmissionsRecord[]> {
+    const query = `
+      SELECT *
+      FROM \`${this.projectId}.${this.datasetId}.${this.tableId}\`
+      WHERE gitlab_project_id = @projectId
+      ORDER BY ingested_at DESC
+      LIMIT @limit
+    `
+
+    const options = {
+      params: {limit, projectId},
+      query,
+    }
+
+    const [rows] = await this.bigquery.query(options)
+    return rows as EmissionsRecord[]
+  }
+
+  async getProjectJobEmissions(projectId: number, limit: number = 20): Promise<{
     jobs: Partial<EmissionsRecord>[];
-    pipeline_id: number;
     total_emissions_g: number;
     total_energy_kwh: number;
   }> {
     const query = `
-      SELECT
-        job_id,
-        machine_type,
-        total_emissions,
-        (cpu_energy_kwh + ram_energy_kwh) as total_energy_kwh,
-        runtime_seconds
+      SELECT *
       FROM \`${this.projectId}.${this.datasetId}.${this.tableId}\`
-      WHERE pipeline_id = @pipelineId
-      ${projectId ? 'AND gitlab_project_id = @projectId' : ''}
+      WHERE gitlab_project_id = @projectId
+      ORDER BY ingested_at DESC
+      LIMIT @limit
     `
 
     const options = {
-      params: {pipelineId, projectId},
+      params: {limit, projectId},
       query,
     }
 
     const [rows] = await this.bigquery.query(options)
-    
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const totalEmissions = rows.reduce((sum: number, row: any) => sum + (row.total_emissions || 0), 0)
+    const totalEmissions = rows.reduce((sum: number, row: any) => sum + (row.total_emissions_g || 0), 0)
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const totalEnergy = rows.reduce((sum: number, row: any) => sum + (row.total_energy_kwh || 0), 0)
+    const totalEnergy = rows.reduce((sum: number, row: any) => sum + (row.energy_kwh || 0), 0)
 
     return {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       jobs: rows.map((r: any) => ({
-        job_id: r.job_id,
+        energy_kwh: r.energy_kwh,
+        gitlab_job_id: r.gitlab_job_id,
+        gitlab_job_name: r.gitlab_job_name,
         machine_type: r.machine_type,
         runtime_seconds: r.runtime_seconds,
-        total_emissions: r.total_emissions,
-        total_energy_kwh: r.total_energy_kwh
+        total_emissions_g: r.total_emissions_g,
       })),
-      pipeline_id: pipelineId,
       total_emissions_g: totalEmissions,
       total_energy_kwh: totalEnergy
     }
   }
-
-  async getProjectEmissionsSummary(projectId: number, limit: number = 10): Promise<EmissionsRecord[]> {
-    const query = `
-      SELECT
-        job_id,
-        pipeline_id,
-        gitlab_project_id as project_id,
-        machine_type,
-        region,
-        total_emissions,
-        (cpu_energy_kwh + ram_energy_kwh) as total_energy_kwh,
-        created_at,
-        runtime_seconds
-      FROM \`${this.projectId}.${this.datasetId}.${this.tableId}\`
-      WHERE gitlab_project_id = @projectId
-      ORDER BY created_at DESC
-      LIMIT @limit
-    `
-
-    const options = {
-      params: {limit, projectId},
-      query,
-    }
-
-    const [rows] = await this.bigquery.query(options)
-    return rows as EmissionsRecord[]
-  }
 }

package/mcp-server/src/lib/types.ts

@@ -54,13 +54,14 @@ export interface CarbonResult {
 }
 
 export interface EmissionsRecord {
-  created_at: string;
-  job_id: number;
+  energy_kwh: number;
+  gitlab_job_id: number;
+  gitlab_job_name: string;
+  gitlab_project_id: number;
+  gitlab_user_name: string;
+  ingested_at: string;
   machine_type: string;
-  pipeline_id: number;
-  project_id: number;
   region: string;
   runtime_seconds: number;
-  total_emissions: number;
-  total_energy_kwh: number;
+  total_emissions_g: number;
 }

package/mcp-server/src/tools/emissions.ts

@@ -15,7 +15,7 @@ export function registerEmissionsTools(server: McpServer) {
     },
     async ({job_id, project_id}) => {
       const emissions = await bq.getJobEmissions(job_id, project_id)
-      
+
       if (!emissions) {
         return {
           content: [{text: `No emissions data found for job ${job_id}`, type: 'text'}],
@@ -33,74 +33,76 @@ export function registerEmissionsTools(server: McpServer) {
   )
 
   server.tool(
-    'get_pipeline_emissions',
+    'get_project_emissions_summary',
     {
-      pipeline_id: z.number().describe('GitLab Pipeline ID'),
-      project_id: z.number().optional().describe('GitLab Project ID (optional filter)'),
+      limit: z.number().optional().default(10).describe('Number of recent jobs to return'),
+      project_id: z.number().describe('GitLab Project ID'),
     },
-    async ({pipeline_id, project_id}) => {
-      const result = await bq.getPipelineEmissions(pipeline_id, project_id)
-      
-      if (result.jobs.length === 0) {
+    async ({limit, project_id}) => {
+      const records = await bq.getProjectEmissionsSummary(project_id, limit)
+
+      if (records.length === 0) {
         return {
-          content: [{text: `No emissions data found for pipeline ${pipeline_id}`, type: 'text'}],
+          content: [{text: `No emissions history found for project ${project_id}. The measure CI component may not have run yet.`, type: 'text'}],
           isError: true,
         }
       }
 
+      const totalEmissions = records.reduce((sum, r) => sum + r.total_emissions_g, 0)
+      const avgEmissions = totalEmissions / records.length
+      const totalEnergy = records.reduce((sum, r) => sum + r.energy_kwh, 0)
+
       const summary = `
-Pipeline ${pipeline_id} Carbon Report:
-Total Emissions: ${result.total_emissions_g.toFixed(3)} gCO2e
-Total Energy: ${result.total_energy_kwh.toFixed(4)} kWh
-Jobs Recorded: ${result.jobs.length}
+Project ${project_id} Emissions Summary (Last ${records.length} jobs):
+Average per job: ${avgEmissions.toFixed(3)} gCO2e
+Total recent: ${totalEmissions.toFixed(3)} gCO2e
+Total energy: ${totalEnergy.toFixed(4)} kWh
 
-Top Emitters:
-${result.jobs
-  .sort((a, b) => (b.total_emissions || 0) - (a.total_emissions || 0))
-  .slice(0, 3)
-  .map(j => `- Job ${j.job_id} (${j.machine_type}): ${j.total_emissions?.toFixed(3)} gCO2e`)
-  .join('\n')}
+Recent Jobs:
+${records.map(r => `- ${r.ingested_at} | ${r.gitlab_job_name} (${r.machine_type}): ${r.total_emissions_g.toFixed(3)} gCO2e, ${r.energy_kwh.toFixed(4)} kWh, ${r.runtime_seconds.toFixed(0)}s`).join('\n')}
 `
 
       return {
-        content: [
-          {text: summary, type: 'text'},
-          {text: JSON.stringify(result, null, 2), type: 'text'} // Full JSON also provided
-        ]
+        content: [{text: summary, type: 'text'}]
       }
     }
   )
 
   server.tool(
-    'get_project_emissions_summary',
+    'get_project_job_emissions',
     {
-      limit: z.number().optional().default(10).describe('Number of recent jobs to return'),
+      limit: z.number().optional().default(20).describe('Number of recent jobs to return'),
       project_id: z.number().describe('GitLab Project ID'),
     },
     async ({limit, project_id}) => {
-      const records = await bq.getProjectEmissionsSummary(project_id, limit)
-      
-      if (records.length === 0) {
+      const result = await bq.getProjectJobEmissions(project_id, limit)
+
+      if (result.jobs.length === 0) {
         return {
-          content: [{text: `No emissions history found for project ${project_id}`, type: 'text'}],
+          content: [{text: `No emissions data found for project ${project_id}`, type: 'text'}],
           isError: true,
         }
       }
 
-      const totalEmissions = records.reduce((sum, r) => sum + r.total_emissions, 0)
-      const avgEmissions = totalEmissions / records.length
-
       const summary = `
-Project ${project_id} Emissions Summary (Last ${records.length} jobs):
-Average per job: ${avgEmissions.toFixed(3)} gCO2e
-Total recent: ${totalEmissions.toFixed(3)} gCO2e
+Project ${project_id} Carbon Report:
+Total Emissions: ${result.total_emissions_g.toFixed(3)} gCO2e
+Total Energy: ${result.total_energy_kwh.toFixed(4)} kWh
+Jobs Recorded: ${result.jobs.length}
 
-Recent Jobs:
-${records.map(r => `- ${r.created_at}: ${r.total_emissions.toFixed(3)} gCO2e (${r.machine_type})`).join('\n')}
+Top Emitters:
+${result.jobs
+  .sort((a, b) => (b.total_emissions_g || 0) - (a.total_emissions_g || 0))
+  .slice(0, 5)
+  .map(j => `- Job ${j.gitlab_job_id} ${j.gitlab_job_name} (${j.machine_type}): ${j.total_emissions_g?.toFixed(3)} gCO2e`)
+  .join('\n')}
 `
 
       return {
-        content: [{text: summary, type: 'text'}]
+        content: [
+          {text: summary, type: 'text'},
+          {text: JSON.stringify(result, null, 2), type: 'text'}
+        ]
       }
     }
   )

package/oclif.manifest.json

@@ -669,5 +669,5 @@
       ]
     }
   },
-  "version": "0.2.8"
+  "version": "0.2.12"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duoops",
   "description": "Toolset for Explainable and Sustainable CI on Gitlab.",
-  "version": "0.2.8",
+  "version": "0.2.12",
   "author": "Younes Laaroussi",
   "bin": {
     "duoops": "./bin/run.js"